diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/big_batch_search.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/big_batch_search.py new file mode 100644 index 0000000000000000000000000000000000000000..14614d286d06c4f7af519e85113c6e330a539ca5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/big_batch_search.py @@ -0,0 +1,515 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import time +import pickle +import os +import logging +from multiprocessing.pool import ThreadPool +import threading +import _thread +from queue import Queue +import traceback +import datetime + +import numpy as np +import faiss + +from faiss.contrib.inspect_tools import get_invlist + + +class BigBatchSearcher: + """ + Object that manages all the data related to the computation + except the actual within-bucket matching and the organization of the + computation (parallel or not) + """ + + def __init__( + self, + index, xq, k, + verbose=0, + use_float16=False): + + # verbosity + self.verbose = verbose + self.tictoc = [] + + self.xq = xq + self.index = index + self.use_float16 = use_float16 + keep_max = faiss.is_similarity_metric(index.metric_type) + self.rh = faiss.ResultHeap(len(xq), k, keep_max=keep_max) + self.t_accu = [0] * 6 + self.t_display = self.t0 = time.time() + + def start_t_accu(self): + self.t_accu_t0 = time.time() + + def stop_t_accu(self, n): + self.t_accu[n] += time.time() - self.t_accu_t0 + + def tic(self, name): + self.tictoc = (name, time.time()) + if self.verbose > 0: + print(name, end="\r", flush=True) + + def toc(self): + name, t0 = self.tictoc + dt = time.time() - t0 + if self.verbose > 0: + print(f"{name}: {dt:.3f} s") + return dt + + def report(self, l): + if self.verbose == 1 or ( + self.verbose == 2 and ( + l > 1000 and time.time() < self.t_display + 1.0 + ) + ): + return + t = time.time() - self.t0 + print( + f"[{t:.1f} s] list {l}/{self.index.nlist} " + f"times prep q {self.t_accu[0]:.3f} prep b {self.t_accu[1]:.3f} " + f"comp {self.t_accu[2]:.3f} res {self.t_accu[3]:.3f} " + f"wait in {self.t_accu[4]:.3f} " + f"wait out {self.t_accu[5]:.3f} " + f"eta {datetime.timedelta(seconds=t*self.index.nlist/(l+1)-t)} " + f"mem {faiss.get_mem_usage_kb()}", + end="\r" if self.verbose <= 2 else "\n", + flush=True, + ) + self.t_display = time.time() + + def coarse_quantization(self): + self.tic("coarse quantization") + bs = 65536 + nq = len(self.xq) + q_assign = np.empty((nq, self.index.nprobe), dtype='int32') + for i0 in range(0, nq, bs): + i1 = min(nq, i0 + bs) + q_dis_i, q_assign_i = self.index.quantizer.search( + self.xq[i0:i1], self.index.nprobe) + # q_dis[i0:i1] = q_dis_i + q_assign[i0:i1] = q_assign_i + self.toc() + self.q_assign = q_assign + + def reorder_assign(self): + self.tic("bucket sort") + q_assign = self.q_assign + q_assign += 1 # move -1 -> 0 + self.bucket_lims = faiss.matrix_bucket_sort_inplace( + self.q_assign, nbucket=self.index.nlist + 1, nt=16) + self.query_ids = self.q_assign.ravel() + if self.verbose > 0: + print(' number of -1s:', self.bucket_lims[1]) + self.bucket_lims = self.bucket_lims[1:] # shift back to ignore -1s + del self.q_assign # inplace so let's forget about the old version... + self.toc() + + def prepare_bucket(self, l): + """ prepare the queries and database items for bucket l""" + t0 = time.time() + index = self.index + # prepare queries + i0, i1 = self.bucket_lims[l], self.bucket_lims[l + 1] + q_subset = self.query_ids[i0:i1] + xq_l = self.xq[q_subset] + if self.by_residual: + xq_l = xq_l - index.quantizer.reconstruct(l) + t1 = time.time() + # prepare database side + list_ids, xb_l = get_invlist(index.invlists, l) + + if self.decode_func is None: + xb_l = xb_l.ravel() + else: + xb_l = self.decode_func(xb_l) + + if self.use_float16: + xb_l = xb_l.astype('float16') + xq_l = xq_l.astype('float16') + + t2 = time.time() + self.t_accu[0] += t1 - t0 + self.t_accu[1] += t2 - t1 + return q_subset, xq_l, list_ids, xb_l + + def add_results_to_heap(self, q_subset, D, list_ids, I): + """add the bucket results to the heap structure""" + if D is None: + return + t0 = time.time() + if I is None: + I = list_ids + else: + I = list_ids[I] + self.rh.add_result_subset(q_subset, D, I) + self.t_accu[3] += time.time() - t0 + + def sizes_in_checkpoint(self): + return (self.xq.shape, self.index.nprobe, self.index.nlist) + + def write_checkpoint(self, fname, completed): + # write to temp file then move to final file + tmpname = fname + ".tmp" + with open(tmpname, "wb") as f: + pickle.dump( + { + "sizes": self.sizes_in_checkpoint(), + "completed": completed, + "rh": (self.rh.D, self.rh.I), + }, f, -1) + os.replace(tmpname, fname) + + def read_checkpoint(self, fname): + with open(fname, "rb") as f: + ckp = pickle.load(f) + assert ckp["sizes"] == self.sizes_in_checkpoint() + self.rh.D[:] = ckp["rh"][0] + self.rh.I[:] = ckp["rh"][1] + return ckp["completed"] + + +class BlockComputer: + """ computation within one bucket """ + + def __init__( + self, + index, + method="knn_function", + pairwise_distances=faiss.pairwise_distances, + knn=faiss.knn): + + self.index = index + if index.__class__ == faiss.IndexIVFFlat: + index_help = faiss.IndexFlat(index.d, index.metric_type) + decode_func = lambda x: x.view("float32") + by_residual = False + elif index.__class__ == faiss.IndexIVFPQ: + index_help = faiss.IndexPQ( + index.d, index.pq.M, index.pq.nbits, index.metric_type) + index_help.pq = index.pq + decode_func = index_help.pq.decode + index_help.is_trained = True + by_residual = index.by_residual + elif index.__class__ == faiss.IndexIVFScalarQuantizer: + index_help = faiss.IndexScalarQuantizer( + index.d, index.sq.qtype, index.metric_type) + index_help.sq = index.sq + decode_func = index_help.sq.decode + index_help.is_trained = True + by_residual = index.by_residual + else: + raise RuntimeError(f"index type {index.__class__} not supported") + self.index_help = index_help + self.decode_func = None if method == "index" else decode_func + self.by_residual = by_residual + self.method = method + self.pairwise_distances = pairwise_distances + self.knn = knn + + def block_search(self, xq_l, xb_l, list_ids, k, **extra_args): + metric_type = self.index.metric_type + if xq_l.size == 0 or xb_l.size == 0: + D = I = None + elif self.method == "index": + faiss.copy_array_to_vector(xb_l, self.index_help.codes) + self.index_help.ntotal = len(list_ids) + D, I = self.index_help.search(xq_l, k) + elif self.method == "pairwise_distances": + # TODO implement blockwise to avoid mem blowup + D = self.pairwise_distances(xq_l, xb_l, metric=metric_type) + I = None + elif self.method == "knn_function": + D, I = self.knn(xq_l, xb_l, k, metric=metric_type, **extra_args) + + return D, I + + +def big_batch_search( + index, xq, k, + method="knn_function", + pairwise_distances=faiss.pairwise_distances, + knn=faiss.knn, + verbose=0, + threaded=0, + use_float16=False, + prefetch_threads=1, + computation_threads=1, + q_assign=None, + checkpoint=None, + checkpoint_freq=7200, + start_list=0, + end_list=None, + crash_at=-1 + ): + """ + Search queries xq in the IVF index, with a search function that collects + batches of query vectors per inverted list. This can be faster than the + regular search indexes. + Supports IVFFlat, IVFPQ and IVFScalarQuantizer. + + Supports three computation methods: + method = "index": + build a flat index and populate it separately for each index + method = "pairwise_distances": + decompress codes and compute all pairwise distances for the queries + and index and add result to heap + method = "knn_function": + decompress codes and compute knn results for the queries + + threaded=0: sequential execution + threaded=1: prefetch next bucket while computing the current one + threaded=2: prefetch prefetch_threads buckets at a time. + + compute_threads>1: the knn function will get an additional thread_no that + tells which worker should handle this. + + In threaded mode, the computation is tiled with the bucket preparation and + the writeback of results (useful to maximize GPU utilization). + + use_float16: convert all matrices to float16 (faster for GPU gemm) + + q_assign: override coarse assignment, should be a matrix of size nq * nprobe + + checkpointing (only for threaded > 1): + checkpoint: file where the checkpoints are stored + checkpoint_freq: when to perform checkpointing. Should be a multiple of threaded + + start_list, end_list: process only a subset of invlists + """ + nprobe = index.nprobe + + assert method in ("index", "pairwise_distances", "knn_function") + + mem_queries = xq.nbytes + mem_assign = len(xq) * nprobe * np.dtype('int32').itemsize + mem_res = len(xq) * k * ( + np.dtype('int64').itemsize + + np.dtype('float32').itemsize + ) + mem_tot = mem_queries + mem_assign + mem_res + if verbose > 0: + logging.info( + f"memory: queries {mem_queries} assign {mem_assign} " + f"result {mem_res} total {mem_tot} = {mem_tot / (1<<30):.3f} GiB" + ) + + bbs = BigBatchSearcher( + index, xq, k, + verbose=verbose, + use_float16=use_float16 + ) + + comp = BlockComputer( + index, + method=method, + pairwise_distances=pairwise_distances, + knn=knn + ) + + bbs.decode_func = comp.decode_func + + bbs.by_residual = comp.by_residual + if q_assign is None: + bbs.coarse_quantization() + else: + bbs.q_assign = q_assign + bbs.reorder_assign() + + if end_list is None: + end_list = index.nlist + + completed = set() + if checkpoint is not None: + assert (start_list, end_list) == (0, index.nlist) + if os.path.exists(checkpoint): + logging.info(f"recovering checkpoint: {checkpoint}") + completed = bbs.read_checkpoint(checkpoint) + logging.info(f" already completed: {len(completed)}") + else: + logging.info("no checkpoint: starting from scratch") + + if threaded == 0: + # simple sequential version + + for l in range(start_list, end_list): + bbs.report(l) + q_subset, xq_l, list_ids, xb_l = bbs.prepare_bucket(l) + t0i = time.time() + D, I = comp.block_search(xq_l, xb_l, list_ids, k) + bbs.t_accu[2] += time.time() - t0i + bbs.add_results_to_heap(q_subset, D, list_ids, I) + + elif threaded == 1: + + # parallel version with granularity 1 + + def add_results_and_prefetch(to_add, l): + """ perform the addition for the previous bucket and + prefetch the next (if applicable) """ + if to_add is not None: + bbs.add_results_to_heap(*to_add) + if l < index.nlist: + return bbs.prepare_bucket(l) + + prefetched_bucket = bbs.prepare_bucket(start_list) + to_add = None + pool = ThreadPool(1) + + for l in range(start_list, end_list): + bbs.report(l) + prefetched_bucket_a = pool.apply_async( + add_results_and_prefetch, (to_add, l + 1)) + q_subset, xq_l, list_ids, xb_l = prefetched_bucket + bbs.start_t_accu() + D, I = comp.block_search(xq_l, xb_l, list_ids, k) + bbs.stop_t_accu(2) + to_add = q_subset, D, list_ids, I + bbs.start_t_accu() + prefetched_bucket = prefetched_bucket_a.get() + bbs.stop_t_accu(4) + + bbs.add_results_to_heap(*to_add) + pool.close() + else: + + def task_manager_thread( + task, + pool_size, + start_task, + end_task, + completed, + output_queue, + input_queue, + ): + try: + with ThreadPool(pool_size) as pool: + res = [pool.apply_async( + task, + args=(i, output_queue, input_queue)) + for i in range(start_task, end_task) + if i not in completed] + for r in res: + r.get() + pool.close() + pool.join() + output_queue.put(None) + except: + traceback.print_exc() + _thread.interrupt_main() + raise + + def task_manager(*args): + task_manager = threading.Thread( + target=task_manager_thread, + args=args, + ) + task_manager.daemon = True + task_manager.start() + return task_manager + + def prepare_task(task_id, output_queue, input_queue=None): + try: + logging.info(f"Prepare start: {task_id}") + q_subset, xq_l, list_ids, xb_l = bbs.prepare_bucket(task_id) + output_queue.put((task_id, q_subset, xq_l, list_ids, xb_l)) + logging.info(f"Prepare end: {task_id}") + except: + traceback.print_exc() + _thread.interrupt_main() + raise + + def compute_task(task_id, output_queue, input_queue): + try: + logging.info(f"Compute start: {task_id}") + t_wait_out = 0 + while True: + t0 = time.time() + logging.info(f'Compute input: task {task_id}') + input_value = input_queue.get() + t_wait_in = time.time() - t0 + if input_value is None: + # signal for other compute tasks + input_queue.put(None) + break + centroid, q_subset, xq_l, list_ids, xb_l = input_value + logging.info(f'Compute work: task {task_id}, centroid {centroid}') + t0 = time.time() + if computation_threads > 1: + D, I = comp.block_search( + xq_l, xb_l, list_ids, k, thread_id=task_id + ) + else: + D, I = comp.block_search(xq_l, xb_l, list_ids, k) + t_compute = time.time() - t0 + logging.info(f'Compute output: task {task_id}, centroid {centroid}') + t0 = time.time() + output_queue.put( + (centroid, t_wait_in, t_wait_out, t_compute, q_subset, D, list_ids, I) + ) + t_wait_out = time.time() - t0 + logging.info(f"Compute end: {task_id}") + except: + traceback.print_exc() + _thread.interrupt_main() + raise + + prepare_to_compute_queue = Queue(2) + compute_to_main_queue = Queue(2) + compute_task_manager = task_manager( + compute_task, + computation_threads, + 0, + computation_threads, + set(), + compute_to_main_queue, + prepare_to_compute_queue, + ) + prepare_task_manager = task_manager( + prepare_task, + prefetch_threads, + start_list, + end_list, + completed, + prepare_to_compute_queue, + None, + ) + + t_checkpoint = time.time() + while True: + logging.info("Waiting for result") + value = compute_to_main_queue.get() + if not value: + break + centroid, t_wait_in, t_wait_out, t_compute, q_subset, D, list_ids, I = value + # to test checkpointing + if centroid == crash_at: + 1 / 0 + bbs.t_accu[2] += t_compute + bbs.t_accu[4] += t_wait_in + bbs.t_accu[5] += t_wait_out + logging.info(f"Adding to heap start: centroid {centroid}") + bbs.add_results_to_heap(q_subset, D, list_ids, I) + logging.info(f"Adding to heap end: centroid {centroid}") + completed.add(centroid) + bbs.report(centroid) + if checkpoint is not None: + if time.time() - t_checkpoint > checkpoint_freq: + logging.info("writing checkpoint") + bbs.write_checkpoint(checkpoint, completed) + t_checkpoint = time.time() + + prepare_task_manager.join() + compute_task_manager.join() + + bbs.tic("finalize heap") + bbs.rh.finalize() + bbs.toc() + + return bbs.rh.D, bbs.rh.I diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/client_server.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/client_server.py new file mode 100644 index 0000000000000000000000000000000000000000..f88f21cf9bb68ab25e29a0763f4103755006ff45 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/client_server.py @@ -0,0 +1,91 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from multiprocessing.pool import ThreadPool +import faiss +from typing import List, Tuple + +from . import rpc + +############################################################ +# Server implementation +############################################################ + + +class SearchServer(rpc.Server): + """ Assign version that can be exposed via RPC """ + + def __init__(self, s: int, index: faiss.Index): + rpc.Server.__init__(self, s) + self.index = index + self.index_ivf = faiss.extract_index_ivf(index) + + def set_nprobe(self, nprobe: int) -> int: + """ set nprobe field """ + self.index_ivf.nprobe = nprobe + + def get_ntotal(self) -> int: + return self.index.ntotal + + def __getattr__(self, f): + # all other functions get forwarded to the index + return getattr(self.index, f) + + +def run_index_server(index: faiss.Index, port: int, v6: bool = False): + """ serve requests for that index forever """ + rpc.run_server( + lambda s: SearchServer(s, index), + port, v6=v6) + + +############################################################ +# Client implementation +############################################################ + +class ClientIndex: + """manages a set of distance sub-indexes. The sub_indexes search a + subset of the inverted lists. Searches are merged afterwards + """ + + def __init__(self, machine_ports: List[Tuple[str, int]], v6: bool = False): + """ connect to a series of (host, port) pairs """ + self.sub_indexes = [] + for machine, port in machine_ports: + self.sub_indexes.append(rpc.Client(machine, port, v6)) + + self.ni = len(self.sub_indexes) + # pool of threads. Each thread manages one sub-index. + self.pool = ThreadPool(self.ni) + # test connection... + self.ntotal = self.get_ntotal() + self.verbose = False + + def set_nprobe(self, nprobe: int) -> None: + self.pool.map( + lambda idx: idx.set_nprobe(nprobe), + self.sub_indexes + ) + + def set_omp_num_threads(self, nt: int) -> None: + self.pool.map( + lambda idx: idx.set_omp_num_threads(nt), + self.sub_indexes + ) + + def get_ntotal(self) -> None: + return sum(self.pool.map( + lambda idx: idx.get_ntotal(), + self.sub_indexes + )) + + def search(self, x, k: int): + + rh = faiss.ResultHeap(x.shape[0], k) + + for Di, Ii in self.pool.imap(lambda idx: idx.search(x, k), self.sub_indexes): + rh.add_result(Di, Ii) + rh.finalize() + return rh.D, rh.I diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/clustering.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/clustering.py new file mode 100644 index 0000000000000000000000000000000000000000..00bc4f08b4478bb09db07abdfde5f6c95c068a72 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/clustering.py @@ -0,0 +1,502 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +This contrib module contains a few routines useful to do clustering variants. +""" + +import numpy as np +import faiss +import time +from multiprocessing.pool import ThreadPool + + +try: + import scipy.sparse +except ImportError: + print("scipy not accessible, Python k-means will not work") + + +def print_nop(*arg, **kwargs): + pass + + +def two_level_clustering(xt, nc1, nc2, rebalance=True, clustering_niter=25, **args): + """ + perform 2-level clustering on a training set xt + nc1 and nc2 are the number of clusters at each level, the final number of + clusters is nc2. Additional arguments are passed to the Kmeans object. + + Rebalance allocates the number of sub-clusters depending on the number of + first-level assignment. + """ + d = xt.shape[1] + + verbose = args.get("verbose", False) + + log = print if verbose else print_nop + + log(f"2-level clustering of {xt.shape} nb 1st level clusters = {nc1} total {nc2}") + log("perform coarse training") + + km = faiss.Kmeans( + d, nc1, niter=clustering_niter, + max_points_per_centroid=2000, + **args + ) + km.train(xt) + + iteration_stats = [km.iteration_stats] + log() + + # coarse centroids + centroids1 = km.centroids + + log("assigning the training set") + t0 = time.time() + _, assign1 = km.assign(xt) + bc = np.bincount(assign1, minlength=nc1) + log(f"done in {time.time() - t0:.2f} s. Sizes of clusters {min(bc)}-{max(bc)}") + o = assign1.argsort() + del km + + if not rebalance: + # make sure the sub-clusters sum up to exactly nc2 + cc = np.arange(nc1 + 1) * nc2 // nc1 + all_nc2 = cc[1:] - cc[:-1] + else: + bc_sum = np.cumsum(bc) + all_nc2 = bc_sum * nc2 // bc_sum[-1] + all_nc2[1:] -= all_nc2[:-1] + assert sum(all_nc2) == nc2 + log(f"nb 2nd-level centroids {min(all_nc2)}-{max(all_nc2)}") + + # train sub-clusters + i0 = 0 + c2 = [] + t0 = time.time() + for c1 in range(nc1): + nc2 = int(all_nc2[c1]) + log(f"[{time.time() - t0:.2f} s] training sub-cluster {c1}/{nc1} nc2={nc2}\r", end="", flush=True) + i1 = i0 + bc[c1] + subset = o[i0:i1] + assert np.all(assign1[subset] == c1) + km = faiss.Kmeans(d, nc2, **args) + xtsub = xt[subset] + km.train(xtsub) + iteration_stats.append(km.iteration_stats) + c2.append(km.centroids) + del km + i0 = i1 + log(f"done in {time.time() - t0:.2f} s") + return np.vstack(c2), iteration_stats + + +def train_ivf_index_with_2level(index, xt, **args): + """ + Applies 2-level clustering to an index_ivf embedded in an index. + """ + # handle PreTransforms + index = faiss.downcast_index(index) + if isinstance(index, faiss.IndexPreTransform): + for i in range(index.chain.size()): + vt = index.chain.at(i) + vt.train(xt) + xt = vt.apply(xt) + train_ivf_index_with_2level(index.index, xt, **args) + index.is_trained = True + return + assert isinstance(index, faiss.IndexIVF) + assert index.metric_type == faiss.METRIC_L2 + # now do 2-level clustering + nc1 = int(np.sqrt(index.nlist)) + print("REBALANCE=", args) + + centroids, _ = two_level_clustering(xt, nc1, index.nlist, **args) + index.quantizer.train(centroids) + index.quantizer.add(centroids) + # finish training + index.train(xt) + + +def balanced_assignment_with_penalties(x, centroids, alpha = 0.03, num_iter = 20, maxk = 100): + """ + Assign vectors x to centroids with a balance constraint. + + Iteratively adjusts per-cluster penalties so that oversized clusters + become less attractive. At each iteration the penalized distance for + cluster c is ``d(x, c)^2 + penalty_c^2`` and the penalty is updated as + ``penalty_c *= (binsize_c / n_opt) ** alpha`` where ``n_opt = n / nc``. + + A single kNN call (with *maxk* neighbors) is done upfront; subsequent + iterations only re-weight among those candidates, making the routine + fast even for large datasets. + + Reference: "Balancing clusters to reduce response time variability in + large scale image search", Tavenard et al., CBMI 2011. + https://inria.hal.science/inria-00576886/document + See also notebook N10159950. + + Args: + x: (n, d) float32 array of vectors to assign. + centroids: (nc, d) float32 array of cluster centroids. + alpha: exponent that controls how aggressively penalties grow. + Higher values yield more balanced clusters at the cost + of higher MSE. Typical range: 0.01 – 0.1. + num_iter: number of penalty-update iterations. + maxk: number of nearest centroids to consider per vector. + Must be <= nc. + + Returns: + assign: (n,) int64 array of centroid indices. + stats: dict with keys + + - *imf*: imbalance factor (1.0 = perfectly balanced) + - *mse*: mean squared error of the assignment + - *binsize_min*, *binsize_max*: smallest / largest cluster + - *penalty_min*, *penalty_max*: penalty value range + - *alpha*: the alpha value used + """ + + nc = len(centroids) + n = len(x) + nopt = n / nc # targed bin sizes + + # we assign to the top-maxk clusters. The final assignment will pick among these clusters. + full_d2, full_assign = faiss.knn(x, centroids, maxk) + + # scalar penalty for each cluster + penalties = np.ones(nc, dtype=np.float32) + + for it in range(num_iter): + # compute penalized assignment + penalties2 = penalties ** 2 + full_d2_penalized = full_d2 + penalties2[full_assign] + a0 = full_d2_penalized.argmin(axis=1) + assign = np.take_along_axis(full_assign, a0[:, None], axis=1).ravel() + binsizes = np.bincount(assign, minlength=nc) + # print(imbalance_factor(nc, assign), mse, int(binsizes.min()), int(binsizes.max())) + penalties *= (binsizes / nopt) ** alpha + + stats = dict( + alpha=alpha, + imf=imbalance_factor(nc, assign), + mse = ((x - centroids[assign]) ** 2).sum(1).mean(), # recompute MSE + binsize_min=int(binsizes.min()), + binsize_max=int(binsizes.max()), + penalty_min=penalties.min(), + penalty_max=penalties.max(), + ) + + return assign, stats + + +############################################################################### +# K-means implementation in Python +# +# It relies on DatasetAssign, an abstraction of the training vectors that offers +# the minimal set of operations to perform k-means clustering. +############################################################################### + + +class DatasetAssign: + """Wrapper for a matrix that offers a function to assign the vectors + to centroids. All other implementations offer the same interface""" + + def __init__(self, x): + self.x = np.ascontiguousarray(x, dtype='float32') + + def count(self): + return self.x.shape[0] + + def dim(self): + return self.x.shape[1] + + def get_subset(self, indices): + return self.x[indices] + + def perform_search(self, centroids): + return faiss.knn(self.x, centroids, 1) + + def assign_to(self, centroids, weights=None): + D, I = self.perform_search(centroids) + + I = I.ravel() + D = D.ravel() + nc, d = centroids.shape + sum_per_centroid = np.zeros((nc, d), dtype='float32') + if weights is None: + np.add.at(sum_per_centroid, I, self.x) + else: + np.add.at(sum_per_centroid, I, weights[:, np.newaxis] * self.x) + + return I, D, sum_per_centroid + + +class DatasetAssignGPU(DatasetAssign): + """ GPU version of the previous """ + + def __init__(self, x, gpu_id, verbose=False): + DatasetAssign.__init__(self, x) + index = faiss.IndexFlatL2(x.shape[1]) + if gpu_id >= 0: + self.index = faiss.index_cpu_to_gpu( + faiss.StandardGpuResources(), + gpu_id, index) + else: + # -1 -> assign to all GPUs + self.index = faiss.index_cpu_to_all_gpus(index) + + def perform_search(self, centroids): + self.index.reset() + self.index.add(centroids) + return self.index.search(self.x, 1) + + +def sparse_assign_to_dense(xq, xb, xq_norms=None, xb_norms=None): + """ assignment function for xq is sparse, xb is dense + uses a matrix multiplication. The squared norms can be provided if + available. + """ + nq = xq.shape[0] + nb = xb.shape[0] + if xb_norms is None: + xb_norms = (xb ** 2).sum(1) + if xq_norms is None: + xq_norms = np.array(xq.power(2).sum(1)) + d2 = xb_norms - 2 * xq @ xb.T + I = d2.argmin(axis=1) + D = d2.ravel()[I + np.arange(nq) * nb] + xq_norms.ravel() + return D, I + + +def sparse_assign_to_dense_blocks( + xq, xb, xq_norms=None, xb_norms=None, qbs=16384, bbs=16384, nt=None): + """ + decomposes the sparse_assign_to_dense function into blocks to avoid a + possible memory blow up. Can be run in multithreaded mode, because scipy's + sparse-dense matrix multiplication is single-threaded. + """ + nq = xq.shape[0] + nb = xb.shape[0] + D = np.empty(nq, dtype="float32") + D.fill(np.inf) + I = -np.ones(nq, dtype=int) + + if xb_norms is None: + xb_norms = (xb ** 2).sum(1) + + def handle_query_block(i): + xq_block = xq[i : i + qbs] + Iblock = I[i : i + qbs] + Dblock = D[i : i + qbs] + if xq_norms is None: + xq_norms_block = np.array(xq_block.power(2).sum(1)) + else: + xq_norms_block = xq_norms[i : i + qbs] + for j in range(0, nb, bbs): + Di, Ii = sparse_assign_to_dense( + xq_block, + xb[j : j + bbs], + xq_norms=xq_norms_block, + xb_norms=xb_norms[j : j + bbs], + ) + if j == 0: + Iblock[:] = Ii + Dblock[:] = Di + else: + mask = Di < Dblock + Iblock[mask] = Ii[mask] + j + Dblock[mask] = Di[mask] + + if nt == 0 or nt == 1 or nq <= qbs: + list(map(handle_query_block, range(0, nq, qbs))) + else: + pool = ThreadPool(nt) + pool.map(handle_query_block, range(0, nq, qbs)) + + return D, I + + +class DatasetAssignSparse(DatasetAssign): + """Wrapper for a matrix that offers a function to assign the vectors + to centroids. All other implementations offer the same interface""" + + def __init__(self, x): + assert x.__class__ == scipy.sparse.csr_matrix + self.x = x + self.squared_norms = np.array(x.power(2).sum(1)) + + def get_subset(self, indices): + return np.array(self.x[indices].todense()) + + def perform_search(self, centroids): + return sparse_assign_to_dense_blocks( + self.x, centroids, xq_norms=self.squared_norms) + + def assign_to(self, centroids, weights=None): + D, I = self.perform_search(centroids) + + I = I.ravel() + D = D.ravel() + n = self.x.shape[0] + if weights is None: + weights = np.ones(n, dtype='float32') + nc = len(centroids) + + m = scipy.sparse.csc_matrix( + (weights, I, np.arange(n + 1)), + shape=(nc, n)) + sum_per_centroid = np.array((m * self.x).todense()) + + return I, D, sum_per_centroid + + +def imbalance_factor(k, assign): + assign = np.ascontiguousarray(assign, dtype='int64') + return faiss.imbalance_factor(len(assign), k, faiss.swig_ptr(assign)) + + +def check_if_torch(x): + if x.__class__ == np.ndarray: + return False + import torch + if isinstance(x, torch.Tensor): + return True + raise NotImplementedError(f"Unknown tensor type {type(x)}") + + +def reassign_centroids(hassign, centroids, rs=None): + """ reassign centroids when some of them collapse """ + if rs is None: + rs = np.random + k, d = centroids.shape + nsplit = 0 + is_torch = check_if_torch(centroids) + + empty_cents = np.where(hassign == 0)[0] + + if len(empty_cents) == 0: + return 0 + + if is_torch: + import torch + fac = torch.ones_like(centroids[0]) + else: + fac = np.ones_like(centroids[0]) + fac[::2] += 1 / 1024. + fac[1::2] -= 1 / 1024. + + # this is a single pass unless there are more than k/2 + # empty centroids + while len(empty_cents) > 0: + # choose which centroids to split (numpy) + probas = hassign.astype('float') - 1 + probas[probas < 0] = 0 + probas /= probas.sum() + nnz = (probas > 0).sum() + + nreplace = min(nnz, empty_cents.size) + cjs = rs.choice(k, size=nreplace, p=probas) + + for ci, cj in zip(empty_cents[:nreplace], cjs): + + c = centroids[cj] + centroids[ci] = c * fac + centroids[cj] = c / fac + + hassign[ci] = hassign[cj] // 2 + hassign[cj] -= hassign[ci] + nsplit += 1 + + empty_cents = empty_cents[nreplace:] + + return nsplit + + + +def kmeans(k, data, niter=25, seed=1234, checkpoint=None, verbose=True, + return_stats=False): + """Pure python kmeans implementation. Follows the Faiss C++ version + quite closely, but takes a DatasetAssign instead of a training data + matrix. Also redo is not implemented. + + For the torch implementation, the centroids are tensors (possibly on GPU), + but the indices remain numpy on CPU. + """ + n, d = data.count(), data.dim() + log = print if verbose else print_nop + + log(("Clustering %d points in %dD to %d clusters, " + + "%d iterations seed %d") % (n, d, k, niter, seed)) + + rs = np.random.RandomState(seed) + print("preproc...") + t0 = time.time() + # initialization + perm = rs.choice(n, size=k, replace=False) + centroids = data.get_subset(perm) + is_torch = check_if_torch(centroids) + + iteration_stats = [] + + log(" done") + t_search_tot = 0 + obj = [] + for i in range(niter): + t0s = time.time() + + log('assigning', end='\r', flush=True) + assign, D, sums = data.assign_to(centroids) + + log('compute centroids', end='\r', flush=True) + + t_search_tot += time.time() - t0s + + err = D.sum() + if is_torch: + err = err.item() + obj.append(err) + + hassign = np.bincount(assign, minlength=k) + + fac = hassign.reshape(-1, 1).astype('float32') + fac[fac == 0] = 1 # quiet warning + if is_torch: + import torch + fac = torch.from_numpy(fac).to(sums.device) + + centroids = sums / fac + + nsplit = reassign_centroids(hassign, centroids, rs) + + s = { + "obj": err, + "time": (time.time() - t0), + "time_search": t_search_tot, + "imbalance_factor": imbalance_factor(k, assign), + "nsplit": nsplit + } + + log((" Iteration %d (%.2f s, search %.2f s): " + "objective=%g imbalance=%.3f nsplit=%d") % ( + i, s["time"], s["time_search"], + err, s["imbalance_factor"], + nsplit) + ) + iteration_stats.append(s) + + if checkpoint is not None: + log('storing centroids in', checkpoint) + if is_torch: + import torch + torch.save(centroids, checkpoint) + else: + np.save(checkpoint, centroids) + + if return_stats: + return centroids, iteration_stats + else: + return centroids diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/datasets.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/datasets.py new file mode 100644 index 0000000000000000000000000000000000000000..6facf7299d75b5c19c0ce680f4d9f4edde7c7b50 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/datasets.py @@ -0,0 +1,465 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +import numpy as np +import faiss +import getpass + + +from .vecs_io import fvecs_read, ivecs_read, bvecs_mmap, fvecs_mmap, bvecs_iter, bvecs_iter_chunked +from .exhaustive_search import knn + + +class Dataset: + """ Generic abstract class for a test dataset """ + + def __init__(self): + """ the constructor should set the following fields: """ + self.d = -1 + self.metric = 'L2' # or IP + self.nq = -1 + self.nb = -1 + self.nt = -1 + + def get_queries(self): + """ return the queries as a (nq, d) array """ + raise NotImplementedError() + + def get_train(self, maxtrain=None): + """ return the queries as a (nt, d) array """ + raise NotImplementedError() + + def get_database(self): + """ return the queries as a (nb, d) array """ + raise NotImplementedError() + + def database_iterator(self, bs=128, split=(1, 0)): + """returns an iterator on database vectors. + bs is the number of vectors per batch + split = (nsplit, rank) means the dataset is split in nsplit + shards and we want shard number rank + The default implementation just iterates over the full matrix + returned by get_dataset. + """ + xb = self.get_database() + nsplit, rank = split + i0, i1 = self.nb * rank // nsplit, self.nb * (rank + 1) // nsplit + for j0 in range(i0, i1, bs): + yield xb[j0: min(j0 + bs, i1)] + + def get_groundtruth(self, k=None): + """ return the ground truth for k-nearest neighbor search """ + raise NotImplementedError() + + def get_groundtruth_range(self, thresh=None): + """ return the ground truth for range search """ + raise NotImplementedError() + + def __str__(self): + return (f"dataset in dimension {self.d}, with metric {self.metric}, " + f"size: Q {self.nq} B {self.nb} T {self.nt}") + + def check_sizes(self): + """ runs the previous and checks the sizes of the matrices """ + assert self.get_queries().shape == (self.nq, self.d) + if self.nt > 0: + xt = self.get_train(maxtrain=123) + assert xt.shape == (123, self.d), "shape=%s" % (xt.shape, ) + assert self.get_database().shape == (self.nb, self.d) + assert self.get_groundtruth(k=13).shape == (self.nq, 13) + + +class SyntheticDataset(Dataset): + """A dataset that is not completely random but still challenging to + index + """ + + def __init__(self, d, nt, nb, nq, metric='L2', seed=1338): + Dataset.__init__(self) + self.d, self.nt, self.nb, self.nq = d, nt, nb, nq + d1 = 10 # intrinsic dimension (more or less) + n = nb + nt + nq + rs = np.random.RandomState(seed) + x = rs.normal(size=(n, d1)) + x = np.dot(x, rs.rand(d1, d)) + # now we have a d1-dim ellipsoid in d-dimensional space + # higher factor (>4) -> higher frequency -> less linear + x = x * (rs.rand(d) * 4 + 0.1) + x = np.sin(x) + x = x.astype('float32') + self.metric = metric + self.xt = x[:nt] + self.xb = x[nt:nt + nb] + self.xq = x[nt + nb:] + + def get_queries(self): + return self.xq + + def get_train(self, maxtrain=None): + maxtrain = maxtrain if maxtrain is not None else self.nt + return self.xt[:maxtrain] + + def get_database(self): + return self.xb + + def get_groundtruth(self, k=100): + return knn( + self.xq, self.xb, k, + faiss.METRIC_L2 if self.metric == 'L2' else faiss.METRIC_INNER_PRODUCT + )[1] + + +############################################################################ +# The following datasets are a few standard open-source datasets +# they should be stored in a directory, and we start by guessing where +# that directory is +############################################################################ + +username = getpass.getuser() + +for dataset_basedir in ( + '/datasets01/simsearch/041218/', + '/mnt/vol/gfsai-flash3-east/ai-group/datasets/simsearch/', + f'/home/{username}/simsearch/data/'): + if os.path.exists(dataset_basedir): + break +else: + # users can link their data directory to `./data` + dataset_basedir = 'data/' + + +def set_dataset_basedir(path): + global dataset_basedir + dataset_basedir = path + + +class DatasetSIFT1M(Dataset): + """ + The original dataset is available at: http://corpus-texmex.irisa.fr/ + (ANN_SIFT1M) + """ + + def __init__(self): + Dataset.__init__(self) + self.d, self.nt, self.nb, self.nq = 128, 100000, 1000000, 10000 + self.basedir = dataset_basedir + 'sift1M/' + + def get_queries(self): + return fvecs_read(self.basedir + "sift_query.fvecs") + + def get_train(self, maxtrain=None): + maxtrain = maxtrain if maxtrain is not None else self.nt + return fvecs_read(self.basedir + "sift_learn.fvecs")[:maxtrain] + + def get_database(self): + return fvecs_read(self.basedir + "sift_base.fvecs") + + def get_groundtruth(self, k=None): + gt = ivecs_read(self.basedir + "sift_groundtruth.ivecs") + if k is not None: + assert k <= 100 + gt = gt[:, :k] + return gt + + +def sanitize(x): + return np.ascontiguousarray(x, dtype='float32') + + +class DatasetBigANN(Dataset): + """ + The original dataset is available at: http://corpus-texmex.irisa.fr/ + (ANN_SIFT1B) + """ + + def __init__(self, nb_M=1000): + Dataset.__init__(self) + assert nb_M in (1, 2, 5, 10, 20, 50, 100, 200, 500, 1000) + self.nb_M = nb_M + nb = nb_M * 10**6 + self.d, self.nt, self.nb, self.nq = 128, 10**8, nb, 10000 + self.basedir = dataset_basedir + 'bigann/' + + def get_queries(self): + return sanitize(bvecs_mmap(self.basedir + 'bigann_query.bvecs')[:]) + + def get_train(self, maxtrain=None): + maxtrain = maxtrain if maxtrain is not None else self.nt + return sanitize(bvecs_mmap(self.basedir + 'bigann_learn.bvecs')[:maxtrain]) + + def get_groundtruth(self, k=None): + gt = ivecs_read(self.basedir + 'gnd/idx_%dM.ivecs' % self.nb_M) + if k is not None: + assert k <= 100 + gt = gt[:, :k] + return gt + + def get_database(self): + assert self.nb_M < 100, "dataset too large, use iterator" + return sanitize(bvecs_mmap(self.basedir + 'bigann_base.bvecs')[:self.nb]) + + def database_iterator(self, bs=128, split=(1, 0)): + xb = bvecs_mmap(self.basedir + 'bigann_base.bvecs') + nsplit, rank = split + i0, i1 = self.nb * rank // nsplit, self.nb * (rank + 1) // nsplit + for j0 in range(i0, i1, bs): + yield sanitize(xb[j0: min(j0 + bs, i1)]) + + +class DatasetDeep1B(Dataset): + """ + See + https://github.com/facebookresearch/faiss/tree/main/benchs#getting-deep1b + on how to get the data + """ + + def __init__(self, nb=10**9): + Dataset.__init__(self) + nb_to_name = { + 10**5: '100k', + 10**6: '1M', + 10**7: '10M', + 10**8: '100M', + 10**9: '1B' + } + assert nb in nb_to_name + self.d, self.nt, self.nb, self.nq = 96, 358480000, nb, 10000 + self.basedir = dataset_basedir + 'deep1b/' + self.gt_fname = "%sdeep%s_groundtruth.ivecs" % ( + self.basedir, nb_to_name[self.nb]) + + def get_queries(self): + return sanitize(fvecs_read(self.basedir + "deep1B_queries.fvecs")) + + def get_train(self, maxtrain=None): + maxtrain = maxtrain if maxtrain is not None else self.nt + return sanitize(fvecs_mmap(self.basedir + "learn.fvecs")[:maxtrain]) + + def get_groundtruth(self, k=None): + gt = ivecs_read(self.gt_fname) + if k is not None: + assert k <= 100 + gt = gt[:, :k] + return gt + + def get_database(self): + assert self.nb <= 10**8, "dataset too large, use iterator" + return sanitize(fvecs_mmap(self.basedir + "base.fvecs")[:self.nb]) + + def database_iterator(self, bs=128, split=(1, 0)): + xb = fvecs_mmap(self.basedir + "base.fvecs") + nsplit, rank = split + i0, i1 = self.nb * rank // nsplit, self.nb * (rank + 1) // nsplit + for j0 in range(i0, i1, bs): + yield sanitize(xb[j0: min(j0 + bs, i1)]) + + +class DatasetGlove(Dataset): + """ + Data from http://ann-benchmarks.com/glove-100-angular.hdf5 + """ + + def __init__(self, loc=None, download=False): + import h5py + assert not download, "not implemented" + if not loc: + loc = dataset_basedir + 'glove/glove-100-angular.hdf5' + self.glove_h5py = h5py.File(loc, 'r') + # IP and L2 are equivalent in this case, but it is traditionally seen as an IP dataset + self.metric = 'IP' + self.d, self.nt = 100, 0 + self.nb = self.glove_h5py['train'].shape[0] + self.nq = self.glove_h5py['test'].shape[0] + + def get_queries(self): + xq = np.array(self.glove_h5py['test']) + faiss.normalize_L2(xq) + return xq + + def get_database(self): + xb = np.array(self.glove_h5py['train']) + faiss.normalize_L2(xb) + return xb + + def get_groundtruth(self, k=None): + gt = self.glove_h5py['neighbors'] + if k is not None: + assert k <= 100 + gt = gt[:, :k] + return gt + + +class DatasetMusic100(Dataset): + """ + get dataset from + https://github.com/stanis-morozov/ip-nsw#dataset + """ + + def __init__(self): + Dataset.__init__(self) + self.d, self.nt, self.nb, self.nq = 100, 0, 10**6, 10000 + self.metric = 'IP' + self.basedir = dataset_basedir + 'music-100/' + + def get_queries(self): + xq = np.fromfile(self.basedir + 'query_music100.bin', dtype='float32') + xq = xq.reshape(-1, 100) + return xq + + def get_database(self): + xb = np.fromfile(self.basedir + 'database_music100.bin', dtype='float32') + xb = xb.reshape(-1, 100) + return xb + + def get_groundtruth(self, k=None): + gt = np.load(self.basedir + 'gt.npy') + if k is not None: + assert k <= 100 + gt = gt[:, :k] + return gt + + +class DatasetGIST1M(Dataset): + """ + The original dataset is available at: http://corpus-texmex.irisa.fr/ + (ANN_GIST1M) + """ + + def __init__(self): + Dataset.__init__(self) + self.d, self.nt, self.nb, self.nq = 960, 100000, 1000000, 10000 + self.basedir = dataset_basedir + 'gist1M/' + + def get_queries(self): + return fvecs_read(self.basedir + "gist_query.fvecs") + + def get_train(self, maxtrain=None): + maxtrain = maxtrain if maxtrain is not None else self.nt + return fvecs_read(self.basedir + "gist_learn.fvecs")[:maxtrain] + + def get_database(self): + return fvecs_read(self.basedir + "gist_base.fvecs") + + def get_groundtruth(self, k=None): + gt = ivecs_read(self.basedir + "gist_groundtruth.ivecs") + if k is not None: + assert k <= 100 + gt = gt[:, :k] + return gt + +class DatasetDINO10B(Dataset): + """ + Data from https://dl.fbaipublicfiles.com/large_objects/dino_vitl_10B/ + The dataset contains 10 billion 1024-d vectors extracted from image patches from the YFCC100M dataset, using a Dino-ViT-L 16 model (facebook/dinov3-vitl16-pretrain-lvd1689m). + The dataset is sharded in multiple chunked .bvecs files. Downloading instructions can be obtained with "wget https://dl.fbaipublicfiles.com/large_objects/dino_vitl_10B/README.md". + Supported sizes : 100k 200k 500k 1M ... 5B 10B listed in supported_nbs (see __init__). + """ + def __init__(self, nb, ignore_supported = False): + Dataset.__init__(self) + supported_nbs = [100_000, 200_000, 500_000, 1_000_000, 2_000_000, 5_000_000, 10_000_000, 20_000_000, 50_000_000, 100_000_000, 200_000_000, 500_000_000, 1_000_000_000, 2_000_000_000, 5_000_000_000, 10_000_000_000] + if nb not in supported_nbs and not ignore_supported: + raise ValueError(f"Unsupported dataset size: {nb}, supported values are: {supported_nbs}") + if not os.path.exists(dataset_basedir): + raise ValueError(f"Provided dataset base directory does not exist: {dataset_basedir}") + self.basedir = dataset_basedir + "dino_vitl_10B/" + self.indexdir = self.basedir + "chunked_base_10B" + assert os.path.exists(self.indexdir), f"Index path should exist, check your dataset path: {self.indexdir}" + self.queriesdir = self.basedir + "queries_clean.bvecs" + assert os.path.exists(self.queriesdir), f"Queries path should exist as dataset size {nb} is supported: {self.queriesdir}" + self.gtsdir = self.basedir + "gts/" + "gts_dino_patch_" + str(nb) + "_" + "k10.npy" + self.train_queriesdir = self.basedir + "train_queries_99M.bvecs" + self.nb = nb + self.d = 1024 + self.nq = 100_000 + self.nt = 99_000_000 + self.metric = "L2" + + + def get_queries(self): + """Get all vectors as a single array""" + queries = bvecs_mmap(self.queriesdir) + return sanitize(queries) + + def get_train(self, maxtrain = None): + """Get training query vectors as a single array""" + if maxtrain is None or maxtrain > 10_000_000: + raise NotImplementedError("The training set is potentially too large to fit in RAM (400 GB of data). Please use train_iterator or use maxtrain parameter below 10_000_000 to get the first maxtrain training vectors.") + return sanitize(bvecs_mmap(self.train_queriesdir)[:maxtrain]) + + def get_database(self): + """Get all database vectors as a single array""" + if self.nb > 10_000_000: + raise NotImplementedError("The dataset is potentially too large to fit in RAM. Please use database_iterator or use a dataset size equal to or below 10_000_000.") + else: + return sanitize(bvecs_iter_chunked(self.indexdir, batch_size=self.nb).__next__()) + + def database_iterator(self, bs=10_000): + """Iterator over the database of size nb, corresponding to the first nb vectors in the .bvecs file""" + total_read = 0 + for batch in bvecs_iter_chunked(self.indexdir, batch_size=bs): + if total_read + batch.shape[0] > self.nb: + batch = batch[:self.nb - total_read] + yield sanitize(batch) + total_read += batch.shape[0] + if total_read >= self.nb: + break + + def train_iterator(self, bs=10_000): + """Iterator over all training query vectors in the .bvecs file""" + for batch in bvecs_iter(self.train_queriesdir, batch_size=bs): + yield sanitize(batch) + + def get_groundtruth(self, k = 10): + """Get ground truth from .npy file""" + if k > 10: + raise NotImplementedError("Ground truth files only available for k<=10") + gts = np.load(self.gtsdir) + gts = gts[:, :k] + return gts + + def distance(self): + return "euclidean" + +def dataset_from_name(dataset='deep1M', download=False): + """ converts a string describing a dataset to a Dataset object + Supports sift1M, bigann1M..bigann1B, deep1M..deep1B, music-100 and glove + """ + + if dataset == 'sift1M': + return DatasetSIFT1M() + + elif dataset == 'gist1M': + return DatasetGIST1M() + + elif dataset.startswith('bigann'): + dbsize = 1000 if dataset == "bigann1B" else int(dataset[6:-1]) + return DatasetBigANN(nb_M=dbsize) + + elif dataset.startswith("deep"): + + szsuf = dataset[4:] + if szsuf[-1] == 'M': + dbsize = 10 ** 6 * int(szsuf[:-1]) + elif szsuf == '1B': + dbsize = 10 ** 9 + elif szsuf[-1] == 'k': + dbsize = 1000 * int(szsuf[:-1]) + else: + assert False, "did not recognize suffix " + szsuf + return DatasetDeep1B(nb=dbsize) + + elif dataset == "music-100": + return DatasetMusic100() + + elif dataset == "glove": + return DatasetGlove(download=download) + + elif dataset.startswith("dino"): + dbsize = 10_000_000_000 if dataset == "dino10B" else int(dataset[4:]) + return DatasetDINO10B(nb=dbsize) + + else: + raise RuntimeError("unknown dataset " + dataset) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/evaluation.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/evaluation.py new file mode 100644 index 0000000000000000000000000000000000000000..9efe2b721894f292b5ac3f0ccd5cf9dc8a0af90f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/evaluation.py @@ -0,0 +1,498 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import unittest +import time +import faiss + +from multiprocessing.pool import ThreadPool + +############################################################### +# Simple functions to evaluate knn results + + +def knn_intersection_measure(I1, I2): + """ computes the intersection measure of two result tables + """ + nq, rank = I1.shape + assert I2.shape == (nq, rank) + ninter = sum( + np.intersect1d(I1[i], I2[i]).size + for i in range(nq) + ) + return ninter / I1.size + +############################################################### +# Range search results can be compared with Precision-Recall + + +def filter_range_results(lims, D, I, thresh): + """ select a set of results """ + nq = lims.size - 1 + mask = D < thresh + new_lims = np.zeros_like(lims) + for i in range(nq): + new_lims[i + 1] = new_lims[i] + mask[lims[i] : lims[i + 1]].sum() + return new_lims, D[mask], I[mask] + + +def range_PR(lims_ref, Iref, lims_new, Inew, mode="overall"): + """compute the precision and recall of range search results. The + function does not take the distances into account. """ + + def ref_result_for(i): + return Iref[lims_ref[i]:lims_ref[i + 1]] + + def new_result_for(i): + return Inew[lims_new[i]:lims_new[i + 1]] + + nq = lims_ref.size - 1 + assert lims_new.size - 1 == nq + + ninter = np.zeros(nq, dtype="int64") + + def compute_PR_for(q): + + # ground truth results for this query + gt_ids = ref_result_for(q) + + # results for this query + new_ids = new_result_for(q) + + # there are no set functions in numpy so let's do this + inter = np.intersect1d(gt_ids, new_ids) + + ninter[q] = len(inter) + + # run in a thread pool, which helps in spite of the GIL + pool = ThreadPool(20) + pool.map(compute_PR_for, range(nq)) + + return counts_to_PR( + lims_ref[1:] - lims_ref[:-1], + lims_new[1:] - lims_new[:-1], + ninter, + mode=mode + ) + + +def counts_to_PR(ngt, nres, ninter, mode="overall"): + """ computes a precision-recall for a set of queries. + ngt = nb of GT results per query + nres = nb of found results per query + ninter = nb of correct results per query (smaller than nres of course) + """ + + if mode == "overall": + ngt, nres, ninter = ngt.sum(), nres.sum(), ninter.sum() + + if nres > 0: + precision = ninter / nres + else: + precision = 1.0 + + if ngt > 0: + recall = ninter / ngt + elif nres == 0: + recall = 1.0 + else: + recall = 0.0 + + return precision, recall + + elif mode == "average": + # average precision and recall over queries + + mask = ngt == 0 + ngt[mask] = 1 + + recalls = ninter / ngt + recalls[mask] = (nres[mask] == 0).astype(float) + + # avoid division by 0 + mask = nres == 0 + assert np.all(ninter[mask] == 0) + ninter[mask] = 1 + nres[mask] = 1 + + precisions = ninter / nres + + return precisions.mean(), recalls.mean() + + else: + raise AssertionError() + + +def sort_range_res_2(lims, D, I): + """ sort 2 arrays using the first as key """ + I2 = np.empty_like(I) + D2 = np.empty_like(D) + nq = len(lims) - 1 + for i in range(nq): + l0, l1 = lims[i], lims[i + 1] + ii = I[l0:l1] + di = D[l0:l1] + o = di.argsort() + I2[l0:l1] = ii[o] + D2[l0:l1] = di[o] + return I2, D2 + + +def sort_range_res_1(lims, I): + I2 = np.empty_like(I) + nq = len(lims) - 1 + for i in range(nq): + l0, l1 = lims[i], lims[i + 1] + I2[l0:l1] = I[l0:l1] + I2[l0:l1].sort() + return I2 + + +def range_PR_multiple_thresholds( + lims_ref, Iref, + lims_new, Dnew, Inew, + thresholds, + mode="overall", do_sort="ref,new" + ): + """ compute precision-recall values for range search results + for several thresholds on the "new" results. + This is to plot PR curves + """ + # ref should be sorted by ids + if "ref" in do_sort: + Iref = sort_range_res_1(lims_ref, Iref) + + # new should be sorted by distances + if "new" in do_sort: + Inew, Dnew = sort_range_res_2(lims_new, Dnew, Inew) + + def ref_result_for(i): + return Iref[lims_ref[i]:lims_ref[i + 1]] + + def new_result_for(i): + l0, l1 = lims_new[i], lims_new[i + 1] + return Inew[l0:l1], Dnew[l0:l1] + + nq = lims_ref.size - 1 + assert lims_new.size - 1 == nq + + nt = len(thresholds) + counts = np.zeros((nq, nt, 3), dtype="int64") + + def compute_PR_for(q): + gt_ids = ref_result_for(q) + res_ids, res_dis = new_result_for(q) + + counts[q, :, 0] = len(gt_ids) + + if res_dis.size == 0: + # the rest remains at 0 + return + + # which offsets we are interested in + nres= np.searchsorted(res_dis, thresholds) + counts[q, :, 1] = nres + + if gt_ids.size == 0: + return + + # find number of TPs at each stage in the result list + ii = np.searchsorted(gt_ids, res_ids) + ii[ii == len(gt_ids)] = -1 + n_ok = np.cumsum(gt_ids[ii] == res_ids) + + # focus on threshold points + n_ok = np.hstack(([0], n_ok)) + counts[q, :, 2] = n_ok[nres] + + pool = ThreadPool(20) + pool.map(compute_PR_for, range(nq)) + # print(counts.transpose(2, 1, 0)) + + precisions = np.zeros(nt) + recalls = np.zeros(nt) + for t in range(nt): + p, r = counts_to_PR( + counts[:, t, 0], counts[:, t, 1], counts[:, t, 2], + mode=mode + ) + precisions[t] = p + recalls[t] = r + + return precisions, recalls + + +############################################################### +# Functions that compare search results with a reference result. +# They are intended for use in tests + +def _cluster_tables_with_tolerance(tab1, tab2, thr): + """ for two tables, cluster them by merging values closer than thr. + Returns the cluster ids for each table element """ + tab = np.hstack([tab1, tab2]) + tab.sort() + n = len(tab) + diffs = np.ones(n) + diffs[1:] = tab[1:] - tab[:-1] + unique_vals = tab[diffs > thr] + idx1 = np.searchsorted(unique_vals, tab1, side='right') - 1 + idx2 = np.searchsorted(unique_vals, tab2, side='right') - 1 + return idx1, idx2 + + +def check_ref_knn_with_draws(Dref, Iref, Dnew, Inew, rtol=1e-5): + """ test that knn search results are identical, with possible ties. + Raise if not. """ + np.testing.assert_allclose(Dref, Dnew, rtol=rtol) + # here we have to be careful because of draws + testcase = unittest.TestCase() # because it makes nice error messages + for i in range(len(Iref)): + if np.all(Iref[i] == Inew[i]): # easy case + continue + + # otherwise collect elements per distance + r = rtol * Dref[i].max() + + DrefC, DnewC = _cluster_tables_with_tolerance(Dref[i], Dnew[i], r) + + for dis in np.unique(DrefC): + if dis == DrefC[-1]: + continue + mask = DrefC == dis + testcase.assertEqual(set(Iref[i, mask]), set(Inew[i, mask])) + + +def check_ref_range_results(Lref, Dref, Iref, + Lnew, Dnew, Inew): + """ compare range search results wrt. a reference result, + throw if it fails """ + np.testing.assert_array_equal(Lref, Lnew) + nq = len(Lref) - 1 + for i in range(nq): + l0, l1 = Lref[i], Lref[i + 1] + Ii_ref = Iref[l0:l1] + Ii_new = Inew[l0:l1] + Di_ref = Dref[l0:l1] + Di_new = Dnew[l0:l1] + if np.all(Ii_ref == Ii_new): # easy + pass + else: + def sort_by_ids(I, D): + o = I.argsort() + return I[o], D[o] + # sort both + (Ii_ref, Di_ref) = sort_by_ids(Ii_ref, Di_ref) + (Ii_new, Di_new) = sort_by_ids(Ii_new, Di_new) + np.testing.assert_array_equal(Ii_ref, Ii_new) + np.testing.assert_array_almost_equal(Di_ref, Di_new, decimal=5) + + +############################################################### +# OperatingPoints functions +# this is the Python version of the AutoTune object in C++ + + +class OperatingPoints: + """ + Manages a set of search parameters with associated performance and time. + Keeps the Pareto optimal points. + """ + + def __init__(self): + # list of (key, perf, t) + self.operating_points = [ + # (self.do_nothing_key(), 0.0, 0.0) + ] + self.suboptimal_points = [] + + def compare_keys(self, k1, k2): + """ return -1 if k1 > k2, 1 if k2 > k1, 0 otherwise """ + raise NotImplemented + + def do_nothing_key(self): + """ parameters to say we do nothing, takes 0 time and has 0 performance""" + raise NotImplemented + + def is_pareto_optimal(self, perf_new, t_new): + for _, perf, t in self.operating_points: + if perf >= perf_new and t <= t_new: + return False + return True + + def predict_bounds(self, key): + """ predicts the bound on time and performance """ + min_time = 0.0 + max_perf = 1.0 + for key2, perf, t in self.operating_points + self.suboptimal_points: + cmp = self.compare_keys(key, key2) + if cmp > 0: # key2 > key + if t > min_time: + min_time = t + if cmp < 0: # key2 < key + if perf < max_perf: + max_perf = perf + return max_perf, min_time + + def should_run_experiment(self, key): + (max_perf, min_time) = self.predict_bounds(key) + return self.is_pareto_optimal(max_perf, min_time) + + def add_operating_point(self, key, perf, t): + if self.is_pareto_optimal(perf, t): + i = 0 + # maybe it shadows some other operating point completely? + while i < len(self.operating_points): + op_Ls, perf2, t2 = self.operating_points[i] + if perf >= perf2 and t < t2: + self.suboptimal_points.append( + self.operating_points.pop(i)) + else: + i += 1 + self.operating_points.append((key, perf, t)) + return True + else: + self.suboptimal_points.append((key, perf, t)) + return False + + +class OperatingPointsWithRanges(OperatingPoints): + """ + Set of parameters that are each picked from a discrete range of values. + An increase of each parameter is assumed to make the operation slower + and more accurate. + A key = int array of indices in the ordered set of parameters. + """ + + def __init__(self): + OperatingPoints.__init__(self) + # list of (name, values) + self.ranges = [] + + def add_range(self, name, values): + self.ranges.append((name, values)) + + def compare_keys(self, k1, k2): + if np.all(k1 >= k2): + return 1 + if np.all(k2 >= k1): + return -1 + return 0 + + def do_nothing_key(self): + return np.zeros(len(self.ranges), dtype=int) + + def num_experiments(self): + return int(np.prod([len(values) for name, values in self.ranges])) + + def sample_experiments(self, n_autotune, rs=np.random): + """ sample a set of experiments of max size n_autotune + (run all experiments in random order if n_autotune is 0) + """ + assert n_autotune == 0 or n_autotune >= 2 + totex = self.num_experiments() + rs = np.random.RandomState(123) + if n_autotune == 0 or totex < n_autotune: + experiments = rs.permutation(totex - 2) + else: + experiments = rs.choice( + totex - 2, size=n_autotune - 2, replace=False) + + experiments = [0, totex - 1] + [int(cno) + 1 for cno in experiments] + return experiments + + def cno_to_key(self, cno): + """Convert a sequential experiment number to a key""" + k = np.zeros(len(self.ranges), dtype=int) + for i, (name, values) in enumerate(self.ranges): + k[i] = cno % len(values) + cno //= len(values) + assert cno == 0 + return k + + def get_parameters(self, k): + """Convert a key to a dictionary with parameter values""" + return { + name: values[k[i]] + for i, (name, values) in enumerate(self.ranges) + } + + def restrict_range(self, name, max_val): + """ remove too large values from a range""" + for name2, values in self.ranges: + if name == name2: + val2 = [v for v in values if v < max_val] + values[:] = val2 + return + raise RuntimeError(f"parameter {name} not found") + + +############################################################### +# Timer object + + +class TimerIter: + def __init__(self, timer): + self.ts = [] + self.runs = timer.runs + self.timer = timer + if timer.nt >= 0: + faiss.omp_set_num_threads(timer.nt) + + def __next__(self): + timer = self.timer + self.runs -= 1 + self.ts.append(time.time()) + total_time = self.ts[-1] - self.ts[0] if len(self.ts) >= 2 else 0 + if self.runs == -1 or total_time > timer.max_secs: + if timer.nt >= 0: + faiss.omp_set_num_threads(timer.remember_nt) + ts = np.array(self.ts) + times = ts[1:] - ts[:-1] + if len(times) == timer.runs: + timer.times = times[timer.warmup :] + else: + # if timeout, we use all the runs + timer.times = times[:] + raise StopIteration + + +class RepeatTimer: + """ + This is yet another timer object. It is adapted to Faiss by + taking a number of openmp threads to set on input. It should be called + in an explicit loop as: + + timer = RepeatTimer(warmup=1, nt=1, runs=6) + + for _ in timer: + # perform operation + + print(f"time={timer.get_ms():.1f} ± {timer.get_ms_std():.1f} ms") + + the same timer can be re-used. In that case it is reset each time it + enters a loop. It focuses on ms-scale times because for second scale + it's usually less relevant to repeat the operation. + """ + def __init__(self, warmup=0, nt=-1, runs=1, max_secs=np.inf): + assert warmup < runs + self.warmup = warmup + self.nt = nt + self.runs = runs + self.max_secs = max_secs + self.remember_nt = faiss.omp_get_max_threads() + + def __iter__(self): + return TimerIter(self) + + def ms(self): + return np.mean(self.times) * 1000 + + def ms_std(self): + return np.std(self.times) * 1000 if len(self.times) > 1 else 0.0 + + def nruns(self): + """ effective number of runs (may be lower than runs - warmup due to timeout)""" + return len(self.times) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/exhaustive_search.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/exhaustive_search.py new file mode 100644 index 0000000000000000000000000000000000000000..7a5156bc7747703774dc9275ac1ccc3b0d329240 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/exhaustive_search.py @@ -0,0 +1,368 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import faiss +import time +import numpy as np + +import logging + +LOG = logging.getLogger(__name__) + + +def knn_ground_truth(xq, db_iterator, k, metric_type=faiss.METRIC_L2, shard=False, ngpu=-1): + """Computes the exact KNN search results for a dataset that possibly + does not fit in RAM but for which we have an iterator that + returns it block by block. + """ + LOG.info("knn_ground_truth queries size %s k=%d" % (xq.shape, k)) + t0 = time.time() + nq, d = xq.shape + keep_max = faiss.is_similarity_metric(metric_type) + rh = faiss.ResultHeap(nq, k, keep_max=keep_max) + + index = faiss.IndexFlat(d, metric_type) + if ngpu == -1: + ngpu = faiss.get_num_gpus() + + if ngpu: + LOG.info('running on %d GPUs' % ngpu) + co = faiss.GpuMultipleClonerOptions() + co.shard = shard + index = faiss.index_cpu_to_all_gpus(index, co=co, ngpu=ngpu) + + # compute ground-truth by blocks, and add to heaps + i0 = 0 + for xbi in db_iterator: + ni = xbi.shape[0] + index.add(xbi) + D, I = index.search(xq, k) + I += i0 + rh.add_result(D, I) + index.reset() + i0 += ni + LOG.info("%d db elements, %.3f s" % (i0, time.time() - t0)) + + rh.finalize() + LOG.info("GT time: %.3f s (%d vectors)" % (time.time() - t0, i0)) + + return rh.D, rh.I + +# knn function used to be here +knn = faiss.knn + + + + +def range_search_gpu(xq, r2, index_gpu, index_cpu, gpu_k=1024): + """GPU does not support range search, so we emulate it with + knn search + fallback to CPU index. + + The index_cpu can either be: + - a CPU index that supports range search + - a numpy table, that will be used to construct a Flat index if needed. + - None. In that case, at most gpu_k results will be returned + """ + nq, d = xq.shape + is_binary_index = isinstance(index_gpu, faiss.IndexBinary) + keep_max = faiss.is_similarity_metric(index_gpu.metric_type) + r2 = int(r2) if is_binary_index else float(r2) + k = min(index_gpu.ntotal, gpu_k) + LOG.debug( + f"GPU search {nq} queries with {k=:} {is_binary_index=:} {keep_max=:}") + t0 = time.time() + D, I = index_gpu.search(xq, k) + t1 = time.time() - t0 + if is_binary_index: + assert d * 8 < 32768 # let's compact the distance matrix + D = D.astype('int16') + t2 = 0 + lim_remain = None + if index_cpu is not None: + if not keep_max: + mask = D[:, k - 1] < r2 + else: + mask = D[:, k - 1] > r2 + if mask.sum() > 0: + LOG.debug("CPU search remain %d" % mask.sum()) + t0 = time.time() + if isinstance(index_cpu, np.ndarray): + # then it in fact an array that we have to make flat + xb = index_cpu + if is_binary_index: + index_cpu = faiss.IndexBinaryFlat(d * 8) + else: + index_cpu = faiss.IndexFlat(d, index_gpu.metric_type) + index_cpu.add(xb) + lim_remain, D_remain, I_remain = index_cpu.range_search(xq[mask], r2) + if is_binary_index: + D_remain = D_remain.astype('int16') + t2 = time.time() - t0 + LOG.debug("combine") + t0 = time.time() + + CombinerRangeKNN = ( + faiss.CombinerRangeKNNint16 if is_binary_index else + faiss.CombinerRangeKNNfloat + ) + + combiner = CombinerRangeKNN(nq, k, r2, keep_max) + if True: + sp = faiss.swig_ptr + combiner.I = sp(I) + combiner.D = sp(D) + # combiner.set_knn_result(sp(I), sp(D)) + if lim_remain is not None: + combiner.mask = sp(mask) + combiner.D_remain = sp(D_remain) + combiner.lim_remain = sp(lim_remain.view("int64")) + combiner.I_remain = sp(I_remain) + # combiner.set_range_result(sp(mask), sp(lim_remain.view("int64")), sp(D_remain), sp(I_remain)) + L_res = np.empty(nq + 1, dtype='int64') + combiner.compute_sizes(sp(L_res)) + nres = L_res[-1] + D_res = np.empty(nres, dtype=D.dtype) + I_res = np.empty(nres, dtype='int64') + combiner.write_result(sp(D_res), sp(I_res)) + else: + D_res, I_res = [], [] + nr = 0 + for i in range(nq): + if not mask[i]: + if index_gpu.metric_type == faiss.METRIC_L2: + nv = (D[i, :] < r2).sum() + else: + nv = (D[i, :] > r2).sum() + D_res.append(D[i, :nv]) + I_res.append(I[i, :nv]) + else: + l0, l1 = lim_remain[nr], lim_remain[nr + 1] + D_res.append(D_remain[l0:l1]) + I_res.append(I_remain[l0:l1]) + nr += 1 + L_res = np.cumsum([0] + [len(di) for di in D_res]) + D_res = np.hstack(D_res) + I_res = np.hstack(I_res) + t3 = time.time() - t0 + LOG.debug(f"times {t1:.3f}s {t2:.3f}s {t3:.3f}s") + return L_res, D_res, I_res + + +def range_ground_truth(xq, db_iterator, threshold, metric_type=faiss.METRIC_L2, + shard=False, ngpu=-1): + """Computes the range-search search results for a dataset that possibly + does not fit in RAM but for which we have an iterator that + returns it block by block. + """ + nq, d = xq.shape + t0 = time.time() + xq = np.ascontiguousarray(xq, dtype='float32') + + index = faiss.IndexFlat(d, metric_type) + if ngpu == -1: + ngpu = faiss.get_num_gpus() + if ngpu: + LOG.info('running on %d GPUs' % ngpu) + co = faiss.GpuMultipleClonerOptions() + co.shard = shard + index_gpu = faiss.index_cpu_to_all_gpus(index, co=co, ngpu=ngpu) + + # compute ground-truth by blocks + i0 = 0 + D = [[] for _i in range(nq)] + I = [[] for _i in range(nq)] + for xbi in db_iterator: + ni = xbi.shape[0] + if ngpu > 0: + index_gpu.add(xbi) + lims_i, Di, Ii = range_search_gpu(xq, threshold, index_gpu, xbi) + index_gpu.reset() + else: + index.add(xbi) + lims_i, Di, Ii = index.range_search(xq, threshold) + index.reset() + Ii += i0 + for j in range(nq): + l0, l1 = lims_i[j], lims_i[j + 1] + if l1 > l0: + D[j].append(Di[l0:l1]) + I[j].append(Ii[l0:l1]) + i0 += ni + LOG.info("%d db elements, %.3f s" % (i0, time.time() - t0)) + + empty_I = np.zeros(0, dtype='int64') + empty_D = np.zeros(0, dtype='float32') + # import pdb; pdb.set_trace() + D = [(np.hstack(i) if i != [] else empty_D) for i in D] + I = [(np.hstack(i) if i != [] else empty_I) for i in I] + sizes = [len(i) for i in I] + assert len(sizes) == nq + lims = np.zeros(nq + 1, dtype="uint64") + lims[1:] = np.cumsum(sizes) + return lims, np.hstack(D), np.hstack(I) + + +def threshold_radius_nres(nres, dis, ids, thresh, keep_max=False): + """ select a set of results """ + if keep_max: + mask = dis > thresh + else: + mask = dis < thresh + new_nres = np.zeros_like(nres) + o = 0 + for i, nr in enumerate(nres): + nr = int(nr) # avoid issues with int64 + uint64 + new_nres[i] = mask[o:o + nr].sum() + o += nr + return new_nres, dis[mask], ids[mask] + + +def threshold_radius(lims, dis, ids, thresh, keep_max=False): + """ restrict range-search results to those below a given radius """ + if keep_max: + mask = dis > thresh + else: + mask = dis < thresh + new_lims = np.zeros_like(lims) + n = len(lims) - 1 + for i in range(n): + l0, l1 = lims[i], lims[i + 1] + new_lims[i + 1] = new_lims[i] + mask[l0:l1].sum() + return new_lims, dis[mask], ids[mask] + + +def apply_maxres(res_batches, target_nres, keep_max=False): + """find radius that reduces number of results to target_nres, and + applies it in-place to the result batches used in + range_search_max_results""" + alldis = np.hstack([dis for _, dis, _ in res_batches]) + assert len(alldis) > target_nres + if keep_max: + alldis.partition(len(alldis) - target_nres - 1) + radius = alldis[-1 - target_nres] + else: + alldis.partition(target_nres) + radius = alldis[target_nres] + + if alldis.dtype == 'float32': + radius = float(radius) + else: + radius = int(radius) + LOG.debug(' setting radius to %s' % radius) + totres = 0 + for i, (nres, dis, ids) in enumerate(res_batches): + nres, dis, ids = threshold_radius_nres( + nres, dis, ids, radius, keep_max=keep_max) + totres += len(dis) + res_batches[i] = nres, dis, ids + LOG.debug(' updated previous results, new nb results %d' % totres) + return radius, totres + + +def range_search_max_results(index, query_iterator, radius, + max_results=None, min_results=None, + shard=False, ngpu=0, clip_to_min=False): + """Performs a range search with many queries (given by an iterator) + and adjusts the threshold on-the-fly so that the total results + table does not grow larger than max_results. + + If ngpu != 0, the function moves the index to this many GPUs to + speed up search. + """ + # TODO: all result manipulations are in python, should move to C++ if perf + # critical + is_binary_index = isinstance(index, faiss.IndexBinary) + + if min_results is None: + assert max_results is not None + min_results = int(0.8 * max_results) + + if max_results is None: + assert min_results is not None + max_results = int(min_results * 1.5) + + if ngpu == -1: + ngpu = faiss.get_num_gpus() + + if ngpu: + LOG.info('running on %d GPUs' % ngpu) + co = faiss.GpuMultipleClonerOptions() + co.shard = shard + index_gpu = faiss.index_cpu_to_all_gpus(index, co=co, ngpu=ngpu) + else: + index_gpu = None + + t_start = time.time() + t_search = t_post_process = 0 + qtot = totres = raw_totres = 0 + res_batches = [] + + for xqi in query_iterator: + t0 = time.time() + LOG.debug(f"searching {len(xqi)} vectors") + if index_gpu: + lims_i, Di, Ii = range_search_gpu(xqi, radius, index_gpu, index) + else: + lims_i, Di, Ii = index.range_search(xqi, radius) + + nres_i = lims_i[1:] - lims_i[:-1] + raw_totres += len(Di) + qtot += len(xqi) + + t1 = time.time() + if is_binary_index: + # weird Faiss quirk that returns floats for Hamming distances + Di = Di.astype('int16') + + totres += len(Di) + res_batches.append((nres_i, Di, Ii)) + + if max_results is not None and totres > max_results: + LOG.info('too many results %d > %d, scaling back radius' % + (totres, max_results)) + radius, totres = apply_maxres( + res_batches, min_results, + keep_max=index.metric_type == faiss.METRIC_INNER_PRODUCT + ) + t2 = time.time() + t_search += t1 - t0 + t_post_process += t2 - t1 + LOG.debug(' [%.3f s] %d queries done, %d results' % ( + time.time() - t_start, qtot, totres)) + + LOG.info( + 'search done in %.3f s + %.3f s, total %d results, end threshold %g' % ( + t_search, t_post_process, totres, radius) + ) + + if clip_to_min and totres > min_results: + radius, totres = apply_maxres( + res_batches, min_results, + keep_max=index.metric_type == faiss.METRIC_INNER_PRODUCT + ) + + nres = np.hstack([nres_i for nres_i, dis_i, ids_i in res_batches]) + dis = np.hstack([dis_i for nres_i, dis_i, ids_i in res_batches]) + ids = np.hstack([ids_i for nres_i, dis_i, ids_i in res_batches]) + + lims = np.zeros(len(nres) + 1, dtype='uint64') + lims[1:] = np.cumsum(nres) + + return radius, lims, dis, ids + + +def exponential_query_iterator(xq, start_bs=32, max_bs=20000): + """ produces batches of progressively increasing sizes. This is useful to + adjust the search radius progressively without overflowing with + intermediate results """ + nq = len(xq) + bs = start_bs + i = 0 + while i < nq: + xqi = xq[i:i + bs] + yield xqi + if bs < max_bs: + bs *= 2 + i += len(xqi) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/factory_tools.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/factory_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..843798fac97fe98feb97e13e6c79eb54c26ddefb --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/factory_tools.py @@ -0,0 +1,156 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import faiss +import re + + +def get_code_size(d, indexkey): + """ size of one vector in an index in dimension d + constructed with factory string indexkey""" + + if indexkey == "Flat": + return d * 4 + + if indexkey.endswith(",RFlat"): + return d * 4 + get_code_size(d, indexkey[:-len(",RFlat")]) + + mo = re.match("IVF\\d+(_HNSW32)?,(.*)$", indexkey) + if mo: + return get_code_size(d, mo.group(2)) + + mo = re.match("IVF\\d+\\(.*\\)?,(.*)$", indexkey) + if mo: + return get_code_size(d, mo.group(1)) + + mo = re.match("IMI\\d+x2,(.*)$", indexkey) + if mo: + return get_code_size(d, mo.group(1)) + + mo = re.match("(.*),Refine\\((.*)\\)$", indexkey) + if mo: + return get_code_size(d, mo.group(1)) + get_code_size(d, mo.group(2)) + + mo = re.match('PQ(\\d+)x(\\d+)(fs|fsr)?$', indexkey) + if mo: + return (int(mo.group(1)) * int(mo.group(2)) + 7) // 8 + + mo = re.match('PQ(\\d+)\\+(\\d+)$', indexkey) + if mo: + return (int(mo.group(1)) + int(mo.group(2))) + + mo = re.match('PQ(\\d+)$', indexkey) + if mo: + return int(mo.group(1)) + + if indexkey == "HNSW32" or indexkey == "HNSW32,Flat": + return d * 4 + 64 * 4 # roughly + + if indexkey == 'SQ8': + return d + elif indexkey == 'SQ4': + return (d + 1) // 2 + elif indexkey == 'SQ6': + return (d * 6 + 7) // 8 + elif indexkey == 'SQfp16': + return d * 2 + elif indexkey == 'SQbf16': + return d * 2 + + mo = re.match('PCAR?(\\d+),(.*)$', indexkey) + if mo: + return get_code_size(int(mo.group(1)), mo.group(2)) + mo = re.match('OPQ\\d+_(\\d+),(.*)$', indexkey) + if mo: + return get_code_size(int(mo.group(1)), mo.group(2)) + mo = re.match('OPQ\\d+,(.*)$', indexkey) + if mo: + return get_code_size(d, mo.group(1)) + mo = re.match('RR(\\d+),(.*)$', indexkey) + if mo: + return get_code_size(int(mo.group(1)), mo.group(2)) + raise RuntimeError("cannot parse " + indexkey) + + +def get_hnsw_M(index): + return index.hnsw.cum_nneighbor_per_level.at(1) // 2 + + +def reverse_index_factory(index): + """ + attempts to get the factory string the index was built with + """ + index = faiss.downcast_index(index) + if isinstance(index, faiss.IndexFlat): + return "Flat" + elif isinstance(index, faiss.IndexIVF): + quantizer = faiss.downcast_index(index.quantizer) + + if isinstance(quantizer, faiss.IndexFlat): + prefix = f"IVF{index.nlist}" + elif isinstance(quantizer, faiss.MultiIndexQuantizer): + prefix = f"IMI{quantizer.pq.M}x{quantizer.pq.nbits}" + elif isinstance(quantizer, faiss.IndexHNSW): + prefix = f"IVF{index.nlist}_HNSW{get_hnsw_M(quantizer)}" + else: + prefix = f"IVF{index.nlist}({reverse_index_factory(quantizer)})" + + if isinstance(index, faiss.IndexIVFFlat): + return prefix + ",Flat" + if isinstance(index, faiss.IndexIVFScalarQuantizer): + return prefix + ",SQ8" + if isinstance(index, faiss.IndexIVFPQ): + return prefix + f",PQ{index.pq.M}x{index.pq.nbits}" + if isinstance(index, faiss.IndexIVFPQFastScan): + return prefix + f",PQ{index.pq.M}x{index.pq.nbits}fs" + + elif isinstance(index, faiss.IndexPreTransform): + if index.chain.size() != 1: + raise NotImplementedError() + vt = faiss.downcast_VectorTransform(index.chain.at(0)) + if isinstance(vt, faiss.OPQMatrix): + prefix = f"OPQ{vt.M}_{vt.d_out}" + elif isinstance(vt, faiss.ITQTransform): + prefix = f"ITQ{vt.itq.d_out}" + elif isinstance(vt, faiss.PCAMatrix): + assert vt.eigen_power == 0 + prefix = "PCA" + ("R" if vt.random_rotation else "") + str(vt.d_out) + else: + raise NotImplementedError() + return f"{prefix},{reverse_index_factory(index.index)}" + + elif isinstance(index, faiss.IndexHNSW): + return f"HNSW{get_hnsw_M(index)}" + + elif isinstance(index, faiss.IndexRefine): + return f"{reverse_index_factory(index.base_index)},Refine({reverse_index_factory(index.refine_index)})" + + elif isinstance(index, faiss.IndexPQFastScan): + return f"PQ{index.pq.M}x{index.pq.nbits}fs" + + elif isinstance(index, faiss.IndexPQ): + return f"PQ{index.pq.M}x{index.pq.nbits}" + + elif isinstance(index, faiss.IndexLSH): + return "LSH" + ("r" if index.rotate_data else "") + ("t" if index.train_thresholds else "") + + elif isinstance(index, faiss.IndexScalarQuantizer): + sqtypes = { + faiss.ScalarQuantizer.QT_8bit: "8", + faiss.ScalarQuantizer.QT_4bit: "4", + faiss.ScalarQuantizer.QT_6bit: "6", + faiss.ScalarQuantizer.QT_fp16: "fp16", + faiss.ScalarQuantizer.QT_bf16: "bf16", + } + return f"SQ{sqtypes[index.sq.qtype]}" + + # IndexIDMap2 is a subclass of IndexIDMap, so it must be checked first. + elif isinstance(index, faiss.IndexIDMap2): + return f"IDMap2,{reverse_index_factory(index.index)}" + + elif isinstance(index, faiss.IndexIDMap): + return f"IDMap,{reverse_index_factory(index.index)}" + + raise NotImplementedError() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/inspect_tools.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/inspect_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..3181559bad126c54fc3c414b57c57c14b6014196 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/inspect_tools.py @@ -0,0 +1,117 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import faiss + + +def get_invlist(invlists, l): + """ returns the inverted lists content as a pair of (list_ids, list_codes). + The codes are reshaped to a proper size + """ + invlists = faiss.downcast_InvertedLists(invlists) + ls = invlists.list_size(l) + list_ids = np.zeros(ls, dtype='int64') + ids = codes = None + try: + ids = invlists.get_ids(l) + if ls > 0: + faiss.memcpy(faiss.swig_ptr(list_ids), ids, list_ids.nbytes) + codes = invlists.get_codes(l) + if invlists.code_size != faiss.InvertedLists.INVALID_CODE_SIZE: + list_codes = np.zeros((ls, invlists.code_size), dtype='uint8') + else: + # it's a BlockInvertedLists + npb = invlists.n_per_block + bs = invlists.block_size + ls_round = (ls + npb - 1) // npb + list_codes = np.zeros((ls_round, bs // npb, npb), dtype='uint8') + if ls > 0: + faiss.memcpy(faiss.swig_ptr(list_codes), codes, list_codes.nbytes) + finally: + if ids is not None: + invlists.release_ids(l, ids) + if codes is not None: + invlists.release_codes(l, codes) + return list_ids, list_codes + + +def get_invlist_sizes(invlists): + """ return the array of sizes of the inverted lists """ + return np.array([ + invlists.list_size(i) + for i in range(invlists.nlist) + ], dtype='int64') + + +def print_object_fields(obj): + """ list values all fields of an object known to SWIG """ + + for name in obj.__class__.__swig_getmethods__: + print(f"{name} = {getattr(obj, name)}") + + +def get_pq_centroids(pq): + """ return the PQ centroids as an array """ + cen = faiss.vector_to_array(pq.centroids) + return cen.reshape(pq.M, pq.ksub, pq.dsub) + + +def get_LinearTransform_matrix(pca): + """ extract matrix + bias from the PCA object + works for any linear transform (OPQ, random rotation, etc.) + """ + b = faiss.vector_to_array(pca.b) + A = faiss.vector_to_array(pca.A).reshape(pca.d_out, pca.d_in) + return A, b + + +def make_LinearTransform_matrix(A, b=None): + """ make a linear transform from a matrix and a bias term (optional)""" + d_out, d_in = A.shape + if b is not None: + assert b.shape == (d_out, ) + lt = faiss.LinearTransform(d_in, d_out, b is not None) + faiss.copy_array_to_vector(A.ravel(), lt.A) + if b is not None: + faiss.copy_array_to_vector(b, lt.b) + lt.is_trained = True + lt.set_is_orthonormal() + return lt + + +def get_additive_quantizer_codebooks(aq): + """ return to codebooks of an additive quantizer """ + codebooks = faiss.vector_to_array(aq.codebooks).reshape(-1, aq.d) + co = faiss.vector_to_array(aq.codebook_offsets) + return [ + codebooks[co[i]:co[i + 1]] + for i in range(aq.M) + ] + + +def get_flat_data(index): + """ copy and return the data matrix in an IndexFlat """ + xb = faiss.vector_to_array(index.codes).view("float32") + return xb.reshape(index.ntotal, index.d) + + +def get_flat_codes(index_flat): + """ get the codes from an indexFlatCodes as an array """ + return faiss.vector_to_array(index_flat.codes).reshape( + index_flat.ntotal, index_flat.code_size) + + +def get_NSG_neighbors(nsg): + """ get the neighbor list for the vectors stored in the NSG structure, as + a N-by-K matrix of indices """ + graph = nsg.get_final_graph() + neighbors = np.zeros((graph.N, graph.K), dtype='int32') + faiss.memcpy( + faiss.swig_ptr(neighbors), + graph.data, + neighbors.nbytes + ) + return neighbors diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/ivf_tools.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/ivf_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..8d155f7c3b0664eb6603f420d1f23bdaf948c84b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/ivf_tools.py @@ -0,0 +1,148 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import faiss + +from faiss.contrib.inspect_tools import get_invlist_sizes + + +def add_preassigned(index_ivf, x, a, ids=None): + """ + Add elements to an IVF index, where the assignment is already computed + """ + n, d = x.shape + assert a.shape == (n, ) + if isinstance(index_ivf, faiss.IndexBinaryIVF): + d *= 8 + assert d == index_ivf.d + if ids is not None: + assert ids.shape == (n, ) + ids = faiss.swig_ptr(ids) + index_ivf.add_core( + n, faiss.swig_ptr(x), ids, faiss.swig_ptr(a) + ) + + +def search_preassigned(index_ivf, xq, k, list_nos, coarse_dis=None): + """ + Perform a search in the IVF index, with predefined lists to search into. + Supports indexes with pretransforms (as opposed to the + IndexIVF.search_preassigned, that cannot be applied with pretransform). + """ + if isinstance(index_ivf, faiss.IndexPreTransform): + assert index_ivf.chain.size() == 1, "chain must have only one component" + transform = faiss.downcast_VectorTransform(index_ivf.chain.at(0)) + xq = transform.apply(xq) + index_ivf = faiss.downcast_index(index_ivf.index) + n, d = xq.shape + if isinstance(index_ivf, faiss.IndexBinaryIVF): + d *= 8 + dis_type = "int32" + else: + dis_type = "float32" + + assert d == index_ivf.d + assert list_nos.shape == (n, index_ivf.nprobe) + + # the coarse distances are used in IVFPQ with L2 distance and + # by_residual=True otherwise we provide dummy coarse_dis + if coarse_dis is None: + coarse_dis = np.zeros((n, index_ivf.nprobe), dtype=dis_type) + else: + assert coarse_dis.shape == (n, index_ivf.nprobe) + + return index_ivf.search_preassigned(xq, k, list_nos, coarse_dis) + + +def range_search_preassigned(index_ivf, x, radius, list_nos, coarse_dis=None): + """ + Perform a range search in the IVF index, with predefined lists to + search into + """ + n, d = x.shape + if isinstance(index_ivf, faiss.IndexBinaryIVF): + d *= 8 + dis_type = "int32" + else: + dis_type = "float32" + + # the coarse distances are used in IVFPQ with L2 distance and + # by_residual=True otherwise we provide dummy coarse_dis + if coarse_dis is None: + coarse_dis = np.zeros((n, index_ivf.nprobe), dtype=dis_type) + else: + assert coarse_dis.shape == (n, index_ivf.nprobe) + + assert d == index_ivf.d + assert list_nos.shape == (n, index_ivf.nprobe) + + res = faiss.RangeSearchResult(n) + sp = faiss.swig_ptr + + index_ivf.range_search_preassigned_c( + n, sp(x), radius, + sp(list_nos), sp(coarse_dis), + res + ) + # get pointers and copy them + lims = faiss.rev_swig_ptr(res.lims, n + 1).copy() + num_results = int(lims[-1]) + dist = faiss.rev_swig_ptr(res.distances, num_results).copy() + indices = faiss.rev_swig_ptr(res.labels, num_results).copy() + return lims, dist, indices + + +def replace_ivf_quantizer(index_ivf, new_quantizer): + """ replace the IVF quantizer with a flat quantizer and return the + old quantizer""" + if new_quantizer.ntotal == 0: + centroids = index_ivf.quantizer.reconstruct_n() + new_quantizer.train(centroids) + new_quantizer.add(centroids) + else: + assert new_quantizer.ntotal == index_ivf.nlist + + # cleanly dealloc old quantizer + old_own = index_ivf.own_fields + index_ivf.own_fields = False + old_quantizer = faiss.downcast_index(index_ivf.quantizer) + old_quantizer.this.own(old_own) + index_ivf.quantizer = new_quantizer + + if hasattr(index_ivf, "referenced_objects"): + index_ivf.referenced_objects.append(new_quantizer) + else: + index_ivf.referenced_objects = [new_quantizer] + return old_quantizer + + +def permute_invlists(index_ivf, perm): + """ Apply some permutation to the inverted lists, and modify the quantizer + entries accordingly. + Perm is an array of size nlist, where old_index = perm[new_index] + """ + nlist, = perm.shape + assert index_ivf.nlist == nlist + quantizer = faiss.downcast_index(index_ivf.quantizer) + assert quantizer.ntotal == index_ivf.nlist + perm = np.ascontiguousarray(perm, dtype='int64') + + # just make sure it's a permutation... + bc = np.bincount(perm, minlength=nlist) + assert np.all(bc == np.ones(nlist, dtype=int)) + + # handle quantizer + quantizer.permute_entries(perm) + + # handle inverted lists + invlists = faiss.downcast_InvertedLists(index_ivf.invlists) + invlists.permute_invlists(faiss.swig_ptr(perm)) + + +def sort_invlists_by_size(index_ivf): + invlist_sizes = get_invlist_sizes(index_ivf.invlists) + perm = np.argsort(invlist_sizes) + permute_invlists(index_ivf, perm) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/ondisk.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/ondisk.py new file mode 100644 index 0000000000000000000000000000000000000000..41500911272a6c1d21e3038c327caa57d45be5df --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/ondisk.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import List +import faiss +import logging + +LOG = logging.getLogger(__name__) + + +def merge_ondisk( + trained_index: faiss.Index, shard_fnames: List[str], ivfdata_fname: str, shift_ids=False +) -> None: + """Add the contents of the indexes stored in shard_fnames into the index + trained_index. The on-disk data is stored in ivfdata_fname""" + assert not isinstance( + trained_index, faiss.IndexIVFPQR + ), "IndexIVFPQR is not supported as an on disk index." + # merge the images into an on-disk index + # first load the inverted lists + ivfs = [] + for fname in shard_fnames: + # the IO_FLAG_MMAP is to avoid actually loading the data thus + # the total size of the inverted lists can exceed the + # available RAM + LOG.info("read " + fname) + index = faiss.read_index(fname, faiss.IO_FLAG_MMAP) + index_ivf = faiss.extract_index_ivf(index) + ivfs.append(index_ivf.invlists) + + # avoid that the invlists get deallocated with the index + index_ivf.own_invlists = False + + # construct the output index + index = trained_index + index_ivf = faiss.extract_index_ivf(index) + + assert index.ntotal == 0, "works only on empty index" + + # prepare the output inverted lists. They will be written + # to merged_index.ivfdata + invlists = faiss.OnDiskInvertedLists( + index_ivf.nlist, index_ivf.code_size, ivfdata_fname + ) + + # merge all the inverted lists + ivf_vector = faiss.InvertedListsPtrVector() + for ivf in ivfs: + ivf_vector.push_back(ivf) + + LOG.info("merge %d inverted lists " % ivf_vector.size()) + ntotal = invlists.merge_from_multiple(ivf_vector.data(), ivf_vector.size(), shift_ids) + + # now replace the inverted lists in the output index + index.ntotal = index_ivf.ntotal = ntotal + index_ivf.replace_invlists(invlists, True) + invlists.this.disown() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/rpc.py b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/rpc.py new file mode 100644 index 0000000000000000000000000000000000000000..0ea9625c3265ebd8fd1a8804f4d2916b23124ee6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss/contrib/rpc.py @@ -0,0 +1,261 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Simplistic RPC implementation. +Exposes all functions of a Server object. + +This code is for demonstration purposes only, and does not include certain +security protections. It is not meant to be run on an untrusted network or +in a production environment. +""" + +import importlib +import os +import pickle +import sys +import _thread +import traceback +import socket +import logging + +LOG = logging.getLogger(__name__) + +# default +PORT = 12032 + +safe_modules = { + 'numpy', + 'numpy.core.multiarray', +} + + +class RestrictedUnpickler(pickle.Unpickler): + + def find_class(self, module, name): + # Only allow safe modules. + if module in safe_modules: + return getattr(importlib.import_module(module), name) + # Forbid everything else. + raise pickle.UnpicklingError("global '%s.%s' is forbidden" % + (module, name)) + + +class FileSock: + " wraps a socket so that it is usable by pickle/cPickle " + + def __init__(self,sock): + self.sock = sock + self.nr=0 + + def write(self, buf): + # print("sending %d bytes"%len(buf)) + #self.sock.sendall(buf) + # print("...done") + bs = 512 * 1024 + ns = 0 + while ns < len(buf): + sent = self.sock.send(buf[ns:ns + bs]) + ns += sent + + def read(self,bs=512*1024): + #if self.nr==10000: pdb.set_trace() + self.nr+=1 + # print("read bs=%d"%bs) + b = [] + nb = 0 + while len(b) 0: + buffer = vectors[start:].copy() + buffer_size = remainder + + if buffer is not None: + yield buffer diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/INSTALLER b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/METADATA b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..6d441355f034a7f7216f14b26cab5f225277d57b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/METADATA @@ -0,0 +1,124 @@ +Metadata-Version: 2.4 +Name: faiss-cpu +Version: 1.14.3 +Summary: A library for efficient similarity search and clustering of dense vectors. +Keywords: search,nearest-neighbors,clustering,vectors,similarity +Author: Meta AI Research +License-Expression: MIT +License-File: LICENSE +License-File: THIRD_PARTY_NOTICES +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Science/Research +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX :: Linux +Classifier: Programming Language :: C++ +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Project-URL: Homepage, https://github.com/facebookresearch/faiss +Project-URL: Documentation, https://github.com/facebookresearch/faiss/wiki +Project-URL: Repository, https://github.com/facebookresearch/faiss +Project-URL: Issues, https://github.com/facebookresearch/faiss/issues +Requires-Python: >=3.10 +Requires-Dist: numpy>=1.25 +Requires-Dist: packaging +Description-Content-Type: text/markdown + +# Faiss + +Faiss is a library for efficient similarity search and clustering of dense vectors. It contains algorithms that search in sets of vectors of any size, up to ones that possibly do not fit in RAM. It also contains supporting code for evaluation and parameter tuning. Faiss is written in C++ with complete wrappers for Python/numpy. Some of the most useful algorithms are implemented on the GPU. It is developed primarily at Meta's [Fundamental AI Research](https://ai.facebook.com/) group. + +## News + +See [CHANGELOG.md](CHANGELOG.md) for detailed information about latest features. + +## Introduction + +Faiss contains several methods for similarity search. It assumes that the instances are represented as vectors and are identified by an integer, and that the vectors can be compared with L2 (Euclidean) distances or dot products. Vectors that are similar to a query vector are those that have the lowest L2 distance or the highest dot product with the query vector. It also supports cosine similarity, since this is a dot product on normalized vectors. + +Some of the methods, like those based on binary vectors and compact quantization codes, solely use a compressed representation of the vectors and do not require to keep the original vectors. This generally comes at the cost of a less precise search but these methods can scale to billions of vectors in main memory on a single server. Other methods, like HNSW and NSG add an indexing structure on top of the raw vectors to make searching more efficient. + +The GPU implementation can accept input from either CPU or GPU memory. On a server with GPUs, the GPU indexes can be used a drop-in replacement for the CPU indexes (e.g., replace `IndexFlatL2` with `GpuIndexFlatL2`) and copies to/from GPU memory are handled automatically. Results will be faster however if both input and output remain resident on the GPU. Both single and multi-GPU usage is supported. + +## Installing + +Faiss comes with precompiled libraries for Anaconda in Python, see [faiss-cpu](https://anaconda.org/pytorch/faiss-cpu), [faiss-gpu](https://anaconda.org/pytorch/faiss-gpu) and [faiss-gpu-cuvs](https://anaconda.org/pytorch/faiss-gpu-cuvs). The library is mostly implemented in C++, the only dependency is a [BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) implementation. Optional GPU support is provided via CUDA or AMD ROCm, and the Python interface is also optional. The backend GPU implementations of NVIDIA [cuVS](https://github.com/rapidsai/cuvs) can also be enabled optionally. It compiles with cmake. See [INSTALL.md](INSTALL.md) for details. + +## How Faiss works + +Faiss is built around an index type that stores a set of vectors, and provides a function to search in them with L2 and/or dot product vector comparison. Some index types are simple baselines, such as exact search. Most of the available indexing structures correspond to various trade-offs with respect to + +- search time +- search quality +- memory used per index vector +- training time +- adding time +- need for external data for unsupervised training + +The optional GPU implementation provides what is likely (as of March 2017) the fastest exact and approximate (compressed-domain) nearest neighbor search implementation for high-dimensional vectors, fastest Lloyd's k-means, and fastest small k-selection algorithm known. [The implementation is detailed here](https://arxiv.org/abs/1702.08734). + +## Full documentation of Faiss + +The following are entry points for documentation: + +- the full documentation can be found on the [wiki page](https://github.com/facebookresearch/faiss/wiki), including a [tutorial](https://github.com/facebookresearch/faiss/wiki/Getting-started), a [FAQ](https://github.com/facebookresearch/faiss/wiki/FAQ) and a [troubleshooting section](https://github.com/facebookresearch/faiss/wiki/Troubleshooting) +- the [doxygen documentation](https://faiss.ai/) gives per-class information extracted from code comments +- to reproduce results from our research papers, [Polysemous codes](https://arxiv.org/abs/1609.01882) and [Billion-scale similarity search with GPUs](https://arxiv.org/abs/1702.08734), refer to the [benchmarks README](benchs/README.md). For [ +Link and code: Fast indexing with graphs and compact regression codes](https://arxiv.org/abs/1804.09996), see the [link_and_code README](benchs/link_and_code) + +## Authors + +The main authors of Faiss are: +- [Hervé Jégou](https://github.com/jegou) initiated the Faiss project and wrote its first implementation +- [Matthijs Douze](https://github.com/mdouze) implemented most of the CPU Faiss +- [Jeff Johnson](https://github.com/wickedfoo) implemented all of the GPU Faiss +- [Lucas Hosseini](https://github.com/beauby) implemented the binary indexes and the build system +- [Chengqi Deng](https://github.com/KinglittleQ) implemented NSG, NNdescent and much of the additive quantization code. +- [Alexandr Guzhva](https://github.com/alexanderguzhva) many optimizations: SIMD, memory allocation and layout, fast decoding kernels for vector codecs, etc. +- [Gergely Szilvasy](https://github.com/algoriddle) build system, benchmarking framework. + +## Reference + +References to cite when you use Faiss in a research paper: +``` +@article{douze2024faiss, + title={The Faiss library}, + author={Matthijs Douze and Alexandr Guzhva and Chengqi Deng and Jeff Johnson and Gergely Szilvasy and Pierre-Emmanuel Mazaré and Maria Lomeli and Lucas Hosseini and Hervé Jégou}, + year={2024}, + eprint={2401.08281}, + archivePrefix={arXiv}, + primaryClass={cs.LG} +} +``` +For the GPU version of Faiss, please cite: +``` +@article{johnson2019billion, + title={Billion-scale similarity search with {GPUs}}, + author={Johnson, Jeff and Douze, Matthijs and J{\'e}gou, Herv{\'e}}, + journal={IEEE Transactions on Big Data}, + volume={7}, + number={3}, + pages={535--547}, + year={2019}, + publisher={IEEE} +} +``` + +## Join the Faiss community + +For public discussion of Faiss or for questions, visit https://github.com/facebookresearch/faiss/discussions. + +We monitor the [issues page](https://github.com/facebookresearch/faiss/issues) of the repository. +You can report bugs, ask questions, etc. + +## Legal + +Faiss is MIT-licensed, refer to the [LICENSE file](https://github.com/facebookresearch/faiss/blob/main/LICENSE) in the top level directory. + +Copyright © Meta Platforms, Inc. diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/RECORD b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..81e9b37277104d6135dddfe159a827d21d929527 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/RECORD @@ -0,0 +1,39 @@ +faiss/__init__.py,sha256=b00ZjZQxoVaB7xSs7F-LGsdjjpKoNf-6TsebbVdb2eg,15852 +faiss/__init__.pyi,sha256=Qa7WJ9DBTMqTbEGT6Q_ApUJvA5IjOtNv9e0L3Wk5XJk,141474 +faiss/_swigfaiss.abi3.so,sha256=c3Fu7gF59JHuTlypqXQKitDt_GN4jqSEnUUdkR45hVo,6343033 +faiss/array_conversions.py,sha256=R2aNQIs0QXl8c4QBokiHqQYSFLHyAnJUjKHJOT2-JaQ,5779 +faiss/class_wrappers.py,sha256=06l2Oj2PCRMRq6vsIf-TK4s59ZxgpJPjBAz9kVMSTVg,54471 +faiss/extra_wrappers.py,sha256=LdmUnKqOIxK89l3fZV-9xKm0QV5aKKvcIpB5GhaOZyk,23168 +faiss/gpu_wrappers.py,sha256=r2XcE_WO_URnFVq01zPgHbyKhfRHFvlw7nlX6-eObc8,9196 +faiss/libfaiss.so,sha256=_M_GSE9kRb5W7XeuoTTflfnOXkziJVGg93MCKEJGn6w,15322617 +faiss/loader.py,sha256=aruLX7CmBXVYo_f-gfIOmXB0cI8s7PQwENS1dQik0z8,8035 +faiss/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +faiss/swigfaiss.py,sha256=dRj4m2PtNonWhEus0TuoGDXj4y5b8aKxrXnRNlubeu4,650107 +faiss/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +faiss/contrib/big_batch_search.py,sha256=Z8jiHtXx_ZjZEd9_0AImuPC2RT_SEjuYv_-0SoQ9FJE,17640 +faiss/contrib/client_server.py,sha256=kuqPNWADtVbR-0U_1Yf1YaJFZaDUaIM71Cb1PszEWSE,2773 +faiss/contrib/clustering.py,sha256=gOh1qLvHeg9sCpj560xf9pDHmjT6kxXNffKi4xFtCSU,15679 +faiss/contrib/datasets.py,sha256=-Y-bgYXkyFCOar-YI3hJYnK0EuLVd3lTCaD8XU9p5Kc,16414 +faiss/contrib/evaluation.py,sha256=lcMt-xWrqjSMFpc7obmI9NAFu0fl1vEsvpUU0tCSsk0,15002 +faiss/contrib/exhaustive_search.py,sha256=aZ9tgA3WswNcu0ORCl_Yj_RcN2qxgWbtc9W8_SyWKvM,12381 +faiss/contrib/factory_tools.py,sha256=s3psIASX0ssAEs4POdkna-1i8eFXakvn8zLLHJTnOJg,5379 +faiss/contrib/inspect_tools.py,sha256=adznxU6EFhVrBXuyyol5M-j5baUVlhJCOoz7cFDFVdQ,3749 +faiss/contrib/ivf_tools.py,sha256=L8zIjlLqjE630RGxv-iGmS9Map4ZarFmoP4mUCnAJBE,4874 +faiss/contrib/ondisk.py,sha256=o75LX2UDSVb0WaKWHKVwfVoXXmIGt-qblIMaVP3VRYQ,2069 +faiss/contrib/rpc.py,sha256=2uTBaGGf6dueh7yTbb1L30UoJMNC0zVXPFV2liiwUfE,7310 +faiss/contrib/torch_utils.py,sha256=Ni6cI29oEfW1ntjnIa-HG6CXwu8rhEO_FQ4sbEh4j58,29177 +faiss/contrib/vecs_io.py,sha256=hp1_SwLOEOZAWr2igEa6qJyVm2ZXuIf_gx6DTd5muSM,5439 +faiss/contrib/torch/README.md,sha256=cSZmWcQwJOW9UNYrLAUwW3QoIFwqlLTpVK_HL-Aekr8,212 +faiss/contrib/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +faiss/contrib/torch/clustering.py,sha256=CtM1XCSTgexM4-iCD1GXw9AWmZR1WWzMLWOy2tobz_4,1676 +faiss/contrib/torch/quantization.py,sha256=eAzTe4Dg4njItfe7VfKvtCwtfO5_Jfo_HS9RpE0DC74,2797 +faiss_cpu.libs/libgfortran-83c28eba.so.5.0.0,sha256=5VSHn-5-2oAFW2yhQHpU0ABQh0-DDMhrK_P1DfXHuys,2714697 +faiss_cpu.libs/libgomp-e985bcbb.so.1.0.0,sha256=pDkE5PopcwHUZA3BuzyKNIC0BvmeSY66mxkUtoqrYEo,253289 +faiss_cpu.libs/libopenblaso-r0-d77a1985.3.15.so,sha256=ODWntDKwTBPEY68sZaphbuv3_ALK3KJa1SJ9yvhG0uw,38700273 +faiss_cpu.libs/libquadmath-2284e583.so.0.0.0,sha256=qTB7uqNTYj-gFOi2gtUMRin15cfWHaqahlL30WXNQho,272193 +faiss_cpu-1.14.3.dist-info/METADATA,sha256=5o0tgI7S2gtoacVv52c5bKF3UN9RhU2jkxnDJ5lY9Fs,7785 +faiss_cpu-1.14.3.dist-info/WHEEL,sha256=hg7z7Me-dEZ0SHvjjdyugRyBrl5j-HfyAzvrIFMX014,155 +faiss_cpu-1.14.3.dist-info/RECORD,, +faiss_cpu-1.14.3.dist-info/licenses/LICENSE,sha256=UkEte8fOQVfqYou6rLiCngqcs8WPV_mRdhJryM8r_IU,1086 +faiss_cpu-1.14.3.dist-info/licenses/THIRD_PARTY_NOTICES,sha256=sHUkrWqCLt2GvR1HA6vIz9_pNBiGcNn1wslmdvVU5As,21831 +faiss_cpu-1.14.3.dist-info/sboms/auditwheel.cdx.json,sha256=fdent5LcjB8z3IpmKXMP5atwaxuOABYIbnobNwLX7Bk,3003 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/REQUESTED b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/WHEEL b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..a17cdaa186fe91207817b5f6d6ee5cef40611bfb --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: scikit-build-core 0.12.2 +Root-Is-Purelib: false +Tag: cp310-abi3-manylinux_2_27_x86_64 +Tag: cp310-abi3-manylinux_2_28_x86_64 + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/licenses/LICENSE b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b96dcb0480a0b0be0727976e5202a1e7b23edc3f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Facebook, Inc. and its affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/licenses/THIRD_PARTY_NOTICES b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/licenses/THIRD_PARTY_NOTICES new file mode 100644 index 0000000000000000000000000000000000000000..e06ba0bed2414859d992b5e0c92749f814a38618 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/licenses/THIRD_PARTY_NOTICES @@ -0,0 +1,410 @@ +Third-Party Notices for faiss pip wheels +======================================== + +The faiss pip wheels bundle the following third-party libraries as binary +dependencies. Their licenses are reproduced below. + + +1. OpenBLAS (Linux, Windows wheels) +------------------------------------------- + +Copyright (c) 2011-2014, The OpenBLAS Project +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + 3. Neither the name of the OpenBLAS project nor the names of + its contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +License: BSD-3-Clause +Source: https://github.com/OpenMathLib/OpenBLAS + + +2. LLVM OpenMP Runtime (libomp) (macOS wheels) +----------------------------------------------- + +============================================================================== +The LLVM Project is under the Apache License v2.0 with LLVM Exceptions: +============================================================================== + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +---- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. + +============================================================================== +Software from third parties included in the LLVM Project: +============================================================================== +The LLVM Project contains third party software which is under different license +terms. All such code will be identified clearly using at least one of two +mechanisms: +1) It will be in a separate directory tree with its own `LICENSE.txt` or + `LICENSE` file at the top containing the specific license and restrictions + which apply to that software, or +2) It will contain specific license and restriction terms at the top of every + file. + +============================================================================== +Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy): +============================================================================== + +The software contained in this directory tree is dual licensed under both the +University of Illinois "BSD-Like" license and the MIT license. As a user of +this code you may choose to use it under either license. As a contributor, +you agree to allow your code to be used under both. The full text of the +relevant licenses is included below. + +In addition, a license agreement from the copyright/patent holders of the +software contained in this directory tree is included below. + +============================================================================== + +University of Illinois/NCSA +Open Source License + +Copyright (c) 1997-2019 Intel Corporation + +All rights reserved. + +Developed by: + OpenMP Runtime Team + Intel Corporation + http://www.openmprtl.org + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal with +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimers. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimers in the + documentation and/or other materials provided with the distribution. + + * Neither the names of Intel Corporation OpenMP Runtime Team nor the + names of its contributors may be used to endorse or promote products + derived from this Software without specific prior written permission. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE +SOFTWARE. + +============================================================================== + +Copyright (c) 1997-2019 Intel Corporation + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +============================================================================== + +Intel Corporation + +Software Grant License Agreement ("Agreement") + +Except for the license granted herein to you, Intel Corporation ("Intel") reserves +all right, title, and interest in and to the Software (defined below). + +Definition + +"Software" means the code and documentation as well as any original work of +authorship, including any modifications or additions to an existing work, that +is intentionally submitted by Intel to llvm.org (http://llvm.org) ("LLVM") for +inclusion in, or documentation of, any of the products owned or managed by LLVM +(the "Work"). For the purposes of this definition, "submitted" means any form of +electronic, verbal, or written communication sent to LLVM or its +representatives, including but not limited to communication on electronic +mailing lists, source code control systems, and issue tracking systems that are +managed by, or on behalf of, LLVM for the purpose of discussing and improving +the Work, but excluding communication that is conspicuously marked otherwise. + +1. Grant of Copyright License. Subject to the terms and conditions of this + Agreement, Intel hereby grants to you and to recipients of the Software + distributed by LLVM a perpetual, worldwide, non-exclusive, no-charge, + royalty-free, irrevocable copyright license to reproduce, prepare derivative + works of, publicly display, publicly perform, sublicense, and distribute the + Software and such derivative works. + +2. Grant of Patent License. Subject to the terms and conditions of this + Agreement, Intel hereby grants you and to recipients of the Software + distributed by LLVM a perpetual, worldwide, non-exclusive, no-charge, + royalty-free, irrevocable (except as stated in this section) patent license + to make, have made, use, offer to sell, sell, import, and otherwise transfer + the Work, where such license applies only to those patent claims licensable + by Intel that are necessarily infringed by Intel's Software alone or by + combination of the Software with the Work to which such Software was + submitted. If any entity institutes patent litigation against Intel or any + other entity (including a cross-claim or counterclaim in a lawsuit) alleging + that Intel's Software, or the Work to which Intel has contributed constitutes + direct or contributory patent infringement, then any patent licenses granted + to that entity under this Agreement for the Software or Work shall terminate + as of the date such litigation is filed. + +Unless required by applicable law or agreed to in writing, the software is +provided on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, +either express or implied, including, without limitation, any warranties or +conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A +PARTICULAR PURPOSE. + +============================================================================== +License: Apache-2.0 WITH LLVM-exception +Source: https://github.com/llvm/llvm-project diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/sboms/auditwheel.cdx.json b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/sboms/auditwheel.cdx.json new file mode 100644 index 0000000000000000000000000000000000000000..ae94b8448c9ee3b30d3f31e3d886bfff7bb917f0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/faiss_cpu-1.14.3.dist-info/sboms/auditwheel.cdx.json @@ -0,0 +1 @@ +{"bomFormat": "CycloneDX", "specVersion": "1.4", "version": 1, "metadata": {"component": {"type": "library", "bom-ref": "pkg:pypi/faiss_cpu@1.14.3?file_name=faiss_cpu-1.14.3-cp310-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "name": "faiss_cpu", "version": "1.14.3", "purl": "pkg:pypi/faiss_cpu@1.14.3?file_name=faiss_cpu-1.14.3-cp310-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"}, "tools": [{"name": "auditwheel", "version": "6.6.0"}]}, "components": [{"type": "library", "bom-ref": "pkg:pypi/faiss_cpu@1.14.3?file_name=faiss_cpu-1.14.3-cp310-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "name": "faiss_cpu", "version": "1.14.3", "purl": "pkg:pypi/faiss_cpu@1.14.3?file_name=faiss_cpu-1.14.3-cp310-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/openblas-openmp@0.3.15-6.el8#413963a9629ce91dfc39c185fd83d1ea744ee2c043ab84d9d1b89deecc051ed4", "name": "openblas-openmp", "version": "0.3.15-6.el8", "purl": "pkg:rpm/almalinux/openblas-openmp@0.3.15-6.el8"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libgomp@8.5.0-28.el8_10.alma.1#c61017c9a24eb6e1e1a3cdc9becd004a6419cbda3d54b4848b98f240a4829571", "name": "libgomp", "version": "8.5.0-28.el8_10.alma.1", "purl": "pkg:rpm/almalinux/libgomp@8.5.0-28.el8_10.alma.1"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa", "name": "libquadmath", "version": "8.5.0-28.el8_10.alma.1", "purl": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650", "name": "libgfortran", "version": "8.5.0-28.el8_10.alma.1", "purl": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1"}], "dependencies": [{"ref": "pkg:pypi/faiss_cpu@1.14.3?file_name=faiss_cpu-1.14.3-cp310-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "dependsOn": ["pkg:rpm/almalinux/openblas-openmp@0.3.15-6.el8#413963a9629ce91dfc39c185fd83d1ea744ee2c043ab84d9d1b89deecc051ed4", "pkg:rpm/almalinux/libgomp@8.5.0-28.el8_10.alma.1#c61017c9a24eb6e1e1a3cdc9becd004a6419cbda3d54b4848b98f240a4829571", "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa", "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650"]}, {"ref": "pkg:rpm/almalinux/openblas-openmp@0.3.15-6.el8#413963a9629ce91dfc39c185fd83d1ea744ee2c043ab84d9d1b89deecc051ed4"}, {"ref": "pkg:rpm/almalinux/libgomp@8.5.0-28.el8_10.alma.1#c61017c9a24eb6e1e1a3cdc9becd004a6419cbda3d54b4848b98f240a4829571"}, {"ref": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa"}, {"ref": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650"}]} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/INSTALLER b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/METADATA b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..73a98cdf4d615e7683a10557daa7604e23a0c81c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/METADATA @@ -0,0 +1,27 @@ +Metadata-Version: 2.4 +Name: flatbuffers +Version: 25.12.19 +Summary: The FlatBuffers serialization format for Python +Home-page: https://google.github.io/flatbuffers/ +Author: Derek Bailey +Author-email: derekbailey@google.com +License: Apache 2.0 +Project-URL: Documentation, https://google.github.io/flatbuffers/ +Project-URL: Source, https://github.com/google/flatbuffers +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 3 +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: summary + +Python runtime library for use with the `Flatbuffers `_ serialization format. diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/RECORD b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..7ad7c6d19cb4f31d6060ecaa7ca3a38ba05e9681 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/RECORD @@ -0,0 +1,26 @@ +flatbuffers-25.12.19.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +flatbuffers-25.12.19.dist-info/METADATA,sha256=nzgjn5b6ohUipqratpEuHlYHCLvpyfaWoGeclAP6CJ4,1004 +flatbuffers-25.12.19.dist-info/RECORD,, +flatbuffers-25.12.19.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +flatbuffers-25.12.19.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109 +flatbuffers-25.12.19.dist-info/top_level.txt,sha256=UXVWLA8ys6HeqTz6rfKesocUq6ln-ZL8mhZC_cq5BEc,12 +flatbuffers/__init__.py,sha256=vJZrqZOOTKdBNMa_iTKUA6WJG_c_NzKGpFXOe1Igtiw,751 +flatbuffers/__pycache__/__init__.cpython-311.pyc,, +flatbuffers/__pycache__/_version.cpython-311.pyc,, +flatbuffers/__pycache__/builder.cpython-311.pyc,, +flatbuffers/__pycache__/compat.cpython-311.pyc,, +flatbuffers/__pycache__/encode.cpython-311.pyc,, +flatbuffers/__pycache__/flexbuffers.cpython-311.pyc,, +flatbuffers/__pycache__/number_types.cpython-311.pyc,, +flatbuffers/__pycache__/packer.cpython-311.pyc,, +flatbuffers/__pycache__/table.cpython-311.pyc,, +flatbuffers/__pycache__/util.cpython-311.pyc,, +flatbuffers/_version.py,sha256=sk31rbYWDseoJxI9YQ1fYR-MMxRATyqsntKAEv7D7pI,696 +flatbuffers/builder.py,sha256=HrG5KJ9rasiSTrMGeatkSdDs7fXV5fy_927Dsgakp4A,24567 +flatbuffers/compat.py,sha256=ihBSpWDCSL-vgLSyZtcu8LX3ZI3wz9LhtqItY2GQZgg,2373 +flatbuffers/encode.py,sha256=2Or3mgWRAkJiWg-GgYasDU4zIHpQU3W06fmIhwbz5uM,1550 +flatbuffers/flexbuffers.py,sha256=yF8Wr4Lo8WJb-pj9NNaIYxLwzlHHyTroM0iO8fyDwbU,44454 +flatbuffers/number_types.py,sha256=ijO0QcJiuxlQegoBOed0v9m0DdzTZHWxpTBZUqzsWHA,3762 +flatbuffers/packer.py,sha256=LNWym8YgFRqHjcPeGpYY3inCGWH6XnbkQKtAPtFEVas,1164 +flatbuffers/table.py,sha256=ciYTmq_CzAuYpb3KAVnl75M84ieChfbyKne-dFHzwwU,4818 +flatbuffers/util.py,sha256=mRVQ1VoHp0MJMNtRTUGVzALwN4T_C-U14tMbj99py2A,1608 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/REQUESTED b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/WHEEL b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..5f133dbb5cfac001f2e84cda817210c03ce6484e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/top_level.txt b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..adf11d699fe6f5f0b219167916d0bff2cb34afeb --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers-25.12.19.dist-info/top_level.txt @@ -0,0 +1 @@ +flatbuffers diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..55ef9377c7ff773b1d84cc1d142ca3b85f0bf85c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2014 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from . import util +from ._version import __version__ +from .builder import Builder +from .compat import range_func as compat_range +from .table import Table diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/_version.py b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/_version.py new file mode 100644 index 0000000000000000000000000000000000000000..a391bf883b83aaac17fb0ac9abde37970d695c8d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/_version.py @@ -0,0 +1,17 @@ +# Copyright 2019 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Placeholder, to be updated during the release process +# by the setup.py +__version__ = "25.12.19" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/builder.py b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..05afabb693c5106e3586cce48a0fc337c9786f10 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/builder.py @@ -0,0 +1,858 @@ +# Copyright 2014 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import warnings + +from . import compat +from . import encode +from . import number_types as N +from . import packer +from .compat import memoryview_type +from .compat import NumpyRequiredForThisFeature, import_numpy +from .compat import range_func +from .number_types import (SOffsetTFlags, UOffsetTFlags, VOffsetTFlags) + +np = import_numpy() +## @file +## @addtogroup flatbuffers_python_api +## @{ + + +## @cond FLATBUFFERS_INTERNAL +class OffsetArithmeticError(RuntimeError): + """Error caused by an Offset arithmetic error. + + Probably caused by bad writing of fields. This is considered an unreachable + situation in normal circumstances. + """ + + pass + + +class IsNotNestedError(RuntimeError): + """Error caused by using a Builder to write Object data when not inside + + an Object. + """ + + pass + + +class IsNestedError(RuntimeError): + """Error caused by using a Builder to begin an Object when an Object is + + already being built. + """ + + pass + + +class StructIsNotInlineError(RuntimeError): + """Error caused by using a Builder to write a Struct at a location that + + is not the current Offset. + """ + + pass + + +class BuilderSizeError(RuntimeError): + """Error caused by causing a Builder to exceed the hardcoded limit of 2 + + gigabytes. + """ + + pass + + +class BuilderNotFinishedError(RuntimeError): + """Error caused by not calling `Finish` before calling `Output`.""" + + pass + + +class EndVectorLengthMismatched(RuntimeError): + """The number of elements passed to EndVector does not match the number + + specified in StartVector. + """ + + pass + + +# VtableMetadataFields is the count of metadata fields in each vtable. +VtableMetadataFields = 2 +## @endcond + + +class Builder(object): + """A Builder is used to construct one or more FlatBuffers. + + Typically, Builder objects will be used from code generated by the `flatc` + compiler. + + A Builder constructs byte buffers in a last-first manner for simplicity and + performance during reading. + + Internally, a Builder is a state machine for creating FlatBuffer objects. + + It holds the following internal state: + - Bytes: an array of bytes. + - current_vtable: a list of integers. + - vtables: a hash of vtable entries. + + Attributes: + Bytes: The internal `bytearray` for the Builder. + finished: A boolean determining if the Builder has been finalized. + """ + + ## @cond FLATBUFFERS_INTENRAL + __slots__ = ( + "Bytes", + "current_vtable", + "head", + "minalign", + "objectEnd", + "vtables", + "nested", + "forceDefaults", + "finished", + "vectorNumElems", + "sharedStrings", + ) + + """Maximum buffer size constant, in bytes. + + Builder will never allow it's buffer grow over this size. + Currently equals 2Gb. + """ + MAX_BUFFER_SIZE = 2**31 + ## @endcond + + def __init__(self, initialSize=1024): + """Initializes a Builder of size `initial_size`. + + The internal buffer is grown as needed. + """ + + if not (0 <= initialSize <= Builder.MAX_BUFFER_SIZE): + msg = "flatbuffers: Cannot create Builder larger than 2 gigabytes." + raise BuilderSizeError(msg) + + self.Bytes = bytearray(initialSize) + ## @cond FLATBUFFERS_INTERNAL + self.current_vtable = None + self.head = UOffsetTFlags.py_type(initialSize) + self.minalign = 1 + self.objectEnd = None + self.vtables = {} + self.nested = False + self.forceDefaults = False + self.sharedStrings = None + ## @endcond + self.finished = False + + def Clear(self): + ## @cond FLATBUFFERS_INTERNAL + self.current_vtable = None + self.head = len(self.Bytes) + self.minalign = 1 + self.objectEnd = None + self.vtables = {} + self.nested = False + self.forceDefaults = False + self.sharedStrings = None + self.vectorNumElems = None + ## @endcond + self.finished = False + + def Output(self): + """Return the portion of the buffer that has been used for writing data. + + This is the typical way to access the FlatBuffer data inside the + builder. If you try to access `Builder.Bytes` directly, you would need + to manually index it with `Head()`, since the buffer is constructed + backwards. + + It raises BuilderNotFinishedError if the buffer has not been finished + with `Finish`. + """ + + if not self.finished: + raise BuilderNotFinishedError() + + return self.Bytes[self.head :] + + ## @cond FLATBUFFERS_INTERNAL + def StartObject(self, numfields): + """StartObject initializes bookkeeping for writing a new object.""" + + self.assertNotNested() + + # use 32-bit offsets so that arithmetic doesn't overflow. + self.current_vtable = [0] * numfields + self.objectEnd = self.Offset() + self.nested = True + + def WriteVtable(self): + """WriteVtable serializes the vtable for the current object, if needed. + + Before writing out the vtable, this checks pre-existing vtables for + equality to this one. If an equal vtable is found, point the object to + the existing vtable and return. + + Because vtable values are sensitive to alignment of object data, not + all logically-equal vtables will be deduplicated. + + A vtable has the following format: + + + * N, where N is the number of fields + in the schema for this type. Includes deprecated fields. + Thus, a vtable is made of 2 + N elements, each VOffsetT bytes wide. + + An object has the following format: + + + + """ + + # Prepend a zero scalar to the object. Later in this function we'll + # write an offset here that points to the object's vtable: + self.PrependSOffsetTRelative(0) + + objectOffset = self.Offset() + + vtKey = [] + trim = True + for elem in reversed(self.current_vtable): + if elem == 0: + if trim: + continue + else: + elem = objectOffset - elem + trim = False + + vtKey.append(elem) + + objectSize = UOffsetTFlags.py_type(objectOffset - self.objectEnd) + vtKey.append(objectSize) + vtKey = tuple(vtKey) + # calculate the size of the object + vt2Offset = self.vtables.get(vtKey) + if vt2Offset is None: + # Did not find a vtable, so write this one to the buffer. + + # Write out the current vtable in reverse , because + # serialization occurs in last-first order: + i = len(self.current_vtable) - 1 + trailing = 0 + trim = True + while i >= 0: + off = 0 + elem = self.current_vtable[i] + i -= 1 + + if elem == 0: + if trim: + trailing += 1 + continue + else: + # Forward reference to field; + # use 32bit number to ensure no overflow: + off = objectOffset - elem + trim = False + + self.PrependVOffsetT(off) + + # The two metadata fields are written last. + + # First, store the object bytesize: + self.PrependVOffsetT(VOffsetTFlags.py_type(objectSize)) + + # Second, store the vtable bytesize: + vBytes = len(self.current_vtable) - trailing + VtableMetadataFields + vBytes *= N.VOffsetTFlags.bytewidth + self.PrependVOffsetT(VOffsetTFlags.py_type(vBytes)) + + # Next, write the offset to the new vtable in the + # already-allocated SOffsetT at the beginning of this object: + objectStart = SOffsetTFlags.py_type(len(self.Bytes) - objectOffset) + encode.Write( + packer.soffset, + self.Bytes, + objectStart, + SOffsetTFlags.py_type(self.Offset() - objectOffset), + ) + + # Finally, store this vtable in memory for future + # deduplication: + self.vtables[vtKey] = self.Offset() + else: + # Found a duplicate vtable. + objectStart = SOffsetTFlags.py_type(len(self.Bytes) - objectOffset) + self.head = UOffsetTFlags.py_type(objectStart) + + # Write the offset to the found vtable in the + # already-allocated SOffsetT at the beginning of this object: + encode.Write( + packer.soffset, + self.Bytes, + self.Head(), + SOffsetTFlags.py_type(vt2Offset - objectOffset), + ) + + self.current_vtable = None + return objectOffset + + def EndObject(self): + """EndObject writes data necessary to finish object construction.""" + self.assertNested() + self.nested = False + return self.WriteVtable() + + def GrowByteBuffer(self): + """Doubles the size of the byteslice, and copies the old data towards + + the end of the new buffer (since we build the buffer backwards). + """ + if len(self.Bytes) == Builder.MAX_BUFFER_SIZE: + msg = "flatbuffers: cannot grow buffer beyond 2 gigabytes" + raise BuilderSizeError(msg) + + newSize = min(len(self.Bytes) * 2, Builder.MAX_BUFFER_SIZE) + if newSize == 0: + newSize = 1 + bytes2 = bytearray(newSize) + bytes2[newSize - len(self.Bytes) :] = self.Bytes + self.Bytes = bytes2 + + ## @endcond + + def Head(self): + """Get the start of useful data in the underlying byte buffer. + + Note: unlike other functions, this value is interpreted as from the + left. + """ + ## @cond FLATBUFFERS_INTERNAL + return self.head + ## @endcond + + ## @cond FLATBUFFERS_INTERNAL + def Offset(self): + """Offset relative to the end of the buffer.""" + return len(self.Bytes) - self.head + + def Pad(self, n): + """Pad places zeros at the current offset.""" + if n <= 0: + return + new_head = self.head - n + self.Bytes[new_head : self.head] = b"\x00" * n + self.head = new_head + + def Prep(self, size, additionalBytes): + """Prep prepares to write an element of `size` after `additional_bytes` + + have been written, e.g. if you write a string, you need to align + such the int length field is aligned to SizeInt32, and the string + data follows it directly. + If all you need to do is align, `additionalBytes` will be 0. + """ + + # Track the biggest thing we've ever aligned to. + if size > self.minalign: + self.minalign = size + + # Find the amount of alignment needed such that `size` is properly + # aligned after `additionalBytes`: + head = self.head + buf_len = len(self.Bytes) + alignSize = (~(buf_len - head + additionalBytes)) + 1 + alignSize &= size - 1 + + # Reallocate the buffer if needed: + needed = alignSize + size + additionalBytes + while head < needed: + oldBufSize = buf_len + self.GrowByteBuffer() + buf_len = len(self.Bytes) + head += buf_len - oldBufSize + self.head = head + self.Pad(alignSize) + + def PrependSOffsetTRelative(self, off): + """PrependSOffsetTRelative prepends an SOffsetT, relative to where it + + will be written. + """ + + # Ensure alignment is already done: + self.Prep(N.SOffsetTFlags.bytewidth, 0) + if not (off <= self.Offset()): + msg = "flatbuffers: Offset arithmetic error." + raise OffsetArithmeticError(msg) + off2 = self.Offset() - off + N.SOffsetTFlags.bytewidth + self.PlaceSOffsetT(off2) + + ## @endcond + + def PrependUOffsetTRelative(self, off): + """Prepends an unsigned offset into vector data, relative to where it + + will be written. + """ + + # Ensure alignment is already done: + self.Prep(N.UOffsetTFlags.bytewidth, 0) + if not (off <= self.Offset()): + msg = "flatbuffers: Offset arithmetic error." + raise OffsetArithmeticError(msg) + off2 = self.Offset() - off + N.UOffsetTFlags.bytewidth + self.PlaceUOffsetT(off2) + + ## @cond FLATBUFFERS_INTERNAL + def StartVector(self, elemSize, numElems, alignment): + """StartVector initializes bookkeeping for writing a new vector. + + A vector has the following format: + - + - +, where T is the type of elements of this vector. + """ + + self.assertNotNested() + self.nested = True + self.vectorNumElems = numElems + self.Prep(N.Uint32Flags.bytewidth, elemSize * numElems) + self.Prep(alignment, elemSize * numElems) # In case alignment > int. + return self.Offset() + + ## @endcond + + def EndVector(self, numElems=None): + """EndVector writes data necessary to finish vector construction.""" + + self.assertNested() + ## @cond FLATBUFFERS_INTERNAL + self.nested = False + ## @endcond + + if numElems: + warnings.warn("numElems is deprecated.", DeprecationWarning, stacklevel=2) + if numElems != self.vectorNumElems: + raise EndVectorLengthMismatched() + + # we already made space for this, so write without PrependUint32 + self.PlaceUOffsetT(self.vectorNumElems) + self.vectorNumElems = None + return self.Offset() + + def CreateSharedString(self, s, encoding="utf-8", errors="strict"): + """CreateSharedString checks if the string is already written to the buffer + + before calling CreateString. + """ + + if not self.sharedStrings: + self.sharedStrings = {} + elif s in self.sharedStrings: + return self.sharedStrings[s] + + off = self.CreateString(s, encoding, errors) + self.sharedStrings[s] = off + + return off + + def CreateString(self, s, encoding="utf-8", errors="strict"): + """CreateString writes a null-terminated byte string as a vector.""" + + self.assertNotNested() + ## @cond FLATBUFFERS_INTERNAL + self.nested = True + ## @endcond + + if isinstance(s, compat.string_types): + x = s.encode(encoding, errors) + elif isinstance(s, compat.binary_types): + x = s + else: + raise TypeError("non-string passed to CreateString") + + payload_len = len(x) + self.Prep(N.UOffsetTFlags.bytewidth, (payload_len + 1) * N.Uint8Flags.bytewidth) + self.Place(0, N.Uint8Flags) + + new_head = self.head - payload_len + self.head = new_head + self.Bytes[new_head : new_head + payload_len] = x + + self.vectorNumElems = payload_len + return self.EndVector() + + def CreateByteVector(self, x): + """CreateString writes a byte vector.""" + + self.assertNotNested() + ## @cond FLATBUFFERS_INTERNAL + self.nested = True + ## @endcond + + if not isinstance(x, compat.binary_types): + raise TypeError("non-byte vector passed to CreateByteVector") + + data_len = len(x) + self.Prep(N.UOffsetTFlags.bytewidth, data_len * N.Uint8Flags.bytewidth) + new_head = self.head - data_len + self.head = new_head + self.Bytes[new_head : new_head + data_len] = x + + self.vectorNumElems = data_len + return self.EndVector() + + def CreateNumpyVector(self, x): + """CreateNumpyVector writes a numpy array into the buffer.""" + + if np is None: + # Numpy is required for this feature + raise NumpyRequiredForThisFeature("Numpy was not found.") + + if not isinstance(x, np.ndarray): + raise TypeError("non-numpy-ndarray passed to CreateNumpyVector") + + if x.dtype.kind not in ["b", "i", "u", "f"]: + raise TypeError("numpy-ndarray holds elements of unsupported datatype") + + if x.ndim > 1: + raise TypeError("multidimensional-ndarray passed to CreateNumpyVector") + + self.StartVector(x.itemsize, x.size, x.dtype.alignment) + + # Ensure little endian byte ordering + if x.dtype.str[0] == "<": + x_lend = x + else: + x_lend = x.byteswap(inplace=False) + + # tobytes ensures c_contiguous ordering + payload = x_lend.tobytes(order="C") + + # Calculate total length + payload_len = len(payload) + new_head = self.head - payload_len + self.head = new_head + self.Bytes[new_head : new_head + payload_len] = payload + + self.vectorNumElems = x.size + return self.EndVector() + + ## @cond FLATBUFFERS_INTERNAL + def assertNested(self): + """Check that we are in the process of building an object.""" + + if not self.nested: + raise IsNotNestedError() + + def assertNotNested(self): + """Check that no other objects are being built while making this object. + + If not, raise an exception. + """ + + if self.nested: + raise IsNestedError() + + def assertStructIsInline(self, obj): + """Structs are always stored inline, so need to be created right + + where they are used. You'll get this error if you created it + elsewhere. + """ + + N.enforce_number(obj, N.UOffsetTFlags) + if obj != self.Offset(): + msg = ( + "flatbuffers: Tried to write a Struct at an Offset that " + "is different from the current Offset of the Builder." + ) + raise StructIsNotInlineError(msg) + + def Slot(self, slotnum): + """Slot sets the vtable key `voffset` to the current location in the + + buffer. + """ + self.assertNested() + self.current_vtable[slotnum] = self.Offset() + + ## @endcond + + def __Finish(self, rootTable, sizePrefix, file_identifier=None): + """Finish finalizes a buffer, pointing to the given `rootTable`.""" + N.enforce_number(rootTable, N.UOffsetTFlags) + + prepSize = N.UOffsetTFlags.bytewidth + if file_identifier is not None: + prepSize += N.Int32Flags.bytewidth + if sizePrefix: + prepSize += N.Int32Flags.bytewidth + self.Prep(self.minalign, prepSize) + + if file_identifier is not None: + self.Prep(N.UOffsetTFlags.bytewidth, encode.FILE_IDENTIFIER_LENGTH) + + # Convert bytes object file_identifier to an array of 4 8-bit integers, + # and use big-endian to enforce size compliance. + # https://docs.python.org/2/library/struct.html#format-characters + file_identifier = N.struct.unpack(">BBBB", file_identifier) + for i in range(encode.FILE_IDENTIFIER_LENGTH - 1, -1, -1): + # Place the bytes of the file_identifer in reverse order: + self.Place(file_identifier[i], N.Uint8Flags) + + self.PrependUOffsetTRelative(rootTable) + if sizePrefix: + size = len(self.Bytes) - self.head + N.enforce_number(size, N.Int32Flags) + self.PrependInt32(size) + self.finished = True + return self.head + + def Finish(self, rootTable, file_identifier=None): + """Finish finalizes a buffer, pointing to the given `rootTable`.""" + return self.__Finish(rootTable, False, file_identifier=file_identifier) + + def FinishSizePrefixed(self, rootTable, file_identifier=None): + """Finish finalizes a buffer, pointing to the given `rootTable`, + + with the size prefixed. + """ + return self.__Finish(rootTable, True, file_identifier=file_identifier) + + ## @cond FLATBUFFERS_INTERNAL + def Prepend(self, flags, off): + self.Prep(flags.bytewidth, 0) + self.Place(off, flags) + + def PrependSlot(self, flags, o, x, d): + if x is not None: + N.enforce_number(x, flags) + if d is not None: + N.enforce_number(d, flags) + if x != d or (self.forceDefaults and d is not None): + self.Prepend(flags, x) + self.Slot(o) + + def PrependBoolSlot(self, *args): + self.PrependSlot(N.BoolFlags, *args) + + def PrependByteSlot(self, *args): + self.PrependSlot(N.Uint8Flags, *args) + + def PrependUint8Slot(self, *args): + self.PrependSlot(N.Uint8Flags, *args) + + def PrependUint16Slot(self, *args): + self.PrependSlot(N.Uint16Flags, *args) + + def PrependUint32Slot(self, *args): + self.PrependSlot(N.Uint32Flags, *args) + + def PrependUint64Slot(self, *args): + self.PrependSlot(N.Uint64Flags, *args) + + def PrependInt8Slot(self, *args): + self.PrependSlot(N.Int8Flags, *args) + + def PrependInt16Slot(self, *args): + self.PrependSlot(N.Int16Flags, *args) + + def PrependInt32Slot(self, *args): + self.PrependSlot(N.Int32Flags, *args) + + def PrependInt64Slot(self, *args): + self.PrependSlot(N.Int64Flags, *args) + + def PrependFloat32Slot(self, *args): + self.PrependSlot(N.Float32Flags, *args) + + def PrependFloat64Slot(self, *args): + self.PrependSlot(N.Float64Flags, *args) + + def PrependUOffsetTRelativeSlot(self, o, x, d): + """PrependUOffsetTRelativeSlot prepends an UOffsetT onto the object at + + vtable slot `o`. If value `x` equals default `d`, then the slot will + be set to zero and no other data will be written. + """ + + if x != d or self.forceDefaults: + self.PrependUOffsetTRelative(x) + self.Slot(o) + + def PrependStructSlot(self, v, x, d): + """PrependStructSlot prepends a struct onto the object at vtable slot `o`. + + Structs are stored inline, so nothing additional is being added. In + generated code, `d` is always 0. + """ + + N.enforce_number(d, N.UOffsetTFlags) + if x != d: + self.assertStructIsInline(x) + self.Slot(v) + + ## @endcond + + def PrependBool(self, x): + """Prepend a `bool` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.BoolFlags, x) + + def PrependByte(self, x): + """Prepend a `byte` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Uint8Flags, x) + + def PrependUint8(self, x): + """Prepend an `uint8` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Uint8Flags, x) + + def PrependUint16(self, x): + """Prepend an `uint16` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Uint16Flags, x) + + def PrependUint32(self, x): + """Prepend an `uint32` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Uint32Flags, x) + + def PrependUint64(self, x): + """Prepend an `uint64` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Uint64Flags, x) + + def PrependInt8(self, x): + """Prepend an `int8` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Int8Flags, x) + + def PrependInt16(self, x): + """Prepend an `int16` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Int16Flags, x) + + def PrependInt32(self, x): + """Prepend an `int32` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Int32Flags, x) + + def PrependInt64(self, x): + """Prepend an `int64` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Int64Flags, x) + + def PrependFloat32(self, x): + """Prepend a `float32` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Float32Flags, x) + + def PrependFloat64(self, x): + """Prepend a `float64` to the Builder buffer. + + Note: aligns and checks for space. + """ + self.Prepend(N.Float64Flags, x) + + def ForceDefaults(self, forceDefaults): + """In order to save space, fields that are set to their default value + + don't get serialized into the buffer. Forcing defaults provides a + way to manually disable this optimization. When set to `True`, will + always serialize default values. + """ + self.forceDefaults = forceDefaults + + ############################################################## + + ## @cond FLATBUFFERS_INTERNAL + def PrependVOffsetT(self, x): + self.Prepend(N.VOffsetTFlags, x) + + def Place(self, x, flags): + """Place prepends a value specified by `flags` to the Builder, + + without checking for available space. + """ + + N.enforce_number(x, flags) + new_head = self.head - flags.bytewidth + self.head = new_head + encode.Write(flags.packer_type, self.Bytes, new_head, x) + + def PlaceVOffsetT(self, x): + """PlaceVOffsetT prepends a VOffsetT to the Builder, without checking + + for space. + """ + N.enforce_number(x, N.VOffsetTFlags) + new_head = self.head - N.VOffsetTFlags.bytewidth + self.head = new_head + encode.Write(packer.voffset, self.Bytes, new_head, x) + + def PlaceSOffsetT(self, x): + """PlaceSOffsetT prepends a SOffsetT to the Builder, without checking + + for space. + """ + N.enforce_number(x, N.SOffsetTFlags) + new_head = self.head - N.SOffsetTFlags.bytewidth + self.head = new_head + encode.Write(packer.soffset, self.Bytes, new_head, x) + + def PlaceUOffsetT(self, x): + """PlaceUOffsetT prepends a UOffsetT to the Builder, without checking + + for space. + """ + N.enforce_number(x, N.UOffsetTFlags) + new_head = self.head - N.UOffsetTFlags.bytewidth + self.head = new_head + encode.Write(packer.uoffset, self.Bytes, new_head, x) + + ## @endcond + +## @} diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/compat.py b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/compat.py new file mode 100644 index 0000000000000000000000000000000000000000..5668ad70f6dc814d60f8393d90729538851981bc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/compat.py @@ -0,0 +1,91 @@ +# Copyright 2016 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""A tiny version of `six` to help with backwards compability. + +Also includes compatibility helpers for numpy. +""" + +import sys + +PY2 = sys.version_info[0] == 2 +PY26 = sys.version_info[0:2] == (2, 6) +PY27 = sys.version_info[0:2] == (2, 7) +PY275 = sys.version_info[0:3] >= (2, 7, 5) +PY3 = sys.version_info[0] == 3 +PY34 = sys.version_info[0:2] >= (3, 4) + +if PY3: + import importlib.machinery + + string_types = (str,) + binary_types = (bytes, bytearray) + range_func = range + memoryview_type = memoryview + struct_bool_decl = "?" +else: + import imp + + string_types = (unicode,) + if PY26 or PY27: + binary_types = (str, bytearray) + else: + binary_types = (str,) + range_func = xrange + if PY26 or (PY27 and not PY275): + memoryview_type = buffer + struct_bool_decl = "= 0 + + if value < (1 << 8): + return BitWidth.W8 + elif value < (1 << 16): + return BitWidth.W16 + elif value < (1 << 32): + return BitWidth.W32 + elif value < (1 << 64): + return BitWidth.W64 + else: + raise ValueError('value is too big to encode: %s' % value) + + @staticmethod + def I(value): + """Returns the minimum `BitWidth` to encode signed integer value.""" + # -2^(n-1) <= value < 2^(n-1) + # -2^n <= 2 * value < 2^n + # 2 * value < 2^n, when value >= 0 or 2 * (-value) <= 2^n, when value < 0 + # 2 * value < 2^n, when value >= 0 or 2 * (-value) - 1 < 2^n, when value < 0 + # + # if value >= 0: + # return BitWidth.U(2 * value) + # else: + # return BitWidth.U(2 * (-value) - 1) # ~x = -x - 1 + value *= 2 + return BitWidth.U(value if value >= 0 else ~value) + + @staticmethod + def F(value): + """Returns the `BitWidth` to encode floating point value.""" + if struct.unpack(' 0: + i = first + step = count // 2 + i += step + if pred(values[i], value): + i += 1 + first = i + count -= step + 1 + else: + count = step + return first + + +# https://en.cppreference.com/w/cpp/algorithm/binary_search +def _BinarySearch(values, value, pred=lambda x, y: x < y): + """Implementation of C++ std::binary_search() algorithm.""" + index = _LowerBound(values, value, pred) + if index != len(values) and not pred(value, values[index]): + return index + return -1 + + +class Type(enum.IntEnum): + """Supported types of encoded data. + + These are used as the upper 6 bits of a type field to indicate the actual + type. + """ + + NULL = 0 + INT = 1 + UINT = 2 + FLOAT = 3 + # Types above stored inline, types below store an offset. + KEY = 4 + STRING = 5 + INDIRECT_INT = 6 + INDIRECT_UINT = 7 + INDIRECT_FLOAT = 8 + MAP = 9 + VECTOR = 10 # Untyped. + + VECTOR_INT = 11 # Typed any size (stores no type table). + VECTOR_UINT = 12 + VECTOR_FLOAT = 13 + VECTOR_KEY = 14 + # DEPRECATED, use VECTOR or VECTOR_KEY instead. + # Read test.cpp/FlexBuffersDeprecatedTest() for details on why. + VECTOR_STRING_DEPRECATED = 15 + + VECTOR_INT2 = 16 # Typed tuple (no type table, no size field). + VECTOR_UINT2 = 17 + VECTOR_FLOAT2 = 18 + VECTOR_INT3 = 19 # Typed triple (no type table, no size field). + VECTOR_UINT3 = 20 + VECTOR_FLOAT3 = 21 + VECTOR_INT4 = 22 # Typed quad (no type table, no size field). + VECTOR_UINT4 = 23 + VECTOR_FLOAT4 = 24 + + BLOB = 25 + BOOL = 26 + VECTOR_BOOL = 36 # To do the same type of conversion of type to vector type + + @staticmethod + def Pack(type_, bit_width): + return (int(type_) << 2) | bit_width + + @staticmethod + def Unpack(packed_type): + return 1 << (packed_type & 0b11), Type(packed_type >> 2) + + @staticmethod + def IsInline(type_): + return type_ <= Type.FLOAT or type_ == Type.BOOL + + @staticmethod + def IsTypedVector(type_): + return ( + Type.VECTOR_INT <= type_ <= Type.VECTOR_STRING_DEPRECATED + or type_ == Type.VECTOR_BOOL + ) + + @staticmethod + def IsTypedVectorElementType(type_): + return Type.INT <= type_ <= Type.STRING or type_ == Type.BOOL + + @staticmethod + def ToTypedVectorElementType(type_): + if not Type.IsTypedVector(type_): + raise ValueError('must be typed vector type') + + return Type(type_ - Type.VECTOR_INT + Type.INT) + + @staticmethod + def IsFixedTypedVector(type_): + return Type.VECTOR_INT2 <= type_ <= Type.VECTOR_FLOAT4 + + @staticmethod + def IsFixedTypedVectorElementType(type_): + return Type.INT <= type_ <= Type.FLOAT + + @staticmethod + def ToFixedTypedVectorElementType(type_): + if not Type.IsFixedTypedVector(type_): + raise ValueError('must be fixed typed vector type') + + # 3 types each, starting from length 2. + fixed_type = type_ - Type.VECTOR_INT2 + return Type(fixed_type % 3 + Type.INT), fixed_type // 3 + 2 + + @staticmethod + def ToTypedVector(element_type, fixed_len=0): + """Converts element type to corresponding vector type. + + Args: + element_type: vector element type + fixed_len: number of elements: 0 for typed vector; 2, 3, or 4 for fixed + typed vector. + + Returns: + Typed vector type or fixed typed vector type. + """ + if fixed_len == 0: + if not Type.IsTypedVectorElementType(element_type): + raise ValueError('must be typed vector element type') + else: + if not Type.IsFixedTypedVectorElementType(element_type): + raise ValueError('must be fixed typed vector element type') + + offset = element_type - Type.INT + if fixed_len == 0: + return Type(offset + Type.VECTOR_INT) # TypedVector + elif fixed_len == 2: + return Type(offset + Type.VECTOR_INT2) # FixedTypedVector + elif fixed_len == 3: + return Type(offset + Type.VECTOR_INT3) # FixedTypedVector + elif fixed_len == 4: + return Type(offset + Type.VECTOR_INT4) # FixedTypedVector + else: + raise ValueError('unsupported fixed_len: %s' % fixed_len) + + +class Buf: + """Class to access underlying buffer object starting from the given offset.""" + + def __init__(self, buf, offset): + self._buf = buf + self._offset = offset if offset >= 0 else len(buf) + offset + self._length = len(buf) - self._offset + + def __getitem__(self, key): + if isinstance(key, slice): + return self._buf[_ShiftSlice(key, self._offset, self._length)] + elif isinstance(key, int): + return self._buf[self._offset + key] + else: + raise TypeError('invalid key type') + + def __setitem__(self, key, value): + if isinstance(key, slice): + self._buf[_ShiftSlice(key, self._offset, self._length)] = value + elif isinstance(key, int): + self._buf[self._offset + key] = key + else: + raise TypeError('invalid key type') + + def __repr__(self): + return 'buf[%d:]' % self._offset + + def Find(self, sub): + """Returns the lowest index where the sub subsequence is found.""" + return self._buf[self._offset :].find(sub) + + def Slice(self, offset): + """Returns new `Buf` which starts from the given offset.""" + return Buf(self._buf, self._offset + offset) + + def Indirect(self, offset, byte_width): + """Return new `Buf` based on the encoded offset (indirect encoding).""" + return self.Slice(offset - _Unpack(U, self[offset : offset + byte_width])) + + +class Object: + """Base class for all non-trivial data accessors.""" + + __slots__ = '_buf', '_byte_width' + + def __init__(self, buf, byte_width): + self._buf = buf + self._byte_width = byte_width + + @property + def ByteWidth(self): + return self._byte_width + + +class Sized(Object): + """Base class for all data accessors which need to read encoded size.""" + + __slots__ = ('_size',) + + def __init__(self, buf, byte_width, size=0): + super().__init__(buf, byte_width) + if size == 0: + self._size = _Unpack(U, self.SizeBytes) + else: + self._size = size + + @property + def SizeBytes(self): + return self._buf[-self._byte_width : 0] + + def __len__(self): + return self._size + + +class Blob(Sized): + """Data accessor for the encoded blob bytes.""" + + __slots__ = () + + @property + def Bytes(self): + return self._buf[0 : len(self)] + + def __repr__(self): + return 'Blob(%s, size=%d)' % (self._buf, len(self)) + + +class String(Sized): + """Data accessor for the encoded string bytes.""" + + __slots__ = () + + @property + def Bytes(self): + return self._buf[0 : len(self)] + + def Mutate(self, value): + """Mutates underlying string bytes in place. + + Args: + value: New string to replace the existing one. New string must have less + or equal UTF-8-encoded bytes than the existing one to successfully + mutate underlying byte buffer. + + Returns: + Whether the value was mutated or not. + """ + encoded = value.encode('utf-8') + n = len(encoded) + if n <= len(self): + self._buf[-self._byte_width : 0] = _Pack(U, n, self._byte_width) + self._buf[0:n] = encoded + self._buf[n : len(self)] = bytearray(len(self) - n) + return True + return False + + def __str__(self): + return self.Bytes.decode('utf-8') + + def __repr__(self): + return 'String(%s, size=%d)' % (self._buf, len(self)) + + +class Key(Object): + """Data accessor for the encoded key bytes.""" + + __slots__ = () + + def __init__(self, buf, byte_width): + assert byte_width == 1 + super().__init__(buf, byte_width) + + @property + def Bytes(self): + return self._buf[0 : len(self)] + + def __len__(self): + return self._buf.Find(0) + + def __str__(self): + return self.Bytes.decode('ascii') + + def __repr__(self): + return 'Key(%s, size=%d)' % (self._buf, len(self)) + + +class Vector(Sized): + """Data accessor for the encoded vector bytes.""" + + __slots__ = () + + def __getitem__(self, index): + if index < 0 or index >= len(self): + raise IndexError( + 'vector index %s is out of [0, %d) range' % (index, len(self)) + ) + + packed_type = self._buf[len(self) * self._byte_width + index] + buf = self._buf.Slice(index * self._byte_width) + return Ref.PackedType(buf, self._byte_width, packed_type) + + @property + def Value(self): + """Returns the underlying encoded data as a list object.""" + return [e.Value for e in self] + + def __repr__(self): + return 'Vector(%s, byte_width=%d, size=%d)' % ( + self._buf, + self._byte_width, + self._size, + ) + + +class TypedVector(Sized): + """Data accessor for the encoded typed vector or fixed typed vector bytes.""" + + __slots__ = '_element_type', '_size' + + def __init__(self, buf, byte_width, element_type, size=0): + super().__init__(buf, byte_width, size) + + if element_type == Type.STRING: + # These can't be accessed as strings, since we don't know the bit-width + # of the size field, see the declaration of + # FBT_VECTOR_STRING_DEPRECATED above for details. + # We change the type here to be keys, which are a subtype of strings, + # and will ignore the size field. This will truncate strings with + # embedded nulls. + element_type = Type.KEY + + self._element_type = element_type + + @property + def Bytes(self): + return self._buf[: self._byte_width * len(self)] + + @property + def ElementType(self): + return self._element_type + + def __getitem__(self, index): + if index < 0 or index >= len(self): + raise IndexError( + 'vector index %s is out of [0, %d) range' % (index, len(self)) + ) + + buf = self._buf.Slice(index * self._byte_width) + return Ref(buf, self._byte_width, 1, self._element_type) + + @property + def Value(self): + """Returns underlying data as list object.""" + if not self: + return [] + + if self._element_type is Type.BOOL: + return [bool(e) for e in _UnpackVector(U, self.Bytes, len(self))] + elif self._element_type is Type.INT: + return list(_UnpackVector(I, self.Bytes, len(self))) + elif self._element_type is Type.UINT: + return list(_UnpackVector(U, self.Bytes, len(self))) + elif self._element_type is Type.FLOAT: + return list(_UnpackVector(F, self.Bytes, len(self))) + elif self._element_type is Type.KEY: + return [e.AsKey for e in self] + elif self._element_type is Type.STRING: + return [e.AsString for e in self] + else: + raise TypeError('unsupported element_type: %s' % self._element_type) + + def __repr__(self): + return 'TypedVector(%s, byte_width=%d, element_type=%s, size=%d)' % ( + self._buf, + self._byte_width, + self._element_type, + self._size, + ) + + +class Map(Vector): + """Data accessor for the encoded map bytes.""" + + @staticmethod + def CompareKeys(a, b): + if isinstance(a, Ref): + a = a.AsKeyBytes + if isinstance(b, Ref): + b = b.AsKeyBytes + return a < b + + def __getitem__(self, key): + if isinstance(key, int): + return super().__getitem__(key) + + index = _BinarySearch(self.Keys, key.encode('ascii'), self.CompareKeys) + if index != -1: + return super().__getitem__(index) + + raise KeyError(key) + + @property + def Keys(self): + byte_width = _Unpack( + U, self._buf[-2 * self._byte_width : -self._byte_width] + ) + buf = self._buf.Indirect(-3 * self._byte_width, self._byte_width) + return TypedVector(buf, byte_width, Type.KEY) + + @property + def Values(self): + return Vector(self._buf, self._byte_width) + + @property + def Value(self): + return {k.Value: v.Value for k, v in zip(self.Keys, self.Values)} + + def __repr__(self): + return 'Map(%s, size=%d)' % (self._buf, len(self)) + + +class Ref: + """Data accessor for the encoded data bytes.""" + + __slots__ = '_buf', '_parent_width', '_byte_width', '_type' + + @staticmethod + def PackedType(buf, parent_width, packed_type): + byte_width, type_ = Type.Unpack(packed_type) + return Ref(buf, parent_width, byte_width, type_) + + def __init__(self, buf, parent_width, byte_width, type_): + self._buf = buf + self._parent_width = parent_width + self._byte_width = byte_width + self._type = type_ + + def __repr__(self): + return 'Ref(%s, parent_width=%d, byte_width=%d, type_=%s)' % ( + self._buf, + self._parent_width, + self._byte_width, + self._type, + ) + + @property + def _Bytes(self): + return self._buf[: self._parent_width] + + def _ConvertError(self, target_type): + raise TypeError('cannot convert %s to %s' % (self._type, target_type)) + + def _Indirect(self): + return self._buf.Indirect(0, self._parent_width) + + @property + def IsNull(self): + return self._type is Type.NULL + + @property + def IsBool(self): + return self._type is Type.BOOL + + @property + def AsBool(self): + if self._type is Type.BOOL: + return bool(_Unpack(U, self._Bytes)) + else: + return self.AsInt != 0 + + def MutateBool(self, value): + """Mutates underlying boolean value bytes in place. + + Args: + value: New boolean value. + + Returns: + Whether the value was mutated or not. + """ + return self.IsBool and _Mutate( + U, self._buf, value, self._parent_width, BitWidth.W8 + ) + + @property + def IsNumeric(self): + return self.IsInt or self.IsFloat + + @property + def IsInt(self): + return self._type in ( + Type.INT, + Type.INDIRECT_INT, + Type.UINT, + Type.INDIRECT_UINT, + ) + + @property + def AsInt(self): + """Returns current reference as integer value.""" + if self.IsNull: + return 0 + elif self.IsBool: + return int(self.AsBool) + elif self._type is Type.INT: + return _Unpack(I, self._Bytes) + elif self._type is Type.INDIRECT_INT: + return _Unpack(I, self._Indirect()[: self._byte_width]) + if self._type is Type.UINT: + return _Unpack(U, self._Bytes) + elif self._type is Type.INDIRECT_UINT: + return _Unpack(U, self._Indirect()[: self._byte_width]) + elif self.IsString: + return len(self.AsString) + elif self.IsKey: + return len(self.AsKey) + elif self.IsBlob: + return len(self.AsBlob) + elif self.IsVector: + return len(self.AsVector) + elif self.IsTypedVector: + return len(self.AsTypedVector) + elif self.IsFixedTypedVector: + return len(self.AsFixedTypedVector) + else: + raise self._ConvertError(Type.INT) + + def MutateInt(self, value): + """Mutates underlying integer value bytes in place. + + Args: + value: New integer value. It must fit to the byte size of the existing + encoded value. + + Returns: + Whether the value was mutated or not. + """ + if self._type is Type.INT: + return _Mutate(I, self._buf, value, self._parent_width, BitWidth.I(value)) + elif self._type is Type.INDIRECT_INT: + return _Mutate( + I, self._Indirect(), value, self._byte_width, BitWidth.I(value) + ) + elif self._type is Type.UINT: + return _Mutate(U, self._buf, value, self._parent_width, BitWidth.U(value)) + elif self._type is Type.INDIRECT_UINT: + return _Mutate( + U, self._Indirect(), value, self._byte_width, BitWidth.U(value) + ) + else: + return False + + @property + def IsFloat(self): + return self._type in (Type.FLOAT, Type.INDIRECT_FLOAT) + + @property + def AsFloat(self): + """Returns current reference as floating point value.""" + if self.IsNull: + return 0.0 + elif self.IsBool: + return float(self.AsBool) + elif self.IsInt: + return float(self.AsInt) + elif self._type is Type.FLOAT: + return _Unpack(F, self._Bytes) + elif self._type is Type.INDIRECT_FLOAT: + return _Unpack(F, self._Indirect()[: self._byte_width]) + elif self.IsString: + return float(self.AsString) + elif self.IsVector: + return float(len(self.AsVector)) + elif self.IsTypedVector(): + return float(len(self.AsTypedVector)) + elif self.IsFixedTypedVector(): + return float(len(self.FixedTypedVector)) + else: + raise self._ConvertError(Type.FLOAT) + + def MutateFloat(self, value): + """Mutates underlying floating point value bytes in place. + + Args: + value: New float value. It must fit to the byte size of the existing + encoded value. + + Returns: + Whether the value was mutated or not. + """ + if self._type is Type.FLOAT: + return _Mutate( + F, + self._buf, + value, + self._parent_width, + BitWidth.B(self._parent_width), + ) + elif self._type is Type.INDIRECT_FLOAT: + return _Mutate( + F, + self._Indirect(), + value, + self._byte_width, + BitWidth.B(self._byte_width), + ) + else: + return False + + @property + def IsKey(self): + return self._type is Type.KEY + + @property + def AsKeyBytes(self): + if self.IsKey: + return Key(self._Indirect(), self._byte_width).Bytes + else: + raise self._ConvertError(Type.KEY) + + @property + def AsKey(self): + if self.IsKey: + return str(Key(self._Indirect(), self._byte_width)) + else: + raise self._ConvertError(Type.KEY) + + @property + def IsString(self): + return self._type is Type.STRING + + @property + def AsStringBytes(self): + if self.IsString: + return String(self._Indirect(), self._byte_width).Bytes + elif self.IsKey: + return self.AsKeyBytes + else: + raise self._ConvertError(Type.STRING) + + @property + def AsString(self): + if self.IsString: + return str(String(self._Indirect(), self._byte_width)) + elif self.IsKey: + return self.AsKey + else: + raise self._ConvertError(Type.STRING) + + def MutateString(self, value): + return String(self._Indirect(), self._byte_width).Mutate(value) + + @property + def IsBlob(self): + return self._type is Type.BLOB + + @property + def AsBlob(self): + if self.IsBlob: + return Blob(self._Indirect(), self._byte_width).Bytes + else: + raise self._ConvertError(Type.BLOB) + + @property + def IsAnyVector(self): + return self.IsVector or self.IsTypedVector or self.IsFixedTypedVector() + + @property + def IsVector(self): + return self._type in (Type.VECTOR, Type.MAP) + + @property + def AsVector(self): + if self.IsVector: + return Vector(self._Indirect(), self._byte_width) + else: + raise self._ConvertError(Type.VECTOR) + + @property + def IsTypedVector(self): + return Type.IsTypedVector(self._type) + + @property + def AsTypedVector(self): + if self.IsTypedVector: + return TypedVector( + self._Indirect(), + self._byte_width, + Type.ToTypedVectorElementType(self._type), + ) + else: + raise self._ConvertError('TYPED_VECTOR') + + @property + def IsFixedTypedVector(self): + return Type.IsFixedTypedVector(self._type) + + @property + def AsFixedTypedVector(self): + if self.IsFixedTypedVector: + element_type, size = Type.ToFixedTypedVectorElementType(self._type) + return TypedVector(self._Indirect(), self._byte_width, element_type, size) + else: + raise self._ConvertError('FIXED_TYPED_VECTOR') + + @property + def IsMap(self): + return self._type is Type.MAP + + @property + def AsMap(self): + if self.IsMap: + return Map(self._Indirect(), self._byte_width) + else: + raise self._ConvertError(Type.MAP) + + @property + def Value(self): + """Converts current reference to value of corresponding type. + + This is equivalent to calling `AsInt` for integer values, `AsFloat` for + floating point values, etc. + + Returns: + Value of corresponding type. + """ + if self.IsNull: + return None + elif self.IsBool: + return self.AsBool + elif self.IsInt: + return self.AsInt + elif self.IsFloat: + return self.AsFloat + elif self.IsString: + return self.AsString + elif self.IsKey: + return self.AsKey + elif self.IsBlob: + return self.AsBlob + elif self.IsMap: + return self.AsMap.Value + elif self.IsVector: + return self.AsVector.Value + elif self.IsTypedVector: + return self.AsTypedVector.Value + elif self.IsFixedTypedVector: + return self.AsFixedTypedVector.Value + else: + raise TypeError('cannot convert %r to value' % self) + + +def _IsIterable(obj): + try: + iter(obj) + return True + except TypeError: + return False + + +class Value: + """Class to represent given value during the encoding process.""" + + @staticmethod + def Null(): + return Value(0, Type.NULL, BitWidth.W8) + + @staticmethod + def Bool(value): + return Value(value, Type.BOOL, BitWidth.W8) + + @staticmethod + def Int(value, bit_width): + return Value(value, Type.INT, bit_width) + + @staticmethod + def UInt(value, bit_width): + return Value(value, Type.UINT, bit_width) + + @staticmethod + def Float(value, bit_width): + return Value(value, Type.FLOAT, bit_width) + + @staticmethod + def Key(offset): + return Value(offset, Type.KEY, BitWidth.W8) + + def __init__(self, value, type_, min_bit_width): + self._value = value + self._type = type_ + + # For scalars: of itself, for vector: of its elements, for string: length. + self._min_bit_width = min_bit_width + + @property + def Value(self): + return self._value + + @property + def Type(self): + return self._type + + @property + def MinBitWidth(self): + return self._min_bit_width + + def StoredPackedType(self, parent_bit_width=BitWidth.W8): + return Type.Pack(self._type, self.StoredWidth(parent_bit_width)) + + # We have an absolute offset, but want to store a relative offset + # elem_index elements beyond the current buffer end. Since whether + # the relative offset fits in a certain byte_width depends on + # the size of the elements before it (and their alignment), we have + # to test for each size in turn. + def ElemWidth(self, buf_size, elem_index=0): + if Type.IsInline(self._type): + return self._min_bit_width + for byte_width in 1, 2, 4, 8: + offset_loc = ( + buf_size + + _PaddingBytes(buf_size, byte_width) + + elem_index * byte_width + ) + bit_width = BitWidth.U(offset_loc - self._value) + if byte_width == (1 << bit_width): + return bit_width + raise ValueError('relative offset is too big') + + def StoredWidth(self, parent_bit_width=BitWidth.W8): + if Type.IsInline(self._type): + return max(self._min_bit_width, parent_bit_width) + return self._min_bit_width + + def __repr__(self): + return 'Value(%s, %s, %s)' % (self._value, self._type, self._min_bit_width) + + def __str__(self): + return str(self._value) + + +def InMap(func): + def wrapper(self, *args, **kwargs): + if isinstance(args[0], str): + self.Key(args[0]) + func(self, *args[1:], **kwargs) + else: + func(self, *args, **kwargs) + + return wrapper + + +def InMapForString(func): + def wrapper(self, *args): + if len(args) == 1: + func(self, args[0]) + elif len(args) == 2: + self.Key(args[0]) + func(self, args[1]) + else: + raise ValueError('invalid number of arguments') + + return wrapper + + +class Pool: + """Collection of (data, offset) pairs sorted by data for quick access.""" + + def __init__(self): + self._pool = [] # sorted list of (data, offset) tuples + + def FindOrInsert(self, data, offset): + do = data, offset + index = _BinarySearch(self._pool, do, lambda a, b: a[0] < b[0]) + if index != -1: + _, offset = self._pool[index] + return offset + self._pool.insert(index, do) + return None + + def Clear(self): + self._pool = [] + + @property + def Elements(self): + return [data for data, _ in self._pool] + + +class Builder: + """Helper class to encode structural data into flexbuffers format.""" + + def __init__( + self, + share_strings=False, + share_keys=True, + force_min_bit_width=BitWidth.W8, + ): + self._share_strings = share_strings + self._share_keys = share_keys + self._force_min_bit_width = force_min_bit_width + + self._string_pool = Pool() + self._key_pool = Pool() + + self._finished = False + self._buf = bytearray() + self._stack = [] + + def __len__(self): + return len(self._buf) + + @property + def StringPool(self): + return self._string_pool + + @property + def KeyPool(self): + return self._key_pool + + def Clear(self): + self._string_pool.Clear() + self._key_pool.Clear() + self._finished = False + self._buf = bytearray() + self._stack = [] + + def Finish(self): + """Finishes encoding process and returns underlying buffer.""" + if self._finished: + raise RuntimeError('builder has been already finished') + + # If you hit this exception, you likely have objects that were never + # included in a parent. You need to have exactly one root to finish a + # buffer. Check your Start/End calls are matched, and all objects are inside + # some other object. + if len(self._stack) != 1: + raise RuntimeError('internal stack size must be one') + + value = self._stack[0] + byte_width = self._Align(value.ElemWidth(len(self._buf))) + self._WriteAny(value, byte_width=byte_width) # Root value + self._Write(U, value.StoredPackedType(), byte_width=1) # Root type + self._Write(U, byte_width, byte_width=1) # Root size + + self.finished = True + return self._buf + + def _ReadKey(self, offset): + key = self._buf[offset:] + return key[: key.find(0)] + + def _Align(self, alignment): + byte_width = 1 << alignment + self._buf.extend(b'\x00' * _PaddingBytes(len(self._buf), byte_width)) + return byte_width + + def _Write(self, fmt, value, byte_width): + self._buf.extend(_Pack(fmt, value, byte_width)) + + def _WriteVector(self, fmt, values, byte_width): + self._buf.extend(_PackVector(fmt, values, byte_width)) + + def _WriteOffset(self, offset, byte_width): + relative_offset = len(self._buf) - offset + assert byte_width == 8 or relative_offset < (1 << (8 * byte_width)) + self._Write(U, relative_offset, byte_width) + + def _WriteAny(self, value, byte_width): + fmt = { + Type.NULL: U, + Type.BOOL: U, + Type.INT: I, + Type.UINT: U, + Type.FLOAT: F, + }.get(value.Type) + if fmt: + self._Write(fmt, value.Value, byte_width) + else: + self._WriteOffset(value.Value, byte_width) + + def _WriteBlob(self, data, append_zero, type_): + bit_width = BitWidth.U(len(data)) + byte_width = self._Align(bit_width) + self._Write(U, len(data), byte_width) + loc = len(self._buf) + self._buf.extend(data) + if append_zero: + self._buf.append(0) + self._stack.append(Value(loc, type_, bit_width)) + return loc + + def _WriteScalarVector(self, element_type, byte_width, elements, fixed): + """Writes scalar vector elements to the underlying buffer.""" + bit_width = BitWidth.B(byte_width) + # If you get this exception, you're trying to write a vector with a size + # field that is bigger than the scalars you're trying to write (e.g. a + # byte vector > 255 elements). For such types, write a "blob" instead. + if BitWidth.U(len(elements)) > bit_width: + raise ValueError('too many elements for the given byte_width') + + self._Align(bit_width) + if not fixed: + self._Write(U, len(elements), byte_width) + + loc = len(self._buf) + + fmt = {Type.INT: I, Type.UINT: U, Type.FLOAT: F}.get(element_type) + if not fmt: + raise TypeError('unsupported element_type') + self._WriteVector(fmt, elements, byte_width) + + type_ = Type.ToTypedVector(element_type, len(elements) if fixed else 0) + self._stack.append(Value(loc, type_, bit_width)) + return loc + + def _CreateVector(self, elements, typed, fixed, keys=None): + """Writes vector elements to the underlying buffer.""" + length = len(elements) + + if fixed and not typed: + raise ValueError('fixed vector must be typed') + + # Figure out smallest bit width we can store this vector with. + bit_width = max(self._force_min_bit_width, BitWidth.U(length)) + prefix_elems = 1 # Vector size + if keys: + bit_width = max(bit_width, keys.ElemWidth(len(self._buf))) + prefix_elems += 2 # Offset to the keys vector and its byte width. + + vector_type = Type.KEY + # Check bit widths and types for all elements. + for i, e in enumerate(elements): + bit_width = max(bit_width, e.ElemWidth(len(self._buf), prefix_elems + i)) + + if typed: + if i == 0: + vector_type = e.Type + else: + if vector_type != e.Type: + raise RuntimeError('typed vector elements must be of the same type') + + if fixed and not Type.IsFixedTypedVectorElementType(vector_type): + raise RuntimeError('must be fixed typed vector element type') + + byte_width = self._Align(bit_width) + # Write vector. First the keys width/offset if available, and size. + if keys: + self._WriteOffset(keys.Value, byte_width) + self._Write(U, 1 << keys.MinBitWidth, byte_width) + + if not fixed: + self._Write(U, length, byte_width) + + # Then the actual data. + loc = len(self._buf) + for e in elements: + self._WriteAny(e, byte_width) + + # Then the types. + if not typed: + for e in elements: + self._buf.append(e.StoredPackedType(bit_width)) + + if keys: + type_ = Type.MAP + else: + if typed: + type_ = Type.ToTypedVector(vector_type, length if fixed else 0) + else: + type_ = Type.VECTOR + + return Value(loc, type_, bit_width) + + def _PushIndirect(self, value, type_, bit_width): + byte_width = self._Align(bit_width) + loc = len(self._buf) + fmt = {Type.INDIRECT_INT: I, Type.INDIRECT_UINT: U, Type.INDIRECT_FLOAT: F}[ + type_ + ] + self._Write(fmt, value, byte_width) + self._stack.append(Value(loc, type_, bit_width)) + + @InMapForString + def String(self, value): + """Encodes string value.""" + reset_to = len(self._buf) + encoded = value.encode('utf-8') + loc = self._WriteBlob(encoded, append_zero=True, type_=Type.STRING) + if self._share_strings: + prev_loc = self._string_pool.FindOrInsert(encoded, loc) + if prev_loc is not None: + del self._buf[reset_to:] + self._stack[-1]._value = loc = prev_loc # pylint: disable=protected-access + + return loc + + @InMap + def Blob(self, value): + """Encodes binary blob value. + + Args: + value: A byte/bytearray value to encode + + Returns: + Offset of the encoded value in underlying the byte buffer. + """ + return self._WriteBlob(value, append_zero=False, type_=Type.BLOB) + + def Key(self, value): + """Encodes key value. + + Args: + value: A byte/bytearray/str value to encode. Byte object must not contain + zero bytes. String object must be convertible to ASCII. + + Returns: + Offset of the encoded value in the underlying byte buffer. + """ + if isinstance(value, (bytes, bytearray)): + encoded = value + else: + encoded = value.encode('ascii') + + if 0 in encoded: + raise ValueError('key contains zero byte') + + loc = len(self._buf) + self._buf.extend(encoded) + self._buf.append(0) + if self._share_keys: + prev_loc = self._key_pool.FindOrInsert(encoded, loc) + if prev_loc is not None: + del self._buf[loc:] + loc = prev_loc + + self._stack.append(Value.Key(loc)) + return loc + + def Null(self, key=None): + """Encodes None value.""" + if key: + self.Key(key) + self._stack.append(Value.Null()) + + @InMap + def Bool(self, value): + """Encodes boolean value. + + Args: + value: A boolean value. + """ + self._stack.append(Value.Bool(value)) + + @InMap + def Int(self, value, byte_width=0): + """Encodes signed integer value. + + Args: + value: A signed integer value. + byte_width: Number of bytes to use: 1, 2, 4, or 8. + """ + bit_width = BitWidth.I(value) if byte_width == 0 else BitWidth.B(byte_width) + self._stack.append(Value.Int(value, bit_width)) + + @InMap + def IndirectInt(self, value, byte_width=0): + """Encodes signed integer value indirectly. + + Args: + value: A signed integer value. + byte_width: Number of bytes to use: 1, 2, 4, or 8. + """ + bit_width = BitWidth.I(value) if byte_width == 0 else BitWidth.B(byte_width) + self._PushIndirect(value, Type.INDIRECT_INT, bit_width) + + @InMap + def UInt(self, value, byte_width=0): + """Encodes unsigned integer value. + + Args: + value: An unsigned integer value. + byte_width: Number of bytes to use: 1, 2, 4, or 8. + """ + bit_width = BitWidth.U(value) if byte_width == 0 else BitWidth.B(byte_width) + self._stack.append(Value.UInt(value, bit_width)) + + @InMap + def IndirectUInt(self, value, byte_width=0): + """Encodes unsigned integer value indirectly. + + Args: + value: An unsigned integer value. + byte_width: Number of bytes to use: 1, 2, 4, or 8. + """ + bit_width = BitWidth.U(value) if byte_width == 0 else BitWidth.B(byte_width) + self._PushIndirect(value, Type.INDIRECT_UINT, bit_width) + + @InMap + def Float(self, value, byte_width=0): + """Encodes floating point value. + + Args: + value: A floating point value. + byte_width: Number of bytes to use: 4 or 8. + """ + bit_width = BitWidth.F(value) if byte_width == 0 else BitWidth.B(byte_width) + self._stack.append(Value.Float(value, bit_width)) + + @InMap + def IndirectFloat(self, value, byte_width=0): + """Encodes floating point value indirectly. + + Args: + value: A floating point value. + byte_width: Number of bytes to use: 4 or 8. + """ + bit_width = BitWidth.F(value) if byte_width == 0 else BitWidth.B(byte_width) + self._PushIndirect(value, Type.INDIRECT_FLOAT, bit_width) + + def _StartVector(self): + """Starts vector construction.""" + return len(self._stack) + + def _EndVector(self, start, typed, fixed): + """Finishes vector construction by encodung its elements.""" + vec = self._CreateVector(self._stack[start:], typed, fixed) + del self._stack[start:] + self._stack.append(vec) + return vec.Value + + @contextlib.contextmanager + def Vector(self, key=None): + if key: + self.Key(key) + + try: + start = self._StartVector() + yield self + finally: + self._EndVector(start, typed=False, fixed=False) + + @InMap + def VectorFromElements(self, elements): + """Encodes sequence of any elements as a vector. + + Args: + elements: sequence of elements, they may have different types. + """ + with self.Vector(): + for e in elements: + self.Add(e) + + @contextlib.contextmanager + def TypedVector(self, key=None): + if key: + self.Key(key) + + try: + start = self._StartVector() + yield self + finally: + self._EndVector(start, typed=True, fixed=False) + + @InMap + def TypedVectorFromElements(self, elements, element_type=None): + """Encodes sequence of elements of the same type as typed vector. + + Args: + elements: Sequence of elements, they must be of the same type. + element_type: Suggested element type. Setting it to None means determining + correct value automatically based on the given elements. + """ + if isinstance(elements, array.array): + if elements.typecode == 'f': + self._WriteScalarVector(Type.FLOAT, 4, elements, fixed=False) + elif elements.typecode == 'd': + self._WriteScalarVector(Type.FLOAT, 8, elements, fixed=False) + elif elements.typecode in ('b', 'h', 'i', 'l', 'q'): + self._WriteScalarVector( + Type.INT, elements.itemsize, elements, fixed=False + ) + elif elements.typecode in ('B', 'H', 'I', 'L', 'Q'): + self._WriteScalarVector( + Type.UINT, elements.itemsize, elements, fixed=False + ) + else: + raise ValueError('unsupported array typecode: %s' % elements.typecode) + else: + add = self.Add if element_type is None else self.Adder(element_type) + with self.TypedVector(): + for e in elements: + add(e) + + @InMap + def FixedTypedVectorFromElements( + self, elements, element_type=None, byte_width=0 + ): + """Encodes sequence of elements of the same type as fixed typed vector. + + Args: + elements: Sequence of elements, they must be of the same type. Allowed + types are `Type.INT`, `Type.UINT`, `Type.FLOAT`. Allowed number of + elements are 2, 3, or 4. + element_type: Suggested element type. Setting it to None means determining + correct value automatically based on the given elements. + byte_width: Number of bytes to use per element. For `Type.INT` and + `Type.UINT`: 1, 2, 4, or 8. For `Type.FLOAT`: 4 or 8. Setting it to 0 + means determining correct value automatically based on the given + elements. + """ + if not 2 <= len(elements) <= 4: + raise ValueError('only 2, 3, or 4 elements are supported') + + types = {type(e) for e in elements} + if len(types) != 1: + raise TypeError('all elements must be of the same type') + + (type_,) = types + + if element_type is None: + element_type = {int: Type.INT, float: Type.FLOAT}.get(type_) + if not element_type: + raise TypeError('unsupported element_type: %s' % type_) + + if byte_width == 0: + width = { + Type.UINT: BitWidth.U, + Type.INT: BitWidth.I, + Type.FLOAT: BitWidth.F, + }[element_type] + byte_width = 1 << max(width(e) for e in elements) + + self._WriteScalarVector(element_type, byte_width, elements, fixed=True) + + def _StartMap(self): + """Starts map construction.""" + return len(self._stack) + + def _EndMap(self, start): + """Finishes map construction by encodung its elements.""" + # Interleaved keys and values on the stack. + stack = self._stack[start:] + + if len(stack) % 2 != 0: + raise RuntimeError('must be even number of keys and values') + + for key in stack[::2]: + if key.Type is not Type.KEY: + raise RuntimeError('all map keys must be of %s type' % Type.KEY) + + pairs = zip(stack[::2], stack[1::2]) # [(key, value), ...] + pairs = sorted(pairs, key=lambda pair: self._ReadKey(pair[0].Value)) + + del self._stack[start:] + for pair in pairs: + self._stack.extend(pair) + + keys = self._CreateVector(self._stack[start::2], typed=True, fixed=False) + values = self._CreateVector( + self._stack[start + 1 :: 2], typed=False, fixed=False, keys=keys + ) + + del self._stack[start:] + self._stack.append(values) + return values.Value + + @contextlib.contextmanager + def Map(self, key=None): + if key: + self.Key(key) + + try: + start = self._StartMap() + yield self + finally: + self._EndMap(start) + + def MapFromElements(self, elements): + start = self._StartMap() + for k, v in elements.items(): + self.Key(k) + self.Add(v) + self._EndMap(start) + + def Adder(self, type_): + return { + Type.BOOL: self.Bool, + Type.INT: self.Int, + Type.INDIRECT_INT: self.IndirectInt, + Type.UINT: self.UInt, + Type.INDIRECT_UINT: self.IndirectUInt, + Type.FLOAT: self.Float, + Type.INDIRECT_FLOAT: self.IndirectFloat, + Type.KEY: self.Key, + Type.BLOB: self.Blob, + Type.STRING: self.String, + }[type_] + + @InMapForString + def Add(self, value): + """Encodes value of any supported type.""" + if value is None: + self.Null() + elif isinstance(value, bool): + self.Bool(value) + elif isinstance(value, int): + self.Int(value) + elif isinstance(value, float): + self.Float(value) + elif isinstance(value, str): + self.String(value) + elif isinstance(value, (bytes, bytearray)): + self.Blob(value) + elif isinstance(value, dict): + with self.Map(): + for k, v in value.items(): + self.Key(k) + self.Add(v) + elif isinstance(value, array.array): + self.TypedVectorFromElements(value) + elif _IsIterable(value): + self.VectorFromElements(value) + else: + raise TypeError('unsupported python type: %s' % type(value)) + + @property + def LastValue(self): + return self._stack[-1] + + @InMap + def ReuseValue(self, value): + self._stack.append(value) + + +def GetRoot(buf): + """Returns root `Ref` object for the given buffer.""" + if len(buf) < 3: + raise ValueError('buffer is too small') + byte_width = buf[-1] + return Ref.PackedType( + Buf(buf, -(2 + byte_width)), byte_width, packed_type=buf[-2] + ) + + +def Dumps(obj): + """Returns bytearray with the encoded python object.""" + fbb = Builder() + fbb.Add(obj) + return fbb.Finish() + + +def Loads(buf): + """Returns python object decoded from the buffer.""" + return GetRoot(buf).Value diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/number_types.py b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/number_types.py new file mode 100644 index 0000000000000000000000000000000000000000..e47f66f12dbdbeb161a12a102a6445dde86d7d04 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/number_types.py @@ -0,0 +1,182 @@ +# Copyright 2014 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import collections +import struct + +from . import packer +from .compat import NumpyRequiredForThisFeature, import_numpy + +np = import_numpy() + +# For reference, see: +# https://docs.python.org/2/library/ctypes.html#ctypes-fundamental-data-types-2 + +# These classes could be collections.namedtuple instances, but those are new +# in 2.6 and we want to work towards 2.5 compatability. + + +class BoolFlags(object): + bytewidth = 1 + min_val = False + max_val = True + py_type = bool + name = "bool" + packer_type = packer.boolean + + +class Uint8Flags(object): + bytewidth = 1 + min_val = 0 + max_val = (2**8) - 1 + py_type = int + name = "uint8" + packer_type = packer.uint8 + + +class Uint16Flags(object): + bytewidth = 2 + min_val = 0 + max_val = (2**16) - 1 + py_type = int + name = "uint16" + packer_type = packer.uint16 + + +class Uint32Flags(object): + bytewidth = 4 + min_val = 0 + max_val = (2**32) - 1 + py_type = int + name = "uint32" + packer_type = packer.uint32 + + +class Uint64Flags(object): + bytewidth = 8 + min_val = 0 + max_val = (2**64) - 1 + py_type = int + name = "uint64" + packer_type = packer.uint64 + + +class Int8Flags(object): + bytewidth = 1 + min_val = -(2**7) + max_val = (2**7) - 1 + py_type = int + name = "int8" + packer_type = packer.int8 + + +class Int16Flags(object): + bytewidth = 2 + min_val = -(2**15) + max_val = (2**15) - 1 + py_type = int + name = "int16" + packer_type = packer.int16 + + +class Int32Flags(object): + bytewidth = 4 + min_val = -(2**31) + max_val = (2**31) - 1 + py_type = int + name = "int32" + packer_type = packer.int32 + + +class Int64Flags(object): + bytewidth = 8 + min_val = -(2**63) + max_val = (2**63) - 1 + py_type = int + name = "int64" + packer_type = packer.int64 + + +class Float32Flags(object): + bytewidth = 4 + min_val = None + max_val = None + py_type = float + name = "float32" + packer_type = packer.float32 + + +class Float64Flags(object): + bytewidth = 8 + min_val = None + max_val = None + py_type = float + name = "float64" + packer_type = packer.float64 + + +class SOffsetTFlags(Int32Flags): + pass + + +class UOffsetTFlags(Uint32Flags): + pass + + +class VOffsetTFlags(Uint16Flags): + pass + + +def valid_number(n, flags): + if flags.min_val is None and flags.max_val is None: + return True + return flags.min_val <= n <= flags.max_val + + +def enforce_number(n, flags): + if flags.min_val is None and flags.max_val is None: + return + if not flags.min_val <= n <= flags.max_val: + raise TypeError("bad number %s for type %s" % (str(n), flags.name)) + + +def float32_to_uint32(n): + packed = struct.pack("<1f", n) + (converted,) = struct.unpack("<1L", packed) + return converted + + +def uint32_to_float32(n): + packed = struct.pack("<1L", n) + (unpacked,) = struct.unpack("<1f", packed) + return unpacked + + +def float64_to_uint64(n): + packed = struct.pack("<1d", n) + (converted,) = struct.unpack("<1Q", packed) + return converted + + +def uint64_to_float64(n): + packed = struct.pack("<1Q", n) + (unpacked,) = struct.unpack("<1d", packed) + return unpacked + + +def to_numpy_type(number_type): + if np is not None: + return np.dtype(number_type.name).newbyteorder("<") + else: + raise NumpyRequiredForThisFeature("Numpy was not found.") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/packer.py b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/packer.py new file mode 100644 index 0000000000000000000000000000000000000000..0296e52b3fb5ff0d7d6b2bbb7ed59f977afa579e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/flatbuffers/packer.py @@ -0,0 +1,41 @@ +# Copyright 2016 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Provide pre-compiled struct packers for encoding and decoding. + +See: https://docs.python.org/2/library/struct.html#format-characters +""" + +import struct +from . import compat + + +boolean = struct.Struct(compat.struct_bool_decl) + +uint8 = struct.Struct(" Any: + any_msg = Any() + any_msg.Pack( + msg=msg, type_url_prefix=type_url_prefix, deterministic=deterministic + ) + return any_msg + + +def unpack(any_msg: Any, msg: Message) -> bool: + return any_msg.Unpack(msg=msg) + + +def unpack_as(any_msg: Any, message_type: type[_MessageT]) -> _MessageT: + unpacked = message_type() + if unpack(any_msg, unpacked): + return unpacked + else: + raise TypeError( + f'Attempted to unpack {type_name(any_msg)} to' + f' {message_type.__qualname__}' + ) + + +def type_name(any_msg: Any) -> str: + return any_msg.TypeName() + + +def is_type(any_msg: Any, des: descriptor.Descriptor) -> bool: + return any_msg.Is(des) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/any_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/any_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..0cef801aa7cf4a5eb769f73aeca82b6b08e7b455 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/any_pb2.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/any.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/any.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x19google/protobuf/any.proto\x12\x0fgoogle.protobuf\"6\n\x03\x41ny\x12\x19\n\x08type_url\x18\x01 \x01(\tR\x07typeUrl\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05valueBv\n\x13\x63om.google.protobufB\x08\x41nyProtoP\x01Z,google.golang.org/protobuf/types/known/anypb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.any_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\010AnyProtoP\001Z,google.golang.org/protobuf/types/known/anypb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_ANY']._serialized_start=46 + _globals['_ANY']._serialized_end=100 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/api_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/api_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..2adbdf8251ff7569d289c6d95d58a5d19a1d217e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/api_pb2.py @@ -0,0 +1,47 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/api.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/api.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import source_context_pb2 as google_dot_protobuf_dot_source__context__pb2 +from google.protobuf import type_pb2 as google_dot_protobuf_dot_type__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x19google/protobuf/api.proto\x12\x0fgoogle.protobuf\x1a$google/protobuf/source_context.proto\x1a\x1agoogle/protobuf/type.proto\"\xdb\x02\n\x03\x41pi\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x31\n\x07methods\x18\x02 \x03(\x0b\x32\x17.google.protobuf.MethodR\x07methods\x12\x31\n\x07options\x18\x03 \x03(\x0b\x32\x17.google.protobuf.OptionR\x07options\x12\x18\n\x07version\x18\x04 \x01(\tR\x07version\x12\x45\n\x0esource_context\x18\x05 \x01(\x0b\x32\x1e.google.protobuf.SourceContextR\rsourceContext\x12.\n\x06mixins\x18\x06 \x03(\x0b\x32\x16.google.protobuf.MixinR\x06mixins\x12/\n\x06syntax\x18\x07 \x01(\x0e\x32\x17.google.protobuf.SyntaxR\x06syntax\x12\x18\n\x07\x65\x64ition\x18\x08 \x01(\tR\x07\x65\x64ition\"\xd4\x02\n\x06Method\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12(\n\x10request_type_url\x18\x02 \x01(\tR\x0erequestTypeUrl\x12+\n\x11request_streaming\x18\x03 \x01(\x08R\x10requestStreaming\x12*\n\x11response_type_url\x18\x04 \x01(\tR\x0fresponseTypeUrl\x12-\n\x12response_streaming\x18\x05 \x01(\x08R\x11responseStreaming\x12\x31\n\x07options\x18\x06 \x03(\x0b\x32\x17.google.protobuf.OptionR\x07options\x12\x33\n\x06syntax\x18\x07 \x01(\x0e\x32\x17.google.protobuf.SyntaxB\x02\x18\x01R\x06syntax\x12\x1c\n\x07\x65\x64ition\x18\x08 \x01(\tB\x02\x18\x01R\x07\x65\x64ition\"/\n\x05Mixin\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n\x04root\x18\x02 \x01(\tR\x04rootBv\n\x13\x63om.google.protobufB\x08\x41piProtoP\x01Z,google.golang.org/protobuf/types/known/apipb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.api_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\010ApiProtoP\001Z,google.golang.org/protobuf/types/known/apipb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_METHOD'].fields_by_name['syntax']._loaded_options = None + _globals['_METHOD'].fields_by_name['syntax']._serialized_options = b'\030\001' + _globals['_METHOD'].fields_by_name['edition']._loaded_options = None + _globals['_METHOD'].fields_by_name['edition']._serialized_options = b'\030\001' + _globals['_API']._serialized_start=113 + _globals['_API']._serialized_end=460 + _globals['_METHOD']._serialized_start=463 + _globals['_METHOD']._serialized_end=803 + _globals['_MIXIN']._serialized_start=805 + _globals['_MIXIN']._serialized_end=852 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/compiler/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/compiler/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/compiler/plugin_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/compiler/plugin_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..8466f9d792914fdee030db578d8f52dcef07faa6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/compiler/plugin_pb2.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/compiler/plugin.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/compiler/plugin.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n%google/protobuf/compiler/plugin.proto\x12\x18google.protobuf.compiler\x1a google/protobuf/descriptor.proto\"c\n\x07Version\x12\x14\n\x05major\x18\x01 \x01(\x05R\x05major\x12\x14\n\x05minor\x18\x02 \x01(\x05R\x05minor\x12\x14\n\x05patch\x18\x03 \x01(\x05R\x05patch\x12\x16\n\x06suffix\x18\x04 \x01(\tR\x06suffix\"\xcf\x02\n\x14\x43odeGeneratorRequest\x12(\n\x10\x66ile_to_generate\x18\x01 \x03(\tR\x0e\x66ileToGenerate\x12\x1c\n\tparameter\x18\x02 \x01(\tR\tparameter\x12\x43\n\nproto_file\x18\x0f \x03(\x0b\x32$.google.protobuf.FileDescriptorProtoR\tprotoFile\x12\\\n\x17source_file_descriptors\x18\x11 \x03(\x0b\x32$.google.protobuf.FileDescriptorProtoR\x15sourceFileDescriptors\x12L\n\x10\x63ompiler_version\x18\x03 \x01(\x0b\x32!.google.protobuf.compiler.VersionR\x0f\x63ompilerVersion\"\x85\x04\n\x15\x43odeGeneratorResponse\x12\x14\n\x05\x65rror\x18\x01 \x01(\tR\x05\x65rror\x12-\n\x12supported_features\x18\x02 \x01(\x04R\x11supportedFeatures\x12\'\n\x0fminimum_edition\x18\x03 \x01(\x05R\x0eminimumEdition\x12\'\n\x0fmaximum_edition\x18\x04 \x01(\x05R\x0emaximumEdition\x12H\n\x04\x66ile\x18\x0f \x03(\x0b\x32\x34.google.protobuf.compiler.CodeGeneratorResponse.FileR\x04\x66ile\x1a\xb1\x01\n\x04\x46ile\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\'\n\x0finsertion_point\x18\x02 \x01(\tR\x0einsertionPoint\x12\x18\n\x07\x63ontent\x18\x0f \x01(\tR\x07\x63ontent\x12R\n\x13generated_code_info\x18\x10 \x01(\x0b\x32\".google.protobuf.GeneratedCodeInfoR\x11generatedCodeInfo\"W\n\x07\x46\x65\x61ture\x12\x10\n\x0c\x46\x45\x41TURE_NONE\x10\x00\x12\x1b\n\x17\x46\x45\x41TURE_PROTO3_OPTIONAL\x10\x01\x12\x1d\n\x19\x46\x45\x41TURE_SUPPORTS_EDITIONS\x10\x02\x42r\n\x1c\x63om.google.protobuf.compilerB\x0cPluginProtosZ)google.golang.org/protobuf/types/pluginpb\xaa\x02\x18Google.Protobuf.Compiler') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.compiler.plugin_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\034com.google.protobuf.compilerB\014PluginProtosZ)google.golang.org/protobuf/types/pluginpb\252\002\030Google.Protobuf.Compiler' + _globals['_VERSION']._serialized_start=101 + _globals['_VERSION']._serialized_end=200 + _globals['_CODEGENERATORREQUEST']._serialized_start=203 + _globals['_CODEGENERATORREQUEST']._serialized_end=538 + _globals['_CODEGENERATORRESPONSE']._serialized_start=541 + _globals['_CODEGENERATORRESPONSE']._serialized_end=1058 + _globals['_CODEGENERATORRESPONSE_FILE']._serialized_start=792 + _globals['_CODEGENERATORRESPONSE_FILE']._serialized_end=969 + _globals['_CODEGENERATORRESPONSE_FEATURE']._serialized_start=971 + _globals['_CODEGENERATORRESPONSE_FEATURE']._serialized_end=1058 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor.py new file mode 100644 index 0000000000000000000000000000000000000000..b9cc3518770bf74089271836606b666286790d37 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor.py @@ -0,0 +1,1665 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Descriptors essentially contain exactly the information found in a .proto + +file, in types that make this information accessible in Python. +""" + +__author__ = 'robinson@google.com (Will Robinson)' + +import abc +import binascii +import os +import threading +import warnings + +from google.protobuf.internal import api_implementation + +_USE_C_DESCRIPTORS = False +if api_implementation.Type() != 'python': + # pylint: disable=protected-access + _message = api_implementation._c_module + # TODO: Remove this import after fix api_implementation + if _message is None: + from google.protobuf.pyext import _message + _USE_C_DESCRIPTORS = True + + +class Error(Exception): + """Base error for this module.""" + + +class TypeTransformationError(Error): + """Error transforming between python proto type and corresponding C++ type.""" + + +if _USE_C_DESCRIPTORS: + # This metaclass allows to override the behavior of code like + # isinstance(my_descriptor, FieldDescriptor) + # and make it return True when the descriptor is an instance of the extension + # type written in C++. + class DescriptorMetaclass(type): + + def __instancecheck__(cls, obj): + if super(DescriptorMetaclass, cls).__instancecheck__(obj): + return True + if isinstance(obj, cls._C_DESCRIPTOR_CLASS): + return True + return False + +else: + # The standard metaclass; nothing changes. + DescriptorMetaclass = abc.ABCMeta + + +class _Lock(object): + """Wrapper class of threading.Lock(), which is allowed by 'with'.""" + + def __new__(cls): + self = object.__new__(cls) + self._lock = threading.Lock() # pylint: disable=protected-access + return self + + def __enter__(self): + self._lock.acquire() + + def __exit__(self, exc_type, exc_value, exc_tb): + self._lock.release() + + +_lock = threading.Lock() + + +def _Deprecated( + name, + alternative='get/find descriptors from generated code or query the descriptor_pool', +): + if _Deprecated.count > 0: + _Deprecated.count -= 1 + warnings.warn( + 'Call to deprecated %s, use %s instead.' % (name, alternative), + category=DeprecationWarning, + stacklevel=3, + ) + + +# These must match the values in descriptor.proto, but we can't use them +# directly because we sometimes need to reference them in feature helpers +# below *during* the build of descriptor.proto. +_FEATURESET_MESSAGE_ENCODING_DELIMITED = 2 +_FEATURESET_FIELD_PRESENCE_IMPLICIT = 2 +_FEATURESET_FIELD_PRESENCE_LEGACY_REQUIRED = 3 +_FEATURESET_REPEATED_FIELD_ENCODING_PACKED = 1 +_FEATURESET_ENUM_TYPE_CLOSED = 2 + +# Deprecated warnings will print 100 times at most which should be enough for +# users to notice and do not cause timeout. +_Deprecated.count = 100 + + +_internal_create_key = object() + + +class DescriptorBase(metaclass=DescriptorMetaclass): + """Descriptors base class. + + This class is the base of all descriptor classes. It provides common options + related functionality. + + Attributes: + has_options: True if the descriptor has non-default options. Usually it is + not necessary to read this -- just call GetOptions() which will happily + return the default instance. However, it's sometimes useful for + efficiency, and also useful inside the protobuf implementation to avoid + some bootstrapping issues. + file (FileDescriptor): Reference to file info. + """ + + if _USE_C_DESCRIPTORS: + # The class, or tuple of classes, that are considered as "virtual + # subclasses" of this descriptor class. + _C_DESCRIPTOR_CLASS = () + + def __init__(self, file, options, serialized_options, options_class_name): + """Initialize the descriptor given its options message and the name of the + + class of the options message. The name of the class is required in case + the options message is None and has to be created. + """ + self._features = None + self.file = file + self._original_options = options + # These two fields are duplicated as a compatibility shim for old gencode + # that resets them. In 26.x (cl/580304039) we renamed _options to, + # _loaded_options breaking backwards compatibility. + self._options = self._loaded_options = None + self._options_class_name = options_class_name + self._serialized_options = serialized_options + + # Does this descriptor have non-default options? + self.has_options = (self._original_options is not None) or ( + self._serialized_options is not None + ) + + @property + @abc.abstractmethod + def _parent(self): + pass + + def _InferLegacyFeatures(self, edition, options, features): + """Infers features from proto2/proto3 syntax so that editions logic can be used everywhere. + + Args: + edition: The edition to infer features for. + options: The options for this descriptor that are being processed. + features: The feature set object to modify with inferred features. + """ + pass + + def _GetFeatures(self): + if not self._features: + self._LazyLoadOptions() + return self._features + + def _ResolveFeatures(self, edition, raw_options): + """Resolves features from the raw options of this descriptor. + + Args: + edition: The edition to use for feature defaults. + raw_options: The options for this descriptor that are being processed. + + Returns: + A fully resolved feature set for making runtime decisions. + """ + # pylint: disable=g-import-not-at-top + from google.protobuf import descriptor_pb2 + + if self._parent: + features = descriptor_pb2.FeatureSet() + features.CopyFrom(self._parent._GetFeatures()) + else: + features = self.file.pool._CreateDefaultFeatures(edition) + unresolved = descriptor_pb2.FeatureSet() + unresolved.CopyFrom(raw_options.features) + self._InferLegacyFeatures(edition, raw_options, unresolved) + features.MergeFrom(unresolved) + + # Use the feature cache to reduce memory bloat. + return self.file.pool._InternFeatures(features) + + def _LazyLoadOptions(self): + """Lazily initializes descriptor options towards the end of the build.""" + if self._options and self._loaded_options == self._options: + # If neither has been reset by gencode, use the cache. + return + + # pylint: disable=g-import-not-at-top + from google.protobuf import descriptor_pb2 + + if not hasattr(descriptor_pb2, self._options_class_name): + raise RuntimeError( + 'Unknown options class name %s!' % self._options_class_name + ) + options_class = getattr(descriptor_pb2, self._options_class_name) + features = None + edition = self.file._edition + + if not self.has_options: + if not self._features: + features = self._ResolveFeatures( + descriptor_pb2.Edition.Value(edition), options_class() + ) + with _lock: + self._options = self._loaded_options = options_class() + if not self._features: + self._features = features + else: + if not self._serialized_options: + options = self._original_options + else: + options = _ParseOptions(options_class(), self._serialized_options) + + if not self._features: + features = self._ResolveFeatures( + descriptor_pb2.Edition.Value(edition), options + ) + with _lock: + self._options = self._loaded_options = options + if not self._features: + self._features = features + if options.HasField('features'): + options.ClearField('features') + if not options.SerializeToString(): + self._options = self._loaded_options = options_class() + self.has_options = False + + def GetOptions(self): + """Retrieves descriptor options. + + Returns: + The options set on this descriptor. + """ + # If either has been reset by gencode, reload options. + if not self._options or not self._loaded_options: + self._LazyLoadOptions() + return self._options + + +class _NestedDescriptorBase(DescriptorBase): + """Common class for descriptors that can be nested.""" + + def __init__( + self, + options, + options_class_name, + name, + full_name, + file, + containing_type, + serialized_start=None, + serialized_end=None, + serialized_options=None, + ): + """Constructor. + + Args: + options: Protocol message options or None to use default message options. + options_class_name (str): The class name of the above options. + name (str): Name of this protocol message type. + full_name (str): Fully-qualified name of this protocol message type, which + will include protocol "package" name and the name of any enclosing + types. + containing_type: if provided, this is a nested descriptor, with this + descriptor as parent, otherwise None. + serialized_start: The start index (inclusive) in block in the + file.serialized_pb that describes this descriptor. + serialized_end: The end index (exclusive) in block in the + file.serialized_pb that describes this descriptor. + serialized_options: Protocol message serialized options or None. + """ + super(_NestedDescriptorBase, self).__init__( + file, options, serialized_options, options_class_name + ) + + self.name = name + # TODO: Add function to calculate full_name instead of having it in + # memory? + self.full_name = full_name + self.containing_type = containing_type + + self._serialized_start = serialized_start + self._serialized_end = serialized_end + + def CopyToProto(self, proto): + """Copies this to the matching proto in descriptor_pb2. + + Args: + proto: An empty proto instance from descriptor_pb2. + + Raises: + Error: If self couldn't be serialized, due to to few constructor + arguments. + """ + if ( + self.file is not None + and self._serialized_start is not None + and self._serialized_end is not None + ): + proto.ParseFromString( + self.file.serialized_pb[self._serialized_start : self._serialized_end] + ) + else: + raise Error('Descriptor does not contain serialization.') + + +class Descriptor(_NestedDescriptorBase): + """Descriptor for a protocol message type. + + Attributes: + name (str): Name of this protocol message type. + full_name (str): Fully-qualified name of this protocol message type, which + will include protocol "package" name and the name of any enclosing + types. + containing_type (Descriptor): Reference to the descriptor of the type + containing us, or None if this is top-level. + fields (list[FieldDescriptor]): Field descriptors for all fields in this + type. + fields_by_number (dict(int, FieldDescriptor)): Same + :class:`FieldDescriptor` objects as in :attr:`fields`, but indexed by + "number" attribute in each FieldDescriptor. + fields_by_name (dict(str, FieldDescriptor)): Same :class:`FieldDescriptor` + objects as in :attr:`fields`, but indexed by "name" attribute in each + :class:`FieldDescriptor`. + nested_types (list[Descriptor]): Descriptor references for all protocol + message types nested within this one. + nested_types_by_name (dict(str, Descriptor)): Same Descriptor objects as + in :attr:`nested_types`, but indexed by "name" attribute in each + Descriptor. + enum_types (list[EnumDescriptor]): :class:`EnumDescriptor` references for + all enums contained within this type. + enum_types_by_name (dict(str, EnumDescriptor)): Same + :class:`EnumDescriptor` objects as in :attr:`enum_types`, but indexed by + "name" attribute in each EnumDescriptor. + enum_values_by_name (dict(str, EnumValueDescriptor)): Dict mapping from + enum value name to :class:`EnumValueDescriptor` for that value. + extensions (list[FieldDescriptor]): All extensions defined directly within + this message type (NOT within a nested type). + extensions_by_name (dict(str, FieldDescriptor)): Same FieldDescriptor + objects as :attr:`extensions`, but indexed by "name" attribute of each + FieldDescriptor. + is_extendable (bool): Does this type define any extension ranges? + oneofs (list[OneofDescriptor]): The list of descriptors for oneof fields + in this message. + oneofs_by_name (dict(str, OneofDescriptor)): Same objects as in + :attr:`oneofs`, but indexed by "name" attribute. + file (FileDescriptor): Reference to file descriptor. + is_map_entry: If the message type is a map entry. + """ + + if _USE_C_DESCRIPTORS: + _C_DESCRIPTOR_CLASS = _message.Descriptor + + def __new__( + cls, + name=None, + full_name=None, + filename=None, + containing_type=None, + fields=None, + nested_types=None, + enum_types=None, + extensions=None, + options=None, + serialized_options=None, + is_extendable=True, + extension_ranges=None, + oneofs=None, + file=None, # pylint: disable=redefined-builtin + serialized_start=None, + serialized_end=None, + syntax=None, + is_map_entry=False, + create_key=None, + ): + _message.Message._CheckCalledFromGeneratedFile() + return _message.default_pool.FindMessageTypeByName(full_name) + + # NOTE: The file argument redefining a builtin is nothing we can + # fix right now since we don't know how many clients already rely on the + # name of the argument. + def __init__( + self, + name, + full_name, + filename, + containing_type, + fields, + nested_types, + enum_types, + extensions, + options=None, + serialized_options=None, + is_extendable=True, + extension_ranges=None, + oneofs=None, + file=None, + serialized_start=None, + serialized_end=None, # pylint: disable=redefined-builtin + syntax=None, + is_map_entry=False, + create_key=None, + ): + """Arguments to __init__() are as described in the description + + of Descriptor fields above. + + Note that filename is an obsolete argument, that is not used anymore. + Please use file.name to access this as an attribute. + """ + if create_key is not _internal_create_key: + _Deprecated('create function Descriptor()') + + super(Descriptor, self).__init__( + options, + 'MessageOptions', + name, + full_name, + file, + containing_type, + serialized_start=serialized_start, + serialized_end=serialized_end, + serialized_options=serialized_options, + ) + + # We have fields in addition to fields_by_name and fields_by_number, + # so that: + # 1. Clients can index fields by "order in which they're listed." + # 2. Clients can easily iterate over all fields with the terse + # syntax: for f in descriptor.fields: ... + self.fields = fields + for field in self.fields: + field.containing_type = self + field.file = file + self.fields_by_number = dict((f.number, f) for f in fields) + self.fields_by_name = dict((f.name, f) for f in fields) + self._fields_by_camelcase_name = None + + self.nested_types = nested_types + for nested_type in nested_types: + nested_type.containing_type = self + self.nested_types_by_name = dict((t.name, t) for t in nested_types) + + self.enum_types = enum_types + for enum_type in self.enum_types: + enum_type.containing_type = self + self.enum_types_by_name = dict((t.name, t) for t in enum_types) + self.enum_values_by_name = dict( + (v.name, v) for t in enum_types for v in t.values + ) + + self.extensions = extensions + for extension in self.extensions: + extension.extension_scope = self + self.extensions_by_name = dict((f.name, f) for f in extensions) + self.is_extendable = is_extendable + self.extension_ranges = extension_ranges + self.oneofs = oneofs if oneofs is not None else [] + self.oneofs_by_name = dict((o.name, o) for o in self.oneofs) + for oneof in self.oneofs: + oneof.containing_type = self + oneof.file = file + self._is_map_entry = is_map_entry + + @property + def _parent(self): + return self.containing_type or self.file + + @property + def fields_by_camelcase_name(self): + """Same FieldDescriptor objects as in :attr:`fields`, but indexed by + + :attr:`FieldDescriptor.camelcase_name`. + """ + if self._fields_by_camelcase_name is None: + self._fields_by_camelcase_name = dict( + (f.camelcase_name, f) for f in self.fields + ) + return self._fields_by_camelcase_name + + def EnumValueName(self, enum, value): + """Returns the string name of an enum value. + + This is just a small helper method to simplify a common operation. + + Args: + enum: string name of the Enum. + value: int, value of the enum. + + Returns: + string name of the enum value. + + Raises: + KeyError if either the Enum doesn't exist or the value is not a valid + value for the enum. + """ + return self.enum_types_by_name[enum].values_by_number[value].name + + def CopyToProto(self, proto): + """Copies this to a descriptor_pb2.DescriptorProto. + + Args: + proto: An empty descriptor_pb2.DescriptorProto. + """ + # This function is overridden to give a better doc comment. + super(Descriptor, self).CopyToProto(proto) + + +# TODO: We should have aggressive checking here, +# for example: +# * If you specify a repeated field, you should not be allowed +# to specify a default value. +# * [Other examples here as needed]. +# +# TODO: for this and other *Descriptor classes, we +# might also want to lock things down aggressively (e.g., +# prevent clients from setting the attributes). Having +# stronger invariants here in general will reduce the number +# of runtime checks we must do in reflection.py... +class FieldDescriptor(DescriptorBase): + """Descriptor for a single field in a .proto file. + + Attributes: + name (str): Name of this field, exactly as it appears in .proto. + full_name (str): Name of this field, including containing scope. This is + particularly relevant for extensions. + index (int): Dense, 0-indexed index giving the order that this field + textually appears within its message in the .proto file. + number (int): Tag number declared for this field in the .proto file. + type (int): (One of the TYPE_* constants below) Declared type. + cpp_type (int): (One of the CPPTYPE_* constants below) C++ type used to + represent this field. + label (int): (One of the LABEL_* constants below) Tells whether this field + is optional, required, or repeated. + has_default_value (bool): True if this field has a default value defined, + otherwise false. + default_value (Varies): Default value of this field. Only meaningful for + non-repeated scalar fields. Repeated fields should always set this to [], + and non-repeated composite fields should always set this to None. + containing_type (Descriptor): Descriptor of the protocol message type that + contains this field. Set by the Descriptor constructor if we're passed + into one. Somewhat confusingly, for extension fields, this is the + descriptor of the EXTENDED message, not the descriptor of the message + containing this field. (See is_extension and extension_scope below). + message_type (Descriptor): If a composite field, a descriptor of the message + type contained in this field. Otherwise, this is None. + enum_type (EnumDescriptor): If this field contains an enum, a descriptor of + that enum. Otherwise, this is None. + is_extension: True iff this describes an extension field. + extension_scope (Descriptor): Only meaningful if is_extension is True. Gives + the message that immediately contains this extension field. Will be None + iff we're a top-level (file-level) extension field. + options (descriptor_pb2.FieldOptions): Protocol message field options or + None to use default field options. + containing_oneof (OneofDescriptor): If the field is a member of a oneof + union, contains its descriptor. Otherwise, None. + file (FileDescriptor): Reference to file descriptor. + """ + + # Must be consistent with C++ FieldDescriptor::Type enum in + # descriptor.h. + # + # TODO: Find a way to eliminate this repetition. + TYPE_DOUBLE = 1 + TYPE_FLOAT = 2 + TYPE_INT64 = 3 + TYPE_UINT64 = 4 + TYPE_INT32 = 5 + TYPE_FIXED64 = 6 + TYPE_FIXED32 = 7 + TYPE_BOOL = 8 + TYPE_STRING = 9 + TYPE_GROUP = 10 + TYPE_MESSAGE = 11 + TYPE_BYTES = 12 + TYPE_UINT32 = 13 + TYPE_ENUM = 14 + TYPE_SFIXED32 = 15 + TYPE_SFIXED64 = 16 + TYPE_SINT32 = 17 + TYPE_SINT64 = 18 + MAX_TYPE = 18 + + # Must be consistent with C++ FieldDescriptor::CppType enum in + # descriptor.h. + # + # TODO: Find a way to eliminate this repetition. + CPPTYPE_INT32 = 1 + CPPTYPE_INT64 = 2 + CPPTYPE_UINT32 = 3 + CPPTYPE_UINT64 = 4 + CPPTYPE_DOUBLE = 5 + CPPTYPE_FLOAT = 6 + CPPTYPE_BOOL = 7 + CPPTYPE_ENUM = 8 + CPPTYPE_STRING = 9 + CPPTYPE_MESSAGE = 10 + MAX_CPPTYPE = 10 + + _PYTHON_TO_CPP_PROTO_TYPE_MAP = { + TYPE_DOUBLE: CPPTYPE_DOUBLE, + TYPE_FLOAT: CPPTYPE_FLOAT, + TYPE_ENUM: CPPTYPE_ENUM, + TYPE_INT64: CPPTYPE_INT64, + TYPE_SINT64: CPPTYPE_INT64, + TYPE_SFIXED64: CPPTYPE_INT64, + TYPE_UINT64: CPPTYPE_UINT64, + TYPE_FIXED64: CPPTYPE_UINT64, + TYPE_INT32: CPPTYPE_INT32, + TYPE_SFIXED32: CPPTYPE_INT32, + TYPE_SINT32: CPPTYPE_INT32, + TYPE_UINT32: CPPTYPE_UINT32, + TYPE_FIXED32: CPPTYPE_UINT32, + TYPE_BYTES: CPPTYPE_STRING, + TYPE_STRING: CPPTYPE_STRING, + TYPE_BOOL: CPPTYPE_BOOL, + TYPE_MESSAGE: CPPTYPE_MESSAGE, + TYPE_GROUP: CPPTYPE_MESSAGE, + } + + # Must be consistent with C++ FieldDescriptor::Label enum in + # descriptor.h. + # + # TODO: Find a way to eliminate this repetition. + LABEL_OPTIONAL = 1 + LABEL_REQUIRED = 2 + LABEL_REPEATED = 3 + MAX_LABEL = 3 + + # Must be consistent with C++ constants kMaxNumber, kFirstReservedNumber, + # and kLastReservedNumber in descriptor.h + MAX_FIELD_NUMBER = (1 << 29) - 1 + FIRST_RESERVED_FIELD_NUMBER = 19000 + LAST_RESERVED_FIELD_NUMBER = 19999 + + if _USE_C_DESCRIPTORS: + _C_DESCRIPTOR_CLASS = _message.FieldDescriptor + + def __new__( + cls, + name, + full_name, + index, + number, + type, + cpp_type, + label, + default_value, + message_type, + enum_type, + containing_type, + is_extension, + extension_scope, + options=None, + serialized_options=None, + has_default_value=True, + containing_oneof=None, + json_name=None, + file=None, + create_key=None, + ): # pylint: disable=redefined-builtin + _message.Message._CheckCalledFromGeneratedFile() + if is_extension: + return _message.default_pool.FindExtensionByName(full_name) + else: + return _message.default_pool.FindFieldByName(full_name) + + def __init__( + self, + name, + full_name, + index, + number, + type, + cpp_type, + label, + default_value, + message_type, + enum_type, + containing_type, + is_extension, + extension_scope, + options=None, + serialized_options=None, + has_default_value=True, + containing_oneof=None, + json_name=None, + file=None, + create_key=None, + ): # pylint: disable=redefined-builtin + """The arguments are as described in the description of FieldDescriptor + + attributes above. + + Note that containing_type may be None, and may be set later if necessary + (to deal with circular references between message types, for example). + Likewise for extension_scope. + """ + if create_key is not _internal_create_key: + _Deprecated('create function FieldDescriptor()') + + super(FieldDescriptor, self).__init__( + file, options, serialized_options, 'FieldOptions' + ) + self.name = name + self.full_name = full_name + self._camelcase_name = None + if json_name is None: + self.json_name = _ToJsonName(name) + else: + self.json_name = json_name + self.index = index + self.number = number + self._type = type + self.cpp_type = cpp_type + self._label = label + self.has_default_value = has_default_value + self.default_value = default_value + self.containing_type = containing_type + self.message_type = message_type + self.enum_type = enum_type + self.is_extension = is_extension + self.extension_scope = extension_scope + self.containing_oneof = containing_oneof + if api_implementation.Type() == 'python': + self._cdescriptor = None + else: + if is_extension: + self._cdescriptor = _message.default_pool.FindExtensionByName(full_name) + else: + self._cdescriptor = _message.default_pool.FindFieldByName(full_name) + + @property + def _parent(self): + if self.containing_oneof: + return self.containing_oneof + if self.is_extension: + return self.extension_scope or self.file + return self.containing_type + + def _InferLegacyFeatures(self, edition, options, features): + # pylint: disable=g-import-not-at-top + from google.protobuf import descriptor_pb2 + + if edition >= descriptor_pb2.Edition.EDITION_2023: + return + + if self._label == FieldDescriptor.LABEL_REQUIRED: + features.field_presence = ( + descriptor_pb2.FeatureSet.FieldPresence.LEGACY_REQUIRED + ) + + if self._type == FieldDescriptor.TYPE_GROUP: + features.message_encoding = ( + descriptor_pb2.FeatureSet.MessageEncoding.DELIMITED + ) + + if options.HasField('packed'): + features.repeated_field_encoding = ( + descriptor_pb2.FeatureSet.RepeatedFieldEncoding.PACKED + if options.packed + else descriptor_pb2.FeatureSet.RepeatedFieldEncoding.EXPANDED + ) + + @property + def type(self): + if ( + self._GetFeatures().message_encoding + == _FEATURESET_MESSAGE_ENCODING_DELIMITED + and self.message_type + and not self.message_type.GetOptions().map_entry + and not self.containing_type.GetOptions().map_entry + ): + return FieldDescriptor.TYPE_GROUP + return self._type + + @type.setter + def type(self, val): + self._type = val + + @property + def is_required(self): + """Returns if the field is required.""" + return ( + self._GetFeatures().field_presence + == _FEATURESET_FIELD_PRESENCE_LEGACY_REQUIRED + ) + + @property + def is_repeated(self): + """Returns if the field is repeated.""" + return self._label == FieldDescriptor.LABEL_REPEATED + + @property + def camelcase_name(self): + """Camelcase name of this field. + + Returns: + str: the name in CamelCase. + """ + if self._camelcase_name is None: + self._camelcase_name = _ToCamelCase(self.name) + return self._camelcase_name + + @property + def has_presence(self): + """Whether the field distinguishes between unpopulated and default values. + + Raises: + RuntimeError: singular field that is not linked with message nor file. + """ + if self.is_repeated: + return False + if ( + self.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE + or self.is_extension + or self.containing_oneof + ): + return True + + return ( + self._GetFeatures().field_presence + != _FEATURESET_FIELD_PRESENCE_IMPLICIT + ) + + @property + def is_packed(self): + """Returns if the field is packed.""" + if not self.is_repeated: + return False + field_type = self.type + if ( + field_type == FieldDescriptor.TYPE_STRING + or field_type == FieldDescriptor.TYPE_GROUP + or field_type == FieldDescriptor.TYPE_MESSAGE + or field_type == FieldDescriptor.TYPE_BYTES + ): + return False + + return ( + self._GetFeatures().repeated_field_encoding + == _FEATURESET_REPEATED_FIELD_ENCODING_PACKED + ) + + @staticmethod + def ProtoTypeToCppProtoType(proto_type): + """Converts from a Python proto type to a C++ Proto Type. + + The Python ProtocolBuffer classes specify both the 'Python' datatype and the + 'C++' datatype - and they're not the same. This helper method should + translate from one to another. + + Args: + proto_type: the Python proto type (descriptor.FieldDescriptor.TYPE_*) + + Returns: + int: descriptor.FieldDescriptor.CPPTYPE_*, the C++ type. + Raises: + TypeTransformationError: when the Python proto type isn't known. + """ + try: + return FieldDescriptor._PYTHON_TO_CPP_PROTO_TYPE_MAP[proto_type] + except KeyError: + raise TypeTransformationError('Unknown proto_type: %s' % proto_type) + + +class EnumDescriptor(_NestedDescriptorBase): + """Descriptor for an enum defined in a .proto file. + + Attributes: + name (str): Name of the enum type. + full_name (str): Full name of the type, including package name and any + enclosing type(s). + values (list[EnumValueDescriptor]): List of the values in this enum. + values_by_name (dict(str, EnumValueDescriptor)): Same as :attr:`values`, but + indexed by the "name" field of each EnumValueDescriptor. + values_by_number (dict(int, EnumValueDescriptor)): Same as :attr:`values`, + but indexed by the "number" field of each EnumValueDescriptor. + containing_type (Descriptor): Descriptor of the immediate containing type of + this enum, or None if this is an enum defined at the top level in a .proto + file. Set by Descriptor's constructor if we're passed into one. + file (FileDescriptor): Reference to file descriptor. + options (descriptor_pb2.EnumOptions): Enum options message or None to use + default enum options. + """ + + if _USE_C_DESCRIPTORS: + _C_DESCRIPTOR_CLASS = _message.EnumDescriptor + + def __new__( + cls, + name, + full_name, + filename, + values, + containing_type=None, + options=None, + serialized_options=None, + file=None, # pylint: disable=redefined-builtin + serialized_start=None, + serialized_end=None, + create_key=None, + ): + _message.Message._CheckCalledFromGeneratedFile() + return _message.default_pool.FindEnumTypeByName(full_name) + + def __init__( + self, + name, + full_name, + filename, + values, + containing_type=None, + options=None, + serialized_options=None, + file=None, # pylint: disable=redefined-builtin + serialized_start=None, + serialized_end=None, + create_key=None, + ): + """Arguments are as described in the attribute description above. + + Note that filename is an obsolete argument, that is not used anymore. + Please use file.name to access this as an attribute. + """ + if create_key is not _internal_create_key: + _Deprecated('create function EnumDescriptor()') + + super(EnumDescriptor, self).__init__( + options, + 'EnumOptions', + name, + full_name, + file, + containing_type, + serialized_start=serialized_start, + serialized_end=serialized_end, + serialized_options=serialized_options, + ) + + self.values = values + for value in self.values: + value.file = file + value.type = self + self.values_by_name = dict((v.name, v) for v in values) + # Values are reversed to ensure that the first alias is retained. + self.values_by_number = dict((v.number, v) for v in reversed(values)) + + @property + def _parent(self): + return self.containing_type or self.file + + @property + def is_closed(self): + """Returns true whether this is a "closed" enum. + + This means that it: + - Has a fixed set of values, rather than being equivalent to an int32. + - Encountering values not in this set causes them to be treated as unknown + fields. + - The first value (i.e., the default) may be nonzero. + + WARNING: Some runtimes currently have a quirk where non-closed enums are + treated as closed when used as the type of fields defined in a + `syntax = proto2;` file. This quirk is not present in all runtimes; as of + writing, we know that: + + - C++, Java, and C++-based Python share this quirk. + - UPB and UPB-based Python do not. + - PHP and Ruby treat all enums as open regardless of declaration. + + Care should be taken when using this function to respect the target + runtime's enum handling quirks. + """ + return self._GetFeatures().enum_type == _FEATURESET_ENUM_TYPE_CLOSED + + def CopyToProto(self, proto): + """Copies this to a descriptor_pb2.EnumDescriptorProto. + + Args: + proto (descriptor_pb2.EnumDescriptorProto): An empty descriptor proto. + """ + # This function is overridden to give a better doc comment. + super(EnumDescriptor, self).CopyToProto(proto) + + +class EnumValueDescriptor(DescriptorBase): + """Descriptor for a single value within an enum. + + Attributes: + name (str): Name of this value. + index (int): Dense, 0-indexed index giving the order that this value appears + textually within its enum in the .proto file. + number (int): Actual number assigned to this enum value. + type (EnumDescriptor): :class:`EnumDescriptor` to which this value belongs. + Set by :class:`EnumDescriptor`'s constructor if we're passed into one. + options (descriptor_pb2.EnumValueOptions): Enum value options message or + None to use default enum value options options. + """ + + if _USE_C_DESCRIPTORS: + _C_DESCRIPTOR_CLASS = _message.EnumValueDescriptor + + def __new__( + cls, + name, + index, + number, + type=None, # pylint: disable=redefined-builtin + options=None, + serialized_options=None, + create_key=None, + ): + _message.Message._CheckCalledFromGeneratedFile() + # There is no way we can build a complete EnumValueDescriptor with the + # given parameters (the name of the Enum is not known, for example). + # Fortunately generated files just pass it to the EnumDescriptor() + # constructor, which will ignore it, so returning None is good enough. + return None + + def __init__( + self, + name, + index, + number, + type=None, # pylint: disable=redefined-builtin + options=None, + serialized_options=None, + create_key=None, + ): + """Arguments are as described in the attribute description above.""" + if create_key is not _internal_create_key: + _Deprecated('create function EnumValueDescriptor()') + + super(EnumValueDescriptor, self).__init__( + type.file if type else None, + options, + serialized_options, + 'EnumValueOptions', + ) + self.name = name + self.index = index + self.number = number + self.type = type + + @property + def _parent(self): + return self.type + + +class OneofDescriptor(DescriptorBase): + """Descriptor for a oneof field. + + Attributes: + name (str): Name of the oneof field. + full_name (str): Full name of the oneof field, including package name. + index (int): 0-based index giving the order of the oneof field inside its + containing type. + containing_type (Descriptor): :class:`Descriptor` of the protocol message + type that contains this field. Set by the :class:`Descriptor` constructor + if we're passed into one. + fields (list[FieldDescriptor]): The list of field descriptors this oneof can + contain. + """ + + if _USE_C_DESCRIPTORS: + _C_DESCRIPTOR_CLASS = _message.OneofDescriptor + + def __new__( + cls, + name, + full_name, + index, + containing_type, + fields, + options=None, + serialized_options=None, + create_key=None, + ): + _message.Message._CheckCalledFromGeneratedFile() + return _message.default_pool.FindOneofByName(full_name) + + def __init__( + self, + name, + full_name, + index, + containing_type, + fields, + options=None, + serialized_options=None, + create_key=None, + ): + """Arguments are as described in the attribute description above.""" + if create_key is not _internal_create_key: + _Deprecated('create function OneofDescriptor()') + + super(OneofDescriptor, self).__init__( + containing_type.file if containing_type else None, + options, + serialized_options, + 'OneofOptions', + ) + self.name = name + self.full_name = full_name + self.index = index + self.containing_type = containing_type + self.fields = fields + + @property + def _parent(self): + return self.containing_type + + +class ServiceDescriptor(_NestedDescriptorBase): + """Descriptor for a service. + + Attributes: + name (str): Name of the service. + full_name (str): Full name of the service, including package name. + index (int): 0-indexed index giving the order that this services definition + appears within the .proto file. + methods (list[MethodDescriptor]): List of methods provided by this service. + methods_by_name (dict(str, MethodDescriptor)): Same + :class:`MethodDescriptor` objects as in :attr:`methods_by_name`, but + indexed by "name" attribute in each :class:`MethodDescriptor`. + options (descriptor_pb2.ServiceOptions): Service options message or None to + use default service options. + file (FileDescriptor): Reference to file info. + """ + + if _USE_C_DESCRIPTORS: + _C_DESCRIPTOR_CLASS = _message.ServiceDescriptor + + def __new__( + cls, + name=None, + full_name=None, + index=None, + methods=None, + options=None, + serialized_options=None, + file=None, # pylint: disable=redefined-builtin + serialized_start=None, + serialized_end=None, + create_key=None, + ): + _message.Message._CheckCalledFromGeneratedFile() # pylint: disable=protected-access + return _message.default_pool.FindServiceByName(full_name) + + def __init__( + self, + name, + full_name, + index, + methods, + options=None, + serialized_options=None, + file=None, # pylint: disable=redefined-builtin + serialized_start=None, + serialized_end=None, + create_key=None, + ): + if create_key is not _internal_create_key: + _Deprecated('create function ServiceDescriptor()') + + super(ServiceDescriptor, self).__init__( + options, + 'ServiceOptions', + name, + full_name, + file, + None, + serialized_start=serialized_start, + serialized_end=serialized_end, + serialized_options=serialized_options, + ) + self.index = index + self.methods = methods + self.methods_by_name = dict((m.name, m) for m in methods) + # Set the containing service for each method in this service. + for method in self.methods: + method.file = self.file + method.containing_service = self + + @property + def _parent(self): + return self.file + + def FindMethodByName(self, name): + """Searches for the specified method, and returns its descriptor. + + Args: + name (str): Name of the method. + + Returns: + MethodDescriptor: The descriptor for the requested method. + + Raises: + KeyError: if the method cannot be found in the service. + """ + return self.methods_by_name[name] + + def CopyToProto(self, proto): + """Copies this to a descriptor_pb2.ServiceDescriptorProto. + + Args: + proto (descriptor_pb2.ServiceDescriptorProto): An empty descriptor proto. + """ + # This function is overridden to give a better doc comment. + super(ServiceDescriptor, self).CopyToProto(proto) + + +class MethodDescriptor(DescriptorBase): + """Descriptor for a method in a service. + + Attributes: + name (str): Name of the method within the service. + full_name (str): Full name of method. + index (int): 0-indexed index of the method inside the service. + containing_service (ServiceDescriptor): The service that contains this + method. + input_type (Descriptor): The descriptor of the message that this method + accepts. + output_type (Descriptor): The descriptor of the message that this method + returns. + client_streaming (bool): Whether this method uses client streaming. + server_streaming (bool): Whether this method uses server streaming. + options (descriptor_pb2.MethodOptions or None): Method options message, or + None to use default method options. + """ + + if _USE_C_DESCRIPTORS: + _C_DESCRIPTOR_CLASS = _message.MethodDescriptor + + def __new__( + cls, + name, + full_name, + index, + containing_service, + input_type, + output_type, + client_streaming=False, + server_streaming=False, + options=None, + serialized_options=None, + create_key=None, + ): + _message.Message._CheckCalledFromGeneratedFile() # pylint: disable=protected-access + return _message.default_pool.FindMethodByName(full_name) + + def __init__( + self, + name, + full_name, + index, + containing_service, + input_type, + output_type, + client_streaming=False, + server_streaming=False, + options=None, + serialized_options=None, + create_key=None, + ): + """The arguments are as described in the description of MethodDescriptor + + attributes above. + + Note that containing_service may be None, and may be set later if necessary. + """ + if create_key is not _internal_create_key: + _Deprecated('create function MethodDescriptor()') + + super(MethodDescriptor, self).__init__( + containing_service.file if containing_service else None, + options, + serialized_options, + 'MethodOptions', + ) + self.name = name + self.full_name = full_name + self.index = index + self.containing_service = containing_service + self.input_type = input_type + self.output_type = output_type + self.client_streaming = client_streaming + self.server_streaming = server_streaming + + @property + def _parent(self): + return self.containing_service + + def CopyToProto(self, proto): + """Copies this to a descriptor_pb2.MethodDescriptorProto. + + Args: + proto (descriptor_pb2.MethodDescriptorProto): An empty descriptor proto. + + Raises: + Error: If self couldn't be serialized, due to too few constructor + arguments. + """ + if self.containing_service is not None: + from google.protobuf import descriptor_pb2 + + service_proto = descriptor_pb2.ServiceDescriptorProto() + self.containing_service.CopyToProto(service_proto) + proto.CopyFrom(service_proto.method[self.index]) + else: + raise Error('Descriptor does not contain a service.') + + +class FileDescriptor(DescriptorBase): + """Descriptor for a file. Mimics the descriptor_pb2.FileDescriptorProto. + + Note that :attr:`enum_types_by_name`, :attr:`extensions_by_name`, and + :attr:`dependencies` fields are only set by the + :py:mod:`google.protobuf.message_factory` module, and not by the generated + proto code. + + Attributes: + name (str): Name of file, relative to root of source tree. + package (str): Name of the package + edition (Edition): Enum value indicating edition of the file + serialized_pb (bytes): Byte string of serialized + :class:`descriptor_pb2.FileDescriptorProto`. + dependencies (list[FileDescriptor]): List of other :class:`FileDescriptor` + objects this :class:`FileDescriptor` depends on. + public_dependencies (list[FileDescriptor]): A subset of + :attr:`dependencies`, which were declared as "public". + message_types_by_name (dict(str, Descriptor)): Mapping from message names to + their :class:`Descriptor`. + enum_types_by_name (dict(str, EnumDescriptor)): Mapping from enum names to + their :class:`EnumDescriptor`. + extensions_by_name (dict(str, FieldDescriptor)): Mapping from extension + names declared at file scope to their :class:`FieldDescriptor`. + services_by_name (dict(str, ServiceDescriptor)): Mapping from services' + names to their :class:`ServiceDescriptor`. + pool (DescriptorPool): The pool this descriptor belongs to. When not passed + to the constructor, the global default pool is used. + """ + + if _USE_C_DESCRIPTORS: + _C_DESCRIPTOR_CLASS = _message.FileDescriptor + + def __new__( + cls, + name, + package, + options=None, + serialized_options=None, + serialized_pb=None, + dependencies=None, + public_dependencies=None, + syntax=None, + edition=None, + pool=None, + create_key=None, + ): + # FileDescriptor() is called from various places, not only from generated + # files, to register dynamic proto files and messages. + # pylint: disable=g-explicit-bool-comparison + if serialized_pb: + return _message.default_pool.AddSerializedFile(serialized_pb) + else: + return super(FileDescriptor, cls).__new__(cls) + + def __init__( + self, + name, + package, + options=None, + serialized_options=None, + serialized_pb=None, + dependencies=None, + public_dependencies=None, + syntax=None, + edition=None, + pool=None, + create_key=None, + ): + """Constructor.""" + if create_key is not _internal_create_key: + _Deprecated('create function FileDescriptor()') + + super(FileDescriptor, self).__init__( + self, options, serialized_options, 'FileOptions' + ) + + if edition and edition != 'EDITION_UNKNOWN': + self._edition = edition + elif syntax == 'proto3': + self._edition = 'EDITION_PROTO3' + else: + self._edition = 'EDITION_PROTO2' + + if pool is None: + from google.protobuf import descriptor_pool + + pool = descriptor_pool.Default() + self.pool = pool + self.message_types_by_name = {} + self.name = name + self.package = package + self.serialized_pb = serialized_pb + + self.enum_types_by_name = {} + self.extensions_by_name = {} + self.services_by_name = {} + self.dependencies = dependencies or [] + self.public_dependencies = public_dependencies or [] + + def CopyToProto(self, proto): + """Copies this to a descriptor_pb2.FileDescriptorProto. + + Args: + proto: An empty descriptor_pb2.FileDescriptorProto. + """ + proto.ParseFromString(self.serialized_pb) + + @property + def _parent(self): + return None + + +def _ParseOptions(message, string): + """Parses serialized options. + + This helper function is used to parse serialized options in generated + proto2 files. It must not be used outside proto2. + """ + message.ParseFromString(string) + return message + + +def _ToCamelCase(name): + """Converts name to camel-case and returns it.""" + capitalize_next = False + result = [] + + for c in name: + if c == '_': + if result: + capitalize_next = True + elif capitalize_next: + result.append(c.upper()) + capitalize_next = False + else: + result += c + + # Lower-case the first letter. + if result and result[0].isupper(): + result[0] = result[0].lower() + return ''.join(result) + + +def _OptionsOrNone(descriptor_proto): + """Returns the value of the field `options`, or None if it is not set.""" + if descriptor_proto.HasField('options'): + return descriptor_proto.options + else: + return None + + +def _ToJsonName(name): + """Converts name to Json name and returns it.""" + capitalize_next = False + result = [] + + for c in name: + if c == '_': + capitalize_next = True + elif capitalize_next: + result.append(c.upper()) + capitalize_next = False + else: + result += c + + return ''.join(result) + + +def MakeDescriptor( + desc_proto, + package='', + build_file_if_cpp=True, + syntax=None, + edition=None, + file_desc=None, +): + """Make a protobuf Descriptor given a DescriptorProto protobuf. + + Handles nested descriptors. Note that this is limited to the scope of defining + a message inside of another message. Composite fields can currently only be + resolved if the message is defined in the same scope as the field. + + Args: + desc_proto: The descriptor_pb2.DescriptorProto protobuf message. + package: Optional package name for the new message Descriptor (string). + build_file_if_cpp: Update the C++ descriptor pool if api matches. Set to + False on recursion, so no duplicates are created. + syntax: The syntax/semantics that should be used. Set to "proto3" to get + proto3 field presence semantics. + edition: The edition that should be used if syntax is "edition". + file_desc: A FileDescriptor to place this descriptor into. + + Returns: + A Descriptor for protobuf messages. + """ + # pylint: disable=g-import-not-at-top + from google.protobuf import descriptor_pb2 + + # Generate a random name for this proto file to prevent conflicts with any + # imported ones. We need to specify a file name so the descriptor pool + # accepts our FileDescriptorProto, but it is not important what that file + # name is actually set to. + proto_name = binascii.hexlify(os.urandom(16)).decode('ascii') + + if package: + file_name = os.path.join(package.replace('.', '/'), proto_name + '.proto') + else: + file_name = proto_name + '.proto' + + if api_implementation.Type() != 'python' and build_file_if_cpp: + # The C++ implementation requires all descriptors to be backed by the same + # definition in the C++ descriptor pool. To do this, we build a + # FileDescriptorProto with the same definition as this descriptor and build + # it into the pool. + file_descriptor_proto = descriptor_pb2.FileDescriptorProto() + file_descriptor_proto.message_type.add().MergeFrom(desc_proto) + + if package: + file_descriptor_proto.package = package + file_descriptor_proto.name = file_name + + _message.default_pool.Add(file_descriptor_proto) + result = _message.default_pool.FindFileByName(file_descriptor_proto.name) + + if _USE_C_DESCRIPTORS: + return result.message_types_by_name[desc_proto.name] + + if file_desc is None: + file_desc = FileDescriptor( + pool=None, + name=file_name, + package=package, + syntax=syntax, + edition=edition, + options=None, + serialized_pb='', + dependencies=[], + public_dependencies=[], + create_key=_internal_create_key, + ) + full_message_name = [desc_proto.name] + if package: + full_message_name.insert(0, package) + + # Create Descriptors for enum types + enum_types = {} + for enum_proto in desc_proto.enum_type: + full_name = '.'.join(full_message_name + [enum_proto.name]) + enum_desc = EnumDescriptor( + enum_proto.name, + full_name, + None, + [ + EnumValueDescriptor( + enum_val.name, + ii, + enum_val.number, + create_key=_internal_create_key, + ) + for ii, enum_val in enumerate(enum_proto.value) + ], + file=file_desc, + create_key=_internal_create_key, + ) + enum_types[full_name] = enum_desc + + # Create Descriptors for nested types + nested_types = {} + for nested_proto in desc_proto.nested_type: + full_name = '.'.join(full_message_name + [nested_proto.name]) + # Nested types are just those defined inside of the message, not all types + # used by fields in the message, so no loops are possible here. + nested_desc = MakeDescriptor( + nested_proto, + package='.'.join(full_message_name), + build_file_if_cpp=False, + syntax=syntax, + edition=edition, + file_desc=file_desc, + ) + nested_types[full_name] = nested_desc + + fields = [] + for field_proto in desc_proto.field: + full_name = '.'.join(full_message_name + [field_proto.name]) + enum_desc = None + nested_desc = None + if field_proto.json_name: + json_name = field_proto.json_name + else: + json_name = None + if field_proto.HasField('type_name'): + type_name = field_proto.type_name + full_type_name = '.'.join( + full_message_name + [type_name[type_name.rfind('.') + 1 :]] + ) + if full_type_name in nested_types: + nested_desc = nested_types[full_type_name] + elif full_type_name in enum_types: + enum_desc = enum_types[full_type_name] + # Else type_name references a non-local type, which isn't implemented + field = FieldDescriptor( + field_proto.name, + full_name, + field_proto.number - 1, + field_proto.number, + field_proto.type, + FieldDescriptor.ProtoTypeToCppProtoType(field_proto.type), + field_proto.label, + None, + nested_desc, + enum_desc, + None, + False, + None, + options=_OptionsOrNone(field_proto), + has_default_value=False, + json_name=json_name, + file=file_desc, + create_key=_internal_create_key, + ) + fields.append(field) + + desc_name = '.'.join(full_message_name) + return Descriptor( + desc_proto.name, + desc_name, + None, + None, + fields, + list(nested_types.values()), + list(enum_types.values()), + [], + options=_OptionsOrNone(desc_proto), + file=file_desc, + create_key=_internal_create_key, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_database.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_database.py new file mode 100644 index 0000000000000000000000000000000000000000..72777eee54b20e205b96a92b170b8be5d382c0a0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_database.py @@ -0,0 +1,185 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Provides a container for DescriptorProtos.""" + +__author__ = 'matthewtoia@google.com (Matt Toia)' + +from typing import Dict, Iterator, Optional +import warnings + + +class Error(Exception): + pass + + +class DescriptorDatabaseConflictingDefinitionError(Error): + """Raised when a proto is added with the same name & different descriptor.""" + + +class DescriptorDatabase(object): + """A container accepting FileDescriptorProtos and maps DescriptorProtos.""" + + def __init__(self) -> None: + self._file_desc_protos_by_file: Dict[ + str, 'descriptor_pb2.FileDescriptorProto' + ] = {} + self._file_desc_protos_by_symbol: Dict[ + str, 'descriptor_pb2.FileDescriptorProto' + ] = {} + + def Add(self, file_desc_proto: 'descriptor_pb2.FileDescriptorProto') -> None: + """Adds the FileDescriptorProto and its types to this database. + + Args: + file_desc_proto: The FileDescriptorProto to add. + Raises: + DescriptorDatabaseConflictingDefinitionError: if an attempt is made to + add a proto with the same name but different definition than an + existing proto in the database. + """ + proto_name = file_desc_proto.name + if proto_name not in self._file_desc_protos_by_file: + self._file_desc_protos_by_file[proto_name] = file_desc_proto + elif self._file_desc_protos_by_file[proto_name] != file_desc_proto: + raise DescriptorDatabaseConflictingDefinitionError( + '%s already added, but with different descriptor.' % proto_name) + else: + return + + # Add all the top-level descriptors to the index. + package = file_desc_proto.package + for message in file_desc_proto.message_type: + for name in _ExtractSymbols(message, package): + self._AddSymbol(name, file_desc_proto) + for enum in file_desc_proto.enum_type: + self._AddSymbol( + ('.'.join((package, enum.name)) if package else enum.name), + file_desc_proto, + ) + for enum_value in enum.value: + self._file_desc_protos_by_symbol[ + '.'.join((package, enum_value.name)) if package else enum_value.name + ] = file_desc_proto + for extension in file_desc_proto.extension: + self._AddSymbol( + ('.'.join((package, extension.name)) if package else extension.name), + file_desc_proto, + ) + for service in file_desc_proto.service: + self._AddSymbol( + ('.'.join((package, service.name)) if package else service.name), + file_desc_proto, + ) + + def FindFileByName(self, name: str) -> 'descriptor_pb2.FileDescriptorProto': + """Finds the file descriptor proto by file name. + + Typically the file name is a relative path ending to a .proto file. The + proto with the given name will have to have been added to this database + using the Add method or else an error will be raised. + + Args: + name: The file name to find. + + Returns: + The file descriptor proto matching the name. + + Raises: + KeyError if no file by the given name was added. + """ + + return self._file_desc_protos_by_file[name] + + def FindFileContainingSymbol( + self, symbol: str + ) -> 'descriptor_pb2.FileDescriptorProto': + """Finds the file descriptor proto containing the specified symbol. + + The symbol should be a fully qualified name including the file descriptor's + package and any containing messages. Some examples: + + 'some.package.name.Message' + 'some.package.name.Message.NestedEnum' + 'some.package.name.Message.some_field' + + The file descriptor proto containing the specified symbol must be added to + this database using the Add method or else an error will be raised. + + Args: + symbol: The fully qualified symbol name. + + Returns: + The file descriptor proto containing the symbol. + + Raises: + KeyError if no file contains the specified symbol. + """ + if symbol.count('.') == 1 and symbol[0] == '.': + symbol = symbol.lstrip('.') + warnings.warn( + 'Please remove the leading "." when ' + 'FindFileContainingSymbol, this will turn to error ' + 'in 2026 Jan.', + RuntimeWarning, + ) + try: + return self._file_desc_protos_by_symbol[symbol] + except KeyError: + # Fields, enum values, and nested extensions are not in + # _file_desc_protos_by_symbol. Try to find the top level + # descriptor. Non-existent nested symbol under a valid top level + # descriptor can also be found. The behavior is the same with + # protobuf C++. + top_level, _, _ = symbol.rpartition('.') + try: + return self._file_desc_protos_by_symbol[top_level] + except KeyError: + # Raise the original symbol as a KeyError for better diagnostics. + raise KeyError(symbol) + + def FindFileContainingExtension( + self, extendee_name: str, extension_number: int # pylint: disable=unused-argument + ) -> Optional['descriptor_pb2.FileDescriptorProto']: + # TODO: implement this API. + return None + + def FindAllExtensionNumbers(self, extendee_name: str) -> list[int]: # pylint: disable=unused-argument + # TODO: implement this API. + return [] + + def _AddSymbol( + self, name: str, file_desc_proto: 'descriptor_pb2.FileDescriptorProto' + ) -> None: + if name in self._file_desc_protos_by_symbol: + warn_msg = ('Conflict register for file "' + file_desc_proto.name + + '": ' + name + + ' is already defined in file "' + + self._file_desc_protos_by_symbol[name].name + '"') + warnings.warn(warn_msg, RuntimeWarning) + self._file_desc_protos_by_symbol[name] = file_desc_proto + + +def _ExtractSymbols( + desc_proto: 'descriptor_pb2.DescriptorProto', package: str +) -> Iterator[str]: + """Pulls out all the symbols from a descriptor proto. + + Args: + desc_proto: The proto to extract symbols from. + package: The package containing the descriptor type. + + Yields: + The fully qualified name found in the descriptor. + """ + message_name = package + '.' + desc_proto.name if package else desc_proto.name + yield message_name + for nested_type in desc_proto.nested_type: + for symbol in _ExtractSymbols(nested_type, message_name): + yield symbol + for enum_type in desc_proto.enum_type: + yield '.'.join((message_name, enum_type.name)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..f0c8c6cd1301a9b2cc353ccabc0a34b8175238f1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_pb2.py @@ -0,0 +1,3391 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/descriptor.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/descriptor.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +if not _descriptor._USE_C_DESCRIPTORS: + DESCRIPTOR = _descriptor.FileDescriptor( + name='google/protobuf/descriptor.proto', + package='google.protobuf', + syntax='proto2', + edition='EDITION_PROTO2', + serialized_options=b'\n\023com.google.protobufB\020DescriptorProtosH\001Z-google.golang.org/protobuf/types/descriptorpb\370\001\001\242\002\003GPB\252\002\032Google.Protobuf.Reflection', + create_key=_descriptor._internal_create_key, + serialized_pb=b'\n google/protobuf/descriptor.proto\x12\x0fgoogle.protobuf\"[\n\x11\x46ileDescriptorSet\x12\x38\n\x04\x66ile\x18\x01 \x03(\x0b\x32$.google.protobuf.FileDescriptorProtoR\x04\x66ile*\x0c\x08\x80\xec\xca\xff\x01\x10\x81\xec\xca\xff\x01\"\xc5\x05\n\x13\x46ileDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n\x07package\x18\x02 \x01(\tR\x07package\x12\x1e\n\ndependency\x18\x03 \x03(\tR\ndependency\x12+\n\x11public_dependency\x18\n \x03(\x05R\x10publicDependency\x12\'\n\x0fweak_dependency\x18\x0b \x03(\x05R\x0eweakDependency\x12+\n\x11option_dependency\x18\x0f \x03(\tR\x10optionDependency\x12\x43\n\x0cmessage_type\x18\x04 \x03(\x0b\x32 .google.protobuf.DescriptorProtoR\x0bmessageType\x12\x41\n\tenum_type\x18\x05 \x03(\x0b\x32$.google.protobuf.EnumDescriptorProtoR\x08\x65numType\x12\x41\n\x07service\x18\x06 \x03(\x0b\x32\'.google.protobuf.ServiceDescriptorProtoR\x07service\x12\x43\n\textension\x18\x07 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProtoR\textension\x12\x36\n\x07options\x18\x08 \x01(\x0b\x32\x1c.google.protobuf.FileOptionsR\x07options\x12I\n\x10source_code_info\x18\t \x01(\x0b\x32\x1f.google.protobuf.SourceCodeInfoR\x0esourceCodeInfo\x12\x16\n\x06syntax\x18\x0c \x01(\tR\x06syntax\x12\x32\n\x07\x65\x64ition\x18\x0e \x01(\x0e\x32\x18.google.protobuf.EditionR\x07\x65\x64ition\"\xfc\x06\n\x0f\x44\x65scriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12;\n\x05\x66ield\x18\x02 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProtoR\x05\x66ield\x12\x43\n\textension\x18\x06 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProtoR\textension\x12\x41\n\x0bnested_type\x18\x03 \x03(\x0b\x32 .google.protobuf.DescriptorProtoR\nnestedType\x12\x41\n\tenum_type\x18\x04 \x03(\x0b\x32$.google.protobuf.EnumDescriptorProtoR\x08\x65numType\x12X\n\x0f\x65xtension_range\x18\x05 \x03(\x0b\x32/.google.protobuf.DescriptorProto.ExtensionRangeR\x0e\x65xtensionRange\x12\x44\n\noneof_decl\x18\x08 \x03(\x0b\x32%.google.protobuf.OneofDescriptorProtoR\toneofDecl\x12\x39\n\x07options\x18\x07 \x01(\x0b\x32\x1f.google.protobuf.MessageOptionsR\x07options\x12U\n\x0ereserved_range\x18\t \x03(\x0b\x32..google.protobuf.DescriptorProto.ReservedRangeR\rreservedRange\x12#\n\rreserved_name\x18\n \x03(\tR\x0creservedName\x12\x41\n\nvisibility\x18\x0b \x01(\x0e\x32!.google.protobuf.SymbolVisibilityR\nvisibility\x1az\n\x0e\x45xtensionRange\x12\x14\n\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n\x03\x65nd\x18\x02 \x01(\x05R\x03\x65nd\x12@\n\x07options\x18\x03 \x01(\x0b\x32&.google.protobuf.ExtensionRangeOptionsR\x07options\x1a\x37\n\rReservedRange\x12\x14\n\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n\x03\x65nd\x18\x02 \x01(\x05R\x03\x65nd\"\xd4\x04\n\x15\x45xtensionRangeOptions\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\x12Y\n\x0b\x64\x65\x63laration\x18\x02 \x03(\x0b\x32\x32.google.protobuf.ExtensionRangeOptions.DeclarationB\x03\x88\x01\x02R\x0b\x64\x65\x63laration\x12\x37\n\x08\x66\x65\x61tures\x18\x32 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12m\n\x0cverification\x18\x03 \x01(\x0e\x32\x38.google.protobuf.ExtensionRangeOptions.VerificationState:\nUNVERIFIEDB\x03\x88\x01\x02R\x0cverification\x1a\x94\x01\n\x0b\x44\x65\x63laration\x12\x16\n\x06number\x18\x01 \x01(\x05R\x06number\x12\x1b\n\tfull_name\x18\x02 \x01(\tR\x08\x66ullName\x12\x12\n\x04type\x18\x03 \x01(\tR\x04type\x12\x1a\n\x08reserved\x18\x05 \x01(\x08R\x08reserved\x12\x1a\n\x08repeated\x18\x06 \x01(\x08R\x08repeatedJ\x04\x08\x04\x10\x05\"4\n\x11VerificationState\x12\x0f\n\x0b\x44\x45\x43LARATION\x10\x00\x12\x0e\n\nUNVERIFIED\x10\x01*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xc1\x06\n\x14\x46ieldDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n\x06number\x18\x03 \x01(\x05R\x06number\x12\x41\n\x05label\x18\x04 \x01(\x0e\x32+.google.protobuf.FieldDescriptorProto.LabelR\x05label\x12>\n\x04type\x18\x05 \x01(\x0e\x32*.google.protobuf.FieldDescriptorProto.TypeR\x04type\x12\x1b\n\ttype_name\x18\x06 \x01(\tR\x08typeName\x12\x1a\n\x08\x65xtendee\x18\x02 \x01(\tR\x08\x65xtendee\x12#\n\rdefault_value\x18\x07 \x01(\tR\x0c\x64\x65\x66\x61ultValue\x12\x1f\n\x0boneof_index\x18\t \x01(\x05R\noneofIndex\x12\x1b\n\tjson_name\x18\n \x01(\tR\x08jsonName\x12\x37\n\x07options\x18\x08 \x01(\x0b\x32\x1d.google.protobuf.FieldOptionsR\x07options\x12\'\n\x0fproto3_optional\x18\x11 \x01(\x08R\x0eproto3Optional\"\xb6\x02\n\x04Type\x12\x0f\n\x0bTYPE_DOUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\n\nTYPE_INT64\x10\x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_INT32\x10\x05\x12\x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED32\x10\x07\x12\r\n\tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\x0e\n\nTYPE_GROUP\x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTYPE_BYTES\x10\x0c\x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\x11\n\rTYPE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\x0bTYPE_SINT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"C\n\x05Label\x12\x12\n\x0eLABEL_OPTIONAL\x10\x01\x12\x12\n\x0eLABEL_REPEATED\x10\x03\x12\x12\n\x0eLABEL_REQUIRED\x10\x02\"c\n\x14OneofDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x37\n\x07options\x18\x02 \x01(\x0b\x32\x1d.google.protobuf.OneofOptionsR\x07options\"\xa6\x03\n\x13\x45numDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12?\n\x05value\x18\x02 \x03(\x0b\x32).google.protobuf.EnumValueDescriptorProtoR\x05value\x12\x36\n\x07options\x18\x03 \x01(\x0b\x32\x1c.google.protobuf.EnumOptionsR\x07options\x12]\n\x0ereserved_range\x18\x04 \x03(\x0b\x32\x36.google.protobuf.EnumDescriptorProto.EnumReservedRangeR\rreservedRange\x12#\n\rreserved_name\x18\x05 \x03(\tR\x0creservedName\x12\x41\n\nvisibility\x18\x06 \x01(\x0e\x32!.google.protobuf.SymbolVisibilityR\nvisibility\x1a;\n\x11\x45numReservedRange\x12\x14\n\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n\x03\x65nd\x18\x02 \x01(\x05R\x03\x65nd\"\x83\x01\n\x18\x45numValueDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n\x06number\x18\x02 \x01(\x05R\x06number\x12;\n\x07options\x18\x03 \x01(\x0b\x32!.google.protobuf.EnumValueOptionsR\x07options\"\xb5\x01\n\x16ServiceDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12>\n\x06method\x18\x02 \x03(\x0b\x32&.google.protobuf.MethodDescriptorProtoR\x06method\x12\x39\n\x07options\x18\x03 \x01(\x0b\x32\x1f.google.protobuf.ServiceOptionsR\x07optionsJ\x04\x08\x04\x10\x05R\x06stream\"\x89\x02\n\x15MethodDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x1d\n\ninput_type\x18\x02 \x01(\tR\tinputType\x12\x1f\n\x0boutput_type\x18\x03 \x01(\tR\noutputType\x12\x38\n\x07options\x18\x04 \x01(\x0b\x32\x1e.google.protobuf.MethodOptionsR\x07options\x12\x30\n\x10\x63lient_streaming\x18\x05 \x01(\x08:\x05\x66\x61lseR\x0f\x63lientStreaming\x12\x30\n\x10server_streaming\x18\x06 \x01(\x08:\x05\x66\x61lseR\x0fserverStreaming\"\xfa\n\n\x0b\x46ileOptions\x12!\n\x0cjava_package\x18\x01 \x01(\tR\x0bjavaPackage\x12\x30\n\x14java_outer_classname\x18\x08 \x01(\tR\x12javaOuterClassname\x12\xf9\x01\n\x13java_multiple_files\x18\n \x01(\x08:\x05\x66\x61lseB\xc1\x01\xb2\x01\xbd\x01\x08\xe6\x07 \xe9\x07*\xb4\x01This behavior is enabled by default in editions 2024 and above. To disable it, you can set `features.(pb.java).nest_in_file_class = YES` on individual messages, enums, or services.R\x11javaMultipleFiles\x12\x44\n\x1djava_generate_equals_and_hash\x18\x14 \x01(\x08\x42\x02\x18\x01R\x19javaGenerateEqualsAndHash\x12:\n\x16java_string_check_utf8\x18\x1b \x01(\x08:\x05\x66\x61lseR\x13javaStringCheckUtf8\x12S\n\x0coptimize_for\x18\t \x01(\x0e\x32).google.protobuf.FileOptions.OptimizeMode:\x05SPEEDR\x0boptimizeFor\x12\x1d\n\ngo_package\x18\x0b \x01(\tR\tgoPackage\x12\x35\n\x13\x63\x63_generic_services\x18\x10 \x01(\x08:\x05\x66\x61lseR\x11\x63\x63GenericServices\x12\x39\n\x15java_generic_services\x18\x11 \x01(\x08:\x05\x66\x61lseR\x13javaGenericServices\x12\x35\n\x13py_generic_services\x18\x12 \x01(\x08:\x05\x66\x61lseR\x11pyGenericServices\x12%\n\ndeprecated\x18\x17 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12.\n\x10\x63\x63_enable_arenas\x18\x1f \x01(\x08:\x04trueR\x0e\x63\x63\x45nableArenas\x12*\n\x11objc_class_prefix\x18$ \x01(\tR\x0fobjcClassPrefix\x12)\n\x10\x63sharp_namespace\x18% \x01(\tR\x0f\x63sharpNamespace\x12!\n\x0cswift_prefix\x18\' \x01(\tR\x0bswiftPrefix\x12(\n\x10php_class_prefix\x18( \x01(\tR\x0ephpClassPrefix\x12#\n\rphp_namespace\x18) \x01(\tR\x0cphpNamespace\x12\x34\n\x16php_metadata_namespace\x18, \x01(\tR\x14phpMetadataNamespace\x12!\n\x0cruby_package\x18- \x01(\tR\x0brubyPackage\x12\x37\n\x08\x66\x65\x61tures\x18\x32 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\":\n\x0cOptimizeMode\x12\t\n\x05SPEED\x10\x01\x12\r\n\tCODE_SIZE\x10\x02\x12\x10\n\x0cLITE_RUNTIME\x10\x03*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08*\x10+J\x04\x08&\x10\'R\x14php_generic_services\"\xfc\x03\n\x0eMessageOptions\x12<\n\x17message_set_wire_format\x18\x01 \x01(\x08:\x05\x66\x61lseR\x14messageSetWireFormat\x12L\n\x1fno_standard_descriptor_accessor\x18\x02 \x01(\x08:\x05\x66\x61lseR\x1cnoStandardDescriptorAccessor\x12%\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12\x1b\n\tmap_entry\x18\x07 \x01(\x08R\x08mapEntry\x12V\n&deprecated_legacy_json_field_conflicts\x18\x0b \x01(\x08\x42\x02\x18\x01R\"deprecatedLegacyJsonFieldConflicts\x12\x37\n\x08\x66\x65\x61tures\x18\x0c \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\x04\x08\x08\x10\tJ\x04\x08\t\x10\n\"\xce\r\n\x0c\x46ieldOptions\x12\x41\n\x05\x63type\x18\x01 \x01(\x0e\x32#.google.protobuf.FieldOptions.CType:\x06STRINGR\x05\x63type\x12\x16\n\x06packed\x18\x02 \x01(\x08R\x06packed\x12G\n\x06jstype\x18\x06 \x01(\x0e\x32$.google.protobuf.FieldOptions.JSType:\tJS_NORMALR\x06jstype\x12\x19\n\x04lazy\x18\x05 \x01(\x08:\x05\x66\x61lseR\x04lazy\x12.\n\x0funverified_lazy\x18\x0f \x01(\x08:\x05\x66\x61lseR\x0eunverifiedLazy\x12%\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12\x1d\n\x04weak\x18\n \x01(\x08:\x05\x66\x61lseB\x02\x18\x01R\x04weak\x12(\n\x0c\x64\x65\x62ug_redact\x18\x10 \x01(\x08:\x05\x66\x61lseR\x0b\x64\x65\x62ugRedact\x12K\n\tretention\x18\x11 \x01(\x0e\x32-.google.protobuf.FieldOptions.OptionRetentionR\tretention\x12H\n\x07targets\x18\x13 \x03(\x0e\x32..google.protobuf.FieldOptions.OptionTargetTypeR\x07targets\x12W\n\x10\x65\x64ition_defaults\x18\x14 \x03(\x0b\x32,.google.protobuf.FieldOptions.EditionDefaultR\x0f\x65\x64itionDefaults\x12\x37\n\x08\x66\x65\x61tures\x18\x15 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12U\n\x0f\x66\x65\x61ture_support\x18\x16 \x01(\x0b\x32,.google.protobuf.FieldOptions.FeatureSupportR\x0e\x66\x65\x61tureSupport\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\x1aZ\n\x0e\x45\x64itionDefault\x12\x32\n\x07\x65\x64ition\x18\x03 \x01(\x0e\x32\x18.google.protobuf.EditionR\x07\x65\x64ition\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value\x1a\xbb\x02\n\x0e\x46\x65\x61tureSupport\x12G\n\x12\x65\x64ition_introduced\x18\x01 \x01(\x0e\x32\x18.google.protobuf.EditionR\x11\x65\x64itionIntroduced\x12G\n\x12\x65\x64ition_deprecated\x18\x02 \x01(\x0e\x32\x18.google.protobuf.EditionR\x11\x65\x64itionDeprecated\x12/\n\x13\x64\x65precation_warning\x18\x03 \x01(\tR\x12\x64\x65precationWarning\x12\x41\n\x0f\x65\x64ition_removed\x18\x04 \x01(\x0e\x32\x18.google.protobuf.EditionR\x0e\x65\x64itionRemoved\x12#\n\rremoval_error\x18\x05 \x01(\tR\x0cremovalError\"/\n\x05\x43Type\x12\n\n\x06STRING\x10\x00\x12\x08\n\x04\x43ORD\x10\x01\x12\x10\n\x0cSTRING_PIECE\x10\x02\"5\n\x06JSType\x12\r\n\tJS_NORMAL\x10\x00\x12\r\n\tJS_STRING\x10\x01\x12\r\n\tJS_NUMBER\x10\x02\"U\n\x0fOptionRetention\x12\x15\n\x11RETENTION_UNKNOWN\x10\x00\x12\x15\n\x11RETENTION_RUNTIME\x10\x01\x12\x14\n\x10RETENTION_SOURCE\x10\x02\"\x8c\x02\n\x10OptionTargetType\x12\x17\n\x13TARGET_TYPE_UNKNOWN\x10\x00\x12\x14\n\x10TARGET_TYPE_FILE\x10\x01\x12\x1f\n\x1bTARGET_TYPE_EXTENSION_RANGE\x10\x02\x12\x17\n\x13TARGET_TYPE_MESSAGE\x10\x03\x12\x15\n\x11TARGET_TYPE_FIELD\x10\x04\x12\x15\n\x11TARGET_TYPE_ONEOF\x10\x05\x12\x14\n\x10TARGET_TYPE_ENUM\x10\x06\x12\x1a\n\x16TARGET_TYPE_ENUM_ENTRY\x10\x07\x12\x17\n\x13TARGET_TYPE_SERVICE\x10\x08\x12\x16\n\x12TARGET_TYPE_METHOD\x10\t*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05J\x04\x08\x12\x10\x13\"\xb4\x01\n\x0cOneofOptions\x12\x37\n\x08\x66\x65\x61tures\x18\x01 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xd9\x02\n\x0b\x45numOptions\x12\x1f\n\x0b\x61llow_alias\x18\x02 \x01(\x08R\nallowAlias\x12%\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12V\n&deprecated_legacy_json_field_conflicts\x18\x06 \x01(\x08\x42\x02\x18\x01R\"deprecatedLegacyJsonFieldConflicts\x12\x37\n\x08\x66\x65\x61tures\x18\x07 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x05\x10\x06\"\xe0\x02\n\x10\x45numValueOptions\x12%\n\ndeprecated\x18\x01 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12\x37\n\x08\x66\x65\x61tures\x18\x02 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12(\n\x0c\x64\x65\x62ug_redact\x18\x03 \x01(\x08:\x05\x66\x61lseR\x0b\x64\x65\x62ugRedact\x12U\n\x0f\x66\x65\x61ture_support\x18\x04 \x01(\x0b\x32,.google.protobuf.FieldOptions.FeatureSupportR\x0e\x66\x65\x61tureSupport\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xdd\x01\n\x0eServiceOptions\x12\x37\n\x08\x66\x65\x61tures\x18\" \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12%\n\ndeprecated\x18! \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xa1\x03\n\rMethodOptions\x12%\n\ndeprecated\x18! \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12q\n\x11idempotency_level\x18\" \x01(\x0e\x32/.google.protobuf.MethodOptions.IdempotencyLevel:\x13IDEMPOTENCY_UNKNOWNR\x10idempotencyLevel\x12\x37\n\x08\x66\x65\x61tures\x18# \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\"P\n\x10IdempotencyLevel\x12\x17\n\x13IDEMPOTENCY_UNKNOWN\x10\x00\x12\x13\n\x0fNO_SIDE_EFFECTS\x10\x01\x12\x0e\n\nIDEMPOTENT\x10\x02*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9a\x03\n\x13UninterpretedOption\x12\x41\n\x04name\x18\x02 \x03(\x0b\x32-.google.protobuf.UninterpretedOption.NamePartR\x04name\x12)\n\x10identifier_value\x18\x03 \x01(\tR\x0fidentifierValue\x12,\n\x12positive_int_value\x18\x04 \x01(\x04R\x10positiveIntValue\x12,\n\x12negative_int_value\x18\x05 \x01(\x03R\x10negativeIntValue\x12!\n\x0c\x64ouble_value\x18\x06 \x01(\x01R\x0b\x64oubleValue\x12!\n\x0cstring_value\x18\x07 \x01(\x0cR\x0bstringValue\x12\'\n\x0f\x61ggregate_value\x18\x08 \x01(\tR\x0e\x61ggregateValue\x1aJ\n\x08NamePart\x12\x1b\n\tname_part\x18\x01 \x02(\tR\x08namePart\x12!\n\x0cis_extension\x18\x02 \x02(\x08R\x0bisExtension\"\xae\x0f\n\nFeatureSet\x12\x91\x01\n\x0e\x66ield_presence\x18\x01 \x01(\x0e\x32).google.protobuf.FeatureSet.FieldPresenceB?\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\r\x12\x08\x45XPLICIT\x18\x84\x07\xa2\x01\r\x12\x08IMPLICIT\x18\xe7\x07\xa2\x01\r\x12\x08\x45XPLICIT\x18\xe8\x07\xb2\x01\x03\x08\xe8\x07R\rfieldPresence\x12l\n\tenum_type\x18\x02 \x01(\x0e\x32$.google.protobuf.FeatureSet.EnumTypeB)\x88\x01\x01\x98\x01\x06\x98\x01\x01\xa2\x01\x0b\x12\x06\x43LOSED\x18\x84\x07\xa2\x01\t\x12\x04OPEN\x18\xe7\x07\xb2\x01\x03\x08\xe8\x07R\x08\x65numType\x12\x98\x01\n\x17repeated_field_encoding\x18\x03 \x01(\x0e\x32\x31.google.protobuf.FeatureSet.RepeatedFieldEncodingB-\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\r\x12\x08\x45XPANDED\x18\x84\x07\xa2\x01\x0b\x12\x06PACKED\x18\xe7\x07\xb2\x01\x03\x08\xe8\x07R\x15repeatedFieldEncoding\x12~\n\x0futf8_validation\x18\x04 \x01(\x0e\x32*.google.protobuf.FeatureSet.Utf8ValidationB)\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\t\x12\x04NONE\x18\x84\x07\xa2\x01\x0b\x12\x06VERIFY\x18\xe7\x07\xb2\x01\x03\x08\xe8\x07R\x0eutf8Validation\x12~\n\x10message_encoding\x18\x05 \x01(\x0e\x32+.google.protobuf.FeatureSet.MessageEncodingB&\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\x14\x12\x0fLENGTH_PREFIXED\x18\x84\x07\xb2\x01\x03\x08\xe8\x07R\x0fmessageEncoding\x12\x82\x01\n\x0bjson_format\x18\x06 \x01(\x0e\x32&.google.protobuf.FeatureSet.JsonFormatB9\x88\x01\x01\x98\x01\x03\x98\x01\x06\x98\x01\x01\xa2\x01\x17\x12\x12LEGACY_BEST_EFFORT\x18\x84\x07\xa2\x01\n\x12\x05\x41LLOW\x18\xe7\x07\xb2\x01\x03\x08\xe8\x07R\njsonFormat\x12\xbc\x01\n\x14\x65nforce_naming_style\x18\x07 \x01(\x0e\x32..google.protobuf.FeatureSet.EnforceNamingStyleBZ\x88\x01\x02\x98\x01\x01\x98\x01\x02\x98\x01\x03\x98\x01\x04\x98\x01\x05\x98\x01\x06\x98\x01\x07\x98\x01\x08\x98\x01\t\xa2\x01\x11\x12\x0cSTYLE_LEGACY\x18\x84\x07\xa2\x01\x0e\x12\tSTYLE2024\x18\xe9\x07\xa2\x01\x0e\x12\tSTYLE2026\x18\x8fN\xb2\x01\x03\x08\xe9\x07R\x12\x65nforceNamingStyle\x12\xb9\x01\n\x19\x64\x65\x66\x61ult_symbol_visibility\x18\x08 \x01(\x0e\x32\x45.google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibilityB6\x88\x01\x02\x98\x01\x01\xa2\x01\x0f\x12\nEXPORT_ALL\x18\x84\x07\xa2\x01\x15\x12\x10\x45XPORT_TOP_LEVEL\x18\xe9\x07\xb2\x01\x03\x08\xe9\x07R\x17\x64\x65\x66\x61ultSymbolVisibility\x1a\xa1\x01\n\x11VisibilityFeature\"\x81\x01\n\x17\x44\x65\x66\x61ultSymbolVisibility\x12%\n!DEFAULT_SYMBOL_VISIBILITY_UNKNOWN\x10\x00\x12\x0e\n\nEXPORT_ALL\x10\x01\x12\x14\n\x10\x45XPORT_TOP_LEVEL\x10\x02\x12\r\n\tLOCAL_ALL\x10\x03\x12\n\n\x06STRICT\x10\x04J\x08\x08\x01\x10\x80\x80\x80\x80\x02\"\\\n\rFieldPresence\x12\x1a\n\x16\x46IELD_PRESENCE_UNKNOWN\x10\x00\x12\x0c\n\x08\x45XPLICIT\x10\x01\x12\x0c\n\x08IMPLICIT\x10\x02\x12\x13\n\x0fLEGACY_REQUIRED\x10\x03\"7\n\x08\x45numType\x12\x15\n\x11\x45NUM_TYPE_UNKNOWN\x10\x00\x12\x08\n\x04OPEN\x10\x01\x12\n\n\x06\x43LOSED\x10\x02\"V\n\x15RepeatedFieldEncoding\x12#\n\x1fREPEATED_FIELD_ENCODING_UNKNOWN\x10\x00\x12\n\n\x06PACKED\x10\x01\x12\x0c\n\x08\x45XPANDED\x10\x02\"I\n\x0eUtf8Validation\x12\x1b\n\x17UTF8_VALIDATION_UNKNOWN\x10\x00\x12\n\n\x06VERIFY\x10\x02\x12\x08\n\x04NONE\x10\x03\"\x04\x08\x01\x10\x01\"S\n\x0fMessageEncoding\x12\x1c\n\x18MESSAGE_ENCODING_UNKNOWN\x10\x00\x12\x13\n\x0fLENGTH_PREFIXED\x10\x01\x12\r\n\tDELIMITED\x10\x02\"H\n\nJsonFormat\x12\x17\n\x13JSON_FORMAT_UNKNOWN\x10\x00\x12\t\n\x05\x41LLOW\x10\x01\x12\x16\n\x12LEGACY_BEST_EFFORT\x10\x02\"f\n\x12\x45nforceNamingStyle\x12 \n\x1c\x45NFORCE_NAMING_STYLE_UNKNOWN\x10\x00\x12\r\n\tSTYLE2024\x10\x01\x12\x10\n\x0cSTYLE_LEGACY\x10\x02\x12\r\n\tSTYLE2026\x10\x03*\x06\x08\xe8\x07\x10\x8bN*\x06\x08\x8bN\x10\x90N*\x06\x08\x90N\x10\x91NJ\x06\x08\xe7\x07\x10\xe8\x07\"\xef\x03\n\x12\x46\x65\x61tureSetDefaults\x12X\n\x08\x64\x65\x66\x61ults\x18\x01 \x03(\x0b\x32<.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefaultR\x08\x64\x65\x66\x61ults\x12\x41\n\x0fminimum_edition\x18\x04 \x01(\x0e\x32\x18.google.protobuf.EditionR\x0eminimumEdition\x12\x41\n\x0fmaximum_edition\x18\x05 \x01(\x0e\x32\x18.google.protobuf.EditionR\x0emaximumEdition\x1a\xf8\x01\n\x18\x46\x65\x61tureSetEditionDefault\x12\x32\n\x07\x65\x64ition\x18\x03 \x01(\x0e\x32\x18.google.protobuf.EditionR\x07\x65\x64ition\x12N\n\x14overridable_features\x18\x04 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x13overridableFeatures\x12\x42\n\x0e\x66ixed_features\x18\x05 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\rfixedFeaturesJ\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03R\x08\x66\x65\x61tures\"\xb5\x02\n\x0eSourceCodeInfo\x12\x44\n\x08location\x18\x01 \x03(\x0b\x32(.google.protobuf.SourceCodeInfo.LocationR\x08location\x1a\xce\x01\n\x08Location\x12\x16\n\x04path\x18\x01 \x03(\x05\x42\x02\x10\x01R\x04path\x12\x16\n\x04span\x18\x02 \x03(\x05\x42\x02\x10\x01R\x04span\x12)\n\x10leading_comments\x18\x03 \x01(\tR\x0fleadingComments\x12+\n\x11trailing_comments\x18\x04 \x01(\tR\x10trailingComments\x12:\n\x19leading_detached_comments\x18\x06 \x03(\tR\x17leadingDetachedComments*\x0c\x08\x80\xec\xca\xff\x01\x10\x81\xec\xca\xff\x01\"\xd0\x02\n\x11GeneratedCodeInfo\x12M\n\nannotation\x18\x01 \x03(\x0b\x32-.google.protobuf.GeneratedCodeInfo.AnnotationR\nannotation\x1a\xeb\x01\n\nAnnotation\x12\x16\n\x04path\x18\x01 \x03(\x05\x42\x02\x10\x01R\x04path\x12\x1f\n\x0bsource_file\x18\x02 \x01(\tR\nsourceFile\x12\x14\n\x05\x62\x65gin\x18\x03 \x01(\x05R\x05\x62\x65gin\x12\x10\n\x03\x65nd\x18\x04 \x01(\x05R\x03\x65nd\x12R\n\x08semantic\x18\x05 \x01(\x0e\x32\x36.google.protobuf.GeneratedCodeInfo.Annotation.SemanticR\x08semantic\"(\n\x08Semantic\x12\x08\n\x04NONE\x10\x00\x12\x07\n\x03SET\x10\x01\x12\t\n\x05\x41LIAS\x10\x02*\xd1\x02\n\x07\x45\x64ition\x12\x13\n\x0f\x45\x44ITION_UNKNOWN\x10\x00\x12\x13\n\x0e\x45\x44ITION_LEGACY\x10\x84\x07\x12\x13\n\x0e\x45\x44ITION_PROTO2\x10\xe6\x07\x12\x13\n\x0e\x45\x44ITION_PROTO3\x10\xe7\x07\x12\x11\n\x0c\x45\x44ITION_2023\x10\xe8\x07\x12\x11\n\x0c\x45\x44ITION_2024\x10\xe9\x07\x12\x11\n\x0c\x45\x44ITION_2026\x10\xea\x07\x12\x15\n\x10\x45\x44ITION_UNSTABLE\x10\x8fN\x12\x17\n\x13\x45\x44ITION_1_TEST_ONLY\x10\x01\x12\x17\n\x13\x45\x44ITION_2_TEST_ONLY\x10\x02\x12\x1d\n\x17\x45\x44ITION_99997_TEST_ONLY\x10\x9d\x8d\x06\x12\x1d\n\x17\x45\x44ITION_99998_TEST_ONLY\x10\x9e\x8d\x06\x12\x1d\n\x17\x45\x44ITION_99999_TEST_ONLY\x10\x9f\x8d\x06\x12\x13\n\x0b\x45\x44ITION_MAX\x10\xff\xff\xff\xff\x07*U\n\x10SymbolVisibility\x12\x14\n\x10VISIBILITY_UNSET\x10\x00\x12\x14\n\x10VISIBILITY_LOCAL\x10\x01\x12\x15\n\x11VISIBILITY_EXPORT\x10\x02\x42~\n\x13\x63om.google.protobufB\x10\x44\x65scriptorProtosH\x01Z-google.golang.org/protobuf/types/descriptorpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.Reflection' + ) +else: + DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n google/protobuf/descriptor.proto\x12\x0fgoogle.protobuf\"[\n\x11\x46ileDescriptorSet\x12\x38\n\x04\x66ile\x18\x01 \x03(\x0b\x32$.google.protobuf.FileDescriptorProtoR\x04\x66ile*\x0c\x08\x80\xec\xca\xff\x01\x10\x81\xec\xca\xff\x01\"\xc5\x05\n\x13\x46ileDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n\x07package\x18\x02 \x01(\tR\x07package\x12\x1e\n\ndependency\x18\x03 \x03(\tR\ndependency\x12+\n\x11public_dependency\x18\n \x03(\x05R\x10publicDependency\x12\'\n\x0fweak_dependency\x18\x0b \x03(\x05R\x0eweakDependency\x12+\n\x11option_dependency\x18\x0f \x03(\tR\x10optionDependency\x12\x43\n\x0cmessage_type\x18\x04 \x03(\x0b\x32 .google.protobuf.DescriptorProtoR\x0bmessageType\x12\x41\n\tenum_type\x18\x05 \x03(\x0b\x32$.google.protobuf.EnumDescriptorProtoR\x08\x65numType\x12\x41\n\x07service\x18\x06 \x03(\x0b\x32\'.google.protobuf.ServiceDescriptorProtoR\x07service\x12\x43\n\textension\x18\x07 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProtoR\textension\x12\x36\n\x07options\x18\x08 \x01(\x0b\x32\x1c.google.protobuf.FileOptionsR\x07options\x12I\n\x10source_code_info\x18\t \x01(\x0b\x32\x1f.google.protobuf.SourceCodeInfoR\x0esourceCodeInfo\x12\x16\n\x06syntax\x18\x0c \x01(\tR\x06syntax\x12\x32\n\x07\x65\x64ition\x18\x0e \x01(\x0e\x32\x18.google.protobuf.EditionR\x07\x65\x64ition\"\xfc\x06\n\x0f\x44\x65scriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12;\n\x05\x66ield\x18\x02 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProtoR\x05\x66ield\x12\x43\n\textension\x18\x06 \x03(\x0b\x32%.google.protobuf.FieldDescriptorProtoR\textension\x12\x41\n\x0bnested_type\x18\x03 \x03(\x0b\x32 .google.protobuf.DescriptorProtoR\nnestedType\x12\x41\n\tenum_type\x18\x04 \x03(\x0b\x32$.google.protobuf.EnumDescriptorProtoR\x08\x65numType\x12X\n\x0f\x65xtension_range\x18\x05 \x03(\x0b\x32/.google.protobuf.DescriptorProto.ExtensionRangeR\x0e\x65xtensionRange\x12\x44\n\noneof_decl\x18\x08 \x03(\x0b\x32%.google.protobuf.OneofDescriptorProtoR\toneofDecl\x12\x39\n\x07options\x18\x07 \x01(\x0b\x32\x1f.google.protobuf.MessageOptionsR\x07options\x12U\n\x0ereserved_range\x18\t \x03(\x0b\x32..google.protobuf.DescriptorProto.ReservedRangeR\rreservedRange\x12#\n\rreserved_name\x18\n \x03(\tR\x0creservedName\x12\x41\n\nvisibility\x18\x0b \x01(\x0e\x32!.google.protobuf.SymbolVisibilityR\nvisibility\x1az\n\x0e\x45xtensionRange\x12\x14\n\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n\x03\x65nd\x18\x02 \x01(\x05R\x03\x65nd\x12@\n\x07options\x18\x03 \x01(\x0b\x32&.google.protobuf.ExtensionRangeOptionsR\x07options\x1a\x37\n\rReservedRange\x12\x14\n\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n\x03\x65nd\x18\x02 \x01(\x05R\x03\x65nd\"\xd4\x04\n\x15\x45xtensionRangeOptions\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\x12Y\n\x0b\x64\x65\x63laration\x18\x02 \x03(\x0b\x32\x32.google.protobuf.ExtensionRangeOptions.DeclarationB\x03\x88\x01\x02R\x0b\x64\x65\x63laration\x12\x37\n\x08\x66\x65\x61tures\x18\x32 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12m\n\x0cverification\x18\x03 \x01(\x0e\x32\x38.google.protobuf.ExtensionRangeOptions.VerificationState:\nUNVERIFIEDB\x03\x88\x01\x02R\x0cverification\x1a\x94\x01\n\x0b\x44\x65\x63laration\x12\x16\n\x06number\x18\x01 \x01(\x05R\x06number\x12\x1b\n\tfull_name\x18\x02 \x01(\tR\x08\x66ullName\x12\x12\n\x04type\x18\x03 \x01(\tR\x04type\x12\x1a\n\x08reserved\x18\x05 \x01(\x08R\x08reserved\x12\x1a\n\x08repeated\x18\x06 \x01(\x08R\x08repeatedJ\x04\x08\x04\x10\x05\"4\n\x11VerificationState\x12\x0f\n\x0b\x44\x45\x43LARATION\x10\x00\x12\x0e\n\nUNVERIFIED\x10\x01*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xc1\x06\n\x14\x46ieldDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n\x06number\x18\x03 \x01(\x05R\x06number\x12\x41\n\x05label\x18\x04 \x01(\x0e\x32+.google.protobuf.FieldDescriptorProto.LabelR\x05label\x12>\n\x04type\x18\x05 \x01(\x0e\x32*.google.protobuf.FieldDescriptorProto.TypeR\x04type\x12\x1b\n\ttype_name\x18\x06 \x01(\tR\x08typeName\x12\x1a\n\x08\x65xtendee\x18\x02 \x01(\tR\x08\x65xtendee\x12#\n\rdefault_value\x18\x07 \x01(\tR\x0c\x64\x65\x66\x61ultValue\x12\x1f\n\x0boneof_index\x18\t \x01(\x05R\noneofIndex\x12\x1b\n\tjson_name\x18\n \x01(\tR\x08jsonName\x12\x37\n\x07options\x18\x08 \x01(\x0b\x32\x1d.google.protobuf.FieldOptionsR\x07options\x12\'\n\x0fproto3_optional\x18\x11 \x01(\x08R\x0eproto3Optional\"\xb6\x02\n\x04Type\x12\x0f\n\x0bTYPE_DOUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\n\nTYPE_INT64\x10\x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_INT32\x10\x05\x12\x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED32\x10\x07\x12\r\n\tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\x0e\n\nTYPE_GROUP\x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTYPE_BYTES\x10\x0c\x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\x11\n\rTYPE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\x0bTYPE_SINT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"C\n\x05Label\x12\x12\n\x0eLABEL_OPTIONAL\x10\x01\x12\x12\n\x0eLABEL_REPEATED\x10\x03\x12\x12\n\x0eLABEL_REQUIRED\x10\x02\"c\n\x14OneofDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x37\n\x07options\x18\x02 \x01(\x0b\x32\x1d.google.protobuf.OneofOptionsR\x07options\"\xa6\x03\n\x13\x45numDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12?\n\x05value\x18\x02 \x03(\x0b\x32).google.protobuf.EnumValueDescriptorProtoR\x05value\x12\x36\n\x07options\x18\x03 \x01(\x0b\x32\x1c.google.protobuf.EnumOptionsR\x07options\x12]\n\x0ereserved_range\x18\x04 \x03(\x0b\x32\x36.google.protobuf.EnumDescriptorProto.EnumReservedRangeR\rreservedRange\x12#\n\rreserved_name\x18\x05 \x03(\tR\x0creservedName\x12\x41\n\nvisibility\x18\x06 \x01(\x0e\x32!.google.protobuf.SymbolVisibilityR\nvisibility\x1a;\n\x11\x45numReservedRange\x12\x14\n\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n\x03\x65nd\x18\x02 \x01(\x05R\x03\x65nd\"\x83\x01\n\x18\x45numValueDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n\x06number\x18\x02 \x01(\x05R\x06number\x12;\n\x07options\x18\x03 \x01(\x0b\x32!.google.protobuf.EnumValueOptionsR\x07options\"\xb5\x01\n\x16ServiceDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12>\n\x06method\x18\x02 \x03(\x0b\x32&.google.protobuf.MethodDescriptorProtoR\x06method\x12\x39\n\x07options\x18\x03 \x01(\x0b\x32\x1f.google.protobuf.ServiceOptionsR\x07optionsJ\x04\x08\x04\x10\x05R\x06stream\"\x89\x02\n\x15MethodDescriptorProto\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x1d\n\ninput_type\x18\x02 \x01(\tR\tinputType\x12\x1f\n\x0boutput_type\x18\x03 \x01(\tR\noutputType\x12\x38\n\x07options\x18\x04 \x01(\x0b\x32\x1e.google.protobuf.MethodOptionsR\x07options\x12\x30\n\x10\x63lient_streaming\x18\x05 \x01(\x08:\x05\x66\x61lseR\x0f\x63lientStreaming\x12\x30\n\x10server_streaming\x18\x06 \x01(\x08:\x05\x66\x61lseR\x0fserverStreaming\"\xfa\n\n\x0b\x46ileOptions\x12!\n\x0cjava_package\x18\x01 \x01(\tR\x0bjavaPackage\x12\x30\n\x14java_outer_classname\x18\x08 \x01(\tR\x12javaOuterClassname\x12\xf9\x01\n\x13java_multiple_files\x18\n \x01(\x08:\x05\x66\x61lseB\xc1\x01\xb2\x01\xbd\x01\x08\xe6\x07 \xe9\x07*\xb4\x01This behavior is enabled by default in editions 2024 and above. To disable it, you can set `features.(pb.java).nest_in_file_class = YES` on individual messages, enums, or services.R\x11javaMultipleFiles\x12\x44\n\x1djava_generate_equals_and_hash\x18\x14 \x01(\x08\x42\x02\x18\x01R\x19javaGenerateEqualsAndHash\x12:\n\x16java_string_check_utf8\x18\x1b \x01(\x08:\x05\x66\x61lseR\x13javaStringCheckUtf8\x12S\n\x0coptimize_for\x18\t \x01(\x0e\x32).google.protobuf.FileOptions.OptimizeMode:\x05SPEEDR\x0boptimizeFor\x12\x1d\n\ngo_package\x18\x0b \x01(\tR\tgoPackage\x12\x35\n\x13\x63\x63_generic_services\x18\x10 \x01(\x08:\x05\x66\x61lseR\x11\x63\x63GenericServices\x12\x39\n\x15java_generic_services\x18\x11 \x01(\x08:\x05\x66\x61lseR\x13javaGenericServices\x12\x35\n\x13py_generic_services\x18\x12 \x01(\x08:\x05\x66\x61lseR\x11pyGenericServices\x12%\n\ndeprecated\x18\x17 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12.\n\x10\x63\x63_enable_arenas\x18\x1f \x01(\x08:\x04trueR\x0e\x63\x63\x45nableArenas\x12*\n\x11objc_class_prefix\x18$ \x01(\tR\x0fobjcClassPrefix\x12)\n\x10\x63sharp_namespace\x18% \x01(\tR\x0f\x63sharpNamespace\x12!\n\x0cswift_prefix\x18\' \x01(\tR\x0bswiftPrefix\x12(\n\x10php_class_prefix\x18( \x01(\tR\x0ephpClassPrefix\x12#\n\rphp_namespace\x18) \x01(\tR\x0cphpNamespace\x12\x34\n\x16php_metadata_namespace\x18, \x01(\tR\x14phpMetadataNamespace\x12!\n\x0cruby_package\x18- \x01(\tR\x0brubyPackage\x12\x37\n\x08\x66\x65\x61tures\x18\x32 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\":\n\x0cOptimizeMode\x12\t\n\x05SPEED\x10\x01\x12\r\n\tCODE_SIZE\x10\x02\x12\x10\n\x0cLITE_RUNTIME\x10\x03*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08*\x10+J\x04\x08&\x10\'R\x14php_generic_services\"\xfc\x03\n\x0eMessageOptions\x12<\n\x17message_set_wire_format\x18\x01 \x01(\x08:\x05\x66\x61lseR\x14messageSetWireFormat\x12L\n\x1fno_standard_descriptor_accessor\x18\x02 \x01(\x08:\x05\x66\x61lseR\x1cnoStandardDescriptorAccessor\x12%\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12\x1b\n\tmap_entry\x18\x07 \x01(\x08R\x08mapEntry\x12V\n&deprecated_legacy_json_field_conflicts\x18\x0b \x01(\x08\x42\x02\x18\x01R\"deprecatedLegacyJsonFieldConflicts\x12\x37\n\x08\x66\x65\x61tures\x18\x0c \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\x04\x08\x08\x10\tJ\x04\x08\t\x10\n\"\xce\r\n\x0c\x46ieldOptions\x12\x41\n\x05\x63type\x18\x01 \x01(\x0e\x32#.google.protobuf.FieldOptions.CType:\x06STRINGR\x05\x63type\x12\x16\n\x06packed\x18\x02 \x01(\x08R\x06packed\x12G\n\x06jstype\x18\x06 \x01(\x0e\x32$.google.protobuf.FieldOptions.JSType:\tJS_NORMALR\x06jstype\x12\x19\n\x04lazy\x18\x05 \x01(\x08:\x05\x66\x61lseR\x04lazy\x12.\n\x0funverified_lazy\x18\x0f \x01(\x08:\x05\x66\x61lseR\x0eunverifiedLazy\x12%\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12\x1d\n\x04weak\x18\n \x01(\x08:\x05\x66\x61lseB\x02\x18\x01R\x04weak\x12(\n\x0c\x64\x65\x62ug_redact\x18\x10 \x01(\x08:\x05\x66\x61lseR\x0b\x64\x65\x62ugRedact\x12K\n\tretention\x18\x11 \x01(\x0e\x32-.google.protobuf.FieldOptions.OptionRetentionR\tretention\x12H\n\x07targets\x18\x13 \x03(\x0e\x32..google.protobuf.FieldOptions.OptionTargetTypeR\x07targets\x12W\n\x10\x65\x64ition_defaults\x18\x14 \x03(\x0b\x32,.google.protobuf.FieldOptions.EditionDefaultR\x0f\x65\x64itionDefaults\x12\x37\n\x08\x66\x65\x61tures\x18\x15 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12U\n\x0f\x66\x65\x61ture_support\x18\x16 \x01(\x0b\x32,.google.protobuf.FieldOptions.FeatureSupportR\x0e\x66\x65\x61tureSupport\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\x1aZ\n\x0e\x45\x64itionDefault\x12\x32\n\x07\x65\x64ition\x18\x03 \x01(\x0e\x32\x18.google.protobuf.EditionR\x07\x65\x64ition\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value\x1a\xbb\x02\n\x0e\x46\x65\x61tureSupport\x12G\n\x12\x65\x64ition_introduced\x18\x01 \x01(\x0e\x32\x18.google.protobuf.EditionR\x11\x65\x64itionIntroduced\x12G\n\x12\x65\x64ition_deprecated\x18\x02 \x01(\x0e\x32\x18.google.protobuf.EditionR\x11\x65\x64itionDeprecated\x12/\n\x13\x64\x65precation_warning\x18\x03 \x01(\tR\x12\x64\x65precationWarning\x12\x41\n\x0f\x65\x64ition_removed\x18\x04 \x01(\x0e\x32\x18.google.protobuf.EditionR\x0e\x65\x64itionRemoved\x12#\n\rremoval_error\x18\x05 \x01(\tR\x0cremovalError\"/\n\x05\x43Type\x12\n\n\x06STRING\x10\x00\x12\x08\n\x04\x43ORD\x10\x01\x12\x10\n\x0cSTRING_PIECE\x10\x02\"5\n\x06JSType\x12\r\n\tJS_NORMAL\x10\x00\x12\r\n\tJS_STRING\x10\x01\x12\r\n\tJS_NUMBER\x10\x02\"U\n\x0fOptionRetention\x12\x15\n\x11RETENTION_UNKNOWN\x10\x00\x12\x15\n\x11RETENTION_RUNTIME\x10\x01\x12\x14\n\x10RETENTION_SOURCE\x10\x02\"\x8c\x02\n\x10OptionTargetType\x12\x17\n\x13TARGET_TYPE_UNKNOWN\x10\x00\x12\x14\n\x10TARGET_TYPE_FILE\x10\x01\x12\x1f\n\x1bTARGET_TYPE_EXTENSION_RANGE\x10\x02\x12\x17\n\x13TARGET_TYPE_MESSAGE\x10\x03\x12\x15\n\x11TARGET_TYPE_FIELD\x10\x04\x12\x15\n\x11TARGET_TYPE_ONEOF\x10\x05\x12\x14\n\x10TARGET_TYPE_ENUM\x10\x06\x12\x1a\n\x16TARGET_TYPE_ENUM_ENTRY\x10\x07\x12\x17\n\x13TARGET_TYPE_SERVICE\x10\x08\x12\x16\n\x12TARGET_TYPE_METHOD\x10\t*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05J\x04\x08\x12\x10\x13\"\xb4\x01\n\x0cOneofOptions\x12\x37\n\x08\x66\x65\x61tures\x18\x01 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xd9\x02\n\x0b\x45numOptions\x12\x1f\n\x0b\x61llow_alias\x18\x02 \x01(\x08R\nallowAlias\x12%\n\ndeprecated\x18\x03 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12V\n&deprecated_legacy_json_field_conflicts\x18\x06 \x01(\x08\x42\x02\x18\x01R\"deprecatedLegacyJsonFieldConflicts\x12\x37\n\x08\x66\x65\x61tures\x18\x07 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x05\x10\x06\"\xe0\x02\n\x10\x45numValueOptions\x12%\n\ndeprecated\x18\x01 \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12\x37\n\x08\x66\x65\x61tures\x18\x02 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12(\n\x0c\x64\x65\x62ug_redact\x18\x03 \x01(\x08:\x05\x66\x61lseR\x0b\x64\x65\x62ugRedact\x12U\n\x0f\x66\x65\x61ture_support\x18\x04 \x01(\x0b\x32,.google.protobuf.FieldOptions.FeatureSupportR\x0e\x66\x65\x61tureSupport\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xdd\x01\n\x0eServiceOptions\x12\x37\n\x08\x66\x65\x61tures\x18\" \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12%\n\ndeprecated\x18! \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xa1\x03\n\rMethodOptions\x12%\n\ndeprecated\x18! \x01(\x08:\x05\x66\x61lseR\ndeprecated\x12q\n\x11idempotency_level\x18\" \x01(\x0e\x32/.google.protobuf.MethodOptions.IdempotencyLevel:\x13IDEMPOTENCY_UNKNOWNR\x10idempotencyLevel\x12\x37\n\x08\x66\x65\x61tures\x18# \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x08\x66\x65\x61tures\x12X\n\x14uninterpreted_option\x18\xe7\x07 \x03(\x0b\x32$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\"P\n\x10IdempotencyLevel\x12\x17\n\x13IDEMPOTENCY_UNKNOWN\x10\x00\x12\x13\n\x0fNO_SIDE_EFFECTS\x10\x01\x12\x0e\n\nIDEMPOTENT\x10\x02*\x06\x08\xde\x07\x10\xe7\x07*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9a\x03\n\x13UninterpretedOption\x12\x41\n\x04name\x18\x02 \x03(\x0b\x32-.google.protobuf.UninterpretedOption.NamePartR\x04name\x12)\n\x10identifier_value\x18\x03 \x01(\tR\x0fidentifierValue\x12,\n\x12positive_int_value\x18\x04 \x01(\x04R\x10positiveIntValue\x12,\n\x12negative_int_value\x18\x05 \x01(\x03R\x10negativeIntValue\x12!\n\x0c\x64ouble_value\x18\x06 \x01(\x01R\x0b\x64oubleValue\x12!\n\x0cstring_value\x18\x07 \x01(\x0cR\x0bstringValue\x12\'\n\x0f\x61ggregate_value\x18\x08 \x01(\tR\x0e\x61ggregateValue\x1aJ\n\x08NamePart\x12\x1b\n\tname_part\x18\x01 \x02(\tR\x08namePart\x12!\n\x0cis_extension\x18\x02 \x02(\x08R\x0bisExtension\"\xae\x0f\n\nFeatureSet\x12\x91\x01\n\x0e\x66ield_presence\x18\x01 \x01(\x0e\x32).google.protobuf.FeatureSet.FieldPresenceB?\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\r\x12\x08\x45XPLICIT\x18\x84\x07\xa2\x01\r\x12\x08IMPLICIT\x18\xe7\x07\xa2\x01\r\x12\x08\x45XPLICIT\x18\xe8\x07\xb2\x01\x03\x08\xe8\x07R\rfieldPresence\x12l\n\tenum_type\x18\x02 \x01(\x0e\x32$.google.protobuf.FeatureSet.EnumTypeB)\x88\x01\x01\x98\x01\x06\x98\x01\x01\xa2\x01\x0b\x12\x06\x43LOSED\x18\x84\x07\xa2\x01\t\x12\x04OPEN\x18\xe7\x07\xb2\x01\x03\x08\xe8\x07R\x08\x65numType\x12\x98\x01\n\x17repeated_field_encoding\x18\x03 \x01(\x0e\x32\x31.google.protobuf.FeatureSet.RepeatedFieldEncodingB-\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\r\x12\x08\x45XPANDED\x18\x84\x07\xa2\x01\x0b\x12\x06PACKED\x18\xe7\x07\xb2\x01\x03\x08\xe8\x07R\x15repeatedFieldEncoding\x12~\n\x0futf8_validation\x18\x04 \x01(\x0e\x32*.google.protobuf.FeatureSet.Utf8ValidationB)\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\t\x12\x04NONE\x18\x84\x07\xa2\x01\x0b\x12\x06VERIFY\x18\xe7\x07\xb2\x01\x03\x08\xe8\x07R\x0eutf8Validation\x12~\n\x10message_encoding\x18\x05 \x01(\x0e\x32+.google.protobuf.FeatureSet.MessageEncodingB&\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\x14\x12\x0fLENGTH_PREFIXED\x18\x84\x07\xb2\x01\x03\x08\xe8\x07R\x0fmessageEncoding\x12\x82\x01\n\x0bjson_format\x18\x06 \x01(\x0e\x32&.google.protobuf.FeatureSet.JsonFormatB9\x88\x01\x01\x98\x01\x03\x98\x01\x06\x98\x01\x01\xa2\x01\x17\x12\x12LEGACY_BEST_EFFORT\x18\x84\x07\xa2\x01\n\x12\x05\x41LLOW\x18\xe7\x07\xb2\x01\x03\x08\xe8\x07R\njsonFormat\x12\xbc\x01\n\x14\x65nforce_naming_style\x18\x07 \x01(\x0e\x32..google.protobuf.FeatureSet.EnforceNamingStyleBZ\x88\x01\x02\x98\x01\x01\x98\x01\x02\x98\x01\x03\x98\x01\x04\x98\x01\x05\x98\x01\x06\x98\x01\x07\x98\x01\x08\x98\x01\t\xa2\x01\x11\x12\x0cSTYLE_LEGACY\x18\x84\x07\xa2\x01\x0e\x12\tSTYLE2024\x18\xe9\x07\xa2\x01\x0e\x12\tSTYLE2026\x18\x8fN\xb2\x01\x03\x08\xe9\x07R\x12\x65nforceNamingStyle\x12\xb9\x01\n\x19\x64\x65\x66\x61ult_symbol_visibility\x18\x08 \x01(\x0e\x32\x45.google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibilityB6\x88\x01\x02\x98\x01\x01\xa2\x01\x0f\x12\nEXPORT_ALL\x18\x84\x07\xa2\x01\x15\x12\x10\x45XPORT_TOP_LEVEL\x18\xe9\x07\xb2\x01\x03\x08\xe9\x07R\x17\x64\x65\x66\x61ultSymbolVisibility\x1a\xa1\x01\n\x11VisibilityFeature\"\x81\x01\n\x17\x44\x65\x66\x61ultSymbolVisibility\x12%\n!DEFAULT_SYMBOL_VISIBILITY_UNKNOWN\x10\x00\x12\x0e\n\nEXPORT_ALL\x10\x01\x12\x14\n\x10\x45XPORT_TOP_LEVEL\x10\x02\x12\r\n\tLOCAL_ALL\x10\x03\x12\n\n\x06STRICT\x10\x04J\x08\x08\x01\x10\x80\x80\x80\x80\x02\"\\\n\rFieldPresence\x12\x1a\n\x16\x46IELD_PRESENCE_UNKNOWN\x10\x00\x12\x0c\n\x08\x45XPLICIT\x10\x01\x12\x0c\n\x08IMPLICIT\x10\x02\x12\x13\n\x0fLEGACY_REQUIRED\x10\x03\"7\n\x08\x45numType\x12\x15\n\x11\x45NUM_TYPE_UNKNOWN\x10\x00\x12\x08\n\x04OPEN\x10\x01\x12\n\n\x06\x43LOSED\x10\x02\"V\n\x15RepeatedFieldEncoding\x12#\n\x1fREPEATED_FIELD_ENCODING_UNKNOWN\x10\x00\x12\n\n\x06PACKED\x10\x01\x12\x0c\n\x08\x45XPANDED\x10\x02\"I\n\x0eUtf8Validation\x12\x1b\n\x17UTF8_VALIDATION_UNKNOWN\x10\x00\x12\n\n\x06VERIFY\x10\x02\x12\x08\n\x04NONE\x10\x03\"\x04\x08\x01\x10\x01\"S\n\x0fMessageEncoding\x12\x1c\n\x18MESSAGE_ENCODING_UNKNOWN\x10\x00\x12\x13\n\x0fLENGTH_PREFIXED\x10\x01\x12\r\n\tDELIMITED\x10\x02\"H\n\nJsonFormat\x12\x17\n\x13JSON_FORMAT_UNKNOWN\x10\x00\x12\t\n\x05\x41LLOW\x10\x01\x12\x16\n\x12LEGACY_BEST_EFFORT\x10\x02\"f\n\x12\x45nforceNamingStyle\x12 \n\x1c\x45NFORCE_NAMING_STYLE_UNKNOWN\x10\x00\x12\r\n\tSTYLE2024\x10\x01\x12\x10\n\x0cSTYLE_LEGACY\x10\x02\x12\r\n\tSTYLE2026\x10\x03*\x06\x08\xe8\x07\x10\x8bN*\x06\x08\x8bN\x10\x90N*\x06\x08\x90N\x10\x91NJ\x06\x08\xe7\x07\x10\xe8\x07\"\xef\x03\n\x12\x46\x65\x61tureSetDefaults\x12X\n\x08\x64\x65\x66\x61ults\x18\x01 \x03(\x0b\x32<.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefaultR\x08\x64\x65\x66\x61ults\x12\x41\n\x0fminimum_edition\x18\x04 \x01(\x0e\x32\x18.google.protobuf.EditionR\x0eminimumEdition\x12\x41\n\x0fmaximum_edition\x18\x05 \x01(\x0e\x32\x18.google.protobuf.EditionR\x0emaximumEdition\x1a\xf8\x01\n\x18\x46\x65\x61tureSetEditionDefault\x12\x32\n\x07\x65\x64ition\x18\x03 \x01(\x0e\x32\x18.google.protobuf.EditionR\x07\x65\x64ition\x12N\n\x14overridable_features\x18\x04 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\x13overridableFeatures\x12\x42\n\x0e\x66ixed_features\x18\x05 \x01(\x0b\x32\x1b.google.protobuf.FeatureSetR\rfixedFeaturesJ\x04\x08\x01\x10\x02J\x04\x08\x02\x10\x03R\x08\x66\x65\x61tures\"\xb5\x02\n\x0eSourceCodeInfo\x12\x44\n\x08location\x18\x01 \x03(\x0b\x32(.google.protobuf.SourceCodeInfo.LocationR\x08location\x1a\xce\x01\n\x08Location\x12\x16\n\x04path\x18\x01 \x03(\x05\x42\x02\x10\x01R\x04path\x12\x16\n\x04span\x18\x02 \x03(\x05\x42\x02\x10\x01R\x04span\x12)\n\x10leading_comments\x18\x03 \x01(\tR\x0fleadingComments\x12+\n\x11trailing_comments\x18\x04 \x01(\tR\x10trailingComments\x12:\n\x19leading_detached_comments\x18\x06 \x03(\tR\x17leadingDetachedComments*\x0c\x08\x80\xec\xca\xff\x01\x10\x81\xec\xca\xff\x01\"\xd0\x02\n\x11GeneratedCodeInfo\x12M\n\nannotation\x18\x01 \x03(\x0b\x32-.google.protobuf.GeneratedCodeInfo.AnnotationR\nannotation\x1a\xeb\x01\n\nAnnotation\x12\x16\n\x04path\x18\x01 \x03(\x05\x42\x02\x10\x01R\x04path\x12\x1f\n\x0bsource_file\x18\x02 \x01(\tR\nsourceFile\x12\x14\n\x05\x62\x65gin\x18\x03 \x01(\x05R\x05\x62\x65gin\x12\x10\n\x03\x65nd\x18\x04 \x01(\x05R\x03\x65nd\x12R\n\x08semantic\x18\x05 \x01(\x0e\x32\x36.google.protobuf.GeneratedCodeInfo.Annotation.SemanticR\x08semantic\"(\n\x08Semantic\x12\x08\n\x04NONE\x10\x00\x12\x07\n\x03SET\x10\x01\x12\t\n\x05\x41LIAS\x10\x02*\xd1\x02\n\x07\x45\x64ition\x12\x13\n\x0f\x45\x44ITION_UNKNOWN\x10\x00\x12\x13\n\x0e\x45\x44ITION_LEGACY\x10\x84\x07\x12\x13\n\x0e\x45\x44ITION_PROTO2\x10\xe6\x07\x12\x13\n\x0e\x45\x44ITION_PROTO3\x10\xe7\x07\x12\x11\n\x0c\x45\x44ITION_2023\x10\xe8\x07\x12\x11\n\x0c\x45\x44ITION_2024\x10\xe9\x07\x12\x11\n\x0c\x45\x44ITION_2026\x10\xea\x07\x12\x15\n\x10\x45\x44ITION_UNSTABLE\x10\x8fN\x12\x17\n\x13\x45\x44ITION_1_TEST_ONLY\x10\x01\x12\x17\n\x13\x45\x44ITION_2_TEST_ONLY\x10\x02\x12\x1d\n\x17\x45\x44ITION_99997_TEST_ONLY\x10\x9d\x8d\x06\x12\x1d\n\x17\x45\x44ITION_99998_TEST_ONLY\x10\x9e\x8d\x06\x12\x1d\n\x17\x45\x44ITION_99999_TEST_ONLY\x10\x9f\x8d\x06\x12\x13\n\x0b\x45\x44ITION_MAX\x10\xff\xff\xff\xff\x07*U\n\x10SymbolVisibility\x12\x14\n\x10VISIBILITY_UNSET\x10\x00\x12\x14\n\x10VISIBILITY_LOCAL\x10\x01\x12\x15\n\x11VISIBILITY_EXPORT\x10\x02\x42~\n\x13\x63om.google.protobufB\x10\x44\x65scriptorProtosH\x01Z-google.golang.org/protobuf/types/descriptorpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.Reflection') + +_globals = globals() +if not _descriptor._USE_C_DESCRIPTORS: + _EDITION = _descriptor.EnumDescriptor( + name='Edition', + full_name='google.protobuf.Edition', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='EDITION_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_LEGACY', index=1, number=900, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_PROTO2', index=2, number=998, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_PROTO3', index=3, number=999, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_2023', index=4, number=1000, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_2024', index=5, number=1001, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_2026', index=6, number=1002, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_UNSTABLE', index=7, number=9999, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_1_TEST_ONLY', index=8, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_2_TEST_ONLY', index=9, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_99997_TEST_ONLY', index=10, number=99997, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_99998_TEST_ONLY', index=11, number=99998, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_99999_TEST_ONLY', index=12, number=99999, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EDITION_MAX', index=13, number=2147483647, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_EDITION) + + _SYMBOLVISIBILITY = _descriptor.EnumDescriptor( + name='SymbolVisibility', + full_name='google.protobuf.SymbolVisibility', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='VISIBILITY_UNSET', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='VISIBILITY_LOCAL', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='VISIBILITY_EXPORT', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_SYMBOLVISIBILITY) + + _EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE = _descriptor.EnumDescriptor( + name='VerificationState', + full_name='google.protobuf.ExtensionRangeOptions.VerificationState', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='DECLARATION', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='UNVERIFIED', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE) + + _FIELDDESCRIPTORPROTO_TYPE = _descriptor.EnumDescriptor( + name='Type', + full_name='google.protobuf.FieldDescriptorProto.Type', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='TYPE_DOUBLE', index=0, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_FLOAT', index=1, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_INT64', index=2, number=3, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_UINT64', index=3, number=4, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_INT32', index=4, number=5, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_FIXED64', index=5, number=6, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_FIXED32', index=6, number=7, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_BOOL', index=7, number=8, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_STRING', index=8, number=9, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_GROUP', index=9, number=10, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_MESSAGE', index=10, number=11, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_BYTES', index=11, number=12, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_UINT32', index=12, number=13, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_ENUM', index=13, number=14, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_SFIXED32', index=14, number=15, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_SFIXED64', index=15, number=16, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_SINT32', index=16, number=17, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TYPE_SINT64', index=17, number=18, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FIELDDESCRIPTORPROTO_TYPE) + + _FIELDDESCRIPTORPROTO_LABEL = _descriptor.EnumDescriptor( + name='Label', + full_name='google.protobuf.FieldDescriptorProto.Label', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='LABEL_OPTIONAL', index=0, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='LABEL_REPEATED', index=1, number=3, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='LABEL_REQUIRED', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FIELDDESCRIPTORPROTO_LABEL) + + _FILEOPTIONS_OPTIMIZEMODE = _descriptor.EnumDescriptor( + name='OptimizeMode', + full_name='google.protobuf.FileOptions.OptimizeMode', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='SPEED', index=0, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='CODE_SIZE', index=1, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='LITE_RUNTIME', index=2, number=3, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FILEOPTIONS_OPTIMIZEMODE) + + _FIELDOPTIONS_CTYPE = _descriptor.EnumDescriptor( + name='CType', + full_name='google.protobuf.FieldOptions.CType', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='STRING', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='CORD', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='STRING_PIECE', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FIELDOPTIONS_CTYPE) + + _FIELDOPTIONS_JSTYPE = _descriptor.EnumDescriptor( + name='JSType', + full_name='google.protobuf.FieldOptions.JSType', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='JS_NORMAL', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='JS_STRING', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='JS_NUMBER', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FIELDOPTIONS_JSTYPE) + + _FIELDOPTIONS_OPTIONRETENTION = _descriptor.EnumDescriptor( + name='OptionRetention', + full_name='google.protobuf.FieldOptions.OptionRetention', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='RETENTION_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='RETENTION_RUNTIME', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='RETENTION_SOURCE', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FIELDOPTIONS_OPTIONRETENTION) + + _FIELDOPTIONS_OPTIONTARGETTYPE = _descriptor.EnumDescriptor( + name='OptionTargetType', + full_name='google.protobuf.FieldOptions.OptionTargetType', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_FILE', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_EXTENSION_RANGE', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_MESSAGE', index=3, number=3, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_FIELD', index=4, number=4, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_ONEOF', index=5, number=5, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_ENUM', index=6, number=6, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_ENUM_ENTRY', index=7, number=7, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_SERVICE', index=8, number=8, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='TARGET_TYPE_METHOD', index=9, number=9, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FIELDOPTIONS_OPTIONTARGETTYPE) + + _METHODOPTIONS_IDEMPOTENCYLEVEL = _descriptor.EnumDescriptor( + name='IdempotencyLevel', + full_name='google.protobuf.MethodOptions.IdempotencyLevel', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='IDEMPOTENCY_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='NO_SIDE_EFFECTS', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='IDEMPOTENT', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_METHODOPTIONS_IDEMPOTENCYLEVEL) + + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY = _descriptor.EnumDescriptor( + name='DefaultSymbolVisibility', + full_name='google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT_SYMBOL_VISIBILITY_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EXPORT_ALL', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EXPORT_TOP_LEVEL', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='LOCAL_ALL', index=3, number=3, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='STRICT', index=4, number=4, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY) + + _FEATURESET_FIELDPRESENCE = _descriptor.EnumDescriptor( + name='FieldPresence', + full_name='google.protobuf.FeatureSet.FieldPresence', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='FIELD_PRESENCE_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EXPLICIT', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='IMPLICIT', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='LEGACY_REQUIRED', index=3, number=3, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FEATURESET_FIELDPRESENCE) + + _FEATURESET_ENUMTYPE = _descriptor.EnumDescriptor( + name='EnumType', + full_name='google.protobuf.FeatureSet.EnumType', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='ENUM_TYPE_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='OPEN', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='CLOSED', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FEATURESET_ENUMTYPE) + + _FEATURESET_REPEATEDFIELDENCODING = _descriptor.EnumDescriptor( + name='RepeatedFieldEncoding', + full_name='google.protobuf.FeatureSet.RepeatedFieldEncoding', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='REPEATED_FIELD_ENCODING_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='PACKED', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='EXPANDED', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FEATURESET_REPEATEDFIELDENCODING) + + _FEATURESET_UTF8VALIDATION = _descriptor.EnumDescriptor( + name='Utf8Validation', + full_name='google.protobuf.FeatureSet.Utf8Validation', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='UTF8_VALIDATION_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='VERIFY', index=1, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='NONE', index=2, number=3, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FEATURESET_UTF8VALIDATION) + + _FEATURESET_MESSAGEENCODING = _descriptor.EnumDescriptor( + name='MessageEncoding', + full_name='google.protobuf.FeatureSet.MessageEncoding', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='MESSAGE_ENCODING_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='LENGTH_PREFIXED', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='DELIMITED', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FEATURESET_MESSAGEENCODING) + + _FEATURESET_JSONFORMAT = _descriptor.EnumDescriptor( + name='JsonFormat', + full_name='google.protobuf.FeatureSet.JsonFormat', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='JSON_FORMAT_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='ALLOW', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='LEGACY_BEST_EFFORT', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FEATURESET_JSONFORMAT) + + _FEATURESET_ENFORCENAMINGSTYLE = _descriptor.EnumDescriptor( + name='EnforceNamingStyle', + full_name='google.protobuf.FeatureSet.EnforceNamingStyle', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='ENFORCE_NAMING_STYLE_UNKNOWN', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='STYLE2024', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='STYLE_LEGACY', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='STYLE2026', index=3, number=3, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_FEATURESET_ENFORCENAMINGSTYLE) + + _GENERATEDCODEINFO_ANNOTATION_SEMANTIC = _descriptor.EnumDescriptor( + name='Semantic', + full_name='google.protobuf.GeneratedCodeInfo.Annotation.Semantic', + filename=None, + file=DESCRIPTOR, + create_key=_descriptor._internal_create_key, + values=[ + _descriptor.EnumValueDescriptor( + name='NONE', index=0, number=0, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='SET', index=1, number=1, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + _descriptor.EnumValueDescriptor( + name='ALIAS', index=2, number=2, + serialized_options=None, + type=None, + create_key=_descriptor._internal_create_key), + ], + containing_type=None, + serialized_options=None, + ) + _sym_db.RegisterEnumDescriptor(_GENERATEDCODEINFO_ANNOTATION_SEMANTIC) + + + _FILEDESCRIPTORSET = _descriptor.Descriptor( + name='FileDescriptorSet', + full_name='google.protobuf.FileDescriptorSet', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='file', full_name='google.protobuf.FileDescriptorSet.file', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='file', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(536000000, 536000001), ], + oneofs=[ + ], + ) + + + _FILEDESCRIPTORPROTO = _descriptor.Descriptor( + name='FileDescriptorProto', + full_name='google.protobuf.FileDescriptorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.FileDescriptorProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='package', full_name='google.protobuf.FileDescriptorProto.package', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='package', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='dependency', full_name='google.protobuf.FileDescriptorProto.dependency', index=2, + number=3, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='dependency', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='public_dependency', full_name='google.protobuf.FileDescriptorProto.public_dependency', index=3, + number=10, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='publicDependency', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='weak_dependency', full_name='google.protobuf.FileDescriptorProto.weak_dependency', index=4, + number=11, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='weakDependency', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='option_dependency', full_name='google.protobuf.FileDescriptorProto.option_dependency', index=5, + number=15, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='optionDependency', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='message_type', full_name='google.protobuf.FileDescriptorProto.message_type', index=6, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='messageType', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='enum_type', full_name='google.protobuf.FileDescriptorProto.enum_type', index=7, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='enumType', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='service', full_name='google.protobuf.FileDescriptorProto.service', index=8, + number=6, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='service', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='extension', full_name='google.protobuf.FileDescriptorProto.extension', index=9, + number=7, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='extension', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.FileDescriptorProto.options', index=10, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='source_code_info', full_name='google.protobuf.FileDescriptorProto.source_code_info', index=11, + number=9, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='sourceCodeInfo', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='syntax', full_name='google.protobuf.FileDescriptorProto.syntax', index=12, + number=12, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='syntax', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='edition', full_name='google.protobuf.FileDescriptorProto.edition', index=13, + number=14, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='edition', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _DESCRIPTORPROTO_EXTENSIONRANGE = _descriptor.Descriptor( + name='ExtensionRange', + full_name='google.protobuf.DescriptorProto.ExtensionRange', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='start', full_name='google.protobuf.DescriptorProto.ExtensionRange.start', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='start', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='end', full_name='google.protobuf.DescriptorProto.ExtensionRange.end', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='end', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.DescriptorProto.ExtensionRange.options', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _DESCRIPTORPROTO_RESERVEDRANGE = _descriptor.Descriptor( + name='ReservedRange', + full_name='google.protobuf.DescriptorProto.ReservedRange', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='start', full_name='google.protobuf.DescriptorProto.ReservedRange.start', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='start', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='end', full_name='google.protobuf.DescriptorProto.ReservedRange.end', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='end', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _DESCRIPTORPROTO = _descriptor.Descriptor( + name='DescriptorProto', + full_name='google.protobuf.DescriptorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.DescriptorProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='field', full_name='google.protobuf.DescriptorProto.field', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='field', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='extension', full_name='google.protobuf.DescriptorProto.extension', index=2, + number=6, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='extension', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='nested_type', full_name='google.protobuf.DescriptorProto.nested_type', index=3, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='nestedType', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='enum_type', full_name='google.protobuf.DescriptorProto.enum_type', index=4, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='enumType', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='extension_range', full_name='google.protobuf.DescriptorProto.extension_range', index=5, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='extensionRange', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='oneof_decl', full_name='google.protobuf.DescriptorProto.oneof_decl', index=6, + number=8, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='oneofDecl', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.DescriptorProto.options', index=7, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='reserved_range', full_name='google.protobuf.DescriptorProto.reserved_range', index=8, + number=9, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='reservedRange', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='reserved_name', full_name='google.protobuf.DescriptorProto.reserved_name', index=9, + number=10, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='reservedName', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='visibility', full_name='google.protobuf.DescriptorProto.visibility', index=10, + number=11, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='visibility', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_DESCRIPTORPROTO_EXTENSIONRANGE, _DESCRIPTORPROTO_RESERVEDRANGE, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _EXTENSIONRANGEOPTIONS_DECLARATION = _descriptor.Descriptor( + name='Declaration', + full_name='google.protobuf.ExtensionRangeOptions.Declaration', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='number', full_name='google.protobuf.ExtensionRangeOptions.Declaration.number', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='number', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='full_name', full_name='google.protobuf.ExtensionRangeOptions.Declaration.full_name', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='fullName', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='type', full_name='google.protobuf.ExtensionRangeOptions.Declaration.type', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='type', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='reserved', full_name='google.protobuf.ExtensionRangeOptions.Declaration.reserved', index=3, + number=5, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='reserved', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='repeated', full_name='google.protobuf.ExtensionRangeOptions.Declaration.repeated', index=4, + number=6, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='repeated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _EXTENSIONRANGEOPTIONS = _descriptor.Descriptor( + name='ExtensionRangeOptions', + full_name='google.protobuf.ExtensionRangeOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.ExtensionRangeOptions.uninterpreted_option', index=0, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='declaration', full_name='google.protobuf.ExtensionRangeOptions.declaration', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\002', json_name='declaration', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.ExtensionRangeOptions.features', index=2, + number=50, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='verification', full_name='google.protobuf.ExtensionRangeOptions.verification', index=3, + number=3, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\002', json_name='verification', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_EXTENSIONRANGEOPTIONS_DECLARATION, ], + enum_types=[ + _EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE, + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _FIELDDESCRIPTORPROTO = _descriptor.Descriptor( + name='FieldDescriptorProto', + full_name='google.protobuf.FieldDescriptorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.FieldDescriptorProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='number', full_name='google.protobuf.FieldDescriptorProto.number', index=1, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='number', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='label', full_name='google.protobuf.FieldDescriptorProto.label', index=2, + number=4, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='label', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='type', full_name='google.protobuf.FieldDescriptorProto.type', index=3, + number=5, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='type', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='type_name', full_name='google.protobuf.FieldDescriptorProto.type_name', index=4, + number=6, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='typeName', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='extendee', full_name='google.protobuf.FieldDescriptorProto.extendee', index=5, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='extendee', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='default_value', full_name='google.protobuf.FieldDescriptorProto.default_value', index=6, + number=7, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='defaultValue', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='oneof_index', full_name='google.protobuf.FieldDescriptorProto.oneof_index', index=7, + number=9, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='oneofIndex', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='json_name', full_name='google.protobuf.FieldDescriptorProto.json_name', index=8, + number=10, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='jsonName', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.FieldDescriptorProto.options', index=9, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='proto3_optional', full_name='google.protobuf.FieldDescriptorProto.proto3_optional', index=10, + number=17, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='proto3Optional', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _FIELDDESCRIPTORPROTO_TYPE, + _FIELDDESCRIPTORPROTO_LABEL, + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _ONEOFDESCRIPTORPROTO = _descriptor.Descriptor( + name='OneofDescriptorProto', + full_name='google.protobuf.OneofDescriptorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.OneofDescriptorProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.OneofDescriptorProto.options', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE = _descriptor.Descriptor( + name='EnumReservedRange', + full_name='google.protobuf.EnumDescriptorProto.EnumReservedRange', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='start', full_name='google.protobuf.EnumDescriptorProto.EnumReservedRange.start', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='start', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='end', full_name='google.protobuf.EnumDescriptorProto.EnumReservedRange.end', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='end', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _ENUMDESCRIPTORPROTO = _descriptor.Descriptor( + name='EnumDescriptorProto', + full_name='google.protobuf.EnumDescriptorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.EnumDescriptorProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='value', full_name='google.protobuf.EnumDescriptorProto.value', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='value', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.EnumDescriptorProto.options', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='reserved_range', full_name='google.protobuf.EnumDescriptorProto.reserved_range', index=3, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='reservedRange', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='reserved_name', full_name='google.protobuf.EnumDescriptorProto.reserved_name', index=4, + number=5, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='reservedName', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='visibility', full_name='google.protobuf.EnumDescriptorProto.visibility', index=5, + number=6, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='visibility', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _ENUMVALUEDESCRIPTORPROTO = _descriptor.Descriptor( + name='EnumValueDescriptorProto', + full_name='google.protobuf.EnumValueDescriptorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.EnumValueDescriptorProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='number', full_name='google.protobuf.EnumValueDescriptorProto.number', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='number', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.EnumValueDescriptorProto.options', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _SERVICEDESCRIPTORPROTO = _descriptor.Descriptor( + name='ServiceDescriptorProto', + full_name='google.protobuf.ServiceDescriptorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.ServiceDescriptorProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='method', full_name='google.protobuf.ServiceDescriptorProto.method', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='method', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.ServiceDescriptorProto.options', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _METHODDESCRIPTORPROTO = _descriptor.Descriptor( + name='MethodDescriptorProto', + full_name='google.protobuf.MethodDescriptorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.MethodDescriptorProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='input_type', full_name='google.protobuf.MethodDescriptorProto.input_type', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='inputType', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='output_type', full_name='google.protobuf.MethodDescriptorProto.output_type', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='outputType', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='options', full_name='google.protobuf.MethodDescriptorProto.options', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='options', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='client_streaming', full_name='google.protobuf.MethodDescriptorProto.client_streaming', index=4, + number=5, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='clientStreaming', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='server_streaming', full_name='google.protobuf.MethodDescriptorProto.server_streaming', index=5, + number=6, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='serverStreaming', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _FILEOPTIONS = _descriptor.Descriptor( + name='FileOptions', + full_name='google.protobuf.FileOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='java_package', full_name='google.protobuf.FileOptions.java_package', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='javaPackage', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='java_outer_classname', full_name='google.protobuf.FileOptions.java_outer_classname', index=1, + number=8, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='javaOuterClassname', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='java_multiple_files', full_name='google.protobuf.FileOptions.java_multiple_files', index=2, + number=10, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\262\001\275\001\010\346\007 \351\007*\264\001This behavior is enabled by default in editions 2024 and above. To disable it, you can set `features.(pb.java).nest_in_file_class = YES` on individual messages, enums, or services.', json_name='javaMultipleFiles', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='java_generate_equals_and_hash', full_name='google.protobuf.FileOptions.java_generate_equals_and_hash', index=3, + number=20, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\030\001', json_name='javaGenerateEqualsAndHash', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='java_string_check_utf8', full_name='google.protobuf.FileOptions.java_string_check_utf8', index=4, + number=27, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='javaStringCheckUtf8', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='optimize_for', full_name='google.protobuf.FileOptions.optimize_for', index=5, + number=9, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='optimizeFor', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='go_package', full_name='google.protobuf.FileOptions.go_package', index=6, + number=11, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='goPackage', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='cc_generic_services', full_name='google.protobuf.FileOptions.cc_generic_services', index=7, + number=16, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='ccGenericServices', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='java_generic_services', full_name='google.protobuf.FileOptions.java_generic_services', index=8, + number=17, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='javaGenericServices', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='py_generic_services', full_name='google.protobuf.FileOptions.py_generic_services', index=9, + number=18, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='pyGenericServices', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='deprecated', full_name='google.protobuf.FileOptions.deprecated', index=10, + number=23, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='deprecated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='cc_enable_arenas', full_name='google.protobuf.FileOptions.cc_enable_arenas', index=11, + number=31, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=True, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='ccEnableArenas', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='objc_class_prefix', full_name='google.protobuf.FileOptions.objc_class_prefix', index=12, + number=36, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='objcClassPrefix', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='csharp_namespace', full_name='google.protobuf.FileOptions.csharp_namespace', index=13, + number=37, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='csharpNamespace', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='swift_prefix', full_name='google.protobuf.FileOptions.swift_prefix', index=14, + number=39, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='swiftPrefix', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='php_class_prefix', full_name='google.protobuf.FileOptions.php_class_prefix', index=15, + number=40, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='phpClassPrefix', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='php_namespace', full_name='google.protobuf.FileOptions.php_namespace', index=16, + number=41, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='phpNamespace', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='php_metadata_namespace', full_name='google.protobuf.FileOptions.php_metadata_namespace', index=17, + number=44, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='phpMetadataNamespace', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='ruby_package', full_name='google.protobuf.FileOptions.ruby_package', index=18, + number=45, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='rubyPackage', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.FileOptions.features', index=19, + number=50, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.FileOptions.uninterpreted_option', index=20, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _FILEOPTIONS_OPTIMIZEMODE, + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _MESSAGEOPTIONS = _descriptor.Descriptor( + name='MessageOptions', + full_name='google.protobuf.MessageOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='message_set_wire_format', full_name='google.protobuf.MessageOptions.message_set_wire_format', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='messageSetWireFormat', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='no_standard_descriptor_accessor', full_name='google.protobuf.MessageOptions.no_standard_descriptor_accessor', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='noStandardDescriptorAccessor', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='deprecated', full_name='google.protobuf.MessageOptions.deprecated', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='deprecated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='map_entry', full_name='google.protobuf.MessageOptions.map_entry', index=3, + number=7, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='mapEntry', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='deprecated_legacy_json_field_conflicts', full_name='google.protobuf.MessageOptions.deprecated_legacy_json_field_conflicts', index=4, + number=11, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\030\001', json_name='deprecatedLegacyJsonFieldConflicts', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.MessageOptions.features', index=5, + number=12, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.MessageOptions.uninterpreted_option', index=6, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _FIELDOPTIONS_EDITIONDEFAULT = _descriptor.Descriptor( + name='EditionDefault', + full_name='google.protobuf.FieldOptions.EditionDefault', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='edition', full_name='google.protobuf.FieldOptions.EditionDefault.edition', index=0, + number=3, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='edition', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='value', full_name='google.protobuf.FieldOptions.EditionDefault.value', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='value', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _FIELDOPTIONS_FEATURESUPPORT = _descriptor.Descriptor( + name='FeatureSupport', + full_name='google.protobuf.FieldOptions.FeatureSupport', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='edition_introduced', full_name='google.protobuf.FieldOptions.FeatureSupport.edition_introduced', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='editionIntroduced', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='edition_deprecated', full_name='google.protobuf.FieldOptions.FeatureSupport.edition_deprecated', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='editionDeprecated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='deprecation_warning', full_name='google.protobuf.FieldOptions.FeatureSupport.deprecation_warning', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='deprecationWarning', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='edition_removed', full_name='google.protobuf.FieldOptions.FeatureSupport.edition_removed', index=3, + number=4, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='editionRemoved', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='removal_error', full_name='google.protobuf.FieldOptions.FeatureSupport.removal_error', index=4, + number=5, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='removalError', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _FIELDOPTIONS = _descriptor.Descriptor( + name='FieldOptions', + full_name='google.protobuf.FieldOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='ctype', full_name='google.protobuf.FieldOptions.ctype', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='ctype', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='packed', full_name='google.protobuf.FieldOptions.packed', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='packed', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='jstype', full_name='google.protobuf.FieldOptions.jstype', index=2, + number=6, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='jstype', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='lazy', full_name='google.protobuf.FieldOptions.lazy', index=3, + number=5, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='lazy', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='unverified_lazy', full_name='google.protobuf.FieldOptions.unverified_lazy', index=4, + number=15, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='unverifiedLazy', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='deprecated', full_name='google.protobuf.FieldOptions.deprecated', index=5, + number=3, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='deprecated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='weak', full_name='google.protobuf.FieldOptions.weak', index=6, + number=10, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\030\001', json_name='weak', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='debug_redact', full_name='google.protobuf.FieldOptions.debug_redact', index=7, + number=16, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='debugRedact', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='retention', full_name='google.protobuf.FieldOptions.retention', index=8, + number=17, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='retention', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='targets', full_name='google.protobuf.FieldOptions.targets', index=9, + number=19, type=14, cpp_type=8, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='targets', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='edition_defaults', full_name='google.protobuf.FieldOptions.edition_defaults', index=10, + number=20, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='editionDefaults', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.FieldOptions.features', index=11, + number=21, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='feature_support', full_name='google.protobuf.FieldOptions.feature_support', index=12, + number=22, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='featureSupport', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.FieldOptions.uninterpreted_option', index=13, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_FIELDOPTIONS_EDITIONDEFAULT, _FIELDOPTIONS_FEATURESUPPORT, ], + enum_types=[ + _FIELDOPTIONS_CTYPE, + _FIELDOPTIONS_JSTYPE, + _FIELDOPTIONS_OPTIONRETENTION, + _FIELDOPTIONS_OPTIONTARGETTYPE, + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _ONEOFOPTIONS = _descriptor.Descriptor( + name='OneofOptions', + full_name='google.protobuf.OneofOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.OneofOptions.features', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.OneofOptions.uninterpreted_option', index=1, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _ENUMOPTIONS = _descriptor.Descriptor( + name='EnumOptions', + full_name='google.protobuf.EnumOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='allow_alias', full_name='google.protobuf.EnumOptions.allow_alias', index=0, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='allowAlias', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='deprecated', full_name='google.protobuf.EnumOptions.deprecated', index=1, + number=3, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='deprecated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='deprecated_legacy_json_field_conflicts', full_name='google.protobuf.EnumOptions.deprecated_legacy_json_field_conflicts', index=2, + number=6, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\030\001', json_name='deprecatedLegacyJsonFieldConflicts', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.EnumOptions.features', index=3, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.EnumOptions.uninterpreted_option', index=4, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _ENUMVALUEOPTIONS = _descriptor.Descriptor( + name='EnumValueOptions', + full_name='google.protobuf.EnumValueOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='deprecated', full_name='google.protobuf.EnumValueOptions.deprecated', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='deprecated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.EnumValueOptions.features', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='debug_redact', full_name='google.protobuf.EnumValueOptions.debug_redact', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='debugRedact', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='feature_support', full_name='google.protobuf.EnumValueOptions.feature_support', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='featureSupport', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.EnumValueOptions.uninterpreted_option', index=4, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _SERVICEOPTIONS = _descriptor.Descriptor( + name='ServiceOptions', + full_name='google.protobuf.ServiceOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.ServiceOptions.features', index=0, + number=34, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='deprecated', full_name='google.protobuf.ServiceOptions.deprecated', index=1, + number=33, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='deprecated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.ServiceOptions.uninterpreted_option', index=2, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _METHODOPTIONS = _descriptor.Descriptor( + name='MethodOptions', + full_name='google.protobuf.MethodOptions', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='deprecated', full_name='google.protobuf.MethodOptions.deprecated', index=0, + number=33, type=8, cpp_type=7, label=1, + has_default_value=True, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='deprecated', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='idempotency_level', full_name='google.protobuf.MethodOptions.idempotency_level', index=1, + number=34, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='idempotencyLevel', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='features', full_name='google.protobuf.MethodOptions.features', index=2, + number=35, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='features', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='uninterpreted_option', full_name='google.protobuf.MethodOptions.uninterpreted_option', index=3, + number=999, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='uninterpretedOption', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _METHODOPTIONS_IDEMPOTENCYLEVEL, + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(990, 999), (1000, 536870912), ], + oneofs=[ + ], + ) + + + _UNINTERPRETEDOPTION_NAMEPART = _descriptor.Descriptor( + name='NamePart', + full_name='google.protobuf.UninterpretedOption.NamePart', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name_part', full_name='google.protobuf.UninterpretedOption.NamePart.name_part', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='namePart', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='is_extension', full_name='google.protobuf.UninterpretedOption.NamePart.is_extension', index=1, + number=2, type=8, cpp_type=7, label=2, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='isExtension', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _UNINTERPRETEDOPTION = _descriptor.Descriptor( + name='UninterpretedOption', + full_name='google.protobuf.UninterpretedOption', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.protobuf.UninterpretedOption.name', index=0, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='name', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='identifier_value', full_name='google.protobuf.UninterpretedOption.identifier_value', index=1, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='identifierValue', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='positive_int_value', full_name='google.protobuf.UninterpretedOption.positive_int_value', index=2, + number=4, type=4, cpp_type=4, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='positiveIntValue', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='negative_int_value', full_name='google.protobuf.UninterpretedOption.negative_int_value', index=3, + number=5, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='negativeIntValue', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='double_value', full_name='google.protobuf.UninterpretedOption.double_value', index=4, + number=6, type=1, cpp_type=5, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='doubleValue', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='string_value', full_name='google.protobuf.UninterpretedOption.string_value', index=5, + number=7, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=b"", + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='stringValue', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='aggregate_value', full_name='google.protobuf.UninterpretedOption.aggregate_value', index=6, + number=8, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='aggregateValue', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_UNINTERPRETEDOPTION_NAMEPART, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _FEATURESET_VISIBILITYFEATURE = _descriptor.Descriptor( + name='VisibilityFeature', + full_name='google.protobuf.FeatureSet.VisibilityFeature', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY, + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _FEATURESET = _descriptor.Descriptor( + name='FeatureSet', + full_name='google.protobuf.FeatureSet', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='field_presence', full_name='google.protobuf.FeatureSet.field_presence', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\001\230\001\004\230\001\001\242\001\r\022\010EXPLICIT\030\204\007\242\001\r\022\010IMPLICIT\030\347\007\242\001\r\022\010EXPLICIT\030\350\007\262\001\003\010\350\007', json_name='fieldPresence', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='enum_type', full_name='google.protobuf.FeatureSet.enum_type', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\001\230\001\006\230\001\001\242\001\013\022\006CLOSED\030\204\007\242\001\t\022\004OPEN\030\347\007\262\001\003\010\350\007', json_name='enumType', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='repeated_field_encoding', full_name='google.protobuf.FeatureSet.repeated_field_encoding', index=2, + number=3, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\001\230\001\004\230\001\001\242\001\r\022\010EXPANDED\030\204\007\242\001\013\022\006PACKED\030\347\007\262\001\003\010\350\007', json_name='repeatedFieldEncoding', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='utf8_validation', full_name='google.protobuf.FeatureSet.utf8_validation', index=3, + number=4, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\001\230\001\004\230\001\001\242\001\t\022\004NONE\030\204\007\242\001\013\022\006VERIFY\030\347\007\262\001\003\010\350\007', json_name='utf8Validation', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='message_encoding', full_name='google.protobuf.FeatureSet.message_encoding', index=4, + number=5, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\001\230\001\004\230\001\001\242\001\024\022\017LENGTH_PREFIXED\030\204\007\262\001\003\010\350\007', json_name='messageEncoding', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='json_format', full_name='google.protobuf.FeatureSet.json_format', index=5, + number=6, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\001\230\001\003\230\001\006\230\001\001\242\001\027\022\022LEGACY_BEST_EFFORT\030\204\007\242\001\n\022\005ALLOW\030\347\007\262\001\003\010\350\007', json_name='jsonFormat', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='enforce_naming_style', full_name='google.protobuf.FeatureSet.enforce_naming_style', index=6, + number=7, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\002\230\001\001\230\001\002\230\001\003\230\001\004\230\001\005\230\001\006\230\001\007\230\001\010\230\001\t\242\001\021\022\014STYLE_LEGACY\030\204\007\242\001\016\022\tSTYLE2024\030\351\007\242\001\016\022\tSTYLE2026\030\217N\262\001\003\010\351\007', json_name='enforceNamingStyle', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='default_symbol_visibility', full_name='google.protobuf.FeatureSet.default_symbol_visibility', index=7, + number=8, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\210\001\002\230\001\001\242\001\017\022\nEXPORT_ALL\030\204\007\242\001\025\022\020EXPORT_TOP_LEVEL\030\351\007\262\001\003\010\351\007', json_name='defaultSymbolVisibility', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_FEATURESET_VISIBILITYFEATURE, ], + enum_types=[ + _FEATURESET_FIELDPRESENCE, + _FEATURESET_ENUMTYPE, + _FEATURESET_REPEATEDFIELDENCODING, + _FEATURESET_UTF8VALIDATION, + _FEATURESET_MESSAGEENCODING, + _FEATURESET_JSONFORMAT, + _FEATURESET_ENFORCENAMINGSTYLE, + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(1000, 9995), (9995, 10000), (10000, 10001), ], + oneofs=[ + ], + ) + + + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT = _descriptor.Descriptor( + name='FeatureSetEditionDefault', + full_name='google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='edition', full_name='google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition', index=0, + number=3, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='edition', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='overridable_features', full_name='google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.overridable_features', index=1, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='overridableFeatures', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='fixed_features', full_name='google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.fixed_features', index=2, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='fixedFeatures', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _FEATURESETDEFAULTS = _descriptor.Descriptor( + name='FeatureSetDefaults', + full_name='google.protobuf.FeatureSetDefaults', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='defaults', full_name='google.protobuf.FeatureSetDefaults.defaults', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='defaults', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='minimum_edition', full_name='google.protobuf.FeatureSetDefaults.minimum_edition', index=1, + number=4, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='minimumEdition', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='maximum_edition', full_name='google.protobuf.FeatureSetDefaults.maximum_edition', index=2, + number=5, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='maximumEdition', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + + _SOURCECODEINFO_LOCATION = _descriptor.Descriptor( + name='Location', + full_name='google.protobuf.SourceCodeInfo.Location', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='path', full_name='google.protobuf.SourceCodeInfo.Location.path', index=0, + number=1, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\020\001', json_name='path', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='span', full_name='google.protobuf.SourceCodeInfo.Location.span', index=1, + number=2, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\020\001', json_name='span', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='leading_comments', full_name='google.protobuf.SourceCodeInfo.Location.leading_comments', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='leadingComments', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='trailing_comments', full_name='google.protobuf.SourceCodeInfo.Location.trailing_comments', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='trailingComments', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='leading_detached_comments', full_name='google.protobuf.SourceCodeInfo.Location.leading_detached_comments', index=4, + number=6, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='leadingDetachedComments', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _SOURCECODEINFO = _descriptor.Descriptor( + name='SourceCodeInfo', + full_name='google.protobuf.SourceCodeInfo', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='location', full_name='google.protobuf.SourceCodeInfo.location', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='location', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_SOURCECODEINFO_LOCATION, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=True, + extension_ranges=[(536000000, 536000001), ], + oneofs=[ + ], + ) + + + _GENERATEDCODEINFO_ANNOTATION = _descriptor.Descriptor( + name='Annotation', + full_name='google.protobuf.GeneratedCodeInfo.Annotation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='path', full_name='google.protobuf.GeneratedCodeInfo.Annotation.path', index=0, + number=1, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=b'\020\001', json_name='path', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='source_file', full_name='google.protobuf.GeneratedCodeInfo.Annotation.source_file', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=b"".decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='sourceFile', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='begin', full_name='google.protobuf.GeneratedCodeInfo.Annotation.begin', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='begin', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='end', full_name='google.protobuf.GeneratedCodeInfo.Annotation.end', index=3, + number=4, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='end', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + _descriptor.FieldDescriptor( + name='semantic', full_name='google.protobuf.GeneratedCodeInfo.Annotation.semantic', index=4, + number=5, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='semantic', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _GENERATEDCODEINFO_ANNOTATION_SEMANTIC, + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _GENERATEDCODEINFO = _descriptor.Descriptor( + name='GeneratedCodeInfo', + full_name='google.protobuf.GeneratedCodeInfo', + filename=None, + file=DESCRIPTOR, + containing_type=None, + create_key=_descriptor._internal_create_key, + fields=[ + _descriptor.FieldDescriptor( + name='annotation', full_name='google.protobuf.GeneratedCodeInfo.annotation', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, json_name='annotation', file=DESCRIPTOR, create_key=_descriptor._internal_create_key), + ], + extensions=[ + ], + nested_types=[_GENERATEDCODEINFO_ANNOTATION, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + ) + + _FILEDESCRIPTORSET.fields_by_name['file'].message_type = _FILEDESCRIPTORPROTO + _FILEDESCRIPTORPROTO.fields_by_name['message_type'].message_type = _DESCRIPTORPROTO + _FILEDESCRIPTORPROTO.fields_by_name['enum_type'].message_type = _ENUMDESCRIPTORPROTO + _FILEDESCRIPTORPROTO.fields_by_name['service'].message_type = _SERVICEDESCRIPTORPROTO + _FILEDESCRIPTORPROTO.fields_by_name['extension'].message_type = _FIELDDESCRIPTORPROTO + _FILEDESCRIPTORPROTO.fields_by_name['options'].message_type = _FILEOPTIONS + _FILEDESCRIPTORPROTO.fields_by_name['source_code_info'].message_type = _SOURCECODEINFO + _FILEDESCRIPTORPROTO.fields_by_name['edition'].enum_type = _EDITION + _DESCRIPTORPROTO_EXTENSIONRANGE.fields_by_name['options'].message_type = _EXTENSIONRANGEOPTIONS + _DESCRIPTORPROTO_EXTENSIONRANGE.containing_type = _DESCRIPTORPROTO + _DESCRIPTORPROTO_RESERVEDRANGE.containing_type = _DESCRIPTORPROTO + _DESCRIPTORPROTO.fields_by_name['field'].message_type = _FIELDDESCRIPTORPROTO + _DESCRIPTORPROTO.fields_by_name['extension'].message_type = _FIELDDESCRIPTORPROTO + _DESCRIPTORPROTO.fields_by_name['nested_type'].message_type = _DESCRIPTORPROTO + _DESCRIPTORPROTO.fields_by_name['enum_type'].message_type = _ENUMDESCRIPTORPROTO + _DESCRIPTORPROTO.fields_by_name['extension_range'].message_type = _DESCRIPTORPROTO_EXTENSIONRANGE + _DESCRIPTORPROTO.fields_by_name['oneof_decl'].message_type = _ONEOFDESCRIPTORPROTO + _DESCRIPTORPROTO.fields_by_name['options'].message_type = _MESSAGEOPTIONS + _DESCRIPTORPROTO.fields_by_name['reserved_range'].message_type = _DESCRIPTORPROTO_RESERVEDRANGE + _DESCRIPTORPROTO.fields_by_name['visibility'].enum_type = _SYMBOLVISIBILITY + _EXTENSIONRANGEOPTIONS_DECLARATION.containing_type = _EXTENSIONRANGEOPTIONS + _EXTENSIONRANGEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _EXTENSIONRANGEOPTIONS.fields_by_name['declaration'].message_type = _EXTENSIONRANGEOPTIONS_DECLARATION + _EXTENSIONRANGEOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _EXTENSIONRANGEOPTIONS.fields_by_name['verification'].enum_type = _EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE + _EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE.containing_type = _EXTENSIONRANGEOPTIONS + _FIELDDESCRIPTORPROTO.fields_by_name['label'].enum_type = _FIELDDESCRIPTORPROTO_LABEL + _FIELDDESCRIPTORPROTO.fields_by_name['type'].enum_type = _FIELDDESCRIPTORPROTO_TYPE + _FIELDDESCRIPTORPROTO.fields_by_name['options'].message_type = _FIELDOPTIONS + _FIELDDESCRIPTORPROTO_TYPE.containing_type = _FIELDDESCRIPTORPROTO + _FIELDDESCRIPTORPROTO_LABEL.containing_type = _FIELDDESCRIPTORPROTO + _ONEOFDESCRIPTORPROTO.fields_by_name['options'].message_type = _ONEOFOPTIONS + _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE.containing_type = _ENUMDESCRIPTORPROTO + _ENUMDESCRIPTORPROTO.fields_by_name['value'].message_type = _ENUMVALUEDESCRIPTORPROTO + _ENUMDESCRIPTORPROTO.fields_by_name['options'].message_type = _ENUMOPTIONS + _ENUMDESCRIPTORPROTO.fields_by_name['reserved_range'].message_type = _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE + _ENUMDESCRIPTORPROTO.fields_by_name['visibility'].enum_type = _SYMBOLVISIBILITY + _ENUMVALUEDESCRIPTORPROTO.fields_by_name['options'].message_type = _ENUMVALUEOPTIONS + _SERVICEDESCRIPTORPROTO.fields_by_name['method'].message_type = _METHODDESCRIPTORPROTO + _SERVICEDESCRIPTORPROTO.fields_by_name['options'].message_type = _SERVICEOPTIONS + _METHODDESCRIPTORPROTO.fields_by_name['options'].message_type = _METHODOPTIONS + _FILEOPTIONS.fields_by_name['optimize_for'].enum_type = _FILEOPTIONS_OPTIMIZEMODE + _FILEOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _FILEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _FILEOPTIONS_OPTIMIZEMODE.containing_type = _FILEOPTIONS + _MESSAGEOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _MESSAGEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _FIELDOPTIONS_EDITIONDEFAULT.fields_by_name['edition'].enum_type = _EDITION + _FIELDOPTIONS_EDITIONDEFAULT.containing_type = _FIELDOPTIONS + _FIELDOPTIONS_FEATURESUPPORT.fields_by_name['edition_introduced'].enum_type = _EDITION + _FIELDOPTIONS_FEATURESUPPORT.fields_by_name['edition_deprecated'].enum_type = _EDITION + _FIELDOPTIONS_FEATURESUPPORT.fields_by_name['edition_removed'].enum_type = _EDITION + _FIELDOPTIONS_FEATURESUPPORT.containing_type = _FIELDOPTIONS + _FIELDOPTIONS.fields_by_name['ctype'].enum_type = _FIELDOPTIONS_CTYPE + _FIELDOPTIONS.fields_by_name['jstype'].enum_type = _FIELDOPTIONS_JSTYPE + _FIELDOPTIONS.fields_by_name['retention'].enum_type = _FIELDOPTIONS_OPTIONRETENTION + _FIELDOPTIONS.fields_by_name['targets'].enum_type = _FIELDOPTIONS_OPTIONTARGETTYPE + _FIELDOPTIONS.fields_by_name['edition_defaults'].message_type = _FIELDOPTIONS_EDITIONDEFAULT + _FIELDOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _FIELDOPTIONS.fields_by_name['feature_support'].message_type = _FIELDOPTIONS_FEATURESUPPORT + _FIELDOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _FIELDOPTIONS_CTYPE.containing_type = _FIELDOPTIONS + _FIELDOPTIONS_JSTYPE.containing_type = _FIELDOPTIONS + _FIELDOPTIONS_OPTIONRETENTION.containing_type = _FIELDOPTIONS + _FIELDOPTIONS_OPTIONTARGETTYPE.containing_type = _FIELDOPTIONS + _ONEOFOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _ONEOFOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _ENUMOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _ENUMOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _ENUMVALUEOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _ENUMVALUEOPTIONS.fields_by_name['feature_support'].message_type = _FIELDOPTIONS_FEATURESUPPORT + _ENUMVALUEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _SERVICEOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _SERVICEOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _METHODOPTIONS.fields_by_name['idempotency_level'].enum_type = _METHODOPTIONS_IDEMPOTENCYLEVEL + _METHODOPTIONS.fields_by_name['features'].message_type = _FEATURESET + _METHODOPTIONS.fields_by_name['uninterpreted_option'].message_type = _UNINTERPRETEDOPTION + _METHODOPTIONS_IDEMPOTENCYLEVEL.containing_type = _METHODOPTIONS + _UNINTERPRETEDOPTION_NAMEPART.containing_type = _UNINTERPRETEDOPTION + _UNINTERPRETEDOPTION.fields_by_name['name'].message_type = _UNINTERPRETEDOPTION_NAMEPART + _FEATURESET_VISIBILITYFEATURE.containing_type = _FEATURESET + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY.containing_type = _FEATURESET_VISIBILITYFEATURE + _FEATURESET.fields_by_name['field_presence'].enum_type = _FEATURESET_FIELDPRESENCE + _FEATURESET.fields_by_name['enum_type'].enum_type = _FEATURESET_ENUMTYPE + _FEATURESET.fields_by_name['repeated_field_encoding'].enum_type = _FEATURESET_REPEATEDFIELDENCODING + _FEATURESET.fields_by_name['utf8_validation'].enum_type = _FEATURESET_UTF8VALIDATION + _FEATURESET.fields_by_name['message_encoding'].enum_type = _FEATURESET_MESSAGEENCODING + _FEATURESET.fields_by_name['json_format'].enum_type = _FEATURESET_JSONFORMAT + _FEATURESET.fields_by_name['enforce_naming_style'].enum_type = _FEATURESET_ENFORCENAMINGSTYLE + _FEATURESET.fields_by_name['default_symbol_visibility'].enum_type = _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY + _FEATURESET_FIELDPRESENCE.containing_type = _FEATURESET + _FEATURESET_ENUMTYPE.containing_type = _FEATURESET + _FEATURESET_REPEATEDFIELDENCODING.containing_type = _FEATURESET + _FEATURESET_UTF8VALIDATION.containing_type = _FEATURESET + _FEATURESET_MESSAGEENCODING.containing_type = _FEATURESET + _FEATURESET_JSONFORMAT.containing_type = _FEATURESET + _FEATURESET_ENFORCENAMINGSTYLE.containing_type = _FEATURESET + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT.fields_by_name['edition'].enum_type = _EDITION + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT.fields_by_name['overridable_features'].message_type = _FEATURESET + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT.fields_by_name['fixed_features'].message_type = _FEATURESET + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT.containing_type = _FEATURESETDEFAULTS + _FEATURESETDEFAULTS.fields_by_name['defaults'].message_type = _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT + _FEATURESETDEFAULTS.fields_by_name['minimum_edition'].enum_type = _EDITION + _FEATURESETDEFAULTS.fields_by_name['maximum_edition'].enum_type = _EDITION + _SOURCECODEINFO_LOCATION.containing_type = _SOURCECODEINFO + _SOURCECODEINFO.fields_by_name['location'].message_type = _SOURCECODEINFO_LOCATION + _GENERATEDCODEINFO_ANNOTATION.fields_by_name['semantic'].enum_type = _GENERATEDCODEINFO_ANNOTATION_SEMANTIC + _GENERATEDCODEINFO_ANNOTATION.containing_type = _GENERATEDCODEINFO + _GENERATEDCODEINFO_ANNOTATION_SEMANTIC.containing_type = _GENERATEDCODEINFO_ANNOTATION + _GENERATEDCODEINFO.fields_by_name['annotation'].message_type = _GENERATEDCODEINFO_ANNOTATION + DESCRIPTOR.message_types_by_name['FileDescriptorSet'] = _FILEDESCRIPTORSET + DESCRIPTOR.message_types_by_name['FileDescriptorProto'] = _FILEDESCRIPTORPROTO + DESCRIPTOR.message_types_by_name['DescriptorProto'] = _DESCRIPTORPROTO + DESCRIPTOR.message_types_by_name['ExtensionRangeOptions'] = _EXTENSIONRANGEOPTIONS + DESCRIPTOR.message_types_by_name['FieldDescriptorProto'] = _FIELDDESCRIPTORPROTO + DESCRIPTOR.message_types_by_name['OneofDescriptorProto'] = _ONEOFDESCRIPTORPROTO + DESCRIPTOR.message_types_by_name['EnumDescriptorProto'] = _ENUMDESCRIPTORPROTO + DESCRIPTOR.message_types_by_name['EnumValueDescriptorProto'] = _ENUMVALUEDESCRIPTORPROTO + DESCRIPTOR.message_types_by_name['ServiceDescriptorProto'] = _SERVICEDESCRIPTORPROTO + DESCRIPTOR.message_types_by_name['MethodDescriptorProto'] = _METHODDESCRIPTORPROTO + DESCRIPTOR.message_types_by_name['FileOptions'] = _FILEOPTIONS + DESCRIPTOR.message_types_by_name['MessageOptions'] = _MESSAGEOPTIONS + DESCRIPTOR.message_types_by_name['FieldOptions'] = _FIELDOPTIONS + DESCRIPTOR.message_types_by_name['OneofOptions'] = _ONEOFOPTIONS + DESCRIPTOR.message_types_by_name['EnumOptions'] = _ENUMOPTIONS + DESCRIPTOR.message_types_by_name['EnumValueOptions'] = _ENUMVALUEOPTIONS + DESCRIPTOR.message_types_by_name['ServiceOptions'] = _SERVICEOPTIONS + DESCRIPTOR.message_types_by_name['MethodOptions'] = _METHODOPTIONS + DESCRIPTOR.message_types_by_name['UninterpretedOption'] = _UNINTERPRETEDOPTION + DESCRIPTOR.message_types_by_name['FeatureSet'] = _FEATURESET + DESCRIPTOR.message_types_by_name['FeatureSetDefaults'] = _FEATURESETDEFAULTS + DESCRIPTOR.message_types_by_name['SourceCodeInfo'] = _SOURCECODEINFO + DESCRIPTOR.message_types_by_name['GeneratedCodeInfo'] = _GENERATEDCODEINFO + DESCRIPTOR.enum_types_by_name['Edition'] = _EDITION + DESCRIPTOR.enum_types_by_name['SymbolVisibility'] = _SYMBOLVISIBILITY + _sym_db.RegisterFileDescriptor(DESCRIPTOR) + + class _ResolvedFeatures: + def __init__(self, features = None, **kwargs): + if features: + for k, v in features.FIELDS.items(): + setattr(self, k, getattr(features, k)) + else: + for k, v in kwargs.items(): + setattr(self, k, v) + DESCRIPTOR._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORSET._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORSET.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[8]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[9]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[10]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[11]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[12]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEDESCRIPTORPROTO.fields[13]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[8]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[9]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO.fields[10]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO_EXTENSIONRANGE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO_EXTENSIONRANGE.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO_EXTENSIONRANGE.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO_EXTENSIONRANGE.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO_RESERVEDRANGE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO_RESERVEDRANGE.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _DESCRIPTORPROTO_RESERVEDRANGE.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_DECLARATION._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_DECLARATION.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_DECLARATION.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_DECLARATION.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_DECLARATION.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_DECLARATION.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[8]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[9]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO.fields[10]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ONEOFDESCRIPTORPROTO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ONEOFDESCRIPTORPROTO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ONEOFDESCRIPTORPROTO.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEDESCRIPTORPROTO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEDESCRIPTORPROTO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEDESCRIPTORPROTO.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEDESCRIPTORPROTO.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SERVICEDESCRIPTORPROTO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SERVICEDESCRIPTORPROTO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SERVICEDESCRIPTORPROTO.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SERVICEDESCRIPTORPROTO.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODDESCRIPTORPROTO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODDESCRIPTORPROTO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODDESCRIPTORPROTO.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODDESCRIPTORPROTO.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODDESCRIPTORPROTO.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODDESCRIPTORPROTO.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODDESCRIPTORPROTO.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[8]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[9]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[10]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[11]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[12]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[13]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[14]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[15]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[16]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[17]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[18]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[19]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS.fields[20]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _MESSAGEOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _MESSAGEOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _MESSAGEOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _MESSAGEOPTIONS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _MESSAGEOPTIONS.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _MESSAGEOPTIONS.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _MESSAGEOPTIONS.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _MESSAGEOPTIONS.fields[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[8]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[9]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[10]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[11]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[12]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS.fields[13]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_EDITIONDEFAULT._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_EDITIONDEFAULT.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_EDITIONDEFAULT.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_FEATURESUPPORT._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_FEATURESUPPORT.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_FEATURESUPPORT.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_FEATURESUPPORT.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_FEATURESUPPORT.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_FEATURESUPPORT.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ONEOFOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ONEOFOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ONEOFOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMOPTIONS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMOPTIONS.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMOPTIONS.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEOPTIONS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEOPTIONS.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _ENUMVALUEOPTIONS.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SERVICEOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SERVICEOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SERVICEOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SERVICEOPTIONS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION.fields[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION_NAMEPART._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION_NAMEPART.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["LEGACY_REQUIRED"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _UNINTERPRETEDOPTION_NAMEPART.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["LEGACY_REQUIRED"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET.fields[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET.fields[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET.fields[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_VISIBILITYFEATURE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESETDEFAULTS._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESETDEFAULTS.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESETDEFAULTS.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESETDEFAULTS.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SOURCECODEINFO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SOURCECODEINFO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SOURCECODEINFO_LOCATION._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SOURCECODEINFO_LOCATION.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["PACKED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SOURCECODEINFO_LOCATION.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["PACKED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SOURCECODEINFO_LOCATION.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SOURCECODEINFO_LOCATION.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SOURCECODEINFO_LOCATION.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION.fields[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["PACKED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION.fields[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION.fields[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION.fields[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION.fields[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[8]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[9]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[10]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[11]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[12]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[13]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[14]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[15]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[16]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_TYPE.values[17]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_LABEL._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_LABEL.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_LABEL.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDDESCRIPTORPROTO_LABEL.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS_OPTIMIZEMODE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS_OPTIMIZEMODE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS_OPTIMIZEMODE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FILEOPTIONS_OPTIMIZEMODE.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_CTYPE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_CTYPE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_CTYPE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_CTYPE.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_JSTYPE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_JSTYPE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_JSTYPE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_JSTYPE.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONRETENTION._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONRETENTION.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONRETENTION.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONRETENTION.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[8]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FIELDOPTIONS_OPTIONTARGETTYPE.values[9]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS_IDEMPOTENCYLEVEL._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS_IDEMPOTENCYLEVEL.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS_IDEMPOTENCYLEVEL.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _METHODOPTIONS_IDEMPOTENCYLEVEL.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_FIELDPRESENCE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_FIELDPRESENCE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_FIELDPRESENCE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_FIELDPRESENCE.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_FIELDPRESENCE.values[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENUMTYPE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENUMTYPE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENUMTYPE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENUMTYPE.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_REPEATEDFIELDENCODING._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_REPEATEDFIELDENCODING.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_REPEATEDFIELDENCODING.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_REPEATEDFIELDENCODING.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_UTF8VALIDATION._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_UTF8VALIDATION.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_UTF8VALIDATION.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_UTF8VALIDATION.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_MESSAGEENCODING._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_MESSAGEENCODING.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_MESSAGEENCODING.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_MESSAGEENCODING.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_JSONFORMAT._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_JSONFORMAT.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_JSONFORMAT.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_JSONFORMAT.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENFORCENAMINGSTYLE._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENFORCENAMINGSTYLE.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENFORCENAMINGSTYLE.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENFORCENAMINGSTYLE.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_ENFORCENAMINGSTYLE.values[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY.values[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY.values[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION_SEMANTIC._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION_SEMANTIC.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION_SEMANTIC.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _GENERATEDCODEINFO_ANNOTATION_SEMANTIC.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[3]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[4]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[5]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[6]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[7]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[8]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[9]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[10]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[11]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[12]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _EDITION.values[13]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SYMBOLVISIBILITY._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SYMBOLVISIBILITY.values[0]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SYMBOLVISIBILITY.values[1]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) + _SYMBOLVISIBILITY.values[2]._features = _ResolvedFeatures(field_presence=_FEATURESET_FIELDPRESENCE.values_by_name["EXPLICIT"].number,enum_type=_FEATURESET_ENUMTYPE.values_by_name["CLOSED"].number,repeated_field_encoding=_FEATURESET_REPEATEDFIELDENCODING.values_by_name["EXPANDED"].number,utf8_validation=_FEATURESET_UTF8VALIDATION.values_by_name["NONE"].number,message_encoding=_FEATURESET_MESSAGEENCODING.values_by_name["LENGTH_PREFIXED"].number,json_format=_FEATURESET_JSONFORMAT.values_by_name["LEGACY_BEST_EFFORT"].number) +else: + _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.descriptor_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\020DescriptorProtosH\001Z-google.golang.org/protobuf/types/descriptorpb\370\001\001\242\002\003GPB\252\002\032Google.Protobuf.Reflection' + _globals['_EXTENSIONRANGEOPTIONS'].fields_by_name['declaration']._loaded_options = None + _globals['_EXTENSIONRANGEOPTIONS'].fields_by_name['declaration']._serialized_options = b'\210\001\002' + _globals['_EXTENSIONRANGEOPTIONS'].fields_by_name['verification']._loaded_options = None + _globals['_EXTENSIONRANGEOPTIONS'].fields_by_name['verification']._serialized_options = b'\210\001\002' + _globals['_FILEOPTIONS'].fields_by_name['java_multiple_files']._loaded_options = None + _globals['_FILEOPTIONS'].fields_by_name['java_multiple_files']._serialized_options = b'\262\001\275\001\010\346\007 \351\007*\264\001This behavior is enabled by default in editions 2024 and above. To disable it, you can set `features.(pb.java).nest_in_file_class = YES` on individual messages, enums, or services.' + _globals['_FILEOPTIONS'].fields_by_name['java_generate_equals_and_hash']._loaded_options = None + _globals['_FILEOPTIONS'].fields_by_name['java_generate_equals_and_hash']._serialized_options = b'\030\001' + _globals['_MESSAGEOPTIONS'].fields_by_name['deprecated_legacy_json_field_conflicts']._loaded_options = None + _globals['_MESSAGEOPTIONS'].fields_by_name['deprecated_legacy_json_field_conflicts']._serialized_options = b'\030\001' + _globals['_FIELDOPTIONS'].fields_by_name['weak']._loaded_options = None + _globals['_FIELDOPTIONS'].fields_by_name['weak']._serialized_options = b'\030\001' + _globals['_ENUMOPTIONS'].fields_by_name['deprecated_legacy_json_field_conflicts']._loaded_options = None + _globals['_ENUMOPTIONS'].fields_by_name['deprecated_legacy_json_field_conflicts']._serialized_options = b'\030\001' + _globals['_FEATURESET'].fields_by_name['field_presence']._loaded_options = None + _globals['_FEATURESET'].fields_by_name['field_presence']._serialized_options = b'\210\001\001\230\001\004\230\001\001\242\001\r\022\010EXPLICIT\030\204\007\242\001\r\022\010IMPLICIT\030\347\007\242\001\r\022\010EXPLICIT\030\350\007\262\001\003\010\350\007' + _globals['_FEATURESET'].fields_by_name['enum_type']._loaded_options = None + _globals['_FEATURESET'].fields_by_name['enum_type']._serialized_options = b'\210\001\001\230\001\006\230\001\001\242\001\013\022\006CLOSED\030\204\007\242\001\t\022\004OPEN\030\347\007\262\001\003\010\350\007' + _globals['_FEATURESET'].fields_by_name['repeated_field_encoding']._loaded_options = None + _globals['_FEATURESET'].fields_by_name['repeated_field_encoding']._serialized_options = b'\210\001\001\230\001\004\230\001\001\242\001\r\022\010EXPANDED\030\204\007\242\001\013\022\006PACKED\030\347\007\262\001\003\010\350\007' + _globals['_FEATURESET'].fields_by_name['utf8_validation']._loaded_options = None + _globals['_FEATURESET'].fields_by_name['utf8_validation']._serialized_options = b'\210\001\001\230\001\004\230\001\001\242\001\t\022\004NONE\030\204\007\242\001\013\022\006VERIFY\030\347\007\262\001\003\010\350\007' + _globals['_FEATURESET'].fields_by_name['message_encoding']._loaded_options = None + _globals['_FEATURESET'].fields_by_name['message_encoding']._serialized_options = b'\210\001\001\230\001\004\230\001\001\242\001\024\022\017LENGTH_PREFIXED\030\204\007\262\001\003\010\350\007' + _globals['_FEATURESET'].fields_by_name['json_format']._loaded_options = None + _globals['_FEATURESET'].fields_by_name['json_format']._serialized_options = b'\210\001\001\230\001\003\230\001\006\230\001\001\242\001\027\022\022LEGACY_BEST_EFFORT\030\204\007\242\001\n\022\005ALLOW\030\347\007\262\001\003\010\350\007' + _globals['_FEATURESET'].fields_by_name['enforce_naming_style']._loaded_options = None + _globals['_FEATURESET'].fields_by_name['enforce_naming_style']._serialized_options = b'\210\001\002\230\001\001\230\001\002\230\001\003\230\001\004\230\001\005\230\001\006\230\001\007\230\001\010\230\001\t\242\001\021\022\014STYLE_LEGACY\030\204\007\242\001\016\022\tSTYLE2024\030\351\007\242\001\016\022\tSTYLE2026\030\217N\262\001\003\010\351\007' + _globals['_FEATURESET'].fields_by_name['default_symbol_visibility']._loaded_options = None + _globals['_FEATURESET'].fields_by_name['default_symbol_visibility']._serialized_options = b'\210\001\002\230\001\001\242\001\017\022\nEXPORT_ALL\030\204\007\242\001\025\022\020EXPORT_TOP_LEVEL\030\351\007\262\001\003\010\351\007' + _globals['_SOURCECODEINFO_LOCATION'].fields_by_name['path']._loaded_options = None + _globals['_SOURCECODEINFO_LOCATION'].fields_by_name['path']._serialized_options = b'\020\001' + _globals['_SOURCECODEINFO_LOCATION'].fields_by_name['span']._loaded_options = None + _globals['_SOURCECODEINFO_LOCATION'].fields_by_name['span']._serialized_options = b'\020\001' + _globals['_GENERATEDCODEINFO_ANNOTATION'].fields_by_name['path']._loaded_options = None + _globals['_GENERATEDCODEINFO_ANNOTATION'].fields_by_name['path']._serialized_options = b'\020\001' + _globals['_EDITION']._serialized_start=13023 + _globals['_EDITION']._serialized_end=13360 + _globals['_SYMBOLVISIBILITY']._serialized_start=13362 + _globals['_SYMBOLVISIBILITY']._serialized_end=13447 + _globals['_FILEDESCRIPTORSET']._serialized_start=53 + _globals['_FILEDESCRIPTORSET']._serialized_end=144 + _globals['_FILEDESCRIPTORPROTO']._serialized_start=147 + _globals['_FILEDESCRIPTORPROTO']._serialized_end=856 + _globals['_DESCRIPTORPROTO']._serialized_start=859 + _globals['_DESCRIPTORPROTO']._serialized_end=1751 + _globals['_DESCRIPTORPROTO_EXTENSIONRANGE']._serialized_start=1572 + _globals['_DESCRIPTORPROTO_EXTENSIONRANGE']._serialized_end=1694 + _globals['_DESCRIPTORPROTO_RESERVEDRANGE']._serialized_start=1696 + _globals['_DESCRIPTORPROTO_RESERVEDRANGE']._serialized_end=1751 + _globals['_EXTENSIONRANGEOPTIONS']._serialized_start=1754 + _globals['_EXTENSIONRANGEOPTIONS']._serialized_end=2350 + _globals['_EXTENSIONRANGEOPTIONS_DECLARATION']._serialized_start=2129 + _globals['_EXTENSIONRANGEOPTIONS_DECLARATION']._serialized_end=2277 + _globals['_EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE']._serialized_start=2279 + _globals['_EXTENSIONRANGEOPTIONS_VERIFICATIONSTATE']._serialized_end=2331 + _globals['_FIELDDESCRIPTORPROTO']._serialized_start=2353 + _globals['_FIELDDESCRIPTORPROTO']._serialized_end=3186 + _globals['_FIELDDESCRIPTORPROTO_TYPE']._serialized_start=2807 + _globals['_FIELDDESCRIPTORPROTO_TYPE']._serialized_end=3117 + _globals['_FIELDDESCRIPTORPROTO_LABEL']._serialized_start=3119 + _globals['_FIELDDESCRIPTORPROTO_LABEL']._serialized_end=3186 + _globals['_ONEOFDESCRIPTORPROTO']._serialized_start=3188 + _globals['_ONEOFDESCRIPTORPROTO']._serialized_end=3287 + _globals['_ENUMDESCRIPTORPROTO']._serialized_start=3290 + _globals['_ENUMDESCRIPTORPROTO']._serialized_end=3712 + _globals['_ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE']._serialized_start=3653 + _globals['_ENUMDESCRIPTORPROTO_ENUMRESERVEDRANGE']._serialized_end=3712 + _globals['_ENUMVALUEDESCRIPTORPROTO']._serialized_start=3715 + _globals['_ENUMVALUEDESCRIPTORPROTO']._serialized_end=3846 + _globals['_SERVICEDESCRIPTORPROTO']._serialized_start=3849 + _globals['_SERVICEDESCRIPTORPROTO']._serialized_end=4030 + _globals['_METHODDESCRIPTORPROTO']._serialized_start=4033 + _globals['_METHODDESCRIPTORPROTO']._serialized_end=4298 + _globals['_FILEOPTIONS']._serialized_start=4301 + _globals['_FILEOPTIONS']._serialized_end=5703 + _globals['_FILEOPTIONS_OPTIMIZEMODE']._serialized_start=5592 + _globals['_FILEOPTIONS_OPTIMIZEMODE']._serialized_end=5650 + _globals['_MESSAGEOPTIONS']._serialized_start=5706 + _globals['_MESSAGEOPTIONS']._serialized_end=6214 + _globals['_FIELDOPTIONS']._serialized_start=6217 + _globals['_FIELDOPTIONS']._serialized_end=7959 + _globals['_FIELDOPTIONS_EDITIONDEFAULT']._serialized_start=7058 + _globals['_FIELDOPTIONS_EDITIONDEFAULT']._serialized_end=7148 + _globals['_FIELDOPTIONS_FEATURESUPPORT']._serialized_start=7151 + _globals['_FIELDOPTIONS_FEATURESUPPORT']._serialized_end=7466 + _globals['_FIELDOPTIONS_CTYPE']._serialized_start=7468 + _globals['_FIELDOPTIONS_CTYPE']._serialized_end=7515 + _globals['_FIELDOPTIONS_JSTYPE']._serialized_start=7517 + _globals['_FIELDOPTIONS_JSTYPE']._serialized_end=7570 + _globals['_FIELDOPTIONS_OPTIONRETENTION']._serialized_start=7572 + _globals['_FIELDOPTIONS_OPTIONRETENTION']._serialized_end=7657 + _globals['_FIELDOPTIONS_OPTIONTARGETTYPE']._serialized_start=7660 + _globals['_FIELDOPTIONS_OPTIONTARGETTYPE']._serialized_end=7928 + _globals['_ONEOFOPTIONS']._serialized_start=7962 + _globals['_ONEOFOPTIONS']._serialized_end=8142 + _globals['_ENUMOPTIONS']._serialized_start=8145 + _globals['_ENUMOPTIONS']._serialized_end=8490 + _globals['_ENUMVALUEOPTIONS']._serialized_start=8493 + _globals['_ENUMVALUEOPTIONS']._serialized_end=8845 + _globals['_SERVICEOPTIONS']._serialized_start=8848 + _globals['_SERVICEOPTIONS']._serialized_end=9069 + _globals['_METHODOPTIONS']._serialized_start=9072 + _globals['_METHODOPTIONS']._serialized_end=9489 + _globals['_METHODOPTIONS_IDEMPOTENCYLEVEL']._serialized_start=9390 + _globals['_METHODOPTIONS_IDEMPOTENCYLEVEL']._serialized_end=9470 + _globals['_UNINTERPRETEDOPTION']._serialized_start=9492 + _globals['_UNINTERPRETEDOPTION']._serialized_end=9902 + _globals['_UNINTERPRETEDOPTION_NAMEPART']._serialized_start=9828 + _globals['_UNINTERPRETEDOPTION_NAMEPART']._serialized_end=9902 + _globals['_FEATURESET']._serialized_start=9905 + _globals['_FEATURESET']._serialized_end=11871 + _globals['_FEATURESET_VISIBILITYFEATURE']._serialized_start=11101 + _globals['_FEATURESET_VISIBILITYFEATURE']._serialized_end=11262 + _globals['_FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY']._serialized_start=11123 + _globals['_FEATURESET_VISIBILITYFEATURE_DEFAULTSYMBOLVISIBILITY']._serialized_end=11252 + _globals['_FEATURESET_FIELDPRESENCE']._serialized_start=11264 + _globals['_FEATURESET_FIELDPRESENCE']._serialized_end=11356 + _globals['_FEATURESET_ENUMTYPE']._serialized_start=11358 + _globals['_FEATURESET_ENUMTYPE']._serialized_end=11413 + _globals['_FEATURESET_REPEATEDFIELDENCODING']._serialized_start=11415 + _globals['_FEATURESET_REPEATEDFIELDENCODING']._serialized_end=11501 + _globals['_FEATURESET_UTF8VALIDATION']._serialized_start=11503 + _globals['_FEATURESET_UTF8VALIDATION']._serialized_end=11576 + _globals['_FEATURESET_MESSAGEENCODING']._serialized_start=11578 + _globals['_FEATURESET_MESSAGEENCODING']._serialized_end=11661 + _globals['_FEATURESET_JSONFORMAT']._serialized_start=11663 + _globals['_FEATURESET_JSONFORMAT']._serialized_end=11735 + _globals['_FEATURESET_ENFORCENAMINGSTYLE']._serialized_start=11737 + _globals['_FEATURESET_ENFORCENAMINGSTYLE']._serialized_end=11839 + _globals['_FEATURESETDEFAULTS']._serialized_start=11874 + _globals['_FEATURESETDEFAULTS']._serialized_end=12369 + _globals['_FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT']._serialized_start=12121 + _globals['_FEATURESETDEFAULTS_FEATURESETEDITIONDEFAULT']._serialized_end=12369 + _globals['_SOURCECODEINFO']._serialized_start=12372 + _globals['_SOURCECODEINFO']._serialized_end=12681 + _globals['_SOURCECODEINFO_LOCATION']._serialized_start=12461 + _globals['_SOURCECODEINFO_LOCATION']._serialized_end=12667 + _globals['_GENERATEDCODEINFO']._serialized_start=12684 + _globals['_GENERATEDCODEINFO']._serialized_end=13020 + _globals['_GENERATEDCODEINFO_ANNOTATION']._serialized_start=12785 + _globals['_GENERATEDCODEINFO_ANNOTATION']._serialized_end=13020 + _globals['_GENERATEDCODEINFO_ANNOTATION_SEMANTIC']._serialized_start=12980 + _globals['_GENERATEDCODEINFO_ANNOTATION_SEMANTIC']._serialized_end=13020 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_pool.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_pool.py new file mode 100644 index 0000000000000000000000000000000000000000..a838c508b58b2f3e06fb7cbf80e24ec2e464e215 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/descriptor_pool.py @@ -0,0 +1,1373 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Provides DescriptorPool to use as a container for proto2 descriptors. + +The DescriptorPool is used in conjection with a DescriptorDatabase to maintain +a collection of protocol buffer descriptors for use when dynamically creating +message types at runtime. + +For most applications protocol buffers should be used via modules generated by +the protocol buffer compiler tool. This should only be used when the type of +protocol buffers used in an application or library cannot be predetermined. + +Below is a straightforward example on how to use this class:: + + pool = DescriptorPool() + file_descriptor_protos = [ ... ] + for file_descriptor_proto in file_descriptor_protos: + pool.Add(file_descriptor_proto) + my_message_descriptor = pool.FindMessageTypeByName('some.package.MessageType') + +The message descriptor can be used in conjunction with the message_factory +module in order to create a protocol buffer class that can be encoded and +decoded. + +If you want to get a Python class for the specified proto, use the +helper functions inside google.protobuf.message_factory +directly instead of this class. +""" + +__author__ = 'matthewtoia@google.com (Matt Toia)' + +import collections +import threading +import warnings + +from google.protobuf import descriptor +from google.protobuf import descriptor_database +from google.protobuf import text_encoding +from google.protobuf.internal import python_edition_defaults +from google.protobuf.internal import python_message + +_USE_C_DESCRIPTORS = descriptor._USE_C_DESCRIPTORS # pylint: disable=protected-access + + +def _NormalizeFullyQualifiedName(name): + """Remove leading period from fully-qualified type name. + + Due to b/13860351 in descriptor_database.py, types in the root namespace are + generated with a leading period. This function removes that prefix. + + Args: + name (str): The fully-qualified symbol name. + + Returns: + str: The normalized fully-qualified symbol name. + """ + return name.lstrip('.') + + +def _OptionsOrNone(descriptor_proto): + """Returns the value of the field `options`, or None if it is not set.""" + if descriptor_proto.HasField('options'): + return descriptor_proto.options + else: + return None + + +def _IsMessageSetExtension(field): + return (field.is_extension and + field.containing_type.has_options and + field.containing_type.GetOptions().message_set_wire_format and + field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and + not field.is_required and + not field.is_repeated) + +_edition_defaults_lock = threading.Lock() + + +class DescriptorPool(object): + """A collection of protobufs dynamically constructed by descriptor protos.""" + + if _USE_C_DESCRIPTORS: + + def __new__(cls, descriptor_db=None): + # pylint: disable=protected-access + return descriptor._message.DescriptorPool(descriptor_db) + + def __init__( + self, descriptor_db=None, use_deprecated_legacy_json_field_conflicts=False + ): + """Initializes a Pool of proto buffs. + + The descriptor_db argument to the constructor is provided to allow + specialized file descriptor proto lookup code to be triggered on demand. An + example would be an implementation which will read and compile a file + specified in a call to FindFileByName() and not require the call to Add() + at all. Results from this database will be cached internally here as well. + + Args: + descriptor_db: A secondary source of file descriptors. + use_deprecated_legacy_json_field_conflicts: Unused, for compatibility with + C++. + """ + + self._internal_db = descriptor_database.DescriptorDatabase() + self._descriptor_db = descriptor_db + self._descriptors = {} + self._enum_descriptors = {} + self._service_descriptors = {} + self._file_descriptors = {} + self._toplevel_extensions = {} + self._top_enum_values = {} + # We store extensions in two two-level mappings: The first key is the + # descriptor of the message being extended, the second key is the extension + # full name or its tag number. + self._extensions_by_name = collections.defaultdict(dict) + self._extensions_by_number = collections.defaultdict(dict) + self._serialized_edition_defaults = ( + python_edition_defaults._PROTOBUF_INTERNAL_PYTHON_EDITION_DEFAULTS + ) + self._edition_defaults = None + self._feature_cache = dict() + + def _CheckConflictRegister(self, desc, desc_name, file_name): + """Check if the descriptor name conflicts with another of the same name. + + Args: + desc: Descriptor of a message, enum, service, extension or enum value. + desc_name (str): the full name of desc. + file_name (str): The file name of descriptor. + """ + for register, descriptor_type in [ + (self._descriptors, descriptor.Descriptor), + (self._enum_descriptors, descriptor.EnumDescriptor), + (self._service_descriptors, descriptor.ServiceDescriptor), + (self._toplevel_extensions, descriptor.FieldDescriptor), + (self._top_enum_values, descriptor.EnumValueDescriptor)]: + if desc_name in register: + old_desc = register[desc_name] + if isinstance(old_desc, descriptor.EnumValueDescriptor): + old_file = old_desc.type.file.name + else: + old_file = old_desc.file.name + + if not isinstance(desc, descriptor_type) or ( + old_file != file_name): + error_msg = ('Conflict register for file "' + file_name + + '": ' + desc_name + + ' is already defined in file "' + + old_file + '". Please fix the conflict by adding ' + 'package name on the proto file, or use different ' + 'name for the duplication.') + if isinstance(desc, descriptor.EnumValueDescriptor): + error_msg += ('\nNote: enum values appear as ' + 'siblings of the enum type instead of ' + 'children of it.') + + raise TypeError(error_msg) + + return + + def Add(self, file_desc_proto): + """Adds the FileDescriptorProto and its types to this pool. + + Args: + file_desc_proto (FileDescriptorProto): The file descriptor to add. + """ + + self._internal_db.Add(file_desc_proto) + + def AddSerializedFile(self, serialized_file_desc_proto): + """Adds the FileDescriptorProto and its types to this pool. + + Args: + serialized_file_desc_proto (bytes): A bytes string, serialization of the + :class:`FileDescriptorProto` to add. + + Returns: + FileDescriptor: Descriptor for the added file. + """ + + # pylint: disable=g-import-not-at-top + from google.protobuf import descriptor_pb2 + file_desc_proto = descriptor_pb2.FileDescriptorProto.FromString( + serialized_file_desc_proto) + file_desc = self._ConvertFileProtoToFileDescriptor(file_desc_proto) + file_desc.serialized_pb = serialized_file_desc_proto + return file_desc + + # Never call this method. It is for internal usage only. + def _AddDescriptor(self, desc): + """Adds a Descriptor to the pool, non-recursively. + + If the Descriptor contains nested messages or enums, the caller must + explicitly register them. This method also registers the FileDescriptor + associated with the message. + + Args: + desc: A Descriptor. + """ + if not isinstance(desc, descriptor.Descriptor): + raise TypeError('Expected instance of descriptor.Descriptor.') + + self._CheckConflictRegister(desc, desc.full_name, desc.file.name) + + self._descriptors[desc.full_name] = desc + self._AddFileDescriptor(desc.file) + + # Never call this method. It is for internal usage only. + def _AddEnumDescriptor(self, enum_desc): + """Adds an EnumDescriptor to the pool. + + This method also registers the FileDescriptor associated with the enum. + + Args: + enum_desc: An EnumDescriptor. + """ + + if not isinstance(enum_desc, descriptor.EnumDescriptor): + raise TypeError('Expected instance of descriptor.EnumDescriptor.') + + file_name = enum_desc.file.name + self._CheckConflictRegister(enum_desc, enum_desc.full_name, file_name) + self._enum_descriptors[enum_desc.full_name] = enum_desc + + # Top enum values need to be indexed. + # Count the number of dots to see whether the enum is toplevel or nested + # in a message. We cannot use enum_desc.containing_type at this stage. + if enum_desc.file.package: + top_level = (enum_desc.full_name.count('.') + - enum_desc.file.package.count('.') == 1) + else: + top_level = enum_desc.full_name.count('.') == 0 + if top_level: + file_name = enum_desc.file.name + package = enum_desc.file.package + for enum_value in enum_desc.values: + full_name = _NormalizeFullyQualifiedName( + '.'.join((package, enum_value.name))) + self._CheckConflictRegister(enum_value, full_name, file_name) + self._top_enum_values[full_name] = enum_value + self._AddFileDescriptor(enum_desc.file) + + # Never call this method. It is for internal usage only. + def _AddServiceDescriptor(self, service_desc): + """Adds a ServiceDescriptor to the pool. + + Args: + service_desc: A ServiceDescriptor. + """ + + if not isinstance(service_desc, descriptor.ServiceDescriptor): + raise TypeError('Expected instance of descriptor.ServiceDescriptor.') + + self._CheckConflictRegister(service_desc, service_desc.full_name, + service_desc.file.name) + self._service_descriptors[service_desc.full_name] = service_desc + + # Never call this method. It is for internal usage only. + def _AddExtensionDescriptor(self, extension): + """Adds a FieldDescriptor describing an extension to the pool. + + Args: + extension: A FieldDescriptor. + + Raises: + AssertionError: when another extension with the same number extends the + same message. + TypeError: when the specified extension is not a + descriptor.FieldDescriptor. + """ + if not (isinstance(extension, descriptor.FieldDescriptor) and + extension.is_extension): + raise TypeError('Expected an extension descriptor.') + + if extension.extension_scope is None: + self._CheckConflictRegister( + extension, extension.full_name, extension.file.name) + self._toplevel_extensions[extension.full_name] = extension + + try: + existing_desc = self._extensions_by_number[ + extension.containing_type][extension.number] + except KeyError: + pass + else: + if extension is not existing_desc: + raise AssertionError( + 'Extensions "%s" and "%s" both try to extend message type "%s" ' + 'with field number %d.' % + (extension.full_name, existing_desc.full_name, + extension.containing_type.full_name, extension.number)) + + self._extensions_by_number[extension.containing_type][ + extension.number] = extension + self._extensions_by_name[extension.containing_type][ + extension.full_name] = extension + + # Also register MessageSet extensions with the type name. + if _IsMessageSetExtension(extension): + self._extensions_by_name[extension.containing_type][ + extension.message_type.full_name] = extension + + if hasattr(extension.containing_type, '_concrete_class'): + python_message._AttachFieldHelpers( + extension.containing_type._concrete_class, extension) + + # Never call this method. It is for internal usage only. + def _InternalAddFileDescriptor(self, file_desc): + """Adds a FileDescriptor to the pool, non-recursively. + + If the FileDescriptor contains messages or enums, the caller must explicitly + register them. + + Args: + file_desc: A FileDescriptor. + """ + + self._AddFileDescriptor(file_desc) + + def _AddFileDescriptor(self, file_desc): + """Adds a FileDescriptor to the pool, non-recursively. + + If the FileDescriptor contains messages or enums, the caller must explicitly + register them. + + Args: + file_desc: A FileDescriptor. + """ + + if not isinstance(file_desc, descriptor.FileDescriptor): + raise TypeError('Expected instance of descriptor.FileDescriptor.') + self._file_descriptors[file_desc.name] = file_desc + + def FindFileByName(self, file_name): + """Gets a FileDescriptor by file name. + + Args: + file_name (str): The path to the file to get a descriptor for. + + Returns: + FileDescriptor: The descriptor for the named file. + + Raises: + KeyError: if the file cannot be found in the pool. + """ + + try: + return self._file_descriptors[file_name] + except KeyError: + pass + + try: + file_proto = self._internal_db.FindFileByName(file_name) + except KeyError as error: + if self._descriptor_db: + file_proto = self._descriptor_db.FindFileByName(file_name) + else: + raise error + if not file_proto: + raise KeyError('Cannot find a file named %s' % file_name) + return self._ConvertFileProtoToFileDescriptor(file_proto) + + def FindFileContainingSymbol(self, symbol): + """Gets the FileDescriptor for the file containing the specified symbol. + + Args: + symbol (str): The name of the symbol to search for. + + Returns: + FileDescriptor: Descriptor for the file that contains the specified + symbol. + + Raises: + KeyError: if the file cannot be found in the pool. + """ + + symbol = _NormalizeFullyQualifiedName(symbol) + try: + return self._InternalFindFileContainingSymbol(symbol) + except KeyError: + pass + + try: + # Try fallback database. Build and find again if possible. + self._FindFileContainingSymbolInDb(symbol) + return self._InternalFindFileContainingSymbol(symbol) + except KeyError: + raise KeyError('Cannot find a file containing %s' % symbol) + + def _InternalFindFileContainingSymbol(self, symbol): + """Gets the already built FileDescriptor containing the specified symbol. + + Args: + symbol (str): The name of the symbol to search for. + + Returns: + FileDescriptor: Descriptor for the file that contains the specified + symbol. + + Raises: + KeyError: if the file cannot be found in the pool. + """ + try: + return self._descriptors[symbol].file + except KeyError: + pass + + try: + return self._enum_descriptors[symbol].file + except KeyError: + pass + + try: + return self._service_descriptors[symbol].file + except KeyError: + pass + + try: + return self._top_enum_values[symbol].type.file + except KeyError: + pass + + try: + return self._toplevel_extensions[symbol].file + except KeyError: + pass + + # Try fields, enum values and nested extensions inside a message. + top_name, _, sub_name = symbol.rpartition('.') + try: + message = self.FindMessageTypeByName(top_name) + assert (sub_name in message.extensions_by_name or + sub_name in message.fields_by_name or + sub_name in message.enum_values_by_name) + return message.file + except (KeyError, AssertionError): + raise KeyError('Cannot find a file containing %s' % symbol) + + def FindMessageTypeByName(self, full_name): + """Loads the named descriptor from the pool. + + Args: + full_name (str): The full name of the descriptor to load. + + Returns: + Descriptor: The descriptor for the named type. + + Raises: + KeyError: if the message cannot be found in the pool. + """ + + full_name = _NormalizeFullyQualifiedName(full_name) + if full_name not in self._descriptors: + self._FindFileContainingSymbolInDb(full_name) + return self._descriptors[full_name] + + def FindEnumTypeByName(self, full_name): + """Loads the named enum descriptor from the pool. + + Args: + full_name (str): The full name of the enum descriptor to load. + + Returns: + EnumDescriptor: The enum descriptor for the named type. + + Raises: + KeyError: if the enum cannot be found in the pool. + """ + + full_name = _NormalizeFullyQualifiedName(full_name) + if full_name not in self._enum_descriptors: + self._FindFileContainingSymbolInDb(full_name) + return self._enum_descriptors[full_name] + + def FindFieldByName(self, full_name): + """Loads the named field descriptor from the pool. + + Args: + full_name (str): The full name of the field descriptor to load. + + Returns: + FieldDescriptor: The field descriptor for the named field. + + Raises: + KeyError: if the field cannot be found in the pool. + """ + full_name = _NormalizeFullyQualifiedName(full_name) + message_name, _, field_name = full_name.rpartition('.') + message_descriptor = self.FindMessageTypeByName(message_name) + return message_descriptor.fields_by_name[field_name] + + def FindOneofByName(self, full_name): + """Loads the named oneof descriptor from the pool. + + Args: + full_name (str): The full name of the oneof descriptor to load. + + Returns: + OneofDescriptor: The oneof descriptor for the named oneof. + + Raises: + KeyError: if the oneof cannot be found in the pool. + """ + full_name = _NormalizeFullyQualifiedName(full_name) + message_name, _, oneof_name = full_name.rpartition('.') + message_descriptor = self.FindMessageTypeByName(message_name) + return message_descriptor.oneofs_by_name[oneof_name] + + def FindExtensionByName(self, full_name): + """Loads the named extension descriptor from the pool. + + Args: + full_name (str): The full name of the extension descriptor to load. + + Returns: + FieldDescriptor: The field descriptor for the named extension. + + Raises: + KeyError: if the extension cannot be found in the pool. + """ + full_name = _NormalizeFullyQualifiedName(full_name) + try: + # The proto compiler does not give any link between the FileDescriptor + # and top-level extensions unless the FileDescriptorProto is added to + # the DescriptorDatabase, but this can impact memory usage. + # So we registered these extensions by name explicitly. + return self._toplevel_extensions[full_name] + except KeyError: + pass + message_name, _, extension_name = full_name.rpartition('.') + try: + # Most extensions are nested inside a message. + scope = self.FindMessageTypeByName(message_name) + except KeyError: + # Some extensions are defined at file scope. + scope = self._FindFileContainingSymbolInDb(full_name) + return scope.extensions_by_name[extension_name] + + def FindExtensionByNumber(self, message_descriptor, number): + """Gets the extension of the specified message with the specified number. + + Extensions have to be registered to this pool by calling :func:`Add` or + :func:`AddExtensionDescriptor`. + + Args: + message_descriptor (Descriptor): descriptor of the extended message. + number (int): Number of the extension field. + + Returns: + FieldDescriptor: The descriptor for the extension. + + Raises: + KeyError: when no extension with the given number is known for the + specified message. + """ + try: + return self._extensions_by_number[message_descriptor][number] + except KeyError: + self._TryLoadExtensionFromDB(message_descriptor, number) + return self._extensions_by_number[message_descriptor][number] + + def FindAllExtensions(self, message_descriptor): + """Gets all the known extensions of a given message. + + Extensions have to be registered to this pool by build related + :func:`Add` or :func:`AddExtensionDescriptor`. + + Args: + message_descriptor (Descriptor): Descriptor of the extended message. + + Returns: + list[FieldDescriptor]: Field descriptors describing the extensions. + """ + # Fallback to descriptor db if FindAllExtensionNumbers is provided. + if self._descriptor_db and hasattr( + self._descriptor_db, 'FindAllExtensionNumbers'): + full_name = message_descriptor.full_name + try: + all_numbers = self._descriptor_db.FindAllExtensionNumbers(full_name) + except: + pass + else: + if isinstance(all_numbers, list): + for number in all_numbers: + if number in self._extensions_by_number[message_descriptor]: + continue + self._TryLoadExtensionFromDB(message_descriptor, number) + else: + warnings.warn( + 'FindAllExtensionNumbers() on fall back DB must return a list,' + ' not {0}'.format(type(all_numbers)) + ) + + return list(self._extensions_by_number[message_descriptor].values()) + + def _TryLoadExtensionFromDB(self, message_descriptor, number): + """Try to Load extensions from descriptor db. + + Args: + message_descriptor: descriptor of the extended message. + number: the extension number that needs to be loaded. + """ + if not self._descriptor_db: + return + # Only supported when FindFileContainingExtension is provided. + if not hasattr( + self._descriptor_db, 'FindFileContainingExtension'): + return + + full_name = message_descriptor.full_name + file_proto = None + try: + file_proto = self._descriptor_db.FindFileContainingExtension( + full_name, number + ) + except: + return + + if file_proto is None: + return + + try: + self._ConvertFileProtoToFileDescriptor(file_proto) + except: + warn_msg = ('Unable to load proto file %s for extension number %d.' % + (file_proto.name, number)) + warnings.warn(warn_msg, RuntimeWarning) + + def FindServiceByName(self, full_name): + """Loads the named service descriptor from the pool. + + Args: + full_name (str): The full name of the service descriptor to load. + + Returns: + ServiceDescriptor: The service descriptor for the named service. + + Raises: + KeyError: if the service cannot be found in the pool. + """ + full_name = _NormalizeFullyQualifiedName(full_name) + if full_name not in self._service_descriptors: + self._FindFileContainingSymbolInDb(full_name) + return self._service_descriptors[full_name] + + def FindMethodByName(self, full_name): + """Loads the named service method descriptor from the pool. + + Args: + full_name (str): The full name of the method descriptor to load. + + Returns: + MethodDescriptor: The method descriptor for the service method. + + Raises: + KeyError: if the method cannot be found in the pool. + """ + full_name = _NormalizeFullyQualifiedName(full_name) + service_name, _, method_name = full_name.rpartition('.') + service_descriptor = self.FindServiceByName(service_name) + return service_descriptor.methods_by_name[method_name] + + def SetFeatureSetDefaults(self, defaults): + """Sets the default feature mappings used during the build. + + Args: + defaults: a FeatureSetDefaults message containing the new mappings. + """ + if self._edition_defaults is not None: + raise ValueError( + "Feature set defaults can't be changed once the pool has started" + ' building!' + ) + + # pylint: disable=g-import-not-at-top + from google.protobuf import descriptor_pb2 + + if not isinstance(defaults, descriptor_pb2.FeatureSetDefaults): + raise TypeError('SetFeatureSetDefaults called with invalid type') + + if defaults.minimum_edition > defaults.maximum_edition: + raise ValueError( + 'Invalid edition range %s to %s' + % ( + descriptor_pb2.Edition.Name(defaults.minimum_edition), + descriptor_pb2.Edition.Name(defaults.maximum_edition), + ) + ) + + prev_edition = descriptor_pb2.Edition.EDITION_UNKNOWN + for d in defaults.defaults: + if d.edition == descriptor_pb2.Edition.EDITION_UNKNOWN: + raise ValueError('Invalid edition EDITION_UNKNOWN specified') + if prev_edition >= d.edition: + raise ValueError( + 'Feature set defaults are not strictly increasing. %s is greater' + ' than or equal to %s' + % ( + descriptor_pb2.Edition.Name(prev_edition), + descriptor_pb2.Edition.Name(d.edition), + ) + ) + prev_edition = d.edition + self._edition_defaults = defaults + + def _CreateDefaultFeatures(self, edition): + """Creates a FeatureSet message with defaults for a specific edition. + + Args: + edition: the edition to generate defaults for. + + Returns: + A FeatureSet message with defaults for a specific edition. + """ + # pylint: disable=g-import-not-at-top + from google.protobuf import descriptor_pb2 + + with _edition_defaults_lock: + if not self._edition_defaults: + self._edition_defaults = descriptor_pb2.FeatureSetDefaults() + self._edition_defaults.ParseFromString( + self._serialized_edition_defaults + ) + + if edition < self._edition_defaults.minimum_edition: + raise TypeError( + 'Edition %s is earlier than the minimum supported edition %s!' + % ( + descriptor_pb2.Edition.Name(edition), + descriptor_pb2.Edition.Name( + self._edition_defaults.minimum_edition + ), + ) + ) + if ( + edition > self._edition_defaults.maximum_edition + and edition != descriptor_pb2.EDITION_UNSTABLE + ): + raise TypeError( + 'Edition %s is later than the maximum supported edition %s!' + % ( + descriptor_pb2.Edition.Name(edition), + descriptor_pb2.Edition.Name( + self._edition_defaults.maximum_edition + ), + ) + ) + found = None + for d in self._edition_defaults.defaults: + if d.edition > edition: + break + found = d + if found is None: + raise TypeError( + 'No valid default found for edition %s!' + % descriptor_pb2.Edition.Name(edition) + ) + + defaults = descriptor_pb2.FeatureSet() + defaults.CopyFrom(found.fixed_features) + defaults.MergeFrom(found.overridable_features) + return defaults + + def _InternFeatures(self, features): + serialized = features.SerializeToString() + with _edition_defaults_lock: + cached = self._feature_cache.get(serialized) + if cached is None: + self._feature_cache[serialized] = features + cached = features + return cached + + def _FindFileContainingSymbolInDb(self, symbol): + """Finds the file in descriptor DB containing the specified symbol. + + Args: + symbol (str): The name of the symbol to search for. + + Returns: + FileDescriptor: The file that contains the specified symbol. + + Raises: + KeyError: if the file cannot be found in the descriptor database. + """ + try: + file_proto = self._internal_db.FindFileContainingSymbol(symbol) + except KeyError as error: + if self._descriptor_db: + file_proto = self._descriptor_db.FindFileContainingSymbol(symbol) + else: + raise error + if not file_proto: + raise KeyError('Cannot find a file containing %s' % symbol) + return self._ConvertFileProtoToFileDescriptor(file_proto) + + def _ConvertFileProtoToFileDescriptor(self, file_proto): + """Creates a FileDescriptor from a proto or returns a cached copy. + + This method also has the side effect of loading all the symbols found in + the file into the appropriate dictionaries in the pool. + + Args: + file_proto: The proto to convert. + + Returns: + A FileDescriptor matching the passed in proto. + """ + if file_proto.name not in self._file_descriptors: + built_deps = list(self._GetDeps(file_proto.dependency)) + direct_deps = [self.FindFileByName(n) for n in file_proto.dependency] + public_deps = [direct_deps[i] for i in file_proto.public_dependency] + + # pylint: disable=g-import-not-at-top + from google.protobuf import descriptor_pb2 + + file_descriptor = descriptor.FileDescriptor( + pool=self, + name=file_proto.name, + package=file_proto.package, + syntax=file_proto.syntax, + edition=descriptor_pb2.Edition.Name(file_proto.edition), + options=_OptionsOrNone(file_proto), + serialized_pb=file_proto.SerializeToString(), + dependencies=direct_deps, + public_dependencies=public_deps, + # pylint: disable=protected-access + create_key=descriptor._internal_create_key, + ) + scope = {} + + # This loop extracts all the message and enum types from all the + # dependencies of the file_proto. This is necessary to create the + # scope of available message types when defining the passed in + # file proto. + for dependency in built_deps: + scope.update(self._ExtractSymbols( + dependency.message_types_by_name.values())) + scope.update((_PrefixWithDot(enum.full_name), enum) + for enum in dependency.enum_types_by_name.values()) + + for message_type in file_proto.message_type: + message_desc = self._ConvertMessageDescriptor( + message_type, file_proto.package, file_descriptor, scope, + file_proto.syntax) + file_descriptor.message_types_by_name[message_desc.name] = ( + message_desc) + + for enum_type in file_proto.enum_type: + file_descriptor.enum_types_by_name[enum_type.name] = ( + self._ConvertEnumDescriptor(enum_type, file_proto.package, + file_descriptor, None, scope, True)) + + for index, extension_proto in enumerate(file_proto.extension): + extension_desc = self._MakeFieldDescriptor( + extension_proto, file_proto.package, index, file_descriptor, + is_extension=True) + extension_desc.containing_type = self._GetTypeFromScope( + file_descriptor.package, extension_proto.extendee, scope) + self._SetFieldType(extension_proto, extension_desc, + file_descriptor.package, scope) + file_descriptor.extensions_by_name[extension_desc.name] = ( + extension_desc) + + for desc_proto in file_proto.message_type: + self._SetAllFieldTypes(file_proto.package, desc_proto, scope) + + if file_proto.package: + desc_proto_prefix = _PrefixWithDot(file_proto.package) + else: + desc_proto_prefix = '' + + for desc_proto in file_proto.message_type: + desc = self._GetTypeFromScope( + desc_proto_prefix, desc_proto.name, scope) + file_descriptor.message_types_by_name[desc_proto.name] = desc + + for index, service_proto in enumerate(file_proto.service): + file_descriptor.services_by_name[service_proto.name] = ( + self._MakeServiceDescriptor(service_proto, index, scope, + file_proto.package, file_descriptor)) + + self._file_descriptors[file_proto.name] = file_descriptor + + # Add extensions to the pool + def AddExtensionForNested(message_type): + for nested in message_type.nested_types: + AddExtensionForNested(nested) + for extension in message_type.extensions: + self._AddExtensionDescriptor(extension) + + file_desc = self._file_descriptors[file_proto.name] + for extension in file_desc.extensions_by_name.values(): + self._AddExtensionDescriptor(extension) + for message_type in file_desc.message_types_by_name.values(): + AddExtensionForNested(message_type) + + return file_desc + + def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None, + scope=None, syntax=None): + """Adds the proto to the pool in the specified package. + + Args: + desc_proto: The descriptor_pb2.DescriptorProto protobuf message. + package: The package the proto should be located in. + file_desc: The file containing this message. + scope: Dict mapping short and full symbols to message and enum types. + syntax: string indicating syntax of the file ("proto2" or "proto3") + + Returns: + The added descriptor. + """ + + if package: + desc_name = '.'.join((package, desc_proto.name)) + else: + desc_name = desc_proto.name + + if file_desc is None: + file_name = None + else: + file_name = file_desc.name + + if scope is None: + scope = {} + + nested = [ + self._ConvertMessageDescriptor( + nested, desc_name, file_desc, scope, syntax) + for nested in desc_proto.nested_type] + enums = [ + self._ConvertEnumDescriptor(enum, desc_name, file_desc, None, + scope, False) + for enum in desc_proto.enum_type] + fields = [self._MakeFieldDescriptor(field, desc_name, index, file_desc) + for index, field in enumerate(desc_proto.field)] + extensions = [ + self._MakeFieldDescriptor(extension, desc_name, index, file_desc, + is_extension=True) + for index, extension in enumerate(desc_proto.extension)] + oneofs = [ + # pylint: disable=g-complex-comprehension + descriptor.OneofDescriptor( + desc.name, + '.'.join((desc_name, desc.name)), + index, + None, + [], + _OptionsOrNone(desc), + # pylint: disable=protected-access + create_key=descriptor._internal_create_key) + for index, desc in enumerate(desc_proto.oneof_decl) + ] + extension_ranges = [(r.start, r.end) for r in desc_proto.extension_range] + if extension_ranges: + is_extendable = True + else: + is_extendable = False + desc = descriptor.Descriptor( + name=desc_proto.name, + full_name=desc_name, + filename=file_name, + containing_type=None, + fields=fields, + oneofs=oneofs, + nested_types=nested, + enum_types=enums, + extensions=extensions, + options=_OptionsOrNone(desc_proto), + is_extendable=is_extendable, + extension_ranges=extension_ranges, + file=file_desc, + serialized_start=None, + serialized_end=None, + is_map_entry=desc_proto.options.map_entry, + # pylint: disable=protected-access + create_key=descriptor._internal_create_key, + ) + for nested in desc.nested_types: + nested.containing_type = desc + for enum in desc.enum_types: + enum.containing_type = desc + for field_index, field_desc in enumerate(desc_proto.field): + if field_desc.HasField('oneof_index'): + oneof_index = field_desc.oneof_index + oneofs[oneof_index].fields.append(fields[field_index]) + fields[field_index].containing_oneof = oneofs[oneof_index] + + scope[_PrefixWithDot(desc_name)] = desc + self._CheckConflictRegister(desc, desc.full_name, desc.file.name) + self._descriptors[desc_name] = desc + return desc + + def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None, + containing_type=None, scope=None, top_level=False): + """Make a protobuf EnumDescriptor given an EnumDescriptorProto protobuf. + + Args: + enum_proto: The descriptor_pb2.EnumDescriptorProto protobuf message. + package: Optional package name for the new message EnumDescriptor. + file_desc: The file containing the enum descriptor. + containing_type: The type containing this enum. + scope: Scope containing available types. + top_level: If True, the enum is a top level symbol. If False, the enum + is defined inside a message. + + Returns: + The added descriptor + """ + + if package: + enum_name = '.'.join((package, enum_proto.name)) + else: + enum_name = enum_proto.name + + if file_desc is None: + file_name = None + else: + file_name = file_desc.name + + values = [self._MakeEnumValueDescriptor(value, index) + for index, value in enumerate(enum_proto.value)] + desc = descriptor.EnumDescriptor(name=enum_proto.name, + full_name=enum_name, + filename=file_name, + file=file_desc, + values=values, + containing_type=containing_type, + options=_OptionsOrNone(enum_proto), + # pylint: disable=protected-access + create_key=descriptor._internal_create_key) + scope['.%s' % enum_name] = desc + self._CheckConflictRegister(desc, desc.full_name, desc.file.name) + self._enum_descriptors[enum_name] = desc + + # Add top level enum values. + if top_level: + for value in values: + full_name = _NormalizeFullyQualifiedName( + '.'.join((package, value.name))) + self._CheckConflictRegister(value, full_name, file_name) + self._top_enum_values[full_name] = value + + return desc + + def _MakeFieldDescriptor(self, field_proto, message_name, index, + file_desc, is_extension=False): + """Creates a field descriptor from a FieldDescriptorProto. + + For message and enum type fields, this method will do a look up + in the pool for the appropriate descriptor for that type. If it + is unavailable, it will fall back to the _source function to + create it. If this type is still unavailable, construction will + fail. + + Args: + field_proto: The proto describing the field. + message_name: The name of the containing message. + index: Index of the field + file_desc: The file containing the field descriptor. + is_extension: Indication that this field is for an extension. + + Returns: + An initialized FieldDescriptor object + """ + + if message_name: + full_name = '.'.join((message_name, field_proto.name)) + else: + full_name = field_proto.name + + if field_proto.json_name: + json_name = field_proto.json_name + else: + json_name = None + + return descriptor.FieldDescriptor( + name=field_proto.name, + full_name=full_name, + index=index, + number=field_proto.number, + type=field_proto.type, + cpp_type=None, + message_type=None, + enum_type=None, + containing_type=None, + label=field_proto.label, + has_default_value=False, + default_value=None, + is_extension=is_extension, + extension_scope=None, + options=_OptionsOrNone(field_proto), + json_name=json_name, + file=file_desc, + # pylint: disable=protected-access + create_key=descriptor._internal_create_key) + + def _SetAllFieldTypes(self, package, desc_proto, scope): + """Sets all the descriptor's fields's types. + + This method also sets the containing types on any extensions. + + Args: + package: The current package of desc_proto. + desc_proto: The message descriptor to update. + scope: Enclosing scope of available types. + """ + + package = _PrefixWithDot(package) + + main_desc = self._GetTypeFromScope(package, desc_proto.name, scope) + + if package == '.': + nested_package = _PrefixWithDot(desc_proto.name) + else: + nested_package = '.'.join([package, desc_proto.name]) + + for field_proto, field_desc in zip(desc_proto.field, main_desc.fields): + self._SetFieldType(field_proto, field_desc, nested_package, scope) + + for extension_proto, extension_desc in ( + zip(desc_proto.extension, main_desc.extensions)): + extension_desc.containing_type = self._GetTypeFromScope( + nested_package, extension_proto.extendee, scope) + self._SetFieldType(extension_proto, extension_desc, nested_package, scope) + + for nested_type in desc_proto.nested_type: + self._SetAllFieldTypes(nested_package, nested_type, scope) + + def _SetFieldType(self, field_proto, field_desc, package, scope): + """Sets the field's type, cpp_type, message_type and enum_type. + + Args: + field_proto: Data about the field in proto format. + field_desc: The descriptor to modify. + package: The package the field's container is in. + scope: Enclosing scope of available types. + """ + if field_proto.type_name: + desc = self._GetTypeFromScope(package, field_proto.type_name, scope) + else: + desc = None + + if not field_proto.HasField('type'): + if isinstance(desc, descriptor.Descriptor): + field_proto.type = descriptor.FieldDescriptor.TYPE_MESSAGE + else: + field_proto.type = descriptor.FieldDescriptor.TYPE_ENUM + + field_desc.cpp_type = descriptor.FieldDescriptor.ProtoTypeToCppProtoType( + field_proto.type) + + if (field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE + or field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP): + field_desc.message_type = desc + + if field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM: + field_desc.enum_type = desc + + if field_proto.label == descriptor.FieldDescriptor.LABEL_REPEATED: + field_desc.has_default_value = False + field_desc.default_value = [] + elif field_proto.HasField('default_value'): + field_desc.has_default_value = True + if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or + field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT): + field_desc.default_value = float(field_proto.default_value) + elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING: + field_desc.default_value = field_proto.default_value + elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL: + field_desc.default_value = field_proto.default_value.lower() == 'true' + elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM: + field_desc.default_value = field_desc.enum_type.values_by_name[ + field_proto.default_value].number + elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES: + field_desc.default_value = text_encoding.CUnescape( + field_proto.default_value) + elif field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE: + field_desc.default_value = None + else: + # All other types are of the "int" type. + field_desc.default_value = int(field_proto.default_value) + else: + field_desc.has_default_value = False + if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or + field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT): + field_desc.default_value = 0.0 + elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING: + field_desc.default_value = u'' + elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL: + field_desc.default_value = False + elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM: + field_desc.default_value = field_desc.enum_type.values[0].number + elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES: + field_desc.default_value = b'' + elif field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE: + field_desc.default_value = None + elif field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP: + field_desc.default_value = None + else: + # All other types are of the "int" type. + field_desc.default_value = 0 + + field_desc.type = field_proto.type + + def _MakeEnumValueDescriptor(self, value_proto, index): + """Creates a enum value descriptor object from a enum value proto. + + Args: + value_proto: The proto describing the enum value. + index: The index of the enum value. + + Returns: + An initialized EnumValueDescriptor object. + """ + + return descriptor.EnumValueDescriptor( + name=value_proto.name, + index=index, + number=value_proto.number, + options=_OptionsOrNone(value_proto), + type=None, + # pylint: disable=protected-access + create_key=descriptor._internal_create_key) + + def _MakeServiceDescriptor(self, service_proto, service_index, scope, + package, file_desc): + """Make a protobuf ServiceDescriptor given a ServiceDescriptorProto. + + Args: + service_proto: The descriptor_pb2.ServiceDescriptorProto protobuf message. + service_index: The index of the service in the File. + scope: Dict mapping short and full symbols to message and enum types. + package: Optional package name for the new message EnumDescriptor. + file_desc: The file containing the service descriptor. + + Returns: + The added descriptor. + """ + + if package: + service_name = '.'.join((package, service_proto.name)) + else: + service_name = service_proto.name + + methods = [self._MakeMethodDescriptor(method_proto, service_name, package, + scope, index) + for index, method_proto in enumerate(service_proto.method)] + desc = descriptor.ServiceDescriptor( + name=service_proto.name, + full_name=service_name, + index=service_index, + methods=methods, + options=_OptionsOrNone(service_proto), + file=file_desc, + # pylint: disable=protected-access + create_key=descriptor._internal_create_key) + self._CheckConflictRegister(desc, desc.full_name, desc.file.name) + self._service_descriptors[service_name] = desc + return desc + + def _MakeMethodDescriptor(self, method_proto, service_name, package, scope, + index): + """Creates a method descriptor from a MethodDescriptorProto. + + Args: + method_proto: The proto describing the method. + service_name: The name of the containing service. + package: Optional package name to look up for types. + scope: Scope containing available types. + index: Index of the method in the service. + + Returns: + An initialized MethodDescriptor object. + """ + full_name = '.'.join((service_name, method_proto.name)) + input_type = self._GetTypeFromScope( + package, method_proto.input_type, scope) + output_type = self._GetTypeFromScope( + package, method_proto.output_type, scope) + return descriptor.MethodDescriptor( + name=method_proto.name, + full_name=full_name, + index=index, + containing_service=None, + input_type=input_type, + output_type=output_type, + client_streaming=method_proto.client_streaming, + server_streaming=method_proto.server_streaming, + options=_OptionsOrNone(method_proto), + # pylint: disable=protected-access + create_key=descriptor._internal_create_key) + + def _ExtractSymbols(self, descriptors): + """Pulls out all the symbols from descriptor protos. + + Args: + descriptors: The messages to extract descriptors from. + Yields: + A two element tuple of the type name and descriptor object. + """ + + for desc in descriptors: + yield (_PrefixWithDot(desc.full_name), desc) + for symbol in self._ExtractSymbols(desc.nested_types): + yield symbol + for enum in desc.enum_types: + yield (_PrefixWithDot(enum.full_name), enum) + + def _GetDeps(self, dependencies, visited=None): + """Recursively finds dependencies for file protos. + + Args: + dependencies: The names of the files being depended on. + visited: The names of files already found. + + Yields: + Each direct and indirect dependency. + """ + + visited = visited or set() + for dependency in dependencies: + if dependency not in visited: + visited.add(dependency) + dep_desc = self.FindFileByName(dependency) + yield dep_desc + public_files = [d.name for d in dep_desc.public_dependencies] + yield from self._GetDeps(public_files, visited) + + def _GetTypeFromScope(self, package, type_name, scope): + """Finds a given type name in the current scope. + + Args: + package: The package the proto should be located in. + type_name: The name of the type to be found in the scope. + scope: Dict mapping short and full symbols to message and enum types. + + Returns: + The descriptor for the requested type. + """ + if type_name not in scope: + components = _PrefixWithDot(package).split('.') + while components: + possible_match = '.'.join(components + [type_name]) + if possible_match in scope: + type_name = possible_match + break + else: + components.pop(-1) + return scope[type_name] + + +def _PrefixWithDot(name): + return name if name.startswith('.') else '.%s' % name + + +if _USE_C_DESCRIPTORS: + # TODO: This pool could be constructed from Python code, when we + # support a flag like 'use_cpp_generated_pool=True'. + # pylint: disable=protected-access + _DEFAULT = descriptor._message.default_pool +else: + _DEFAULT = DescriptorPool() + + +def Default(): + return _DEFAULT diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/duration.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/duration.py new file mode 100644 index 0000000000000000000000000000000000000000..21f17bf71a2f34f412849a24989a6b406df817d0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/duration.py @@ -0,0 +1,100 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains the Duration helper APIs.""" + +import datetime + +from google.protobuf.duration_pb2 import Duration + + +def from_json_string(value: str) -> Duration: + """Converts a string to Duration. + + Args: + value: A string to be converted. The string must end with 's'. Any + fractional digits (or none) are accepted as long as they fit into + precision. For example: "1s", "1.01s", "1.0000001s", "-3.100s" + + Raises: + ValueError: On parsing problems. + """ + duration = Duration() + duration.FromJsonString(value) + return duration + + +def from_microseconds(micros: float) -> Duration: + """Converts microseconds to Duration.""" + duration = Duration() + duration.FromMicroseconds(micros) + return duration + + +def from_milliseconds(millis: float) -> Duration: + """Converts milliseconds to Duration.""" + duration = Duration() + duration.FromMilliseconds(millis) + return duration + + +def from_nanoseconds(nanos: float) -> Duration: + """Converts nanoseconds to Duration.""" + duration = Duration() + duration.FromNanoseconds(nanos) + return duration + + +def from_seconds(seconds: float) -> Duration: + """Converts seconds to Duration.""" + duration = Duration() + duration.FromSeconds(seconds) + return duration + + +def from_timedelta(td: datetime.timedelta) -> Duration: + """Converts timedelta to Duration.""" + duration = Duration() + duration.FromTimedelta(td) + return duration + + +def to_json_string(duration: Duration) -> str: + """Converts Duration to string format. + + Returns: + A string converted from self. The string format will contains + 3, 6, or 9 fractional digits depending on the precision required to + represent the exact Duration value. For example: "1s", "1.010s", + "1.000000100s", "-3.100s" + """ + return duration.ToJsonString() + + +def to_microseconds(duration: Duration) -> int: + """Converts a Duration to microseconds.""" + return duration.ToMicroseconds() + + +def to_milliseconds(duration: Duration) -> int: + """Converts a Duration to milliseconds.""" + return duration.ToMilliseconds() + + +def to_nanoseconds(duration: Duration) -> int: + """Converts a Duration to nanoseconds.""" + return duration.ToNanoseconds() + + +def to_seconds(duration: Duration) -> int: + """Converts a Duration to seconds.""" + return duration.ToSeconds() + + +def to_timedelta(duration: Duration) -> datetime.timedelta: + """Converts Duration to timedelta.""" + return duration.ToTimedelta() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/duration_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/duration_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..7580f7f88bd4a4ada02a8f91fe24f0a47b45732a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/duration_pb2.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/duration.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/duration.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1egoogle/protobuf/duration.proto\x12\x0fgoogle.protobuf\":\n\x08\x44uration\x12\x18\n\x07seconds\x18\x01 \x01(\x03R\x07seconds\x12\x14\n\x05nanos\x18\x02 \x01(\x05R\x05nanosB\x83\x01\n\x13\x63om.google.protobufB\rDurationProtoP\x01Z1google.golang.org/protobuf/types/known/durationpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.duration_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\rDurationProtoP\001Z1google.golang.org/protobuf/types/known/durationpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_DURATION']._serialized_start=51 + _globals['_DURATION']._serialized_end=109 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/empty_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/empty_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..07c5cb6f9af1372433abc657a82e95675629f32c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/empty_pb2.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/empty.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/empty.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1bgoogle/protobuf/empty.proto\x12\x0fgoogle.protobuf\"\x07\n\x05\x45mptyB}\n\x13\x63om.google.protobufB\nEmptyProtoP\x01Z.google.golang.org/protobuf/types/known/emptypb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.empty_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\nEmptyProtoP\001Z.google.golang.org/protobuf/types/known/emptypb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_EMPTY']._serialized_start=48 + _globals['_EMPTY']._serialized_end=55 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/field_mask_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/field_mask_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..d21407387826258103a6da70cffca6324a64d353 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/field_mask_pb2.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/field_mask.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/field_mask.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n google/protobuf/field_mask.proto\x12\x0fgoogle.protobuf\"!\n\tFieldMask\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05pathsB\x85\x01\n\x13\x63om.google.protobufB\x0e\x46ieldMaskProtoP\x01Z2google.golang.org/protobuf/types/known/fieldmaskpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.field_mask_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\016FieldMaskProtoP\001Z2google.golang.org/protobuf/types/known/fieldmaskpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_FIELDMASK']._serialized_start=53 + _globals['_FIELDMASK']._serialized_end=86 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e676e288161e00ae5c266d080ca5018336849a7d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/__init__.py @@ -0,0 +1,7 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/api_implementation.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/api_implementation.py new file mode 100644 index 0000000000000000000000000000000000000000..f4346bce945fc943d39394012e1817c49a57ed47 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/api_implementation.py @@ -0,0 +1,136 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Determine which implementation of the protobuf API is used in this process. +""" + +import importlib +import os +import sys +import warnings + +_GOOGLE3_PYTHON_UPB_DEFAULT = True + + +def _ApiVersionToImplementationType(api_version): + if api_version == 2: + return 'cpp' + if api_version == 1: + raise ValueError('api_version=1 is no longer supported.') + if api_version == 0: + return 'python' + return None + + +_implementation_type = None +try: + # pylint: disable=g-import-not-at-top + from google.protobuf.internal import _api_implementation + # The compile-time constants in the _api_implementation module can be used to + # switch to a certain implementation of the Python API at build time. + _implementation_type = _ApiVersionToImplementationType( + _api_implementation.api_version) +except ImportError: + pass # Unspecified by compiler flags. + + +def _CanImport(mod_name): + try: + mod = importlib.import_module(mod_name) + # Work around a known issue in the classic bootstrap .par import hook. + if not mod: + raise ImportError(mod_name + ' import succeeded but was None') + return True + except ImportError: + return False + + +if _implementation_type is None: + if _CanImport('google._upb._message'): + _implementation_type = 'upb' + elif _CanImport('google.protobuf.pyext._message'): + _implementation_type = 'cpp' + else: + _implementation_type = 'python' + + +# This environment variable can be used to switch to a certain implementation +# of the Python API, overriding the compile-time constants in the +# _api_implementation module. Right now only 'python', 'cpp' and 'upb' are +# valid values. Any other value will raise error. +_implementation_type = os.getenv('PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION', + _implementation_type) + +if _implementation_type not in ('python', 'cpp', 'upb'): + raise ValueError('PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION {0} is not ' + 'supported. Please set to \'python\', \'cpp\' or ' + '\'upb\'.'.format(_implementation_type)) + +if 'PyPy' in sys.version and _implementation_type == 'cpp': + warnings.warn('PyPy does not work yet with cpp protocol buffers. ' + 'Falling back to the python implementation.') + _implementation_type = 'python' + +_c_module = None + +if _implementation_type == 'cpp': + try: + # pylint: disable=g-import-not-at-top + from google.protobuf.pyext import _message + sys.modules['google3.net.proto2.python.internal.cpp._message'] = _message + _c_module = _message + del _message + except ImportError: + # TODO: fail back to python + warnings.warn( + 'Selected implementation cpp is not available.') + pass + +if _implementation_type == 'upb': + try: + # pylint: disable=g-import-not-at-top + from google._upb import _message + _c_module = _message + del _message + except ImportError: + warnings.warn('Selected implementation upb is not available. ' + 'Falling back to the python implementation.') + _implementation_type = 'python' + pass + +# Detect if serialization should be deterministic by default +try: + # The presence of this module in a build allows the proto implementation to + # be upgraded merely via build deps. + # + # NOTE: Merely importing this automatically enables deterministic proto + # serialization for C++ code, but we still need to export it as a boolean so + # that we can do the same for `_implementation_type == 'python'`. + # + # NOTE2: It is possible for C++ code to enable deterministic serialization by + # default _without_ affecting Python code, if the C++ implementation is not in + # use by this module. That is intended behavior, so we don't actually expose + # this boolean outside of this module. + # + # pylint: disable=g-import-not-at-top,unused-import + from google.protobuf import enable_deterministic_proto_serialization + _python_deterministic_proto_serialization = True +except ImportError: + _python_deterministic_proto_serialization = False + + +# Usage of this function is discouraged. Clients shouldn't care which +# implementation of the API is in use. Note that there is no guarantee +# that differences between APIs will be maintained. +# Please don't use this function if possible. +def Type(): + return _implementation_type + + +# For internal use only +def IsPythonDefaultSerializationDeterministic(): + return _python_deterministic_proto_serialization diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/builder.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..131138311c1ea3f7a8a88b5b9cf28ccefddf9ef2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/builder.py @@ -0,0 +1,122 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Builds descriptors, message classes and services for generated _pb2.py. + +This file is only called in python generated _pb2.py files. It builds +descriptors, message classes and services that users can directly use +in generated code. +""" + +__author__ = 'jieluo@google.com (Jie Luo)' + +from google.protobuf.internal import enum_type_wrapper +from google.protobuf.internal import python_message +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database + +_sym_db = _symbol_database.Default() + + +def _BuildNestedDescriptors(module, msg_des, prefix): + for name, nested_msg in msg_des.nested_types_by_name.items(): + module_name = prefix + name.upper() + module[module_name] = nested_msg + _BuildNestedDescriptors(module, nested_msg, module_name + '_') + for enum_des in msg_des.enum_types: + module[prefix + enum_des.name.upper()] = enum_des + + +def BuildMessageAndEnumDescriptors(file_des, module): + """Builds message and enum descriptors. + + Args: + file_des: FileDescriptor of the .proto file + module: Generated _pb2 module + """ + for (name, msg_des) in file_des.message_types_by_name.items(): + module_name = '_' + name.upper() + module[module_name] = msg_des + _BuildNestedDescriptors(module, msg_des, module_name + '_') + + +def _BuildMessage(module_name, msg_des, prefix): + create_dict = {} + for name, nested_msg in msg_des.nested_types_by_name.items(): + create_dict[name] = _BuildMessage( + module_name, nested_msg, prefix + msg_des.name + '.' + ) + create_dict['DESCRIPTOR'] = msg_des + create_dict['__module__'] = module_name + create_dict['__qualname__'] = prefix + msg_des.name + message_class = _reflection.GeneratedProtocolMessageType( + msg_des.name, (_message.Message,), create_dict + ) + _sym_db.RegisterMessage(message_class) + return message_class + + +def BuildTopDescriptorsAndMessages(file_des, module_name, module): + """Builds top level descriptors and message classes. + + Args: + file_des: FileDescriptor of the .proto file + module_name: str, the name of generated _pb2 module + module: Generated _pb2 module + """ + + # top level enums + for (name, enum_des) in file_des.enum_types_by_name.items(): + module['_' + name.upper()] = enum_des + module[name] = enum_type_wrapper.EnumTypeWrapper(enum_des) + for enum_value in enum_des.values: + module[enum_value.name] = enum_value.number + + # top level extensions + for (name, extension_des) in file_des.extensions_by_name.items(): + module[name.upper() + '_FIELD_NUMBER'] = extension_des.number + module[name] = extension_des + + # services + for (name, service) in file_des.services_by_name.items(): + module['_' + name.upper()] = service + + # Build messages. + for (name, msg_des) in file_des.message_types_by_name.items(): + module[name] = _BuildMessage(module_name, msg_des, '') + + +def AddHelpersToExtensions(file_des): + """no-op to keep old generated code work with new runtime. + + Args: + file_des: FileDescriptor of the .proto file + """ + # TODO: Remove this on-op + return + + +def BuildServices(file_des, module_name, module): + """Builds services classes and services stub class. + + Args: + file_des: FileDescriptor of the .proto file + module_name: str, the name of generated _pb2 module + module: Generated _pb2 module + """ + # pylint: disable=g-import-not-at-top + from google.protobuf import service_reflection + # pylint: enable=g-import-not-at-top + for (name, service) in file_des.services_by_name.items(): + module[name] = service_reflection.GeneratedServiceType( + name, (), + dict(DESCRIPTOR=service, __module__=module_name)) + stub_name = name + '_Stub' + module[stub_name] = service_reflection.GeneratedServiceStubType( + stub_name, (module[name],), + dict(DESCRIPTOR=service, __module__=module_name)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/containers.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/containers.py new file mode 100644 index 0000000000000000000000000000000000000000..e1c233cbf0764d3abb35fcb8c9ac9a548f897170 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/containers.py @@ -0,0 +1,726 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains container classes to represent different protocol buffer types. + +This file defines container classes which represent categories of protocol +buffer field types which need extra maintenance. Currently these categories +are: + +- Repeated scalar fields - These are all repeated fields which aren't + composite (e.g. they are of simple types like int32, string, etc). +- Repeated composite fields - Repeated fields which are composite. This + includes groups and nested messages. +""" + +import collections.abc +import copy +import pickle +from typing import ( + Any, + Iterable, + Iterator, + List, + MutableMapping, + MutableSequence, + NoReturn, + Optional, + Sequence, + TypeVar, + Union, + overload, +) + + +_T = TypeVar('_T') +_K = TypeVar('_K') +_V = TypeVar('_V') + +from google.protobuf.descriptor import FieldDescriptor + +class BaseContainer(Sequence[_T]): + """Base container class.""" + + # Minimizes memory usage and disallows assignment to other attributes. + __slots__ = ['_message_listener', '_values'] + + def __init__(self, message_listener: Any) -> None: + """ + Args: + message_listener: A MessageListener implementation. + The RepeatedScalarFieldContainer will call this object's + Modified() method when it is modified. + """ + self._message_listener = message_listener + self._values = [] + + @overload + def __getitem__(self, key: int) -> _T: + ... + + @overload + def __getitem__(self, key: slice) -> List[_T]: + ... + + def __getitem__(self, key): + """Retrieves item by the specified key.""" + return self._values[key] + + def __len__(self) -> int: + """Returns the number of elements in the container.""" + return len(self._values) + + def __ne__(self, other: Any) -> bool: + """Checks if another instance isn't equal to this one.""" + # The concrete classes should define __eq__. + return not self == other + + __hash__ = None + + def __repr__(self) -> str: + return repr(self._values) + + def sort(self, *args, **kwargs) -> None: + # Continue to support the old sort_function keyword argument. + # This is expected to be a rare occurrence, so use LBYL to avoid + # the overhead of actually catching KeyError. + if 'sort_function' in kwargs: + kwargs['cmp'] = kwargs.pop('sort_function') + self._values.sort(*args, **kwargs) + + def reverse(self) -> None: + self._values.reverse() + + +# TODO: Remove this. BaseContainer does *not* conform to +# MutableSequence, only its subclasses do. +collections.abc.MutableSequence.register(BaseContainer) + + +class RepeatedScalarFieldContainer(BaseContainer[_T], MutableSequence[_T]): + """Simple, type-checked, list-like container for holding repeated scalars.""" + + # Disallows assignment to other attributes. + __slots__ = ['_type_checker', '_field'] + + def __init__( + self, + message_listener: Any, + type_checker: Any, + field: Any = None, + ) -> None: + """Args: + + message_listener: A MessageListener implementation. The + RepeatedScalarFieldContainer will call this object's Modified() method + when it is modified. + type_checker: A type_checkers.ValueChecker instance to run on elements + inserted into this container. + """ + super().__init__(message_listener) + self._type_checker = type_checker + self._field = field + + def append(self, value: _T) -> None: + """Appends an item to the list. Similar to list.append().""" + self._values.append(self._type_checker.CheckValue(value)) + if not self._message_listener.dirty: + self._message_listener.Modified() + + def insert(self, key: int, value: _T) -> None: + """Inserts the item at the specified position. Similar to list.insert().""" + self._values.insert(key, self._type_checker.CheckValue(value)) + if not self._message_listener.dirty: + self._message_listener.Modified() + + def extend(self, elem_seq: Iterable[_T]) -> None: + """Extends by appending the given iterable. Similar to list.extend().""" + elem_seq_iter = iter(elem_seq) + new_values = [self._type_checker.CheckValue(elem) for elem in elem_seq_iter] + if new_values: + self._values.extend(new_values) + self._message_listener.Modified() + + def MergeFrom( + self, + other: Union['RepeatedScalarFieldContainer[_T]', Iterable[_T]], + ) -> None: + """Appends the contents of another repeated field of the same type to this + one. We do not check the types of the individual fields. + """ + self._values.extend(other) + self._message_listener.Modified() + + def remove(self, elem: _T): + """Removes an item from the list. Similar to list.remove().""" + self._values.remove(elem) + self._message_listener.Modified() + + def pop(self, key: Optional[int] = -1) -> _T: + """Removes and returns an item at a given index. Similar to list.pop().""" + value = self._values[key] + self.__delitem__(key) + return value + + @overload + def __setitem__(self, key: int, value: _T) -> None: + ... + + @overload + def __setitem__(self, key: slice, value: Iterable[_T]) -> None: + ... + + def __setitem__(self, key, value) -> None: + """Sets the item on the specified position.""" + if isinstance(key, slice): + if key.step is not None: + raise ValueError('Extended slices not supported') + self._values[key] = map(self._type_checker.CheckValue, value) + self._message_listener.Modified() + else: + self._values[key] = self._type_checker.CheckValue(value) + self._message_listener.Modified() + + def __delitem__(self, key: Union[int, slice]) -> None: + """Deletes the item at the specified position.""" + del self._values[key] + self._message_listener.Modified() + + def __eq__(self, other: Any) -> bool: + """Compares the current instance with another one.""" + if self is other: + return True + # Special case for the same type which should be common and fast. + if isinstance(other, self.__class__): + return other._values == self._values + # We are presumably comparing against some other sequence type. + return other == self._values + + def __deepcopy__( + self, + unused_memo: Any = None, + ) -> 'RepeatedScalarFieldContainer[_T]': + clone = RepeatedScalarFieldContainer( + copy.deepcopy(self._message_listener), self._type_checker, self._field + ) + clone.MergeFrom(self) + return clone + + def __reduce__(self, **kwargs) -> NoReturn: + raise pickle.PickleError( + "Can't pickle repeated scalar fields, convert to list first") + + def __array__(self, dtype=None, copy=None): + import numpy as np + + if dtype is None: + cpp_type = self._field.cpp_type + if cpp_type == FieldDescriptor.CPPTYPE_INT32: + dtype = np.int32 + elif cpp_type == FieldDescriptor.CPPTYPE_INT64: + dtype = np.int64 + elif cpp_type == FieldDescriptor.CPPTYPE_UINT32: + dtype = np.uint32 + elif cpp_type == FieldDescriptor.CPPTYPE_UINT64: + dtype = np.uint64 + elif cpp_type == FieldDescriptor.CPPTYPE_DOUBLE: + dtype = np.float64 + elif cpp_type == FieldDescriptor.CPPTYPE_FLOAT: + dtype = np.float32 + elif cpp_type == FieldDescriptor.CPPTYPE_BOOL: + dtype = np.bool + elif cpp_type == FieldDescriptor.CPPTYPE_ENUM: + dtype = np.int32 + elif self._field.type == FieldDescriptor.TYPE_BYTES: + dtype = 'S' + elif self._field.type == FieldDescriptor.TYPE_STRING: + dtype = str + else: + raise SystemError( + 'Code should never reach here: message type detected in' + ' RepeatedScalarFieldContainer' + ) + return np.array(self._values, dtype=dtype, copy=True) + + +# TODO: Constrain T to be a subtype of Message. +class RepeatedCompositeFieldContainer(BaseContainer[_T], MutableSequence[_T]): + """Simple, list-like container for holding repeated composite fields.""" + + # Disallows assignment to other attributes. + __slots__ = ['_message_descriptor'] + + def __init__(self, message_listener: Any, message_descriptor: Any) -> None: + """ + Note that we pass in a descriptor instead of the generated directly, + since at the time we construct a _RepeatedCompositeFieldContainer we + haven't yet necessarily initialized the type that will be contained in the + container. + + Args: + message_listener: A MessageListener implementation. + The RepeatedCompositeFieldContainer will call this object's + Modified() method when it is modified. + message_descriptor: A Descriptor instance describing the protocol type + that should be present in this container. We'll use the + _concrete_class field of this descriptor when the client calls add(). + """ + super().__init__(message_listener) + self._message_descriptor = message_descriptor + + def add(self, **kwargs: Any) -> _T: + """Adds a new element at the end of the list and returns it. Keyword + arguments may be used to initialize the element. + """ + new_element = self._message_descriptor._concrete_class(**kwargs) + new_element._SetListener(self._message_listener) + self._values.append(new_element) + if not self._message_listener.dirty: + self._message_listener.Modified() + return new_element + + def append(self, value: _T) -> None: + """Appends one element by copying the message.""" + new_element = self._message_descriptor._concrete_class() + new_element._SetListener(self._message_listener) + new_element.CopyFrom(value) + self._values.append(new_element) + if not self._message_listener.dirty: + self._message_listener.Modified() + + def insert(self, key: int, value: _T) -> None: + """Inserts the item at the specified position by copying.""" + new_element = self._message_descriptor._concrete_class() + new_element._SetListener(self._message_listener) + new_element.CopyFrom(value) + self._values.insert(key, new_element) + if not self._message_listener.dirty: + self._message_listener.Modified() + + def extend(self, elem_seq: Iterable[_T]) -> None: + """Extends by appending the given sequence of elements of the same type + + as this one, copying each individual message. + """ + message_class = self._message_descriptor._concrete_class + listener = self._message_listener + values = self._values + for message in elem_seq: + new_element = message_class() + new_element._SetListener(listener) + new_element.MergeFrom(message) + values.append(new_element) + listener.Modified() + + def MergeFrom( + self, + other: Union['RepeatedCompositeFieldContainer[_T]', Iterable[_T]], + ) -> None: + """Appends the contents of another repeated field of the same type to this + one, copying each individual message. + """ + self.extend(other) + + def remove(self, elem: _T) -> None: + """Removes an item from the list. Similar to list.remove().""" + self._values.remove(elem) + self._message_listener.Modified() + + def pop(self, key: Optional[int] = -1) -> _T: + """Removes and returns an item at a given index. Similar to list.pop().""" + value = self._values[key] + self.__delitem__(key) + return value + + @overload + def __setitem__(self, key: int, value: _T) -> None: + ... + + @overload + def __setitem__(self, key: slice, value: Iterable[_T]) -> None: + ... + + def __setitem__(self, key, value): + # This method is implemented to make RepeatedCompositeFieldContainer + # structurally compatible with typing.MutableSequence. It is + # otherwise unsupported and will always raise an error. + raise TypeError( + f'{self.__class__.__name__} object does not support item assignment') + + def __delitem__(self, key: Union[int, slice]) -> None: + """Deletes the item at the specified position.""" + del self._values[key] + self._message_listener.Modified() + + def __eq__(self, other: Any) -> bool: + """Compares the current instance with another one.""" + if self is other: + return True + if not isinstance(other, self.__class__): + raise TypeError('Can only compare repeated composite fields against ' + 'other repeated composite fields.') + return self._values == other._values + + +class ScalarMap(MutableMapping[_K, _V]): + """Simple, type-checked, dict-like container for holding repeated scalars.""" + + # Disallows assignment to other attributes. + __slots__ = ['_key_checker', '_value_checker', '_values', '_message_listener', + '_entry_descriptor'] + + def __init__( + self, + message_listener: Any, + key_checker: Any, + value_checker: Any, + entry_descriptor: Any, + ) -> None: + """ + Args: + message_listener: A MessageListener implementation. + The ScalarMap will call this object's Modified() method when it + is modified. + key_checker: A type_checkers.ValueChecker instance to run on keys + inserted into this container. + value_checker: A type_checkers.ValueChecker instance to run on values + inserted into this container. + entry_descriptor: The MessageDescriptor of a map entry: key and value. + """ + self._message_listener = message_listener + self._key_checker = key_checker + self._value_checker = value_checker + self._entry_descriptor = entry_descriptor + self._values = {} + + def __getitem__(self, key: _K) -> _V: + try: + return self._values[key] + except KeyError: + key = self._key_checker.CheckValue(key) + val = self._value_checker.DefaultValue() + self._values[key] = val + return val + + def __contains__(self, item: _K) -> bool: + # We check the key's type to match the strong-typing flavor of the API. + # Also this makes it easier to match the behavior of the C++ implementation. + self._key_checker.CheckValue(item) + return item in self._values + + @overload + def get(self, key: _K) -> Optional[_V]: + ... + + @overload + def get(self, key: _K, default: _T) -> Union[_V, _T]: + ... + + # We need to override this explicitly, because our defaultdict-like behavior + # will make the default implementation (from our base class) always insert + # the key. + def get(self, key, default=None): + if key in self: + return self[key] + else: + return default + + def __setitem__(self, key: _K, value: _V) -> _T: + checked_key = self._key_checker.CheckValue(key) + checked_value = self._value_checker.CheckValue(value) + self._values[checked_key] = checked_value + self._message_listener.Modified() + + def __delitem__(self, key: _K) -> None: + del self._values[key] + self._message_listener.Modified() + + def __len__(self) -> int: + return len(self._values) + + def __iter__(self) -> Iterator[_K]: + return iter(self._values) + + def __repr__(self) -> str: + return repr(self._values) + + def setdefault(self, key: _K, value: Optional[_V] = None) -> _V: + if value == None: + raise ValueError('The value for scalar map setdefault must be set.') + if key not in self._values: + self.__setitem__(key, value) + return self[key] + + def MergeFrom(self, other: 'ScalarMap[_K, _V]') -> None: + self._values.update(other._values) + self._message_listener.Modified() + + def InvalidateIterators(self) -> None: + # It appears that the only way to reliably invalidate iterators to + # self._values is to ensure that its size changes. + original = self._values + self._values = original.copy() + original[None] = None + + # This is defined in the abstract base, but we can do it much more cheaply. + def clear(self) -> None: + self._values.clear() + self._message_listener.Modified() + + def GetEntryClass(self) -> Any: + return self._entry_descriptor._concrete_class + + +class MessageMap(MutableMapping[_K, _V]): + """Simple, type-checked, dict-like container for with submessage values.""" + + # Disallows assignment to other attributes. + __slots__ = ['_key_checker', '_values', '_message_listener', + '_message_descriptor', '_entry_descriptor'] + + def __init__( + self, + message_listener: Any, + message_descriptor: Any, + key_checker: Any, + entry_descriptor: Any, + ) -> None: + """ + Args: + message_listener: A MessageListener implementation. + The ScalarMap will call this object's Modified() method when it + is modified. + key_checker: A type_checkers.ValueChecker instance to run on keys + inserted into this container. + value_checker: A type_checkers.ValueChecker instance to run on values + inserted into this container. + entry_descriptor: The MessageDescriptor of a map entry: key and value. + """ + self._message_listener = message_listener + self._message_descriptor = message_descriptor + self._key_checker = key_checker + self._entry_descriptor = entry_descriptor + self._values = {} + + def __getitem__(self, key: _K) -> _V: + key = self._key_checker.CheckValue(key) + try: + return self._values[key] + except KeyError: + new_element = self._message_descriptor._concrete_class() + new_element._SetListener(self._message_listener) + self._values[key] = new_element + self._message_listener.Modified() + return new_element + + def get_or_create(self, key: _K) -> _V: + """get_or_create() is an alias for getitem (ie. map[key]). + + Args: + key: The key to get or create in the map. + + This is useful in cases where you want to be explicit that the call is + mutating the map. This can avoid lint errors for statements like this + that otherwise would appear to be pointless statements: + + msg.my_map[key] + """ + return self[key] + + @overload + def get(self, key: _K) -> Optional[_V]: + ... + + @overload + def get(self, key: _K, default: _T) -> Union[_V, _T]: + ... + + # We need to override this explicitly, because our defaultdict-like behavior + # will make the default implementation (from our base class) always insert + # the key. + def get(self, key, default=None): + if key in self: + return self[key] + else: + return default + + def __contains__(self, item: _K) -> bool: + item = self._key_checker.CheckValue(item) + return item in self._values + + def __setitem__(self, key: _K, value: _V) -> NoReturn: + raise ValueError('May not set values directly, call my_map[key].foo = 5') + + def __delitem__(self, key: _K) -> None: + key = self._key_checker.CheckValue(key) + del self._values[key] + self._message_listener.Modified() + + def __len__(self) -> int: + return len(self._values) + + def __iter__(self) -> Iterator[_K]: + return iter(self._values) + + def __repr__(self) -> str: + return repr(self._values) + + def setdefault(self, key: _K, value: Optional[_V] = None) -> _V: + raise NotImplementedError( + 'Set message map value directly is not supported, call' + ' my_map[key].foo = 5' + ) + + def MergeFrom(self, other: 'MessageMap[_K, _V]') -> None: + # pylint: disable=protected-access + for key in other._values: + # According to documentation: "When parsing from the wire or when merging, + # if there are duplicate map keys the last key seen is used". + if key in self: + del self[key] + self[key].CopyFrom(other[key]) + # self._message_listener.Modified() not required here, because + # mutations to submessages already propagate. + + def InvalidateIterators(self) -> None: + # It appears that the only way to reliably invalidate iterators to + # self._values is to ensure that its size changes. + original = self._values + self._values = original.copy() + original[None] = None + + # This is defined in the abstract base, but we can do it much more cheaply. + def clear(self) -> None: + self._values.clear() + self._message_listener.Modified() + + def GetEntryClass(self) -> Any: + return self._entry_descriptor._concrete_class + + +class _UnknownField: + """A parsed unknown field.""" + + # Disallows assignment to other attributes. + __slots__ = ['_field_number', '_wire_type', '_data'] + + def __init__(self, field_number, wire_type, data): + self._field_number = field_number + self._wire_type = wire_type + self._data = data + return + + def __lt__(self, other): + # pylint: disable=protected-access + return self._field_number < other._field_number + + def __eq__(self, other): + if self is other: + return True + # pylint: disable=protected-access + return (self._field_number == other._field_number and + self._wire_type == other._wire_type and + self._data == other._data) + + +class UnknownFieldRef: # pylint: disable=missing-class-docstring + + def __init__(self, parent, index): + self._parent = parent + self._index = index + + def _check_valid(self): + if not self._parent: + raise ValueError('UnknownField does not exist. ' + 'The parent message might be cleared.') + if self._index >= len(self._parent): + raise ValueError('UnknownField does not exist. ' + 'The parent message might be cleared.') + + @property + def field_number(self): + self._check_valid() + # pylint: disable=protected-access + return self._parent._internal_get(self._index)._field_number + + @property + def wire_type(self): + self._check_valid() + # pylint: disable=protected-access + return self._parent._internal_get(self._index)._wire_type + + @property + def data(self): + self._check_valid() + # pylint: disable=protected-access + return self._parent._internal_get(self._index)._data + + +class UnknownFieldSet: + """UnknownField container""" + + # Disallows assignment to other attributes. + __slots__ = ['_values'] + + def __init__(self): + self._values = [] + + def __getitem__(self, index): + if self._values is None: + raise ValueError('UnknownFields does not exist. ' + 'The parent message might be cleared.') + size = len(self._values) + if index < 0: + index += size + if index < 0 or index >= size: + raise IndexError('index %d out of range'.index) + + return UnknownFieldRef(self, index) + + def _internal_get(self, index): + return self._values[index] + + def __len__(self): + if self._values is None: + raise ValueError('UnknownFields does not exist. ' + 'The parent message might be cleared.') + return len(self._values) + + def _add(self, field_number, wire_type, data): + unknown_field = _UnknownField(field_number, wire_type, data) + self._values.append(unknown_field) + return unknown_field + + def __iter__(self): + for i in range(len(self)): + yield UnknownFieldRef(self, i) + + def _extend(self, other): + if other is None: + return + # pylint: disable=protected-access + self._values.extend(other._values) + + def __eq__(self, other): + if self is other: + return True + # Sort unknown fields because their order shouldn't + # affect equality test. + values = list(self._values) + if other is None: + return not values + values.sort() + # pylint: disable=protected-access + other_values = sorted(other._values) + return values == other_values + + def _clear(self): + for value in self._values: + # pylint: disable=protected-access + if isinstance(value._data, UnknownFieldSet): + value._data._clear() # pylint: disable=protected-access + self._values = None diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/decoder.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..efd04096d0d52ca7ed44460ffbb65972a73482c0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/decoder.py @@ -0,0 +1,1078 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Code for decoding protocol buffer primitives. + +This code is very similar to encoder.py -- read the docs for that module first. + +A "decoder" is a function with the signature: + Decode(buffer, pos, end, message, field_dict) +The arguments are: + buffer: The string containing the encoded message. + pos: The current position in the string. + end: The position in the string where the current message ends. May be + less than len(buffer) if we're reading a sub-message. + message: The message object into which we're parsing. + field_dict: message._fields (avoids a hashtable lookup). +The decoder reads the field and stores it into field_dict, returning the new +buffer position. A decoder for a repeated field may proactively decode all of +the elements of that field, if they appear consecutively. + +Note that decoders may throw any of the following: + IndexError: Indicates a truncated message. + struct.error: Unpacking of a fixed-width field failed. + message.DecodeError: Other errors. + +Decoders are expected to raise an exception if they are called with pos > end. +This allows callers to be lax about bounds checking: it's fineto read past +"end" as long as you are sure that someone else will notice and throw an +exception later on. + +Something up the call stack is expected to catch IndexError and struct.error +and convert them to message.DecodeError. + +Decoders are constructed using decoder constructors with the signature: + MakeDecoder(field_number, is_repeated, is_packed, key, new_default) +The arguments are: + field_number: The field number of the field we want to decode. + is_repeated: Is the field a repeated field? (bool) + is_packed: Is the field a packed field? (bool) + key: The key to use when looking up the field within field_dict. + (This is actually the FieldDescriptor but nothing in this + file should depend on that.) + new_default: A function which takes a message object as a parameter and + returns a new instance of the default value for this field. + (This is called for repeated fields and sub-messages, when an + instance does not already exist.) + +As with encoders, we define a decoder constructor for every type of field. +Then, for every field of every message class we construct an actual decoder. +That decoder goes into a dict indexed by tag, so when we decode a message +we repeatedly read a tag, look up the corresponding decoder, and invoke it. +""" + +__author__ = 'kenton@google.com (Kenton Varda)' + +import math +import numbers +import struct + +from google.protobuf import message +from google.protobuf.internal import containers +from google.protobuf.internal import encoder +from google.protobuf.internal import wire_format + + +# This is not for optimization, but rather to avoid conflicts with local +# variables named "message". +_DecodeError = message.DecodeError + + +def IsDefaultScalarValue(value): + """Returns whether or not a scalar value is the default value of its type. + + Specifically, this should be used to determine presence of implicit-presence + fields, where we disallow custom defaults. + + Args: + value: A scalar value to check. + + Returns: + True if the value is equivalent to a default value, False otherwise. + """ + if isinstance(value, numbers.Number) and math.copysign(1.0, value) < 0: + # Special case for negative zero, where "truthiness" fails to give the right + # answer. + return False + + # Normally, we can just use Python's boolean conversion. + return not value + + +def _VarintDecoder(mask, result_type): + """Return an encoder for a basic varint value (does not include tag). + + Decoded values will be bitwise-anded with the given mask before being + returned, e.g. to limit them to 32 bits. The returned decoder does not + take the usual "end" parameter -- the caller is expected to do bounds checking + after the fact (often the caller can defer such checking until later). The + decoder returns a (value, new_pos) pair. + """ + + def DecodeVarint(buffer, pos: int=None): + result = 0 + shift = 0 + while 1: + if pos is None: + # Read from BytesIO + try: + b = buffer.read(1)[0] + except IndexError as e: + if shift == 0: + # End of BytesIO. + return None + else: + raise ValueError('Fail to read varint %s' % str(e)) + else: + b = buffer[pos] + pos += 1 + result |= ((b & 0x7f) << shift) + if not (b & 0x80): + result &= mask + result = result_type(result) + return result if pos is None else (result, pos) + shift += 7 + if shift >= 64: + raise _DecodeError('Too many bytes when decoding varint.') + + return DecodeVarint + + +def _SignedVarintDecoder(bits, result_type): + """Like _VarintDecoder() but decodes signed values.""" + + signbit = 1 << (bits - 1) + mask = (1 << bits) - 1 + + def DecodeVarint(buffer, pos): + result = 0 + shift = 0 + while 1: + b = buffer[pos] + result |= ((b & 0x7f) << shift) + pos += 1 + if not (b & 0x80): + result &= mask + result = (result ^ signbit) - signbit + result = result_type(result) + return (result, pos) + shift += 7 + if shift >= 64: + raise _DecodeError('Too many bytes when decoding varint.') + return DecodeVarint + +# All 32-bit and 64-bit values are represented as int. +_DecodeVarint = _VarintDecoder((1 << 64) - 1, int) +_DecodeSignedVarint = _SignedVarintDecoder(64, int) + +# Use these versions for values which must be limited to 32 bits. +_DecodeVarint32 = _VarintDecoder((1 << 32) - 1, int) +_DecodeSignedVarint32 = _SignedVarintDecoder(32, int) + + +def ReadTag(buffer, pos): + """Read a tag from the memoryview, and return a (tag_bytes, new_pos) tuple. + + We return the raw bytes of the tag rather than decoding them. The raw + bytes can then be used to look up the proper decoder. This effectively allows + us to trade some work that would be done in pure-python (decoding a varint) + for work that is done in C (searching for a byte string in a hash table). + In a low-level language it would be much cheaper to decode the varint and + use that, but not in Python. + + Args: + buffer: memoryview object of the encoded bytes + pos: int of the current position to start from + + Returns: + Tuple[bytes, int] of the tag data and new position. + """ + start = pos + while buffer[pos] & 0x80: + pos += 1 + pos += 1 + + tag_bytes = buffer[start:pos].tobytes() + return tag_bytes, pos + + +def DecodeTag(tag_bytes): + """Decode a tag from the bytes. + + Args: + tag_bytes: the bytes of the tag + + Returns: + Tuple[int, int] of the tag field number and wire type. + """ + (tag, _) = _DecodeVarint(tag_bytes, 0) + return wire_format.UnpackTag(tag) + + +# -------------------------------------------------------------------- + + +def _SimpleDecoder(wire_type, decode_value): + """Return a constructor for a decoder for fields of a particular type. + + Args: + wire_type: The field's wire type. + decode_value: A function which decodes an individual value, e.g. + _DecodeVarint() + """ + + def SpecificDecoder(field_number, is_repeated, is_packed, key, new_default, + clear_if_default=False): + if is_packed: + local_DecodeVarint = _DecodeVarint + def DecodePackedField( + buffer, pos, end, message, field_dict, current_depth=0 + ): + del current_depth # unused + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + (endpoint, pos) = local_DecodeVarint(buffer, pos) + endpoint += pos + if endpoint > end: + raise _DecodeError('Truncated message.') + while pos < endpoint: + (element, pos) = decode_value(buffer, pos) + value.append(element) + if pos > endpoint: + del value[-1] # Discard corrupt value. + raise _DecodeError('Packed element was truncated.') + return pos + + return DecodePackedField + elif is_repeated: + tag_bytes = encoder.TagBytes(field_number, wire_type) + tag_len = len(tag_bytes) + def DecodeRepeatedField( + buffer, pos, end, message, field_dict, current_depth=0 + ): + del current_depth # unused + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + while 1: + (element, new_pos) = decode_value(buffer, pos) + value.append(element) + # Predict that the next tag is another copy of the same repeated + # field. + pos = new_pos + tag_len + if buffer[new_pos:pos] != tag_bytes or new_pos >= end: + # Prediction failed. Return. + if new_pos > end: + raise _DecodeError('Truncated message.') + return new_pos + + return DecodeRepeatedField + else: + + def DecodeField(buffer, pos, end, message, field_dict, current_depth=0): + del current_depth # unused + (new_value, pos) = decode_value(buffer, pos) + if pos > end: + raise _DecodeError('Truncated message.') + if clear_if_default and IsDefaultScalarValue(new_value): + field_dict.pop(key, None) + else: + field_dict[key] = new_value + return pos + + return DecodeField + + return SpecificDecoder + + +def _ModifiedDecoder(wire_type, decode_value, modify_value): + """Like SimpleDecoder but additionally invokes modify_value on every value + before storing it. Usually modify_value is ZigZagDecode. + """ + + # Reusing _SimpleDecoder is slightly slower than copying a bunch of code, but + # not enough to make a significant difference. + + def InnerDecode(buffer, pos): + (result, new_pos) = decode_value(buffer, pos) + return (modify_value(result), new_pos) + return _SimpleDecoder(wire_type, InnerDecode) + + +def _StructPackDecoder(wire_type, format): + """Return a constructor for a decoder for a fixed-width field. + + Args: + wire_type: The field's wire type. + format: The format string to pass to struct.unpack(). + """ + + value_size = struct.calcsize(format) + local_unpack = struct.unpack + + # Reusing _SimpleDecoder is slightly slower than copying a bunch of code, but + # not enough to make a significant difference. + + # Note that we expect someone up-stack to catch struct.error and convert + # it to _DecodeError -- this way we don't have to set up exception- + # handling blocks every time we parse one value. + + def InnerDecode(buffer, pos): + new_pos = pos + value_size + result = local_unpack(format, buffer[pos:new_pos])[0] + return (result, new_pos) + return _SimpleDecoder(wire_type, InnerDecode) + + +def _FloatDecoder(): + """Returns a decoder for a float field. + + This code works around a bug in struct.unpack for non-finite 32-bit + floating-point values. + """ + + local_unpack = struct.unpack + + def InnerDecode(buffer, pos): + """Decode serialized float to a float and new position. + + Args: + buffer: memoryview of the serialized bytes + pos: int, position in the memory view to start at. + + Returns: + Tuple[float, int] of the deserialized float value and new position + in the serialized data. + """ + # We expect a 32-bit value in little-endian byte order. Bit 1 is the sign + # bit, bits 2-9 represent the exponent, and bits 10-32 are the significand. + new_pos = pos + 4 + float_bytes = buffer[pos:new_pos].tobytes() + + # If this value has all its exponent bits set, then it's non-finite. + # In Python 2.4, struct.unpack will convert it to a finite 64-bit value. + # To avoid that, we parse it specially. + if (float_bytes[3:4] in b'\x7F\xFF' and float_bytes[2:3] >= b'\x80'): + # If at least one significand bit is set... + if float_bytes[0:3] != b'\x00\x00\x80': + return (math.nan, new_pos) + # If sign bit is set... + if float_bytes[3:4] == b'\xFF': + return (-math.inf, new_pos) + return (math.inf, new_pos) + + # Note that we expect someone up-stack to catch struct.error and convert + # it to _DecodeError -- this way we don't have to set up exception- + # handling blocks every time we parse one value. + result = local_unpack('= b'\xF0') + and (double_bytes[0:7] != b'\x00\x00\x00\x00\x00\x00\xF0')): + return (math.nan, new_pos) + + # Note that we expect someone up-stack to catch struct.error and convert + # it to _DecodeError -- this way we don't have to set up exception- + # handling blocks every time we parse one value. + result = local_unpack(' end: + raise _DecodeError('Truncated message.') + while pos < endpoint: + value_start_pos = pos + (element, pos) = _DecodeSignedVarint32(buffer, pos) + # pylint: disable=protected-access + if element in enum_type.values_by_number: + value.append(element) + else: + if not message._unknown_fields: + message._unknown_fields = [] + tag_bytes = encoder.TagBytes(field_number, + wire_format.WIRETYPE_VARINT) + + message._unknown_fields.append( + (tag_bytes, buffer[value_start_pos:pos].tobytes())) + # pylint: enable=protected-access + if pos > endpoint: + if element in enum_type.values_by_number: + del value[-1] # Discard corrupt value. + else: + del message._unknown_fields[-1] + # pylint: enable=protected-access + raise _DecodeError('Packed element was truncated.') + return pos + + return DecodePackedField + elif is_repeated: + tag_bytes = encoder.TagBytes(field_number, wire_format.WIRETYPE_VARINT) + tag_len = len(tag_bytes) + def DecodeRepeatedField( + buffer, pos, end, message, field_dict, current_depth=0 + ): + """Decode serialized repeated enum to its value and a new position. + + Args: + buffer: memoryview of the serialized bytes. + pos: int, position in the memory view to start at. + end: int, end position of serialized data + message: Message object to store unknown fields in + field_dict: Map[Descriptor, Any] to store decoded values in. + + Returns: + int, new position in serialized data. + """ + del current_depth # unused + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + while 1: + (element, new_pos) = _DecodeSignedVarint32(buffer, pos) + # pylint: disable=protected-access + if element in enum_type.values_by_number: + value.append(element) + else: + if not message._unknown_fields: + message._unknown_fields = [] + message._unknown_fields.append( + (tag_bytes, buffer[pos:new_pos].tobytes())) + # pylint: enable=protected-access + # Predict that the next tag is another copy of the same repeated + # field. + pos = new_pos + tag_len + if buffer[new_pos:pos] != tag_bytes or new_pos >= end: + # Prediction failed. Return. + if new_pos > end: + raise _DecodeError('Truncated message.') + return new_pos + + return DecodeRepeatedField + else: + + def DecodeField(buffer, pos, end, message, field_dict, current_depth=0): + """Decode serialized repeated enum to its value and a new position. + + Args: + buffer: memoryview of the serialized bytes. + pos: int, position in the memory view to start at. + end: int, end position of serialized data + message: Message object to store unknown fields in + field_dict: Map[Descriptor, Any] to store decoded values in. + + Returns: + int, new position in serialized data. + """ + del current_depth # unused + value_start_pos = pos + (enum_value, pos) = _DecodeSignedVarint32(buffer, pos) + if pos > end: + raise _DecodeError('Truncated message.') + if clear_if_default and IsDefaultScalarValue(enum_value): + field_dict.pop(key, None) + return pos + # pylint: disable=protected-access + if enum_value in enum_type.values_by_number: + field_dict[key] = enum_value + else: + if not message._unknown_fields: + message._unknown_fields = [] + tag_bytes = encoder.TagBytes(field_number, + wire_format.WIRETYPE_VARINT) + message._unknown_fields.append( + (tag_bytes, buffer[value_start_pos:pos].tobytes())) + # pylint: enable=protected-access + return pos + + return DecodeField + + +# -------------------------------------------------------------------- + + +Int32Decoder = _SimpleDecoder( + wire_format.WIRETYPE_VARINT, _DecodeSignedVarint32) + +Int64Decoder = _SimpleDecoder( + wire_format.WIRETYPE_VARINT, _DecodeSignedVarint) + +UInt32Decoder = _SimpleDecoder(wire_format.WIRETYPE_VARINT, _DecodeVarint32) +UInt64Decoder = _SimpleDecoder(wire_format.WIRETYPE_VARINT, _DecodeVarint) + +SInt32Decoder = _ModifiedDecoder( + wire_format.WIRETYPE_VARINT, _DecodeVarint32, wire_format.ZigZagDecode) +SInt64Decoder = _ModifiedDecoder( + wire_format.WIRETYPE_VARINT, _DecodeVarint, wire_format.ZigZagDecode) + +# Note that Python conveniently guarantees that when using the '<' prefix on +# formats, they will also have the same size across all platforms (as opposed +# to without the prefix, where their sizes depend on the C compiler's basic +# type sizes). +Fixed32Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED32, ' end: + raise _DecodeError('Truncated string.') + value.append(_ConvertToUnicode(buffer[pos:new_pos])) + # Predict that the next tag is another copy of the same repeated field. + pos = new_pos + tag_len + if buffer[new_pos:pos] != tag_bytes or new_pos == end: + # Prediction failed. Return. + return new_pos + + return DecodeRepeatedField + else: + + def DecodeField(buffer, pos, end, message, field_dict, current_depth=0): + del current_depth # unused + (size, pos) = local_DecodeVarint(buffer, pos) + new_pos = pos + size + if new_pos > end: + raise _DecodeError('Truncated string.') + if clear_if_default and IsDefaultScalarValue(size): + field_dict.pop(key, None) + else: + field_dict[key] = _ConvertToUnicode(buffer[pos:new_pos]) + return new_pos + + return DecodeField + + +def BytesDecoder(field_number, is_repeated, is_packed, key, new_default, + clear_if_default=False): + """Returns a decoder for a bytes field.""" + + local_DecodeVarint = _DecodeVarint + + assert not is_packed + if is_repeated: + tag_bytes = encoder.TagBytes(field_number, + wire_format.WIRETYPE_LENGTH_DELIMITED) + tag_len = len(tag_bytes) + def DecodeRepeatedField( + buffer, pos, end, message, field_dict, current_depth=0 + ): + del current_depth # unused + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + while 1: + (size, pos) = local_DecodeVarint(buffer, pos) + new_pos = pos + size + if new_pos > end: + raise _DecodeError('Truncated string.') + value.append(buffer[pos:new_pos].tobytes()) + # Predict that the next tag is another copy of the same repeated field. + pos = new_pos + tag_len + if buffer[new_pos:pos] != tag_bytes or new_pos == end: + # Prediction failed. Return. + return new_pos + + return DecodeRepeatedField + else: + + def DecodeField(buffer, pos, end, message, field_dict, current_depth=0): + del current_depth # unused + (size, pos) = local_DecodeVarint(buffer, pos) + new_pos = pos + size + if new_pos > end: + raise _DecodeError('Truncated string.') + if clear_if_default and IsDefaultScalarValue(size): + field_dict.pop(key, None) + else: + field_dict[key] = buffer[pos:new_pos].tobytes() + return new_pos + + return DecodeField + + +def GroupDecoder(field_number, is_repeated, is_packed, key, new_default): + """Returns a decoder for a group field.""" + + end_tag_bytes = encoder.TagBytes(field_number, + wire_format.WIRETYPE_END_GROUP) + end_tag_len = len(end_tag_bytes) + + assert not is_packed + if is_repeated: + tag_bytes = encoder.TagBytes(field_number, + wire_format.WIRETYPE_START_GROUP) + tag_len = len(tag_bytes) + def DecodeRepeatedField( + buffer, pos, end, message, field_dict, current_depth=0 + ): + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + while 1: + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + # Read sub-message. + current_depth += 1 + if current_depth > _recursion_limit: + raise _DecodeError( + 'Error parsing message: too many levels of nesting.' + ) + pos = value.add()._InternalParse(buffer, pos, end, current_depth) + current_depth -= 1 + # Read end tag. + new_pos = pos+end_tag_len + if buffer[pos:new_pos] != end_tag_bytes or new_pos > end: + raise _DecodeError('Missing group end tag.') + # Predict that the next tag is another copy of the same repeated field. + pos = new_pos + tag_len + if buffer[new_pos:pos] != tag_bytes or new_pos == end: + # Prediction failed. Return. + return new_pos + + return DecodeRepeatedField + else: + + def DecodeField(buffer, pos, end, message, field_dict, current_depth=0): + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + # Read sub-message. + current_depth += 1 + if current_depth > _recursion_limit: + raise _DecodeError('Error parsing message: too many levels of nesting.') + pos = value._InternalParse(buffer, pos, end, current_depth) + current_depth -= 1 + # Read end tag. + new_pos = pos+end_tag_len + if buffer[pos:new_pos] != end_tag_bytes or new_pos > end: + raise _DecodeError('Missing group end tag.') + return new_pos + + return DecodeField + + +def MessageDecoder(field_number, is_repeated, is_packed, key, new_default): + """Returns a decoder for a message field.""" + + local_DecodeVarint = _DecodeVarint + + assert not is_packed + if is_repeated: + tag_bytes = encoder.TagBytes(field_number, + wire_format.WIRETYPE_LENGTH_DELIMITED) + tag_len = len(tag_bytes) + def DecodeRepeatedField( + buffer, pos, end, message, field_dict, current_depth=0 + ): + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + while 1: + # Read length. + (size, pos) = local_DecodeVarint(buffer, pos) + new_pos = pos + size + if new_pos > end: + raise _DecodeError('Truncated message.') + # Read sub-message. + current_depth += 1 + if current_depth > _recursion_limit: + raise _DecodeError( + 'Error parsing message: too many levels of nesting.' + ) + if ( + value.add()._InternalParse(buffer, pos, new_pos, current_depth) + != new_pos + ): + # The only reason _InternalParse would return early is if it + # encountered an end-group tag. + raise _DecodeError('Unexpected end-group tag.') + current_depth -= 1 + # Predict that the next tag is another copy of the same repeated field. + pos = new_pos + tag_len + if buffer[new_pos:pos] != tag_bytes or new_pos == end: + # Prediction failed. Return. + return new_pos + + return DecodeRepeatedField + else: + + def DecodeField(buffer, pos, end, message, field_dict, current_depth=0): + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + # Read length. + (size, pos) = local_DecodeVarint(buffer, pos) + new_pos = pos + size + if new_pos > end: + raise _DecodeError('Truncated message.') + # Read sub-message. + current_depth += 1 + if current_depth > _recursion_limit: + raise _DecodeError('Error parsing message: too many levels of nesting.') + if value._InternalParse(buffer, pos, new_pos, current_depth) != new_pos: + # The only reason _InternalParse would return early is if it encountered + # an end-group tag. + raise _DecodeError('Unexpected end-group tag.') + current_depth -= 1 + return new_pos + + return DecodeField + + +# -------------------------------------------------------------------- + +MESSAGE_SET_ITEM_TAG = encoder.TagBytes(1, wire_format.WIRETYPE_START_GROUP) + +def MessageSetItemDecoder(descriptor): + """Returns a decoder for a MessageSet item. + + The parameter is the message Descriptor. + + The message set message looks like this: + message MessageSet { + repeated group Item = 1 { + required int32 type_id = 2; + required string message = 3; + } + } + """ + + type_id_tag_bytes = encoder.TagBytes(2, wire_format.WIRETYPE_VARINT) + message_tag_bytes = encoder.TagBytes(3, wire_format.WIRETYPE_LENGTH_DELIMITED) + item_end_tag_bytes = encoder.TagBytes(1, wire_format.WIRETYPE_END_GROUP) + + local_ReadTag = ReadTag + local_DecodeVarint = _DecodeVarint + + def DecodeItem(buffer, pos, end, message, field_dict, current_depth=0): + """Decode serialized message set to its value and new position. + + Args: + buffer: memoryview of the serialized bytes. + pos: int, position in the memory view to start at. + end: int, end position of serialized data + message: Message object to store unknown fields in + field_dict: Map[Descriptor, Any] to store decoded values in. + + Returns: + int, new position in serialized data. + """ + message_set_item_start = pos + type_id = -1 + message_start = -1 + message_end = -1 + + # Technically, type_id and message can appear in any order, so we need + # a little loop here. + while 1: + (tag_bytes, pos) = local_ReadTag(buffer, pos) + if tag_bytes == type_id_tag_bytes: + (type_id, pos) = local_DecodeVarint(buffer, pos) + elif tag_bytes == message_tag_bytes: + (size, message_start) = local_DecodeVarint(buffer, pos) + pos = message_end = message_start + size + elif tag_bytes == item_end_tag_bytes: + break + else: + field_number, wire_type = DecodeTag(tag_bytes) + _, pos = _DecodeUnknownField(buffer, pos, end, field_number, wire_type) + if pos == -1: + raise _DecodeError('Unexpected end-group tag.') + + if pos > end: + raise _DecodeError('Truncated message.') + + if type_id == -1: + raise _DecodeError('MessageSet item missing type_id.') + if message_start == -1: + raise _DecodeError('MessageSet item missing message.') + + extension = message.Extensions._FindExtensionByNumber(type_id) + # pylint: disable=protected-access + if extension is not None: + value = field_dict.get(extension) + if value is None: + message_type = extension.message_type + if not hasattr(message_type, '_concrete_class'): + message_factory.GetMessageClass(message_type) + value = field_dict.setdefault( + extension, message_type._concrete_class()) + current_depth += 1 + if current_depth > _recursion_limit: + raise _DecodeError('Error parsing message: too many levels of nesting.') + if ( + value._InternalParse( + buffer, message_start, message_end, current_depth + ) + != message_end + ): + # The only reason _InternalParse would return early is if it encountered + # an end-group tag. + raise _DecodeError('Unexpected end-group tag.') + current_depth -= 1 + else: + if not message._unknown_fields: + message._unknown_fields = [] + message._unknown_fields.append( + (MESSAGE_SET_ITEM_TAG, buffer[message_set_item_start:pos].tobytes())) + # pylint: enable=protected-access + + return pos + + return DecodeItem + + +def UnknownMessageSetItemDecoder(): + """Returns a decoder for a Unknown MessageSet item.""" + + type_id_tag_bytes = encoder.TagBytes(2, wire_format.WIRETYPE_VARINT) + message_tag_bytes = encoder.TagBytes(3, wire_format.WIRETYPE_LENGTH_DELIMITED) + item_end_tag_bytes = encoder.TagBytes(1, wire_format.WIRETYPE_END_GROUP) + + def DecodeUnknownItem(buffer): + pos = 0 + end = len(buffer) + message_start = -1 + message_end = -1 + while 1: + (tag_bytes, pos) = ReadTag(buffer, pos) + if tag_bytes == type_id_tag_bytes: + (type_id, pos) = _DecodeVarint(buffer, pos) + elif tag_bytes == message_tag_bytes: + (size, message_start) = _DecodeVarint(buffer, pos) + pos = message_end = message_start + size + elif tag_bytes == item_end_tag_bytes: + break + else: + field_number, wire_type = DecodeTag(tag_bytes) + _, pos = _DecodeUnknownField(buffer, pos, end, field_number, wire_type) + if pos == -1: + raise _DecodeError('Unexpected end-group tag.') + + if pos > end: + raise _DecodeError('Truncated message.') + + if type_id == -1: + raise _DecodeError('MessageSet item missing type_id.') + if message_start == -1: + raise _DecodeError('MessageSet item missing message.') + + return (type_id, buffer[message_start:message_end].tobytes()) + + return DecodeUnknownItem + +# -------------------------------------------------------------------- + +def MapDecoder(field_descriptor, new_default, is_message_map): + """Returns a decoder for a map field.""" + + key = field_descriptor + tag_bytes = encoder.TagBytes(field_descriptor.number, + wire_format.WIRETYPE_LENGTH_DELIMITED) + tag_len = len(tag_bytes) + local_DecodeVarint = _DecodeVarint + # Can't read _concrete_class yet; might not be initialized. + message_type = field_descriptor.message_type + + def DecodeMap(buffer, pos, end, message, field_dict, current_depth=0): + submsg = message_type._concrete_class() + value = field_dict.get(key) + if value is None: + value = field_dict.setdefault(key, new_default(message)) + while 1: + # Read length. + (size, pos) = local_DecodeVarint(buffer, pos) + new_pos = pos + size + if new_pos > end: + raise _DecodeError('Truncated message.') + # Read sub-message. + submsg.Clear() + current_depth += 1 + if current_depth > _recursion_limit: + raise _DecodeError('Error parsing message: too many levels of nesting.') + if submsg._InternalParse(buffer, pos, new_pos, current_depth) != new_pos: + # The only reason _InternalParse would return early is if it + # encountered an end-group tag. + raise _DecodeError('Unexpected end-group tag.') + current_depth -= 1 + + if is_message_map: + value[submsg.key].CopyFrom(submsg.value) + else: + value[submsg.key] = submsg.value + + # Predict that the next tag is another copy of the same repeated field. + pos = new_pos + tag_len + if buffer[new_pos:pos] != tag_bytes or new_pos == end: + # Prediction failed. Return. + return new_pos + + return DecodeMap + + +def _DecodeFixed64(buffer, pos): + """Decode a fixed64.""" + new_pos = pos + 8 + return (struct.unpack('= _recursion_limit: + raise _DecodeError('Error parsing message: too many levels of nesting.') + data, pos = _DecodeUnknownFieldSet(buffer, pos, end_pos, current_depth) + current_depth -= 1 + # Check end tag. + if buffer[pos - len(end_tag_bytes) : pos] != end_tag_bytes: + raise _DecodeError('Missing group end tag.') + elif wire_type == wire_format.WIRETYPE_END_GROUP: + return (0, -1) + else: + raise _DecodeError('Wrong wire type in tag.') + + if pos > end_pos: + raise _DecodeError('Truncated message.') + + return (data, pos) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/encoder.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..df7bf1b537f6a3d5f1f4e10009f7e23be91382dd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/encoder.py @@ -0,0 +1,806 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Code for encoding protocol message primitives. + +Contains the logic for encoding every logical protocol field type +into one of the 5 physical wire types. + +This code is designed to push the Python interpreter's performance to the +limits. + +The basic idea is that at startup time, for every field (i.e. every +FieldDescriptor) we construct two functions: a "sizer" and an "encoder". The +sizer takes a value of this field's type and computes its byte size. The +encoder takes a writer function and a value. It encodes the value into byte +strings and invokes the writer function to write those strings. Typically the +writer function is the write() method of a BytesIO. + +We try to do as much work as possible when constructing the writer and the +sizer rather than when calling them. In particular: +* We copy any needed global functions to local variables, so that we do not need + to do costly global table lookups at runtime. +* Similarly, we try to do any attribute lookups at startup time if possible. +* Every field's tag is encoded to bytes at startup, since it can't change at + runtime. +* Whatever component of the field size we can compute at startup, we do. +* We *avoid* sharing code if doing so would make the code slower and not sharing + does not burden us too much. For example, encoders for repeated fields do + not just call the encoders for singular fields in a loop because this would + add an extra function call overhead for every loop iteration; instead, we + manually inline the single-value encoder into the loop. +* If a Python function lacks a return statement, Python actually generates + instructions to pop the result of the last statement off the stack, push + None onto the stack, and then return that. If we really don't care what + value is returned, then we can save two instructions by returning the + result of the last statement. It looks funny but it helps. +* We assume that type and bounds checking has happened at a higher level. +""" + +__author__ = 'kenton@google.com (Kenton Varda)' + +import struct + +from google.protobuf.internal import wire_format + + +# This will overflow and thus become IEEE-754 "infinity". We would use +# "float('inf')" but it doesn't work on Windows pre-Python-2.6. +_POS_INF = 1e10000 +_NEG_INF = -_POS_INF + + +def _VarintSize(value): + """Compute the size of a varint value.""" + if value <= 0x7f: return 1 + if value <= 0x3fff: return 2 + if value <= 0x1fffff: return 3 + if value <= 0xfffffff: return 4 + if value <= 0x7ffffffff: return 5 + if value <= 0x3ffffffffff: return 6 + if value <= 0x1ffffffffffff: return 7 + if value <= 0xffffffffffffff: return 8 + if value <= 0x7fffffffffffffff: return 9 + return 10 + + +def _SignedVarintSize(value): + """Compute the size of a signed varint value.""" + if value < 0: return 10 + if value <= 0x7f: return 1 + if value <= 0x3fff: return 2 + if value <= 0x1fffff: return 3 + if value <= 0xfffffff: return 4 + if value <= 0x7ffffffff: return 5 + if value <= 0x3ffffffffff: return 6 + if value <= 0x1ffffffffffff: return 7 + if value <= 0xffffffffffffff: return 8 + if value <= 0x7fffffffffffffff: return 9 + return 10 + + +def _TagSize(field_number): + """Returns the number of bytes required to serialize a tag with this field + number.""" + # Just pass in type 0, since the type won't affect the tag+type size. + return _VarintSize(wire_format.PackTag(field_number, 0)) + + +# -------------------------------------------------------------------- +# In this section we define some generic sizers. Each of these functions +# takes parameters specific to a particular field type, e.g. int32 or fixed64. +# It returns another function which in turn takes parameters specific to a +# particular field, e.g. the field number and whether it is repeated or packed. +# Look at the next section to see how these are used. + + +def _SimpleSizer(compute_value_size): + """A sizer which uses the function compute_value_size to compute the size of + each value. Typically compute_value_size is _VarintSize.""" + + def SpecificSizer(field_number, is_repeated, is_packed): + tag_size = _TagSize(field_number) + if is_packed: + local_VarintSize = _VarintSize + def PackedFieldSize(value): + result = 0 + for element in value: + result += compute_value_size(element) + return result + local_VarintSize(result) + tag_size + return PackedFieldSize + elif is_repeated: + def RepeatedFieldSize(value): + result = tag_size * len(value) + for element in value: + result += compute_value_size(element) + return result + return RepeatedFieldSize + else: + def FieldSize(value): + return tag_size + compute_value_size(value) + return FieldSize + + return SpecificSizer + + +def _ModifiedSizer(compute_value_size, modify_value): + """Like SimpleSizer, but modify_value is invoked on each value before it is + passed to compute_value_size. modify_value is typically ZigZagEncode.""" + + def SpecificSizer(field_number, is_repeated, is_packed): + tag_size = _TagSize(field_number) + if is_packed: + local_VarintSize = _VarintSize + def PackedFieldSize(value): + result = 0 + for element in value: + result += compute_value_size(modify_value(element)) + return result + local_VarintSize(result) + tag_size + return PackedFieldSize + elif is_repeated: + def RepeatedFieldSize(value): + result = tag_size * len(value) + for element in value: + result += compute_value_size(modify_value(element)) + return result + return RepeatedFieldSize + else: + def FieldSize(value): + return tag_size + compute_value_size(modify_value(value)) + return FieldSize + + return SpecificSizer + + +def _FixedSizer(value_size): + """Like _SimpleSizer except for a fixed-size field. The input is the size + of one value.""" + + def SpecificSizer(field_number, is_repeated, is_packed): + tag_size = _TagSize(field_number) + if is_packed: + local_VarintSize = _VarintSize + def PackedFieldSize(value): + result = len(value) * value_size + return result + local_VarintSize(result) + tag_size + return PackedFieldSize + elif is_repeated: + element_size = value_size + tag_size + def RepeatedFieldSize(value): + return len(value) * element_size + return RepeatedFieldSize + else: + field_size = value_size + tag_size + def FieldSize(value): + return field_size + return FieldSize + + return SpecificSizer + + +# ==================================================================== +# Here we declare a sizer constructor for each field type. Each "sizer +# constructor" is a function that takes (field_number, is_repeated, is_packed) +# as parameters and returns a sizer, which in turn takes a field value as +# a parameter and returns its encoded size. + + +Int32Sizer = Int64Sizer = EnumSizer = _SimpleSizer(_SignedVarintSize) + +UInt32Sizer = UInt64Sizer = _SimpleSizer(_VarintSize) + +SInt32Sizer = SInt64Sizer = _ModifiedSizer( + _SignedVarintSize, wire_format.ZigZagEncode) + +Fixed32Sizer = SFixed32Sizer = FloatSizer = _FixedSizer(4) +Fixed64Sizer = SFixed64Sizer = DoubleSizer = _FixedSizer(8) + +BoolSizer = _FixedSizer(1) + + +def StringSizer(field_number, is_repeated, is_packed): + """Returns a sizer for a string field.""" + + tag_size = _TagSize(field_number) + local_VarintSize = _VarintSize + local_len = len + assert not is_packed + if is_repeated: + def RepeatedFieldSize(value): + result = tag_size * len(value) + for element in value: + l = local_len(element.encode('utf-8')) + result += local_VarintSize(l) + l + return result + return RepeatedFieldSize + else: + def FieldSize(value): + l = local_len(value.encode('utf-8')) + return tag_size + local_VarintSize(l) + l + return FieldSize + + +def BytesSizer(field_number, is_repeated, is_packed): + """Returns a sizer for a bytes field.""" + + tag_size = _TagSize(field_number) + local_VarintSize = _VarintSize + local_len = len + assert not is_packed + if is_repeated: + def RepeatedFieldSize(value): + result = tag_size * len(value) + for element in value: + l = local_len(element) + result += local_VarintSize(l) + l + return result + return RepeatedFieldSize + else: + def FieldSize(value): + l = local_len(value) + return tag_size + local_VarintSize(l) + l + return FieldSize + + +def GroupSizer(field_number, is_repeated, is_packed): + """Returns a sizer for a group field.""" + + tag_size = _TagSize(field_number) * 2 + assert not is_packed + if is_repeated: + def RepeatedFieldSize(value): + result = tag_size * len(value) + for element in value: + result += element.ByteSize() + return result + return RepeatedFieldSize + else: + def FieldSize(value): + return tag_size + value.ByteSize() + return FieldSize + + +def MessageSizer(field_number, is_repeated, is_packed): + """Returns a sizer for a message field.""" + + tag_size = _TagSize(field_number) + local_VarintSize = _VarintSize + assert not is_packed + if is_repeated: + def RepeatedFieldSize(value): + result = tag_size * len(value) + for element in value: + l = element.ByteSize() + result += local_VarintSize(l) + l + return result + return RepeatedFieldSize + else: + def FieldSize(value): + l = value.ByteSize() + return tag_size + local_VarintSize(l) + l + return FieldSize + + +# -------------------------------------------------------------------- +# MessageSet is special: it needs custom logic to compute its size properly. + + +def MessageSetItemSizer(field_number): + """Returns a sizer for extensions of MessageSet. + + The message set message looks like this: + message MessageSet { + repeated group Item = 1 { + required int32 type_id = 2; + required string message = 3; + } + } + """ + static_size = (_TagSize(1) * 2 + _TagSize(2) + _VarintSize(field_number) + + _TagSize(3)) + local_VarintSize = _VarintSize + + def FieldSize(value): + l = value.ByteSize() + return static_size + local_VarintSize(l) + l + + return FieldSize + + +# -------------------------------------------------------------------- +# Map is special: it needs custom logic to compute its size properly. + + +def MapSizer(field_descriptor, is_message_map): + """Returns a sizer for a map field.""" + + # Can't look at field_descriptor.message_type._concrete_class because it may + # not have been initialized yet. + message_type = field_descriptor.message_type + message_sizer = MessageSizer(field_descriptor.number, False, False) + + def FieldSize(map_value): + total = 0 + for key in map_value: + value = map_value[key] + # It's wasteful to create the messages and throw them away one second + # later since we'll do the same for the actual encode. But there's not an + # obvious way to avoid this within the current design without tons of code + # duplication. For message map, value.ByteSize() should be called to + # update the status. + entry_msg = message_type._concrete_class(key=key, value=value) + total += message_sizer(entry_msg) + if is_message_map: + value.ByteSize() + return total + + return FieldSize + +# ==================================================================== +# Encoders! + + +def _VarintEncoder(): + """Return an encoder for a basic varint value (does not include tag).""" + + local_int2byte = struct.Struct('>B').pack + + def EncodeVarint(write, value, unused_deterministic=None): + bits = value & 0x7f + value >>= 7 + while value: + write(local_int2byte(0x80|bits)) + bits = value & 0x7f + value >>= 7 + return write(local_int2byte(bits)) + + return EncodeVarint + + +def _SignedVarintEncoder(): + """Return an encoder for a basic signed varint value (does not include + tag).""" + + local_int2byte = struct.Struct('>B').pack + + def EncodeSignedVarint(write, value, unused_deterministic=None): + if value < 0: + value += (1 << 64) + bits = value & 0x7f + value >>= 7 + while value: + write(local_int2byte(0x80|bits)) + bits = value & 0x7f + value >>= 7 + return write(local_int2byte(bits)) + + return EncodeSignedVarint + + +_EncodeVarint = _VarintEncoder() +_EncodeSignedVarint = _SignedVarintEncoder() + + +def _VarintBytes(value): + """Encode the given integer as a varint and return the bytes. This is only + called at startup time so it doesn't need to be fast.""" + + pieces = [] + _EncodeVarint(pieces.append, value, True) + return b"".join(pieces) + + +def TagBytes(field_number, wire_type): + """Encode the given tag and return the bytes. Only called at startup.""" + + return bytes(_VarintBytes(wire_format.PackTag(field_number, wire_type))) + +# -------------------------------------------------------------------- +# As with sizers (see above), we have a number of common encoder +# implementations. + + +def _SimpleEncoder(wire_type, encode_value, compute_value_size): + """Return a constructor for an encoder for fields of a particular type. + + Args: + wire_type: The field's wire type, for encoding tags. + encode_value: A function which encodes an individual value, e.g. + _EncodeVarint(). + compute_value_size: A function which computes the size of an individual + value, e.g. _VarintSize(). + """ + + def SpecificEncoder(field_number, is_repeated, is_packed): + if is_packed: + tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) + local_EncodeVarint = _EncodeVarint + def EncodePackedField(write, value, deterministic): + write(tag_bytes) + size = 0 + for element in value: + size += compute_value_size(element) + local_EncodeVarint(write, size, deterministic) + for element in value: + encode_value(write, element, deterministic) + return EncodePackedField + elif is_repeated: + tag_bytes = TagBytes(field_number, wire_type) + def EncodeRepeatedField(write, value, deterministic): + for element in value: + write(tag_bytes) + encode_value(write, element, deterministic) + return EncodeRepeatedField + else: + tag_bytes = TagBytes(field_number, wire_type) + def EncodeField(write, value, deterministic): + write(tag_bytes) + return encode_value(write, value, deterministic) + return EncodeField + + return SpecificEncoder + + +def _ModifiedEncoder(wire_type, encode_value, compute_value_size, modify_value): + """Like SimpleEncoder but additionally invokes modify_value on every value + before passing it to encode_value. Usually modify_value is ZigZagEncode.""" + + def SpecificEncoder(field_number, is_repeated, is_packed): + if is_packed: + tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) + local_EncodeVarint = _EncodeVarint + def EncodePackedField(write, value, deterministic): + write(tag_bytes) + size = 0 + for element in value: + size += compute_value_size(modify_value(element)) + local_EncodeVarint(write, size, deterministic) + for element in value: + encode_value(write, modify_value(element), deterministic) + return EncodePackedField + elif is_repeated: + tag_bytes = TagBytes(field_number, wire_type) + def EncodeRepeatedField(write, value, deterministic): + for element in value: + write(tag_bytes) + encode_value(write, modify_value(element), deterministic) + return EncodeRepeatedField + else: + tag_bytes = TagBytes(field_number, wire_type) + def EncodeField(write, value, deterministic): + write(tag_bytes) + return encode_value(write, modify_value(value), deterministic) + return EncodeField + + return SpecificEncoder + + +def _StructPackEncoder(wire_type, format): + """Return a constructor for an encoder for a fixed-width field. + + Args: + wire_type: The field's wire type, for encoding tags. + format: The format string to pass to struct.pack(). + """ + + value_size = struct.calcsize(format) + + def SpecificEncoder(field_number, is_repeated, is_packed): + local_struct_pack = struct.pack + if is_packed: + tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) + local_EncodeVarint = _EncodeVarint + def EncodePackedField(write, value, deterministic): + write(tag_bytes) + local_EncodeVarint(write, len(value) * value_size, deterministic) + for element in value: + write(local_struct_pack(format, element)) + return EncodePackedField + elif is_repeated: + tag_bytes = TagBytes(field_number, wire_type) + def EncodeRepeatedField(write, value, unused_deterministic=None): + for element in value: + write(tag_bytes) + write(local_struct_pack(format, element)) + return EncodeRepeatedField + else: + tag_bytes = TagBytes(field_number, wire_type) + def EncodeField(write, value, unused_deterministic=None): + write(tag_bytes) + return write(local_struct_pack(format, value)) + return EncodeField + + return SpecificEncoder + + +def _FloatingPointEncoder(wire_type, format): + """Return a constructor for an encoder for float fields. + + This is like StructPackEncoder, but catches errors that may be due to + passing non-finite floating-point values to struct.pack, and makes a + second attempt to encode those values. + + Args: + wire_type: The field's wire type, for encoding tags. + format: The format string to pass to struct.pack(). + """ + + value_size = struct.calcsize(format) + if value_size == 4: + def EncodeNonFiniteOrRaise(write, value): + # Remember that the serialized form uses little-endian byte order. + if value == _POS_INF: + write(b'\x00\x00\x80\x7F') + elif value == _NEG_INF: + write(b'\x00\x00\x80\xFF') + elif value != value: # NaN + write(b'\x00\x00\xC0\x7F') + else: + raise + elif value_size == 8: + def EncodeNonFiniteOrRaise(write, value): + if value == _POS_INF: + write(b'\x00\x00\x00\x00\x00\x00\xF0\x7F') + elif value == _NEG_INF: + write(b'\x00\x00\x00\x00\x00\x00\xF0\xFF') + elif value != value: # NaN + write(b'\x00\x00\x00\x00\x00\x00\xF8\x7F') + else: + raise + else: + raise ValueError('Can\'t encode floating-point values that are ' + '%d bytes long (only 4 or 8)' % value_size) + + def SpecificEncoder(field_number, is_repeated, is_packed): + local_struct_pack = struct.pack + if is_packed: + tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) + local_EncodeVarint = _EncodeVarint + def EncodePackedField(write, value, deterministic): + write(tag_bytes) + local_EncodeVarint(write, len(value) * value_size, deterministic) + for element in value: + # This try/except block is going to be faster than any code that + # we could write to check whether element is finite. + try: + write(local_struct_pack(format, element)) + except SystemError: + EncodeNonFiniteOrRaise(write, element) + return EncodePackedField + elif is_repeated: + tag_bytes = TagBytes(field_number, wire_type) + def EncodeRepeatedField(write, value, unused_deterministic=None): + for element in value: + write(tag_bytes) + try: + write(local_struct_pack(format, element)) + except SystemError: + EncodeNonFiniteOrRaise(write, element) + return EncodeRepeatedField + else: + tag_bytes = TagBytes(field_number, wire_type) + def EncodeField(write, value, unused_deterministic=None): + write(tag_bytes) + try: + write(local_struct_pack(format, value)) + except SystemError: + EncodeNonFiniteOrRaise(write, value) + return EncodeField + + return SpecificEncoder + + +# ==================================================================== +# Here we declare an encoder constructor for each field type. These work +# very similarly to sizer constructors, described earlier. + + +Int32Encoder = Int64Encoder = EnumEncoder = _SimpleEncoder( + wire_format.WIRETYPE_VARINT, _EncodeSignedVarint, _SignedVarintSize) + +UInt32Encoder = UInt64Encoder = _SimpleEncoder( + wire_format.WIRETYPE_VARINT, _EncodeVarint, _VarintSize) + +SInt32Encoder = SInt64Encoder = _ModifiedEncoder( + wire_format.WIRETYPE_VARINT, _EncodeVarint, _VarintSize, + wire_format.ZigZagEncode) + +# Note that Python conveniently guarantees that when using the '<' prefix on +# formats, they will also have the same size across all platforms (as opposed +# to without the prefix, where their sizes depend on the C compiler's basic +# type sizes). +Fixed32Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED32, ' str + ValueType = int + + def __init__(self, enum_type): + """Inits EnumTypeWrapper with an EnumDescriptor.""" + self._enum_type = enum_type + self.DESCRIPTOR = enum_type # pylint: disable=invalid-name + + def Name(self, number): # pylint: disable=invalid-name + """Returns a string containing the name of an enum value.""" + try: + return self._enum_type.values_by_number[number].name + except KeyError: + pass # fall out to break exception chaining + + if not isinstance(number, int): + raise TypeError( + 'Enum value for {} must be an int, but got {} {!r}.'.format( + self._enum_type.name, type(number), number)) + else: + # repr here to handle the odd case when you pass in a boolean. + raise ValueError('Enum {} has no name defined for value {!r}'.format( + self._enum_type.name, number)) + + def Value(self, name): # pylint: disable=invalid-name + """Returns the value corresponding to the given enum name.""" + try: + return self._enum_type.values_by_name[name].number + except KeyError: + pass # fall out to break exception chaining + raise ValueError('Enum {} has no value defined for name {!r}'.format( + self._enum_type.name, name)) + + def keys(self): + """Return a list of the string names in the enum. + + Returns: + A list of strs, in the order they were defined in the .proto file. + """ + + return [value_descriptor.name + for value_descriptor in self._enum_type.values] + + def values(self): + """Return a list of the integer values in the enum. + + Returns: + A list of ints, in the order they were defined in the .proto file. + """ + + return [value_descriptor.number + for value_descriptor in self._enum_type.values] + + def items(self): + """Return a list of the (name, value) pairs of the enum. + + Returns: + A list of (str, int) pairs, in the order they were defined + in the .proto file. + """ + return [(value_descriptor.name, value_descriptor.number) + for value_descriptor in self._enum_type.values] + + def __getattr__(self, name): + """Returns the value corresponding to the given enum name.""" + try: + return super( + EnumTypeWrapper, + self).__getattribute__('_enum_type').values_by_name[name].number + except KeyError: + pass # fall out to break exception chaining + raise AttributeError('Enum {} has no value defined for name {!r}'.format( + self._enum_type.name, name)) + + def __or__(self, other): + """Returns the union type of self and other.""" + if sys.version_info >= (3, 10): + return type(self) | other + else: + raise NotImplementedError( + 'You may not use | on EnumTypes (or classes) below python 3.10' + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/extension_dict.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/extension_dict.py new file mode 100644 index 0000000000000000000000000000000000000000..8163ab94b1bd2a1e3a61ff3dc63e608cf315c105 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/extension_dict.py @@ -0,0 +1,194 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains _ExtensionDict class to represent extensions. +""" + +from google.protobuf.internal import type_checkers +from google.protobuf.descriptor import FieldDescriptor + + +def _VerifyExtensionHandle(message, extension_handle): + """Verify that the given extension handle is valid.""" + + if not isinstance(extension_handle, FieldDescriptor): + raise KeyError('HasExtension() expects an extension handle, got: %s' % + extension_handle) + + if not extension_handle.is_extension: + raise KeyError('"%s" is not an extension.' % extension_handle.full_name) + + if not extension_handle.containing_type: + raise KeyError('"%s" is missing a containing_type.' + % extension_handle.full_name) + + if extension_handle.containing_type is not message.DESCRIPTOR: + raise KeyError('Extension "%s" extends message type "%s", but this ' + 'message is of type "%s".' % + (extension_handle.full_name, + extension_handle.containing_type.full_name, + message.DESCRIPTOR.full_name)) + + +# TODO: Unify error handling of "unknown extension" crap. +# TODO: Support iteritems()-style iteration over all +# extensions with the "has" bits turned on? +class _ExtensionDict(object): + + """Dict-like container for Extension fields on proto instances. + + Note that in all cases we expect extension handles to be + FieldDescriptors. + """ + + def __init__(self, extended_message): + """ + Args: + extended_message: Message instance for which we are the Extensions dict. + """ + self._extended_message = extended_message + + def __getitem__(self, extension_handle): + """Returns the current value of the given extension handle.""" + + _VerifyExtensionHandle(self._extended_message, extension_handle) + + result = self._extended_message._fields.get(extension_handle) + if result is not None: + return result + + if extension_handle.is_repeated: + result = extension_handle._default_constructor(self._extended_message) + elif extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE: + message_type = extension_handle.message_type + if not hasattr(message_type, '_concrete_class'): + # pylint: disable=g-import-not-at-top + from google.protobuf import message_factory + message_factory.GetMessageClass(message_type) + if not hasattr(extension_handle.message_type, '_concrete_class'): + from google.protobuf import message_factory + message_factory.GetMessageClass(extension_handle.message_type) + result = extension_handle.message_type._concrete_class() + try: + result._SetListener(self._extended_message._listener_for_children) + except ReferenceError: + pass + else: + # Singular scalar -- just return the default without inserting into the + # dict. + return extension_handle.default_value + + # Atomically check if another thread has preempted us and, if not, swap + # in the new object we just created. If someone has preempted us, we + # take that object and discard ours. + # WARNING: We are relying on setdefault() being atomic. This is true + # in CPython but we haven't investigated others. This warning appears + # in several other locations in this file. + result = self._extended_message._fields.setdefault( + extension_handle, result) + + return result + + def __eq__(self, other): + if not isinstance(other, self.__class__): + return False + + my_fields = self._extended_message.ListFields() + other_fields = other._extended_message.ListFields() + + # Get rid of non-extension fields. + my_fields = [field for field in my_fields if field.is_extension] + other_fields = [field for field in other_fields if field.is_extension] + + return my_fields == other_fields + + def __ne__(self, other): + return not self == other + + def __len__(self): + fields = self._extended_message.ListFields() + # Get rid of non-extension fields. + extension_fields = [field for field in fields if field[0].is_extension] + return len(extension_fields) + + def __hash__(self): + raise TypeError('unhashable object') + + # Note that this is only meaningful for non-repeated, scalar extension + # fields. Note also that we may have to call _Modified() when we do + # successfully set a field this way, to set any necessary "has" bits in the + # ancestors of the extended message. + def __setitem__(self, extension_handle, value): + """If extension_handle specifies a non-repeated, scalar extension + field, sets the value of that field. + """ + + _VerifyExtensionHandle(self._extended_message, extension_handle) + + if (extension_handle.is_repeated or + extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE): + raise TypeError( + 'Cannot assign to extension "%s" because it is a repeated or ' + 'composite type.' % extension_handle.full_name) + + # It's slightly wasteful to lookup the type checker each time, + # but we expect this to be a vanishingly uncommon case anyway. + type_checker = type_checkers.GetTypeChecker(extension_handle) + # pylint: disable=protected-access + self._extended_message._fields[extension_handle] = ( + type_checker.CheckValue(value)) + self._extended_message._Modified() + + def __delitem__(self, extension_handle): + self._extended_message.ClearExtension(extension_handle) + + def _FindExtensionByName(self, name): + """Tries to find a known extension with the specified name. + + Args: + name: Extension full name. + + Returns: + Extension field descriptor. + """ + descriptor = self._extended_message.DESCRIPTOR + extensions = descriptor.file.pool._extensions_by_name[descriptor] + return extensions.get(name, None) + + def _FindExtensionByNumber(self, number): + """Tries to find a known extension with the field number. + + Args: + number: Extension field number. + + Returns: + Extension field descriptor. + """ + descriptor = self._extended_message.DESCRIPTOR + extensions = descriptor.file.pool._extensions_by_number[descriptor] + return extensions.get(number, None) + + def __iter__(self): + # Return a generator over the populated extension fields + return (f[0] for f in self._extended_message.ListFields() + if f[0].is_extension) + + def __contains__(self, extension_handle): + _VerifyExtensionHandle(self._extended_message, extension_handle) + + if extension_handle not in self._extended_message._fields: + return False + + if extension_handle.is_repeated: + return bool(self._extended_message._fields.get(extension_handle)) + + if extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE: + value = self._extended_message._fields.get(extension_handle) + # pylint: disable=protected-access + return value is not None and value._is_present_in_parent + + return True diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/field_mask.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/field_mask.py new file mode 100644 index 0000000000000000000000000000000000000000..869e0e18d0ecbbc0ddeaa2ae987d8cb85e14bd82 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/field_mask.py @@ -0,0 +1,326 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains FieldMask class.""" + +from google.protobuf.descriptor import FieldDescriptor + + +class FieldMask(object): + """Class for FieldMask message type.""" + + __slots__ = () + + def ToJsonString(self): + """Converts FieldMask to string according to ProtoJSON spec.""" + camelcase_paths = [] + for path in self.paths: + camelcase_paths.append(_SnakeCaseToCamelCase(path)) + return ','.join(camelcase_paths) + + def FromJsonString(self, value): + """Converts string to FieldMask according to ProtoJSON spec.""" + if not isinstance(value, str): + raise ValueError('FieldMask JSON value not a string: {!r}'.format(value)) + self.Clear() + if value: + for path in value.split(','): + self.paths.append(_CamelCaseToSnakeCase(path)) + + def IsValidForDescriptor(self, message_descriptor): + """Checks whether the FieldMask is valid for Message Descriptor.""" + for path in self.paths: + if not _IsValidPath(message_descriptor, path): + return False + return True + + def AllFieldsFromDescriptor(self, message_descriptor): + """Gets all direct fields of Message Descriptor to FieldMask.""" + self.Clear() + for field in message_descriptor.fields: + self.paths.append(field.name) + + def CanonicalFormFromMask(self, mask): + """Converts a FieldMask to the canonical form. + + Removes paths that are covered by another path. For example, + "foo.bar" is covered by "foo" and will be removed if "foo" + is also in the FieldMask. Then sorts all paths in alphabetical order. + + Args: + mask: The original FieldMask to be converted. + """ + tree = _FieldMaskTree(mask) + tree.ToFieldMask(self) + + def Union(self, mask1, mask2): + """Merges mask1 and mask2 into this FieldMask.""" + _CheckFieldMaskMessage(mask1) + _CheckFieldMaskMessage(mask2) + tree = _FieldMaskTree(mask1) + tree.MergeFromFieldMask(mask2) + tree.ToFieldMask(self) + + def Intersect(self, mask1, mask2): + """Intersects mask1 and mask2 into this FieldMask.""" + _CheckFieldMaskMessage(mask1) + _CheckFieldMaskMessage(mask2) + tree = _FieldMaskTree(mask1) + intersection = _FieldMaskTree() + for path in mask2.paths: + tree.IntersectPath(path, intersection) + intersection.ToFieldMask(self) + + def MergeMessage( + self, source, destination, + replace_message_field=False, replace_repeated_field=False): + """Merges fields specified in FieldMask from source to destination. + + Args: + source: Source message. + destination: The destination message to be merged into. + replace_message_field: Replace message field if True. Merge message + field if False. + replace_repeated_field: Replace repeated field if True. Append + elements of repeated field if False. + """ + tree = _FieldMaskTree(self) + tree.MergeMessage( + source, destination, replace_message_field, replace_repeated_field) + + +def _IsValidPath(message_descriptor, path): + """Checks whether the path is valid for Message Descriptor.""" + parts = path.split('.') + last = parts.pop() + for name in parts: + field = message_descriptor.fields_by_name.get(name) + if (field is None or + field.is_repeated or + field.type != FieldDescriptor.TYPE_MESSAGE): + return False + message_descriptor = field.message_type + return last in message_descriptor.fields_by_name + + +def _CheckFieldMaskMessage(message): + """Raises ValueError if message is not a FieldMask.""" + message_descriptor = message.DESCRIPTOR + if (message_descriptor.name != 'FieldMask' or + message_descriptor.file.name != 'google/protobuf/field_mask.proto'): + raise ValueError('Message {0} is not a FieldMask.'.format( + message_descriptor.full_name)) + + +def _SnakeCaseToCamelCase(path_name): + """Converts a path name from snake_case to camelCase.""" + result = [] + after_underscore = False + for c in path_name: + if c.isupper(): + raise ValueError( + 'Fail to print FieldMask to Json string: Path name ' + '{0} must not contain uppercase letters.'.format(path_name)) + if after_underscore: + if c.islower(): + result.append(c.upper()) + after_underscore = False + else: + raise ValueError( + 'Fail to print FieldMask to Json string: The ' + 'character after a "_" must be a lowercase letter ' + 'in path name {0}.'.format(path_name)) + elif c == '_': + after_underscore = True + else: + result += c + + if after_underscore: + raise ValueError('Fail to print FieldMask to Json string: Trailing "_" ' + 'in path name {0}.'.format(path_name)) + return ''.join(result) + + +def _CamelCaseToSnakeCase(path_name): + """Converts a field name from camelCase to snake_case.""" + result = [] + for c in path_name: + if c == '_': + raise ValueError('Fail to parse FieldMask: Path name ' + '{0} must not contain "_"s.'.format(path_name)) + if c.isupper(): + result += '_' + result += c.lower() + else: + result += c + return ''.join(result) + + +class _FieldMaskTree(object): + """Represents a FieldMask in a tree structure. + + For example, given a FieldMask "foo.bar,foo.baz,bar.baz", + the FieldMaskTree will be: + [_root] -+- foo -+- bar + | | + | +- baz + | + +- bar --- baz + In the tree, each leaf node represents a field path. + """ + + __slots__ = ('_root',) + + def __init__(self, field_mask=None): + """Initializes the tree by FieldMask.""" + self._root = {} + if field_mask: + self.MergeFromFieldMask(field_mask) + + def MergeFromFieldMask(self, field_mask): + """Merges a FieldMask to the tree.""" + for path in field_mask.paths: + self.AddPath(path) + + def AddPath(self, path): + """Adds a field path into the tree. + + If the field path to add is a sub-path of an existing field path + in the tree (i.e., a leaf node), it means the tree already matches + the given path so nothing will be added to the tree. If the path + matches an existing non-leaf node in the tree, that non-leaf node + will be turned into a leaf node with all its children removed because + the path matches all the node's children. Otherwise, a new path will + be added. + + Args: + path: The field path to add. + """ + node = self._root + for name in path.split('.'): + if name not in node: + node[name] = {} + elif not node[name]: + # Pre-existing empty node implies we already have this entire tree. + return + node = node[name] + # Remove any sub-trees we might have had. + node.clear() + + def ToFieldMask(self, field_mask): + """Converts the tree to a FieldMask.""" + field_mask.Clear() + _AddFieldPaths(self._root, '', field_mask) + + def IntersectPath(self, path, intersection): + """Calculates the intersection part of a field path with this tree. + + Args: + path: The field path to calculates. + intersection: The out tree to record the intersection part. + """ + node = self._root + for name in path.split('.'): + if name not in node: + return + elif not node[name]: + intersection.AddPath(path) + return + node = node[name] + intersection.AddLeafNodes(path, node) + + def AddLeafNodes(self, prefix, node): + """Adds leaf nodes begin with prefix to this tree.""" + if not node: + self.AddPath(prefix) + return + stack = [(prefix, node)] + while stack: + current_prefix, current_node = stack.pop() + if not current_node: + self.AddPath(current_prefix) + continue + for name in current_node: + child_path = current_prefix + '.' + name + stack.append((child_path, current_node[name])) + + def MergeMessage( + self, source, destination, + replace_message, replace_repeated): + """Merge all fields specified by this tree from source to destination.""" + _MergeMessage( + self._root, source, destination, replace_message, replace_repeated) + + +def _StrConvert(value): + """Converts value to str if it is not.""" + # This file is imported by c extension and some methods like ClearField + # requires string for the field name. py2/py3 has different text + # type and may use unicode. + if not isinstance(value, str): + return value.encode('utf-8') + return value + + +def _MergeMessage( + node, source, destination, replace_message, replace_repeated): + """Merge all fields specified by a sub-tree from source to destination.""" + stack = [(node, source, destination)] + while stack: + current_node, current_source, current_destination = stack.pop() + source_descriptor = current_source.DESCRIPTOR + for name in current_node: + child = current_node[name] + field = source_descriptor.fields_by_name[name] + if field is None: + raise ValueError('Error: Can\'t find field {0} in message {1}.'.format( + name, source_descriptor.full_name)) + if child: + # Sub-paths are only allowed for singular message fields. + if (field.is_repeated or + field.cpp_type != FieldDescriptor.CPPTYPE_MESSAGE): + raise ValueError('Error: Field {0} in message {1} is not a singular ' + 'message field and cannot have sub-fields.'.format( + name, source_descriptor.full_name)) + if current_source.HasField(name): + stack.append( + (child, getattr(current_source, name), + getattr(current_destination, name))) + continue + if field.is_repeated: + if replace_repeated: + current_destination.ClearField(_StrConvert(name)) + repeated_source = getattr(current_source, name) + repeated_destination = getattr(current_destination, name) + repeated_destination.MergeFrom(repeated_source) + else: + if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE: + if replace_message: + current_destination.ClearField(_StrConvert(name)) + if current_source.HasField(name): + getattr(current_destination, name).MergeFrom( + getattr(current_source, name)) + elif not field.has_presence or current_source.HasField(name): + setattr(current_destination, name, getattr(current_source, name)) + else: + current_destination.ClearField(_StrConvert(name)) + + +def _AddFieldPaths(node, prefix, field_mask): + """Adds the field paths descended from node to field_mask.""" + stack = [(node, prefix)] + while stack: + current_node, current_prefix = stack.pop() + if not current_node and current_prefix: + field_mask.paths.append(current_prefix) + continue + for name in sorted(current_node, reverse=True): + if current_prefix: + child_path = current_prefix + '.' + name + else: + child_path = name + stack.append((current_node[name], child_path)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/message_listener.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/message_listener.py new file mode 100644 index 0000000000000000000000000000000000000000..ff1c127d549dcd8973fdbe67fda09b9ce3460abe --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/message_listener.py @@ -0,0 +1,55 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Defines a listener interface for observing certain +state transitions on Message objects. + +Also defines a null implementation of this interface. +""" + +__author__ = 'robinson@google.com (Will Robinson)' + + +class MessageListener(object): + + """Listens for modifications made to a message. Meant to be registered via + Message._SetListener(). + + Attributes: + dirty: If True, then calling Modified() would be a no-op. This can be + used to avoid these calls entirely in the common case. + """ + + def Modified(self): + """Called every time the message is modified in such a way that the parent + message may need to be updated. This currently means either: + (a) The message was modified for the first time, so the parent message + should henceforth mark the message as present. + (b) The message's cached byte size became dirty -- i.e. the message was + modified for the first time after a previous call to ByteSize(). + Therefore the parent should also mark its byte size as dirty. + Note that (a) implies (b), since new objects start out with a client cached + size (zero). However, we document (a) explicitly because it is important. + + Modified() will *only* be called in response to one of these two events -- + not every time the sub-message is modified. + + Note that if the listener's |dirty| attribute is true, then calling + Modified at the moment would be a no-op, so it can be skipped. Performance- + sensitive callers should check this attribute directly before calling since + it will be true most of the time. + """ + + raise NotImplementedError + + +class NullMessageListener(object): + + """No-op MessageListener implementation.""" + + def Modified(self): + pass diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/python_edition_defaults.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/python_edition_defaults.py new file mode 100644 index 0000000000000000000000000000000000000000..4a68d1b91cfc8fb2dc3e0dd3b687ced48930e132 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/python_edition_defaults.py @@ -0,0 +1,5 @@ +""" +This file contains the serialized FeatureSetDefaults object corresponding to +the Pure Python runtime. This is used for feature resolution under Editions. +""" +_PROTOBUF_INTERNAL_PYTHON_EDITION_DEFAULTS = b"\n\027\030\204\007\"\000*\020\010\001\020\002\030\002 \003(\0010\0028\002@\001\n\027\030\347\007\"\000*\020\010\002\020\001\030\001 \002(\0010\0018\002@\001\n\027\030\350\007\"\014\010\001\020\001\030\001 \002(\0010\001*\0048\002@\001\n\027\030\351\007\"\020\010\001\020\001\030\001 \002(\0010\0018\001@\002*\000\n\027\030\217N\"\020\010\001\020\001\030\001 \002(\0010\0018\003@\002*\000 \346\007(\351\007" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/python_message.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/python_message.py new file mode 100644 index 0000000000000000000000000000000000000000..8148358f039ed43ab3b21621d6e8fa4cdf53ec3c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/python_message.py @@ -0,0 +1,1602 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +# This code is meant to work on Python 2.4 and above only. +# +# TODO: Helpers for verbose, common checks like seeing if a +# descriptor's cpp_type is CPPTYPE_MESSAGE. + +"""Contains a metaclass and helper functions used to create +protocol message classes from Descriptor objects at runtime. + +Recall that a metaclass is the "type" of a class. +(A class is to a metaclass what an instance is to a class.) + +In this case, we use the GeneratedProtocolMessageType metaclass +to inject all the useful functionality into the classes +output by the protocol compiler at compile-time. + +The upshot of all this is that the real implementation +details for ALL pure-Python protocol buffers are *here in +this file*. +""" + +__author__ = 'robinson@google.com (Will Robinson)' + +import datetime +from io import BytesIO +import math +import struct +import sys +import warnings +import weakref + +from google.protobuf import descriptor as descriptor_mod +from google.protobuf import message as message_mod +from google.protobuf import text_format +# We use "as" to avoid name collisions with variables. +from google.protobuf.internal import api_implementation +from google.protobuf.internal import containers +from google.protobuf.internal import decoder +from google.protobuf.internal import encoder +from google.protobuf.internal import enum_type_wrapper +from google.protobuf.internal import extension_dict +from google.protobuf.internal import message_listener as message_listener_mod +from google.protobuf.internal import type_checkers +from google.protobuf.internal import well_known_types +from google.protobuf.internal import wire_format + +_FieldDescriptor = descriptor_mod.FieldDescriptor +_AnyFullTypeName = 'google.protobuf.Any' +_StructFullTypeName = 'google.protobuf.Struct' +_ListValueFullTypeName = 'google.protobuf.ListValue' +_ExtensionDict = extension_dict._ExtensionDict + +class GeneratedProtocolMessageType(type): + + """Metaclass for protocol message classes created at runtime from Descriptors. + + We add implementations for all methods described in the Message class. We + also create properties to allow getting/setting all fields in the protocol + message. Finally, we create slots to prevent users from accidentally + "setting" nonexistent fields in the protocol message, which then wouldn't get + serialized / deserialized properly. + + The protocol compiler currently uses this metaclass to create protocol + message classes at runtime. Clients can also manually create their own + classes at runtime, as in this example: + + mydescriptor = Descriptor(.....) + factory = symbol_database.Default() + factory.pool.AddDescriptor(mydescriptor) + MyProtoClass = message_factory.GetMessageClass(mydescriptor) + myproto_instance = MyProtoClass() + myproto.foo_field = 23 + ... + """ + + # Must be consistent with the protocol-compiler code in + # proto2/compiler/internal/generator.*. + _DESCRIPTOR_KEY = 'DESCRIPTOR' + + def __new__(cls, name, bases, dictionary): + """Custom allocation for runtime-generated class types. + + We override __new__ because this is apparently the only place + where we can meaningfully set __slots__ on the class we're creating(?). + (The interplay between metaclasses and slots is not very well-documented). + + Args: + name: Name of the class (ignored, but required by the + metaclass protocol). + bases: Base classes of the class we're constructing. + (Should be message.Message). We ignore this field, but + it's required by the metaclass protocol + dictionary: The class dictionary of the class we're + constructing. dictionary[_DESCRIPTOR_KEY] must contain + a Descriptor object describing this protocol message + type. + + Returns: + Newly-allocated class. + + Raises: + RuntimeError: Generated code only work with python cpp extension. + """ + descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY] + + if isinstance(descriptor, str): + raise RuntimeError('The generated code only work with python cpp ' + 'extension, but it is using pure python runtime.') + + # If a concrete class already exists for this descriptor, don't try to + # create another. Doing so will break any messages that already exist with + # the existing class. + # + # The C++ implementation appears to have its own internal `PyMessageFactory` + # to achieve similar results. + # + # This most commonly happens in `text_format.py` when using descriptors from + # a custom pool; it calls message_factory.GetMessageClass() on a + # descriptor which already has an existing concrete class. + new_class = getattr(descriptor, '_concrete_class', None) + if new_class: + return new_class + + if descriptor.full_name in well_known_types.WKTBASES: + bases += (well_known_types.WKTBASES[descriptor.full_name],) + _AddClassAttributesForNestedExtensions(descriptor, dictionary) + _AddSlots(descriptor, dictionary) + + superclass = super(GeneratedProtocolMessageType, cls) + new_class = superclass.__new__(cls, name, bases, dictionary) + return new_class + + def __init__(cls, name, bases, dictionary): + """Here we perform the majority of our work on the class. + We add enum getters, an __init__ method, implementations + of all Message methods, and properties for all fields + in the protocol type. + + Args: + name: Name of the class (ignored, but required by the + metaclass protocol). + bases: Base classes of the class we're constructing. + (Should be message.Message). We ignore this field, but + it's required by the metaclass protocol + dictionary: The class dictionary of the class we're + constructing. dictionary[_DESCRIPTOR_KEY] must contain + a Descriptor object describing this protocol message + type. + """ + descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY] + + # If this is an _existing_ class looked up via `_concrete_class` in the + # __new__ method above, then we don't need to re-initialize anything. + existing_class = getattr(descriptor, '_concrete_class', None) + if existing_class: + assert existing_class is cls, ( + 'Duplicate `GeneratedProtocolMessageType` created for descriptor %r' + % (descriptor.full_name)) + return + + cls._message_set_decoders_by_tag = {} + cls._fields_by_tag = {} + if (descriptor.has_options and + descriptor.GetOptions().message_set_wire_format): + cls._message_set_decoders_by_tag[decoder.MESSAGE_SET_ITEM_TAG] = ( + decoder.MessageSetItemDecoder(descriptor), + None, + ) + + # Attach stuff to each FieldDescriptor for quick lookup later on. + for field in descriptor.fields: + _AttachFieldHelpers(cls, field) + + if descriptor.is_extendable and hasattr(descriptor.file, 'pool'): + extensions = descriptor.file.pool.FindAllExtensions(descriptor) + for ext in extensions: + _AttachFieldHelpers(cls, ext) + + descriptor._concrete_class = cls # pylint: disable=protected-access + _AddEnumValues(descriptor, cls) + _AddInitMethod(descriptor, cls) + _AddPropertiesForFields(descriptor, cls) + _AddPropertiesForExtensions(descriptor, cls) + _AddStaticMethods(cls) + _AddMessageMethods(descriptor, cls) + _AddPrivateHelperMethods(descriptor, cls) + + superclass = super(GeneratedProtocolMessageType, cls) + superclass.__init__(name, bases, dictionary) + + +# Stateless helpers for GeneratedProtocolMessageType below. +# Outside clients should not access these directly. +# +# I opted not to make any of these methods on the metaclass, to make it more +# clear that I'm not really using any state there and to keep clients from +# thinking that they have direct access to these construction helpers. + + +def _PropertyName(proto_field_name): + """Returns the name of the public property attribute which + clients can use to get and (in some cases) set the value + of a protocol message field. + + Args: + proto_field_name: The protocol message field name, exactly + as it appears (or would appear) in a .proto file. + """ + # TODO: Escape Python keywords (e.g., yield), and test this support. + # nnorwitz makes my day by writing: + # """ + # FYI. See the keyword module in the stdlib. This could be as simple as: + # + # if keyword.iskeyword(proto_field_name): + # return proto_field_name + "_" + # return proto_field_name + # """ + # Kenton says: The above is a BAD IDEA. People rely on being able to use + # getattr() and setattr() to reflectively manipulate field values. If we + # rename the properties, then every such user has to also make sure to apply + # the same transformation. Note that currently if you name a field "yield", + # you can still access it just fine using getattr/setattr -- it's not even + # that cumbersome to do so. + # TODO: Remove this method entirely if/when everyone agrees with my + # position. + return proto_field_name + + +def _AddSlots(message_descriptor, dictionary): + """Adds a __slots__ entry to dictionary, containing the names of all valid + attributes for this message type. + + Args: + message_descriptor: A Descriptor instance describing this message type. + dictionary: Class dictionary to which we'll add a '__slots__' entry. + """ + dictionary['__slots__'] = ['_cached_byte_size', + '_cached_byte_size_dirty', + '_fields', + '_unknown_fields', + '_is_present_in_parent', + '_listener', + '_listener_for_children', + '__weakref__', + '_oneofs'] + + +def _IsMessageSetExtension(field): + return (field.is_extension and + field.containing_type.has_options and + field.containing_type.GetOptions().message_set_wire_format and + field.type == _FieldDescriptor.TYPE_MESSAGE and + not field.is_required and + not field.is_repeated) + + +def _IsMapField(field): + return (field.type == _FieldDescriptor.TYPE_MESSAGE and + field.message_type._is_map_entry) + + +def _IsMessageMapField(field): + value_type = field.message_type.fields_by_name['value'] + return value_type.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE + +def _AttachFieldHelpers(cls, field_descriptor): + field_descriptor._default_constructor = _DefaultValueConstructorForField( + field_descriptor + ) + + def AddFieldByTag(wiretype, is_packed): + tag_bytes = encoder.TagBytes(field_descriptor.number, wiretype) + cls._fields_by_tag[tag_bytes] = (field_descriptor, is_packed) + + AddFieldByTag( + type_checkers.FIELD_TYPE_TO_WIRE_TYPE[field_descriptor.type], False + ) + + if field_descriptor.is_repeated and wire_format.IsTypePackable( + field_descriptor.type + ): + # To support wire compatibility of adding packed = true, add a decoder for + # packed values regardless of the field's options. + AddFieldByTag(wire_format.WIRETYPE_LENGTH_DELIMITED, True) + + +def _MaybeAddEncoder(cls, field_descriptor): + if hasattr(field_descriptor, '_encoder'): + return + is_repeated = field_descriptor.is_repeated + is_map_entry = _IsMapField(field_descriptor) + is_packed = field_descriptor.is_packed + + if is_map_entry: + field_encoder = encoder.MapEncoder(field_descriptor) + sizer = encoder.MapSizer(field_descriptor, + _IsMessageMapField(field_descriptor)) + elif _IsMessageSetExtension(field_descriptor): + field_encoder = encoder.MessageSetItemEncoder(field_descriptor.number) + sizer = encoder.MessageSetItemSizer(field_descriptor.number) + else: + field_encoder = type_checkers.TYPE_TO_ENCODER[field_descriptor.type]( + field_descriptor.number, is_repeated, is_packed) + sizer = type_checkers.TYPE_TO_SIZER[field_descriptor.type]( + field_descriptor.number, is_repeated, is_packed) + + field_descriptor._sizer = sizer + field_descriptor._encoder = field_encoder + + +def _MaybeAddDecoder(cls, field_descriptor): + if hasattr(field_descriptor, '_decoders'): + return + + is_repeated = field_descriptor.is_repeated + is_map_entry = _IsMapField(field_descriptor) + helper_decoders = {} + + def AddDecoder(is_packed): + decode_type = field_descriptor.type + if (decode_type == _FieldDescriptor.TYPE_ENUM and + not field_descriptor.enum_type.is_closed): + decode_type = _FieldDescriptor.TYPE_INT32 + + oneof_descriptor = None + if field_descriptor.containing_oneof is not None: + oneof_descriptor = field_descriptor + + if is_map_entry: + is_message_map = _IsMessageMapField(field_descriptor) + + field_decoder = decoder.MapDecoder( + field_descriptor, _GetInitializeDefaultForMap(field_descriptor), + is_message_map) + elif decode_type == _FieldDescriptor.TYPE_STRING: + field_decoder = decoder.StringDecoder( + field_descriptor.number, is_repeated, is_packed, + field_descriptor, field_descriptor._default_constructor, + not field_descriptor.has_presence) + elif field_descriptor.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + field_decoder = type_checkers.TYPE_TO_DECODER[decode_type]( + field_descriptor.number, is_repeated, is_packed, + field_descriptor, field_descriptor._default_constructor) + else: + field_decoder = type_checkers.TYPE_TO_DECODER[decode_type]( + field_descriptor.number, is_repeated, is_packed, + # pylint: disable=protected-access + field_descriptor, field_descriptor._default_constructor, + not field_descriptor.has_presence) + + helper_decoders[is_packed] = field_decoder + + AddDecoder(False) + + if is_repeated and wire_format.IsTypePackable(field_descriptor.type): + # To support wire compatibility of adding packed = true, add a decoder for + # packed values regardless of the field's options. + AddDecoder(True) + + field_descriptor._decoders = helper_decoders + + +def _AddClassAttributesForNestedExtensions(descriptor, dictionary): + extensions = descriptor.extensions_by_name + for extension_name, extension_field in extensions.items(): + assert extension_name not in dictionary + dictionary[extension_name] = extension_field + + +def _AddEnumValues(descriptor, cls): + """Sets class-level attributes for all enum fields defined in this message. + + Also exporting a class-level object that can name enum values. + + Args: + descriptor: Descriptor object for this message type. + cls: Class we're constructing for this message type. + """ + for enum_type in descriptor.enum_types: + setattr(cls, enum_type.name, enum_type_wrapper.EnumTypeWrapper(enum_type)) + for enum_value in enum_type.values: + setattr(cls, enum_value.name, enum_value.number) + + +def _GetInitializeDefaultForMap(field): + if not field.is_repeated: + raise ValueError('map_entry set on non-repeated field %s' % ( + field.name)) + fields_by_name = field.message_type.fields_by_name + key_checker = type_checkers.GetTypeChecker(fields_by_name['key']) + + value_field = fields_by_name['value'] + if _IsMessageMapField(field): + def MakeMessageMapDefault(message): + return containers.MessageMap( + message._listener_for_children, value_field.message_type, key_checker, + field.message_type) + return MakeMessageMapDefault + else: + value_checker = type_checkers.GetTypeChecker(value_field) + def MakePrimitiveMapDefault(message): + return containers.ScalarMap( + message._listener_for_children, key_checker, value_checker, + field.message_type) + return MakePrimitiveMapDefault + +def _DefaultValueConstructorForField(field): + """Returns a function which returns a default value for a field. + + Args: + field: FieldDescriptor object for this field. + + The returned function has one argument: + message: Message instance containing this field, or a weakref proxy + of same. + + That function in turn returns a default value for this field. The default + value may refer back to |message| via a weak reference. + """ + + if _IsMapField(field): + return _GetInitializeDefaultForMap(field) + + if field.is_repeated: + if field.has_default_value and field.default_value != []: + raise ValueError('Repeated field default value not empty list: %s' % ( + field.default_value)) + if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + # We can't look at _concrete_class yet since it might not have + # been set. (Depends on order in which we initialize the classes). + message_type = field.message_type + def MakeRepeatedMessageDefault(message): + return containers.RepeatedCompositeFieldContainer( + message._listener_for_children, field.message_type) + return MakeRepeatedMessageDefault + else: + type_checker = type_checkers.GetTypeChecker(field) + def MakeRepeatedScalarDefault(message): + return containers.RepeatedScalarFieldContainer( + message._listener_for_children, type_checker, field + ) + return MakeRepeatedScalarDefault + + if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + message_type = field.message_type + def MakeSubMessageDefault(message): + # _concrete_class may not yet be initialized. + if not hasattr(message_type, '_concrete_class'): + from google.protobuf import message_factory + message_factory.GetMessageClass(message_type) + result = message_type._concrete_class() + result._SetListener( + _OneofListener(message, field) + if field.containing_oneof is not None + else message._listener_for_children) + return result + return MakeSubMessageDefault + + def MakeScalarDefault(message): + # TODO: This may be broken since there may not be + # default_value. Combine with has_default_value somehow. + return field.default_value + return MakeScalarDefault + + +def _ReraiseTypeErrorWithFieldName(message_name, field_name): + """Re-raise the currently-handled TypeError with the field name added.""" + exc = sys.exc_info()[1] + if len(exc.args) == 1 and type(exc) is TypeError: + # simple TypeError; add field name to exception message + exc = TypeError('%s for field %s.%s' % (str(exc), message_name, field_name)) + + # re-raise possibly-amended exception with original traceback: + raise exc.with_traceback(sys.exc_info()[2]) + + +def _AddInitMethod(message_descriptor, cls): + """Adds an __init__ method to cls.""" + + def _GetIntegerEnumValue(enum_type, value): + """Convert a string or integer enum value to an integer. + + If the value is a string, it is converted to the enum value in + enum_type with the same name. If the value is not a string, it's + returned as-is. (No conversion or bounds-checking is done.) + """ + if isinstance(value, str): + try: + return enum_type.values_by_name[value].number + except KeyError: + raise ValueError('Enum type %s: unknown label "%s"' % ( + enum_type.full_name, value)) + return value + + def init(self, **kwargs): + + def init_wkt_or_merge(field, msg, value): + if isinstance(value, message_mod.Message): + msg.MergeFrom(value) + elif ( + isinstance(value, dict) + and field.message_type.full_name == _StructFullTypeName + ): + msg.Clear() + if len(value) == 1 and 'fields' in value: + try: + msg.update(value) + except: + msg.Clear() + msg.__init__(**value) + else: + msg.update(value) + elif hasattr(msg, '_internal_assign'): + msg._internal_assign(value) + else: + raise TypeError( + 'Message field {0}.{1} must be initialized with a ' + 'dict or instance of same class, got {2}.'.format( + message_descriptor.name, + field.name, + type(value).__name__, + ) + ) + + self._cached_byte_size = 0 + self._cached_byte_size_dirty = len(kwargs) > 0 + self._fields = {} + # Contains a mapping from oneof field descriptors to the descriptor + # of the currently set field in that oneof field. + self._oneofs = {} + + # _unknown_fields is () when empty for efficiency, and will be turned into + # a list if fields are added. + self._unknown_fields = () + self._is_present_in_parent = False + self._listener = message_listener_mod.NullMessageListener() + self._listener_for_children = _Listener(self) + for field_name, field_value in kwargs.items(): + field = _GetFieldByName(message_descriptor, field_name) + if field is None: + raise TypeError('%s() got an unexpected keyword argument "%s"' % + (message_descriptor.name, field_name)) + if field_value is None: + # field=None is the same as no field at all. + continue + if field.is_repeated: + field_copy = field._default_constructor(self) + if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: # Composite + if _IsMapField(field): + if _IsMessageMapField(field): + for key in field_value: + item_value = field_value[key] + if isinstance(item_value, dict): + field_copy[key].__init__(**item_value) + else: + field_copy[key].MergeFrom(item_value) + else: + field_copy.update(field_value) + else: + for val in field_value: + if isinstance(val, dict) and ( + field.message_type.full_name != _StructFullTypeName + ): + field_copy.add(**val) + else: + new_msg = field_copy.add() + init_wkt_or_merge(field, new_msg, val) + else: # Scalar + if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM: + field_value = [_GetIntegerEnumValue(field.enum_type, val) + for val in field_value] + field_copy.extend(field_value) + self._fields[field] = field_copy + elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + field_copy = field._default_constructor(self) + if isinstance(field_value, dict) and ( + field.message_type.full_name != _StructFullTypeName + ): + new_val = field.message_type._concrete_class(**field_value) + field_copy.MergeFrom(new_val) + else: + try: + init_wkt_or_merge(field, field_copy, field_value) + except TypeError: + _ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name) + self._fields[field] = field_copy + else: + if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM: + field_value = _GetIntegerEnumValue(field.enum_type, field_value) + try: + setattr(self, field_name, field_value) + except TypeError: + _ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name) + + init.__module__ = None + init.__doc__ = None + cls.__init__ = init + + +def _GetFieldByName(message_descriptor, field_name): + """Returns a field descriptor by field name. + + Args: + message_descriptor: A Descriptor describing all fields in message. + field_name: The name of the field to retrieve. + Returns: + The field descriptor associated with the field name. + """ + try: + return message_descriptor.fields_by_name[field_name] + except KeyError: + raise ValueError('Protocol message %s has no "%s" field.' % + (message_descriptor.name, field_name)) + + +def _AddPropertiesForFields(descriptor, cls): + """Adds properties for all fields in this protocol message type.""" + for field in descriptor.fields: + _AddPropertiesForField(field, cls) + + if descriptor.is_extendable: + # _ExtensionDict is just an adaptor with no state so we allocate a new one + # every time it is accessed. + cls.Extensions = property(lambda self: _ExtensionDict(self)) + + +def _AddPropertiesForField(field, cls): + """Adds a public property for a protocol message field. + Clients can use this property to get and (in the case + of non-repeated scalar fields) directly set the value + of a protocol message field. + + Args: + field: A FieldDescriptor for this field. + cls: The class we're constructing. + """ + # Catch it if we add other types that we should + # handle specially here. + assert _FieldDescriptor.MAX_CPPTYPE == 10 + + constant_name = field.name.upper() + '_FIELD_NUMBER' + setattr(cls, constant_name, field.number) + + if field.is_repeated: + _AddPropertiesForRepeatedField(field, cls) + elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + _AddPropertiesForNonRepeatedCompositeField(field, cls) + else: + _AddPropertiesForNonRepeatedScalarField(field, cls) + + +class _FieldProperty(property): + __slots__ = ('DESCRIPTOR',) + + def __init__(self, descriptor, getter, setter, doc): + property.__init__(self, getter, setter, doc=doc) + self.DESCRIPTOR = descriptor + + +def _AddPropertiesForRepeatedField(field, cls): + """Adds a public property for a "repeated" protocol message field. Clients + can use this property to get the value of the field, which will be either a + RepeatedScalarFieldContainer or RepeatedCompositeFieldContainer (see + below). + + Note that when clients add values to these containers, we perform + type-checking in the case of repeated scalar fields, and we also set any + necessary "has" bits as a side-effect. + + Args: + field: A FieldDescriptor for this field. + cls: The class we're constructing. + """ + proto_field_name = field.name + property_name = _PropertyName(proto_field_name) + + def getter(self): + field_value = self._fields.get(field) + if field_value is None: + # Construct a new object to represent this field. + field_value = field._default_constructor(self) + + # Atomically check if another thread has preempted us and, if not, swap + # in the new object we just created. If someone has preempted us, we + # take that object and discard ours. + # WARNING: We are relying on setdefault() being atomic. This is true + # in CPython but we haven't investigated others. This warning appears + # in several other locations in this file. + field_value = self._fields.setdefault(field, field_value) + return field_value + getter.__module__ = None + getter.__doc__ = 'Getter for %s.' % proto_field_name + + # We define a setter just so we can throw an exception with a more + # helpful error message. + def setter(self, new_value): + raise AttributeError('Assignment not allowed to repeated field ' + '"%s" in protocol message object.' % proto_field_name) + + doc = 'Magic attribute generated for "%s" proto field.' % proto_field_name + setattr(cls, property_name, _FieldProperty(field, getter, setter, doc=doc)) + + +def _AddPropertiesForNonRepeatedScalarField(field, cls): + """Adds a public property for a nonrepeated, scalar protocol message field. + Clients can use this property to get and directly set the value of the field. + Note that when the client sets the value of a field by using this property, + all necessary "has" bits are set as a side-effect, and we also perform + type-checking. + + Args: + field: A FieldDescriptor for this field. + cls: The class we're constructing. + """ + proto_field_name = field.name + property_name = _PropertyName(proto_field_name) + type_checker = type_checkers.GetTypeChecker(field) + default_value = field.default_value + + def getter(self): + # TODO: This may be broken since there may not be + # default_value. Combine with has_default_value somehow. + return self._fields.get(field, default_value) + getter.__module__ = None + getter.__doc__ = 'Getter for %s.' % proto_field_name + + def field_setter(self, new_value): + # pylint: disable=protected-access + # Testing the value for truthiness captures all of the implicit presence + # defaults (0, 0.0, enum 0, and False), except for -0.0. + try: + new_value = type_checker.CheckValue(new_value) + except TypeError as e: + raise TypeError( + 'Cannot set %s to %.1024r: %s' % (field.full_name, new_value, e)) + if not field.has_presence and decoder.IsDefaultScalarValue(new_value): + self._fields.pop(field, None) + else: + self._fields[field] = new_value + # Check _cached_byte_size_dirty inline to improve performance, since scalar + # setters are called frequently. + if not self._cached_byte_size_dirty: + self._Modified() + + if field.containing_oneof: + def setter(self, new_value): + field_setter(self, new_value) + self._UpdateOneofState(field) + else: + setter = field_setter + + setter.__module__ = None + setter.__doc__ = 'Setter for %s.' % proto_field_name + + # Add a property to encapsulate the getter/setter. + doc = 'Magic attribute generated for "%s" proto field.' % proto_field_name + setattr(cls, property_name, _FieldProperty(field, getter, setter, doc=doc)) + + +def _AddPropertiesForNonRepeatedCompositeField(field, cls): + """Adds a public property for a nonrepeated, composite protocol message field. + A composite field is a "group" or "message" field. + + Clients can use this property to get the value of the field, but cannot + assign to the property directly. + + Args: + field: A FieldDescriptor for this field. + cls: The class we're constructing. + """ + # TODO: Remove duplication with similar method + # for non-repeated scalars. + proto_field_name = field.name + property_name = _PropertyName(proto_field_name) + + def getter(self): + field_value = self._fields.get(field) + if field_value is None: + # Construct a new object to represent this field. + field_value = field._default_constructor(self) + + # Atomically check if another thread has preempted us and, if not, swap + # in the new object we just created. If someone has preempted us, we + # take that object and discard ours. + # WARNING: We are relying on setdefault() being atomic. This is true + # in CPython but we haven't investigated others. This warning appears + # in several other locations in this file. + field_value = self._fields.setdefault(field, field_value) + return field_value + getter.__module__ = None + getter.__doc__ = 'Getter for %s.' % proto_field_name + + # We define a setter just so we can throw an exception with a more + # helpful error message. + def setter(self, new_value): + if field.message_type.full_name == 'google.protobuf.Timestamp': + getter(self) + self._fields[field].FromDatetime(new_value) + elif field.message_type.full_name == 'google.protobuf.Duration': + getter(self) + self._fields[field].FromTimedelta(new_value) + elif field.message_type.full_name == _StructFullTypeName: + getter(self) + self._fields[field].Clear() + self._fields[field].update(new_value) + elif field.message_type.full_name == _ListValueFullTypeName: + getter(self) + self._fields[field].Clear() + self._fields[field].extend(new_value) + else: + raise AttributeError( + 'Assignment not allowed to composite field ' + '"%s" in protocol message object.' % proto_field_name + ) + + # Add a property to encapsulate the getter. + doc = 'Magic attribute generated for "%s" proto field.' % proto_field_name + setattr(cls, property_name, _FieldProperty(field, getter, setter, doc=doc)) + + +def _AddPropertiesForExtensions(descriptor, cls): + """Adds properties for all fields in this protocol message type.""" + extensions = descriptor.extensions_by_name + for extension_name, extension_field in extensions.items(): + constant_name = extension_name.upper() + '_FIELD_NUMBER' + setattr(cls, constant_name, extension_field.number) + + # TODO: Migrate all users of these attributes to functions like + # pool.FindExtensionByNumber(descriptor). + if descriptor.file is not None: + # TODO: Use cls.MESSAGE_FACTORY.pool when available. + pool = descriptor.file.pool + +def _AddStaticMethods(cls): + + def RegisterExtension(_): + """no-op to keep generated code <=4.23 working with new runtimes.""" + # This was originally removed in 5.26 (cl/595989309). + pass + + cls.RegisterExtension = staticmethod(RegisterExtension) + def FromString(s): + message = cls() + message.MergeFromString(s) + return message + cls.FromString = staticmethod(FromString) + + +def _IsPresent(item): + """Given a (FieldDescriptor, value) tuple from _fields, return true if the + value should be included in the list returned by ListFields().""" + + if item[0].is_repeated: + return bool(item[1]) + elif item[0].cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + return item[1]._is_present_in_parent + else: + return True + + +def _AddListFieldsMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + + def ListFields(self): + all_fields = [item for item in self._fields.items() if _IsPresent(item)] + all_fields.sort(key = lambda item: item[0].number) + return all_fields + + cls.ListFields = ListFields + + +def _AddHasFieldMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + + hassable_fields = {} + for field in message_descriptor.fields: + if field.is_repeated: + continue + # For proto3, only submessages and fields inside a oneof have presence. + if not field.has_presence: + continue + hassable_fields[field.name] = field + + # Has methods are supported for oneof descriptors. + for oneof in message_descriptor.oneofs: + hassable_fields[oneof.name] = oneof + + def HasField(self, field_name): + try: + field = hassable_fields[field_name] + except KeyError as exc: + raise ValueError('Protocol message %s has no non-repeated field "%s" ' + 'nor has presence is not available for this field.' % ( + message_descriptor.full_name, field_name)) from exc + + if isinstance(field, descriptor_mod.OneofDescriptor): + try: + return HasField(self, self._oneofs[field].name) + except KeyError: + return False + else: + if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + value = self._fields.get(field) + return value is not None and value._is_present_in_parent + else: + return field in self._fields + + cls.HasField = HasField + + +def _AddClearFieldMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + def ClearField(self, field_name): + try: + field = message_descriptor.fields_by_name[field_name] + except KeyError: + try: + field = message_descriptor.oneofs_by_name[field_name] + if field in self._oneofs: + field = self._oneofs[field] + else: + return + except KeyError: + raise ValueError('Protocol message %s has no "%s" field.' % + (message_descriptor.name, field_name)) + + if field in self._fields: + # To match the C++ implementation, we need to invalidate iterators + # for map fields when ClearField() happens. + if hasattr(self._fields[field], 'InvalidateIterators'): + self._fields[field].InvalidateIterators() + + # Note: If the field is a sub-message, its listener will still point + # at us. That's fine, because the worst than can happen is that it + # will call _Modified() and invalidate our byte size. Big deal. + del self._fields[field] + + if self._oneofs.get(field.containing_oneof, None) is field: + del self._oneofs[field.containing_oneof] + + # Always call _Modified() -- even if nothing was changed, this is + # a mutating method, and thus calling it should cause the field to become + # present in the parent message. + self._Modified() + + cls.ClearField = ClearField + + +def _AddClearExtensionMethod(cls): + """Helper for _AddMessageMethods().""" + def ClearExtension(self, field_descriptor): + extension_dict._VerifyExtensionHandle(self, field_descriptor) + + # Similar to ClearField(), above. + if field_descriptor in self._fields: + del self._fields[field_descriptor] + self._Modified() + cls.ClearExtension = ClearExtension + + +def _AddHasExtensionMethod(cls): + """Helper for _AddMessageMethods().""" + def HasExtension(self, field_descriptor): + extension_dict._VerifyExtensionHandle(self, field_descriptor) + if field_descriptor.is_repeated: + raise KeyError('"%s" is repeated.' % field_descriptor.full_name) + + if field_descriptor.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + value = self._fields.get(field_descriptor) + return value is not None and value._is_present_in_parent + else: + return field_descriptor in self._fields + cls.HasExtension = HasExtension + +def _InternalUnpackAny(msg): + """Unpacks Any message and returns the unpacked message. + + This internal method is different from public Any Unpack method which takes + the target message as argument. _InternalUnpackAny method does not have + target message type and need to find the message type in descriptor pool. + + Args: + msg: An Any message to be unpacked. + + Returns: + The unpacked message. + """ + # TODO: Don't use the factory of generated messages. + # To make Any work with custom factories, use the message factory of the + # parent message. + # pylint: disable=g-import-not-at-top + from google.protobuf import symbol_database + factory = symbol_database.Default() + + type_url = msg.type_url + + if not type_url: + return None + + # TODO: For now we just strip the hostname. Better logic will be + # required. + type_name = type_url.split('/')[-1] + descriptor = factory.pool.FindMessageTypeByName(type_name) + + if descriptor is None: + return None + + # Unable to import message_factory at top because of circular import. + # pylint: disable=g-import-not-at-top + from google.protobuf import message_factory + message_class = message_factory.GetMessageClass(descriptor) + message = message_class() + + message.ParseFromString(msg.value) + return message + + +def _AddEqualsMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + def __eq__(self, other): + if self.DESCRIPTOR.full_name == _ListValueFullTypeName and isinstance( + other, list + ): + return self._internal_compare(other) + if self.DESCRIPTOR.full_name == _StructFullTypeName and isinstance( + other, dict + ): + return self._internal_compare(other) + + if (not isinstance(other, message_mod.Message) or + other.DESCRIPTOR != self.DESCRIPTOR): + return NotImplemented + + if self is other: + return True + + if self.DESCRIPTOR.full_name == _AnyFullTypeName: + any_a = _InternalUnpackAny(self) + any_b = _InternalUnpackAny(other) + if any_a and any_b: + return any_a == any_b + + if not self.ListFields() == other.ListFields(): + return False + + # TODO: Fix UnknownFieldSet to consider MessageSet extensions, + # then use it for the comparison. + unknown_fields = list(self._unknown_fields) + unknown_fields.sort() + other_unknown_fields = list(other._unknown_fields) + other_unknown_fields.sort() + return unknown_fields == other_unknown_fields + + cls.__eq__ = __eq__ + + +def _AddStrMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + def __str__(self): + return text_format.MessageToString(self) + cls.__str__ = __str__ + + +def _AddReprMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + def __repr__(self): + return text_format.MessageToString(self) + cls.__repr__ = __repr__ + + +def _AddUnicodeMethod(unused_message_descriptor, cls): + """Helper for _AddMessageMethods().""" + + def __unicode__(self): + return text_format.MessageToString(self, as_utf8=True).decode('utf-8') + cls.__unicode__ = __unicode__ + + +def _AddContainsMethod(message_descriptor, cls): + + if message_descriptor.full_name == 'google.protobuf.Struct': + def __contains__(self, key): + return key in self.fields + elif message_descriptor.full_name == 'google.protobuf.ListValue': + def __contains__(self, value): + return value in self.items() + else: + def __contains__(self, field): + return self.HasField(field) + + cls.__contains__ = __contains__ + + +def _BytesForNonRepeatedElement(value, field_number, field_type): + """Returns the number of bytes needed to serialize a non-repeated element. + The returned byte count includes space for tag information and any + other additional space associated with serializing value. + + Args: + value: Value we're serializing. + field_number: Field number of this value. (Since the field number + is stored as part of a varint-encoded tag, this has an impact + on the total bytes required to serialize the value). + field_type: The type of the field. One of the TYPE_* constants + within FieldDescriptor. + """ + try: + fn = type_checkers.TYPE_TO_BYTE_SIZE_FN[field_type] + return fn(field_number, value) + except KeyError: + raise message_mod.EncodeError('Unrecognized field type: %d' % field_type) + + +def _AddByteSizeMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + + def ByteSize(self): + if not self._cached_byte_size_dirty: + return self._cached_byte_size + + size = 0 + descriptor = self.DESCRIPTOR + if descriptor._is_map_entry: + # Fields of map entry should always be serialized. + key_field = descriptor.fields_by_name['key'] + _MaybeAddEncoder(cls, key_field) + size = key_field._sizer(self.key) + value_field = descriptor.fields_by_name['value'] + _MaybeAddEncoder(cls, value_field) + size += value_field._sizer(self.value) + else: + for field_descriptor, field_value in self.ListFields(): + _MaybeAddEncoder(cls, field_descriptor) + size += field_descriptor._sizer(field_value) + for tag_bytes, value_bytes in self._unknown_fields: + size += len(tag_bytes) + len(value_bytes) + + self._cached_byte_size = size + self._cached_byte_size_dirty = False + self._listener_for_children.dirty = False + return size + + cls.ByteSize = ByteSize + + +def _AddSerializeToStringMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + + def SerializeToString(self, **kwargs): + # Check if the message has all of its required fields set. + if not self.IsInitialized(): + raise message_mod.EncodeError( + 'Message %s is missing required fields: %s' % ( + self.DESCRIPTOR.full_name, ','.join(self.FindInitializationErrors()))) + return self.SerializePartialToString(**kwargs) + cls.SerializeToString = SerializeToString + + +def _AddSerializePartialToStringMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + + def SerializePartialToString(self, **kwargs): + out = BytesIO() + self._InternalSerialize(out.write, **kwargs) + return out.getvalue() + cls.SerializePartialToString = SerializePartialToString + + def InternalSerialize(self, write_bytes, deterministic=None): + if deterministic is None: + deterministic = ( + api_implementation.IsPythonDefaultSerializationDeterministic()) + else: + deterministic = bool(deterministic) + + descriptor = self.DESCRIPTOR + if descriptor._is_map_entry: + # Fields of map entry should always be serialized. + key_field = descriptor.fields_by_name['key'] + _MaybeAddEncoder(cls, key_field) + key_field._encoder(write_bytes, self.key, deterministic) + value_field = descriptor.fields_by_name['value'] + _MaybeAddEncoder(cls, value_field) + value_field._encoder(write_bytes, self.value, deterministic) + else: + for field_descriptor, field_value in self.ListFields(): + _MaybeAddEncoder(cls, field_descriptor) + field_descriptor._encoder(write_bytes, field_value, deterministic) + for tag_bytes, value_bytes in self._unknown_fields: + write_bytes(tag_bytes) + write_bytes(value_bytes) + cls._InternalSerialize = InternalSerialize + + +def _AddMergeFromStringMethod(message_descriptor, cls): + """Helper for _AddMessageMethods().""" + def MergeFromString(self, serialized): + serialized = memoryview(serialized) + length = len(serialized) + try: + if self._InternalParse(serialized, 0, length) != length: + # The only reason _InternalParse would return early is if it + # encountered an end-group tag. + raise message_mod.DecodeError('Unexpected end-group tag.') + except (IndexError, TypeError): + # Now ord(buf[p:p+1]) == ord('') gets TypeError. + raise message_mod.DecodeError('Truncated message.') + except struct.error as e: + raise message_mod.DecodeError(e) + return length # Return this for legacy reasons. + cls.MergeFromString = MergeFromString + + fields_by_tag = cls._fields_by_tag + message_set_decoders_by_tag = cls._message_set_decoders_by_tag + + def InternalParse(self, buffer, pos, end, current_depth=0): + """Create a message from serialized bytes. + + Args: + self: Message, instance of the proto message object. + buffer: memoryview of the serialized data. + pos: int, position to start in the serialized data. + end: int, end position of the serialized data. + + Returns: + Message object. + """ + # Guard against internal misuse, since this function is called internally + # quite extensively, and its easy to accidentally pass bytes. + assert isinstance(buffer, memoryview) + self._Modified() + field_dict = self._fields + while pos != end: + (tag_bytes, new_pos) = decoder.ReadTag(buffer, pos) + field_decoder, field_des = message_set_decoders_by_tag.get( + tag_bytes, (None, None) + ) + if field_decoder: + pos = field_decoder( + buffer, new_pos, end, self, field_dict, current_depth + ) + continue + field_des, is_packed = fields_by_tag.get(tag_bytes, (None, None)) + if field_des is None: + if not self._unknown_fields: # pylint: disable=protected-access + self._unknown_fields = [] # pylint: disable=protected-access + field_number, wire_type = decoder.DecodeTag(tag_bytes) + if field_number == 0: + raise message_mod.DecodeError('Field number 0 is illegal.') + (data, new_pos) = decoder._DecodeUnknownField( + buffer, new_pos, end, field_number, wire_type + ) # pylint: disable=protected-access + if new_pos == -1: + return pos + self._unknown_fields.append( + (tag_bytes, buffer[pos + len(tag_bytes) : new_pos].tobytes()) + ) + pos = new_pos + else: + _MaybeAddDecoder(cls, field_des) + field_decoder = field_des._decoders[is_packed] + pos = field_decoder( + buffer, new_pos, end, self, field_dict, current_depth + ) + if field_des.containing_oneof: + self._UpdateOneofState(field_des) + return pos + + cls._InternalParse = InternalParse + + +def _AddIsInitializedMethod(message_descriptor, cls): + """Adds the IsInitialized and FindInitializationError methods to the + protocol message class.""" + + required_fields = [field for field in message_descriptor.fields + if field.is_required] + + def IsInitialized(self, errors=None): + """Checks if all required fields of a message are set. + + Args: + errors: A list which, if provided, will be populated with the field + paths of all missing required fields. + + Returns: + True iff the specified message has all required fields set. + """ + + # Performance is critical so we avoid HasField() and ListFields(). + + for field in required_fields: + if (field not in self._fields or + (field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE and + not self._fields[field]._is_present_in_parent)): + if errors is not None: + errors.extend(self.FindInitializationErrors()) + return False + + for field, value in list(self._fields.items()): # dict can change size! + if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + if field.is_repeated: + if (field.message_type._is_map_entry): + continue + for element in value: + if not element.IsInitialized(): + if errors is not None: + errors.extend(self.FindInitializationErrors()) + return False + elif value._is_present_in_parent and not value.IsInitialized(): + if errors is not None: + errors.extend(self.FindInitializationErrors()) + return False + + return True + + cls.IsInitialized = IsInitialized + + def FindInitializationErrors(self): + """Finds required fields which are not initialized. + + Returns: + A list of strings. Each string is a path to an uninitialized field from + the top-level message, e.g. "foo.bar[5].baz". + """ + + errors = [] # simplify things + + for field in required_fields: + if not self.HasField(field.name): + errors.append(field.name) + + for field, value in self.ListFields(): + if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + if field.is_extension: + name = '(%s)' % field.full_name + else: + name = field.name + + if _IsMapField(field): + if _IsMessageMapField(field): + for key in value: + element = value[key] + prefix = '%s[%s].' % (name, key) + sub_errors = element.FindInitializationErrors() + errors += [prefix + error for error in sub_errors] + else: + # ScalarMaps can't have any initialization errors. + pass + elif field.is_repeated: + for i in range(len(value)): + element = value[i] + prefix = '%s[%d].' % (name, i) + sub_errors = element.FindInitializationErrors() + errors += [prefix + error for error in sub_errors] + else: + prefix = name + '.' + sub_errors = value.FindInitializationErrors() + errors += [prefix + error for error in sub_errors] + + return errors + + cls.FindInitializationErrors = FindInitializationErrors + + +def _FullyQualifiedClassName(klass): + module = klass.__module__ + name = getattr(klass, '__qualname__', klass.__name__) + if module in (None, 'builtins', '__builtin__'): + return name + return module + '.' + name + + +def _AddMergeFromMethod(cls): + CPPTYPE_MESSAGE = _FieldDescriptor.CPPTYPE_MESSAGE + + def MergeFrom(self, msg): + if not isinstance(msg, cls): + raise TypeError( + 'Parameter to MergeFrom() must be instance of same class: ' + 'expected %s got %s.' % (_FullyQualifiedClassName(cls), + _FullyQualifiedClassName(msg.__class__))) + + assert msg is not self + self._Modified() + + fields = self._fields + + for field, value in msg._fields.items(): + if field.is_repeated: + field_value = fields.get(field) + if field_value is None: + # Construct a new object to represent this field. + field_value = field._default_constructor(self) + fields[field] = field_value + field_value.MergeFrom(value) + elif field.cpp_type == CPPTYPE_MESSAGE: + if value._is_present_in_parent: + field_value = fields.get(field) + if field_value is None: + # Construct a new object to represent this field. + field_value = field._default_constructor(self) + fields[field] = field_value + field_value.MergeFrom(value) + else: + self._fields[field] = value + if field.containing_oneof: + self._UpdateOneofState(field) + + if msg._unknown_fields: + if not self._unknown_fields: + self._unknown_fields = [] + self._unknown_fields.extend(msg._unknown_fields) + + cls.MergeFrom = MergeFrom + + +def _AddWhichOneofMethod(message_descriptor, cls): + def WhichOneof(self, oneof_name): + """Returns the name of the currently set field inside a oneof, or None.""" + try: + field = message_descriptor.oneofs_by_name[oneof_name] + except KeyError: + raise ValueError( + 'Protocol message has no oneof "%s" field.' % oneof_name) + + nested_field = self._oneofs.get(field, None) + if nested_field is not None and self.HasField(nested_field.name): + return nested_field.name + else: + return None + + cls.WhichOneof = WhichOneof + + +def _Clear(self): + # Clear fields. + self._fields = {} + self._unknown_fields = () + + self._oneofs = {} + self._Modified() + + +def _UnknownFields(self): + raise NotImplementedError('Please use the add-on feaure ' + 'unknown_fields.UnknownFieldSet(message) in ' + 'unknown_fields.py instead.') + + +def _DiscardUnknownFields(self): + self._unknown_fields = [] + for field, value in self.ListFields(): + if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE: + if _IsMapField(field): + if _IsMessageMapField(field): + for key in value: + value[key].DiscardUnknownFields() + elif field.is_repeated: + for sub_message in value: + sub_message.DiscardUnknownFields() + else: + value.DiscardUnknownFields() + + +def _SetListener(self, listener): + if listener is None: + self._listener = message_listener_mod.NullMessageListener() + else: + self._listener = listener + + +def _AddMessageMethods(message_descriptor, cls): + """Adds implementations of all Message methods to cls.""" + _AddListFieldsMethod(message_descriptor, cls) + _AddHasFieldMethod(message_descriptor, cls) + _AddClearFieldMethod(message_descriptor, cls) + if message_descriptor.is_extendable: + _AddClearExtensionMethod(cls) + _AddHasExtensionMethod(cls) + _AddEqualsMethod(message_descriptor, cls) + _AddStrMethod(message_descriptor, cls) + _AddReprMethod(message_descriptor, cls) + _AddUnicodeMethod(message_descriptor, cls) + _AddContainsMethod(message_descriptor, cls) + _AddByteSizeMethod(message_descriptor, cls) + _AddSerializeToStringMethod(message_descriptor, cls) + _AddSerializePartialToStringMethod(message_descriptor, cls) + _AddMergeFromStringMethod(message_descriptor, cls) + _AddIsInitializedMethod(message_descriptor, cls) + _AddMergeFromMethod(cls) + _AddWhichOneofMethod(message_descriptor, cls) + # Adds methods which do not depend on cls. + cls.Clear = _Clear + cls.DiscardUnknownFields = _DiscardUnknownFields + cls._SetListener = _SetListener + + +def _AddPrivateHelperMethods(message_descriptor, cls): + """Adds implementation of private helper methods to cls.""" + + def Modified(self): + """Sets the _cached_byte_size_dirty bit to true, + and propagates this to our listener iff this was a state change. + """ + + # Note: Some callers check _cached_byte_size_dirty before calling + # _Modified() as an extra optimization. So, if this method is ever + # changed such that it does stuff even when _cached_byte_size_dirty is + # already true, the callers need to be updated. + if not self._cached_byte_size_dirty: + self._cached_byte_size_dirty = True + self._listener_for_children.dirty = True + self._is_present_in_parent = True + self._listener.Modified() + + def _UpdateOneofState(self, field): + """Sets field as the active field in its containing oneof. + + Will also delete currently active field in the oneof, if it is different + from the argument. Does not mark the message as modified. + """ + other_field = self._oneofs.setdefault(field.containing_oneof, field) + if other_field is not field: + del self._fields[other_field] + self._oneofs[field.containing_oneof] = field + + cls._Modified = Modified + cls.SetInParent = Modified + cls._UpdateOneofState = _UpdateOneofState + + +class _Listener(object): + + """MessageListener implementation that a parent message registers with its + child message. + + In order to support semantics like: + + foo.bar.baz.moo = 23 + assert foo.HasField('bar') + + ...child objects must have back references to their parents. + This helper class is at the heart of this support. + """ + + def __init__(self, parent_message): + """Args: + parent_message: The message whose _Modified() method we should call when + we receive Modified() messages. + """ + # This listener establishes a back reference from a child (contained) object + # to its parent (containing) object. We make this a weak reference to avoid + # creating cyclic garbage when the client finishes with the 'parent' object + # in the tree. + if isinstance(parent_message, weakref.ProxyType): + self._parent_message_weakref = parent_message + else: + self._parent_message_weakref = weakref.proxy(parent_message) + + # As an optimization, we also indicate directly on the listener whether + # or not the parent message is dirty. This way we can avoid traversing + # up the tree in the common case. + self.dirty = False + + def Modified(self): + if self.dirty: + return + try: + # Propagate the signal to our parents iff this is the first field set. + self._parent_message_weakref._Modified() + except ReferenceError: + # We can get here if a client has kept a reference to a child object, + # and is now setting a field on it, but the child's parent has been + # garbage-collected. This is not an error. + pass + + +class _OneofListener(_Listener): + """Special listener implementation for setting composite oneof fields.""" + + def __init__(self, parent_message, field): + """Args: + parent_message: The message whose _Modified() method we should call when + we receive Modified() messages. + field: The descriptor of the field being set in the parent message. + """ + super(_OneofListener, self).__init__(parent_message) + self._field = field + + def Modified(self): + """Also updates the state of the containing oneof in the parent message.""" + try: + self._parent_message_weakref._UpdateOneofState(self._field) + super(_OneofListener, self).Modified() + except ReferenceError: + pass diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/testing_refleaks.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/testing_refleaks.py new file mode 100644 index 0000000000000000000000000000000000000000..f94ef2b9d6128b82cc832409843e7d8a57d935c8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/testing_refleaks.py @@ -0,0 +1,128 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""A subclass of unittest.TestCase which checks for reference leaks. + +To use: +- Use testing_refleak.BaseTestCase instead of unittest.TestCase +- Configure and compile Python with --with-pydebug + +If sys.gettotalrefcount() is not available (because Python was built without +the Py_DEBUG option), then this module is a no-op and tests will run normally. +""" + +import copyreg +import gc +import sys +import unittest + + +class LocalTestResult(unittest.TestResult): + """A TestResult which forwards events to a parent object, except for Skips.""" + + def __init__(self, parent_result): + unittest.TestResult.__init__(self) + self.parent_result = parent_result + + def addError(self, test, error): + self.parent_result.addError(test, error) + + def addFailure(self, test, error): + self.parent_result.addFailure(test, error) + + def addSkip(self, test, reason): + pass + + def addDuration(self, test, duration): + pass + + +class ReferenceLeakCheckerMixin(object): + """A mixin class for TestCase, which checks reference counts.""" + + NB_RUNS = 3 + + def run(self, result=None): + testMethod = getattr(self, self._testMethodName) + expecting_failure_method = getattr(testMethod, "__unittest_expecting_failure__", False) + expecting_failure_class = getattr(self, "__unittest_expecting_failure__", False) + if expecting_failure_class or expecting_failure_method: + return + + # python_message.py registers all Message classes to some pickle global + # registry, which makes the classes immortal. + # We save a copy of this registry, and reset it before we could references. + self._saved_pickle_registry = copyreg.dispatch_table.copy() + + # Run the test twice, to warm up the instance attributes. + super(ReferenceLeakCheckerMixin, self).run(result=result) + super(ReferenceLeakCheckerMixin, self).run(result=result) + + local_result = LocalTestResult(result) + num_flakes = 0 + refcount_deltas = [] + + # Observe the refcount, then create oldrefcount which actually makes the + # refcount 1 higher than the recorded value immediately + oldrefcount = self._getRefcounts() + while len(refcount_deltas) < self.NB_RUNS: + oldrefcount = self._getRefcounts() + super(ReferenceLeakCheckerMixin, self).run(result=local_result) + newrefcount = self._getRefcounts() + # If the GC was able to collect some objects after the call to run() that + # it could not collect before the call, then the counts won't match. + if newrefcount < oldrefcount and num_flakes < 2: + # This result is (probably) a flake -- garbage collectors aren't very + # predictable, but a lower ending refcount is the opposite of the + # failure we are testing for. If the result is repeatable, then we will + # eventually report it, but not after trying to eliminate it. + num_flakes += 1 + continue + num_flakes = 0 + refcount_deltas.append(newrefcount - oldrefcount) + print(refcount_deltas, self) + + try: + self.assertEqual(refcount_deltas, [0] * self.NB_RUNS) + except Exception: # pylint: disable=broad-except + result.addError(self, sys.exc_info()) + + def _getRefcounts(self): + if hasattr(sys, "_clear_internal_caches"): # Since 3.13 + sys._clear_internal_caches() # pylint: disable=protected-access + else: + sys._clear_type_cache() # pylint: disable=protected-access + copyreg.dispatch_table.clear() + copyreg.dispatch_table.update(self._saved_pickle_registry) + # It is sometimes necessary to gc.collect() multiple times, to ensure + # that all objects can be collected. + gc.collect() + gc.collect() + gc.collect() + return sys.gettotalrefcount() + + +if hasattr(sys, 'gettotalrefcount'): + + def TestCase(test_class): + new_bases = (ReferenceLeakCheckerMixin,) + test_class.__bases__ + new_class = type(test_class)( + test_class.__name__, new_bases, dict(test_class.__dict__)) + return new_class + SkipReferenceLeakChecker = unittest.skip + +else: + # When PyDEBUG is not enabled, run the tests normally. + + def TestCase(test_class): + return test_class + + def SkipReferenceLeakChecker(reason): + del reason # Don't skip, so don't need a reason. + def Same(func): + return func + return Same diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/type_checkers.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/type_checkers.py new file mode 100644 index 0000000000000000000000000000000000000000..1d318e289d22d41b77a376b10da67bb335efa5d8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/type_checkers.py @@ -0,0 +1,442 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Provides type checking routines. + +This module defines type checking utilities in the forms of dictionaries: + +VALUE_CHECKERS: A dictionary of field types and a value validation object. +TYPE_TO_BYTE_SIZE_FN: A dictionary with field types and a size computing + function. +TYPE_TO_SERIALIZE_METHOD: A dictionary with field types and serialization + function. +FIELD_TYPE_TO_WIRE_TYPE: A dictionary with field typed and their + corresponding wire types. +TYPE_TO_DESERIALIZE_METHOD: A dictionary with field types and deserialization + function. +""" + +__author__ = 'robinson@google.com (Will Robinson)' + +import numbers +import struct +import warnings + +from google.protobuf import descriptor +from google.protobuf.internal import decoder +from google.protobuf.internal import encoder +from google.protobuf.internal import wire_format + +_FieldDescriptor = descriptor.FieldDescriptor + +def TruncateToFourByteFloat(original): + return struct.unpack(' _FLOAT_MAX: + if converted_value <= _MAX_FLOAT_AS_DOUBLE_ROUNDED: + return _FLOAT_MAX + return _INF + if converted_value < _FLOAT_MIN: + if converted_value >= -_MAX_FLOAT_AS_DOUBLE_ROUNDED: + return _FLOAT_MIN + return _NEG_INF + + return TruncateToFourByteFloat(converted_value) + +# Type-checkers for all scalar CPPTYPEs. +_VALUE_CHECKERS = { + _FieldDescriptor.CPPTYPE_INT32: Int32ValueChecker(), + _FieldDescriptor.CPPTYPE_INT64: Int64ValueChecker(), + _FieldDescriptor.CPPTYPE_UINT32: Uint32ValueChecker(), + _FieldDescriptor.CPPTYPE_UINT64: Uint64ValueChecker(), + _FieldDescriptor.CPPTYPE_DOUBLE: DoubleValueChecker(), + _FieldDescriptor.CPPTYPE_FLOAT: FloatValueChecker(), + _FieldDescriptor.CPPTYPE_BOOL: BoolValueChecker(), + _FieldDescriptor.CPPTYPE_STRING: TypeCheckerWithDefault(b'', bytes), +} + + +# Map from field type to a function F, such that F(field_num, value) +# gives the total byte size for a value of the given type. This +# byte size includes tag information and any other additional space +# associated with serializing "value". +TYPE_TO_BYTE_SIZE_FN = { + _FieldDescriptor.TYPE_DOUBLE: wire_format.DoubleByteSize, + _FieldDescriptor.TYPE_FLOAT: wire_format.FloatByteSize, + _FieldDescriptor.TYPE_INT64: wire_format.Int64ByteSize, + _FieldDescriptor.TYPE_UINT64: wire_format.UInt64ByteSize, + _FieldDescriptor.TYPE_INT32: wire_format.Int32ByteSize, + _FieldDescriptor.TYPE_FIXED64: wire_format.Fixed64ByteSize, + _FieldDescriptor.TYPE_FIXED32: wire_format.Fixed32ByteSize, + _FieldDescriptor.TYPE_BOOL: wire_format.BoolByteSize, + _FieldDescriptor.TYPE_STRING: wire_format.StringByteSize, + _FieldDescriptor.TYPE_GROUP: wire_format.GroupByteSize, + _FieldDescriptor.TYPE_MESSAGE: wire_format.MessageByteSize, + _FieldDescriptor.TYPE_BYTES: wire_format.BytesByteSize, + _FieldDescriptor.TYPE_UINT32: wire_format.UInt32ByteSize, + _FieldDescriptor.TYPE_ENUM: wire_format.EnumByteSize, + _FieldDescriptor.TYPE_SFIXED32: wire_format.SFixed32ByteSize, + _FieldDescriptor.TYPE_SFIXED64: wire_format.SFixed64ByteSize, + _FieldDescriptor.TYPE_SINT32: wire_format.SInt32ByteSize, + _FieldDescriptor.TYPE_SINT64: wire_format.SInt64ByteSize + } + + +# Maps from field types to encoder constructors. +TYPE_TO_ENCODER = { + _FieldDescriptor.TYPE_DOUBLE: encoder.DoubleEncoder, + _FieldDescriptor.TYPE_FLOAT: encoder.FloatEncoder, + _FieldDescriptor.TYPE_INT64: encoder.Int64Encoder, + _FieldDescriptor.TYPE_UINT64: encoder.UInt64Encoder, + _FieldDescriptor.TYPE_INT32: encoder.Int32Encoder, + _FieldDescriptor.TYPE_FIXED64: encoder.Fixed64Encoder, + _FieldDescriptor.TYPE_FIXED32: encoder.Fixed32Encoder, + _FieldDescriptor.TYPE_BOOL: encoder.BoolEncoder, + _FieldDescriptor.TYPE_STRING: encoder.StringEncoder, + _FieldDescriptor.TYPE_GROUP: encoder.GroupEncoder, + _FieldDescriptor.TYPE_MESSAGE: encoder.MessageEncoder, + _FieldDescriptor.TYPE_BYTES: encoder.BytesEncoder, + _FieldDescriptor.TYPE_UINT32: encoder.UInt32Encoder, + _FieldDescriptor.TYPE_ENUM: encoder.EnumEncoder, + _FieldDescriptor.TYPE_SFIXED32: encoder.SFixed32Encoder, + _FieldDescriptor.TYPE_SFIXED64: encoder.SFixed64Encoder, + _FieldDescriptor.TYPE_SINT32: encoder.SInt32Encoder, + _FieldDescriptor.TYPE_SINT64: encoder.SInt64Encoder, + } + + +# Maps from field types to sizer constructors. +TYPE_TO_SIZER = { + _FieldDescriptor.TYPE_DOUBLE: encoder.DoubleSizer, + _FieldDescriptor.TYPE_FLOAT: encoder.FloatSizer, + _FieldDescriptor.TYPE_INT64: encoder.Int64Sizer, + _FieldDescriptor.TYPE_UINT64: encoder.UInt64Sizer, + _FieldDescriptor.TYPE_INT32: encoder.Int32Sizer, + _FieldDescriptor.TYPE_FIXED64: encoder.Fixed64Sizer, + _FieldDescriptor.TYPE_FIXED32: encoder.Fixed32Sizer, + _FieldDescriptor.TYPE_BOOL: encoder.BoolSizer, + _FieldDescriptor.TYPE_STRING: encoder.StringSizer, + _FieldDescriptor.TYPE_GROUP: encoder.GroupSizer, + _FieldDescriptor.TYPE_MESSAGE: encoder.MessageSizer, + _FieldDescriptor.TYPE_BYTES: encoder.BytesSizer, + _FieldDescriptor.TYPE_UINT32: encoder.UInt32Sizer, + _FieldDescriptor.TYPE_ENUM: encoder.EnumSizer, + _FieldDescriptor.TYPE_SFIXED32: encoder.SFixed32Sizer, + _FieldDescriptor.TYPE_SFIXED64: encoder.SFixed64Sizer, + _FieldDescriptor.TYPE_SINT32: encoder.SInt32Sizer, + _FieldDescriptor.TYPE_SINT64: encoder.SInt64Sizer, + } + + +# Maps from field type to a decoder constructor. +TYPE_TO_DECODER = { + _FieldDescriptor.TYPE_DOUBLE: decoder.DoubleDecoder, + _FieldDescriptor.TYPE_FLOAT: decoder.FloatDecoder, + _FieldDescriptor.TYPE_INT64: decoder.Int64Decoder, + _FieldDescriptor.TYPE_UINT64: decoder.UInt64Decoder, + _FieldDescriptor.TYPE_INT32: decoder.Int32Decoder, + _FieldDescriptor.TYPE_FIXED64: decoder.Fixed64Decoder, + _FieldDescriptor.TYPE_FIXED32: decoder.Fixed32Decoder, + _FieldDescriptor.TYPE_BOOL: decoder.BoolDecoder, + _FieldDescriptor.TYPE_STRING: decoder.StringDecoder, + _FieldDescriptor.TYPE_GROUP: decoder.GroupDecoder, + _FieldDescriptor.TYPE_MESSAGE: decoder.MessageDecoder, + _FieldDescriptor.TYPE_BYTES: decoder.BytesDecoder, + _FieldDescriptor.TYPE_UINT32: decoder.UInt32Decoder, + _FieldDescriptor.TYPE_ENUM: decoder.EnumDecoder, + _FieldDescriptor.TYPE_SFIXED32: decoder.SFixed32Decoder, + _FieldDescriptor.TYPE_SFIXED64: decoder.SFixed64Decoder, + _FieldDescriptor.TYPE_SINT32: decoder.SInt32Decoder, + _FieldDescriptor.TYPE_SINT64: decoder.SInt64Decoder, + } + +# Maps from field type to expected wiretype. +FIELD_TYPE_TO_WIRE_TYPE = { + _FieldDescriptor.TYPE_DOUBLE: wire_format.WIRETYPE_FIXED64, + _FieldDescriptor.TYPE_FLOAT: wire_format.WIRETYPE_FIXED32, + _FieldDescriptor.TYPE_INT64: wire_format.WIRETYPE_VARINT, + _FieldDescriptor.TYPE_UINT64: wire_format.WIRETYPE_VARINT, + _FieldDescriptor.TYPE_INT32: wire_format.WIRETYPE_VARINT, + _FieldDescriptor.TYPE_FIXED64: wire_format.WIRETYPE_FIXED64, + _FieldDescriptor.TYPE_FIXED32: wire_format.WIRETYPE_FIXED32, + _FieldDescriptor.TYPE_BOOL: wire_format.WIRETYPE_VARINT, + _FieldDescriptor.TYPE_STRING: + wire_format.WIRETYPE_LENGTH_DELIMITED, + _FieldDescriptor.TYPE_GROUP: wire_format.WIRETYPE_START_GROUP, + _FieldDescriptor.TYPE_MESSAGE: + wire_format.WIRETYPE_LENGTH_DELIMITED, + _FieldDescriptor.TYPE_BYTES: + wire_format.WIRETYPE_LENGTH_DELIMITED, + _FieldDescriptor.TYPE_UINT32: wire_format.WIRETYPE_VARINT, + _FieldDescriptor.TYPE_ENUM: wire_format.WIRETYPE_VARINT, + _FieldDescriptor.TYPE_SFIXED32: wire_format.WIRETYPE_FIXED32, + _FieldDescriptor.TYPE_SFIXED64: wire_format.WIRETYPE_FIXED64, + _FieldDescriptor.TYPE_SINT32: wire_format.WIRETYPE_VARINT, + _FieldDescriptor.TYPE_SINT64: wire_format.WIRETYPE_VARINT, + } diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/well_known_types.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/well_known_types.py new file mode 100644 index 0000000000000000000000000000000000000000..e646dd70223b05a43b21a9bce8ad02a3914f2c12 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/well_known_types.py @@ -0,0 +1,709 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains well known classes. + +This files defines well known classes which need extra maintenance including: + - Any + - Duration + - FieldMask + - Struct + - Timestamp +""" + +__author__ = 'jieluo@google.com (Jie Luo)' + +import calendar +import collections.abc +import datetime +from typing import Union +import warnings +from google.protobuf.internal import field_mask + +FieldMask = field_mask.FieldMask + +_TIMESTAMPFORMAT = '%Y-%m-%dT%H:%M:%S' +_NANOS_PER_SECOND = 1000000000 +_NANOS_PER_MILLISECOND = 1000000 +_NANOS_PER_MICROSECOND = 1000 +_MILLIS_PER_SECOND = 1000 +_MICROS_PER_SECOND = 1000000 +_SECONDS_PER_DAY = 24 * 3600 +_DURATION_SECONDS_MAX = 315576000000 +_TIMESTAMP_SECONDS_MIN = -62135596800 +_TIMESTAMP_SECONDS_MAX = 253402300799 + +_EPOCH_DATETIME_NAIVE = datetime.datetime(1970, 1, 1, tzinfo=None) +_EPOCH_DATETIME_AWARE = _EPOCH_DATETIME_NAIVE.replace( + tzinfo=datetime.timezone.utc +) + + +class Any(object): + """Class for Any Message type.""" + + __slots__ = () + + def Pack( + self, msg, type_url_prefix='type.googleapis.com/', deterministic=None + ): + """Packs the specified message into current Any message.""" + if len(type_url_prefix) < 1 or type_url_prefix[-1] != '/': + self.type_url = '%s/%s' % (type_url_prefix, msg.DESCRIPTOR.full_name) + else: + self.type_url = '%s%s' % (type_url_prefix, msg.DESCRIPTOR.full_name) + self.value = msg.SerializeToString(deterministic=deterministic) + + def Unpack(self, msg): + """Unpacks the current Any message into specified message.""" + descriptor = msg.DESCRIPTOR + if not self.Is(descriptor): + return False + msg.ParseFromString(self.value) + return True + + def TypeName(self): + """Returns the protobuf type name of the inner message.""" + # Only last part is to be used: b/25630112 + return self.type_url.rpartition('/')[2] + + def Is(self, descriptor): + """Checks if this Any represents the given protobuf type.""" + return '/' in self.type_url and self.TypeName() == descriptor.full_name + + +class Timestamp(object): + """Class for Timestamp message type.""" + + __slots__ = () + + def ToJsonString(self): + """Converts Timestamp to RFC 3339 date string format. + + Returns: + A string converted from timestamp. The string is always Z-normalized + and uses 3, 6 or 9 fractional digits as required to represent the + exact time. Example of the return format: '1972-01-01T10:00:20.021Z' + """ + _CheckTimestampValid(self.seconds, self.nanos) + nanos = self.nanos + seconds = self.seconds % _SECONDS_PER_DAY + days = (self.seconds - seconds) // _SECONDS_PER_DAY + dt = datetime.datetime(1970, 1, 1) + datetime.timedelta(days, seconds) + + result = dt.isoformat() + if (nanos % 1e9) == 0: + # If there are 0 fractional digits, the fractional + # point '.' should be omitted when serializing. + return result + 'Z' + if (nanos % 1e6) == 0: + # Serialize 3 fractional digits. + return result + '.%03dZ' % (nanos / 1e6) + if (nanos % 1e3) == 0: + # Serialize 6 fractional digits. + return result + '.%06dZ' % (nanos / 1e3) + # Serialize 9 fractional digits. + return result + '.%09dZ' % nanos + + def FromJsonString(self, value): + """Parse a RFC 3339 date string format to Timestamp. + + Args: + value: A date string. Any fractional digits (or none) and any offset are + accepted as long as they fit into nano-seconds precision. Example of + accepted format: '1972-01-01T10:00:20.021-05:00' + + Raises: + ValueError: On parsing problems. + """ + if not isinstance(value, str): + raise ValueError('Timestamp JSON value not a string: {!r}'.format(value)) + timezone_offset = value.find('Z') + if timezone_offset == -1: + timezone_offset = value.find('+') + if timezone_offset == -1: + timezone_offset = value.rfind('-') + if timezone_offset == -1: + raise ValueError( + 'Failed to parse timestamp: missing valid timezone offset.' + ) + time_value = value[0:timezone_offset] + # Parse datetime and nanos. + point_position = time_value.find('.') + if point_position == -1: + second_value = time_value + nano_value = '' + else: + second_value = time_value[:point_position] + nano_value = time_value[point_position + 1 :] + if 't' in second_value: + raise ValueError( + "time data '{0}' does not match format '%Y-%m-%dT%H:%M:%S', " + "lowercase 't' is not accepted".format(second_value) + ) + date_object = datetime.datetime.strptime(second_value, _TIMESTAMPFORMAT) + td = date_object - datetime.datetime(1970, 1, 1) + seconds = td.seconds + td.days * _SECONDS_PER_DAY + if len(nano_value) > 9: + raise ValueError( + 'Failed to parse Timestamp: nanos {0} more than ' + '9 fractional digits.'.format(nano_value) + ) + if nano_value: + nanos = round(float('0.' + nano_value) * 1e9) + else: + nanos = 0 + # Parse timezone offsets. + if value[timezone_offset] == 'Z': + if len(value) != timezone_offset + 1: + raise ValueError( + 'Failed to parse timestamp: invalid trailing data {0}.'.format( + value + ) + ) + else: + timezone = value[timezone_offset:] + pos = timezone.find(':') + if pos == -1: + raise ValueError('Invalid timezone offset value: {0}.'.format(timezone)) + if timezone[0] == '+': + seconds -= (int(timezone[1:pos]) * 60 + int(timezone[pos + 1 :])) * 60 + else: + seconds += (int(timezone[1:pos]) * 60 + int(timezone[pos + 1 :])) * 60 + # Set seconds and nanos + _CheckTimestampValid(seconds, nanos) + self.seconds = int(seconds) + self.nanos = int(nanos) + + def GetCurrentTime(self): + """Get the current UTC into Timestamp.""" + self.FromDatetime(datetime.datetime.now(tz=datetime.timezone.utc)) + + def ToNanoseconds(self): + """Converts Timestamp to nanoseconds since epoch.""" + _CheckTimestampValid(self.seconds, self.nanos) + return self.seconds * _NANOS_PER_SECOND + self.nanos + + def ToMicroseconds(self): + """Converts Timestamp to microseconds since epoch.""" + _CheckTimestampValid(self.seconds, self.nanos) + return ( + self.seconds * _MICROS_PER_SECOND + self.nanos // _NANOS_PER_MICROSECOND + ) + + def ToMilliseconds(self): + """Converts Timestamp to milliseconds since epoch.""" + _CheckTimestampValid(self.seconds, self.nanos) + return ( + self.seconds * _MILLIS_PER_SECOND + self.nanos // _NANOS_PER_MILLISECOND + ) + + def ToSeconds(self): + """Converts Timestamp to seconds since epoch.""" + _CheckTimestampValid(self.seconds, self.nanos) + return self.seconds + + def FromNanoseconds(self, nanos): + """Converts nanoseconds since epoch to Timestamp.""" + seconds = nanos // _NANOS_PER_SECOND + nanos = nanos % _NANOS_PER_SECOND + _CheckTimestampValid(seconds, nanos) + self.seconds = seconds + self.nanos = nanos + + def FromMicroseconds(self, micros): + """Converts microseconds since epoch to Timestamp.""" + seconds = micros // _MICROS_PER_SECOND + nanos = (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND + _CheckTimestampValid(seconds, nanos) + self.seconds = seconds + self.nanos = nanos + + def FromMilliseconds(self, millis): + """Converts milliseconds since epoch to Timestamp.""" + seconds = millis // _MILLIS_PER_SECOND + nanos = (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND + _CheckTimestampValid(seconds, nanos) + self.seconds = seconds + self.nanos = nanos + + def FromSeconds(self, seconds): + """Converts seconds since epoch to Timestamp.""" + _CheckTimestampValid(seconds, 0) + self.seconds = seconds + self.nanos = 0 + + def ToDatetime(self, tzinfo=None): + """Converts Timestamp to a datetime. + + Args: + tzinfo: A datetime.tzinfo subclass; defaults to None. + + Returns: + If tzinfo is None, returns a timezone-naive UTC datetime (with no timezone + information, i.e. not aware that it's UTC). + + Otherwise, returns a timezone-aware datetime in the input timezone. + """ + # Using datetime.fromtimestamp for this would avoid constructing an extra + # timedelta object and possibly an extra datetime. Unfortunately, that has + # the disadvantage of not handling the full precision (on all platforms, see + # https://github.com/python/cpython/issues/109849) or full range (on some + # platforms, see https://github.com/python/cpython/issues/110042) of + # datetime. + _CheckTimestampValid(self.seconds, self.nanos) + delta = datetime.timedelta( + seconds=self.seconds, + microseconds=_RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND), + ) + if tzinfo is None: + return _EPOCH_DATETIME_NAIVE + delta + else: + # Note the tz conversion has to come after the timedelta arithmetic. + return (_EPOCH_DATETIME_AWARE + delta).astimezone(tzinfo) + + def FromDatetime(self, dt): + """Converts datetime to Timestamp. + + Args: + dt: A datetime. If it's timezone-naive, it's assumed to be in UTC. + """ + # Using this guide: http://wiki.python.org/moin/WorkingWithTime + # And this conversion guide: http://docs.python.org/library/time.html + + # Turn the date parameter into a tuple (struct_time) that can then be + # manipulated into a long value of seconds. During the conversion from + # struct_time to long, the source date in UTC, and so it follows that the + # correct transformation is calendar.timegm() + if type(dt).__name__ != 'datetime' and not isinstance( + dt, datetime.datetime + ): + raise TypeError( + 'Fail to convert to Timestamp. Expected a datetime object ' + 'got {0}'.format(type(dt).__name__) + ) + try: + seconds = calendar.timegm(dt.utctimetuple()) + nanos = dt.microsecond * _NANOS_PER_MICROSECOND + except AttributeError as e: + raise AttributeError( + 'Fail to convert to Timestamp. Expected a datetime like ' + 'object got {0} : {1}'.format(type(dt).__name__, e) + ) from e + _CheckTimestampValid(seconds, nanos) + self.seconds = seconds + self.nanos = nanos + + def _internal_assign(self, dt): + self.FromDatetime(dt) + + def __add__(self, value) -> datetime.datetime: + if isinstance(value, Duration): + return self.ToDatetime() + value.ToTimedelta() + return self.ToDatetime() + value + + __radd__ = __add__ + + def __sub__(self, value) -> Union[datetime.datetime, datetime.timedelta]: + if isinstance(value, Timestamp): + return self.ToDatetime() - value.ToDatetime() + elif isinstance(value, Duration): + return self.ToDatetime() - value.ToTimedelta() + return self.ToDatetime() - value + + def __rsub__(self, dt) -> datetime.timedelta: + return dt - self.ToDatetime() + + +def _CheckTimestampValid(seconds, nanos): + if seconds < _TIMESTAMP_SECONDS_MIN or seconds > _TIMESTAMP_SECONDS_MAX: + raise ValueError( + 'Timestamp is not valid: Seconds {0} must be in range ' + '[-62135596800, 253402300799].'.format(seconds)) + if nanos < 0 or nanos >= _NANOS_PER_SECOND: + raise ValueError( + 'Timestamp is not valid: Nanos {} must be in a range ' + '[0, 999999].'.format(nanos) + ) + + +class Duration(object): + """Class for Duration message type.""" + + __slots__ = () + + def ToJsonString(self): + """Converts Duration to string format. + + Returns: + A string converted from self. The string format will contains + 3, 6, or 9 fractional digits depending on the precision required to + represent the exact Duration value. For example: "1s", "1.010s", + "1.000000100s", "-3.100s" + """ + _CheckDurationValid(self.seconds, self.nanos) + if self.seconds < 0 or self.nanos < 0: + result = '-' + seconds = -self.seconds + int((0 - self.nanos) // 1e9) + nanos = (0 - self.nanos) % 1e9 + else: + result = '' + seconds = self.seconds + int(self.nanos // 1e9) + nanos = self.nanos % 1e9 + result += '%d' % seconds + if (nanos % 1e9) == 0: + # If there are 0 fractional digits, the fractional + # point '.' should be omitted when serializing. + return result + 's' + if (nanos % 1e6) == 0: + # Serialize 3 fractional digits. + return result + '.%03ds' % (nanos / 1e6) + if (nanos % 1e3) == 0: + # Serialize 6 fractional digits. + return result + '.%06ds' % (nanos / 1e3) + # Serialize 9 fractional digits. + return result + '.%09ds' % nanos + + def FromJsonString(self, value): + """Converts a string to Duration. + + Args: + value: A string to be converted. The string must end with 's'. Any + fractional digits (or none) are accepted as long as they fit into + precision. For example: "1s", "1.01s", "1.0000001s", "-3.100s + + Raises: + ValueError: On parsing problems. + """ + if not isinstance(value, str): + raise ValueError('Duration JSON value not a string: {!r}'.format(value)) + if len(value) < 1 or value[-1] != 's': + raise ValueError('Duration must end with letter "s": {0}.'.format(value)) + try: + pos = value.find('.') + if pos == -1: + seconds = int(value[:-1]) + nanos = 0 + else: + seconds = int(value[:pos]) + if value[0] == '-': + nanos = int(round(float('-0{0}'.format(value[pos:-1])) * 1e9)) + else: + nanos = int(round(float('0{0}'.format(value[pos:-1])) * 1e9)) + _CheckDurationValid(seconds, nanos) + self.seconds = seconds + self.nanos = nanos + except ValueError as e: + raise ValueError("Couldn't parse duration: {0} : {1}.".format(value, e)) + + def ToNanoseconds(self): + """Converts a Duration to nanoseconds.""" + return self.seconds * _NANOS_PER_SECOND + self.nanos + + def ToMicroseconds(self): + """Converts a Duration to microseconds.""" + micros = _RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND) + return self.seconds * _MICROS_PER_SECOND + micros + + def ToMilliseconds(self): + """Converts a Duration to milliseconds.""" + millis = _RoundTowardZero(self.nanos, _NANOS_PER_MILLISECOND) + return self.seconds * _MILLIS_PER_SECOND + millis + + def ToSeconds(self): + """Converts a Duration to seconds.""" + return self.seconds + + def FromNanoseconds(self, nanos): + """Converts nanoseconds to Duration.""" + self._NormalizeDuration( + nanos // _NANOS_PER_SECOND, nanos % _NANOS_PER_SECOND + ) + + def FromMicroseconds(self, micros): + """Converts microseconds to Duration.""" + self._NormalizeDuration( + micros // _MICROS_PER_SECOND, + (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND, + ) + + def FromMilliseconds(self, millis): + """Converts milliseconds to Duration.""" + self._NormalizeDuration( + millis // _MILLIS_PER_SECOND, + (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND, + ) + + def FromSeconds(self, seconds): + """Converts seconds to Duration.""" + self.seconds = seconds + self.nanos = 0 + + def ToTimedelta(self) -> datetime.timedelta: + """Converts Duration to timedelta.""" + return datetime.timedelta( + seconds=self.seconds, + microseconds=_RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND), + ) + + def FromTimedelta(self, td): + """Converts timedelta to Duration.""" + if type(td).__name__ != 'timedelta' and not isinstance( + td, datetime.timedelta + ): + raise TypeError( + 'Fail to convert to Duration. Expected a timedelta object ' + 'got {0}'.format(type(td).__name__) + ) + try: + self._NormalizeDuration( + td.seconds + td.days * _SECONDS_PER_DAY, + td.microseconds * _NANOS_PER_MICROSECOND, + ) + except AttributeError as e: + raise AttributeError( + 'Fail to convert to Duration. Expected a timedelta like ' + 'object got {0}: {1}'.format(type(td).__name__, e) + ) from e + + def _internal_assign(self, td): + self.FromTimedelta(td) + + def _NormalizeDuration(self, seconds, nanos): + """Set Duration by seconds and nanos.""" + # Force nanos to be negative if the duration is negative. + if seconds < 0 and nanos > 0: + seconds += 1 + nanos -= _NANOS_PER_SECOND + self.seconds = seconds + self.nanos = nanos + + def __add__(self, value) -> Union[datetime.datetime, datetime.timedelta]: + if isinstance(value, Timestamp): + return self.ToTimedelta() + value.ToDatetime() + return self.ToTimedelta() + value + + __radd__ = __add__ + + def __sub__(self, value) -> datetime.timedelta: + return self.ToTimedelta() - value + + def __rsub__(self, value) -> Union[datetime.datetime, datetime.timedelta]: + return value - self.ToTimedelta() + + +def _CheckDurationValid(seconds, nanos): + if seconds < -_DURATION_SECONDS_MAX or seconds > _DURATION_SECONDS_MAX: + raise ValueError( + 'Duration is not valid: Seconds {0} must be in range ' + '[-315576000000, 315576000000].'.format(seconds) + ) + if nanos <= -_NANOS_PER_SECOND or nanos >= _NANOS_PER_SECOND: + raise ValueError( + 'Duration is not valid: Nanos {0} must be in range ' + '[-999999999, 999999999].'.format(nanos) + ) + if (nanos < 0 and seconds > 0) or (nanos > 0 and seconds < 0): + raise ValueError('Duration is not valid: Sign mismatch.') + + +def _RoundTowardZero(value, divider): + """Truncates the remainder part after division.""" + # For some languages, the sign of the remainder is implementation + # dependent if any of the operands is negative. Here we enforce + # "rounded toward zero" semantics. For example, for (-5) / 2 an + # implementation may give -3 as the result with the remainder being + # 1. This function ensures we always return -2 (closer to zero). + result = value // divider + remainder = value % divider + if result < 0 and remainder > 0: + return result + 1 + else: + return result + + +def _SetStructValue(struct_value, value): + if value is None: + struct_value.null_value = 0 + elif isinstance(value, bool): + # Note: this check must come before the number check because in Python + # True and False are also considered numbers. + struct_value.bool_value = value + elif isinstance(value, str): + struct_value.string_value = value + elif isinstance(value, (int, float)): + struct_value.number_value = value + elif isinstance(value, (dict, Struct)): + struct_value.struct_value.Clear() + struct_value.struct_value.update(value) + elif isinstance(value, (list, tuple, ListValue)): + struct_value.list_value.Clear() + struct_value.list_value.extend(value) + else: + raise ValueError('Unexpected type') + + +def _GetStructValue(struct_value): + which = struct_value.WhichOneof('kind') + if which == 'struct_value': + return struct_value.struct_value + elif which == 'null_value': + return None + elif which == 'number_value': + return struct_value.number_value + elif which == 'string_value': + return struct_value.string_value + elif which == 'bool_value': + return struct_value.bool_value + elif which == 'list_value': + return struct_value.list_value + elif which is None: + raise ValueError('Value not set') + + +class Struct(object): + """Class for Struct message type.""" + + __slots__ = () + + def __getitem__(self, key): + return _GetStructValue(self.fields[key]) + + def __setitem__(self, key, value): + _SetStructValue(self.fields[key], value) + + def __delitem__(self, key): + del self.fields[key] + + def __len__(self): + return len(self.fields) + + def __iter__(self): + return iter(self.fields) + + def _internal_assign(self, dictionary): + self.Clear() + self.update(dictionary) + + def _internal_compare(self, other): + size = len(self) + if size != len(other): + return False + for key, value in self.items(): + if key not in other: + return False + if isinstance(other[key], (dict, list)): + if not value._internal_compare(other[key]): + return False + elif value != other[key]: + return False + return True + + def keys(self): # pylint: disable=invalid-name + return self.fields.keys() + + def values(self): # pylint: disable=invalid-name + return [self[key] for key in self] + + def items(self): # pylint: disable=invalid-name + return [(key, self[key]) for key in self] + + def get_or_create_list(self, key): + """Returns a list for this key, creating if it didn't exist already.""" + if not self.fields[key].HasField('list_value'): + # Clear will mark list_value modified which will indeed create a list. + self.fields[key].list_value.Clear() + return self.fields[key].list_value + + def get_or_create_struct(self, key): + """Returns a struct for this key, creating if it didn't exist already.""" + if not self.fields[key].HasField('struct_value'): + # Clear will mark struct_value modified which will indeed create a struct. + self.fields[key].struct_value.Clear() + return self.fields[key].struct_value + + def update(self, dictionary): # pylint: disable=invalid-name + for key, value in dictionary.items(): + _SetStructValue(self.fields[key], value) + + +collections.abc.MutableMapping.register(Struct) + + +class ListValue(object): + """Class for ListValue message type.""" + + __slots__ = () + + def __len__(self): + return len(self.values) + + def append(self, value): + _SetStructValue(self.values.add(), value) + + def extend(self, elem_seq): + for value in elem_seq: + self.append(value) + + def __getitem__(self, index): + """Retrieves item by the specified index.""" + return _GetStructValue(self.values.__getitem__(index)) + + def __setitem__(self, index, value): + _SetStructValue(self.values.__getitem__(index), value) + + def __delitem__(self, key): + del self.values[key] + + def _internal_assign(self, elem_seq): + self.Clear() + self.extend(elem_seq) + + def _internal_compare(self, other): + size = len(self) + if size != len(other): + return False + for i in range(size): + if isinstance(other[i], (dict, list)): + if not self[i]._internal_compare(other[i]): + return False + elif self[i] != other[i]: + return False + return True + + def items(self): + for i in range(len(self)): + yield self[i] + + def add_struct(self): + """Appends and returns a struct value as the next value in the list.""" + struct_value = self.values.add().struct_value + # Clear will mark struct_value modified which will indeed create a struct. + struct_value.Clear() + return struct_value + + def add_list(self): + """Appends and returns a list value as the next value in the list.""" + list_value = self.values.add().list_value + # Clear will mark list_value modified which will indeed create a list. + list_value.Clear() + return list_value + + +collections.abc.MutableSequence.register(ListValue) + + +# LINT.IfChange(wktbases) +WKTBASES = { + 'google.protobuf.Any': Any, + 'google.protobuf.Duration': Duration, + 'google.protobuf.FieldMask': FieldMask, + 'google.protobuf.ListValue': ListValue, + 'google.protobuf.Struct': Struct, + 'google.protobuf.Timestamp': Timestamp, +} +# LINT.ThenChange(//depot/google.protobuf/compiler/python/pyi_generator.cc:wktbases) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/wire_format.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/wire_format.py new file mode 100644 index 0000000000000000000000000000000000000000..6237dabf950e49d2d6124340c06724f41c1c2c8d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/internal/wire_format.py @@ -0,0 +1,245 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Constants and static functions to support protocol buffer wire format.""" + +__author__ = 'robinson@google.com (Will Robinson)' + +import struct +from google.protobuf import descriptor +from google.protobuf import message + + +TAG_TYPE_BITS = 3 # Number of bits used to hold type info in a proto tag. +TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1 # 0x7 + +# These numbers identify the wire type of a protocol buffer value. +# We use the least-significant TAG_TYPE_BITS bits of the varint-encoded +# tag-and-type to store one of these WIRETYPE_* constants. +# These values must match WireType enum in //google/protobuf/wire_format.h. +WIRETYPE_VARINT = 0 +WIRETYPE_FIXED64 = 1 +WIRETYPE_LENGTH_DELIMITED = 2 +WIRETYPE_START_GROUP = 3 +WIRETYPE_END_GROUP = 4 +WIRETYPE_FIXED32 = 5 +_WIRETYPE_MAX = 5 + + +# Bounds for various integer types. +INT32_MAX = int((1 << 31) - 1) +INT32_MIN = int(-(1 << 31)) +UINT32_MAX = (1 << 32) - 1 + +INT64_MAX = (1 << 63) - 1 +INT64_MIN = -(1 << 63) +UINT64_MAX = (1 << 64) - 1 + +# "struct" format strings that will encode/decode the specified formats. +FORMAT_UINT32_LITTLE_ENDIAN = '> TAG_TYPE_BITS), (tag & TAG_TYPE_MASK) + + +def ZigZagEncode(value): + """ZigZag Transform: Encodes signed integers so that they can be + effectively used with varint encoding. See wire_format.h for + more details. + """ + if value >= 0: + return value << 1 + return (value << 1) ^ (~0) + + +def ZigZagDecode(value): + """Inverse of ZigZagEncode().""" + if not value & 0x1: + return value >> 1 + return (value >> 1) ^ (~0) + + + +# The *ByteSize() functions below return the number of bytes required to +# serialize "field number + type" information and then serialize the value. + + +def Int32ByteSize(field_number, int32): + return Int64ByteSize(field_number, int32) + + +def Int32ByteSizeNoTag(int32): + return _VarUInt64ByteSizeNoTag(0xffffffffffffffff & int32) + + +def Int64ByteSize(field_number, int64): + # Have to convert to uint before calling UInt64ByteSize(). + return UInt64ByteSize(field_number, 0xffffffffffffffff & int64) + + +def UInt32ByteSize(field_number, uint32): + return UInt64ByteSize(field_number, uint32) + + +def UInt64ByteSize(field_number, uint64): + return TagByteSize(field_number) + _VarUInt64ByteSizeNoTag(uint64) + + +def SInt32ByteSize(field_number, int32): + return UInt32ByteSize(field_number, ZigZagEncode(int32)) + + +def SInt64ByteSize(field_number, int64): + return UInt64ByteSize(field_number, ZigZagEncode(int64)) + + +def Fixed32ByteSize(field_number, fixed32): + return TagByteSize(field_number) + 4 + + +def Fixed64ByteSize(field_number, fixed64): + return TagByteSize(field_number) + 8 + + +def SFixed32ByteSize(field_number, sfixed32): + return TagByteSize(field_number) + 4 + + +def SFixed64ByteSize(field_number, sfixed64): + return TagByteSize(field_number) + 8 + + +def FloatByteSize(field_number, flt): + return TagByteSize(field_number) + 4 + + +def DoubleByteSize(field_number, double): + return TagByteSize(field_number) + 8 + + +def BoolByteSize(field_number, b): + return TagByteSize(field_number) + 1 + + +def EnumByteSize(field_number, enum): + return UInt32ByteSize(field_number, enum) + + +def StringByteSize(field_number, string): + return BytesByteSize(field_number, string.encode('utf-8')) + + +def BytesByteSize(field_number, b): + return (TagByteSize(field_number) + + _VarUInt64ByteSizeNoTag(len(b)) + + len(b)) + + +def GroupByteSize(field_number, message): + return (2 * TagByteSize(field_number) # START and END group. + + message.ByteSize()) + + +def MessageByteSize(field_number, message): + return (TagByteSize(field_number) + + _VarUInt64ByteSizeNoTag(message.ByteSize()) + + message.ByteSize()) + + +def MessageSetItemByteSize(field_number, msg): + # First compute the sizes of the tags. + # There are 2 tags for the beginning and ending of the repeated group, that + # is field number 1, one with field number 2 (type_id) and one with field + # number 3 (message). + total_size = (2 * TagByteSize(1) + TagByteSize(2) + TagByteSize(3)) + + # Add the number of bytes for type_id. + total_size += _VarUInt64ByteSizeNoTag(field_number) + + message_size = msg.ByteSize() + + # The number of bytes for encoding the length of the message. + total_size += _VarUInt64ByteSizeNoTag(message_size) + + # The size of the message. + total_size += message_size + return total_size + + +def TagByteSize(field_number): + """Returns the bytes required to serialize a tag with this field number.""" + # Just pass in type 0, since the type won't affect the tag+type size. + return _VarUInt64ByteSizeNoTag(PackTag(field_number, 0)) + + +# Private helper function for the *ByteSize() functions above. + +def _VarUInt64ByteSizeNoTag(uint64): + """Returns the number of bytes required to serialize a single varint + using boundary value comparisons. (unrolled loop optimization -WPierce) + uint64 must be unsigned. + """ + if uint64 <= 0x7f: return 1 + if uint64 <= 0x3fff: return 2 + if uint64 <= 0x1fffff: return 3 + if uint64 <= 0xfffffff: return 4 + if uint64 <= 0x7ffffffff: return 5 + if uint64 <= 0x3ffffffffff: return 6 + if uint64 <= 0x1ffffffffffff: return 7 + if uint64 <= 0xffffffffffffff: return 8 + if uint64 <= 0x7fffffffffffffff: return 9 + if uint64 > UINT64_MAX: + raise message.EncodeError('Value out of range: %d' % uint64) + return 10 + + +NON_PACKABLE_TYPES = ( + descriptor.FieldDescriptor.TYPE_STRING, + descriptor.FieldDescriptor.TYPE_GROUP, + descriptor.FieldDescriptor.TYPE_MESSAGE, + descriptor.FieldDescriptor.TYPE_BYTES +) + + +def IsTypePackable(field_type): + """Return true iff packable = true is valid for fields of this type. + + Args: + field_type: a FieldDescriptor::Type value. + + Returns: + True iff fields of this type are packable. + """ + return field_type not in NON_PACKABLE_TYPES diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/json_format.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/json_format.py new file mode 100644 index 0000000000000000000000000000000000000000..9262abafa7cbc9a0d95ef6be0615bf8481aae95e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/json_format.py @@ -0,0 +1,1111 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains routines for printing protocol messages in JSON format. + +Simple usage example: + + # Create a proto object and serialize it to a json format string. + message = my_proto_pb2.MyMessage(foo='bar') + json_string = json_format.MessageToJson(message) + + # Parse a json format string to proto object. + message = json_format.Parse(json_string, my_proto_pb2.MyMessage()) +""" + +__author__ = 'jieluo@google.com (Jie Luo)' + + +import base64 +from collections import OrderedDict +import json +import math +from operator import methodcaller +import re + +from google.protobuf import descriptor +from google.protobuf import message_factory +from google.protobuf import symbol_database +from google.protobuf.internal import type_checkers + + +_INT_TYPES = frozenset([ + descriptor.FieldDescriptor.CPPTYPE_INT32, + descriptor.FieldDescriptor.CPPTYPE_UINT32, + descriptor.FieldDescriptor.CPPTYPE_INT64, + descriptor.FieldDescriptor.CPPTYPE_UINT64, +]) +_INT64_TYPES = frozenset([ + descriptor.FieldDescriptor.CPPTYPE_INT64, + descriptor.FieldDescriptor.CPPTYPE_UINT64, +]) +_FLOAT_TYPES = frozenset([ + descriptor.FieldDescriptor.CPPTYPE_FLOAT, + descriptor.FieldDescriptor.CPPTYPE_DOUBLE, +]) +_INFINITY = 'Infinity' +_NEG_INFINITY = '-Infinity' +_NAN = 'NaN' + +_UNPAIRED_SURROGATE_PATTERN = re.compile( + '[\ud800-\udbff](?![\udc00-\udfff])|(? self.max_recursion_depth: + raise ParseError( + 'Message too deep. Max recursion depth is {0}'.format( + self.max_recursion_depth + ) + ) + message_descriptor = message.DESCRIPTOR + full_name = message_descriptor.full_name + if not path: + path = message_descriptor.name + if _IsWrapperMessage(message_descriptor): + self._ConvertWrapperMessage(value, message, path) + elif full_name in _WKTJSONMETHODS: + methodcaller(_WKTJSONMETHODS[full_name][1], value, message, path)(self) + else: + self._ConvertFieldValuePair(value, message, path) + self.recursion_depth -= 1 + + def _ConvertFieldValuePair(self, js, message, path): + """Convert field value pairs into regular message. + + Args: + js: A JSON object to convert the field value pairs. + message: A regular protocol message to record the data. + path: parent path to log parse error info. + + Raises: + ParseError: In case of problems converting. + """ + names = [] + message_descriptor = message.DESCRIPTOR + fields_by_json_name = dict( + (f.json_name, f) for f in message_descriptor.fields + ) + + def _ClearFieldOrExtension(message, field): + if field.is_extension: + message.ClearExtension(field) + else: + message.ClearField(field.name) + + def _GetFieldOrExtension(message, field): + if field.is_extension: + return message.Extensions[field] + else: + return getattr(message, field.name) + + def _SetFieldOrExtension(message, field, value): + if field.is_extension: + message.Extensions[field] = value + else: + setattr(message, field.name, value) + + for name in js: + try: + field = fields_by_json_name.get(name, None) + if not field: + field = message_descriptor.fields_by_name.get(name, None) + if not field and _VALID_EXTENSION_NAME.match(name): + if not message_descriptor.is_extendable: + raise ParseError( + 'Message type {0} does not have extensions at {1}'.format( + message_descriptor.full_name, path + ) + ) + identifier = name[1:-1] # strip [] brackets + # pylint: disable=protected-access + field = message.Extensions._FindExtensionByName(identifier) + # pylint: enable=protected-access + if not field: + # Try looking for extension by the message type name, dropping the + # field name following the final . separator in full_name. + identifier = '.'.join(identifier.split('.')[:-1]) + # pylint: disable=protected-access + field = message.Extensions._FindExtensionByName(identifier) + # pylint: enable=protected-access + if not field: + if self.ignore_unknown_fields: + continue + raise ParseError( + ( + 'Message type "{0}" has no field named "{1}" at "{2}".\n' + ' Available Fields(except extensions): "{3}"' + ).format( + message_descriptor.full_name, + name, + path, + [f.json_name for f in message_descriptor.fields], + ) + ) + if name in names: + raise ParseError( + 'Message type "{0}" should not have multiple ' + '"{1}" fields at "{2}".'.format( + message.DESCRIPTOR.full_name, name, path + ) + ) + names.append(name) + value = js[name] + # Check no other oneof field is parsed. + if field.containing_oneof is not None and value is not None: + oneof_name = field.containing_oneof.name + if oneof_name in names: + raise ParseError( + 'Message type "{0}" should not have multiple ' + '"{1}" oneof fields at "{2}".'.format( + message.DESCRIPTOR.full_name, oneof_name, path + ) + ) + names.append(oneof_name) + + if value is None: + if ( + field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE + and field.message_type.full_name == 'google.protobuf.Value' + ): + sub_message = _GetFieldOrExtension(message, field) + sub_message.null_value = 0 + elif ( + field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM + and field.enum_type.full_name == 'google.protobuf.NullValue' + ): + _SetFieldOrExtension(message, field, 0) + else: + _ClearFieldOrExtension(message, field) + continue + + # Parse field value. + if _IsMapEntry(field): + _ClearFieldOrExtension(message, field) + self._ConvertMapFieldValue( + value, message, field, '{0}.{1}'.format(path, name) + ) + elif field.is_repeated: + _ClearFieldOrExtension(message, field) + if not isinstance(value, _LIST_LIKE): + raise ParseError( + 'repeated field {0} must be in [] which is {1} at {2}'.format( + name, value, path + ) + ) + if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE: + # Repeated message field. + for index, item in enumerate(value): + sub_message = _GetFieldOrExtension(message, field).add() + # None is a null_value in Value. + if ( + item is None + and sub_message.DESCRIPTOR.full_name + != 'google.protobuf.Value' + ): + raise ParseError( + 'null is not allowed to be used as an element' + ' in a repeated field at {0}.{1}[{2}]'.format( + path, name, index + ) + ) + self.ConvertMessage( + item, sub_message, '{0}.{1}[{2}]'.format(path, name, index) + ) + else: + # Repeated scalar field. + for index, item in enumerate(value): + if item is None: + raise ParseError( + 'null is not allowed to be used as an element' + ' in a repeated field at {0}.{1}[{2}]'.format( + path, name, index + ) + ) + self._ConvertAndAppendScalar( + message, field, item, '{0}.{1}[{2}]'.format(path, name, index) + ) + elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE: + sub_message = _GetFieldOrExtension(message, field) + sub_message.SetInParent() + self.ConvertMessage(value, sub_message, '{0}.{1}'.format(path, name)) + else: + self._ConvertAndSetScalar( + message, field, value, '{0}.{1}'.format(path, name) + ) + except ParseError as e: + if field and field.containing_oneof is None: + raise ParseError( + 'Failed to parse {0} field: {1}.'.format(name, e) + ) from e + else: + raise ParseError(str(e)) from e + except ValueError as e: + raise ParseError( + 'Failed to parse {0} field: {1}.'.format(name, e) + ) from e + except TypeError as e: + raise ParseError( + 'Failed to parse {0} field: {1}.'.format(name, e) + ) from e + + def _ConvertAnyMessage(self, value, message, path): + """Convert a JSON representation into Any message.""" + if isinstance(value, dict) and not value: + return + try: + type_url = value['@type'] + except KeyError as e: + raise ParseError( + '@type is missing when parsing any message at {0}'.format(path) + ) from e + + try: + sub_message = _CreateMessageFromTypeUrl(type_url, self.descriptor_pool) + except TypeError as e: + raise ParseError('{0} at {1}'.format(e, path)) from e + message_descriptor = sub_message.DESCRIPTOR + full_name = message_descriptor.full_name + if _IsWrapperMessage(message_descriptor): + self._ConvertWrapperMessage( + value['value'], sub_message, '{0}.value'.format(path) + ) + elif full_name in _WKTJSONMETHODS: + # For well-known types (including nested Any), use ConvertMessage + # to ensure recursion depth is properly tracked + self.ConvertMessage( + value['value'], sub_message, '{0}.value'.format(path) + ) + else: + del value['@type'] + try: + self._ConvertFieldValuePair(value, sub_message, path) + finally: + value['@type'] = type_url + # Sets Any message + message.value = sub_message.SerializeToString() + message.type_url = type_url + + def _ConvertGenericMessage(self, value, message, path): + """Convert a JSON representation into message with FromJsonString.""" + # Duration, Timestamp, FieldMask have a FromJsonString method to do the + # conversion. Users can also call the method directly. + try: + message.FromJsonString(value) + except ValueError as e: + raise ParseError('{0} at {1}'.format(e, path)) from e + + def _ConvertValueMessage(self, value, message, path): + """Convert a JSON representation into Value message.""" + if isinstance(value, dict): + self._ConvertStructMessage(value, message.struct_value, path) + elif isinstance(value, _LIST_LIKE): + self._ConvertListOrTupleValueMessage(value, message.list_value, path) + elif value is None: + message.null_value = 0 + elif isinstance(value, bool): + message.bool_value = value + elif isinstance(value, str): + message.string_value = value + elif isinstance(value, _INT_OR_FLOAT): + message.number_value = value + else: + raise ParseError( + 'Value {0} has unexpected type {1} at {2}'.format( + value, type(value), path + ) + ) + + def _ConvertListOrTupleValueMessage(self, value, message, path): + """Convert a JSON representation into ListValue message.""" + if not isinstance(value, _LIST_LIKE): + raise ParseError( + 'ListValue must be in [] which is {0} at {1}'.format(value, path) + ) + message.ClearField('values') + for index, item in enumerate(value): + self._ConvertValueMessage( + item, message.values.add(), '{0}[{1}]'.format(path, index) + ) + + def _ConvertStructMessage(self, value, message, path): + """Convert a JSON representation into Struct message.""" + if not isinstance(value, dict): + raise ParseError( + 'Struct must be in a dict which is {0} at {1}'.format(value, path) + ) + # Clear will mark the struct as modified so it will be created even if + # there are no values. + message.Clear() + for key in value: + self._ConvertValueMessage( + value[key], message.fields[key], '{0}.{1}'.format(path, key) + ) + return + + def _ConvertWrapperMessage(self, value, message, path): + """Convert a JSON representation into Wrapper message.""" + field = message.DESCRIPTOR.fields_by_name['value'] + self._ConvertAndSetScalar( + message, field, value, path='{0}.value'.format(path) + ) + + def _ConvertMapFieldValue(self, value, message, field, path): + """Convert map field value for a message map field. + + Args: + value: A JSON object to convert the map field value. + message: A protocol message to record the converted data. + field: The descriptor of the map field to be converted. + path: parent path to log parse error info. + + Raises: + ParseError: In case of convert problems. + """ + if not isinstance(value, dict): + raise ParseError( + 'Map field {0} must be in a dict which is {1} at {2}'.format( + field.name, value, path + ) + ) + key_field = field.message_type.fields_by_name['key'] + value_field = field.message_type.fields_by_name['value'] + for key in value: + key_value = _ConvertScalarFieldValue( + key, key_field, '{0}.key'.format(path), True + ) + if value_field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE: + self.ConvertMessage( + value[key], + getattr(message, field.name)[key_value], + '{0}[{1}]'.format(path, key_value), + ) + else: + self._ConvertAndSetScalarToMapKey( + message, + field, + key_value, + value[key], + path='{0}[{1}]'.format(path, key_value), + ) + + def _ConvertAndSetScalar(self, message, field, js_value, path): + """Convert scalar from js_value and assign it to message.field.""" + try: + value = _ConvertScalarFieldValue(js_value, field, path) + if field.is_extension: + message.Extensions[field] = value + else: + setattr(message, field.name, value) + except EnumStringValueParseError: + if not self.ignore_unknown_fields: + raise + + def _ConvertAndAppendScalar(self, message, repeated_field, js_value, path): + """Convert scalar from js_value and append it to message.repeated_field.""" + try: + if repeated_field.is_extension: + repeated = message.Extensions[repeated_field] + else: + repeated = getattr(message, repeated_field.name) + value = _ConvertScalarFieldValue(js_value, repeated_field, path) + repeated.append(value) + except EnumStringValueParseError: + if not self.ignore_unknown_fields: + raise + + def _ConvertAndSetScalarToMapKey( + self, message, map_field, converted_key, js_value, path + ): + """Convert scalar from 'js_value' and add it to message.map_field[converted_key].""" + try: + getattr(message, map_field.name)[converted_key] = ( + _ConvertScalarFieldValue( + js_value, + map_field.message_type.fields_by_name['value'], + path, + ) + ) + except EnumStringValueParseError: + if not self.ignore_unknown_fields: + raise + + +def _ConvertScalarFieldValue(value, field, path, require_str=False): + """Convert a single scalar field value. + + Args: + value: A scalar value to convert the scalar field value. + field: The descriptor of the field to convert. + path: parent path to log parse error info. + require_str: If True, the field value must be a str. + + Returns: + The converted scalar field value + + Raises: + ParseError: In case of convert problems. + EnumStringValueParseError: In case of unknown enum string value. + """ + try: + if field.cpp_type in _INT_TYPES: + return _ConvertInteger(value) + elif field.cpp_type in _FLOAT_TYPES: + return _ConvertFloat(value, field) + elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL: + return _ConvertBool(value, require_str) + elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING: + if field.type == descriptor.FieldDescriptor.TYPE_BYTES: + if isinstance(value, str): + encoded = value.encode('utf-8') + else: + encoded = value + # Add extra padding '=' + padded_value = encoded + b'=' * (4 - len(encoded) % 4) + return base64.urlsafe_b64decode(padded_value) + else: + # Checking for unpaired surrogates appears to be unreliable, + # depending on the specific Python version, so we check manually. + if _UNPAIRED_SURROGATE_PATTERN.search(value): + raise ParseError('Unpaired surrogate') + return value + elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM: + # Convert an enum value. + enum_value = field.enum_type.values_by_name.get(value, None) + if enum_value is None: + try: + number = int(value) + enum_value = field.enum_type.values_by_number.get(number, None) + except ValueError as e: + # Since parsing to integer failed and lookup in values_by_name didn't + # find this name, we have an enum string value which is unknown. + raise EnumStringValueParseError( + 'Invalid enum value {0} for enum type {1}'.format( + value, field.enum_type.full_name + ) + ) from e + if enum_value is None: + if field.enum_type.is_closed: + raise ParseError( + 'Invalid enum value {0} for enum type {1}'.format( + value, field.enum_type.full_name + ) + ) + else: + return number + return enum_value.number + except EnumStringValueParseError as e: + raise EnumStringValueParseError('{0} at {1}'.format(e, path)) from e + except ParseError as e: + raise ParseError('{0} at {1}'.format(e, path)) from e + + +def _ConvertInteger(value): + """Convert an integer. + + Args: + value: A scalar value to convert. + + Returns: + The integer value. + + Raises: + ParseError: If an integer couldn't be consumed. + """ + if isinstance(value, float) and not value.is_integer(): + raise ParseError("Couldn't parse integer: {0}".format(value)) + + if isinstance(value, str) and value.find(' ') != -1: + raise ParseError('Couldn\'t parse integer: "{0}"'.format(value)) + + if isinstance(value, bool): + raise ParseError( + 'Bool value {0} is not acceptable for integer field'.format(value) + ) + + try: + return int(value) + except ValueError as e: + # Attempt to parse as an integer-valued float. + try: + f = float(value) + except ValueError: + # Raise the original exception for the int parse. + raise e # pylint: disable=raise-missing-from + if not f.is_integer(): + raise ParseError( + 'Couldn\'t parse non-integer string: "{0}"'.format(value) + ) from e + return int(f) + + +def _ConvertFloat(value, field): + """Convert an floating point number.""" + if isinstance(value, float): + if math.isnan(value): + raise ParseError('Couldn\'t parse NaN, use quoted "NaN" instead') + if math.isinf(value): + if value > 0: + raise ParseError( + "Couldn't parse Infinity or value too large, " + 'use quoted "Infinity" instead' + ) + else: + raise ParseError( + "Couldn't parse -Infinity or value too small, " + 'use quoted "-Infinity" instead' + ) + if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_FLOAT: + # pylint: disable=protected-access + if value > type_checkers._FLOAT_MAX: + raise ParseError('Float value too large') + # pylint: disable=protected-access + if value < type_checkers._FLOAT_MIN: + raise ParseError('Float value too small') + if value == 'nan': + raise ParseError('Couldn\'t parse float "nan", use "NaN" instead') + try: + # Assume Python compatible syntax. + return float(value) + except ValueError as e: + # Check alternative spellings. + if value == _NEG_INFINITY: + return float('-inf') + elif value == _INFINITY: + return float('inf') + elif value == _NAN: + return float('nan') + else: + raise ParseError("Couldn't parse float: {0}".format(value)) from e + + +def _ConvertBool(value, require_str): + """Convert a boolean value. + + Args: + value: A scalar value to convert. + require_str: If True, value must be a str. + + Returns: + The bool parsed. + + Raises: + ParseError: If a boolean value couldn't be consumed. + """ + if require_str: + if value == 'true': + return True + elif value == 'false': + return False + else: + raise ParseError('Expected "true" or "false", not {0}'.format(value)) + + if not isinstance(value, bool): + raise ParseError('Expected true or false without quotes') + return value + + +_WKTJSONMETHODS = { + 'google.protobuf.Any': ['_AnyMessageToJsonObject', '_ConvertAnyMessage'], + 'google.protobuf.Duration': [ + '_GenericMessageToJsonObject', + '_ConvertGenericMessage', + ], + 'google.protobuf.FieldMask': [ + '_GenericMessageToJsonObject', + '_ConvertGenericMessage', + ], + 'google.protobuf.ListValue': [ + '_ListValueMessageToJsonObject', + '_ConvertListOrTupleValueMessage', + ], + 'google.protobuf.Struct': [ + '_StructMessageToJsonObject', + '_ConvertStructMessage', + ], + 'google.protobuf.Timestamp': [ + '_GenericMessageToJsonObject', + '_ConvertGenericMessage', + ], + 'google.protobuf.Value': [ + '_ValueMessageToJsonObject', + '_ConvertValueMessage', + ], +} diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/message.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/message.py new file mode 100644 index 0000000000000000000000000000000000000000..d48f4f409d055f6e47fa7985a8be0c96bdb57797 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/message.py @@ -0,0 +1,448 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +# TODO: We should just make these methods all "pure-virtual" and move +# all implementation out, into reflection.py for now. + + +"""Contains an abstract base class for protocol messages.""" + +__author__ = 'robinson@google.com (Will Robinson)' + +_INCONSISTENT_MESSAGE_ATTRIBUTES = ('Extensions',) + + +class Error(Exception): + """Base error type for this module.""" + pass + + +class DecodeError(Error): + """Exception raised when deserializing messages.""" + pass + + +class EncodeError(Error): + """Exception raised when serializing messages.""" + pass + + +class Message(object): + + """Abstract base class for protocol messages. + + Protocol message classes are almost always generated by the protocol + compiler. These generated types subclass Message and implement the methods + shown below. + """ + + # TODO: Link to an HTML document here. + + # TODO: Document that instances of this class will also + # have an Extensions attribute with __getitem__ and __setitem__. + # Again, not sure how to best convey this. + + # TODO: Document these fields and methods. + + __slots__ = [] + + #: The :class:`google.protobuf.Descriptor` + # for this message type. + DESCRIPTOR = None + + def __deepcopy__(self, memo=None): + clone = type(self)() + clone.MergeFrom(self) + return clone + + def __dir__(self): + """Provides the list of all accessible Message attributes.""" + message_attributes = set(super().__dir__()) + + # TODO: Remove this once the UPB implementation is improved. + # The UPB proto implementation currently doesn't provide proto fields as + # attributes and they have to added. + if self.DESCRIPTOR is not None: + for field in self.DESCRIPTOR.fields: + message_attributes.add(field.name) + + # The Fast C++ proto implementation provides inaccessible attributes that + # have to be removed. + for attribute in _INCONSISTENT_MESSAGE_ATTRIBUTES: + if attribute not in message_attributes: + continue + try: + getattr(self, attribute) + except AttributeError: + message_attributes.remove(attribute) + + return sorted(message_attributes) + + def __eq__(self, other_msg): + """Recursively compares two messages by value and structure.""" + raise NotImplementedError + + def __ne__(self, other_msg): + # Can't just say self != other_msg, since that would infinitely recurse. :) + return not self == other_msg + + def __hash__(self): + raise TypeError('unhashable object') + + def __str__(self): + """Outputs a human-readable representation of the message.""" + raise NotImplementedError + + def __unicode__(self): + """Outputs a human-readable representation of the message.""" + raise NotImplementedError + + def __contains__(self, field_name_or_key): + """Checks if a certain field is set for the message. + + Has presence fields return true if the field is set, false if the field is + not set. Fields without presence do raise `ValueError` (this includes + repeated fields, map fields, and implicit presence fields). + + If field_name is not defined in the message descriptor, `ValueError` will + be raised. + Note: WKT Struct checks if the key is contained in fields. ListValue checks + if the item is contained in the list. + + Args: + field_name_or_key: For Struct, the key (str) of the fields map. For + ListValue, any type that may be contained in the list. For other + messages, name of the field (str) to check for presence. + + Returns: + bool: For Struct, whether the item is contained in fields. For ListValue, + whether the item is contained in the list. For other message, + whether a value has been set for the named field. + + Raises: + ValueError: For normal messages, if the `field_name_or_key` is not a + member of this message or `field_name_or_key` is not a string. + """ + raise NotImplementedError + + def MergeFrom(self, other_msg): + """Merges the contents of the specified message into current message. + + This method merges the contents of the specified message into the current + message. Singular fields that are set in the specified message overwrite + the corresponding fields in the current message. Repeated fields are + appended. Singular sub-messages and groups are recursively merged. + + Args: + other_msg (Message): A message to merge into the current message. + """ + raise NotImplementedError + + def CopyFrom(self, other_msg): + """Copies the content of the specified message into the current message. + + The method clears the current message and then merges the specified + message using MergeFrom. + + Args: + other_msg (Message): A message to copy into the current one. + """ + if self is other_msg: + return + self.Clear() + self.MergeFrom(other_msg) + + def Clear(self): + """Clears all data that was set in the message.""" + raise NotImplementedError + + def SetInParent(self): + """Mark this as present in the parent. + + This normally happens automatically when you assign a field of a + sub-message, but sometimes you want to make the sub-message + present while keeping it empty. If you find yourself using this, + you may want to reconsider your design. + """ + raise NotImplementedError + + def IsInitialized(self): + """Checks if the message is initialized. + + Returns: + bool: The method returns True if the message is initialized (i.e. all of + its required fields are set). + """ + raise NotImplementedError + + # TODO: MergeFromString() should probably return None and be + # implemented in terms of a helper that returns the # of bytes read. Our + # deserialization routines would use the helper when recursively + # deserializing, but the end user would almost always just want the no-return + # MergeFromString(). + + def MergeFromString(self, serialized): + """Merges serialized protocol buffer data into this message. + + When we find a field in `serialized` that is already present + in this message: + + - If it's a "repeated" field, we append to the end of our list. + - Else, if it's a scalar, we overwrite our field. + - Else, (it's a nonrepeated composite), we recursively merge + into the existing composite. + + Args: + serialized (bytes): Any object that allows us to call + ``memoryview(serialized)`` to access a string of bytes using the + buffer interface. + + Returns: + int: The number of bytes read from `serialized`. + For non-group messages, this will always be `len(serialized)`, + but for messages which are actually groups, this will + generally be less than `len(serialized)`, since we must + stop when we reach an ``END_GROUP`` tag. Note that if + we *do* stop because of an ``END_GROUP`` tag, the number + of bytes returned does not include the bytes + for the ``END_GROUP`` tag information. + + Raises: + DecodeError: if the input cannot be parsed. + """ + # TODO: Document handling of unknown fields. + # TODO: When we switch to a helper, this will return None. + raise NotImplementedError + + def ParseFromString(self, serialized): + """Parse serialized protocol buffer data in binary form into this message. + + Like :func:`MergeFromString()`, except we clear the object first. + + Raises: + message.DecodeError if the input cannot be parsed. + """ + self.Clear() + return self.MergeFromString(serialized) + + def SerializeToString(self, **kwargs): + """Serializes the protocol message to a binary string. + + Keyword Args: + deterministic (bool): If true, requests deterministic serialization + of the protobuf, with predictable ordering of map keys. + + Returns: + A binary string representation of the message if all of the required + fields in the message are set (i.e. the message is initialized). + + Raises: + EncodeError: if the message isn't initialized (see :func:`IsInitialized`). + """ + raise NotImplementedError + + def SerializePartialToString(self, **kwargs): + """Serializes the protocol message to a binary string. + + This method is similar to SerializeToString but doesn't check if the + message is initialized. + + Keyword Args: + deterministic (bool): If true, requests deterministic serialization + of the protobuf, with predictable ordering of map keys. + + Returns: + bytes: A serialized representation of the partial message. + """ + raise NotImplementedError + + # TODO: Decide whether we like these better + # than auto-generated has_foo() and clear_foo() methods + # on the instances themselves. This way is less consistent + # with C++, but it makes reflection-type access easier and + # reduces the number of magically autogenerated things. + # + # TODO: Be sure to document (and test) exactly + # which field names are accepted here. Are we case-sensitive? + # What do we do with fields that share names with Python keywords + # like 'lambda' and 'yield'? + # + # nnorwitz says: + # """ + # Typically (in python), an underscore is appended to names that are + # keywords. So they would become lambda_ or yield_. + # """ + def ListFields(self): + """Returns a list of (FieldDescriptor, value) tuples for present fields. + + A message field is non-empty if HasField() would return true. A singular + primitive field is non-empty if HasField() would return true in proto2 or it + is non zero in proto3. A repeated field is non-empty if it contains at least + one element. The fields are ordered by field number. + + Returns: + list[tuple(FieldDescriptor, value)]: field descriptors and values + for all fields in the message which are not empty. The values vary by + field type. + """ + raise NotImplementedError + + def HasField(self, field_name): + """Checks if a certain field is set for the message. + + For a oneof group, checks if any field inside is set. Note that if the + field_name is not defined in the message descriptor, :exc:`ValueError` will + be raised. + + Args: + field_name (str): The name of the field to check for presence. + + Returns: + bool: Whether a value has been set for the named field. + + Raises: + ValueError: if the `field_name` is not a member of this message. + """ + raise NotImplementedError + + def ClearField(self, field_name): + """Clears the contents of a given field. + + Inside a oneof group, clears the field set. If the name neither refers to a + defined field or oneof group, :exc:`ValueError` is raised. + + Args: + field_name (str): The name of the field to check for presence. + + Raises: + ValueError: if the `field_name` is not a member of this message. + """ + raise NotImplementedError + + def WhichOneof(self, oneof_group): + """Returns the name of the field that is set inside a oneof group. + + If no field is set, returns None. + + Args: + oneof_group (str): the name of the oneof group to check. + + Returns: + str or None: The name of the group that is set, or None. + + Raises: + ValueError: no group with the given name exists + """ + raise NotImplementedError + + def HasExtension(self, field_descriptor): + """Checks if a certain extension is present for this message. + + Extensions are retrieved using the :attr:`Extensions` mapping (if present). + + Args: + field_descriptor: The field descriptor for the extension to check. + + Returns: + bool: Whether the extension is present for this message. + + Raises: + KeyError: if the extension is repeated. Similar to repeated fields, + there is no separate notion of presence: a "not present" repeated + extension is an empty list. + """ + raise NotImplementedError + + def ClearExtension(self, field_descriptor): + """Clears the contents of a given extension. + + Args: + field_descriptor: The field descriptor for the extension to clear. + """ + raise NotImplementedError + + def UnknownFields(self): + """Returns the UnknownFieldSet. + + Returns: + UnknownFieldSet: The unknown fields stored in this message. + """ + raise NotImplementedError + + def DiscardUnknownFields(self): + """Clears all fields in the :class:`UnknownFieldSet`. + + This operation is recursive for nested message. + """ + raise NotImplementedError + + def ByteSize(self): + """Returns the serialized size of this message. + + Recursively calls ByteSize() on all contained messages. + + Returns: + int: The number of bytes required to serialize this message. + """ + raise NotImplementedError + + @classmethod + def FromString(cls, s): + raise NotImplementedError + + def _SetListener(self, message_listener): + """Internal method used by the protocol message implementation. + Clients should not call this directly. + + Sets a listener that this message will call on certain state transitions. + + The purpose of this method is to register back-edges from children to + parents at runtime, for the purpose of setting "has" bits and + byte-size-dirty bits in the parent and ancestor objects whenever a child or + descendant object is modified. + + If the client wants to disconnect this Message from the object tree, she + explicitly sets callback to None. + + If message_listener is None, unregisters any existing listener. Otherwise, + message_listener must implement the MessageListener interface in + internal/message_listener.py, and we discard any listener registered + via a previous _SetListener() call. + """ + raise NotImplementedError + + def __getstate__(self): + """Support the pickle protocol.""" + return dict(serialized=self.SerializePartialToString()) + + def __setstate__(self, state): + """Support the pickle protocol.""" + self.__init__() + serialized = state['serialized'] + # On Python 3, using encoding='latin1' is required for unpickling + # protos pickled by Python 2. + if not isinstance(serialized, bytes): + serialized = serialized.encode('latin1') + self.ParseFromString(serialized) + + def __reduce__(self): + message_descriptor = self.DESCRIPTOR + if message_descriptor.containing_type is None: + return type(self), (), self.__getstate__() + # the message type must be nested. + # Python does not pickle nested classes; use the symbol_database on the + # receiving end. + container = message_descriptor + return (_InternalConstructMessage, (container.full_name,), + self.__getstate__()) + + +def _InternalConstructMessage(full_name): + """Constructs a nested message.""" + from google.protobuf import symbol_database # pylint:disable=g-import-not-at-top + + return symbol_database.Default().GetSymbol(full_name)() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/message_factory.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/message_factory.py new file mode 100644 index 0000000000000000000000000000000000000000..3bc4d92867c08199a582d515e6e326e3bc29ce82 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/message_factory.py @@ -0,0 +1,190 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Provides a factory class for generating dynamic messages. + +The easiest way to use this class is if you have access to the FileDescriptor +protos containing the messages you want to create you can just do the following: + +message_classes = message_factory.GetMessages(iterable_of_file_descriptors) +my_proto_instance = message_classes['some.proto.package.MessageName']() +""" + +__author__ = 'matthewtoia@google.com (Matt Toia)' + +import warnings + +from google.protobuf import descriptor_pool +from google.protobuf import message +from google.protobuf.internal import api_implementation + +if api_implementation.Type() == 'python': + from google.protobuf.internal import python_message as message_impl +else: + from google.protobuf.pyext import cpp_message as message_impl # pylint: disable=g-import-not-at-top + + +# The type of all Message classes. +_GENERATED_PROTOCOL_MESSAGE_TYPE = message_impl.GeneratedProtocolMessageType + + +def GetMessageClass(descriptor): + """Obtains a proto2 message class based on the passed in descriptor. + + Passing a descriptor with a fully qualified name matching a previous + invocation will cause the same class to be returned. + + Args: + descriptor: The descriptor to build from. + + Returns: + A class describing the passed in descriptor. + """ + concrete_class = getattr(descriptor, '_concrete_class', None) + if concrete_class: + return concrete_class + return _InternalCreateMessageClass(descriptor) + + +def GetMessageClassesForFiles(files, pool): + """Gets all the messages from specified files. + + This will find and resolve dependencies, failing if the descriptor + pool cannot satisfy them. + + This will not return the classes for nested types within those classes, for + those, use GetMessageClass() on the nested types within their containing + messages. + + For example, for the message: + + message NestedTypeMessage { + message NestedType { + string data = 1; + } + NestedType nested = 1; + } + + NestedTypeMessage will be in the result, but not + NestedTypeMessage.NestedType. + + Args: + files: The file names to extract messages from. + pool: The descriptor pool to find the files including the dependent files. + + Returns: + A dictionary mapping proto names to the message classes. + """ + result = {} + for file_name in files: + file_desc = pool.FindFileByName(file_name) + for desc in file_desc.message_types_by_name.values(): + result[desc.full_name] = GetMessageClass(desc) + + # While the extension FieldDescriptors are created by the descriptor pool, + # the python classes created in the factory need them to be registered + # explicitly, which is done below. + # + # The call to RegisterExtension will specifically check if the + # extension was already registered on the object and either + # ignore the registration if the original was the same, or raise + # an error if they were different. + + for extension in file_desc.extensions_by_name.values(): + _ = GetMessageClass(extension.containing_type) + if api_implementation.Type() != 'python': + # TODO: Remove this check here. Duplicate extension + # register check should be in descriptor_pool. + if extension is not pool.FindExtensionByNumber( + extension.containing_type, extension.number + ): + raise ValueError('Double registration of Extensions') + # Recursively load protos for extension field, in order to be able to + # fully represent the extension. This matches the behavior for regular + # fields too. + if extension.message_type: + GetMessageClass(extension.message_type) + return result + + +def _InternalCreateMessageClass(descriptor): + """Builds a proto2 message class based on the passed in descriptor. + + Args: + descriptor: The descriptor to build from. + + Returns: + A class describing the passed in descriptor. + """ + descriptor_name = descriptor.name + result_class = _GENERATED_PROTOCOL_MESSAGE_TYPE( + descriptor_name, + (message.Message,), + { + 'DESCRIPTOR': descriptor, + # If module not set, it wrongly points to message_factory module. + '__module__': None, + }, + ) + for field in descriptor.fields: + if field.message_type: + GetMessageClass(field.message_type) + + for extension in result_class.DESCRIPTOR.extensions: + extended_class = GetMessageClass(extension.containing_type) + if api_implementation.Type() != 'python': + # TODO: Remove this check here. Duplicate extension + # register check should be in descriptor_pool. + pool = extension.containing_type.file.pool + if extension is not pool.FindExtensionByNumber( + extension.containing_type, extension.number + ): + raise ValueError('Double registration of Extensions') + if extension.message_type: + GetMessageClass(extension.message_type) + return result_class + + +# Deprecated. Please use GetMessageClass() or GetMessageClassesForFiles() +# method above instead. +class MessageFactory(object): + """Factory for creating Proto2 messages from descriptors in a pool.""" + + def __init__(self, pool=None): + """Initializes a new factory.""" + self.pool = pool or descriptor_pool.DescriptorPool() + + +def GetMessages(file_protos, pool=None): + """Builds a dictionary of all the messages available in a set of files. + + Args: + file_protos: Iterable of FileDescriptorProto to build messages out of. + pool: The descriptor pool to add the file protos. + + Returns: + A dictionary mapping proto names to the message classes. This will include + any dependent messages as well as any messages defined in the same file as + a specified message. + """ + # The cpp implementation of the protocol buffer library requires to add the + # message in topological order of the dependency graph. + des_pool = pool or descriptor_pool.DescriptorPool() + file_by_name = {file_proto.name: file_proto for file_proto in file_protos} + + def _AddFile(file_proto): + for dependency in file_proto.dependency: + if dependency in file_by_name: + # Remove from elements to be visited, in order to cut cycles. + _AddFile(file_by_name.pop(dependency)) + des_pool.Add(file_proto) + + while file_by_name: + _AddFile(file_by_name.popitem()[1]) + return GetMessageClassesForFiles( + [file_proto.name for file_proto in file_protos], des_pool + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto.py new file mode 100644 index 0000000000000000000000000000000000000000..1e6291c3ae4a6908b66437648e6f550e1113acc0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto.py @@ -0,0 +1,153 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains the Nextgen Pythonic protobuf APIs.""" + +import io +from typing import Text, Type, TypeVar + +from google.protobuf.internal import decoder +from google.protobuf.internal import encoder +from google.protobuf.message import Message + +_MESSAGE = TypeVar('_MESSAGE', bound='Message') + + +def serialize(message: _MESSAGE, deterministic: bool = None) -> bytes: + """Return the serialized proto. + + Args: + message: The proto message to be serialized. + deterministic: If true, requests deterministic serialization + of the protobuf, with predictable ordering of map keys. + + Returns: + A binary bytes representation of the message. + """ + return message.SerializeToString(deterministic=deterministic) + + +def parse(message_class: Type[_MESSAGE], payload: bytes) -> _MESSAGE: + """Given a serialized data in binary form, deserialize it into a Message. + + Args: + message_class: The message meta class. + payload: A serialized bytes in binary form. + + Returns: + A new message deserialized from payload. + """ + new_message = message_class() + new_message.ParseFromString(payload) + return new_message + + +def serialize_length_prefixed(message: _MESSAGE, output: io.BytesIO) -> None: + """Writes the size of the message as a varint and the serialized message. + + Writes the size of the message as a varint and then the serialized message. + This allows more data to be written to the output after the message. Use + parse_length_prefixed to parse messages written by this method. + + The output stream must be buffered, e.g. using + https://docs.python.org/3/library/io.html#buffered-streams. + + Example usage: + out = io.BytesIO() + for msg in message_list: + proto.serialize_length_prefixed(msg, out) + + Args: + message: The protocol buffer message that should be serialized. + output: BytesIO or custom buffered IO that data should be written to. + """ + size = message.ByteSize() + encoder._VarintEncoder()(output.write, size) + out_size = output.write(serialize(message)) + + if out_size != size: + raise TypeError( + 'Failed to write complete message (wrote: %d, expected: %d)' + '. Ensure output is using buffered IO.' % (out_size, size) + ) + + +def parse_length_prefixed( + message_class: Type[_MESSAGE], input_bytes: io.BytesIO +) -> _MESSAGE: + """Parse a message from input_bytes. + + Args: + message_class: The protocol buffer message class that parser should parse. + input_bytes: A buffered input. + + Example usage: + while True: + msg = proto.parse_length_prefixed(message_class, input_bytes) + if msg is None: + break + ... + + Returns: + A parsed message if successful. None if input_bytes is at EOF. + """ + size = decoder._DecodeVarint(input_bytes) + if size is None: + # It is the end of buffered input. See example usage in the + # API description. + return None + + message = message_class() + + if size == 0: + return message + + parsed_size = message.ParseFromString(input_bytes.read(size)) + if parsed_size != size: + raise ValueError( + 'Truncated message or non-buffered input_bytes: ' + 'Expected {0} bytes but only {1} bytes parsed for ' + '{2}.'.format(size, parsed_size, message.DESCRIPTOR.name) + ) + return message + + +def byte_size(message: Message) -> int: + """Returns the serialized size of this message. + + Args: + message: A proto message. + + Returns: + int: The number of bytes required to serialize this message. + """ + return message.ByteSize() + + +def clear_message(message: Message) -> None: + """Clears all data that was set in the message. + + Args: + message: The proto message to be cleared. + """ + message.Clear() + + +def clear_field(message: Message, field_name: Text) -> None: + """Clears the contents of a given field. + + Inside a oneof group, clears the field set. If the name neither refers to a + defined field or oneof group, :exc:`ValueError` is raised. + + Args: + message: The proto message. + field_name (str): The name of the field to be cleared. + + Raises: + ValueError: if the `field_name` is not a member of this message. + """ + message.ClearField(field_name) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_builder.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..803d0040a99b6347d12c1e3891e0928ec8a4751f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_builder.py @@ -0,0 +1,111 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Dynamic Protobuf class creator.""" + +from collections import OrderedDict +import hashlib +import os + +from google.protobuf import descriptor_pb2 +from google.protobuf import descriptor +from google.protobuf import descriptor_pool +from google.protobuf import message_factory + + +def _GetMessageFromFactory(pool, full_name): + """Get a proto class from the MessageFactory by name. + + Args: + pool: a descriptor pool. + full_name: str, the fully qualified name of the proto type. + Returns: + A class, for the type identified by full_name. + Raises: + KeyError, if the proto is not found in the factory's descriptor pool. + """ + proto_descriptor = pool.FindMessageTypeByName(full_name) + proto_cls = message_factory.GetMessageClass(proto_descriptor) + return proto_cls + + +def MakeSimpleProtoClass(fields, full_name=None, pool=None): + """Create a Protobuf class whose fields are basic types. + + Note: this doesn't validate field names! + + Args: + fields: dict of {name: field_type} mappings for each field in the proto. If + this is an OrderedDict the order will be maintained, otherwise the + fields will be sorted by name. + full_name: optional str, the fully-qualified name of the proto type. + pool: optional DescriptorPool instance. + Returns: + a class, the new protobuf class with a FileDescriptor. + """ + pool_instance = pool or descriptor_pool.DescriptorPool() + if full_name is not None: + try: + proto_cls = _GetMessageFromFactory(pool_instance, full_name) + return proto_cls + except KeyError: + # The factory's DescriptorPool doesn't know about this class yet. + pass + + # Get a list of (name, field_type) tuples from the fields dict. If fields was + # an OrderedDict we keep the order, but otherwise we sort the field to ensure + # consistent ordering. + field_items = fields.items() + if not isinstance(fields, OrderedDict): + field_items = sorted(field_items) + + # Use a consistent file name that is unlikely to conflict with any imported + # proto files. + fields_hash = hashlib.sha1() + for f_name, f_type in field_items: + fields_hash.update(f_name.encode('utf-8')) + fields_hash.update(str(f_type).encode('utf-8')) + proto_file_name = fields_hash.hexdigest() + '.proto' + + # If the proto is anonymous, use the same hash to name it. + if full_name is None: + full_name = ('net.proto2.python.public.proto_builder.AnonymousProto_' + + fields_hash.hexdigest()) + try: + proto_cls = _GetMessageFromFactory(pool_instance, full_name) + return proto_cls + except KeyError: + # The factory's DescriptorPool doesn't know about this class yet. + pass + + # This is the first time we see this proto: add a new descriptor to the pool. + pool_instance.Add( + _MakeFileDescriptorProto(proto_file_name, full_name, field_items)) + return _GetMessageFromFactory(pool_instance, full_name) + + +def _MakeFileDescriptorProto(proto_file_name, full_name, field_items): + """Populate FileDescriptorProto for MessageFactory's DescriptorPool.""" + package, name = full_name.rsplit('.', 1) + file_proto = descriptor_pb2.FileDescriptorProto() + file_proto.name = os.path.join(package.replace('.', '/'), proto_file_name) + file_proto.package = package + desc_proto = file_proto.message_type.add() + desc_proto.name = name + for f_number, (f_name, f_type) in enumerate(field_items, 1): + field_proto = desc_proto.field.add() + field_proto.name = f_name + # # If the number falls in the reserved range, reassign it to the correct + # # number after the range. + if f_number >= descriptor.FieldDescriptor.FIRST_RESERVED_FIELD_NUMBER: + f_number += ( + descriptor.FieldDescriptor.LAST_RESERVED_FIELD_NUMBER - + descriptor.FieldDescriptor.FIRST_RESERVED_FIELD_NUMBER + 1) + field_proto.number = f_number + field_proto.label = descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL + field_proto.type = f_type + return file_proto diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_json.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_json.py new file mode 100644 index 0000000000000000000000000000000000000000..fb2980e8bfec9155ec852101cc71655f9dd189c4 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_json.py @@ -0,0 +1,80 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains the Nextgen Pythonic Protobuf JSON APIs.""" + +from typing import Optional, Type + +from google.protobuf.message import Message +from google.protobuf.descriptor_pool import DescriptorPool +from google.protobuf import json_format + +def serialize( + message: Message, + always_print_fields_with_no_presence: bool=False, + preserving_proto_field_name: bool=False, + use_integers_for_enums: bool=False, + descriptor_pool: Optional[DescriptorPool]=None, +) -> dict: + """Converts protobuf message to a dictionary. + + When the dictionary is encoded to JSON, it conforms to ProtoJSON spec. + + Args: + message: The protocol buffers message instance to serialize. + always_print_fields_with_no_presence: If True, fields without presence + (implicit presence scalars, repeated fields, and map fields) will always + be serialized. Any field that supports presence is not affected by this + option (including singular message fields and oneof fields). + preserving_proto_field_name: If True, use the original proto field names as + defined in the .proto file. If False, convert the field names to + lowerCamelCase. + use_integers_for_enums: If true, print integers instead of enum names. + descriptor_pool: A Descriptor Pool for resolving types. If None use the + default. + + Returns: + A dict representation of the protocol buffer message. + """ + return json_format.MessageToDict( + message, + always_print_fields_with_no_presence=always_print_fields_with_no_presence, + preserving_proto_field_name=preserving_proto_field_name, + use_integers_for_enums=use_integers_for_enums, + ) + +def parse( + message_class: Type[Message], + js_dict: dict, + ignore_unknown_fields: bool=False, + descriptor_pool: Optional[DescriptorPool]=None, + max_recursion_depth: int=100 +) -> Message: + """Parses a JSON dictionary representation into a message. + + Args: + message_class: The message meta class. + js_dict: Dict representation of a JSON message. + ignore_unknown_fields: If True, do not raise errors for unknown fields. + descriptor_pool: A Descriptor Pool for resolving types. If None use the + default. + max_recursion_depth: max recursion depth of JSON message to be deserialized. + JSON messages over this depth will fail to be deserialized. Default value + is 100. + + Returns: + A new message passed from json_dict. + """ + new_message = message_class() + json_format.ParseDict( + js_dict=js_dict, + message=new_message, + ignore_unknown_fields=ignore_unknown_fields, + descriptor_pool=descriptor_pool, + max_recursion_depth=max_recursion_depth, + ) + return new_message diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_text.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_text.py new file mode 100644 index 0000000000000000000000000000000000000000..45cffeded80178ef1d5da55b1812c07633c48e76 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/proto_text.py @@ -0,0 +1,118 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2025 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains the Nextgen Pythonic Protobuf Text Format APIs.""" +from typing import AnyStr, Callable, Optional, Text, Type, Union + +from google.protobuf import text_format +from google.protobuf.descriptor_pool import DescriptorPool +from google.protobuf.message import Message + +_MsgFormatter = Callable[[Message, Union[int, bool], bool], Optional[Text]] + + +def serialize( + message: Message, + as_utf8: bool = True, + as_one_line: bool = False, + use_short_repeated_primitives: bool = False, + pointy_brackets: bool = False, + use_index_order: bool = False, + use_field_number: bool = False, + descriptor_pool: Optional[DescriptorPool] = None, + indent: int = 0, + message_formatter: Optional[_MsgFormatter] = None, + print_unknown_fields: bool = False, + force_colon: bool = False, +) -> str: + """Convert protobuf message to text format. + + Double values can be formatted compactly with 15 digits of + precision (which is the most that IEEE 754 "double" can guarantee) + using double_format='.15g'. To ensure that converting to text and back to a + proto will result in an identical value, double_format='.17g' should be used. + + Args: + message: The protocol buffers message. + as_utf8: Return unescaped Unicode for non-ASCII characters. + as_one_line: Don't introduce newlines between fields. + use_short_repeated_primitives: Use short repeated format for primitives. + pointy_brackets: If True, use angle brackets instead of curly braces for + nesting. + use_index_order: If True, fields of a proto message will be printed using + the order defined in source code instead of the field number, extensions + will be printed at the end of the message and their relative order is + determined by the extension number. By default, use the field number + order. + use_field_number: If True, print field numbers instead of names. + descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types. + indent (int): The initial indent level, in terms of spaces, for pretty + print. + message_formatter (function(message, indent, as_one_line) -> unicode|None): + Custom formatter for selected sub-messages (usually based on message + type). Use to pretty print parts of the protobuf for easier diffing. + print_unknown_fields: If True, unknown fields will be printed. + force_colon: If set, a colon will be added after the field name even if the + field is a proto message. + + Returns: + str: A string of the text formatted protocol buffer message. + """ + return text_format.MessageToString( + message=message, + as_utf8=as_utf8, + as_one_line=as_one_line, + use_short_repeated_primitives=use_short_repeated_primitives, + pointy_brackets=pointy_brackets, + use_index_order=use_index_order, + use_field_number=use_field_number, + descriptor_pool=descriptor_pool, + indent=indent, + message_formatter=message_formatter, + print_unknown_fields=print_unknown_fields, + force_colon=force_colon, + ) + + +def parse( + message_class: Type[Message], + text: AnyStr, + allow_unknown_extension: bool = False, + allow_field_number: bool = False, + descriptor_pool: Optional[DescriptorPool] = None, + allow_unknown_field: bool = False, +) -> Message: + """Parses a text representation of a protocol message into a message. + + Args: + message_class: The message meta class. + text (str): Message text representation. + message (Message): A protocol buffer message to merge into. + allow_unknown_extension: if True, skip over missing extensions and keep + parsing + allow_field_number: if True, both field number and field name are allowed. + descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types. + allow_unknown_field: if True, skip over unknown field and keep parsing. + Avoid to use this option if possible. It may hide some errors (e.g. + spelling error on field name) + + Returns: + Message: A new message passed from text. + + Raises: + ParseError: On text parsing problems. + """ + new_message = message_class() + text_format.Parse( + text=text, + message=new_message, + allow_unknown_extension=allow_unknown_extension, + allow_field_number=allow_field_number, + descriptor_pool=descriptor_pool, + allow_unknown_field=allow_unknown_field, + ) + return new_message diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/pyext/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/pyext/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/pyext/cpp_message.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/pyext/cpp_message.py new file mode 100644 index 0000000000000000000000000000000000000000..54cfe30646aaaed023e4b6228ad291aa7c53d147 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/pyext/cpp_message.py @@ -0,0 +1,49 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Protocol message implementation hooks for C++ implementation. + +Contains helper functions used to create protocol message classes from +Descriptor objects at runtime backed by the protocol buffer C++ API. +""" + +__author__ = 'tibell@google.com (Johan Tibell)' + +from google.protobuf.internal import api_implementation + + +# pylint: disable=protected-access +_message = api_implementation._c_module +# TODO: Remove this import after fix api_implementation +if _message is None: + from google.protobuf.pyext import _message + + +class GeneratedProtocolMessageType(_message.MessageMeta): + + """Metaclass for protocol message classes created at runtime from Descriptors. + + The protocol compiler currently uses this metaclass to create protocol + message classes at runtime. Clients can also manually create their own + classes at runtime, as in this example: + + mydescriptor = Descriptor(.....) + factory = symbol_database.Default() + factory.pool.AddDescriptor(mydescriptor) + MyProtoClass = message_factory.GetMessageClass(mydescriptor) + myproto_instance = MyProtoClass() + myproto.foo_field = 23 + ... + + The above example will not work for nested types. If you wish to include them, + use reflection.MakeClass() instead of manually instantiating the class in + order to create the appropriate class structure. + """ + + # Must be consistent with the protocol-compiler code in + # proto2/compiler/internal/generator.*. + _DESCRIPTOR_KEY = 'DESCRIPTOR' diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/reflection.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/reflection.py new file mode 100644 index 0000000000000000000000000000000000000000..a29f41a0527c78f437ecb564d8291a7485413a06 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/reflection.py @@ -0,0 +1,36 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +# This code is meant to work on Python 2.4 and above only. + +"""Contains a metaclass and helper functions used to create +protocol message classes from Descriptor objects at runtime. + +Recall that a metaclass is the "type" of a class. +(A class is to a metaclass what an instance is to a class.) + +In this case, we use the GeneratedProtocolMessageType metaclass +to inject all the useful functionality into the classes +output by the protocol compiler at compile-time. + +The upshot of all this is that the real implementation +details for ALL pure-Python protocol buffers are *here in +this file*. +""" + +__author__ = 'robinson@google.com (Will Robinson)' + +import warnings + +from google.protobuf import message_factory +from google.protobuf import symbol_database + +# The type of all Message classes. +# Part of the public interface, but normally only used by message factories. +GeneratedProtocolMessageType = message_factory._GENERATED_PROTOCOL_MESSAGE_TYPE + +MESSAGE_CLASS_CACHE = {} diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/runtime_version.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/runtime_version.py new file mode 100644 index 0000000000000000000000000000000000000000..39b759831e80606989f674a1df27072b67ca2eec --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/runtime_version.py @@ -0,0 +1,104 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Protobuf Runtime versions and validators. + +It should only be accessed by Protobuf gencodes and tests. DO NOT USE it +elsewhere. +""" + +__author__ = 'shaod@google.com (Dennis Shao)' + +from enum import Enum +import os +import warnings + + +class Domain(Enum): + GOOGLE_INTERNAL = 1 + PUBLIC = 2 + + +# The versions of this Python Protobuf runtime to be changed automatically by +# the Protobuf release process. Do not edit them manually. +# These OSS versions are not stripped to avoid merging conflicts. +OSS_DOMAIN = Domain.PUBLIC +OSS_MAJOR = 7 +OSS_MINOR = 35 +OSS_PATCH = 1 +OSS_SUFFIX = '' + +DOMAIN = OSS_DOMAIN +MAJOR = OSS_MAJOR +MINOR = OSS_MINOR +PATCH = OSS_PATCH +SUFFIX = OSS_SUFFIX + +# Avoid flooding of warnings. +_MAX_WARNING_COUNT = 20 +_warning_count = 0 + +class VersionError(Exception): + """Exception class for version violation.""" + + +def _ReportVersionError(msg): + raise VersionError(msg) + + +def ValidateProtobufRuntimeVersion( + gen_domain, gen_major, gen_minor, gen_patch, gen_suffix, location +): + """Function to validate versions. + + Args: + gen_domain: The domain where the code was generated from. + gen_major: The major version number of the gencode. + gen_minor: The minor version number of the gencode. + gen_patch: The patch version number of the gencode. + gen_suffix: The version suffix e.g. '-dev', '-rc1' of the gencode. + location: The proto location that causes the version violation. + + Raises: + VersionError: if gencode version is invalid or incompatible with the + runtime. + """ + + disable_flag = os.getenv('TEMPORARILY_DISABLE_PROTOBUF_VERSION_CHECK') + if disable_flag is not None and disable_flag.lower() == 'true': + return + + global _warning_count + + version = f'{MAJOR}.{MINOR}.{PATCH}{SUFFIX}' + gen_version = f'{gen_major}.{gen_minor}.{gen_patch}{gen_suffix}' + + if gen_major < 0 or gen_minor < 0 or gen_patch < 0: + raise VersionError(f'Invalid gencode version: {gen_version}') + + error_prompt = ( + 'See Protobuf version guarantees at' + ' https://protobuf.dev/support/cross-version-runtime-guarantee.' + ) + + if gen_domain != DOMAIN: + _ReportVersionError( + 'Detected mismatched Protobuf Gencode/Runtime domains when loading' + f' {location}: gencode {gen_domain.name} runtime {DOMAIN.name}.' + ' Cross-domain usage of Protobuf is not supported.' + ) + + if ( + MAJOR < gen_major + or (MAJOR == gen_major and MINOR < gen_minor) + or (MAJOR == gen_major and MINOR == gen_minor and PATCH < gen_patch) + ): + _ReportVersionError( + 'Detected incompatible Protobuf Gencode/Runtime versions when loading' + f' {location}: gencode {gen_version} runtime {version}. Runtime version' + f' cannot be older than the linked gencode version. {error_prompt}' + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/service_reflection.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/service_reflection.py new file mode 100644 index 0000000000000000000000000000000000000000..7ba3d0b2e448629bc53e1e9c75f0249a0b74c033 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/service_reflection.py @@ -0,0 +1,272 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains metaclasses used to create protocol service and service stub +classes from ServiceDescriptor objects at runtime. + +The GeneratedServiceType and GeneratedServiceStubType metaclasses are used to +inject all useful functionality into the classes output by the protocol +compiler at compile-time. +""" + +__author__ = 'petar@google.com (Petar Petrov)' + + +class GeneratedServiceType(type): + + """Metaclass for service classes created at runtime from ServiceDescriptors. + + Implementations for all methods described in the Service class are added here + by this class. We also create properties to allow getting/setting all fields + in the protocol message. + + The protocol compiler currently uses this metaclass to create protocol service + classes at runtime. Clients can also manually create their own classes at + runtime, as in this example:: + + mydescriptor = ServiceDescriptor(.....) + class MyProtoService(service.Service): + __metaclass__ = GeneratedServiceType + DESCRIPTOR = mydescriptor + myservice_instance = MyProtoService() + # ... + """ + + _DESCRIPTOR_KEY = 'DESCRIPTOR' + + def __init__(cls, name, bases, dictionary): + """Creates a message service class. + + Args: + name: Name of the class (ignored, but required by the metaclass + protocol). + bases: Base classes of the class being constructed. + dictionary: The class dictionary of the class being constructed. + dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object + describing this protocol service type. + """ + # Don't do anything if this class doesn't have a descriptor. This happens + # when a service class is subclassed. + if GeneratedServiceType._DESCRIPTOR_KEY not in dictionary: + return + + descriptor = dictionary[GeneratedServiceType._DESCRIPTOR_KEY] + service_builder = _ServiceBuilder(descriptor) + service_builder.BuildService(cls) + cls.DESCRIPTOR = descriptor + + +class GeneratedServiceStubType(GeneratedServiceType): + + """Metaclass for service stubs created at runtime from ServiceDescriptors. + + This class has similar responsibilities as GeneratedServiceType, except that + it creates the service stub classes. + """ + + _DESCRIPTOR_KEY = 'DESCRIPTOR' + + def __init__(cls, name, bases, dictionary): + """Creates a message service stub class. + + Args: + name: Name of the class (ignored, here). + bases: Base classes of the class being constructed. + dictionary: The class dictionary of the class being constructed. + dictionary[_DESCRIPTOR_KEY] must contain a ServiceDescriptor object + describing this protocol service type. + """ + super(GeneratedServiceStubType, cls).__init__(name, bases, dictionary) + # Don't do anything if this class doesn't have a descriptor. This happens + # when a service stub is subclassed. + if GeneratedServiceStubType._DESCRIPTOR_KEY not in dictionary: + return + + descriptor = dictionary[GeneratedServiceStubType._DESCRIPTOR_KEY] + service_stub_builder = _ServiceStubBuilder(descriptor) + service_stub_builder.BuildServiceStub(cls) + + +class _ServiceBuilder(object): + + """This class constructs a protocol service class using a service descriptor. + + Given a service descriptor, this class constructs a class that represents + the specified service descriptor. One service builder instance constructs + exactly one service class. That means all instances of that class share the + same builder. + """ + + def __init__(self, service_descriptor): + """Initializes an instance of the service class builder. + + Args: + service_descriptor: ServiceDescriptor to use when constructing the + service class. + """ + self.descriptor = service_descriptor + + def BuildService(builder, cls): + """Constructs the service class. + + Args: + cls: The class that will be constructed. + """ + + # CallMethod needs to operate with an instance of the Service class. This + # internal wrapper function exists only to be able to pass the service + # instance to the method that does the real CallMethod work. + # Making sure to use exact argument names from the abstract interface in + # service.py to match the type signature + def _WrapCallMethod(self, method_descriptor, rpc_controller, request, done): + return builder._CallMethod(self, method_descriptor, rpc_controller, + request, done) + + def _WrapGetRequestClass(self, method_descriptor): + return builder._GetRequestClass(method_descriptor) + + def _WrapGetResponseClass(self, method_descriptor): + return builder._GetResponseClass(method_descriptor) + + builder.cls = cls + cls.CallMethod = _WrapCallMethod + cls.GetDescriptor = staticmethod(lambda: builder.descriptor) + cls.GetDescriptor.__doc__ = 'Returns the service descriptor.' + cls.GetRequestClass = _WrapGetRequestClass + cls.GetResponseClass = _WrapGetResponseClass + for method in builder.descriptor.methods: + setattr(cls, method.name, builder._GenerateNonImplementedMethod(method)) + + def _CallMethod(self, srvc, method_descriptor, + rpc_controller, request, callback): + """Calls the method described by a given method descriptor. + + Args: + srvc: Instance of the service for which this method is called. + method_descriptor: Descriptor that represent the method to call. + rpc_controller: RPC controller to use for this method's execution. + request: Request protocol message. + callback: A callback to invoke after the method has completed. + """ + if method_descriptor.containing_service != self.descriptor: + raise RuntimeError( + 'CallMethod() given method descriptor for wrong service type.') + method = getattr(srvc, method_descriptor.name) + return method(rpc_controller, request, callback) + + def _GetRequestClass(self, method_descriptor): + """Returns the class of the request protocol message. + + Args: + method_descriptor: Descriptor of the method for which to return the + request protocol message class. + + Returns: + A class that represents the input protocol message of the specified + method. + """ + if method_descriptor.containing_service != self.descriptor: + raise RuntimeError( + 'GetRequestClass() given method descriptor for wrong service type.') + return method_descriptor.input_type._concrete_class + + def _GetResponseClass(self, method_descriptor): + """Returns the class of the response protocol message. + + Args: + method_descriptor: Descriptor of the method for which to return the + response protocol message class. + + Returns: + A class that represents the output protocol message of the specified + method. + """ + if method_descriptor.containing_service != self.descriptor: + raise RuntimeError( + 'GetResponseClass() given method descriptor for wrong service type.') + return method_descriptor.output_type._concrete_class + + def _GenerateNonImplementedMethod(self, method): + """Generates and returns a method that can be set for a service methods. + + Args: + method: Descriptor of the service method for which a method is to be + generated. + + Returns: + A method that can be added to the service class. + """ + return lambda inst, rpc_controller, request, callback: ( + self._NonImplementedMethod(method.name, rpc_controller, callback)) + + def _NonImplementedMethod(self, method_name, rpc_controller, callback): + """The body of all methods in the generated service class. + + Args: + method_name: Name of the method being executed. + rpc_controller: RPC controller used to execute this method. + callback: A callback which will be invoked when the method finishes. + """ + rpc_controller.SetFailed('Method %s not implemented.' % method_name) + callback(None) + + +class _ServiceStubBuilder(object): + + """Constructs a protocol service stub class using a service descriptor. + + Given a service descriptor, this class constructs a suitable stub class. + A stub is just a type-safe wrapper around an RpcChannel which emulates a + local implementation of the service. + + One service stub builder instance constructs exactly one class. It means all + instances of that class share the same service stub builder. + """ + + def __init__(self, service_descriptor): + """Initializes an instance of the service stub class builder. + + Args: + service_descriptor: ServiceDescriptor to use when constructing the + stub class. + """ + self.descriptor = service_descriptor + + def BuildServiceStub(self, cls): + """Constructs the stub class. + + Args: + cls: The class that will be constructed. + """ + + def _ServiceStubInit(stub, rpc_channel): + stub.rpc_channel = rpc_channel + self.cls = cls + cls.__init__ = _ServiceStubInit + for method in self.descriptor.methods: + setattr(cls, method.name, self._GenerateStubMethod(method)) + + def _GenerateStubMethod(self, method): + return (lambda inst, rpc_controller, request, callback=None: + self._StubMethod(inst, method, rpc_controller, request, callback)) + + def _StubMethod(self, stub, method_descriptor, + rpc_controller, request, callback): + """The body of all service methods in the generated stub class. + + Args: + stub: Stub instance. + method_descriptor: Descriptor of the invoked method. + rpc_controller: Rpc controller to execute the method. + request: Request protocol message. + callback: A callback to execute when the method finishes. + Returns: + Response message (in case of blocking call). + """ + return stub.rpc_channel.CallMethod( + method_descriptor, rpc_controller, request, + method_descriptor.output_type._concrete_class, callback) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/source_context_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/source_context_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..c8e6cda9785d0dd4282ac8fe3a28c6079b82106c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/source_context_pb2.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/source_context.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/source_context.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$google/protobuf/source_context.proto\x12\x0fgoogle.protobuf\",\n\rSourceContext\x12\x1b\n\tfile_name\x18\x01 \x01(\tR\x08\x66ileNameB\x8a\x01\n\x13\x63om.google.protobufB\x12SourceContextProtoP\x01Z6google.golang.org/protobuf/types/known/sourcecontextpb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.source_context_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\022SourceContextProtoP\001Z6google.golang.org/protobuf/types/known/sourcecontextpb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_SOURCECONTEXT']._serialized_start=57 + _globals['_SOURCECONTEXT']._serialized_end=101 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/struct_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/struct_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..5e2284ab28ac276e95a464921d3bc94a077485c4 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/struct_pb2.py @@ -0,0 +1,47 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/struct.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/struct.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1cgoogle/protobuf/struct.proto\x12\x0fgoogle.protobuf\"\x98\x01\n\x06Struct\x12;\n\x06\x66ields\x18\x01 \x03(\x0b\x32#.google.protobuf.Struct.FieldsEntryR\x06\x66ields\x1aQ\n\x0b\x46ieldsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.ValueR\x05value:\x02\x38\x01\"\xb2\x02\n\x05Value\x12;\n\nnull_value\x18\x01 \x01(\x0e\x32\x1a.google.protobuf.NullValueH\x00R\tnullValue\x12#\n\x0cnumber_value\x18\x02 \x01(\x01H\x00R\x0bnumberValue\x12#\n\x0cstring_value\x18\x03 \x01(\tH\x00R\x0bstringValue\x12\x1f\n\nbool_value\x18\x04 \x01(\x08H\x00R\tboolValue\x12<\n\x0cstruct_value\x18\x05 \x01(\x0b\x32\x17.google.protobuf.StructH\x00R\x0bstructValue\x12;\n\nlist_value\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.ListValueH\x00R\tlistValueB\x06\n\x04kind\";\n\tListValue\x12.\n\x06values\x18\x01 \x03(\x0b\x32\x16.google.protobuf.ValueR\x06values*\x1b\n\tNullValue\x12\x0e\n\nNULL_VALUE\x10\x00\x42\x7f\n\x13\x63om.google.protobufB\x0bStructProtoP\x01Z/google.golang.org/protobuf/types/known/structpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.struct_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\013StructProtoP\001Z/google.golang.org/protobuf/types/known/structpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_STRUCT_FIELDSENTRY']._loaded_options = None + _globals['_STRUCT_FIELDSENTRY']._serialized_options = b'8\001' + _globals['_NULLVALUE']._serialized_start=574 + _globals['_NULLVALUE']._serialized_end=601 + _globals['_STRUCT']._serialized_start=50 + _globals['_STRUCT']._serialized_end=202 + _globals['_STRUCT_FIELDSENTRY']._serialized_start=121 + _globals['_STRUCT_FIELDSENTRY']._serialized_end=202 + _globals['_VALUE']._serialized_start=205 + _globals['_VALUE']._serialized_end=511 + _globals['_LISTVALUE']._serialized_start=513 + _globals['_LISTVALUE']._serialized_end=572 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/symbol_database.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/symbol_database.py new file mode 100644 index 0000000000000000000000000000000000000000..a538d5d6da750ed4b48d14689b5f3d894a263538 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/symbol_database.py @@ -0,0 +1,179 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""A database of Python protocol buffer generated symbols. + +SymbolDatabase is the MessageFactory for messages generated at compile time, +and makes it easy to create new instances of a registered type, given only the +type's protocol buffer symbol name. + +Example usage:: + + db = symbol_database.SymbolDatabase() + + # Register symbols of interest, from one or multiple files. + db.RegisterFileDescriptor(my_proto_pb2.DESCRIPTOR) + db.RegisterMessage(my_proto_pb2.MyMessage) + db.RegisterEnumDescriptor(my_proto_pb2.MyEnum.DESCRIPTOR) + + # The database can be used as a MessageFactory, to generate types based on + # their name: + types = db.GetMessages(['my_proto.proto']) + my_message_instance = types['MyMessage']() + + # The database's underlying descriptor pool can be queried, so it's not + # necessary to know a type's filename to be able to generate it: + filename = db.pool.FindFileContainingSymbol('MyMessage') + my_message_instance = db.GetMessages([filename])['MyMessage']() + + # This functionality is also provided directly via a convenience method: + my_message_instance = db.GetSymbol('MyMessage')() +""" + +import warnings + +from google.protobuf.internal import api_implementation +from google.protobuf import descriptor_pool +from google.protobuf import message_factory + + +class SymbolDatabase(): + """A database of Python generated symbols.""" + + # local cache of registered classes. + _classes = {} + + def __init__(self, pool=None): + """Initializes a new SymbolDatabase.""" + self.pool = pool or descriptor_pool.DescriptorPool() + + def RegisterMessage(self, message): + """Registers the given message type in the local database. + + Calls to GetSymbol() and GetMessages() will return messages registered here. + + Args: + message: A :class:`google.protobuf.message.Message` subclass (or + instance); its descriptor will be registered. + + Returns: + The provided message. + """ + + desc = message.DESCRIPTOR + self._classes[desc] = message + self.RegisterMessageDescriptor(desc) + return message + + def RegisterMessageDescriptor(self, message_descriptor): + """Registers the given message descriptor in the local database. + + Args: + message_descriptor (Descriptor): the message descriptor to add. + """ + if api_implementation.Type() == 'python': + # pylint: disable=protected-access + self.pool._AddDescriptor(message_descriptor) + + def RegisterEnumDescriptor(self, enum_descriptor): + """Registers the given enum descriptor in the local database. + + Args: + enum_descriptor (EnumDescriptor): The enum descriptor to register. + + Returns: + EnumDescriptor: The provided descriptor. + """ + if api_implementation.Type() == 'python': + # pylint: disable=protected-access + self.pool._AddEnumDescriptor(enum_descriptor) + return enum_descriptor + + def RegisterServiceDescriptor(self, service_descriptor): + """Registers the given service descriptor in the local database. + + Args: + service_descriptor (ServiceDescriptor): the service descriptor to + register. + """ + if api_implementation.Type() == 'python': + # pylint: disable=protected-access + self.pool._AddServiceDescriptor(service_descriptor) + + def RegisterFileDescriptor(self, file_descriptor): + """Registers the given file descriptor in the local database. + + Args: + file_descriptor (FileDescriptor): The file descriptor to register. + """ + if api_implementation.Type() == 'python': + # pylint: disable=protected-access + self.pool._InternalAddFileDescriptor(file_descriptor) + + def GetSymbol(self, symbol): + """Tries to find a symbol in the local database. + + Currently, this method only returns message.Message instances, however, if + may be extended in future to support other symbol types. + + Args: + symbol (str): a protocol buffer symbol. + + Returns: + A Python class corresponding to the symbol. + + Raises: + KeyError: if the symbol could not be found. + """ + + return self._classes[self.pool.FindMessageTypeByName(symbol)] + + def GetMessages(self, files): + # TODO: Fix the differences with MessageFactory. + """Gets all registered messages from a specified file. + + Only messages already created and registered will be returned; (this is the + case for imported _pb2 modules) + But unlike MessageFactory, this version also returns already defined nested + messages, but does not register any message extensions. + + Args: + files (list[str]): The file names to extract messages from. + + Returns: + A dictionary mapping proto names to the message classes. + + Raises: + KeyError: if a file could not be found. + """ + + def _GetAllMessages(desc): + """Walk a message Descriptor and recursively yields all message names.""" + yield desc + for msg_desc in desc.nested_types: + for nested_desc in _GetAllMessages(msg_desc): + yield nested_desc + + result = {} + for file_name in files: + file_desc = self.pool.FindFileByName(file_name) + for msg_desc in file_desc.message_types_by_name.values(): + for desc in _GetAllMessages(msg_desc): + try: + result[desc.full_name] = self._classes[desc] + except KeyError: + # This descriptor has no registered class, skip it. + pass + return result + + +_DEFAULT = SymbolDatabase(pool=descriptor_pool.Default()) + + +def Default(): + """Returns the default SymbolDatabase.""" + return _DEFAULT diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/testdata/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/testdata/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/text_encoding.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/text_encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..03c27dc104b2b9b9ab708084d9a5480bb9d058b6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/text_encoding.py @@ -0,0 +1,106 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Encoding related utilities.""" +import re + +def _AsciiIsPrint(i): + return i >= 32 and i < 127 + +def _MakeStrEscapes(): + ret = {} + for i in range(0, 128): + if not _AsciiIsPrint(i): + ret[i] = r'\%03o' % i + ret[ord('\t')] = r'\t' # optional escape + ret[ord('\n')] = r'\n' # optional escape + ret[ord('\r')] = r'\r' # optional escape + ret[ord('"')] = r'\"' # necessary escape + ret[ord('\'')] = r"\'" # optional escape + ret[ord('\\')] = r'\\' # necessary escape + return ret + +# Maps int -> char, performing string escapes. +_str_escapes = _MakeStrEscapes() + +# Maps int -> char, performing byte escaping and string escapes +_byte_escapes = {i: chr(i) for i in range(0, 256)} +_byte_escapes.update(_str_escapes) +_byte_escapes.update({i: r'\%03o' % i for i in range(128, 256)}) + + +def _DecodeUtf8EscapeErrors(text_bytes): + ret = '' + while text_bytes: + try: + ret += text_bytes.decode('utf-8').translate(_str_escapes) + text_bytes = '' + except UnicodeDecodeError as e: + ret += text_bytes[:e.start].decode('utf-8').translate(_str_escapes) + ret += _byte_escapes[text_bytes[e.start]] + text_bytes = text_bytes[e.start+1:] + return ret + + +def CEscape(text, as_utf8) -> str: + """Escape a bytes string for use in an text protocol buffer. + + Args: + text: A byte string to be escaped. + as_utf8: Specifies if result may contain non-ASCII characters. + In Python 3 this allows unescaped non-ASCII Unicode characters. + In Python 2 the return value will be valid UTF-8 rather than only ASCII. + Returns: + Escaped string (str). + """ + # Python's text.encode() 'string_escape' or 'unicode_escape' codecs do not + # satisfy our needs; they encodes unprintable characters using two-digit hex + # escapes whereas our C++ unescaping function allows hex escapes to be any + # length. So, "\0011".encode('string_escape') ends up being "\\x011", which + # will be decoded in C++ as a single-character string with char code 0x11. + text_is_unicode = isinstance(text, str) + if as_utf8: + if text_is_unicode: + return text.translate(_str_escapes) + else: + return _DecodeUtf8EscapeErrors(text) + else: + if text_is_unicode: + text = text.encode('utf-8') + return ''.join([_byte_escapes[c] for c in text]) + + +_CUNESCAPE_HEX = re.compile(r'(\\+)x([0-9a-fA-F])(?![0-9a-fA-F])') + + +def CUnescape(text: str) -> bytes: + """Unescape a text string with C-style escape sequences to UTF-8 bytes. + + Args: + text: The data to parse in a str. + Returns: + A byte string. + """ + + def ReplaceHex(m): + # Only replace the match if the number of leading back slashes is odd. i.e. + # the slash itself is not escaped. + if len(m.group(1)) & 1: + return m.group(1) + 'x0' + m.group(2) + return m.group(0) + + # This is required because the 'string_escape' encoding doesn't + # allow single-digit hex escapes (like '\xf'). + result = _CUNESCAPE_HEX.sub(ReplaceHex, text) + + # Replaces Unicode escape sequences with their character equivalents. + result = result.encode('raw_unicode_escape').decode('raw_unicode_escape') + # Encode Unicode characters as UTF-8, then decode to Latin-1 escaping + # unprintable characters. + result = result.encode('utf-8').decode('unicode_escape') + # Convert Latin-1 text back to a byte string (latin-1 codec also works here). + return result.encode('latin-1') diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/text_format.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/text_format.py new file mode 100644 index 0000000000000000000000000000000000000000..103d6a5197ba8745043e88818d21990435ae4195 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/text_format.py @@ -0,0 +1,1963 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains routines for printing protocol messages in text format. + +Simple usage example:: + + # Create a proto object and serialize it to a text proto string. + message = my_proto_pb2.MyMessage(foo='bar') + text_proto = text_format.MessageToString(message) + + # Parse a text proto string. + message = text_format.Parse(text_proto, my_proto_pb2.MyMessage()) +""" + +__author__ = 'kenton@google.com (Kenton Varda)' + +# TODO Import thread contention leads to test failures. +import encodings.raw_unicode_escape # pylint: disable=unused-import +import encodings.unicode_escape # pylint: disable=unused-import +import io +import math +import re +import warnings + +from google.protobuf.internal import decoder +from google.protobuf.internal import type_checkers +from google.protobuf import descriptor +from google.protobuf import text_encoding +from google.protobuf import unknown_fields + +# pylint: disable=g-import-not-at-top +__all__ = ['MessageToString', 'Parse', 'PrintMessage', 'PrintField', + 'PrintFieldValue', 'Merge', 'MessageToBytes'] + +_INTEGER_CHECKERS = (type_checkers.Uint32ValueChecker(), + type_checkers.Int32ValueChecker(), + type_checkers.Uint64ValueChecker(), + type_checkers.Int64ValueChecker()) +_FLOAT_INFINITY = re.compile('-?inf(?:inity)?f?$', re.IGNORECASE) +_FLOAT_NAN = re.compile('nanf?$', re.IGNORECASE) +_FLOAT_OCTAL_PREFIX = re.compile('-?0[0-9]+') +_PERCENT_ENCODING = re.compile(r'^%[\da-fA-F][\da-fA-F]$') +_TYPE_NAME = re.compile(r'^[^\d\W]\w*(\.[^\d\W]\w*)*$') +_QUOTES = frozenset(("'", '"')) +_ANY_FULL_TYPE_NAME = 'google.protobuf.Any' +_DEBUG_STRING_SILENT_MARKER = '\t ' + +_as_utf8_default = True + + +class Error(Exception): + """Top-level module error for text_format.""" + + +class ParseError(Error): + """Thrown in case of text parsing or tokenizing error.""" + + def __init__(self, message=None, line=None, column=None): + if message is not None and line is not None: + loc = str(line) + if column is not None: + loc += ':{0}'.format(column) + message = '{0} : {1}'.format(loc, message) + if message is not None: + super(ParseError, self).__init__(message) + else: + super(ParseError, self).__init__() + self._line = line + self._column = column + + def GetLine(self): + return self._line + + def GetColumn(self): + return self._column + + +class TextWriter(object): + + def __init__(self, as_utf8): + self._writer = io.StringIO() + + def write(self, val): + return self._writer.write(val) + + def close(self): + return self._writer.close() + + def getvalue(self): + return self._writer.getvalue() + + +def MessageToString( + message, + as_utf8=_as_utf8_default, + as_one_line=False, + use_short_repeated_primitives=False, + pointy_brackets=False, + use_index_order=False, + use_field_number=False, + descriptor_pool=None, + indent=0, + message_formatter=None, + print_unknown_fields=False, + force_colon=False) -> str: + """Convert protobuf message to text format. + + Args: + message: The protocol buffers message. + as_utf8: Return unescaped Unicode for non-ASCII characters. + as_one_line: Don't introduce newlines between fields. + use_short_repeated_primitives: Use short repeated format for primitives. + pointy_brackets: If True, use angle brackets instead of curly braces for + nesting. + use_index_order: If True, fields of a proto message will be printed using + the order defined in source code instead of the field number, extensions + will be printed at the end of the message and their relative order is + determined by the extension number. By default, use the field number + order. + use_field_number: If True, print field numbers instead of names. + descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types. + indent (int): The initial indent level, in terms of spaces, for pretty + print. + message_formatter (function(message, indent, as_one_line) -> unicode|None): + Custom formatter for selected sub-messages (usually based on message + type). Use to pretty print parts of the protobuf for easier diffing. + print_unknown_fields: If True, unknown fields will be printed. + force_colon: If set, a colon will be added after the field name even if the + field is a proto message. + + Returns: + str: A string of the text formatted protocol buffer message. + """ + out = TextWriter(as_utf8) + printer = _Printer( + out=out, + indent=indent, + as_utf8=as_utf8, + as_one_line=as_one_line, + use_short_repeated_primitives=use_short_repeated_primitives, + pointy_brackets=pointy_brackets, + use_index_order=use_index_order, + use_field_number=use_field_number, + descriptor_pool=descriptor_pool, + message_formatter=message_formatter, + print_unknown_fields=print_unknown_fields, + force_colon=force_colon, + ) + printer.PrintMessage(message) + result = out.getvalue() + out.close() + if as_one_line: + return result.rstrip() + return result + + +def MessageToBytes(message, **kwargs) -> bytes: + """Convert protobuf message to encoded text format. See MessageToString.""" + text = MessageToString(message, **kwargs) + if isinstance(text, bytes): + return text + codec = 'utf-8' if kwargs.get('as_utf8') else 'ascii' + return text.encode(codec) + + +def _IsMapEntry(field): + return (field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and + field.message_type.has_options and + field.message_type.GetOptions().map_entry) + + +def _IsGroupLike(field): + """Determines if a field is consistent with a proto2 group. + + Args: + field: The field descriptor. + + Returns: + True if this field is group-like, false otherwise. + """ + # Groups are always tag-delimited. + if field.type != descriptor.FieldDescriptor.TYPE_GROUP: + return False + + # Group fields always are always the lowercase type name. + if field.name != field.message_type.name.lower(): + return False + + if field.message_type.file != field.file: + return False + + # Group messages are always defined in the same scope as the field. File + # level extensions will compare NULL == NULL here, which is why the file + # comparison above is necessary to ensure both come from the same file. + return ( + field.message_type.containing_type == field.extension_scope + if field.is_extension + else field.message_type.containing_type == field.containing_type + ) + + +def PrintMessage(message, + out, + indent=0, + as_utf8=_as_utf8_default, + as_one_line=False, + use_short_repeated_primitives=False, + pointy_brackets=False, + use_index_order=False, + use_field_number=False, + descriptor_pool=None, + message_formatter=None, + print_unknown_fields=False, + force_colon=False): + """Convert the message to text format and write it to the out stream. + + Args: + message: The Message object to convert to text format. + out: A file handle to write the message to. + indent: The initial indent level for pretty print. + as_utf8: Return unescaped Unicode for non-ASCII characters. + as_one_line: Don't introduce newlines between fields. + use_short_repeated_primitives: Use short repeated format for primitives. + pointy_brackets: If True, use angle brackets instead of curly braces for + nesting. + use_index_order: If True, print fields of a proto message using the order + defined in source code instead of the field number. By default, use the + field number order. + use_field_number: If True, print field numbers instead of names. + descriptor_pool: A DescriptorPool used to resolve Any types. + message_formatter: A function(message, indent, as_one_line): unicode|None + to custom format selected sub-messages (usually based on message type). + Use to pretty print parts of the protobuf for easier diffing. + print_unknown_fields: If True, unknown fields will be printed. + force_colon: If set, a colon will be added after the field name even if + the field is a proto message. + """ + printer = _Printer( + out=out, indent=indent, as_utf8=as_utf8, + as_one_line=as_one_line, + use_short_repeated_primitives=use_short_repeated_primitives, + pointy_brackets=pointy_brackets, + use_index_order=use_index_order, + use_field_number=use_field_number, + descriptor_pool=descriptor_pool, + message_formatter=message_formatter, + print_unknown_fields=print_unknown_fields, + force_colon=force_colon) + printer.PrintMessage(message) + + +def PrintField(field, + value, + out, + indent=0, + as_utf8=_as_utf8_default, + as_one_line=False, + use_short_repeated_primitives=False, + pointy_brackets=False, + use_index_order=False, + message_formatter=None, + print_unknown_fields=False, + force_colon=False): + """Print a single field name/value pair.""" + printer = _Printer( + out, + indent, + as_utf8, + as_one_line, + use_short_repeated_primitives, + pointy_brackets, + use_index_order, + message_formatter=message_formatter, + print_unknown_fields=print_unknown_fields, + force_colon=force_colon, + ) + printer.PrintField(field, value) + + +def PrintFieldValue(field, + value, + out, + indent=0, + as_utf8=_as_utf8_default, + as_one_line=False, + use_short_repeated_primitives=False, + pointy_brackets=False, + use_index_order=False, + message_formatter=None, + print_unknown_fields=False, + force_colon=False): + """Print a single field value (not including name).""" + printer = _Printer( + out, + indent, + as_utf8, + as_one_line, + use_short_repeated_primitives, + pointy_brackets, + use_index_order, + message_formatter=message_formatter, + print_unknown_fields=print_unknown_fields, + force_colon=force_colon, + ) + printer.PrintFieldValue(field, value) + + +def _BuildMessageFromTypeName(type_name, descriptor_pool): + """Returns a protobuf message instance. + + Args: + type_name: Fully-qualified protobuf message type name string. + descriptor_pool: DescriptorPool instance. + + Returns: + A Message instance of type matching type_name, or None if the a Descriptor + wasn't found matching type_name. + """ + # pylint: disable=g-import-not-at-top + if descriptor_pool is None: + from google.protobuf import descriptor_pool as pool_mod + + descriptor_pool = pool_mod.Default() + from google.protobuf import message_factory + + try: + message_descriptor = descriptor_pool.FindMessageTypeByName(type_name) + except KeyError: + return None + message_type = message_factory.GetMessageClass(message_descriptor) + return message_type() + + +# These values must match WireType enum in //google/protobuf/wire_format.h. +WIRETYPE_LENGTH_DELIMITED = 2 +WIRETYPE_START_GROUP = 3 + + +class _Printer(object): + """Text format printer for protocol message.""" + + def __init__( + self, + out, + indent=0, + as_utf8=_as_utf8_default, + as_one_line=False, + use_short_repeated_primitives=False, + pointy_brackets=False, + use_index_order=False, + use_field_number=False, + descriptor_pool=None, + message_formatter=None, + print_unknown_fields=False, + force_colon=False, + ): + """Initialize the Printer. + + Args: + out: To record the text format result. + indent: The initial indent level for pretty print. + as_utf8: Return unescaped Unicode for non-ASCII characters. + as_one_line: Don't introduce newlines between fields. + use_short_repeated_primitives: Use short repeated format for primitives. + pointy_brackets: If True, use angle brackets instead of curly braces for + nesting. + use_index_order: If True, print fields of a proto message using the order + defined in source code instead of the field number. By default, use the + field number order. + use_field_number: If True, print field numbers instead of names. + descriptor_pool: A DescriptorPool used to resolve Any types. + message_formatter: A function(message, indent, as_one_line): unicode|None + to custom format selected sub-messages (usually based on message type). + Use to pretty print parts of the protobuf for easier diffing. + print_unknown_fields: If True, unknown fields will be printed. + force_colon: If set, a colon will be added after the field name even if + the field is a proto message. + """ + self.out = out + self.indent = indent + self.as_utf8 = as_utf8 + self.as_one_line = as_one_line + self.use_short_repeated_primitives = use_short_repeated_primitives + self.pointy_brackets = pointy_brackets + self.use_index_order = use_index_order + self.use_field_number = use_field_number + self.descriptor_pool = descriptor_pool + self.message_formatter = message_formatter + self.print_unknown_fields = print_unknown_fields + self.force_colon = force_colon + + def _TryPrintAsAnyMessage(self, message): + """Serializes if message is a google.protobuf.Any field.""" + if '/' not in message.type_url: + return False + packed_message = _BuildMessageFromTypeName(message.TypeName(), + self.descriptor_pool) + if packed_message is not None: + packed_message.MergeFromString(message.value) + colon = ':' if self.force_colon else '' + self.out.write('%s[%s]%s ' % (self.indent * ' ', message.type_url, colon)) + self._PrintMessageFieldValue(packed_message) + self.out.write(' ' if self.as_one_line else '\n') + return True + else: + return False + + def _TryCustomFormatMessage(self, message): + formatted = self.message_formatter(message, self.indent, self.as_one_line) + if formatted is None: + return False + + out = self.out + out.write(' ' * self.indent) + out.write(formatted) + out.write(' ' if self.as_one_line else '\n') + return True + + def PrintMessage(self, message): + """Convert protobuf message to text format. + + Args: + message: The protocol buffers message. + """ + if self.message_formatter and self._TryCustomFormatMessage(message): + return + if (message.DESCRIPTOR.full_name == _ANY_FULL_TYPE_NAME and + self._TryPrintAsAnyMessage(message)): + return + fields = message.ListFields() + if self.use_index_order: + fields.sort( + key=lambda x: x[0].number if x[0].is_extension else x[0].index) + for field, value in fields: + if _IsMapEntry(field): + for key in sorted(value): + # This is slow for maps with submessage entries because it copies the + # entire tree. Unfortunately this would take significant refactoring + # of this file to work around. + # + # TODO: refactor and optimize if this becomes an issue. + entry_submsg = value.GetEntryClass()(key=key, value=value[key]) + self.PrintField(field, entry_submsg) + elif field.is_repeated: + if (self.use_short_repeated_primitives + and field.cpp_type != descriptor.FieldDescriptor.CPPTYPE_MESSAGE + and field.cpp_type != descriptor.FieldDescriptor.CPPTYPE_STRING): + self._PrintShortRepeatedPrimitivesValue(field, value) + else: + for element in value: + self.PrintField(field, element) + else: + self.PrintField(field, value) + + if self.print_unknown_fields: + self._PrintUnknownFields(unknown_fields.UnknownFieldSet(message)) + + def _PrintUnknownFields(self, unknown_field_set): + """Print unknown fields.""" + out = self.out + for field in unknown_field_set: + out.write(' ' * self.indent) + out.write(str(field.field_number)) + if field.wire_type == WIRETYPE_START_GROUP: + if self.as_one_line: + out.write(' { ') + else: + out.write(' {\n') + self.indent += 2 + + self._PrintUnknownFields(field.data) + + if self.as_one_line: + out.write('} ') + else: + self.indent -= 2 + out.write(' ' * self.indent + '}\n') + elif field.wire_type == WIRETYPE_LENGTH_DELIMITED: + try: + # If this field is parseable as a Message, it is probably + # an embedded message. + # pylint: disable=protected-access + (embedded_unknown_message, pos) = decoder._DecodeUnknownFieldSet( + memoryview(field.data), 0, len(field.data)) + except Exception: # pylint: disable=broad-except + pos = 0 + + if pos == len(field.data): + if self.as_one_line: + out.write(' { ') + else: + out.write(' {\n') + self.indent += 2 + + self._PrintUnknownFields(embedded_unknown_message) + + if self.as_one_line: + out.write('} ') + else: + self.indent -= 2 + out.write(' ' * self.indent + '}\n') + else: + # A string or bytes field. self.as_utf8 may not work. + out.write(': \"') + out.write(text_encoding.CEscape(field.data, False)) + out.write('\" ' if self.as_one_line else '\"\n') + else: + # varint, fixed32, fixed64 + out.write(': ') + out.write(str(field.data)) + out.write(' ' if self.as_one_line else '\n') + + def _PrintFieldName(self, field): + """Print field name.""" + out = self.out + out.write(' ' * self.indent) + if self.use_field_number: + out.write(str(field.number)) + else: + if field.is_extension: + out.write('[') + if (field.containing_type.GetOptions().message_set_wire_format and + field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and + not field.is_required and + not field.is_repeated): + out.write(field.message_type.full_name) + else: + out.write(field.full_name) + out.write(']') + elif _IsGroupLike(field): + # For groups, use the capitalized name. + out.write(field.message_type.name) + else: + out.write(field.name) + + if (self.force_colon or + field.cpp_type != descriptor.FieldDescriptor.CPPTYPE_MESSAGE): + # The colon is optional in this case, but our cross-language golden files + # don't include it. Here, the colon is only included if force_colon is + # set to True + out.write(':') + + def PrintField(self, field, value): + """Print a single field name/value pair.""" + self._PrintFieldName(field) + self.out.write(' ') + self.PrintFieldValue(field, value) + self.out.write(' ' if self.as_one_line else '\n') + + def _PrintShortRepeatedPrimitivesValue(self, field, value): + """"Prints short repeated primitives value.""" + # Note: this is called only when value has at least one element. + self._PrintFieldName(field) + self.out.write(' [') + for i in range(len(value) - 1): + self.PrintFieldValue(field, value[i]) + self.out.write(', ') + self.PrintFieldValue(field, value[-1]) + self.out.write(']') + self.out.write(' ' if self.as_one_line else '\n') + + def _PrintMessageFieldValue(self, value): + if self.pointy_brackets: + openb = '<' + closeb = '>' + else: + openb = '{' + closeb = '}' + + if self.as_one_line: + self.out.write('%s ' % openb) + self.PrintMessage(value) + self.out.write(closeb) + else: + self.out.write('%s\n' % openb) + self.indent += 2 + self.PrintMessage(value) + self.indent -= 2 + self.out.write(' ' * self.indent + closeb) + + def PrintFieldValue(self, field, value): + """Print a single field value (not including name). + + For repeated fields, the value should be a single element. + + Args: + field: The descriptor of the field to be printed. + value: The value of the field. + """ + out = self.out + if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE: + self._PrintMessageFieldValue(value) + elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM: + enum_value = field.enum_type.values_by_number.get(value, None) + if enum_value is not None: + out.write(enum_value.name) + else: + out.write(str(value)) + elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING: + out.write('\"') + if isinstance(value, str) and not self.as_utf8: + out_value = value.encode('utf-8') + else: + out_value = value + if field.type == descriptor.FieldDescriptor.TYPE_BYTES: + # We always need to escape all binary data in TYPE_BYTES fields. + out_as_utf8 = False + else: + out_as_utf8 = self.as_utf8 + out.write(text_encoding.CEscape(out_value, out_as_utf8)) + out.write('\"') + elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL: + if value: + out.write('true') + else: + out.write('false') + elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_FLOAT: + if math.isnan(value): + out.write(str(value)) + else: + out.write(str(type_checkers.ToShortestFloat(value))) + else: + out.write(str(value)) + + +def Parse(text, + message, + allow_unknown_extension=False, + allow_field_number=False, + descriptor_pool=None, + allow_unknown_field=False, + max_recursion_depth=None): + """Parses a text representation of a protocol message into a message. + + NOTE: for historical reasons this function does not clear the input + message. This is different from what the binary msg.ParseFrom(...) does. + If text contains a field already set in message, the value is appended if the + field is repeated. Otherwise, an error is raised. + + Example:: + + a = MyProto() + a.repeated_field.append('test') + b = MyProto() + + # Repeated fields are combined + text_format.Parse(repr(a), b) + text_format.Parse(repr(a), b) # repeated_field contains ["test", "test"] + + # Non-repeated fields cannot be overwritten + a.singular_field = 1 + b.singular_field = 2 + text_format.Parse(repr(a), b) # ParseError + + # Binary version: + b.ParseFromString(a.SerializeToString()) # repeated_field is now "test" + + Caller is responsible for clearing the message as needed. + + Args: + text (str): Message text representation. + message (Message): A protocol buffer message to merge into. + allow_unknown_extension: if True, skip over missing extensions and keep + parsing + allow_field_number: if True, both field number and field name are allowed. + descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types. + allow_unknown_field: if True, skip over unknown field and keep + parsing. Avoid to use this option if possible. It may hide some + errors (e.g. spelling error on field name) + max_recursion_depth: Optional maximum recursion depth of a text proto + message to be deserialized. Text proto messages over this depth will + fail to parse. ``None`` keeps the historical unbounded behavior. + + Returns: + Message: The same message passed as argument. + + Raises: + ParseError: On text parsing problems. + """ + return ParseLines(text.split(b'\n' if isinstance(text, bytes) else u'\n'), + message, + allow_unknown_extension, + allow_field_number, + descriptor_pool=descriptor_pool, + allow_unknown_field=allow_unknown_field, + max_recursion_depth=max_recursion_depth) + + +def Merge(text, + message, + allow_unknown_extension=False, + allow_field_number=False, + descriptor_pool=None, + allow_unknown_field=False, + max_recursion_depth=None): + """Parses a text representation of a protocol message into a message. + + Like Parse(), but allows repeated values for a non-repeated field, and uses + the last one. This means any non-repeated, top-level fields specified in text + replace those in the message. + + Args: + text (str): Message text representation. + message (Message): A protocol buffer message to merge into. + allow_unknown_extension: if True, skip over missing extensions and keep + parsing + allow_field_number: if True, both field number and field name are allowed. + descriptor_pool (DescriptorPool): Descriptor pool used to resolve Any types. + allow_unknown_field: if True, skip over unknown field and keep + parsing. Avoid to use this option if possible. It may hide some + errors (e.g. spelling error on field name) + max_recursion_depth: Optional maximum recursion depth of a text proto + message to be deserialized. Text proto messages over this depth will + fail to parse. ``None`` keeps the historical unbounded behavior. + + Returns: + Message: The same message passed as argument. + + Raises: + ParseError: On text parsing problems. + """ + return MergeLines( + text.split(b'\n' if isinstance(text, bytes) else u'\n'), + message, + allow_unknown_extension, + allow_field_number, + descriptor_pool=descriptor_pool, + allow_unknown_field=allow_unknown_field, + max_recursion_depth=max_recursion_depth) + + +def ParseLines(lines, + message, + allow_unknown_extension=False, + allow_field_number=False, + descriptor_pool=None, + allow_unknown_field=False, + max_recursion_depth=None): + """Parses a text representation of a protocol message into a message. + + See Parse() for caveats. + + Args: + lines: An iterable of lines of a message's text representation. + message: A protocol buffer message to merge into. + allow_unknown_extension: if True, skip over missing extensions and keep + parsing + allow_field_number: if True, both field number and field name are allowed. + descriptor_pool: A DescriptorPool used to resolve Any types. + allow_unknown_field: if True, skip over unknown field and keep + parsing. Avoid to use this option if possible. It may hide some + errors (e.g. spelling error on field name) + max_recursion_depth: Optional maximum recursion depth of a text proto + message to be deserialized. Text proto messages over this depth will + fail to parse. ``None`` keeps the historical unbounded behavior. + + Returns: + The same message passed as argument. + + Raises: + ParseError: On text parsing problems. + """ + parser = _Parser(allow_unknown_extension, + allow_field_number, + descriptor_pool=descriptor_pool, + allow_unknown_field=allow_unknown_field, + max_recursion_depth=max_recursion_depth) + return parser.ParseLines(lines, message) + + +def MergeLines(lines, + message, + allow_unknown_extension=False, + allow_field_number=False, + descriptor_pool=None, + allow_unknown_field=False, + max_recursion_depth=None): + """Parses a text representation of a protocol message into a message. + + See Merge() for more details. + + Args: + lines: An iterable of lines of a message's text representation. + message: A protocol buffer message to merge into. + allow_unknown_extension: if True, skip over missing extensions and keep + parsing + allow_field_number: if True, both field number and field name are allowed. + descriptor_pool: A DescriptorPool used to resolve Any types. + allow_unknown_field: if True, skip over unknown field and keep + parsing. Avoid to use this option if possible. It may hide some + errors (e.g. spelling error on field name) + max_recursion_depth: Optional maximum recursion depth of a text proto + message to be deserialized. Text proto messages over this depth will + fail to parse. ``None`` keeps the historical unbounded behavior. + + Returns: + The same message passed as argument. + + Raises: + ParseError: On text parsing problems. + """ + parser = _Parser(allow_unknown_extension, + allow_field_number, + descriptor_pool=descriptor_pool, + allow_unknown_field=allow_unknown_field, + max_recursion_depth=max_recursion_depth) + return parser.MergeLines(lines, message) + + +class _Parser(object): + """Text format parser for protocol message.""" + + def __init__(self, + allow_unknown_extension=False, + allow_field_number=False, + descriptor_pool=None, + allow_unknown_field=False, + max_recursion_depth=None): + self.allow_unknown_extension = allow_unknown_extension + self.allow_field_number = allow_field_number + self.descriptor_pool = descriptor_pool + self.allow_unknown_field = allow_unknown_field + self.max_recursion_depth = max_recursion_depth + self.recursion_depth = 0 + + def ParseLines(self, lines, message): + """Parses a text representation of a protocol message into a message.""" + self._allow_multiple_scalars = False + self._ParseOrMerge(lines, message) + return message + + def MergeLines(self, lines, message): + """Merges a text representation of a protocol message into a message.""" + self._allow_multiple_scalars = True + self._ParseOrMerge(lines, message) + return message + + def _ParseOrMerge(self, lines, message): + """Converts a text representation of a protocol message into a message. + + Args: + lines: Lines of a message's text representation. + message: A protocol buffer message to merge into. + + Raises: + ParseError: On text parsing problems. + """ + # Tokenize expects native str lines. + try: + str_lines = ( + line if isinstance(line, str) else line.decode('utf-8') + for line in lines) + tokenizer = Tokenizer(str_lines) + except UnicodeDecodeError as e: + raise ParseError from e + if message: + self.root_type = message.DESCRIPTOR.full_name + self.recursion_depth += 1 + if ( + self.max_recursion_depth is not None + and self.recursion_depth > self.max_recursion_depth + ): + raise ParseError( + 'Message too deep. Max recursion depth is {0}'.format( + self.max_recursion_depth + ) + ) + while not tokenizer.AtEnd(): + self._MergeField(tokenizer, message) + self.recursion_depth -= 1 + + def _MergeMessage(self, tokenizer, message, end_token): + self.recursion_depth += 1 + if ( + self.max_recursion_depth is not None + and self.recursion_depth > self.max_recursion_depth + ): + raise ParseError( + 'Message too deep. Max recursion depth is {0}'.format( + self.max_recursion_depth + ) + ) + while not tokenizer.TryConsume(end_token): + if tokenizer.AtEnd(): + raise tokenizer.ParseErrorPreviousToken( + 'Expected "%s".' % (end_token,) + ) + self._MergeField(tokenizer, message) + self.recursion_depth -= 1 + + def _MergeField(self, tokenizer, message): + """Merges a single protocol message field into a message. + + Args: + tokenizer: A tokenizer to parse the field name and values. + message: A protocol message to record the data. + + Raises: + ParseError: In case of text parsing problems. + """ + message_descriptor = message.DESCRIPTOR + if (message_descriptor.full_name == _ANY_FULL_TYPE_NAME and + tokenizer.TryConsume('[')): + type_url_prefix, packed_type_name = self._ConsumeAnyTypeUrl(tokenizer) + tokenizer.TryConsume(':') + self._DetectSilentMarker( + tokenizer, + message_descriptor.full_name, + type_url_prefix + '/' + packed_type_name, + ) + if tokenizer.TryConsume('<'): + expanded_any_end_token = '>' + else: + tokenizer.Consume('{') + expanded_any_end_token = '}' + expanded_any_sub_message = _BuildMessageFromTypeName(packed_type_name, + self.descriptor_pool) + # Direct comparison with None is used instead of implicit bool conversion + # to avoid false positives with falsy initial values, e.g. for + # google.protobuf.ListValue. + if expanded_any_sub_message is None: + raise ParseError('Type %s not found in descriptor pool' % + packed_type_name) + self._MergeMessage( + tokenizer, expanded_any_sub_message, expanded_any_end_token + ) + deterministic = False + + message.Pack( + expanded_any_sub_message, + type_url_prefix=type_url_prefix + '/', + deterministic=deterministic, + ) + return + + if tokenizer.TryConsume('['): + name = [tokenizer.ConsumeIdentifier()] + while tokenizer.TryConsume('.'): + name.append(tokenizer.ConsumeIdentifier()) + name = '.'.join(name) + + if not message_descriptor.is_extendable: + raise tokenizer.ParseErrorPreviousToken( + 'Message type "%s" does not have extensions.' % + message_descriptor.full_name) + # pylint: disable=protected-access + field = message.Extensions._FindExtensionByName(name) + # pylint: enable=protected-access + if not field: + if self.allow_unknown_extension: + field = None + else: + raise tokenizer.ParseErrorPreviousToken( + 'Extension "%s" not registered. ' + 'Did you import the _pb2 module which defines it? ' + 'If you are trying to place the extension in the MessageSet ' + 'field of another message that is in an Any or MessageSet field, ' + 'that message\'s _pb2 module must be imported as well' % name) + elif message_descriptor != field.containing_type: + raise tokenizer.ParseErrorPreviousToken( + 'Extension "%s" does not extend message type "%s".' % + (name, message_descriptor.full_name)) + + tokenizer.Consume(']') + + else: + name = tokenizer.ConsumeIdentifierOrNumber() + if self.allow_field_number and name.isdigit(): + number = ParseInteger(name, True, True) + field = message_descriptor.fields_by_number.get(number, None) + if not field and message_descriptor.is_extendable: + field = message.Extensions._FindExtensionByNumber(number) + else: + field = message_descriptor.fields_by_name.get(name, None) + + # Group names are expected to be capitalized as they appear in the + # .proto file, which actually matches their type names, not their field + # names. + if not field: + field = message_descriptor.fields_by_name.get(name.lower(), None) + if field and not _IsGroupLike(field): + field = None + if field and field.message_type.name != name: + field = None + + if not field and not self.allow_unknown_field: + raise tokenizer.ParseErrorPreviousToken( + 'Message type "%s" has no field named "%s".' % + (message_descriptor.full_name, name)) + + if field: + if not self._allow_multiple_scalars and field.containing_oneof: + # Check if there's a different field set in this oneof. + # Note that we ignore the case if the same field was set before, and we + # apply _allow_multiple_scalars to non-scalar fields as well. + which_oneof = message.WhichOneof(field.containing_oneof.name) + if which_oneof is not None and which_oneof != field.name: + raise tokenizer.ParseErrorPreviousToken( + 'Field "%s" is specified along with field "%s", another member ' + 'of oneof "%s" for message type "%s".' % + (field.name, which_oneof, field.containing_oneof.name, + message_descriptor.full_name)) + + if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE: + tokenizer.TryConsume(':') + self._DetectSilentMarker(tokenizer, message_descriptor.full_name, + field.full_name) + merger = self._MergeMessageField + else: + tokenizer.Consume(':') + self._DetectSilentMarker(tokenizer, message_descriptor.full_name, + field.full_name) + merger = self._MergeScalarField + + if (field.is_repeated and + tokenizer.TryConsume('[')): + # Short repeated format, e.g. "foo: [1, 2, 3]" + if not tokenizer.TryConsume(']'): + while True: + merger(tokenizer, message, field) + if tokenizer.TryConsume(']'): + break + tokenizer.Consume(',') + + else: + merger(tokenizer, message, field) + + else: # Proto field is unknown. + assert (self.allow_unknown_extension or self.allow_unknown_field) + self._SkipFieldContents(tokenizer, name, message_descriptor.full_name) + + # For historical reasons, fields may optionally be separated by commas or + # semicolons. + if not tokenizer.TryConsume(','): + tokenizer.TryConsume(';') + + def _LogSilentMarker(self, immediate_message_type, field_name): + pass + + def _DetectSilentMarker(self, tokenizer, immediate_message_type, field_name): + if tokenizer.contains_silent_marker_before_current_token: + self._LogSilentMarker(immediate_message_type, field_name) + + def _ConsumeAnyTypeUrl(self, tokenizer): + """Consumes a google.protobuf.Any type URL. + + Assumes the caller has already consumed the opening [ and consumes up to the + closing ]. + + Args: + tokenizer: A tokenizer to parse the type URL. + + Returns: + A tuple of type URL prefix (without trailing slash) and type name. + """ + # Consume all tokens with valid URL characters until ]. Whitespace and + # comments are ignored/skipped by the Tokenizer. + tokens = [] + last_slash = -1 + while True: + try: + tokens.append(tokenizer.ConsumeUrlChars()) + continue + except ParseError: + pass + if tokenizer.TryConsume('/'): + last_slash = len(tokens) + tokens.append('/') + else: + tokenizer.Consume(']') + break + + if last_slash == -1: + raise tokenizer.ParseError('Type URL does not contain "/".') + + prefix = ''.join(tokens[:last_slash]) + name = ''.join(tokens[last_slash + 1 :]) + + if not prefix: + raise tokenizer.ParseError('Type URL prefix is empty.') + if prefix.startswith('/'): + raise tokenizer.ParseError('Type URL prefix starts with "/".') + + # Check for invalid percent encodings. '%' needs to be followed by exactly + # two valid hexadecimal digits. + for i, char in enumerate(prefix): + if char == '%' and not _PERCENT_ENCODING.match(prefix[i : i + 3]): + raise tokenizer.ParseError( + f'Invalid percent escape, got "{prefix[i : i + 3]}".' + ) + + # After the last slash we expect a valid type name, not just any sequence of + # URL characters. + if not _TYPE_NAME.match(name): + raise tokenizer.ParseError('Expected type name, got "%s".' % name) + + return prefix, name + + def _MergeMessageField(self, tokenizer, message, field): + """Merges a single scalar field into a message. + + Args: + tokenizer: A tokenizer to parse the field value. + message: The message of which field is a member. + field: The descriptor of the field to be merged. + + Raises: + ParseError: In case of text parsing problems. + """ + is_map_entry = _IsMapEntry(field) + + if tokenizer.TryConsume('<'): + end_token = '>' + else: + tokenizer.Consume('{') + end_token = '}' + + if field.is_repeated: + if field.is_extension: + sub_message = message.Extensions[field].add() + elif is_map_entry: + sub_message = getattr(message, field.name).GetEntryClass()() + else: + sub_message = getattr(message, field.name).add() + else: + if field.is_extension: + if (not self._allow_multiple_scalars and + message.HasExtension(field)): + raise tokenizer.ParseErrorPreviousToken( + 'Message type "%s" should not have multiple "%s" extensions.' % + (message.DESCRIPTOR.full_name, field.full_name)) + sub_message = message.Extensions[field] + else: + # Also apply _allow_multiple_scalars to message field. + # TODO: Change to _allow_singular_overwrites. + if (not self._allow_multiple_scalars and + message.HasField(field.name)): + raise tokenizer.ParseErrorPreviousToken( + 'Message type "%s" should not have multiple "%s" fields.' % + (message.DESCRIPTOR.full_name, field.name)) + sub_message = getattr(message, field.name) + sub_message.SetInParent() + + self._MergeMessage(tokenizer, sub_message, end_token) + + if is_map_entry: + value_cpptype = field.message_type.fields_by_name['value'].cpp_type + if value_cpptype == descriptor.FieldDescriptor.CPPTYPE_MESSAGE: + value = getattr(message, field.name)[sub_message.key] + value.CopyFrom(sub_message.value) + else: + getattr(message, field.name)[sub_message.key] = sub_message.value + + def _MergeScalarField(self, tokenizer, message, field): + """Merges a single scalar field into a message. + + Args: + tokenizer: A tokenizer to parse the field value. + message: A protocol message to record the data. + field: The descriptor of the field to be merged. + + Raises: + ParseError: In case of text parsing problems. + RuntimeError: On runtime errors. + """ + _ = self.allow_unknown_extension + value = None + + if field.type in (descriptor.FieldDescriptor.TYPE_INT32, + descriptor.FieldDescriptor.TYPE_SINT32, + descriptor.FieldDescriptor.TYPE_SFIXED32): + value = _ConsumeInt32(tokenizer) + elif field.type in (descriptor.FieldDescriptor.TYPE_INT64, + descriptor.FieldDescriptor.TYPE_SINT64, + descriptor.FieldDescriptor.TYPE_SFIXED64): + value = _ConsumeInt64(tokenizer) + elif field.type in (descriptor.FieldDescriptor.TYPE_UINT32, + descriptor.FieldDescriptor.TYPE_FIXED32): + value = _ConsumeUint32(tokenizer) + elif field.type in (descriptor.FieldDescriptor.TYPE_UINT64, + descriptor.FieldDescriptor.TYPE_FIXED64): + value = _ConsumeUint64(tokenizer) + elif field.type in (descriptor.FieldDescriptor.TYPE_FLOAT, + descriptor.FieldDescriptor.TYPE_DOUBLE): + value = tokenizer.ConsumeFloat() + elif field.type == descriptor.FieldDescriptor.TYPE_BOOL: + value = tokenizer.ConsumeBool() + elif field.type == descriptor.FieldDescriptor.TYPE_STRING: + value = tokenizer.ConsumeString() + elif field.type == descriptor.FieldDescriptor.TYPE_BYTES: + value = tokenizer.ConsumeByteString() + elif field.type == descriptor.FieldDescriptor.TYPE_ENUM: + value = tokenizer.ConsumeEnum(field) + else: + raise RuntimeError('Unknown field type %d' % field.type) + + if field.is_repeated: + if field.is_extension: + message.Extensions[field].append(value) + else: + getattr(message, field.name).append(value) + else: + if field.is_extension: + if (not self._allow_multiple_scalars and + field.has_presence and + message.HasExtension(field)): + raise tokenizer.ParseErrorPreviousToken( + 'Message type "%s" should not have multiple "%s" extensions.' % + (message.DESCRIPTOR.full_name, field.full_name)) + else: + message.Extensions[field] = value + else: + duplicate_error = False + if not self._allow_multiple_scalars: + if field.has_presence: + duplicate_error = message.HasField(field.name) + else: + # For field that doesn't represent presence, try best effort to + # check multiple scalars by compare to default values. + duplicate_error = not decoder.IsDefaultScalarValue( + getattr(message, field.name) + ) + + if duplicate_error: + raise tokenizer.ParseErrorPreviousToken( + 'Message type "%s" should not have multiple "%s" fields.' % + (message.DESCRIPTOR.full_name, field.name)) + else: + setattr(message, field.name, value) + + def _SkipFieldContents(self, tokenizer, field_name, immediate_message_type): + """Skips over contents (value or message) of a field. + + Args: + tokenizer: A tokenizer to parse the field name and values. + field_name: The field name currently being parsed. + immediate_message_type: The type of the message immediately containing + the silent marker. + """ + # Try to guess the type of this field. + # If this field is not a message, there should be a ":" between the + # field name and the field value and also the field value should not + # start with "{" or "<" which indicates the beginning of a message body. + # If there is no ":" or there is a "{" or "<" after ":", this field has + # to be a message or the input is ill-formed. + if tokenizer.TryConsume( + ':') and not tokenizer.LookingAt('{') and not tokenizer.LookingAt('<'): + self._DetectSilentMarker(tokenizer, immediate_message_type, field_name) + if tokenizer.LookingAt('['): + self._SkipRepeatedFieldValue(tokenizer, immediate_message_type) + else: + self._SkipFieldValue(tokenizer) + else: + self._DetectSilentMarker(tokenizer, immediate_message_type, field_name) + self._SkipFieldMessage(tokenizer, immediate_message_type) + + def _SkipField(self, tokenizer, immediate_message_type): + """Skips over a complete field (name and value/message). + + Args: + tokenizer: A tokenizer to parse the field name and values. + immediate_message_type: The type of the message immediately containing + the silent marker. + """ + field_name = '' + if tokenizer.TryConsume('['): + # Consume extension or google.protobuf.Any type URL + field_name += '[' + tokenizer.ConsumeIdentifier() + num_identifiers = 1 + while tokenizer.TryConsume('.'): + field_name += '.' + tokenizer.ConsumeIdentifier() + num_identifiers += 1 + # This is possibly a type URL for an Any message. + if num_identifiers == 3 and tokenizer.TryConsume('/'): + field_name += '/' + tokenizer.ConsumeIdentifier() + while tokenizer.TryConsume('.'): + field_name += '.' + tokenizer.ConsumeIdentifier() + tokenizer.Consume(']') + field_name += ']' + else: + field_name += tokenizer.ConsumeIdentifierOrNumber() + + self._SkipFieldContents(tokenizer, field_name, immediate_message_type) + + # For historical reasons, fields may optionally be separated by commas or + # semicolons. + if not tokenizer.TryConsume(','): + tokenizer.TryConsume(';') + + def _SkipFieldMessage(self, tokenizer, immediate_message_type): + """Skips over a field message. + + Args: + tokenizer: A tokenizer to parse the field name and values. + immediate_message_type: The type of the message immediately containing + the silent marker + """ + if tokenizer.TryConsume('<'): + delimiter = '>' + else: + tokenizer.Consume('{') + delimiter = '}' + + while not tokenizer.LookingAt('>') and not tokenizer.LookingAt('}'): + self._SkipField(tokenizer, immediate_message_type) + + tokenizer.Consume(delimiter) + + def _SkipFieldValue(self, tokenizer): + """Skips over a field value. + + Args: + tokenizer: A tokenizer to parse the field name and values. + + Raises: + ParseError: In case an invalid field value is found. + """ + if (not tokenizer.TryConsumeByteString()and + not tokenizer.TryConsumeIdentifier() and + not _TryConsumeInt64(tokenizer) and + not _TryConsumeUint64(tokenizer) and + not tokenizer.TryConsumeFloat()): + raise ParseError('Invalid field value: ' + tokenizer.token) + + def _SkipRepeatedFieldValue(self, tokenizer, immediate_message_type): + """Skips over a repeated field value. + + Args: + tokenizer: A tokenizer to parse the field value. + """ + tokenizer.Consume('[') + if not tokenizer.TryConsume(']'): + while True: + if tokenizer.LookingAt('<') or tokenizer.LookingAt('{'): + self._SkipFieldMessage(tokenizer, immediate_message_type) + else: + self._SkipFieldValue(tokenizer) + if tokenizer.TryConsume(']'): + break + tokenizer.Consume(',') + + +class Tokenizer(object): + """Protocol buffer text representation tokenizer. + + This class handles the lower level string parsing by splitting it into + meaningful tokens. + + It was directly ported from the Java protocol buffer API. + """ + + _WHITESPACE = re.compile(r'\s+') + _COMMENT = re.compile(r'(\s*#.*$)', re.MULTILINE) + _WHITESPACE_OR_COMMENT = re.compile(r'(\s|(#.*$))+', re.MULTILINE) + _TOKEN = re.compile( + '|'.join( + [ + r'[a-zA-Z_][0-9a-zA-Z_+-]*', # an identifier + r'([0-9+-]|(\.[0-9]))[0-9a-zA-Z_.+-]*', # a number + ] + + [ # quoted str for each quote mark + # Avoid backtracking! https://stackoverflow.com/a/844267 + r'{qt}[^{qt}\n\\]*((\\.)+[^{qt}\n\\]*)*({qt}|\\?$)'.format( + qt=mark + ) + for mark in _QUOTES + ] + ) + ) + + _IDENTIFIER = re.compile(r'[^\d\W]\w*') + _IDENTIFIER_OR_NUMBER = re.compile(r'\w+') + # Accepted URL characters (excluding "/") + _URL_CHARS = re.compile(r'^[0-9a-zA-Z-.~_ !$&()*+,;=%]+$') + + def __init__(self, lines, skip_comments=True): + self._position = 0 + self._line = -1 + self._column = 0 + self._token_start = None + self.token = '' + self._lines = iter(lines) + self._current_line = '' + self._previous_line = 0 + self._previous_column = 0 + self._more_lines = True + self._skip_comments = skip_comments + self._whitespace_pattern = (skip_comments and self._WHITESPACE_OR_COMMENT + or self._WHITESPACE) + self.contains_silent_marker_before_current_token = False + + self._SkipWhitespace() + self.NextToken() + + def LookingAt(self, token): + return self.token == token + + def AtEnd(self): + """Checks the end of the text was reached. + + Returns: + True iff the end was reached. + """ + return not self.token + + def _PopLine(self): + while len(self._current_line) <= self._column: + try: + self._current_line = next(self._lines) + except StopIteration: + self._current_line = '' + self._more_lines = False + return + else: + self._line += 1 + self._column = 0 + + def _SkipWhitespace(self): + while True: + self._PopLine() + match = self._whitespace_pattern.match(self._current_line, self._column) + if not match: + break + self.contains_silent_marker_before_current_token = match.group(0) == ( + ' ' + _DEBUG_STRING_SILENT_MARKER) + length = len(match.group(0)) + self._column += length + + def TryConsume(self, token): + """Tries to consume a given piece of text. + + Args: + token: Text to consume. + + Returns: + True iff the text was consumed. + """ + if self.token == token: + self.NextToken() + return True + return False + + def Consume(self, token): + """Consumes a piece of text. + + Args: + token: Text to consume. + + Raises: + ParseError: If the text couldn't be consumed. + """ + if not self.TryConsume(token): + raise self.ParseError('Expected "%s".' % token) + + def ConsumeComment(self): + result = self.token + if not self._COMMENT.match(result): + raise self.ParseError('Expected comment.') + self.NextToken() + return result + + def ConsumeCommentOrTrailingComment(self): + """Consumes a comment, returns a 2-tuple (trailing bool, comment str).""" + + # Tokenizer initializes _previous_line and _previous_column to 0. As the + # tokenizer starts, it looks like there is a previous token on the line. + just_started = self._line == 0 and self._column == 0 + + before_parsing = self._previous_line + comment = self.ConsumeComment() + + # A trailing comment is a comment on the same line than the previous token. + trailing = (self._previous_line == before_parsing + and not just_started) + + return trailing, comment + + def TryConsumeIdentifier(self): + try: + self.ConsumeIdentifier() + return True + except ParseError: + return False + + def ConsumeIdentifier(self): + """Consumes protocol message field identifier. + + Returns: + Identifier string. + + Raises: + ParseError: If an identifier couldn't be consumed. + """ + result = self.token + if not self._IDENTIFIER.match(result): + raise self.ParseError('Expected identifier.') + self.NextToken() + return result + + def TryConsumeIdentifierOrNumber(self): + try: + self.ConsumeIdentifierOrNumber() + return True + except ParseError: + return False + + def ConsumeIdentifierOrNumber(self): + """Consumes protocol message field identifier. + + Returns: + Identifier string. + + Raises: + ParseError: If an identifier couldn't be consumed. + """ + result = self.token + if not self._IDENTIFIER_OR_NUMBER.match(result): + raise self.ParseError('Expected identifier or number, got %s.' % result) + self.NextToken() + return result + + def TryConsumeInteger(self): + try: + self.ConsumeInteger() + return True + except ParseError: + return False + + def ConsumeInteger(self): + """Consumes an integer number. + + Returns: + The integer parsed. + + Raises: + ParseError: If an integer couldn't be consumed. + """ + try: + result = _ParseAbstractInteger(self.token) + except ValueError as e: + raise self.ParseError(str(e)) + self.NextToken() + return result + + def TryConsumeFloat(self): + try: + self.ConsumeFloat() + return True + except ParseError: + return False + + def ConsumeFloat(self): + """Consumes an floating point number. + + Returns: + The number parsed. + + Raises: + ParseError: If a floating point number couldn't be consumed. + """ + try: + result = ParseFloat(self.token) + except ValueError as e: + raise self.ParseError(str(e)) + self.NextToken() + return result + + def ConsumeBool(self): + """Consumes a boolean value. + + Returns: + The bool parsed. + + Raises: + ParseError: If a boolean value couldn't be consumed. + """ + try: + result = ParseBool(self.token) + except ValueError as e: + raise self.ParseError(str(e)) + self.NextToken() + return result + + def TryConsumeByteString(self): + try: + self.ConsumeByteString() + return True + except ParseError: + return False + + def ConsumeString(self): + """Consumes a string value. + + Returns: + The string parsed. + + Raises: + ParseError: If a string value couldn't be consumed. + """ + the_bytes = self.ConsumeByteString() + try: + return str(the_bytes, 'utf-8') + except UnicodeDecodeError as e: + raise self._StringParseError(e) + + def ConsumeByteString(self): + """Consumes a byte array value. + + Returns: + The array parsed (as a string). + + Raises: + ParseError: If a byte array value couldn't be consumed. + """ + the_list = [self._ConsumeSingleByteString()] + while self.token and self.token[0] in _QUOTES: + the_list.append(self._ConsumeSingleByteString()) + return b''.join(the_list) + + def _ConsumeSingleByteString(self): + """Consume one token of a string literal. + + String literals (whether bytes or text) can come in multiple adjacent + tokens which are automatically concatenated, like in C or Python. This + method only consumes one token. + + Returns: + The token parsed. + Raises: + ParseError: When the wrong format data is found. + """ + text = self.token + if len(text) < 1 or text[0] not in _QUOTES: + raise self.ParseError('Expected string but found: %r' % (text,)) + + if len(text) < 2 or text[-1] != text[0]: + raise self.ParseError('String missing ending quote: %r' % (text,)) + + try: + result = text_encoding.CUnescape(text[1:-1]) + except ValueError as e: + raise self.ParseError(str(e)) + self.NextToken() + return result + + def ConsumeEnum(self, field): + try: + result = ParseEnum(field, self.token) + except ValueError as e: + raise self.ParseError(str(e)) + self.NextToken() + return result + + def ConsumeUrlChars(self): + """Consumes a token containing valid URL characters. + + Excludes '/' so that it can be treated specially as a delimiter. + + Returns: + The next token containing one or more URL characters. + + Raises: + ParseError: If the next token contains unaccepted URL characters. + """ + if not self._URL_CHARS.match(self.token): + raise self.ParseError('Expected URL character(s), got "%s"' % self.token) + + result = self.token + self.NextToken() + return result + + def TryConsumeUrlChars(self): + try: + self.ConsumeUrlChars() + return True + except ParseError: + return False + + def ParseErrorPreviousToken(self, message): + """Creates and *returns* a ParseError for the previously read token. + + Args: + message: A message to set for the exception. + + Returns: + A ParseError instance. + """ + return ParseError(message, self._previous_line + 1, + self._previous_column + 1) + + def ParseError(self, message): + """Creates and *returns* a ParseError for the current token.""" + return ParseError('\'' + self._current_line + '\': ' + message, + self._line + 1, self._column + 1) + + def _StringParseError(self, e): + return self.ParseError('Couldn\'t parse string: ' + str(e)) + + def NextToken(self): + """Reads the next meaningful token.""" + self._previous_line = self._line + self._previous_column = self._column + self.contains_silent_marker_before_current_token = False + + self._column += len(self.token) + self._SkipWhitespace() + + if not self._more_lines: + self.token = '' + return + + match = self._TOKEN.match(self._current_line, self._column) + if not match and not self._skip_comments: + match = self._COMMENT.match(self._current_line, self._column) + if match: + token = match.group(0) + self.token = token + else: + self.token = self._current_line[self._column] + +# Aliased so it can still be accessed by current visibility violators. +# TODO: Migrate violators to textformat_tokenizer. +_Tokenizer = Tokenizer # pylint: disable=invalid-name + + +def _ConsumeInt32(tokenizer): + """Consumes a signed 32bit integer number from tokenizer. + + Args: + tokenizer: A tokenizer used to parse the number. + + Returns: + The integer parsed. + + Raises: + ParseError: If a signed 32bit integer couldn't be consumed. + """ + return _ConsumeInteger(tokenizer, is_signed=True, is_long=False) + + +def _ConsumeUint32(tokenizer): + """Consumes an unsigned 32bit integer number from tokenizer. + + Args: + tokenizer: A tokenizer used to parse the number. + + Returns: + The integer parsed. + + Raises: + ParseError: If an unsigned 32bit integer couldn't be consumed. + """ + return _ConsumeInteger(tokenizer, is_signed=False, is_long=False) + + +def _TryConsumeInt64(tokenizer): + try: + _ConsumeInt64(tokenizer) + return True + except ParseError: + return False + + +def _ConsumeInt64(tokenizer): + """Consumes a signed 32bit integer number from tokenizer. + + Args: + tokenizer: A tokenizer used to parse the number. + + Returns: + The integer parsed. + + Raises: + ParseError: If a signed 32bit integer couldn't be consumed. + """ + return _ConsumeInteger(tokenizer, is_signed=True, is_long=True) + + +def _TryConsumeUint64(tokenizer): + try: + _ConsumeUint64(tokenizer) + return True + except ParseError: + return False + + +def _ConsumeUint64(tokenizer): + """Consumes an unsigned 64bit integer number from tokenizer. + + Args: + tokenizer: A tokenizer used to parse the number. + + Returns: + The integer parsed. + + Raises: + ParseError: If an unsigned 64bit integer couldn't be consumed. + """ + return _ConsumeInteger(tokenizer, is_signed=False, is_long=True) + + +def _ConsumeInteger(tokenizer, is_signed=False, is_long=False): + """Consumes an integer number from tokenizer. + + Args: + tokenizer: A tokenizer used to parse the number. + is_signed: True if a signed integer must be parsed. + is_long: True if a long integer must be parsed. + + Returns: + The integer parsed. + + Raises: + ParseError: If an integer with given characteristics couldn't be consumed. + """ + try: + result = ParseInteger(tokenizer.token, is_signed=is_signed, is_long=is_long) + except ValueError as e: + raise tokenizer.ParseError(str(e)) + tokenizer.NextToken() + return result + + +def ParseInteger(text, is_signed=False, is_long=False): + """Parses an integer. + + Args: + text: The text to parse. + is_signed: True if a signed integer must be parsed. + is_long: True if a long integer must be parsed. + + Returns: + The integer value. + + Raises: + ValueError: Thrown Iff the text is not a valid integer. + """ + # Do the actual parsing. Exception handling is propagated to caller. + result = _ParseAbstractInteger(text) + + # Check if the integer is sane. Exceptions handled by callers. + checker = _INTEGER_CHECKERS[2 * int(is_long) + int(is_signed)] + checker.CheckValue(result) + return result + + +def _ParseAbstractInteger(text): + """Parses an integer without checking size/signedness. + + Args: + text: The text to parse. + + Returns: + The integer value. + + Raises: + ValueError: Thrown Iff the text is not a valid integer. + """ + # Do the actual parsing. Exception handling is propagated to caller. + orig_text = text + c_octal_match = re.match(r'(-?)0(\d+)$', text) + if c_octal_match: + # Python 3 no longer supports 0755 octal syntax without the 'o', so + # we always use the '0o' prefix for multi-digit numbers starting with 0. + text = c_octal_match.group(1) + '0o' + c_octal_match.group(2) + try: + return int(text, 0) + except ValueError: + raise ValueError('Couldn\'t parse integer: %s' % orig_text) + + +def ParseFloat(text): + """Parse a floating point number. + + Args: + text: Text to parse. + + Returns: + The number parsed. + + Raises: + ValueError: If a floating point number couldn't be parsed. + """ + if _FLOAT_OCTAL_PREFIX.match(text): + raise ValueError('Invalid octal float: %s' % text) + try: + # Assume Python compatible syntax. + return float(text) + except ValueError: + # Check alternative spellings. + if _FLOAT_INFINITY.match(text): + if text[0] == '-': + return float('-inf') + else: + return float('inf') + elif _FLOAT_NAN.match(text): + return float('nan') + else: + # assume '1.0f' format + try: + return float(text.rstrip('fF')) + except ValueError: + raise ValueError("Couldn't parse float: %s" % text) + + +def ParseBool(text): + """Parse a boolean value. + + Args: + text: Text to parse. + + Returns: + Boolean values parsed + + Raises: + ValueError: If text is not a valid boolean. + """ + if text in ('true', 't', '1', 'True'): + return True + elif text in ('false', 'f', '0', 'False'): + return False + else: + raise ValueError('Expected "true" or "false".') + + +def ParseEnum(field, value): + """Parse an enum value. + + The value can be specified by a number (the enum value), or by + a string literal (the enum name). + + Args: + field: Enum field descriptor. + value: String value. + + Returns: + Enum value number. + + Raises: + ValueError: If the enum value could not be parsed. + """ + enum_descriptor = field.enum_type + try: + number = int(value, 0) + except ValueError: + # Identifier. + enum_value = enum_descriptor.values_by_name.get(value, None) + if enum_value is None: + raise ValueError('Enum type "%s" has no value named %s.' % + (enum_descriptor.full_name, value)) + else: + if not field.enum_type.is_closed: + return number + enum_value = enum_descriptor.values_by_number.get(number, None) + if enum_value is None: + raise ValueError('Enum type "%s" has no value with number %d.' % + (enum_descriptor.full_name, number)) + return enum_value.number diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/timestamp.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/timestamp.py new file mode 100644 index 0000000000000000000000000000000000000000..b23b9f11af02984469f565ae253730c1fdda0c1d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/timestamp.py @@ -0,0 +1,112 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains the Timestamp helper APIs.""" + +import datetime +from typing import Optional + +from google.protobuf.timestamp_pb2 import Timestamp + + +def from_json_string(value: str) -> Timestamp: + """Parse a RFC 3339 date string format to Timestamp. + + Args: + value: A date string. Any fractional digits (or none) and any offset are + accepted as long as they fit into nano-seconds precision. Example of + accepted format: '1972-01-01T10:00:20.021-05:00' + + Raises: + ValueError: On parsing problems. + """ + timestamp = Timestamp() + timestamp.FromJsonString(value) + return timestamp + + +def from_microseconds(micros: float) -> Timestamp: + """Converts microseconds since epoch to Timestamp.""" + timestamp = Timestamp() + timestamp.FromMicroseconds(micros) + return timestamp + + +def from_milliseconds(millis: float) -> Timestamp: + """Converts milliseconds since epoch to Timestamp.""" + timestamp = Timestamp() + timestamp.FromMilliseconds(millis) + return timestamp + + +def from_nanoseconds(nanos: float) -> Timestamp: + """Converts nanoseconds since epoch to Timestamp.""" + timestamp = Timestamp() + timestamp.FromNanoseconds(nanos) + return timestamp + + +def from_seconds(seconds: float) -> Timestamp: + """Converts seconds since epoch to Timestamp.""" + timestamp = Timestamp() + timestamp.FromSeconds(seconds) + return timestamp + + +def from_current_time() -> Timestamp: + """Converts the current UTC to Timestamp.""" + timestamp = Timestamp() + timestamp.FromDatetime(datetime.datetime.now(tz=datetime.timezone.utc)) + return timestamp + + +def to_json_string(ts: Timestamp) -> str: + """Converts Timestamp to RFC 3339 date string format. + + Returns: + A string converted from timestamp. The string is always Z-normalized + and uses 3, 6 or 9 fractional digits as required to represent the + exact time. Example of the return format: '1972-01-01T10:00:20.021Z' + """ + return ts.ToJsonString() + + +def to_microseconds(ts: Timestamp) -> int: + """Converts Timestamp to microseconds since epoch.""" + return ts.ToMicroseconds() + + +def to_milliseconds(ts: Timestamp) -> int: + """Converts Timestamp to milliseconds since epoch.""" + return ts.ToMilliseconds() + + +def to_nanoseconds(ts: Timestamp) -> int: + """Converts Timestamp to nanoseconds since epoch.""" + return ts.ToNanoseconds() + + +def to_seconds(ts: Timestamp) -> int: + """Converts Timestamp to seconds since epoch.""" + return ts.ToSeconds() + + +def to_datetime( + ts: Timestamp, tz: Optional[datetime.tzinfo] = None +) -> datetime.datetime: + """Converts Timestamp to a datetime. + + Args: + tz: A datetime.tzinfo subclass; defaults to None. + + Returns: + If tzinfo is None, returns a timezone-naive UTC datetime (with no timezone + information, i.e. not aware that it's UTC). + + Otherwise, returns a timezone-aware datetime in the input timezone. + """ + return ts.ToDatetime(tzinfo=tz) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/timestamp_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/timestamp_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..c096dcaad2e86d4087e11384b4660a24c8587e23 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/timestamp_pb2.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/timestamp.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/timestamp.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1fgoogle/protobuf/timestamp.proto\x12\x0fgoogle.protobuf\";\n\tTimestamp\x12\x18\n\x07seconds\x18\x01 \x01(\x03R\x07seconds\x12\x14\n\x05nanos\x18\x02 \x01(\x05R\x05nanosB\x85\x01\n\x13\x63om.google.protobufB\x0eTimestampProtoP\x01Z2google.golang.org/protobuf/types/known/timestamppb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.timestamp_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\016TimestampProtoP\001Z2google.golang.org/protobuf/types/known/timestamppb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_TIMESTAMP']._serialized_start=52 + _globals['_TIMESTAMP']._serialized_end=111 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/type_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/type_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..73c5a8f8777bc0106d62130ee58c9145c562e8e5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/type_pb2.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/type.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/type.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 +from google.protobuf import source_context_pb2 as google_dot_protobuf_dot_source__context__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1agoogle/protobuf/type.proto\x12\x0fgoogle.protobuf\x1a\x19google/protobuf/any.proto\x1a$google/protobuf/source_context.proto\"\xa7\x02\n\x04Type\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12.\n\x06\x66ields\x18\x02 \x03(\x0b\x32\x16.google.protobuf.FieldR\x06\x66ields\x12\x16\n\x06oneofs\x18\x03 \x03(\tR\x06oneofs\x12\x31\n\x07options\x18\x04 \x03(\x0b\x32\x17.google.protobuf.OptionR\x07options\x12\x45\n\x0esource_context\x18\x05 \x01(\x0b\x32\x1e.google.protobuf.SourceContextR\rsourceContext\x12/\n\x06syntax\x18\x06 \x01(\x0e\x32\x17.google.protobuf.SyntaxR\x06syntax\x12\x18\n\x07\x65\x64ition\x18\x07 \x01(\tR\x07\x65\x64ition\"\xb4\x06\n\x05\x46ield\x12/\n\x04kind\x18\x01 \x01(\x0e\x32\x1b.google.protobuf.Field.KindR\x04kind\x12\x44\n\x0b\x63\x61rdinality\x18\x02 \x01(\x0e\x32\".google.protobuf.Field.CardinalityR\x0b\x63\x61rdinality\x12\x16\n\x06number\x18\x03 \x01(\x05R\x06number\x12\x12\n\x04name\x18\x04 \x01(\tR\x04name\x12\x19\n\x08type_url\x18\x06 \x01(\tR\x07typeUrl\x12\x1f\n\x0boneof_index\x18\x07 \x01(\x05R\noneofIndex\x12\x16\n\x06packed\x18\x08 \x01(\x08R\x06packed\x12\x31\n\x07options\x18\t \x03(\x0b\x32\x17.google.protobuf.OptionR\x07options\x12\x1b\n\tjson_name\x18\n \x01(\tR\x08jsonName\x12#\n\rdefault_value\x18\x0b \x01(\tR\x0c\x64\x65\x66\x61ultValue\"\xc8\x02\n\x04Kind\x12\x10\n\x0cTYPE_UNKNOWN\x10\x00\x12\x0f\n\x0bTYPE_DOUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\n\nTYPE_INT64\x10\x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_INT32\x10\x05\x12\x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED32\x10\x07\x12\r\n\tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\x0e\n\nTYPE_GROUP\x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTYPE_BYTES\x10\x0c\x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\x11\n\rTYPE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\x0bTYPE_SINT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"t\n\x0b\x43\x61rdinality\x12\x17\n\x13\x43\x41RDINALITY_UNKNOWN\x10\x00\x12\x18\n\x14\x43\x41RDINALITY_OPTIONAL\x10\x01\x12\x18\n\x14\x43\x41RDINALITY_REQUIRED\x10\x02\x12\x18\n\x14\x43\x41RDINALITY_REPEATED\x10\x03\"\x99\x02\n\x04\x45num\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x38\n\tenumvalue\x18\x02 \x03(\x0b\x32\x1a.google.protobuf.EnumValueR\tenumvalue\x12\x31\n\x07options\x18\x03 \x03(\x0b\x32\x17.google.protobuf.OptionR\x07options\x12\x45\n\x0esource_context\x18\x04 \x01(\x0b\x32\x1e.google.protobuf.SourceContextR\rsourceContext\x12/\n\x06syntax\x18\x05 \x01(\x0e\x32\x17.google.protobuf.SyntaxR\x06syntax\x12\x18\n\x07\x65\x64ition\x18\x06 \x01(\tR\x07\x65\x64ition\"j\n\tEnumValue\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n\x06number\x18\x02 \x01(\x05R\x06number\x12\x31\n\x07options\x18\x03 \x03(\x0b\x32\x17.google.protobuf.OptionR\x07options\"H\n\x06Option\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12*\n\x05value\x18\x02 \x01(\x0b\x32\x14.google.protobuf.AnyR\x05value*C\n\x06Syntax\x12\x11\n\rSYNTAX_PROTO2\x10\x00\x12\x11\n\rSYNTAX_PROTO3\x10\x01\x12\x13\n\x0fSYNTAX_EDITIONS\x10\x02\x42{\n\x13\x63om.google.protobufB\tTypeProtoP\x01Z-google.golang.org/protobuf/types/known/typepb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.type_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\tTypeProtoP\001Z-google.golang.org/protobuf/types/known/typepb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_SYNTAX']._serialized_start=1699 + _globals['_SYNTAX']._serialized_end=1766 + _globals['_TYPE']._serialized_start=113 + _globals['_TYPE']._serialized_end=408 + _globals['_FIELD']._serialized_start=411 + _globals['_FIELD']._serialized_end=1231 + _globals['_FIELD_KIND']._serialized_start=785 + _globals['_FIELD_KIND']._serialized_end=1113 + _globals['_FIELD_CARDINALITY']._serialized_start=1115 + _globals['_FIELD_CARDINALITY']._serialized_end=1231 + _globals['_ENUM']._serialized_start=1234 + _globals['_ENUM']._serialized_end=1515 + _globals['_ENUMVALUE']._serialized_start=1517 + _globals['_ENUMVALUE']._serialized_end=1623 + _globals['_OPTION']._serialized_start=1625 + _globals['_OPTION']._serialized_end=1697 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/unknown_fields.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/unknown_fields.py new file mode 100644 index 0000000000000000000000000000000000000000..6c16a2d30ced679544f8134812e99118caed8348 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/unknown_fields.py @@ -0,0 +1,96 @@ +# Protocol Buffers - Google's data interchange format +# Copyright 2008 Google Inc. All rights reserved. +# +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file or at +# https://developers.google.com/open-source/licenses/bsd + +"""Contains Unknown Fields APIs. + +Simple usage example: + unknown_field_set = UnknownFieldSet(message) + for unknown_field in unknown_field_set: + wire_type = unknown_field.wire_type + field_number = unknown_field.field_number + data = unknown_field.data +""" + + +from google.protobuf.internal import api_implementation + +if api_implementation._c_module is not None: # pylint: disable=protected-access + UnknownFieldSet = api_implementation._c_module.UnknownFieldSet # pylint: disable=protected-access +else: + from google.protobuf.internal import decoder # pylint: disable=g-import-not-at-top + from google.protobuf.internal import wire_format # pylint: disable=g-import-not-at-top + + class UnknownField: + """A parsed unknown field.""" + + # Disallows assignment to other attributes. + __slots__ = ['_field_number', '_wire_type', '_data'] + + def __init__(self, field_number, wire_type, data): + self._field_number = field_number + self._wire_type = wire_type + self._data = data + return + + @property + def field_number(self): + return self._field_number + + @property + def wire_type(self): + return self._wire_type + + @property + def data(self): + return self._data + + class UnknownFieldSet: + """UnknownField container.""" + + # Disallows assignment to other attributes. + __slots__ = ['_values'] + + def __init__(self, msg): + + def InternalAdd(field_number, wire_type, data): + unknown_field = UnknownField(field_number, wire_type, data) + self._values.append(unknown_field) + + self._values = [] + msg_des = msg.DESCRIPTOR + # pylint: disable=protected-access + unknown_fields = msg._unknown_fields + if (msg_des.has_options and + msg_des.GetOptions().message_set_wire_format): + local_decoder = decoder.UnknownMessageSetItemDecoder() + for _, buffer in unknown_fields: + (field_number, data) = local_decoder(memoryview(buffer)) + InternalAdd(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED, data) + else: + for tag_bytes, buffer in unknown_fields: + field_number, wire_type = decoder.DecodeTag(tag_bytes) + if field_number == 0: + raise RuntimeError('Field number 0 is illegal.') + (data, _) = decoder._DecodeUnknownField( + memoryview(buffer), 0, len(buffer), field_number, wire_type + ) + InternalAdd(field_number, wire_type, data) + + def __getitem__(self, index): + size = len(self._values) + if index < 0: + index += size + if index < 0 or index >= size: + raise IndexError('index %d out of range'.index) + + return self._values[index] + + def __len__(self): + return len(self._values) + + def __iter__(self): + return iter(self._values) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/util/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/util/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/wrappers_pb2.py b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/wrappers_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..1901bedad0f14a78351063c3d14a6f2008f7aeca --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/google/protobuf/wrappers_pb2.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# NO CHECKED-IN PROTOBUF GENCODE +# source: google/protobuf/wrappers.proto +# Protobuf Python Version: 7.35.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import runtime_version as _runtime_version +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +_runtime_version.ValidateProtobufRuntimeVersion( + _runtime_version.Domain.PUBLIC, + 7, + 35, + 1, + '', + 'google/protobuf/wrappers.proto' +) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1egoogle/protobuf/wrappers.proto\x12\x0fgoogle.protobuf\"#\n\x0b\x44oubleValue\x12\x14\n\x05value\x18\x01 \x01(\x01R\x05value\"\"\n\nFloatValue\x12\x14\n\x05value\x18\x01 \x01(\x02R\x05value\"\"\n\nInt64Value\x12\x14\n\x05value\x18\x01 \x01(\x03R\x05value\"#\n\x0bUInt64Value\x12\x14\n\x05value\x18\x01 \x01(\x04R\x05value\"\"\n\nInt32Value\x12\x14\n\x05value\x18\x01 \x01(\x05R\x05value\"#\n\x0bUInt32Value\x12\x14\n\x05value\x18\x01 \x01(\rR\x05value\"!\n\tBoolValue\x12\x14\n\x05value\x18\x01 \x01(\x08R\x05value\"#\n\x0bStringValue\x12\x14\n\x05value\x18\x01 \x01(\tR\x05value\"\"\n\nBytesValue\x12\x14\n\x05value\x18\x01 \x01(\x0cR\x05valueB\x83\x01\n\x13\x63om.google.protobufB\rWrappersProtoP\x01Z1google.golang.org/protobuf/types/known/wrapperspb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.wrappers_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\rWrappersProtoP\001Z1google.golang.org/protobuf/types/known/wrapperspb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes' + _globals['_DOUBLEVALUE']._serialized_start=51 + _globals['_DOUBLEVALUE']._serialized_end=86 + _globals['_FLOATVALUE']._serialized_start=88 + _globals['_FLOATVALUE']._serialized_end=122 + _globals['_INT64VALUE']._serialized_start=124 + _globals['_INT64VALUE']._serialized_end=158 + _globals['_UINT64VALUE']._serialized_start=160 + _globals['_UINT64VALUE']._serialized_end=195 + _globals['_INT32VALUE']._serialized_start=197 + _globals['_INT32VALUE']._serialized_end=231 + _globals['_UINT32VALUE']._serialized_start=233 + _globals['_UINT32VALUE']._serialized_end=268 + _globals['_BOOLVALUE']._serialized_start=270 + _globals['_BOOLVALUE']._serialized_end=303 + _globals['_STRINGVALUE']._serialized_start=305 + _globals['_STRINGVALUE']._serialized_end=340 + _globals['_BYTESVALUE']._serialized_start=342 + _globals['_BYTESVALUE']._serialized_end=376 +# @@protoc_insertion_point(module_scope) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/INSTALLER b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/LICENSE.txt b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..96ece318ed5a5fa072e231c98495d746bacaeef9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/LICENSE.txt @@ -0,0 +1,20 @@ +Copyright (c) 2021 Peter Odding + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/METADATA b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..c36fa4cafe53d55ba15ddc3c4045db067a165282 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/METADATA @@ -0,0 +1,216 @@ +Metadata-Version: 2.1 +Name: humanfriendly +Version: 10.0 +Summary: Human friendly output for text interfaces using Python +Home-page: https://humanfriendly.readthedocs.io +Author: Peter Odding +Author-email: peter@peterodding.com +License: MIT +Platform: UNKNOWN +Classifier: Development Status :: 6 - Mature +Classifier: Environment :: Console +Classifier: Framework :: Sphinx :: Extension +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: System Administrators +Classifier: License :: OSI Approved :: MIT License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Communications +Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Software Development :: User Interfaces +Classifier: Topic :: System :: Shells +Classifier: Topic :: System :: System Shells +Classifier: Topic :: System :: Systems Administration +Classifier: Topic :: Terminals +Classifier: Topic :: Text Processing :: General +Classifier: Topic :: Text Processing :: Linguistic +Classifier: Topic :: Utilities +Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.* +Requires-Dist: monotonic ; python_version == "2.7" +Requires-Dist: pyreadline ; sys_platform == "win32" and python_version<"3.8" +Requires-Dist: pyreadline3 ; sys_platform == "win32" and python_version>="3.8" + +humanfriendly: Human friendly input/output in Python +==================================================== + +.. image:: https://github.com/xolox/python-humanfriendly/actions/workflows/test.yml/badge.svg?branch=master + :target: https://github.com/xolox/python-humanfriendly/actions + +.. image:: https://codecov.io/gh/xolox/python-humanfriendly/branch/master/graph/badge.svg?token=jYaj4T74TU + :target: https://codecov.io/gh/xolox/python-humanfriendly + +The functions and classes in the `humanfriendly` package can be used to make +text interfaces more user friendly. Some example features: + +- Parsing and formatting numbers, file sizes, pathnames and timespans in + simple, human friendly formats. + +- Easy to use timers for long running operations, with human friendly + formatting of the resulting timespans. + +- Prompting the user to select a choice from a list of options by typing the + option's number or a unique substring of the option. + +- Terminal interaction including text styling (`ANSI escape sequences`_), user + friendly rendering of usage messages and querying the terminal for its + size. + +The `humanfriendly` package is currently tested on Python 2.7, 3.5+ and PyPy +(2.7) on Linux and macOS. While the intention is to support Windows as well, +you may encounter some rough edges. + +.. contents:: + :local: + +Getting started +--------------- + +It's very simple to start using the `humanfriendly` package:: + + >>> from humanfriendly import format_size, parse_size + >>> from humanfriendly.prompts import prompt_for_input + >>> user_input = prompt_for_input("Enter a readable file size: ") + + Enter a readable file size: 16G + + >>> num_bytes = parse_size(user_input) + >>> print(num_bytes) + 16000000000 + >>> print("You entered:", format_size(num_bytes)) + You entered: 16 GB + >>> print("You entered:", format_size(num_bytes, binary=True)) + You entered: 14.9 GiB + +To get a demonstration of supported terminal text styles (based on +`ANSI escape sequences`_) you can run the following command:: + + $ humanfriendly --demo + +Command line +------------ + +.. A DRY solution to avoid duplication of the `humanfriendly --help' text: +.. +.. [[[cog +.. from humanfriendly.usage import inject_usage +.. inject_usage('humanfriendly.cli') +.. ]]] + +**Usage:** `humanfriendly [OPTIONS]` + +Human friendly input/output (text formatting) on the command +line based on the Python package with the same name. + +**Supported options:** + +.. csv-table:: + :header: Option, Description + :widths: 30, 70 + + + "``-c``, ``--run-command``","Execute an external command (given as the positional arguments) and render + a spinner and timer while the command is running. The exit status of the + command is propagated." + ``--format-table``,"Read tabular data from standard input (each line is a row and each + whitespace separated field is a column), format the data as a table and + print the resulting table to standard output. See also the ``--delimiter`` + option." + "``-d``, ``--delimiter=VALUE``","Change the delimiter used by ``--format-table`` to ``VALUE`` (a string). By default + all whitespace is treated as a delimiter." + "``-l``, ``--format-length=LENGTH``","Convert a length count (given as the integer or float ``LENGTH``) into a human + readable string and print that string to standard output." + "``-n``, ``--format-number=VALUE``","Format a number (given as the integer or floating point number ``VALUE``) with + thousands separators and two decimal places (if needed) and print the + formatted number to standard output." + "``-s``, ``--format-size=BYTES``","Convert a byte count (given as the integer ``BYTES``) into a human readable + string and print that string to standard output." + "``-b``, ``--binary``","Change the output of ``-s``, ``--format-size`` to use binary multiples of bytes + (base-2) instead of the default decimal multiples of bytes (base-10)." + "``-t``, ``--format-timespan=SECONDS``","Convert a number of seconds (given as the floating point number ``SECONDS``) + into a human readable timespan and print that string to standard output." + ``--parse-length=VALUE``,"Parse a human readable length (given as the string ``VALUE``) and print the + number of metres to standard output." + ``--parse-size=VALUE``,"Parse a human readable data size (given as the string ``VALUE``) and print the + number of bytes to standard output." + ``--demo``,"Demonstrate changing the style and color of the terminal font using ANSI + escape sequences." + "``-h``, ``--help``",Show this message and exit. + +.. [[[end]]] + +A note about size units +----------------------- + +When I originally published the `humanfriendly` package I went with binary +multiples of bytes (powers of two). It was pointed out several times that this +was a poor choice (see issue `#4`_ and pull requests `#8`_ and `#9`_) and thus +the new default became decimal multiples of bytes (powers of ten): + ++------+---------------+---------------+ +| Unit | Binary value | Decimal value | ++------+---------------+---------------+ +| KB | 1024 | 1000 + ++------+---------------+---------------+ +| MB | 1048576 | 1000000 | ++------+---------------+---------------+ +| GB | 1073741824 | 1000000000 | ++------+---------------+---------------+ +| TB | 1099511627776 | 1000000000000 | ++------+---------------+---------------+ +| etc | | | ++------+---------------+---------------+ + +The option to use binary multiples of bytes remains by passing the keyword +argument `binary=True` to the `format_size()`_ and `parse_size()`_ functions. + +Windows support +--------------- + +Windows 10 gained native support for ANSI escape sequences which means commands +like ``humanfriendly --demo`` should work out of the box (if your system is +up-to-date enough). If this doesn't work then you can install the colorama_ +package, it will be used automatically once installed. + +Contact +------- + +The latest version of `humanfriendly` is available on PyPI_ and GitHub_. The +documentation is hosted on `Read the Docs`_ and includes a changelog_. For bug +reports please create an issue on GitHub_. If you have questions, suggestions, +etc. feel free to send me an e-mail at `peter@peterodding.com`_. + +License +------- + +This software is licensed under the `MIT license`_. + +© 2021 Peter Odding. + +.. External references: +.. _#4: https://github.com/xolox/python-humanfriendly/issues/4 +.. _#8: https://github.com/xolox/python-humanfriendly/pull/8 +.. _#9: https://github.com/xolox/python-humanfriendly/pull/9 +.. _ANSI escape sequences: https://en.wikipedia.org/wiki/ANSI_escape_code +.. _changelog: https://humanfriendly.readthedocs.io/en/latest/changelog.html +.. _colorama: https://pypi.org/project/colorama +.. _format_size(): https://humanfriendly.readthedocs.io/en/latest/#humanfriendly.format_size +.. _GitHub: https://github.com/xolox/python-humanfriendly +.. _MIT license: https://en.wikipedia.org/wiki/MIT_License +.. _parse_size(): https://humanfriendly.readthedocs.io/en/latest/#humanfriendly.parse_size +.. _peter@peterodding.com: peter@peterodding.com +.. _PyPI: https://pypi.org/project/humanfriendly +.. _Read the Docs: https://humanfriendly.readthedocs.io + + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/RECORD b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..de480c7c01140d67896eff4c3c11d84eb9deb731 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/RECORD @@ -0,0 +1,41 @@ +../../bin/humanfriendly,sha256=lMhmCZlJe5iioDwC8kMSdJK3GNH-SUKiiiMxnEv9wwg,189 +humanfriendly-10.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +humanfriendly-10.0.dist-info/LICENSE.txt,sha256=SsSPQReAnyc0BmFQRQ8SCzuxEKwdOzIXB5XgVg27wfU,1056 +humanfriendly-10.0.dist-info/METADATA,sha256=aLs0k4jN_spgKsw0Vbg6ey_jy-hAJeJ0k7y-dvOrbII,9201 +humanfriendly-10.0.dist-info/RECORD,, +humanfriendly-10.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +humanfriendly-10.0.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110 +humanfriendly-10.0.dist-info/entry_points.txt,sha256=hU-ADsGls3mgf3plBt9B-oYLCtBDQiUJZ00khuAoqXc,58 +humanfriendly-10.0.dist-info/top_level.txt,sha256=7eKAKhckmlD4ZoWJkWmhnTs1pnP_bzF-56VTq0D7WIo,14 +humanfriendly/__init__.py,sha256=sPCMQv16m3p8xYwd3N3kUs1rewVJB3ZGDBkF0_8v6vo,31725 +humanfriendly/__pycache__/__init__.cpython-311.pyc,, +humanfriendly/__pycache__/case.cpython-311.pyc,, +humanfriendly/__pycache__/cli.cpython-311.pyc,, +humanfriendly/__pycache__/compat.cpython-311.pyc,, +humanfriendly/__pycache__/decorators.cpython-311.pyc,, +humanfriendly/__pycache__/deprecation.cpython-311.pyc,, +humanfriendly/__pycache__/prompts.cpython-311.pyc,, +humanfriendly/__pycache__/sphinx.cpython-311.pyc,, +humanfriendly/__pycache__/tables.cpython-311.pyc,, +humanfriendly/__pycache__/testing.cpython-311.pyc,, +humanfriendly/__pycache__/tests.cpython-311.pyc,, +humanfriendly/__pycache__/text.cpython-311.pyc,, +humanfriendly/__pycache__/usage.cpython-311.pyc,, +humanfriendly/case.py,sha256=fkIinj4V1S8Xl3OCSYSgqKoGzCCbVJOjI5ZznViCT1Q,6008 +humanfriendly/cli.py,sha256=ZpGqTHLwfLjFACsQacYkN9DiBZkGecPzIHysliWN1i8,9822 +humanfriendly/compat.py,sha256=7qoFGMNFizGhs5BIyiMKTDUq29DxzuXGX4MRoZLo4ms,3984 +humanfriendly/decorators.py,sha256=ivxB-U9dfXUjCl4GZ8g_gKFC4a3uyxDVi-3rlxPjvJo,1501 +humanfriendly/deprecation.py,sha256=bdx1_T8L1gF635E41E6bYTqie9P3o7rY6n4wohjkLLk,9499 +humanfriendly/prompts.py,sha256=8PSJ1Hpr3ld6YkCaXQsTHAep9BtTKYlKmQi1RiaHIEc,16335 +humanfriendly/sphinx.py,sha256=BrFxK-rX3LN4iMqgNFuOTweYfppYp--O3HqWBlu05M0,11452 +humanfriendly/tables.py,sha256=lCDnEKyyZRmrIHrDlUzzVpg9z6lKOO8ldP4fh1gzMBI,13968 +humanfriendly/terminal/__init__.py,sha256=5BzxVHKriznclRjrWwYEk2l1ct0q0WdupJIrkuI9glc,30759 +humanfriendly/terminal/__pycache__/__init__.cpython-311.pyc,, +humanfriendly/terminal/__pycache__/html.cpython-311.pyc,, +humanfriendly/terminal/__pycache__/spinners.cpython-311.pyc,, +humanfriendly/terminal/html.py,sha256=_csUZ4hID0ATwTvPXU8KrAe6ZzD_gUS7_tN3FmCHA4Q,16747 +humanfriendly/terminal/spinners.py,sha256=o7nkn8rBdTqr-XHIT972sIgIuxiDymQ5kPVkBzR7utE,11323 +humanfriendly/testing.py,sha256=hErsmBN5Crej5k1P_I0dhQK8IAwFr1IOZ9kQPIrZUys,24359 +humanfriendly/tests.py,sha256=3bkasrRgw0cAdZFHgmTo4DUHgXEnlHtRoq_t2MEafbc,68919 +humanfriendly/text.py,sha256=_WBG4SZ4bT5SH94zLUdfmB6NXbvc4gBYECEmQYXJ1sE,16212 +humanfriendly/usage.py,sha256=AhPo6DcvaBRIFGWNctU22McMzN3Ryc6ZCC83kt2Zbk4,13768 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/REQUESTED b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/WHEEL b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..ef99c6cf3283b50a273ac4c6d009a0aa85597070 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.34.2) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/entry_points.txt b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..2ce8fb835327993d3f6319a10b722b908601de30 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/entry_points.txt @@ -0,0 +1,3 @@ +[console_scripts] +humanfriendly = humanfriendly.cli:main + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/top_level.txt b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..f5368c4974de83a9507c8c10676150fc0f3e2b69 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly-10.0.dist-info/top_level.txt @@ -0,0 +1 @@ +humanfriendly diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4c0a333861df55f5676e6dfd69c5e5ac1ece0213 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/__init__.py @@ -0,0 +1,838 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: September 17, 2021 +# URL: https://humanfriendly.readthedocs.io + +"""The main module of the `humanfriendly` package.""" + +# Standard library modules. +import collections +import datetime +import decimal +import numbers +import os +import os.path +import re +import time + +# Modules included in our package. +from humanfriendly.compat import is_string, monotonic +from humanfriendly.deprecation import define_aliases +from humanfriendly.text import concatenate, format, pluralize, tokenize + +# Public identifiers that require documentation. +__all__ = ( + 'CombinedUnit', + 'InvalidDate', + 'InvalidLength', + 'InvalidSize', + 'InvalidTimespan', + 'SizeUnit', + 'Timer', + '__version__', + 'coerce_boolean', + 'coerce_pattern', + 'coerce_seconds', + 'disk_size_units', + 'format_length', + 'format_number', + 'format_path', + 'format_size', + 'format_timespan', + 'length_size_units', + 'parse_date', + 'parse_length', + 'parse_path', + 'parse_size', + 'parse_timespan', + 'round_number', + 'time_units', +) + +# Semi-standard module versioning. +__version__ = '10.0' + +# Named tuples to define units of size. +SizeUnit = collections.namedtuple('SizeUnit', 'divider, symbol, name') +CombinedUnit = collections.namedtuple('CombinedUnit', 'decimal, binary') + +# Common disk size units in binary (base-2) and decimal (base-10) multiples. +disk_size_units = ( + CombinedUnit(SizeUnit(1000**1, 'KB', 'kilobyte'), SizeUnit(1024**1, 'KiB', 'kibibyte')), + CombinedUnit(SizeUnit(1000**2, 'MB', 'megabyte'), SizeUnit(1024**2, 'MiB', 'mebibyte')), + CombinedUnit(SizeUnit(1000**3, 'GB', 'gigabyte'), SizeUnit(1024**3, 'GiB', 'gibibyte')), + CombinedUnit(SizeUnit(1000**4, 'TB', 'terabyte'), SizeUnit(1024**4, 'TiB', 'tebibyte')), + CombinedUnit(SizeUnit(1000**5, 'PB', 'petabyte'), SizeUnit(1024**5, 'PiB', 'pebibyte')), + CombinedUnit(SizeUnit(1000**6, 'EB', 'exabyte'), SizeUnit(1024**6, 'EiB', 'exbibyte')), + CombinedUnit(SizeUnit(1000**7, 'ZB', 'zettabyte'), SizeUnit(1024**7, 'ZiB', 'zebibyte')), + CombinedUnit(SizeUnit(1000**8, 'YB', 'yottabyte'), SizeUnit(1024**8, 'YiB', 'yobibyte')), +) + +# Common length size units, used for formatting and parsing. +length_size_units = (dict(prefix='nm', divider=1e-09, singular='nm', plural='nm'), + dict(prefix='mm', divider=1e-03, singular='mm', plural='mm'), + dict(prefix='cm', divider=1e-02, singular='cm', plural='cm'), + dict(prefix='m', divider=1, singular='metre', plural='metres'), + dict(prefix='km', divider=1000, singular='km', plural='km')) + +# Common time units, used for formatting of time spans. +time_units = (dict(divider=1e-9, singular='nanosecond', plural='nanoseconds', abbreviations=['ns']), + dict(divider=1e-6, singular='microsecond', plural='microseconds', abbreviations=['us']), + dict(divider=1e-3, singular='millisecond', plural='milliseconds', abbreviations=['ms']), + dict(divider=1, singular='second', plural='seconds', abbreviations=['s', 'sec', 'secs']), + dict(divider=60, singular='minute', plural='minutes', abbreviations=['m', 'min', 'mins']), + dict(divider=60 * 60, singular='hour', plural='hours', abbreviations=['h']), + dict(divider=60 * 60 * 24, singular='day', plural='days', abbreviations=['d']), + dict(divider=60 * 60 * 24 * 7, singular='week', plural='weeks', abbreviations=['w']), + dict(divider=60 * 60 * 24 * 7 * 52, singular='year', plural='years', abbreviations=['y'])) + + +def coerce_boolean(value): + """ + Coerce any value to a boolean. + + :param value: Any Python value. If the value is a string: + + - The strings '1', 'yes', 'true' and 'on' are coerced to :data:`True`. + - The strings '0', 'no', 'false' and 'off' are coerced to :data:`False`. + - Other strings raise an exception. + + Other Python values are coerced using :class:`bool`. + :returns: A proper boolean value. + :raises: :exc:`exceptions.ValueError` when the value is a string but + cannot be coerced with certainty. + """ + if is_string(value): + normalized = value.strip().lower() + if normalized in ('1', 'yes', 'true', 'on'): + return True + elif normalized in ('0', 'no', 'false', 'off', ''): + return False + else: + msg = "Failed to coerce string to boolean! (%r)" + raise ValueError(format(msg, value)) + else: + return bool(value) + + +def coerce_pattern(value, flags=0): + """ + Coerce strings to compiled regular expressions. + + :param value: A string containing a regular expression pattern + or a compiled regular expression. + :param flags: The flags used to compile the pattern (an integer). + :returns: A compiled regular expression. + :raises: :exc:`~exceptions.ValueError` when `value` isn't a string + and also isn't a compiled regular expression. + """ + if is_string(value): + value = re.compile(value, flags) + else: + empty_pattern = re.compile('') + pattern_type = type(empty_pattern) + if not isinstance(value, pattern_type): + msg = "Failed to coerce value to compiled regular expression! (%r)" + raise ValueError(format(msg, value)) + return value + + +def coerce_seconds(value): + """ + Coerce a value to the number of seconds. + + :param value: An :class:`int`, :class:`float` or + :class:`datetime.timedelta` object. + :returns: An :class:`int` or :class:`float` value. + + When `value` is a :class:`datetime.timedelta` object the + :meth:`~datetime.timedelta.total_seconds()` method is called. + """ + if isinstance(value, datetime.timedelta): + return value.total_seconds() + if not isinstance(value, numbers.Number): + msg = "Failed to coerce value to number of seconds! (%r)" + raise ValueError(format(msg, value)) + return value + + +def format_size(num_bytes, keep_width=False, binary=False): + """ + Format a byte count as a human readable file size. + + :param num_bytes: The size to format in bytes (an integer). + :param keep_width: :data:`True` if trailing zeros should not be stripped, + :data:`False` if they can be stripped. + :param binary: :data:`True` to use binary multiples of bytes (base-2), + :data:`False` to use decimal multiples of bytes (base-10). + :returns: The corresponding human readable file size (a string). + + This function knows how to format sizes in bytes, kilobytes, megabytes, + gigabytes, terabytes and petabytes. Some examples: + + >>> from humanfriendly import format_size + >>> format_size(0) + '0 bytes' + >>> format_size(1) + '1 byte' + >>> format_size(5) + '5 bytes' + > format_size(1000) + '1 KB' + > format_size(1024, binary=True) + '1 KiB' + >>> format_size(1000 ** 3 * 4) + '4 GB' + """ + for unit in reversed(disk_size_units): + if num_bytes >= unit.binary.divider and binary: + number = round_number(float(num_bytes) / unit.binary.divider, keep_width=keep_width) + return pluralize(number, unit.binary.symbol, unit.binary.symbol) + elif num_bytes >= unit.decimal.divider and not binary: + number = round_number(float(num_bytes) / unit.decimal.divider, keep_width=keep_width) + return pluralize(number, unit.decimal.symbol, unit.decimal.symbol) + return pluralize(num_bytes, 'byte') + + +def parse_size(size, binary=False): + """ + Parse a human readable data size and return the number of bytes. + + :param size: The human readable file size to parse (a string). + :param binary: :data:`True` to use binary multiples of bytes (base-2) for + ambiguous unit symbols and names, :data:`False` to use + decimal multiples of bytes (base-10). + :returns: The corresponding size in bytes (an integer). + :raises: :exc:`InvalidSize` when the input can't be parsed. + + This function knows how to parse sizes in bytes, kilobytes, megabytes, + gigabytes, terabytes and petabytes. Some examples: + + >>> from humanfriendly import parse_size + >>> parse_size('42') + 42 + >>> parse_size('13b') + 13 + >>> parse_size('5 bytes') + 5 + >>> parse_size('1 KB') + 1000 + >>> parse_size('1 kilobyte') + 1000 + >>> parse_size('1 KiB') + 1024 + >>> parse_size('1 KB', binary=True) + 1024 + >>> parse_size('1.5 GB') + 1500000000 + >>> parse_size('1.5 GB', binary=True) + 1610612736 + """ + tokens = tokenize(size) + if tokens and isinstance(tokens[0], numbers.Number): + # Get the normalized unit (if any) from the tokenized input. + normalized_unit = tokens[1].lower() if len(tokens) == 2 and is_string(tokens[1]) else '' + # If the input contains only a number, it's assumed to be the number of + # bytes. The second token can also explicitly reference the unit bytes. + if len(tokens) == 1 or normalized_unit.startswith('b'): + return int(tokens[0]) + # Otherwise we expect two tokens: A number and a unit. + if normalized_unit: + # Convert plural units to singular units, for details: + # https://github.com/xolox/python-humanfriendly/issues/26 + normalized_unit = normalized_unit.rstrip('s') + for unit in disk_size_units: + # First we check for unambiguous symbols (KiB, MiB, GiB, etc) + # and names (kibibyte, mebibyte, gibibyte, etc) because their + # handling is always the same. + if normalized_unit in (unit.binary.symbol.lower(), unit.binary.name.lower()): + return int(tokens[0] * unit.binary.divider) + # Now we will deal with ambiguous prefixes (K, M, G, etc), + # symbols (KB, MB, GB, etc) and names (kilobyte, megabyte, + # gigabyte, etc) according to the caller's preference. + if (normalized_unit in (unit.decimal.symbol.lower(), unit.decimal.name.lower()) or + normalized_unit.startswith(unit.decimal.symbol[0].lower())): + return int(tokens[0] * (unit.binary.divider if binary else unit.decimal.divider)) + # We failed to parse the size specification. + msg = "Failed to parse size! (input %r was tokenized as %r)" + raise InvalidSize(format(msg, size, tokens)) + + +def format_length(num_metres, keep_width=False): + """ + Format a metre count as a human readable length. + + :param num_metres: The length to format in metres (float / integer). + :param keep_width: :data:`True` if trailing zeros should not be stripped, + :data:`False` if they can be stripped. + :returns: The corresponding human readable length (a string). + + This function supports ranges from nanometres to kilometres. + + Some examples: + + >>> from humanfriendly import format_length + >>> format_length(0) + '0 metres' + >>> format_length(1) + '1 metre' + >>> format_length(5) + '5 metres' + >>> format_length(1000) + '1 km' + >>> format_length(0.004) + '4 mm' + """ + for unit in reversed(length_size_units): + if num_metres >= unit['divider']: + number = round_number(float(num_metres) / unit['divider'], keep_width=keep_width) + return pluralize(number, unit['singular'], unit['plural']) + return pluralize(num_metres, 'metre') + + +def parse_length(length): + """ + Parse a human readable length and return the number of metres. + + :param length: The human readable length to parse (a string). + :returns: The corresponding length in metres (a float). + :raises: :exc:`InvalidLength` when the input can't be parsed. + + Some examples: + + >>> from humanfriendly import parse_length + >>> parse_length('42') + 42 + >>> parse_length('1 km') + 1000 + >>> parse_length('5mm') + 0.005 + >>> parse_length('15.3cm') + 0.153 + """ + tokens = tokenize(length) + if tokens and isinstance(tokens[0], numbers.Number): + # If the input contains only a number, it's assumed to be the number of metres. + if len(tokens) == 1: + return tokens[0] + # Otherwise we expect to find two tokens: A number and a unit. + if len(tokens) == 2 and is_string(tokens[1]): + normalized_unit = tokens[1].lower() + # Try to match the first letter of the unit. + for unit in length_size_units: + if normalized_unit.startswith(unit['prefix']): + return tokens[0] * unit['divider'] + # We failed to parse the length specification. + msg = "Failed to parse length! (input %r was tokenized as %r)" + raise InvalidLength(format(msg, length, tokens)) + + +def format_number(number, num_decimals=2): + """ + Format a number as a string including thousands separators. + + :param number: The number to format (a number like an :class:`int`, + :class:`long` or :class:`float`). + :param num_decimals: The number of decimals to render (2 by default). If no + decimal places are required to represent the number + they will be omitted regardless of this argument. + :returns: The formatted number (a string). + + This function is intended to make it easier to recognize the order of size + of the number being formatted. + + Here's an example: + + >>> from humanfriendly import format_number + >>> print(format_number(6000000)) + 6,000,000 + > print(format_number(6000000000.42)) + 6,000,000,000.42 + > print(format_number(6000000000.42, num_decimals=0)) + 6,000,000,000 + """ + integer_part, _, decimal_part = str(float(number)).partition('.') + negative_sign = integer_part.startswith('-') + reversed_digits = ''.join(reversed(integer_part.lstrip('-'))) + parts = [] + while reversed_digits: + parts.append(reversed_digits[:3]) + reversed_digits = reversed_digits[3:] + formatted_number = ''.join(reversed(','.join(parts))) + decimals_to_add = decimal_part[:num_decimals].rstrip('0') + if decimals_to_add: + formatted_number += '.' + decimals_to_add + if negative_sign: + formatted_number = '-' + formatted_number + return formatted_number + + +def round_number(count, keep_width=False): + """ + Round a floating point number to two decimal places in a human friendly format. + + :param count: The number to format. + :param keep_width: :data:`True` if trailing zeros should not be stripped, + :data:`False` if they can be stripped. + :returns: The formatted number as a string. If no decimal places are + required to represent the number, they will be omitted. + + The main purpose of this function is to be used by functions like + :func:`format_length()`, :func:`format_size()` and + :func:`format_timespan()`. + + Here are some examples: + + >>> from humanfriendly import round_number + >>> round_number(1) + '1' + >>> round_number(math.pi) + '3.14' + >>> round_number(5.001) + '5' + """ + text = '%.2f' % float(count) + if not keep_width: + text = re.sub('0+$', '', text) + text = re.sub(r'\.$', '', text) + return text + + +def format_timespan(num_seconds, detailed=False, max_units=3): + """ + Format a timespan in seconds as a human readable string. + + :param num_seconds: Any value accepted by :func:`coerce_seconds()`. + :param detailed: If :data:`True` milliseconds are represented separately + instead of being represented as fractional seconds + (defaults to :data:`False`). + :param max_units: The maximum number of units to show in the formatted time + span (an integer, defaults to three). + :returns: The formatted timespan as a string. + :raise: See :func:`coerce_seconds()`. + + Some examples: + + >>> from humanfriendly import format_timespan + >>> format_timespan(0) + '0 seconds' + >>> format_timespan(1) + '1 second' + >>> import math + >>> format_timespan(math.pi) + '3.14 seconds' + >>> hour = 60 * 60 + >>> day = hour * 24 + >>> week = day * 7 + >>> format_timespan(week * 52 + day * 2 + hour * 3) + '1 year, 2 days and 3 hours' + """ + num_seconds = coerce_seconds(num_seconds) + if num_seconds < 60 and not detailed: + # Fast path. + return pluralize(round_number(num_seconds), 'second') + else: + # Slow path. + result = [] + num_seconds = decimal.Decimal(str(num_seconds)) + relevant_units = list(reversed(time_units[0 if detailed else 3:])) + for unit in relevant_units: + # Extract the unit count from the remaining time. + divider = decimal.Decimal(str(unit['divider'])) + count = num_seconds / divider + num_seconds %= divider + # Round the unit count appropriately. + if unit != relevant_units[-1]: + # Integer rounding for all but the smallest unit. + count = int(count) + else: + # Floating point rounding for the smallest unit. + count = round_number(count) + # Only include relevant units in the result. + if count not in (0, '0'): + result.append(pluralize(count, unit['singular'], unit['plural'])) + if len(result) == 1: + # A single count/unit combination. + return result[0] + else: + if not detailed: + # Remove `insignificant' data from the formatted timespan. + result = result[:max_units] + # Format the timespan in a readable way. + return concatenate(result) + + +def parse_timespan(timespan): + """ + Parse a "human friendly" timespan into the number of seconds. + + :param value: A string like ``5h`` (5 hours), ``10m`` (10 minutes) or + ``42s`` (42 seconds). + :returns: The number of seconds as a floating point number. + :raises: :exc:`InvalidTimespan` when the input can't be parsed. + + Note that the :func:`parse_timespan()` function is not meant to be the + "mirror image" of the :func:`format_timespan()` function. Instead it's + meant to allow humans to easily and succinctly specify a timespan with a + minimal amount of typing. It's very useful to accept easy to write time + spans as e.g. command line arguments to programs. + + The time units (and abbreviations) supported by this function are: + + - ms, millisecond, milliseconds + - s, sec, secs, second, seconds + - m, min, mins, minute, minutes + - h, hour, hours + - d, day, days + - w, week, weeks + - y, year, years + + Some examples: + + >>> from humanfriendly import parse_timespan + >>> parse_timespan('42') + 42.0 + >>> parse_timespan('42s') + 42.0 + >>> parse_timespan('1m') + 60.0 + >>> parse_timespan('1h') + 3600.0 + >>> parse_timespan('1d') + 86400.0 + """ + tokens = tokenize(timespan) + if tokens and isinstance(tokens[0], numbers.Number): + # If the input contains only a number, it's assumed to be the number of seconds. + if len(tokens) == 1: + return float(tokens[0]) + # Otherwise we expect to find two tokens: A number and a unit. + if len(tokens) == 2 and is_string(tokens[1]): + normalized_unit = tokens[1].lower() + for unit in time_units: + if (normalized_unit == unit['singular'] or + normalized_unit == unit['plural'] or + normalized_unit in unit['abbreviations']): + return float(tokens[0]) * unit['divider'] + # We failed to parse the timespan specification. + msg = "Failed to parse timespan! (input %r was tokenized as %r)" + raise InvalidTimespan(format(msg, timespan, tokens)) + + +def parse_date(datestring): + """ + Parse a date/time string into a tuple of integers. + + :param datestring: The date/time string to parse. + :returns: A tuple with the numbers ``(year, month, day, hour, minute, + second)`` (all numbers are integers). + :raises: :exc:`InvalidDate` when the date cannot be parsed. + + Supported date/time formats: + + - ``YYYY-MM-DD`` + - ``YYYY-MM-DD HH:MM:SS`` + + .. note:: If you want to parse date/time strings with a fixed, known + format and :func:`parse_date()` isn't useful to you, consider + :func:`time.strptime()` or :meth:`datetime.datetime.strptime()`, + both of which are included in the Python standard library. + Alternatively for more complex tasks consider using the date/time + parsing module in the dateutil_ package. + + Examples: + + >>> from humanfriendly import parse_date + >>> parse_date('2013-06-17') + (2013, 6, 17, 0, 0, 0) + >>> parse_date('2013-06-17 02:47:42') + (2013, 6, 17, 2, 47, 42) + + Here's how you convert the result to a number (`Unix time`_): + + >>> from humanfriendly import parse_date + >>> from time import mktime + >>> mktime(parse_date('2013-06-17 02:47:42') + (-1, -1, -1)) + 1371430062.0 + + And here's how you convert it to a :class:`datetime.datetime` object: + + >>> from humanfriendly import parse_date + >>> from datetime import datetime + >>> datetime(*parse_date('2013-06-17 02:47:42')) + datetime.datetime(2013, 6, 17, 2, 47, 42) + + Here's an example that combines :func:`format_timespan()` and + :func:`parse_date()` to calculate a human friendly timespan since a + given date: + + >>> from humanfriendly import format_timespan, parse_date + >>> from time import mktime, time + >>> unix_time = mktime(parse_date('2013-06-17 02:47:42') + (-1, -1, -1)) + >>> seconds_since_then = time() - unix_time + >>> print(format_timespan(seconds_since_then)) + 1 year, 43 weeks and 1 day + + .. _dateutil: https://dateutil.readthedocs.io/en/latest/parser.html + .. _Unix time: http://en.wikipedia.org/wiki/Unix_time + """ + try: + tokens = [t.strip() for t in datestring.split()] + if len(tokens) >= 2: + date_parts = list(map(int, tokens[0].split('-'))) + [1, 1] + time_parts = list(map(int, tokens[1].split(':'))) + [0, 0, 0] + return tuple(date_parts[0:3] + time_parts[0:3]) + else: + year, month, day = (list(map(int, datestring.split('-'))) + [1, 1])[0:3] + return (year, month, day, 0, 0, 0) + except Exception: + msg = "Invalid date! (expected 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM:SS' but got: %r)" + raise InvalidDate(format(msg, datestring)) + + +def format_path(pathname): + """ + Shorten a pathname to make it more human friendly. + + :param pathname: An absolute pathname (a string). + :returns: The pathname with the user's home directory abbreviated. + + Given an absolute pathname, this function abbreviates the user's home + directory to ``~/`` in order to shorten the pathname without losing + information. It is not an error if the pathname is not relative to the + current user's home directory. + + Here's an example of its usage: + + >>> from os import environ + >>> from os.path import join + >>> vimrc = join(environ['HOME'], '.vimrc') + >>> vimrc + '/home/peter/.vimrc' + >>> from humanfriendly import format_path + >>> format_path(vimrc) + '~/.vimrc' + """ + pathname = os.path.abspath(pathname) + home = os.environ.get('HOME') + if home: + home = os.path.abspath(home) + if pathname.startswith(home): + pathname = os.path.join('~', os.path.relpath(pathname, home)) + return pathname + + +def parse_path(pathname): + """ + Convert a human friendly pathname to an absolute pathname. + + Expands leading tildes using :func:`os.path.expanduser()` and + environment variables using :func:`os.path.expandvars()` and makes the + resulting pathname absolute using :func:`os.path.abspath()`. + + :param pathname: A human friendly pathname (a string). + :returns: An absolute pathname (a string). + """ + return os.path.abspath(os.path.expanduser(os.path.expandvars(pathname))) + + +class Timer(object): + + """ + Easy to use timer to keep track of long during operations. + """ + + def __init__(self, start_time=None, resumable=False): + """ + Remember the time when the :class:`Timer` was created. + + :param start_time: The start time (a float, defaults to the current time). + :param resumable: Create a resumable timer (defaults to :data:`False`). + + When `start_time` is given :class:`Timer` uses :func:`time.time()` as a + clock source, otherwise it uses :func:`humanfriendly.compat.monotonic()`. + """ + if resumable: + self.monotonic = True + self.resumable = True + self.start_time = 0.0 + self.total_time = 0.0 + elif start_time: + self.monotonic = False + self.resumable = False + self.start_time = start_time + else: + self.monotonic = True + self.resumable = False + self.start_time = monotonic() + + def __enter__(self): + """ + Start or resume counting elapsed time. + + :returns: The :class:`Timer` object. + :raises: :exc:`~exceptions.ValueError` when the timer isn't resumable. + """ + if not self.resumable: + raise ValueError("Timer is not resumable!") + self.start_time = monotonic() + return self + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """ + Stop counting elapsed time. + + :raises: :exc:`~exceptions.ValueError` when the timer isn't resumable. + """ + if not self.resumable: + raise ValueError("Timer is not resumable!") + if self.start_time: + self.total_time += monotonic() - self.start_time + self.start_time = 0.0 + + def sleep(self, seconds): + """ + Easy to use rate limiting of repeating actions. + + :param seconds: The number of seconds to sleep (an + integer or floating point number). + + This method sleeps for the given number of seconds minus the + :attr:`elapsed_time`. If the resulting duration is negative + :func:`time.sleep()` will still be called, but the argument + given to it will be the number 0 (negative numbers cause + :func:`time.sleep()` to raise an exception). + + The use case for this is to initialize a :class:`Timer` inside + the body of a :keyword:`for` or :keyword:`while` loop and call + :func:`Timer.sleep()` at the end of the loop body to rate limit + whatever it is that is being done inside the loop body. + + For posterity: Although the implementation of :func:`sleep()` only + requires a single line of code I've added it to :mod:`humanfriendly` + anyway because now that I've thought about how to tackle this once I + never want to have to think about it again :-P (unless I find ways to + improve this). + """ + time.sleep(max(0, seconds - self.elapsed_time)) + + @property + def elapsed_time(self): + """ + Get the number of seconds counted so far. + """ + elapsed_time = 0 + if self.resumable: + elapsed_time += self.total_time + if self.start_time: + current_time = monotonic() if self.monotonic else time.time() + elapsed_time += current_time - self.start_time + return elapsed_time + + @property + def rounded(self): + """Human readable timespan rounded to seconds (a string).""" + return format_timespan(round(self.elapsed_time)) + + def __str__(self): + """Show the elapsed time since the :class:`Timer` was created.""" + return format_timespan(self.elapsed_time) + + +class InvalidDate(Exception): + + """ + Raised when a string cannot be parsed into a date. + + For example: + + >>> from humanfriendly import parse_date + >>> parse_date('2013-06-XY') + Traceback (most recent call last): + File "humanfriendly.py", line 206, in parse_date + raise InvalidDate(format(msg, datestring)) + humanfriendly.InvalidDate: Invalid date! (expected 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM:SS' but got: '2013-06-XY') + """ + + +class InvalidSize(Exception): + + """ + Raised when a string cannot be parsed into a file size. + + For example: + + >>> from humanfriendly import parse_size + >>> parse_size('5 Z') + Traceback (most recent call last): + File "humanfriendly/__init__.py", line 267, in parse_size + raise InvalidSize(format(msg, size, tokens)) + humanfriendly.InvalidSize: Failed to parse size! (input '5 Z' was tokenized as [5, 'Z']) + """ + + +class InvalidLength(Exception): + + """ + Raised when a string cannot be parsed into a length. + + For example: + + >>> from humanfriendly import parse_length + >>> parse_length('5 Z') + Traceback (most recent call last): + File "humanfriendly/__init__.py", line 267, in parse_length + raise InvalidLength(format(msg, length, tokens)) + humanfriendly.InvalidLength: Failed to parse length! (input '5 Z' was tokenized as [5, 'Z']) + """ + + +class InvalidTimespan(Exception): + + """ + Raised when a string cannot be parsed into a timespan. + + For example: + + >>> from humanfriendly import parse_timespan + >>> parse_timespan('1 age') + Traceback (most recent call last): + File "humanfriendly/__init__.py", line 419, in parse_timespan + raise InvalidTimespan(format(msg, timespan, tokens)) + humanfriendly.InvalidTimespan: Failed to parse timespan! (input '1 age' was tokenized as [1, 'age']) + """ + + +# Define aliases for backwards compatibility. +define_aliases( + module_name=__name__, + # In humanfriendly 1.23 the format_table() function was added to render a + # table using characters like dashes and vertical bars to emulate borders. + # Since then support for other tables has been added and the name of + # format_table() has changed. + format_table='humanfriendly.tables.format_pretty_table', + # In humanfriendly 1.30 the following text manipulation functions were + # moved out into a separate module to enable their usage in other modules + # of the humanfriendly package (without causing circular imports). + compact='humanfriendly.text.compact', + concatenate='humanfriendly.text.concatenate', + dedent='humanfriendly.text.dedent', + format='humanfriendly.text.format', + is_empty_line='humanfriendly.text.is_empty_line', + pluralize='humanfriendly.text.pluralize', + tokenize='humanfriendly.text.tokenize', + trim_empty_lines='humanfriendly.text.trim_empty_lines', + # In humanfriendly 1.38 the prompt_for_choice() function was moved out into a + # separate module because several variants of interactive prompts were added. + prompt_for_choice='humanfriendly.prompts.prompt_for_choice', + # In humanfriendly 8.0 the Spinner class and minimum_spinner_interval + # variable were extracted to a new module and the erase_line_code, + # hide_cursor_code and show_cursor_code variables were moved. + AutomaticSpinner='humanfriendly.terminal.spinners.AutomaticSpinner', + Spinner='humanfriendly.terminal.spinners.Spinner', + erase_line_code='humanfriendly.terminal.ANSI_ERASE_LINE', + hide_cursor_code='humanfriendly.terminal.ANSI_SHOW_CURSOR', + minimum_spinner_interval='humanfriendly.terminal.spinners.MINIMUM_INTERVAL', + show_cursor_code='humanfriendly.terminal.ANSI_HIDE_CURSOR', +) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/case.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/case.py new file mode 100644 index 0000000000000000000000000000000000000000..4c71857e40c4d1f517c0069b0b83ababcdfc0ae8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/case.py @@ -0,0 +1,157 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: April 19, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Simple case insensitive dictionaries. + +The :class:`CaseInsensitiveDict` class is a dictionary whose string keys +are case insensitive. It works by automatically coercing string keys to +:class:`CaseInsensitiveKey` objects. Keys that are not strings are +supported as well, just without case insensitivity. + +At its core this module works by normalizing strings to lowercase before +comparing or hashing them. It doesn't support proper case folding nor +does it support Unicode normalization, hence the word "simple". +""" + +# Standard library modules. +import collections + +try: + # Python >= 3.3. + from collections.abc import Iterable, Mapping +except ImportError: + # Python 2.7. + from collections import Iterable, Mapping + +# Modules included in our package. +from humanfriendly.compat import basestring, unicode + +# Public identifiers that require documentation. +__all__ = ("CaseInsensitiveDict", "CaseInsensitiveKey") + + +class CaseInsensitiveDict(collections.OrderedDict): + + """ + Simple case insensitive dictionary implementation (that remembers insertion order). + + This class works by overriding methods that deal with dictionary keys to + coerce string keys to :class:`CaseInsensitiveKey` objects before calling + down to the regular dictionary handling methods. While intended to be + complete this class has not been extensively tested yet. + """ + + def __init__(self, other=None, **kw): + """Initialize a :class:`CaseInsensitiveDict` object.""" + # Initialize our superclass. + super(CaseInsensitiveDict, self).__init__() + # Handle the initializer arguments. + self.update(other, **kw) + + def coerce_key(self, key): + """ + Coerce string keys to :class:`CaseInsensitiveKey` objects. + + :param key: The value to coerce (any type). + :returns: If `key` is a string then a :class:`CaseInsensitiveKey` + object is returned, otherwise the value of `key` is + returned unmodified. + """ + if isinstance(key, basestring): + key = CaseInsensitiveKey(key) + return key + + @classmethod + def fromkeys(cls, iterable, value=None): + """Create a case insensitive dictionary with keys from `iterable` and values set to `value`.""" + return cls((k, value) for k in iterable) + + def get(self, key, default=None): + """Get the value of an existing item.""" + return super(CaseInsensitiveDict, self).get(self.coerce_key(key), default) + + def pop(self, key, default=None): + """Remove an item from a case insensitive dictionary.""" + return super(CaseInsensitiveDict, self).pop(self.coerce_key(key), default) + + def setdefault(self, key, default=None): + """Get the value of an existing item or add a new item.""" + return super(CaseInsensitiveDict, self).setdefault(self.coerce_key(key), default) + + def update(self, other=None, **kw): + """Update a case insensitive dictionary with new items.""" + if isinstance(other, Mapping): + # Copy the items from the given mapping. + for key, value in other.items(): + self[key] = value + elif isinstance(other, Iterable): + # Copy the items from the given iterable. + for key, value in other: + self[key] = value + elif other is not None: + # Complain about unsupported values. + msg = "'%s' object is not iterable" + type_name = type(value).__name__ + raise TypeError(msg % type_name) + # Copy the keyword arguments (if any). + for key, value in kw.items(): + self[key] = value + + def __contains__(self, key): + """Check if a case insensitive dictionary contains the given key.""" + return super(CaseInsensitiveDict, self).__contains__(self.coerce_key(key)) + + def __delitem__(self, key): + """Delete an item in a case insensitive dictionary.""" + return super(CaseInsensitiveDict, self).__delitem__(self.coerce_key(key)) + + def __getitem__(self, key): + """Get the value of an item in a case insensitive dictionary.""" + return super(CaseInsensitiveDict, self).__getitem__(self.coerce_key(key)) + + def __setitem__(self, key, value): + """Set the value of an item in a case insensitive dictionary.""" + return super(CaseInsensitiveDict, self).__setitem__(self.coerce_key(key), value) + + +class CaseInsensitiveKey(unicode): + + """ + Simple case insensitive dictionary key implementation. + + The :class:`CaseInsensitiveKey` class provides an intentionally simple + implementation of case insensitive strings to be used as dictionary keys. + + If you need features like Unicode normalization or proper case folding + please consider using a more advanced implementation like the :pypi:`istr` + package instead. + """ + + def __new__(cls, value): + """Create a :class:`CaseInsensitiveKey` object.""" + # Delegate string object creation to our superclass. + obj = unicode.__new__(cls, value) + # Store the lowercased string and its hash value. + normalized = obj.lower() + obj._normalized = normalized + obj._hash_value = hash(normalized) + return obj + + def __hash__(self): + """Get the hash value of the lowercased string.""" + return self._hash_value + + def __eq__(self, other): + """Compare two strings as lowercase.""" + if isinstance(other, CaseInsensitiveKey): + # Fast path (and the most common case): Comparison with same type. + return self._normalized == other._normalized + elif isinstance(other, unicode): + # Slow path: Comparison with strings that need lowercasing. + return self._normalized == other.lower() + else: + return NotImplemented diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/cli.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..eb81db172bcdc45fb0d0cea32a63df07a3abde4a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/cli.py @@ -0,0 +1,291 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: March 1, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Usage: humanfriendly [OPTIONS] + +Human friendly input/output (text formatting) on the command +line based on the Python package with the same name. + +Supported options: + + -c, --run-command + + Execute an external command (given as the positional arguments) and render + a spinner and timer while the command is running. The exit status of the + command is propagated. + + --format-table + + Read tabular data from standard input (each line is a row and each + whitespace separated field is a column), format the data as a table and + print the resulting table to standard output. See also the --delimiter + option. + + -d, --delimiter=VALUE + + Change the delimiter used by --format-table to VALUE (a string). By default + all whitespace is treated as a delimiter. + + -l, --format-length=LENGTH + + Convert a length count (given as the integer or float LENGTH) into a human + readable string and print that string to standard output. + + -n, --format-number=VALUE + + Format a number (given as the integer or floating point number VALUE) with + thousands separators and two decimal places (if needed) and print the + formatted number to standard output. + + -s, --format-size=BYTES + + Convert a byte count (given as the integer BYTES) into a human readable + string and print that string to standard output. + + -b, --binary + + Change the output of -s, --format-size to use binary multiples of bytes + (base-2) instead of the default decimal multiples of bytes (base-10). + + -t, --format-timespan=SECONDS + + Convert a number of seconds (given as the floating point number SECONDS) + into a human readable timespan and print that string to standard output. + + --parse-length=VALUE + + Parse a human readable length (given as the string VALUE) and print the + number of metres to standard output. + + --parse-size=VALUE + + Parse a human readable data size (given as the string VALUE) and print the + number of bytes to standard output. + + --demo + + Demonstrate changing the style and color of the terminal font using ANSI + escape sequences. + + -h, --help + + Show this message and exit. +""" + +# Standard library modules. +import functools +import getopt +import pipes +import subprocess +import sys + +# Modules included in our package. +from humanfriendly import ( + Timer, + format_length, + format_number, + format_size, + format_timespan, + parse_length, + parse_size, +) +from humanfriendly.tables import format_pretty_table, format_smart_table +from humanfriendly.terminal import ( + ANSI_COLOR_CODES, + ANSI_TEXT_STYLES, + HIGHLIGHT_COLOR, + ansi_strip, + ansi_wrap, + enable_ansi_support, + find_terminal_size, + output, + usage, + warning, +) +from humanfriendly.terminal.spinners import Spinner + +# Public identifiers that require documentation. +__all__ = ( + 'demonstrate_256_colors', + 'demonstrate_ansi_formatting', + 'main', + 'print_formatted_length', + 'print_formatted_number', + 'print_formatted_size', + 'print_formatted_table', + 'print_formatted_timespan', + 'print_parsed_length', + 'print_parsed_size', + 'run_command', +) + + +def main(): + """Command line interface for the ``humanfriendly`` program.""" + enable_ansi_support() + try: + options, arguments = getopt.getopt(sys.argv[1:], 'cd:l:n:s:bt:h', [ + 'run-command', 'format-table', 'delimiter=', 'format-length=', + 'format-number=', 'format-size=', 'binary', 'format-timespan=', + 'parse-length=', 'parse-size=', 'demo', 'help', + ]) + except Exception as e: + warning("Error: %s", e) + sys.exit(1) + actions = [] + delimiter = None + should_format_table = False + binary = any(o in ('-b', '--binary') for o, v in options) + for option, value in options: + if option in ('-d', '--delimiter'): + delimiter = value + elif option == '--parse-size': + actions.append(functools.partial(print_parsed_size, value)) + elif option == '--parse-length': + actions.append(functools.partial(print_parsed_length, value)) + elif option in ('-c', '--run-command'): + actions.append(functools.partial(run_command, arguments)) + elif option in ('-l', '--format-length'): + actions.append(functools.partial(print_formatted_length, value)) + elif option in ('-n', '--format-number'): + actions.append(functools.partial(print_formatted_number, value)) + elif option in ('-s', '--format-size'): + actions.append(functools.partial(print_formatted_size, value, binary)) + elif option == '--format-table': + should_format_table = True + elif option in ('-t', '--format-timespan'): + actions.append(functools.partial(print_formatted_timespan, value)) + elif option == '--demo': + actions.append(demonstrate_ansi_formatting) + elif option in ('-h', '--help'): + usage(__doc__) + return + if should_format_table: + actions.append(functools.partial(print_formatted_table, delimiter)) + if not actions: + usage(__doc__) + return + for partial in actions: + partial() + + +def run_command(command_line): + """Run an external command and show a spinner while the command is running.""" + timer = Timer() + spinner_label = "Waiting for command: %s" % " ".join(map(pipes.quote, command_line)) + with Spinner(label=spinner_label, timer=timer) as spinner: + process = subprocess.Popen(command_line) + while True: + spinner.step() + spinner.sleep() + if process.poll() is not None: + break + sys.exit(process.returncode) + + +def print_formatted_length(value): + """Print a human readable length.""" + if '.' in value: + output(format_length(float(value))) + else: + output(format_length(int(value))) + + +def print_formatted_number(value): + """Print large numbers in a human readable format.""" + output(format_number(float(value))) + + +def print_formatted_size(value, binary): + """Print a human readable size.""" + output(format_size(int(value), binary=binary)) + + +def print_formatted_table(delimiter): + """Read tabular data from standard input and print a table.""" + data = [] + for line in sys.stdin: + line = line.rstrip() + data.append(line.split(delimiter)) + output(format_pretty_table(data)) + + +def print_formatted_timespan(value): + """Print a human readable timespan.""" + output(format_timespan(float(value))) + + +def print_parsed_length(value): + """Parse a human readable length and print the number of metres.""" + output(parse_length(value)) + + +def print_parsed_size(value): + """Parse a human readable data size and print the number of bytes.""" + output(parse_size(value)) + + +def demonstrate_ansi_formatting(): + """Demonstrate the use of ANSI escape sequences.""" + # First we demonstrate the supported text styles. + output('%s', ansi_wrap('Text styles:', bold=True)) + styles = ['normal', 'bright'] + styles.extend(ANSI_TEXT_STYLES.keys()) + for style_name in sorted(styles): + options = dict(color=HIGHLIGHT_COLOR) + if style_name != 'normal': + options[style_name] = True + style_label = style_name.replace('_', ' ').capitalize() + output(' - %s', ansi_wrap(style_label, **options)) + # Now we demonstrate named foreground and background colors. + for color_type, color_label in (('color', 'Foreground colors'), + ('background', 'Background colors')): + intensities = [ + ('normal', dict()), + ('bright', dict(bright=True)), + ] + if color_type != 'background': + intensities.insert(0, ('faint', dict(faint=True))) + output('\n%s' % ansi_wrap('%s:' % color_label, bold=True)) + output(format_smart_table([ + [color_name] + [ + ansi_wrap( + 'XXXXXX' if color_type != 'background' else (' ' * 6), + **dict(list(kw.items()) + [(color_type, color_name)]) + ) for label, kw in intensities + ] for color_name in sorted(ANSI_COLOR_CODES.keys()) + ], column_names=['Color'] + [ + label.capitalize() for label, kw in intensities + ])) + # Demonstrate support for 256 colors as well. + demonstrate_256_colors(0, 7, 'standard colors') + demonstrate_256_colors(8, 15, 'high-intensity colors') + demonstrate_256_colors(16, 231, '216 colors') + demonstrate_256_colors(232, 255, 'gray scale colors') + + +def demonstrate_256_colors(i, j, group=None): + """Demonstrate 256 color mode support.""" + # Generate the label. + label = '256 color mode' + if group: + label += ' (%s)' % group + output('\n' + ansi_wrap('%s:' % label, bold=True)) + # Generate a simple rendering of the colors in the requested range and + # check if it will fit on a single line (given the terminal's width). + single_line = ''.join(' ' + ansi_wrap(str(n), color=n) for n in range(i, j + 1)) + lines, columns = find_terminal_size() + if columns >= len(ansi_strip(single_line)): + output(single_line) + else: + # Generate a more complex rendering of the colors that will nicely wrap + # over multiple lines without using too many lines. + width = len(str(j)) + 1 + colors_per_line = int(columns / width) + colors = [ansi_wrap(str(n).rjust(width), color=n) for n in range(i, j + 1)] + blocks = [colors[n:n + colors_per_line] for n in range(0, len(colors), colors_per_line)] + output('\n'.join(''.join(b) for b in blocks)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/compat.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/compat.py new file mode 100644 index 0000000000000000000000000000000000000000..24c9d1833adbcc8a0f7ad736b63e37e8e88ec9d4 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/compat.py @@ -0,0 +1,146 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: September 17, 2021 +# URL: https://humanfriendly.readthedocs.io + +""" +Compatibility with Python 2 and 3. + +This module exposes aliases and functions that make it easier to write Python +code that is compatible with Python 2 and Python 3. + +.. data:: basestring + + Alias for :func:`python2:basestring` (in Python 2) or :class:`python3:str` + (in Python 3). See also :func:`is_string()`. + +.. data:: HTMLParser + + Alias for :class:`python2:HTMLParser.HTMLParser` (in Python 2) or + :class:`python3:html.parser.HTMLParser` (in Python 3). + +.. data:: interactive_prompt + + Alias for :func:`python2:raw_input()` (in Python 2) or + :func:`python3:input()` (in Python 3). + +.. data:: StringIO + + Alias for :class:`python2:StringIO.StringIO` (in Python 2) or + :class:`python3:io.StringIO` (in Python 3). + +.. data:: unicode + + Alias for :func:`python2:unicode` (in Python 2) or :class:`python3:str` (in + Python 3). See also :func:`coerce_string()`. + +.. data:: monotonic + + Alias for :func:`python3:time.monotonic()` (in Python 3.3 and higher) or + `monotonic.monotonic()` (a `conditional dependency + `_ on older Python versions). +""" + +__all__ = ( + 'HTMLParser', + 'StringIO', + 'basestring', + 'coerce_string', + 'interactive_prompt', + 'is_string', + 'is_unicode', + 'monotonic', + 'name2codepoint', + 'on_macos', + 'on_windows', + 'unichr', + 'unicode', + 'which', +) + +# Standard library modules. +import sys + +# Differences between Python 2 and 3. +try: + # Python 2. + unicode = unicode + unichr = unichr + basestring = basestring + interactive_prompt = raw_input + from distutils.spawn import find_executable as which + from HTMLParser import HTMLParser + from StringIO import StringIO + from htmlentitydefs import name2codepoint +except (ImportError, NameError): + # Python 3. + unicode = str + unichr = chr + basestring = str + interactive_prompt = input + from shutil import which + from html.parser import HTMLParser + from io import StringIO + from html.entities import name2codepoint + +try: + # Python 3.3 and higher. + from time import monotonic +except ImportError: + # A replacement for older Python versions: + # https://pypi.org/project/monotonic/ + try: + from monotonic import monotonic + except (ImportError, RuntimeError): + # We fall back to the old behavior of using time.time() instead of + # failing when {time,monotonic}.monotonic() are both missing. + from time import time as monotonic + + +def coerce_string(value): + """ + Coerce any value to a Unicode string (:func:`python2:unicode` in Python 2 and :class:`python3:str` in Python 3). + + :param value: The value to coerce. + :returns: The value coerced to a Unicode string. + """ + return value if is_string(value) else unicode(value) + + +def is_string(value): + """ + Check if a value is a :func:`python2:basestring` (in Python 2) or :class:`python3:str` (in Python 3) object. + + :param value: The value to check. + :returns: :data:`True` if the value is a string, :data:`False` otherwise. + """ + return isinstance(value, basestring) + + +def is_unicode(value): + """ + Check if a value is a :func:`python2:unicode` (in Python 2) or :class:`python2:str` (in Python 3) object. + + :param value: The value to check. + :returns: :data:`True` if the value is a Unicode string, :data:`False` otherwise. + """ + return isinstance(value, unicode) + + +def on_macos(): + """ + Check if we're running on Apple MacOS. + + :returns: :data:`True` if running MacOS, :data:`False` otherwise. + """ + return sys.platform.startswith('darwin') + + +def on_windows(): + """ + Check if we're running on the Microsoft Windows OS. + + :returns: :data:`True` if running Windows, :data:`False` otherwise. + """ + return sys.platform.startswith('win') diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/decorators.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/decorators.py new file mode 100644 index 0000000000000000000000000000000000000000..c90a59ea2868daa3cf754400d8b348cc80c965da --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/decorators.py @@ -0,0 +1,43 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: March 2, 2020 +# URL: https://humanfriendly.readthedocs.io + +"""Simple function decorators to make Python programming easier.""" + +# Standard library modules. +import functools + +# Public identifiers that require documentation. +__all__ = ('RESULTS_ATTRIBUTE', 'cached') + +RESULTS_ATTRIBUTE = 'cached_results' +"""The name of the property used to cache the return values of functions (a string).""" + + +def cached(function): + """ + Rudimentary caching decorator for functions. + + :param function: The function whose return value should be cached. + :returns: The decorated function. + + The given function will only be called once, the first time the wrapper + function is called. The return value is cached by the wrapper function as + an attribute of the given function and returned on each subsequent call. + + .. note:: Currently no function arguments are supported because only a + single return value can be cached. Accepting any function + arguments at all would imply that the cache is parametrized on + function arguments, which is not currently the case. + """ + @functools.wraps(function) + def wrapper(): + try: + return getattr(wrapper, RESULTS_ATTRIBUTE) + except AttributeError: + result = function() + setattr(wrapper, RESULTS_ATTRIBUTE, result) + return result + return wrapper diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/deprecation.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/deprecation.py new file mode 100644 index 0000000000000000000000000000000000000000..f2012bbd6f3ddd9b955f7a25010cd78ece431c6a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/deprecation.py @@ -0,0 +1,251 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: March 2, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Support for deprecation warnings when importing names from old locations. + +When software evolves, things tend to move around. This is usually detrimental +to backwards compatibility (in Python this primarily manifests itself as +:exc:`~exceptions.ImportError` exceptions). + +While backwards compatibility is very important, it should not get in the way +of progress. It would be great to have the agility to move things around +without breaking backwards compatibility. + +This is where the :mod:`humanfriendly.deprecation` module comes in: It enables +the definition of backwards compatible aliases that emit a deprecation warning +when they are accessed. + +The way it works is that it wraps the original module in an :class:`DeprecationProxy` +object that defines a :func:`~DeprecationProxy.__getattr__()` special method to +override attribute access of the module. +""" + +# Standard library modules. +import collections +import functools +import importlib +import inspect +import sys +import types +import warnings + +# Modules included in our package. +from humanfriendly.text import format + +# Registry of known aliases (used by humanfriendly.sphinx). +REGISTRY = collections.defaultdict(dict) + +# Public identifiers that require documentation. +__all__ = ("DeprecationProxy", "define_aliases", "deprecated_args", "get_aliases", "is_method") + + +def define_aliases(module_name, **aliases): + """ + Update a module with backwards compatible aliases. + + :param module_name: The ``__name__`` of the module (a string). + :param aliases: Each keyword argument defines an alias. The values + are expected to be "dotted paths" (strings). + + The behavior of this function depends on whether the Sphinx documentation + generator is active, because the use of :class:`DeprecationProxy` to shadow the + real module in :data:`sys.modules` has the unintended side effect of + breaking autodoc support for ``:data:`` members (module variables). + + To avoid breaking Sphinx the proxy object is omitted and instead the + aliased names are injected into the original module namespace, to make sure + that imports can be satisfied when the documentation is being rendered. + + If you run into cyclic dependencies caused by :func:`define_aliases()` when + running Sphinx, you can try moving the call to :func:`define_aliases()` to + the bottom of the Python module you're working on. + """ + module = sys.modules[module_name] + proxy = DeprecationProxy(module, aliases) + # Populate the registry of aliases. + for name, target in aliases.items(): + REGISTRY[module.__name__][name] = target + # Avoid confusing Sphinx. + if "sphinx" in sys.modules: + for name, target in aliases.items(): + setattr(module, name, proxy.resolve(target)) + else: + # Install a proxy object to raise DeprecationWarning. + sys.modules[module_name] = proxy + + +def get_aliases(module_name): + """ + Get the aliases defined by a module. + + :param module_name: The ``__name__`` of the module (a string). + :returns: A dictionary with string keys and values: + + 1. Each key gives the name of an alias + created for backwards compatibility. + + 2. Each value gives the dotted path of + the proper location of the identifier. + + An empty dictionary is returned for modules that + don't define any backwards compatible aliases. + """ + return REGISTRY.get(module_name, {}) + + +def deprecated_args(*names): + """ + Deprecate positional arguments without dropping backwards compatibility. + + :param names: + + The positional arguments to :func:`deprecated_args()` give the names of + the positional arguments that the to-be-decorated function should warn + about being deprecated and translate to keyword arguments. + + :returns: A decorator function specialized to `names`. + + The :func:`deprecated_args()` decorator function was created to make it + easy to switch from positional arguments to keyword arguments [#]_ while + preserving backwards compatibility [#]_ and informing call sites + about the change. + + .. [#] Increased flexibility is the main reason why I find myself switching + from positional arguments to (optional) keyword arguments as my code + evolves to support more use cases. + + .. [#] In my experience positional argument order implicitly becomes part + of API compatibility whether intended or not. While this makes sense + for functions that over time adopt more and more optional arguments, + at a certain point it becomes an inconvenience to code maintenance. + + Here's an example of how to use the decorator:: + + @deprecated_args('text') + def report_choice(**options): + print(options['text']) + + When the decorated function is called with positional arguments + a deprecation warning is given:: + + >>> report_choice('this will give a deprecation warning') + DeprecationWarning: report_choice has deprecated positional arguments, please switch to keyword arguments + this will give a deprecation warning + + But when the function is called with keyword arguments no deprecation + warning is emitted:: + + >>> report_choice(text='this will not give a deprecation warning') + this will not give a deprecation warning + """ + def decorator(function): + def translate(args, kw): + # Raise TypeError when too many positional arguments are passed to the decorated function. + if len(args) > len(names): + raise TypeError( + format( + "{name} expected at most {limit} arguments, got {count}", + name=function.__name__, + limit=len(names), + count=len(args), + ) + ) + # Emit a deprecation warning when positional arguments are used. + if args: + warnings.warn( + format( + "{name} has deprecated positional arguments, please switch to keyword arguments", + name=function.__name__, + ), + category=DeprecationWarning, + stacklevel=3, + ) + # Translate positional arguments to keyword arguments. + for name, value in zip(names, args): + kw[name] = value + if is_method(function): + @functools.wraps(function) + def wrapper(*args, **kw): + """Wrapper for instance methods.""" + args = list(args) + self = args.pop(0) + translate(args, kw) + return function(self, **kw) + else: + @functools.wraps(function) + def wrapper(*args, **kw): + """Wrapper for module level functions.""" + translate(args, kw) + return function(**kw) + return wrapper + return decorator + + +def is_method(function): + """Check if the expected usage of the given function is as an instance method.""" + try: + # Python 3.3 and newer. + signature = inspect.signature(function) + return "self" in signature.parameters + except AttributeError: + # Python 3.2 and older. + metadata = inspect.getargspec(function) + return "self" in metadata.args + + +class DeprecationProxy(types.ModuleType): + + """Emit deprecation warnings for imports that should be updated.""" + + def __init__(self, module, aliases): + """ + Initialize an :class:`DeprecationProxy` object. + + :param module: The original module object. + :param aliases: A dictionary of aliases. + """ + # Initialize our superclass. + super(DeprecationProxy, self).__init__(name=module.__name__) + # Store initializer arguments. + self.module = module + self.aliases = aliases + + def __getattr__(self, name): + """ + Override module attribute lookup. + + :param name: The name to look up (a string). + :returns: The attribute value. + """ + # Check if the given name is an alias. + target = self.aliases.get(name) + if target is not None: + # Emit the deprecation warning. + warnings.warn( + format("%s.%s was moved to %s, please update your imports", self.module.__name__, name, target), + category=DeprecationWarning, + stacklevel=2, + ) + # Resolve the dotted path. + return self.resolve(target) + # Look up the name in the original module namespace. + value = getattr(self.module, name, None) + if value is not None: + return value + # Fall back to the default behavior. + raise AttributeError(format("module '%s' has no attribute '%s'", self.module.__name__, name)) + + def resolve(self, target): + """ + Look up the target of an alias. + + :param target: The fully qualified dotted path (a string). + :returns: The value of the given target. + """ + module_name, _, member = target.rpartition(".") + module = importlib.import_module(module_name) + return getattr(module, member) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/prompts.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/prompts.py new file mode 100644 index 0000000000000000000000000000000000000000..07166b67091c38f9954bc8e69816364747832ef2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/prompts.py @@ -0,0 +1,376 @@ +# vim: fileencoding=utf-8 + +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: February 9, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Interactive terminal prompts. + +The :mod:`~humanfriendly.prompts` module enables interaction with the user +(operator) by asking for confirmation (:func:`prompt_for_confirmation()`) and +asking to choose from a list of options (:func:`prompt_for_choice()`). It works +by rendering interactive prompts on the terminal. +""" + +# Standard library modules. +import logging +import sys + +# Modules included in our package. +from humanfriendly.compat import interactive_prompt +from humanfriendly.terminal import ( + HIGHLIGHT_COLOR, + ansi_strip, + ansi_wrap, + connected_to_terminal, + terminal_supports_colors, + warning, +) +from humanfriendly.text import format, concatenate + +# Public identifiers that require documentation. +__all__ = ( + 'MAX_ATTEMPTS', + 'TooManyInvalidReplies', + 'logger', + 'prepare_friendly_prompts', + 'prepare_prompt_text', + 'prompt_for_choice', + 'prompt_for_confirmation', + 'prompt_for_input', + 'retry_limit', +) + +MAX_ATTEMPTS = 10 +"""The number of times an interactive prompt is shown on invalid input (an integer).""" + +# Initialize a logger for this module. +logger = logging.getLogger(__name__) + + +def prompt_for_confirmation(question, default=None, padding=True): + """ + Prompt the user for confirmation. + + :param question: The text that explains what the user is confirming (a string). + :param default: The default value (a boolean) or :data:`None`. + :param padding: Refer to the documentation of :func:`prompt_for_input()`. + :returns: - If the user enters 'yes' or 'y' then :data:`True` is returned. + - If the user enters 'no' or 'n' then :data:`False` is returned. + - If the user doesn't enter any text or standard input is not + connected to a terminal (which makes it impossible to prompt + the user) the value of the keyword argument ``default`` is + returned (if that value is not :data:`None`). + :raises: - Any exceptions raised by :func:`retry_limit()`. + - Any exceptions raised by :func:`prompt_for_input()`. + + When `default` is :data:`False` and the user doesn't enter any text an + error message is printed and the prompt is repeated: + + >>> prompt_for_confirmation("Are you sure?") + + Are you sure? [y/n] + + Error: Please enter 'yes' or 'no' (there's no default choice). + + Are you sure? [y/n] + + The same thing happens when the user enters text that isn't recognized: + + >>> prompt_for_confirmation("Are you sure?") + + Are you sure? [y/n] about what? + + Error: Please enter 'yes' or 'no' (the text 'about what?' is not recognized). + + Are you sure? [y/n] + """ + # Generate the text for the prompt. + prompt_text = prepare_prompt_text(question, bold=True) + # Append the valid replies (and default reply) to the prompt text. + hint = "[Y/n]" if default else "[y/N]" if default is not None else "[y/n]" + prompt_text += " %s " % prepare_prompt_text(hint, color=HIGHLIGHT_COLOR) + # Loop until a valid response is given. + logger.debug("Requesting interactive confirmation from terminal: %r", ansi_strip(prompt_text).rstrip()) + for attempt in retry_limit(): + reply = prompt_for_input(prompt_text, '', padding=padding, strip=True) + if reply.lower() in ('y', 'yes'): + logger.debug("Confirmation granted by reply (%r).", reply) + return True + elif reply.lower() in ('n', 'no'): + logger.debug("Confirmation denied by reply (%r).", reply) + return False + elif (not reply) and default is not None: + logger.debug("Default choice selected by empty reply (%r).", + "granted" if default else "denied") + return default + else: + details = ("the text '%s' is not recognized" % reply + if reply else "there's no default choice") + logger.debug("Got %s reply (%s), retrying (%i/%i) ..", + "invalid" if reply else "empty", details, + attempt, MAX_ATTEMPTS) + warning("{indent}Error: Please enter 'yes' or 'no' ({details}).", + indent=' ' if padding else '', details=details) + + +def prompt_for_choice(choices, default=None, padding=True): + """ + Prompt the user to select a choice from a group of options. + + :param choices: A sequence of strings with available options. + :param default: The default choice if the user simply presses Enter + (expected to be a string, defaults to :data:`None`). + :param padding: Refer to the documentation of + :func:`~humanfriendly.prompts.prompt_for_input()`. + :returns: The string corresponding to the user's choice. + :raises: - :exc:`~exceptions.ValueError` if `choices` is an empty sequence. + - Any exceptions raised by + :func:`~humanfriendly.prompts.retry_limit()`. + - Any exceptions raised by + :func:`~humanfriendly.prompts.prompt_for_input()`. + + When no options are given an exception is raised: + + >>> prompt_for_choice([]) + Traceback (most recent call last): + File "humanfriendly/prompts.py", line 148, in prompt_for_choice + raise ValueError("Can't prompt for choice without any options!") + ValueError: Can't prompt for choice without any options! + + If a single option is given the user isn't prompted: + + >>> prompt_for_choice(['only one choice']) + 'only one choice' + + Here's what the actual prompt looks like by default: + + >>> prompt_for_choice(['first option', 'second option']) + + 1. first option + 2. second option + + Enter your choice as a number or unique substring (Control-C aborts): second + + 'second option' + + If you don't like the whitespace (empty lines and indentation): + + >>> prompt_for_choice(['first option', 'second option'], padding=False) + 1. first option + 2. second option + Enter your choice as a number or unique substring (Control-C aborts): first + 'first option' + """ + indent = ' ' if padding else '' + # Make sure we can use 'choices' more than once (i.e. not a generator). + choices = list(choices) + if len(choices) == 1: + # If there's only one option there's no point in prompting the user. + logger.debug("Skipping interactive prompt because there's only option (%r).", choices[0]) + return choices[0] + elif not choices: + # We can't render a choice prompt without any options. + raise ValueError("Can't prompt for choice without any options!") + # Generate the prompt text. + prompt_text = ('\n\n' if padding else '\n').join([ + # Present the available choices in a user friendly way. + "\n".join([ + (u" %i. %s" % (i, choice)) + (" (default choice)" if choice == default else "") + for i, choice in enumerate(choices, start=1) + ]), + # Instructions for the user. + "Enter your choice as a number or unique substring (Control-C aborts): ", + ]) + prompt_text = prepare_prompt_text(prompt_text, bold=True) + # Loop until a valid choice is made. + logger.debug("Requesting interactive choice on terminal (options are %s) ..", + concatenate(map(repr, choices))) + for attempt in retry_limit(): + reply = prompt_for_input(prompt_text, '', padding=padding, strip=True) + if not reply and default is not None: + logger.debug("Default choice selected by empty reply (%r).", default) + return default + elif reply.isdigit(): + index = int(reply) - 1 + if 0 <= index < len(choices): + logger.debug("Option (%r) selected by numeric reply (%s).", choices[index], reply) + return choices[index] + # Check for substring matches. + matches = [] + for choice in choices: + lower_reply = reply.lower() + lower_choice = choice.lower() + if lower_reply == lower_choice: + # If we have an 'exact' match we return it immediately. + logger.debug("Option (%r) selected by reply (exact match).", choice) + return choice + elif lower_reply in lower_choice and len(lower_reply) > 0: + # Otherwise we gather substring matches. + matches.append(choice) + if len(matches) == 1: + # If a single choice was matched we return it. + logger.debug("Option (%r) selected by reply (substring match on %r).", matches[0], reply) + return matches[0] + else: + # Give the user a hint about what went wrong. + if matches: + details = format("text '%s' matches more than one choice: %s", reply, concatenate(matches)) + elif reply.isdigit(): + details = format("number %i is not a valid choice", int(reply)) + elif reply and not reply.isspace(): + details = format("text '%s' doesn't match any choices", reply) + else: + details = "there's no default choice" + logger.debug("Got %s reply (%s), retrying (%i/%i) ..", + "invalid" if reply else "empty", details, + attempt, MAX_ATTEMPTS) + warning("%sError: Invalid input (%s).", indent, details) + + +def prompt_for_input(question, default=None, padding=True, strip=True): + """ + Prompt the user for input (free form text). + + :param question: An explanation of what is expected from the user (a string). + :param default: The return value if the user doesn't enter any text or + standard input is not connected to a terminal (which + makes it impossible to prompt the user). + :param padding: Render empty lines before and after the prompt to make it + stand out from the surrounding text? (a boolean, defaults + to :data:`True`) + :param strip: Strip leading/trailing whitespace from the user's reply? + :returns: The text entered by the user (a string) or the value of the + `default` argument. + :raises: - :exc:`~exceptions.KeyboardInterrupt` when the program is + interrupted_ while the prompt is active, for example + because the user presses Control-C_. + - :exc:`~exceptions.EOFError` when reading from `standard input`_ + fails, for example because the user presses Control-D_ or + because the standard input stream is redirected (only if + `default` is :data:`None`). + + .. _Control-C: https://en.wikipedia.org/wiki/Control-C#In_command-line_environments + .. _Control-D: https://en.wikipedia.org/wiki/End-of-transmission_character#Meaning_in_Unix + .. _interrupted: https://en.wikipedia.org/wiki/Unix_signal#SIGINT + .. _standard input: https://en.wikipedia.org/wiki/Standard_streams#Standard_input_.28stdin.29 + """ + prepare_friendly_prompts() + reply = None + try: + # Prefix an empty line to the text and indent by one space? + if padding: + question = '\n' + question + question = question.replace('\n', '\n ') + # Render the prompt and wait for the user's reply. + try: + reply = interactive_prompt(question) + finally: + if reply is None: + # If the user terminated the prompt using Control-C or + # Control-D instead of pressing Enter no newline will be + # rendered after the prompt's text. The result looks kind of + # weird: + # + # $ python -c 'print(raw_input("Are you sure? "))' + # Are you sure? ^CTraceback (most recent call last): + # File "", line 1, in + # KeyboardInterrupt + # + # We can avoid this by emitting a newline ourselves if an + # exception was raised (signaled by `reply' being None). + sys.stderr.write('\n') + if padding: + # If the caller requested (didn't opt out of) `padding' then we'll + # emit a newline regardless of whether an exception is being + # handled. This helps to make interactive prompts `stand out' from + # a surrounding `wall of text' on the terminal. + sys.stderr.write('\n') + except BaseException as e: + if isinstance(e, EOFError) and default is not None: + # If standard input isn't connected to an interactive terminal + # but the caller provided a default we'll return that. + logger.debug("Got EOF from terminal, returning default value (%r) ..", default) + return default + else: + # Otherwise we log that the prompt was interrupted but propagate + # the exception to the caller. + logger.warning("Interactive prompt was interrupted by exception!", exc_info=True) + raise + if default is not None and not reply: + # If the reply is empty and `default' is None we don't want to return + # None because it's nicer for callers to be able to assume that the + # return value is always a string. + return default + else: + return reply.strip() + + +def prepare_prompt_text(prompt_text, **options): + """ + Wrap a text to be rendered as an interactive prompt in ANSI escape sequences. + + :param prompt_text: The text to render on the prompt (a string). + :param options: Any keyword arguments are passed on to :func:`.ansi_wrap()`. + :returns: The resulting prompt text (a string). + + ANSI escape sequences are only used when the standard output stream is + connected to a terminal. When the standard input stream is connected to a + terminal any escape sequences are wrapped in "readline hints". + """ + return (ansi_wrap(prompt_text, readline_hints=connected_to_terminal(sys.stdin), **options) + if terminal_supports_colors(sys.stdout) + else prompt_text) + + +def prepare_friendly_prompts(): + u""" + Make interactive prompts more user friendly. + + The prompts presented by :func:`python2:raw_input()` (in Python 2) and + :func:`python3:input()` (in Python 3) are not very user friendly by + default, for example the cursor keys (:kbd:`←`, :kbd:`↑`, :kbd:`→` and + :kbd:`↓`) and the :kbd:`Home` and :kbd:`End` keys enter characters instead + of performing the action you would expect them to. By simply importing the + :mod:`readline` module these prompts become much friendlier (as mentioned + in the Python standard library documentation). + + This function is called by the other functions in this module to enable + user friendly prompts. + """ + try: + import readline # NOQA + except ImportError: + # might not be available on Windows if pyreadline isn't installed + pass + + +def retry_limit(limit=MAX_ATTEMPTS): + """ + Allow the user to provide valid input up to `limit` times. + + :param limit: The maximum number of attempts (a number, + defaults to :data:`MAX_ATTEMPTS`). + :returns: A generator of numbers starting from one. + :raises: :exc:`TooManyInvalidReplies` when an interactive prompt + receives repeated invalid input (:data:`MAX_ATTEMPTS`). + + This function returns a generator for interactive prompts that want to + repeat on invalid input without getting stuck in infinite loops. + """ + for i in range(limit): + yield i + 1 + msg = "Received too many invalid replies on interactive prompt, giving up! (tried %i times)" + formatted_msg = msg % limit + # Make sure the event is logged. + logger.warning(formatted_msg) + # Force the caller to decide what to do now. + raise TooManyInvalidReplies(formatted_msg) + + +class TooManyInvalidReplies(Exception): + + """Raised by interactive prompts when they've received too many invalid inputs.""" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/sphinx.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/sphinx.py new file mode 100644 index 0000000000000000000000000000000000000000..cf5d1b393567ed58457c490186d908c529449df3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/sphinx.py @@ -0,0 +1,315 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: June 11, 2021 +# URL: https://humanfriendly.readthedocs.io + +""" +Customizations for and integration with the Sphinx_ documentation generator. + +The :mod:`humanfriendly.sphinx` module uses the `Sphinx extension API`_ to +customize the process of generating Sphinx based Python documentation. To +explore the functionality this module offers its best to start reading +from the :func:`setup()` function. + +.. _Sphinx: http://www.sphinx-doc.org/ +.. _Sphinx extension API: http://sphinx-doc.org/extdev/appapi.html +""" + +# Standard library modules. +import logging +import types + +# External dependencies (if Sphinx is installed docutils will be installed). +import docutils.nodes +import docutils.utils + +# Modules included in our package. +from humanfriendly.deprecation import get_aliases +from humanfriendly.text import compact, dedent, format +from humanfriendly.usage import USAGE_MARKER, render_usage + +# Public identifiers that require documentation. +__all__ = ( + "deprecation_note_callback", + "enable_deprecation_notes", + "enable_man_role", + "enable_pypi_role", + "enable_special_methods", + "enable_usage_formatting", + "logger", + "man_role", + "pypi_role", + "setup", + "special_methods_callback", + "usage_message_callback", +) + +# Initialize a logger for this module. +logger = logging.getLogger(__name__) + + +def deprecation_note_callback(app, what, name, obj, options, lines): + """ + Automatically document aliases defined using :func:`~humanfriendly.deprecation.define_aliases()`. + + Refer to :func:`enable_deprecation_notes()` to enable the use of this + function (you probably don't want to call :func:`deprecation_note_callback()` + directly). + + This function implements a callback for ``autodoc-process-docstring`` that + reformats module docstrings to append an overview of aliases defined by the + module. + + The parameters expected by this function are those defined for Sphinx event + callback functions (i.e. I'm not going to document them here :-). + """ + if isinstance(obj, types.ModuleType) and lines: + aliases = get_aliases(obj.__name__) + if aliases: + # Convert the existing docstring to a string and remove leading + # indentation from that string, otherwise our generated content + # would have to match the existing indentation in order not to + # break docstring parsing (because indentation is significant + # in the reStructuredText format). + blocks = [dedent("\n".join(lines))] + # Use an admonition to group the deprecated aliases together and + # to distinguish them from the autodoc entries that follow. + blocks.append(".. note:: Deprecated names") + indent = " " * 3 + if len(aliases) == 1: + explanation = """ + The following alias exists to preserve backwards compatibility, + however a :exc:`~exceptions.DeprecationWarning` is triggered + when it is accessed, because this alias will be removed + in a future release. + """ + else: + explanation = """ + The following aliases exist to preserve backwards compatibility, + however a :exc:`~exceptions.DeprecationWarning` is triggered + when they are accessed, because these aliases will be + removed in a future release. + """ + blocks.append(indent + compact(explanation)) + for name, target in aliases.items(): + blocks.append(format("%s.. data:: %s", indent, name)) + blocks.append(format("%sAlias for :obj:`%s`.", indent * 2, target)) + update_lines(lines, "\n\n".join(blocks)) + + +def enable_deprecation_notes(app): + """ + Enable documenting backwards compatibility aliases using the autodoc_ extension. + + :param app: The Sphinx application object. + + This function connects the :func:`deprecation_note_callback()` function to + ``autodoc-process-docstring`` events. + + .. _autodoc: http://www.sphinx-doc.org/en/stable/ext/autodoc.html + """ + app.connect("autodoc-process-docstring", deprecation_note_callback) + + +def enable_man_role(app): + """ + Enable the ``:man:`` role for linking to Debian Linux manual pages. + + :param app: The Sphinx application object. + + This function registers the :func:`man_role()` function to handle the + ``:man:`` role. + """ + app.add_role("man", man_role) + + +def enable_pypi_role(app): + """ + Enable the ``:pypi:`` role for linking to the Python Package Index. + + :param app: The Sphinx application object. + + This function registers the :func:`pypi_role()` function to handle the + ``:pypi:`` role. + """ + app.add_role("pypi", pypi_role) + + +def enable_special_methods(app): + """ + Enable documenting "special methods" using the autodoc_ extension. + + :param app: The Sphinx application object. + + This function connects the :func:`special_methods_callback()` function to + ``autodoc-skip-member`` events. + + .. _autodoc: http://www.sphinx-doc.org/en/stable/ext/autodoc.html + """ + app.connect("autodoc-skip-member", special_methods_callback) + + +def enable_usage_formatting(app): + """ + Reformat human friendly usage messages to reStructuredText_. + + :param app: The Sphinx application object (as given to ``setup()``). + + This function connects the :func:`usage_message_callback()` function to + ``autodoc-process-docstring`` events. + + .. _reStructuredText: https://en.wikipedia.org/wiki/ReStructuredText + """ + app.connect("autodoc-process-docstring", usage_message_callback) + + +def man_role(role, rawtext, text, lineno, inliner, options={}, content=[]): + """ + Convert a Linux manual topic to a hyperlink. + + Using the ``:man:`` role is very simple, here's an example: + + .. code-block:: rst + + See the :man:`python` documentation. + + This results in the following: + + See the :man:`python` documentation. + + As the example shows you can use the role inline, embedded in sentences of + text. In the generated documentation the ``:man:`` text is omitted and a + hyperlink pointing to the Debian Linux manual pages is emitted. + """ + man_url = "https://manpages.debian.org/%s" % text + reference = docutils.nodes.reference(rawtext, docutils.utils.unescape(text), refuri=man_url, **options) + return [reference], [] + + +def pypi_role(role, rawtext, text, lineno, inliner, options={}, content=[]): + """ + Generate hyperlinks to the Python Package Index. + + Using the ``:pypi:`` role is very simple, here's an example: + + .. code-block:: rst + + See the :pypi:`humanfriendly` package. + + This results in the following: + + See the :pypi:`humanfriendly` package. + + As the example shows you can use the role inline, embedded in sentences of + text. In the generated documentation the ``:pypi:`` text is omitted and a + hyperlink pointing to the Python Package Index is emitted. + """ + pypi_url = "https://pypi.org/project/%s/" % text + reference = docutils.nodes.reference(rawtext, docutils.utils.unescape(text), refuri=pypi_url, **options) + return [reference], [] + + +def setup(app): + """ + Enable all of the provided Sphinx_ customizations. + + :param app: The Sphinx application object. + + The :func:`setup()` function makes it easy to enable all of the Sphinx + customizations provided by the :mod:`humanfriendly.sphinx` module with the + least amount of code. All you need to do is to add the module name to the + ``extensions`` variable in your ``conf.py`` file: + + .. code-block:: python + + # Sphinx extension module names. + extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.doctest', + 'sphinx.ext.intersphinx', + 'humanfriendly.sphinx', + ] + + When Sphinx sees the :mod:`humanfriendly.sphinx` name it will import the + module and call its :func:`setup()` function. This function will then call + the following: + + - :func:`enable_deprecation_notes()` + - :func:`enable_man_role()` + - :func:`enable_pypi_role()` + - :func:`enable_special_methods()` + - :func:`enable_usage_formatting()` + + Of course more functionality may be added at a later stage. If you don't + like that idea you may be better of calling the individual functions from + your own ``setup()`` function. + """ + from humanfriendly import __version__ + + enable_deprecation_notes(app) + enable_man_role(app) + enable_pypi_role(app) + enable_special_methods(app) + enable_usage_formatting(app) + + return dict(parallel_read_safe=True, parallel_write_safe=True, version=__version__) + + +def special_methods_callback(app, what, name, obj, skip, options): + """ + Enable documenting "special methods" using the autodoc_ extension. + + Refer to :func:`enable_special_methods()` to enable the use of this + function (you probably don't want to call + :func:`special_methods_callback()` directly). + + This function implements a callback for ``autodoc-skip-member`` events to + include documented "special methods" (method names with two leading and two + trailing underscores) in your documentation. The result is similar to the + use of the ``special-members`` flag with one big difference: Special + methods are included but other types of members are ignored. This means + that attributes like ``__weakref__`` will always be ignored (this was my + main annoyance with the ``special-members`` flag). + + The parameters expected by this function are those defined for Sphinx event + callback functions (i.e. I'm not going to document them here :-). + """ + if getattr(obj, "__doc__", None) and isinstance(obj, (types.FunctionType, types.MethodType)): + return False + else: + return skip + + +def update_lines(lines, text): + """Private helper for ``autodoc-process-docstring`` callbacks.""" + while lines: + lines.pop() + lines.extend(text.splitlines()) + + +def usage_message_callback(app, what, name, obj, options, lines): + """ + Reformat human friendly usage messages to reStructuredText_. + + Refer to :func:`enable_usage_formatting()` to enable the use of this + function (you probably don't want to call :func:`usage_message_callback()` + directly). + + This function implements a callback for ``autodoc-process-docstring`` that + reformats module docstrings using :func:`.render_usage()` so that Sphinx + doesn't mangle usage messages that were written to be human readable + instead of machine readable. Only module docstrings whose first line starts + with :data:`.USAGE_MARKER` are reformatted. + + The parameters expected by this function are those defined for Sphinx event + callback functions (i.e. I'm not going to document them here :-). + """ + # Make sure we only modify the docstrings of modules. + if isinstance(obj, types.ModuleType) and lines: + # Make sure we only modify docstrings containing a usage message. + if lines[0].startswith(USAGE_MARKER): + # Convert the usage message to reStructuredText. + text = render_usage("\n".join(lines)) + # Fill up the buffer with our modified docstring. + update_lines(lines, text) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/tables.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/tables.py new file mode 100644 index 0000000000000000000000000000000000000000..3a32ba3b3f6dc9866e74b1f0ea7ea21a01bc81e0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/tables.py @@ -0,0 +1,341 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: February 16, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Functions that render ASCII tables. + +Some generic notes about the table formatting functions in this module: + +- These functions were not written with performance in mind (*at all*) because + they're intended to format tabular data to be presented on a terminal. If + someone were to run into a performance problem using these functions, they'd + be printing so much tabular data to the terminal that a human wouldn't be + able to digest the tabular data anyway, so the point is moot :-). + +- These functions ignore ANSI escape sequences (at least the ones generated by + the :mod:`~humanfriendly.terminal` module) in the calculation of columns + widths. On reason for this is that column names are highlighted in color when + connected to a terminal. It also means that you can use ANSI escape sequences + to highlight certain column's values if you feel like it (for example to + highlight deviations from the norm in an overview of calculated values). +""" + +# Standard library modules. +import collections +import re + +# Modules included in our package. +from humanfriendly.compat import coerce_string +from humanfriendly.terminal import ( + ansi_strip, + ansi_width, + ansi_wrap, + terminal_supports_colors, + find_terminal_size, + HIGHLIGHT_COLOR, +) + +# Public identifiers that require documentation. +__all__ = ( + 'format_pretty_table', + 'format_robust_table', + 'format_rst_table', + 'format_smart_table', +) + +# Compiled regular expression pattern to recognize table columns containing +# numeric data (integer and/or floating point numbers). Used to right-align the +# contents of such columns. +# +# Pre-emptive snarky comment: This pattern doesn't match every possible +# floating point number notation!?!1!1 +# +# Response: I know, that's intentional. The use of this regular expression +# pattern has a very high DWIM level and weird floating point notations do not +# fall under the DWIM umbrella :-). +NUMERIC_DATA_PATTERN = re.compile(r'^\d+(\.\d+)?$') + + +def format_smart_table(data, column_names): + """ + Render tabular data using the most appropriate representation. + + :param data: An iterable (e.g. a :func:`tuple` or :class:`list`) + containing the rows of the table, where each row is an + iterable containing the columns of the table (strings). + :param column_names: An iterable of column names (strings). + :returns: The rendered table (a string). + + If you want an easy way to render tabular data on a terminal in a human + friendly format then this function is for you! It works as follows: + + - If the input data doesn't contain any line breaks the function + :func:`format_pretty_table()` is used to render a pretty table. If the + resulting table fits in the terminal without wrapping the rendered pretty + table is returned. + + - If the input data does contain line breaks or if a pretty table would + wrap (given the width of the terminal) then the function + :func:`format_robust_table()` is used to render a more robust table that + can deal with data containing line breaks and long text. + """ + # Normalize the input in case we fall back from a pretty table to a robust + # table (in which case we'll definitely iterate the input more than once). + data = [normalize_columns(r) for r in data] + column_names = normalize_columns(column_names) + # Make sure the input data doesn't contain any line breaks (because pretty + # tables break horribly when a column's text contains a line break :-). + if not any(any('\n' in c for c in r) for r in data): + # Render a pretty table. + pretty_table = format_pretty_table(data, column_names) + # Check if the pretty table fits in the terminal. + table_width = max(map(ansi_width, pretty_table.splitlines())) + num_rows, num_columns = find_terminal_size() + if table_width <= num_columns: + # The pretty table fits in the terminal without wrapping! + return pretty_table + # Fall back to a robust table when a pretty table won't work. + return format_robust_table(data, column_names) + + +def format_pretty_table(data, column_names=None, horizontal_bar='-', vertical_bar='|'): + """ + Render a table using characters like dashes and vertical bars to emulate borders. + + :param data: An iterable (e.g. a :func:`tuple` or :class:`list`) + containing the rows of the table, where each row is an + iterable containing the columns of the table (strings). + :param column_names: An iterable of column names (strings). + :param horizontal_bar: The character used to represent a horizontal bar (a + string). + :param vertical_bar: The character used to represent a vertical bar (a + string). + :returns: The rendered table (a string). + + Here's an example: + + >>> from humanfriendly.tables import format_pretty_table + >>> column_names = ['Version', 'Uploaded on', 'Downloads'] + >>> humanfriendly_releases = [ + ... ['1.23', '2015-05-25', '218'], + ... ['1.23.1', '2015-05-26', '1354'], + ... ['1.24', '2015-05-26', '223'], + ... ['1.25', '2015-05-26', '4319'], + ... ['1.25.1', '2015-06-02', '197'], + ... ] + >>> print(format_pretty_table(humanfriendly_releases, column_names)) + ------------------------------------- + | Version | Uploaded on | Downloads | + ------------------------------------- + | 1.23 | 2015-05-25 | 218 | + | 1.23.1 | 2015-05-26 | 1354 | + | 1.24 | 2015-05-26 | 223 | + | 1.25 | 2015-05-26 | 4319 | + | 1.25.1 | 2015-06-02 | 197 | + ------------------------------------- + + Notes about the resulting table: + + - If a column contains numeric data (integer and/or floating point + numbers) in all rows (ignoring column names of course) then the content + of that column is right-aligned, as can be seen in the example above. The + idea here is to make it easier to compare the numbers in different + columns to each other. + + - The column names are highlighted in color so they stand out a bit more + (see also :data:`.HIGHLIGHT_COLOR`). The following screen shot shows what + that looks like (my terminals are always set to white text on a black + background): + + .. image:: images/pretty-table.png + """ + # Normalize the input because we'll have to iterate it more than once. + data = [normalize_columns(r, expandtabs=True) for r in data] + if column_names is not None: + column_names = normalize_columns(column_names) + if column_names: + if terminal_supports_colors(): + column_names = [highlight_column_name(n) for n in column_names] + data.insert(0, column_names) + # Calculate the maximum width of each column. + widths = collections.defaultdict(int) + numeric_data = collections.defaultdict(list) + for row_index, row in enumerate(data): + for column_index, column in enumerate(row): + widths[column_index] = max(widths[column_index], ansi_width(column)) + if not (column_names and row_index == 0): + numeric_data[column_index].append(bool(NUMERIC_DATA_PATTERN.match(ansi_strip(column)))) + # Create a horizontal bar of dashes as a delimiter. + line_delimiter = horizontal_bar * (sum(widths.values()) + len(widths) * 3 + 1) + # Start the table with a vertical bar. + lines = [line_delimiter] + # Format the rows and columns. + for row_index, row in enumerate(data): + line = [vertical_bar] + for column_index, column in enumerate(row): + padding = ' ' * (widths[column_index] - ansi_width(column)) + if all(numeric_data[column_index]): + line.append(' ' + padding + column + ' ') + else: + line.append(' ' + column + padding + ' ') + line.append(vertical_bar) + lines.append(u''.join(line)) + if column_names and row_index == 0: + lines.append(line_delimiter) + # End the table with a vertical bar. + lines.append(line_delimiter) + # Join the lines, returning a single string. + return u'\n'.join(lines) + + +def format_robust_table(data, column_names): + """ + Render tabular data with one column per line (allowing columns with line breaks). + + :param data: An iterable (e.g. a :func:`tuple` or :class:`list`) + containing the rows of the table, where each row is an + iterable containing the columns of the table (strings). + :param column_names: An iterable of column names (strings). + :returns: The rendered table (a string). + + Here's an example: + + >>> from humanfriendly.tables import format_robust_table + >>> column_names = ['Version', 'Uploaded on', 'Downloads'] + >>> humanfriendly_releases = [ + ... ['1.23', '2015-05-25', '218'], + ... ['1.23.1', '2015-05-26', '1354'], + ... ['1.24', '2015-05-26', '223'], + ... ['1.25', '2015-05-26', '4319'], + ... ['1.25.1', '2015-06-02', '197'], + ... ] + >>> print(format_robust_table(humanfriendly_releases, column_names)) + ----------------------- + Version: 1.23 + Uploaded on: 2015-05-25 + Downloads: 218 + ----------------------- + Version: 1.23.1 + Uploaded on: 2015-05-26 + Downloads: 1354 + ----------------------- + Version: 1.24 + Uploaded on: 2015-05-26 + Downloads: 223 + ----------------------- + Version: 1.25 + Uploaded on: 2015-05-26 + Downloads: 4319 + ----------------------- + Version: 1.25.1 + Uploaded on: 2015-06-02 + Downloads: 197 + ----------------------- + + The column names are highlighted in bold font and color so they stand out a + bit more (see :data:`.HIGHLIGHT_COLOR`). + """ + blocks = [] + column_names = ["%s:" % n for n in normalize_columns(column_names)] + if terminal_supports_colors(): + column_names = [highlight_column_name(n) for n in column_names] + # Convert each row into one or more `name: value' lines (one per column) + # and group each `row of lines' into a block (i.e. rows become blocks). + for row in data: + lines = [] + for column_index, column_text in enumerate(normalize_columns(row)): + stripped_column = column_text.strip() + if '\n' not in stripped_column: + # Columns without line breaks are formatted inline. + lines.append("%s %s" % (column_names[column_index], stripped_column)) + else: + # Columns with line breaks could very well contain indented + # lines, so we'll put the column name on a separate line. This + # way any indentation remains intact, and it's easier to + # copy/paste the text. + lines.append(column_names[column_index]) + lines.extend(column_text.rstrip().splitlines()) + blocks.append(lines) + # Calculate the width of the row delimiter. + num_rows, num_columns = find_terminal_size() + longest_line = max(max(map(ansi_width, lines)) for lines in blocks) + delimiter = u"\n%s\n" % ('-' * min(longest_line, num_columns)) + # Force a delimiter at the start and end of the table. + blocks.insert(0, "") + blocks.append("") + # Embed the row delimiter between every two blocks. + return delimiter.join(u"\n".join(b) for b in blocks).strip() + + +def format_rst_table(data, column_names=None): + """ + Render a table in reStructuredText_ format. + + :param data: An iterable (e.g. a :func:`tuple` or :class:`list`) + containing the rows of the table, where each row is an + iterable containing the columns of the table (strings). + :param column_names: An iterable of column names (strings). + :returns: The rendered table (a string). + + Here's an example: + + >>> from humanfriendly.tables import format_rst_table + >>> column_names = ['Version', 'Uploaded on', 'Downloads'] + >>> humanfriendly_releases = [ + ... ['1.23', '2015-05-25', '218'], + ... ['1.23.1', '2015-05-26', '1354'], + ... ['1.24', '2015-05-26', '223'], + ... ['1.25', '2015-05-26', '4319'], + ... ['1.25.1', '2015-06-02', '197'], + ... ] + >>> print(format_rst_table(humanfriendly_releases, column_names)) + ======= =========== ========= + Version Uploaded on Downloads + ======= =========== ========= + 1.23 2015-05-25 218 + 1.23.1 2015-05-26 1354 + 1.24 2015-05-26 223 + 1.25 2015-05-26 4319 + 1.25.1 2015-06-02 197 + ======= =========== ========= + + .. _reStructuredText: https://en.wikipedia.org/wiki/ReStructuredText + """ + data = [normalize_columns(r) for r in data] + if column_names: + data.insert(0, normalize_columns(column_names)) + # Calculate the maximum width of each column. + widths = collections.defaultdict(int) + for row in data: + for index, column in enumerate(row): + widths[index] = max(widths[index], len(column)) + # Pad the columns using whitespace. + for row in data: + for index, column in enumerate(row): + if index < (len(row) - 1): + row[index] = column.ljust(widths[index]) + # Add table markers. + delimiter = ['=' * w for i, w in sorted(widths.items())] + if column_names: + data.insert(1, delimiter) + data.insert(0, delimiter) + data.append(delimiter) + # Join the lines and columns together. + return '\n'.join(' '.join(r) for r in data) + + +def normalize_columns(row, expandtabs=False): + results = [] + for value in row: + text = coerce_string(value) + if expandtabs: + text = text.expandtabs() + results.append(text) + return results + + +def highlight_column_name(name): + return ansi_wrap(name, bold=True, color=HIGHLIGHT_COLOR) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ba9739ccb22e5708458c453eeb366de77d0e4b4d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/__init__.py @@ -0,0 +1,776 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: March 1, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Interaction with interactive text terminals. + +The :mod:`~humanfriendly.terminal` module makes it easy to interact with +interactive text terminals and format text for rendering on such terminals. If +the terms used in the documentation of this module don't make sense to you then +please refer to the `Wikipedia article on ANSI escape sequences`_ for details +about how ANSI escape sequences work. + +This module was originally developed for use on UNIX systems, but since then +Windows 10 gained native support for ANSI escape sequences and this module was +enhanced to recognize and support this. For details please refer to the +:func:`enable_ansi_support()` function. + +.. _Wikipedia article on ANSI escape sequences: http://en.wikipedia.org/wiki/ANSI_escape_code#Sequence_elements +""" + +# Standard library modules. +import codecs +import numbers +import os +import platform +import re +import subprocess +import sys + +# The `fcntl' module is platform specific so importing it may give an error. We +# hide this implementation detail from callers by handling the import error and +# setting a flag instead. +try: + import fcntl + import termios + import struct + HAVE_IOCTL = True +except ImportError: + HAVE_IOCTL = False + +# Modules included in our package. +from humanfriendly.compat import coerce_string, is_unicode, on_windows, which +from humanfriendly.decorators import cached +from humanfriendly.deprecation import define_aliases +from humanfriendly.text import concatenate, format +from humanfriendly.usage import format_usage + +# Public identifiers that require documentation. +__all__ = ( + 'ANSI_COLOR_CODES', + 'ANSI_CSI', + 'ANSI_ERASE_LINE', + 'ANSI_HIDE_CURSOR', + 'ANSI_RESET', + 'ANSI_SGR', + 'ANSI_SHOW_CURSOR', + 'ANSI_TEXT_STYLES', + 'CLEAN_OUTPUT_PATTERN', + 'DEFAULT_COLUMNS', + 'DEFAULT_ENCODING', + 'DEFAULT_LINES', + 'HIGHLIGHT_COLOR', + 'ansi_strip', + 'ansi_style', + 'ansi_width', + 'ansi_wrap', + 'auto_encode', + 'clean_terminal_output', + 'connected_to_terminal', + 'enable_ansi_support', + 'find_terminal_size', + 'find_terminal_size_using_ioctl', + 'find_terminal_size_using_stty', + 'get_pager_command', + 'have_windows_native_ansi_support', + 'message', + 'output', + 'readline_strip', + 'readline_wrap', + 'show_pager', + 'terminal_supports_colors', + 'usage', + 'warning', +) + +ANSI_CSI = '\x1b[' +"""The ANSI "Control Sequence Introducer" (a string).""" + +ANSI_SGR = 'm' +"""The ANSI "Select Graphic Rendition" sequence (a string).""" + +ANSI_ERASE_LINE = '%sK' % ANSI_CSI +"""The ANSI escape sequence to erase the current line (a string).""" + +ANSI_RESET = '%s0%s' % (ANSI_CSI, ANSI_SGR) +"""The ANSI escape sequence to reset styling (a string).""" + +ANSI_HIDE_CURSOR = '%s?25l' % ANSI_CSI +"""The ANSI escape sequence to hide the text cursor (a string).""" + +ANSI_SHOW_CURSOR = '%s?25h' % ANSI_CSI +"""The ANSI escape sequence to show the text cursor (a string).""" + +ANSI_COLOR_CODES = dict(black=0, red=1, green=2, yellow=3, blue=4, magenta=5, cyan=6, white=7) +""" +A dictionary with (name, number) pairs of `portable color codes`_. Used by +:func:`ansi_style()` to generate ANSI escape sequences that change font color. + +.. _portable color codes: http://en.wikipedia.org/wiki/ANSI_escape_code#Colors +""" + +ANSI_TEXT_STYLES = dict(bold=1, faint=2, italic=3, underline=4, inverse=7, strike_through=9) +""" +A dictionary with (name, number) pairs of text styles (effects). Used by +:func:`ansi_style()` to generate ANSI escape sequences that change text +styles. Only widely supported text styles are included here. +""" + +CLEAN_OUTPUT_PATTERN = re.compile(u'(\r|\n|\b|%s)' % re.escape(ANSI_ERASE_LINE)) +""" +A compiled regular expression used to separate significant characters from other text. + +This pattern is used by :func:`clean_terminal_output()` to split terminal +output into regular text versus backspace, carriage return and line feed +characters and ANSI 'erase line' escape sequences. +""" + +DEFAULT_LINES = 25 +"""The default number of lines in a terminal (an integer).""" + +DEFAULT_COLUMNS = 80 +"""The default number of columns in a terminal (an integer).""" + +DEFAULT_ENCODING = 'UTF-8' +"""The output encoding for Unicode strings.""" + +HIGHLIGHT_COLOR = os.environ.get('HUMANFRIENDLY_HIGHLIGHT_COLOR', 'green') +""" +The color used to highlight important tokens in formatted text (e.g. the usage +message of the ``humanfriendly`` program). If the environment variable +``$HUMANFRIENDLY_HIGHLIGHT_COLOR`` is set it determines the value of +:data:`HIGHLIGHT_COLOR`. +""" + + +def ansi_strip(text, readline_hints=True): + """ + Strip ANSI escape sequences from the given string. + + :param text: The text from which ANSI escape sequences should be removed (a + string). + :param readline_hints: If :data:`True` then :func:`readline_strip()` is + used to remove `readline hints`_ from the string. + :returns: The text without ANSI escape sequences (a string). + """ + pattern = '%s.*?%s' % (re.escape(ANSI_CSI), re.escape(ANSI_SGR)) + text = re.sub(pattern, '', text) + if readline_hints: + text = readline_strip(text) + return text + + +def ansi_style(**kw): + """ + Generate ANSI escape sequences for the given color and/or style(s). + + :param color: The foreground color. Three types of values are supported: + + - The name of a color (one of the strings 'black', 'red', + 'green', 'yellow', 'blue', 'magenta', 'cyan' or 'white'). + - An integer that refers to the 256 color mode palette. + - A tuple or list with three integers representing an RGB + (red, green, blue) value. + + The value :data:`None` (the default) means no escape + sequence to switch color will be emitted. + :param background: The background color (see the description + of the `color` argument). + :param bright: Use high intensity colors instead of default colors + (a boolean, defaults to :data:`False`). + :param readline_hints: If :data:`True` then :func:`readline_wrap()` is + applied to the generated ANSI escape sequences (the + default is :data:`False`). + :param kw: Any additional keyword arguments are expected to match a key + in the :data:`ANSI_TEXT_STYLES` dictionary. If the argument's + value evaluates to :data:`True` the respective style will be + enabled. + :returns: The ANSI escape sequences to enable the requested text styles or + an empty string if no styles were requested. + :raises: :exc:`~exceptions.ValueError` when an invalid color name is given. + + Even though only eight named colors are supported, the use of `bright=True` + and `faint=True` increases the number of available colors to around 24 (it + may be slightly lower, for example because faint black is just black). + + **Support for 8-bit colors** + + In `release 4.7`_ support for 256 color mode was added. While this + significantly increases the available colors it's not very human friendly + in usage because you need to look up color codes in the `256 color mode + palette `_. + + You can use the ``humanfriendly --demo`` command to get a demonstration of + the available colors, see also the screen shot below. Note that the small + font size in the screen shot was so that the demonstration of 256 color + mode support would fit into a single screen shot without scrolling :-) + (I wasn't feeling very creative). + + .. image:: images/ansi-demo.png + + **Support for 24-bit colors** + + In `release 4.14`_ support for 24-bit colors was added by accepting a tuple + or list with three integers representing the RGB (red, green, blue) value + of a color. This is not included in the demo because rendering millions of + colors was deemed unpractical ;-). + + .. _release 4.7: http://humanfriendly.readthedocs.io/en/latest/changelog.html#release-4-7-2018-01-14 + .. _release 4.14: http://humanfriendly.readthedocs.io/en/latest/changelog.html#release-4-14-2018-07-13 + """ + # Start with sequences that change text styles. + sequences = [ANSI_TEXT_STYLES[k] for k, v in kw.items() if k in ANSI_TEXT_STYLES and v] + # Append the color code (if any). + for color_type in 'color', 'background': + color_value = kw.get(color_type) + if isinstance(color_value, (tuple, list)): + if len(color_value) != 3: + msg = "Invalid color value %r! (expected tuple or list with three numbers)" + raise ValueError(msg % color_value) + sequences.append(48 if color_type == 'background' else 38) + sequences.append(2) + sequences.extend(map(int, color_value)) + elif isinstance(color_value, numbers.Number): + # Numeric values are assumed to be 256 color codes. + sequences.extend(( + 39 if color_type == 'background' else 38, + 5, int(color_value) + )) + elif color_value: + # Other values are assumed to be strings containing one of the known color names. + if color_value not in ANSI_COLOR_CODES: + msg = "Invalid color value %r! (expected an integer or one of the strings %s)" + raise ValueError(msg % (color_value, concatenate(map(repr, sorted(ANSI_COLOR_CODES))))) + # Pick the right offset for foreground versus background + # colors and regular intensity versus bright colors. + offset = ( + (100 if kw.get('bright') else 40) + if color_type == 'background' + else (90 if kw.get('bright') else 30) + ) + # Combine the offset and color code into a single integer. + sequences.append(offset + ANSI_COLOR_CODES[color_value]) + if sequences: + encoded = ANSI_CSI + ';'.join(map(str, sequences)) + ANSI_SGR + return readline_wrap(encoded) if kw.get('readline_hints') else encoded + else: + return '' + + +def ansi_width(text): + """ + Calculate the effective width of the given text (ignoring ANSI escape sequences). + + :param text: The text whose width should be calculated (a string). + :returns: The width of the text without ANSI escape sequences (an + integer). + + This function uses :func:`ansi_strip()` to strip ANSI escape sequences from + the given string and returns the length of the resulting string. + """ + return len(ansi_strip(text)) + + +def ansi_wrap(text, **kw): + """ + Wrap text in ANSI escape sequences for the given color and/or style(s). + + :param text: The text to wrap (a string). + :param kw: Any keyword arguments are passed to :func:`ansi_style()`. + :returns: The result of this function depends on the keyword arguments: + + - If :func:`ansi_style()` generates an ANSI escape sequence based + on the keyword arguments, the given text is prefixed with the + generated ANSI escape sequence and suffixed with + :data:`ANSI_RESET`. + + - If :func:`ansi_style()` returns an empty string then the text + given by the caller is returned unchanged. + """ + start_sequence = ansi_style(**kw) + if start_sequence: + end_sequence = ANSI_RESET + if kw.get('readline_hints'): + end_sequence = readline_wrap(end_sequence) + return start_sequence + text + end_sequence + else: + return text + + +def auto_encode(stream, text, *args, **kw): + """ + Reliably write Unicode strings to the terminal. + + :param stream: The file-like object to write to (a value like + :data:`sys.stdout` or :data:`sys.stderr`). + :param text: The text to write to the stream (a string). + :param args: Refer to :func:`~humanfriendly.text.format()`. + :param kw: Refer to :func:`~humanfriendly.text.format()`. + + Renders the text using :func:`~humanfriendly.text.format()` and writes it + to the given stream. If an :exc:`~exceptions.UnicodeEncodeError` is + encountered in doing so, the text is encoded using :data:`DEFAULT_ENCODING` + and the write is retried. The reasoning behind this rather blunt approach + is that it's preferable to get output on the command line in the wrong + encoding then to have the Python program blow up with a + :exc:`~exceptions.UnicodeEncodeError` exception. + """ + text = format(text, *args, **kw) + try: + stream.write(text) + except UnicodeEncodeError: + stream.write(codecs.encode(text, DEFAULT_ENCODING)) + + +def clean_terminal_output(text): + """ + Clean up the terminal output of a command. + + :param text: The raw text with special characters (a Unicode string). + :returns: A list of Unicode strings (one for each line). + + This function emulates the effect of backspace (0x08), carriage return + (0x0D) and line feed (0x0A) characters and the ANSI 'erase line' escape + sequence on interactive terminals. It's intended to clean up command output + that was originally meant to be rendered on an interactive terminal and + that has been captured using e.g. the :man:`script` program [#]_ or the + :mod:`pty` module [#]_. + + .. [#] My coloredlogs_ package supports the ``coloredlogs --to-html`` + command which uses :man:`script` to fool a subprocess into thinking + that it's connected to an interactive terminal (in order to get it + to emit ANSI escape sequences). + + .. [#] My capturer_ package uses the :mod:`pty` module to fool the current + process and subprocesses into thinking they are connected to an + interactive terminal (in order to get them to emit ANSI escape + sequences). + + **Some caveats about the use of this function:** + + - Strictly speaking the effect of carriage returns cannot be emulated + outside of an actual terminal due to the interaction between overlapping + output, terminal widths and line wrapping. The goal of this function is + to sanitize noise in terminal output while preserving useful output. + Think of it as a useful and pragmatic but possibly lossy conversion. + + - The algorithm isn't smart enough to properly handle a pair of ANSI escape + sequences that open before a carriage return and close after the last + carriage return in a linefeed delimited string; the resulting string will + contain only the closing end of the ANSI escape sequence pair. Tracking + this kind of complexity requires a state machine and proper parsing. + + .. _capturer: https://pypi.org/project/capturer + .. _coloredlogs: https://pypi.org/project/coloredlogs + """ + cleaned_lines = [] + current_line = '' + current_position = 0 + for token in CLEAN_OUTPUT_PATTERN.split(text): + if token == '\r': + # Seek back to the start of the current line. + current_position = 0 + elif token == '\b': + # Seek back one character in the current line. + current_position = max(0, current_position - 1) + else: + if token == '\n': + # Capture the current line. + cleaned_lines.append(current_line) + if token in ('\n', ANSI_ERASE_LINE): + # Clear the current line. + current_line = '' + current_position = 0 + elif token: + # Merge regular output into the current line. + new_position = current_position + len(token) + prefix = current_line[:current_position] + suffix = current_line[new_position:] + current_line = prefix + token + suffix + current_position = new_position + # Capture the last line (if any). + cleaned_lines.append(current_line) + # Remove any empty trailing lines. + while cleaned_lines and not cleaned_lines[-1]: + cleaned_lines.pop(-1) + return cleaned_lines + + +def connected_to_terminal(stream=None): + """ + Check if a stream is connected to a terminal. + + :param stream: The stream to check (a file-like object, + defaults to :data:`sys.stdout`). + :returns: :data:`True` if the stream is connected to a terminal, + :data:`False` otherwise. + + See also :func:`terminal_supports_colors()`. + """ + stream = sys.stdout if stream is None else stream + try: + return stream.isatty() + except Exception: + return False + + +@cached +def enable_ansi_support(): + """ + Try to enable support for ANSI escape sequences (required on Windows). + + :returns: :data:`True` if ANSI is supported, :data:`False` otherwise. + + This functions checks for the following supported configurations, in the + given order: + + 1. On Windows, if :func:`have_windows_native_ansi_support()` confirms + native support for ANSI escape sequences :mod:`ctypes` will be used to + enable this support. + + 2. On Windows, if the environment variable ``$ANSICON`` is set nothing is + done because it is assumed that support for ANSI escape sequences has + already been enabled via `ansicon `_. + + 3. On Windows, an attempt is made to import and initialize the Python + package :pypi:`colorama` instead (of course for this to work + :pypi:`colorama` has to be installed). + + 4. On other platforms this function calls :func:`connected_to_terminal()` + to determine whether ANSI escape sequences are supported (that is to + say all platforms that are not Windows are assumed to support ANSI + escape sequences natively, without weird contortions like above). + + This makes it possible to call :func:`enable_ansi_support()` + unconditionally without checking the current platform. + + The :func:`~humanfriendly.decorators.cached` decorator is used to ensure + that this function is only executed once, but its return value remains + available on later calls. + """ + if have_windows_native_ansi_support(): + import ctypes + ctypes.windll.kernel32.SetConsoleMode(ctypes.windll.kernel32.GetStdHandle(-11), 7) + ctypes.windll.kernel32.SetConsoleMode(ctypes.windll.kernel32.GetStdHandle(-12), 7) + return True + elif on_windows(): + if 'ANSICON' in os.environ: + return True + try: + import colorama + colorama.init() + return True + except ImportError: + return False + else: + return connected_to_terminal() + + +def find_terminal_size(): + """ + Determine the number of lines and columns visible in the terminal. + + :returns: A tuple of two integers with the line and column count. + + The result of this function is based on the first of the following three + methods that works: + + 1. First :func:`find_terminal_size_using_ioctl()` is tried, + 2. then :func:`find_terminal_size_using_stty()` is tried, + 3. finally :data:`DEFAULT_LINES` and :data:`DEFAULT_COLUMNS` are returned. + + .. note:: The :func:`find_terminal_size()` function performs the steps + above every time it is called, the result is not cached. This is + because the size of a virtual terminal can change at any time and + the result of :func:`find_terminal_size()` should be correct. + + `Pre-emptive snarky comment`_: It's possible to cache the result + of this function and use :mod:`signal.SIGWINCH ` to + refresh the cached values! + + Response: As a library I don't consider it the role of the + :mod:`humanfriendly.terminal` module to install a process wide + signal handler ... + + .. _Pre-emptive snarky comment: http://blogs.msdn.com/b/oldnewthing/archive/2008/01/30/7315957.aspx + """ + # The first method. Any of the standard streams may have been redirected + # somewhere and there's no telling which, so we'll just try them all. + for stream in sys.stdin, sys.stdout, sys.stderr: + try: + result = find_terminal_size_using_ioctl(stream) + if min(result) >= 1: + return result + except Exception: + pass + # The second method. + try: + result = find_terminal_size_using_stty() + if min(result) >= 1: + return result + except Exception: + pass + # Fall back to conservative defaults. + return DEFAULT_LINES, DEFAULT_COLUMNS + + +def find_terminal_size_using_ioctl(stream): + """ + Find the terminal size using :func:`fcntl.ioctl()`. + + :param stream: A stream connected to the terminal (a file object with a + ``fileno`` attribute). + :returns: A tuple of two integers with the line and column count. + :raises: This function can raise exceptions but I'm not going to document + them here, you should be using :func:`find_terminal_size()`. + + Based on an `implementation found on StackOverflow `_. + """ + if not HAVE_IOCTL: + raise NotImplementedError("It looks like the `fcntl' module is not available!") + h, w, hp, wp = struct.unpack('HHHH', fcntl.ioctl(stream, termios.TIOCGWINSZ, struct.pack('HHHH', 0, 0, 0, 0))) + return h, w + + +def find_terminal_size_using_stty(): + """ + Find the terminal size using the external command ``stty size``. + + :param stream: A stream connected to the terminal (a file object). + :returns: A tuple of two integers with the line and column count. + :raises: This function can raise exceptions but I'm not going to document + them here, you should be using :func:`find_terminal_size()`. + """ + stty = subprocess.Popen(['stty', 'size'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + stdout, stderr = stty.communicate() + tokens = stdout.split() + if len(tokens) != 2: + raise Exception("Invalid output from `stty size'!") + return tuple(map(int, tokens)) + + +def get_pager_command(text=None): + """ + Get the command to show a text on the terminal using a pager. + + :param text: The text to print to the terminal (a string). + :returns: A list of strings with the pager command and arguments. + + The use of a pager helps to avoid the wall of text effect where the user + has to scroll up to see where the output began (not very user friendly). + + If the given text contains ANSI escape sequences the command ``less + --RAW-CONTROL-CHARS`` is used, otherwise the environment variable + ``$PAGER`` is used (if ``$PAGER`` isn't set :man:`less` is used). + + When the selected pager is :man:`less`, the following options are used to + make the experience more user friendly: + + - ``--quit-if-one-screen`` causes :man:`less` to automatically exit if the + entire text can be displayed on the first screen. This makes the use of a + pager transparent for smaller texts (because the operator doesn't have to + quit the pager). + + - ``--no-init`` prevents :man:`less` from clearing the screen when it + exits. This ensures that the operator gets a chance to review the text + (for example a usage message) after quitting the pager, while composing + the next command. + """ + # Compose the pager command. + if text and ANSI_CSI in text: + command_line = ['less', '--RAW-CONTROL-CHARS'] + else: + command_line = [os.environ.get('PAGER', 'less')] + # Pass some additional options to `less' (to make it more + # user friendly) without breaking support for other pagers. + if os.path.basename(command_line[0]) == 'less': + command_line.append('--no-init') + command_line.append('--quit-if-one-screen') + return command_line + + +@cached +def have_windows_native_ansi_support(): + """ + Check if we're running on a Windows 10 release with native support for ANSI escape sequences. + + :returns: :data:`True` if so, :data:`False` otherwise. + + The :func:`~humanfriendly.decorators.cached` decorator is used as a minor + performance optimization. Semantically this should have zero impact because + the answer doesn't change in the lifetime of a computer process. + """ + if on_windows(): + try: + # I can't be 100% sure this will never break and I'm not in a + # position to test it thoroughly either, so I decided that paying + # the price of one additional try / except statement is worth the + # additional peace of mind :-). + components = tuple(int(c) for c in platform.version().split('.')) + return components >= (10, 0, 14393) + except Exception: + pass + return False + + +def message(text, *args, **kw): + """ + Print a formatted message to the standard error stream. + + For details about argument handling please refer to + :func:`~humanfriendly.text.format()`. + + Renders the message using :func:`~humanfriendly.text.format()` and writes + the resulting string (followed by a newline) to :data:`sys.stderr` using + :func:`auto_encode()`. + """ + auto_encode(sys.stderr, coerce_string(text) + '\n', *args, **kw) + + +def output(text, *args, **kw): + """ + Print a formatted message to the standard output stream. + + For details about argument handling please refer to + :func:`~humanfriendly.text.format()`. + + Renders the message using :func:`~humanfriendly.text.format()` and writes + the resulting string (followed by a newline) to :data:`sys.stdout` using + :func:`auto_encode()`. + """ + auto_encode(sys.stdout, coerce_string(text) + '\n', *args, **kw) + + +def readline_strip(expr): + """ + Remove `readline hints`_ from a string. + + :param text: The text to strip (a string). + :returns: The stripped text. + """ + return expr.replace('\001', '').replace('\002', '') + + +def readline_wrap(expr): + """ + Wrap an ANSI escape sequence in `readline hints`_. + + :param text: The text with the escape sequence to wrap (a string). + :returns: The wrapped text. + + .. _readline hints: http://superuser.com/a/301355 + """ + return '\001' + expr + '\002' + + +def show_pager(formatted_text, encoding=DEFAULT_ENCODING): + """ + Print a large text to the terminal using a pager. + + :param formatted_text: The text to print to the terminal (a string). + :param encoding: The name of the text encoding used to encode the formatted + text if the formatted text is a Unicode string (a string, + defaults to :data:`DEFAULT_ENCODING`). + + When :func:`connected_to_terminal()` returns :data:`True` a pager is used + to show the text on the terminal, otherwise the text is printed directly + without invoking a pager. + + The use of a pager helps to avoid the wall of text effect where the user + has to scroll up to see where the output began (not very user friendly). + + Refer to :func:`get_pager_command()` for details about the command line + that's used to invoke the pager. + """ + if connected_to_terminal(): + # Make sure the selected pager command is available. + command_line = get_pager_command(formatted_text) + if which(command_line[0]): + pager = subprocess.Popen(command_line, stdin=subprocess.PIPE) + if is_unicode(formatted_text): + formatted_text = formatted_text.encode(encoding) + pager.communicate(input=formatted_text) + return + output(formatted_text) + + +def terminal_supports_colors(stream=None): + """ + Check if a stream is connected to a terminal that supports ANSI escape sequences. + + :param stream: The stream to check (a file-like object, + defaults to :data:`sys.stdout`). + :returns: :data:`True` if the terminal supports ANSI escape sequences, + :data:`False` otherwise. + + This function was originally inspired by the implementation of + `django.core.management.color.supports_color() + `_ + but has since evolved significantly. + """ + if on_windows(): + # On Windows support for ANSI escape sequences is not a given. + have_ansicon = 'ANSICON' in os.environ + have_colorama = 'colorama' in sys.modules + have_native_support = have_windows_native_ansi_support() + if not (have_ansicon or have_colorama or have_native_support): + return False + return connected_to_terminal(stream) + + +def usage(usage_text): + """ + Print a human friendly usage message to the terminal. + + :param text: The usage message to print (a string). + + This function does two things: + + 1. If :data:`sys.stdout` is connected to a terminal (see + :func:`connected_to_terminal()`) then the usage message is formatted + using :func:`.format_usage()`. + 2. The usage message is shown using a pager (see :func:`show_pager()`). + """ + if terminal_supports_colors(sys.stdout): + usage_text = format_usage(usage_text) + show_pager(usage_text) + + +def warning(text, *args, **kw): + """ + Show a warning message on the terminal. + + For details about argument handling please refer to + :func:`~humanfriendly.text.format()`. + + Renders the message using :func:`~humanfriendly.text.format()` and writes + the resulting string (followed by a newline) to :data:`sys.stderr` using + :func:`auto_encode()`. + + If :data:`sys.stderr` is connected to a terminal that supports colors, + :func:`ansi_wrap()` is used to color the message in a red font (to make + the warning stand out from surrounding text). + """ + text = coerce_string(text) + if terminal_supports_colors(sys.stderr): + text = ansi_wrap(text, color='red') + auto_encode(sys.stderr, text + '\n', *args, **kw) + + +# Define aliases for backwards compatibility. +define_aliases( + module_name=__name__, + # In humanfriendly 1.31 the find_meta_variables() and format_usage() + # functions were extracted to the new module humanfriendly.usage. + find_meta_variables='humanfriendly.usage.find_meta_variables', + format_usage='humanfriendly.usage.format_usage', + # In humanfriendly 8.0 the html_to_ansi() function and HTMLConverter + # class were extracted to the new module humanfriendly.terminal.html. + html_to_ansi='humanfriendly.terminal.html.html_to_ansi', + HTMLConverter='humanfriendly.terminal.html.HTMLConverter', +) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/html.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/html.py new file mode 100644 index 0000000000000000000000000000000000000000..4214e09e7069a8a3e4a96cdc870c78db91f4fe13 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/html.py @@ -0,0 +1,423 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: February 29, 2020 +# URL: https://humanfriendly.readthedocs.io + +"""Convert HTML with simple text formatting to text with ANSI escape sequences.""" + +# Standard library modules. +import re + +# Modules included in our package. +from humanfriendly.compat import HTMLParser, StringIO, name2codepoint, unichr +from humanfriendly.text import compact_empty_lines +from humanfriendly.terminal import ANSI_COLOR_CODES, ANSI_RESET, ansi_style + +# Public identifiers that require documentation. +__all__ = ('HTMLConverter', 'html_to_ansi') + + +def html_to_ansi(data, callback=None): + """ + Convert HTML with simple text formatting to text with ANSI escape sequences. + + :param data: The HTML to convert (a string). + :param callback: Optional callback to pass to :class:`HTMLConverter`. + :returns: Text with ANSI escape sequences (a string). + + Please refer to the documentation of the :class:`HTMLConverter` class for + details about the conversion process (like which tags are supported) and an + example with a screenshot. + """ + converter = HTMLConverter(callback=callback) + return converter(data) + + +class HTMLConverter(HTMLParser): + + """ + Convert HTML with simple text formatting to text with ANSI escape sequences. + + The following text styles are supported: + + - Bold: ````, ```` and ```` + - Italic: ````, ```` and ```` + - Strike-through: ````, ```` and ```` + - Underline: ````, ```` and ```` + + Colors can be specified as follows: + + - Foreground color: ```` + - Background color: ```` + + Here's a small demonstration: + + .. code-block:: python + + from humanfriendly.text import dedent + from humanfriendly.terminal import html_to_ansi + + print(html_to_ansi(dedent(''' + Hello world! + Is this thing on? + I guess I can underline or strike-through text? + And what about color? + '''))) + + rainbow_colors = [ + '#FF0000', '#E2571E', '#FF7F00', '#FFFF00', '#00FF00', + '#96BF33', '#0000FF', '#4B0082', '#8B00FF', '#FFFFFF', + ] + html_rainbow = "".join('o' % c for c in rainbow_colors) + print(html_to_ansi("Let's try a rainbow: %s" % html_rainbow)) + + Here's what the results look like: + + .. image:: images/html-to-ansi.png + + Some more details: + + - Nested tags are supported, within reasonable limits. + + - Text in ```` and ``
`` tags will be highlighted in a
+      different color from the main text (currently this is yellow).
+
+    - ``TEXT`` is converted to the format "TEXT (URL)" where
+      the uppercase symbols are highlighted in light blue with an underline.
+
+    - ``
``, ``

`` and ``

`` tags are considered block level tags
+      and are wrapped in vertical whitespace to prevent their content from
+      "running into" surrounding text. This may cause runs of multiple empty
+      lines to be emitted. As a *workaround* the :func:`__call__()` method
+      will automatically call :func:`.compact_empty_lines()` on the generated
+      output before returning it to the caller. Of course this won't work
+      when `output` is set to something like :data:`sys.stdout`.
+
+    - ``
`` is converted to a single plain text line break. + + Implementation notes: + + - A list of dictionaries with style information is used as a stack where + new styling can be pushed and a pop will restore the previous styling. + When new styling is pushed, it is merged with (but overrides) the current + styling. + + - If you're going to be converting a lot of HTML it might be useful from + a performance standpoint to re-use an existing :class:`HTMLConverter` + object for unrelated HTML fragments, in this case take a look at the + :func:`__call__()` method (it makes this use case very easy). + + .. versionadded:: 4.15 + :class:`humanfriendly.terminal.HTMLConverter` was added to the + `humanfriendly` package during the initial development of my new + `chat-archive `_ project, whose + command line interface makes for a great demonstration of the + flexibility that this feature provides (hint: check out how the search + keyword highlighting combines with the regular highlighting). + """ + + BLOCK_TAGS = ('div', 'p', 'pre') + """The names of tags that are padded with vertical whitespace.""" + + def __init__(self, *args, **kw): + """ + Initialize an :class:`HTMLConverter` object. + + :param callback: Optional keyword argument to specify a function that + will be called to process text fragments before they + are emitted on the output stream. Note that link text + and preformatted text fragments are not processed by + this callback. + :param output: Optional keyword argument to redirect the output to the + given file-like object. If this is not given a new + :class:`~python3:io.StringIO` object is created. + """ + # Hide our optional keyword arguments from the superclass. + self.callback = kw.pop("callback", None) + self.output = kw.pop("output", None) + # Initialize the superclass. + HTMLParser.__init__(self, *args, **kw) + + def __call__(self, data): + """ + Reset the parser, convert some HTML and get the text with ANSI escape sequences. + + :param data: The HTML to convert to text (a string). + :returns: The converted text (only in case `output` is + a :class:`~python3:io.StringIO` object). + """ + self.reset() + self.feed(data) + self.close() + if isinstance(self.output, StringIO): + return compact_empty_lines(self.output.getvalue()) + + @property + def current_style(self): + """Get the current style from the top of the stack (a dictionary).""" + return self.stack[-1] if self.stack else {} + + def close(self): + """ + Close previously opened ANSI escape sequences. + + This method overrides the same method in the superclass to ensure that + an :data:`.ANSI_RESET` code is emitted when parsing reaches the end of + the input but a style is still active. This is intended to prevent + malformed HTML from messing up terminal output. + """ + if any(self.stack): + self.output.write(ANSI_RESET) + self.stack = [] + HTMLParser.close(self) + + def emit_style(self, style=None): + """ + Emit an ANSI escape sequence for the given or current style to the output stream. + + :param style: A dictionary with arguments for :func:`.ansi_style()` or + :data:`None`, in which case the style at the top of the + stack is emitted. + """ + # Clear the current text styles. + self.output.write(ANSI_RESET) + # Apply a new text style? + style = self.current_style if style is None else style + if style: + self.output.write(ansi_style(**style)) + + def handle_charref(self, value): + """ + Process a decimal or hexadecimal numeric character reference. + + :param value: The decimal or hexadecimal value (a string). + """ + self.output.write(unichr(int(value[1:], 16) if value.startswith('x') else int(value))) + + def handle_data(self, data): + """ + Process textual data. + + :param data: The decoded text (a string). + """ + if self.link_url: + # Link text is captured literally so that we can reliably check + # whether the text and the URL of the link are the same string. + self.link_text = data + elif self.callback and self.preformatted_text_level == 0: + # Text that is not part of a link and not preformatted text is + # passed to the user defined callback to allow for arbitrary + # pre-processing. + data = self.callback(data) + # All text is emitted unmodified on the output stream. + self.output.write(data) + + def handle_endtag(self, tag): + """ + Process the end of an HTML tag. + + :param tag: The name of the tag (a string). + """ + if tag in ('a', 'b', 'code', 'del', 'em', 'i', 'ins', 'pre', 's', 'strong', 'span', 'u'): + old_style = self.current_style + # The following conditional isn't necessary for well formed + # HTML but prevents raising exceptions on malformed HTML. + if self.stack: + self.stack.pop(-1) + new_style = self.current_style + if tag == 'a': + if self.urls_match(self.link_text, self.link_url): + # Don't render the URL when it's part of the link text. + self.emit_style(new_style) + else: + self.emit_style(new_style) + self.output.write(' (') + self.emit_style(old_style) + self.output.write(self.render_url(self.link_url)) + self.emit_style(new_style) + self.output.write(')') + else: + self.emit_style(new_style) + if tag in ('code', 'pre'): + self.preformatted_text_level -= 1 + if tag in self.BLOCK_TAGS: + # Emit an empty line after block level tags. + self.output.write('\n\n') + + def handle_entityref(self, name): + """ + Process a named character reference. + + :param name: The name of the character reference (a string). + """ + self.output.write(unichr(name2codepoint[name])) + + def handle_starttag(self, tag, attrs): + """ + Process the start of an HTML tag. + + :param tag: The name of the tag (a string). + :param attrs: A list of tuples with two strings each. + """ + if tag in self.BLOCK_TAGS: + # Emit an empty line before block level tags. + self.output.write('\n\n') + if tag == 'a': + self.push_styles(color='blue', bright=True, underline=True) + # Store the URL that the link points to for later use, so that we + # can render the link text before the URL (with the reasoning that + # this is the most intuitive way to present a link in a plain text + # interface). + self.link_url = next((v for n, v in attrs if n == 'href'), '') + elif tag == 'b' or tag == 'strong': + self.push_styles(bold=True) + elif tag == 'br': + self.output.write('\n') + elif tag == 'code' or tag == 'pre': + self.push_styles(color='yellow') + self.preformatted_text_level += 1 + elif tag == 'del' or tag == 's': + self.push_styles(strike_through=True) + elif tag == 'em' or tag == 'i': + self.push_styles(italic=True) + elif tag == 'ins' or tag == 'u': + self.push_styles(underline=True) + elif tag == 'span': + styles = {} + css = next((v for n, v in attrs if n == 'style'), "") + for rule in css.split(';'): + name, _, value = rule.partition(':') + name = name.strip() + value = value.strip() + if name == 'background-color': + styles['background'] = self.parse_color(value) + elif name == 'color': + styles['color'] = self.parse_color(value) + elif name == 'font-style' and value == 'italic': + styles['italic'] = True + elif name == 'font-weight' and value == 'bold': + styles['bold'] = True + elif name == 'text-decoration' and value == 'line-through': + styles['strike_through'] = True + elif name == 'text-decoration' and value == 'underline': + styles['underline'] = True + self.push_styles(**styles) + + def normalize_url(self, url): + """ + Normalize a URL to enable string equality comparison. + + :param url: The URL to normalize (a string). + :returns: The normalized URL (a string). + """ + return re.sub('^mailto:', '', url) + + def parse_color(self, value): + """ + Convert a CSS color to something that :func:`.ansi_style()` understands. + + :param value: A string like ``rgb(1,2,3)``, ``#AABBCC`` or ``yellow``. + :returns: A color value supported by :func:`.ansi_style()` or :data:`None`. + """ + # Parse an 'rgb(N,N,N)' expression. + if value.startswith('rgb'): + tokens = re.findall(r'\d+', value) + if len(tokens) == 3: + return tuple(map(int, tokens)) + # Parse an '#XXXXXX' expression. + elif value.startswith('#'): + value = value[1:] + length = len(value) + if length == 6: + # Six hex digits (proper notation). + return ( + int(value[:2], 16), + int(value[2:4], 16), + int(value[4:6], 16), + ) + elif length == 3: + # Three hex digits (shorthand). + return ( + int(value[0], 16), + int(value[1], 16), + int(value[2], 16), + ) + # Try to recognize a named color. + value = value.lower() + if value in ANSI_COLOR_CODES: + return value + + def push_styles(self, **changes): + """ + Push new style information onto the stack. + + :param changes: Any keyword arguments are passed on to :func:`.ansi_style()`. + + This method is a helper for :func:`handle_starttag()` + that does the following: + + 1. Make a copy of the current styles (from the top of the stack), + 2. Apply the given `changes` to the copy of the current styles, + 3. Add the new styles to the stack, + 4. Emit the appropriate ANSI escape sequence to the output stream. + """ + prototype = self.current_style + if prototype: + new_style = dict(prototype) + new_style.update(changes) + else: + new_style = changes + self.stack.append(new_style) + self.emit_style(new_style) + + def render_url(self, url): + """ + Prepare a URL for rendering on the terminal. + + :param url: The URL to simplify (a string). + :returns: The simplified URL (a string). + + This method pre-processes a URL before rendering on the terminal. The + following modifications are made: + + - The ``mailto:`` prefix is stripped. + - Spaces are converted to ``%20``. + - A trailing parenthesis is converted to ``%29``. + """ + url = re.sub('^mailto:', '', url) + url = re.sub(' ', '%20', url) + url = re.sub(r'\)$', '%29', url) + return url + + def reset(self): + """ + Reset the state of the HTML parser and ANSI converter. + + When `output` is a :class:`~python3:io.StringIO` object a new + instance will be created (and the old one garbage collected). + """ + # Reset the state of the superclass. + HTMLParser.reset(self) + # Reset our instance variables. + self.link_text = None + self.link_url = None + self.preformatted_text_level = 0 + if self.output is None or isinstance(self.output, StringIO): + # If the caller specified something like output=sys.stdout then it + # doesn't make much sense to negate that choice here in reset(). + self.output = StringIO() + self.stack = [] + + def urls_match(self, a, b): + """ + Compare two URLs for equality using :func:`normalize_url()`. + + :param a: A string containing a URL. + :param b: A string containing a URL. + :returns: :data:`True` if the URLs are the same, :data:`False` otherwise. + + This method is used by :func:`handle_endtag()` to omit the URL of a + hyperlink (````) when the link text is that same URL. + """ + return self.normalize_url(a) == self.normalize_url(b) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/spinners.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/spinners.py new file mode 100644 index 0000000000000000000000000000000000000000..e4dc55d3026790bf0b5e3e5f48f88373868804b5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/terminal/spinners.py @@ -0,0 +1,310 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: March 1, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Support for spinners that represent progress on interactive terminals. + +The :class:`Spinner` class shows a "spinner" on the terminal to let the user +know that something is happening during long running operations that would +otherwise be silent (leaving the user to wonder what they're waiting for). +Below are some visual examples that should illustrate the point. + +**Simple spinners:** + + Here's a screen capture that shows the simplest form of spinner: + + .. image:: images/spinner-basic.gif + :alt: Animated screen capture of a simple spinner. + + The following code was used to create the spinner above: + + .. code-block:: python + + import itertools + import time + from humanfriendly import Spinner + + with Spinner(label="Downloading") as spinner: + for i in itertools.count(): + # Do something useful here. + time.sleep(0.1) + # Advance the spinner. + spinner.step() + +**Spinners that show elapsed time:** + + Here's a spinner that shows the elapsed time since it started: + + .. image:: images/spinner-with-timer.gif + :alt: Animated screen capture of a spinner showing elapsed time. + + The following code was used to create the spinner above: + + .. code-block:: python + + import itertools + import time + from humanfriendly import Spinner, Timer + + with Spinner(label="Downloading", timer=Timer()) as spinner: + for i in itertools.count(): + # Do something useful here. + time.sleep(0.1) + # Advance the spinner. + spinner.step() + +**Spinners that show progress:** + + Here's a spinner that shows a progress percentage: + + .. image:: images/spinner-with-progress.gif + :alt: Animated screen capture of spinner showing progress. + + The following code was used to create the spinner above: + + .. code-block:: python + + import itertools + import random + import time + from humanfriendly import Spinner, Timer + + with Spinner(label="Downloading", total=100) as spinner: + progress = 0 + while progress < 100: + # Do something useful here. + time.sleep(0.1) + # Advance the spinner. + spinner.step(progress) + # Determine the new progress value. + progress += random.random() * 5 + +If you want to provide user feedback during a long running operation but it's +not practical to periodically call the :func:`~Spinner.step()` method consider +using :class:`AutomaticSpinner` instead. + +As you may already have noticed in the examples above, :class:`Spinner` objects +can be used as context managers to automatically call :func:`Spinner.clear()` +when the spinner ends. +""" + +# Standard library modules. +import multiprocessing +import sys +import time + +# Modules included in our package. +from humanfriendly import Timer +from humanfriendly.deprecation import deprecated_args +from humanfriendly.terminal import ANSI_ERASE_LINE + +# Public identifiers that require documentation. +__all__ = ("AutomaticSpinner", "GLYPHS", "MINIMUM_INTERVAL", "Spinner") + +GLYPHS = ["-", "\\", "|", "/"] +"""A list of strings with characters that together form a crude animation :-).""" + +MINIMUM_INTERVAL = 0.2 +"""Spinners are redrawn with a frequency no higher than this number (a floating point number of seconds).""" + + +class Spinner(object): + + """Show a spinner on the terminal as a simple means of feedback to the user.""" + + @deprecated_args('label', 'total', 'stream', 'interactive', 'timer') + def __init__(self, **options): + """ + Initialize a :class:`Spinner` object. + + :param label: + + The label for the spinner (a string or :data:`None`, defaults to + :data:`None`). + + :param total: + + The expected number of steps (an integer or :data:`None`). If this is + provided the spinner will show a progress percentage. + + :param stream: + + The output stream to show the spinner on (a file-like object, + defaults to :data:`sys.stderr`). + + :param interactive: + + :data:`True` to enable rendering of the spinner, :data:`False` to + disable (defaults to the result of ``stream.isatty()``). + + :param timer: + + A :class:`.Timer` object (optional). If this is given the spinner + will show the elapsed time according to the timer. + + :param interval: + + The spinner will be updated at most once every this many seconds + (a floating point number, defaults to :data:`MINIMUM_INTERVAL`). + + :param glyphs: + + A list of strings with single characters that are drawn in the same + place in succession to implement a simple animated effect (defaults + to :data:`GLYPHS`). + """ + # Store initializer arguments. + self.interactive = options.get('interactive') + self.interval = options.get('interval', MINIMUM_INTERVAL) + self.label = options.get('label') + self.states = options.get('glyphs', GLYPHS) + self.stream = options.get('stream', sys.stderr) + self.timer = options.get('timer') + self.total = options.get('total') + # Define instance variables. + self.counter = 0 + self.last_update = 0 + # Try to automatically discover whether the stream is connected to + # a terminal, but don't fail if no isatty() method is available. + if self.interactive is None: + try: + self.interactive = self.stream.isatty() + except Exception: + self.interactive = False + + def step(self, progress=0, label=None): + """ + Advance the spinner by one step and redraw it. + + :param progress: The number of the current step, relative to the total + given to the :class:`Spinner` constructor (an integer, + optional). If not provided the spinner will not show + progress. + :param label: The label to use while redrawing (a string, optional). If + not provided the label given to the :class:`Spinner` + constructor is used instead. + + This method advances the spinner by one step without starting a new + line, causing an animated effect which is very simple but much nicer + than waiting for a prompt which is completely silent for a long time. + + .. note:: This method uses time based rate limiting to avoid redrawing + the spinner too frequently. If you know you're dealing with + code that will call :func:`step()` at a high frequency, + consider using :func:`sleep()` to avoid creating the + equivalent of a busy loop that's rate limiting the spinner + 99% of the time. + """ + if self.interactive: + time_now = time.time() + if time_now - self.last_update >= self.interval: + self.last_update = time_now + state = self.states[self.counter % len(self.states)] + label = label or self.label + if not label: + raise Exception("No label set for spinner!") + elif self.total and progress: + label = "%s: %.2f%%" % (label, progress / (self.total / 100.0)) + elif self.timer and self.timer.elapsed_time > 2: + label = "%s (%s)" % (label, self.timer.rounded) + self.stream.write("%s %s %s ..\r" % (ANSI_ERASE_LINE, state, label)) + self.counter += 1 + + def sleep(self): + """ + Sleep for a short period before redrawing the spinner. + + This method is useful when you know you're dealing with code that will + call :func:`step()` at a high frequency. It will sleep for the interval + with which the spinner is redrawn (less than a second). This avoids + creating the equivalent of a busy loop that's rate limiting the + spinner 99% of the time. + + This method doesn't redraw the spinner, you still have to call + :func:`step()` in order to do that. + """ + time.sleep(MINIMUM_INTERVAL) + + def clear(self): + """ + Clear the spinner. + + The next line which is shown on the standard output or error stream + after calling this method will overwrite the line that used to show the + spinner. + """ + if self.interactive: + self.stream.write(ANSI_ERASE_LINE) + + def __enter__(self): + """ + Enable the use of spinners as context managers. + + :returns: The :class:`Spinner` object. + """ + return self + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Clear the spinner when leaving the context.""" + self.clear() + + +class AutomaticSpinner(object): + + """ + Show a spinner on the terminal that automatically starts animating. + + This class shows a spinner on the terminal (just like :class:`Spinner` + does) that automatically starts animating. This class should be used as a + context manager using the :keyword:`with` statement. The animation + continues for as long as the context is active. + + :class:`AutomaticSpinner` provides an alternative to :class:`Spinner` + for situations where it is not practical for the caller to periodically + call :func:`~Spinner.step()` to advance the animation, e.g. because + you're performing a blocking call and don't fancy implementing threading or + subprocess handling just to provide some user feedback. + + This works using the :mod:`multiprocessing` module by spawning a + subprocess to render the spinner while the main process is busy doing + something more useful. By using the :keyword:`with` statement you're + guaranteed that the subprocess is properly terminated at the appropriate + time. + """ + + def __init__(self, label, show_time=True): + """ + Initialize an automatic spinner. + + :param label: The label for the spinner (a string). + :param show_time: If this is :data:`True` (the default) then the spinner + shows elapsed time. + """ + self.label = label + self.show_time = show_time + self.shutdown_event = multiprocessing.Event() + self.subprocess = multiprocessing.Process(target=self._target) + + def __enter__(self): + """Enable the use of automatic spinners as context managers.""" + self.subprocess.start() + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Enable the use of automatic spinners as context managers.""" + self.shutdown_event.set() + self.subprocess.join() + + def _target(self): + try: + timer = Timer() if self.show_time else None + with Spinner(label=self.label, timer=timer) as spinner: + while not self.shutdown_event.is_set(): + spinner.step() + spinner.sleep() + except KeyboardInterrupt: + # Swallow Control-C signals without producing a nasty traceback that + # won't make any sense to the average user. + pass diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/testing.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/testing.py new file mode 100644 index 0000000000000000000000000000000000000000..f6abddf07423faacdef2059601a9d52155c498e5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/testing.py @@ -0,0 +1,669 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: March 6, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Utility classes and functions that make it easy to write :mod:`unittest` compatible test suites. + +Over the years I've developed the habit of writing test suites for Python +projects using the :mod:`unittest` module. During those years I've come to know +:pypi:`pytest` and in fact I use :pypi:`pytest` to run my test suites (due to +its much better error reporting) but I've yet to publish a test suite that +*requires* :pypi:`pytest`. I have several reasons for doing so: + +- It's nice to keep my test suites as simple and accessible as possible and + not requiring a specific test runner is part of that attitude. + +- Whereas :mod:`unittest` is quite explicit, :pypi:`pytest` contains a lot of + magic, which kind of contradicts the Python mantra "explicit is better than + implicit" (IMHO). +""" + +# Standard library module +import functools +import logging +import os +import pipes +import shutil +import sys +import tempfile +import time +import unittest + +# Modules included in our package. +from humanfriendly.compat import StringIO +from humanfriendly.text import random_string + +# Initialize a logger for this module. +logger = logging.getLogger(__name__) + +# A unique object reference used to detect missing attributes. +NOTHING = object() + +# Public identifiers that require documentation. +__all__ = ( + 'CallableTimedOut', + 'CaptureBuffer', + 'CaptureOutput', + 'ContextManager', + 'CustomSearchPath', + 'MockedProgram', + 'PatchedAttribute', + 'PatchedItem', + 'TemporaryDirectory', + 'TestCase', + 'configure_logging', + 'make_dirs', + 'retry', + 'run_cli', + 'skip_on_raise', + 'touch', +) + + +def configure_logging(log_level=logging.DEBUG): + """configure_logging(log_level=logging.DEBUG) + Automatically configure logging to the terminal. + + :param log_level: The log verbosity (a number, defaults + to :mod:`logging.DEBUG `). + + When :mod:`coloredlogs` is installed :func:`coloredlogs.install()` will be + used to configure logging to the terminal. When this fails with an + :exc:`~exceptions.ImportError` then :func:`logging.basicConfig()` is used + as a fall back. + """ + try: + import coloredlogs + coloredlogs.install(level=log_level) + except ImportError: + logging.basicConfig( + level=log_level, + format='%(asctime)s %(name)s[%(process)d] %(levelname)s %(message)s', + datefmt='%Y-%m-%d %H:%M:%S') + + +def make_dirs(pathname): + """ + Create missing directories. + + :param pathname: The pathname of a directory (a string). + """ + if not os.path.isdir(pathname): + os.makedirs(pathname) + + +def retry(func, timeout=60, exc_type=AssertionError): + """retry(func, timeout=60, exc_type=AssertionError) + Retry a function until assertions no longer fail. + + :param func: A callable. When the callable returns + :data:`False` it will also be retried. + :param timeout: The number of seconds after which to abort (a number, + defaults to 60). + :param exc_type: The type of exceptions to retry (defaults + to :exc:`~exceptions.AssertionError`). + :returns: The value returned by `func`. + :raises: Once the timeout has expired :func:`retry()` will raise the + previously retried assertion error. When `func` keeps returning + :data:`False` until `timeout` expires :exc:`CallableTimedOut` + will be raised. + + This function sleeps between retries to avoid claiming CPU cycles we don't + need. It starts by sleeping for 0.1 second but adjusts this to one second + as the number of retries grows. + """ + pause = 0.1 + timeout += time.time() + while True: + try: + result = func() + if result is not False: + return result + except exc_type: + if time.time() > timeout: + raise + else: + if time.time() > timeout: + raise CallableTimedOut() + time.sleep(pause) + if pause < 1: + pause *= 2 + + +def run_cli(entry_point, *arguments, **options): + """ + Test a command line entry point. + + :param entry_point: The function that implements the command line interface + (a callable). + :param arguments: Any positional arguments (strings) become the command + line arguments (:data:`sys.argv` items 1-N). + :param options: The following keyword arguments are supported: + + **capture** + Whether to use :class:`CaptureOutput`. Defaults + to :data:`True` but can be disabled by passing + :data:`False` instead. + **input** + Refer to :class:`CaptureOutput`. + **merged** + Refer to :class:`CaptureOutput`. + **program_name** + Used to set :data:`sys.argv` item 0. + :returns: A tuple with two values: + + 1. The return code (an integer). + 2. The captured output (a string). + """ + # Add the `program_name' option to the arguments. + arguments = list(arguments) + arguments.insert(0, options.pop('program_name', sys.executable)) + # Log the command line arguments (and the fact that we're about to call the + # command line entry point function). + logger.debug("Calling command line entry point with arguments: %s", arguments) + # Prepare to capture the return code and output even if the command line + # interface raises an exception (whether the exception type is SystemExit + # or something else). + returncode = 0 + stdout = None + stderr = None + try: + # Temporarily override sys.argv. + with PatchedAttribute(sys, 'argv', arguments): + # Manipulate the standard input/output/error streams? + options['enabled'] = options.pop('capture', True) + with CaptureOutput(**options) as capturer: + try: + # Call the command line interface. + entry_point() + finally: + # Get the output even if an exception is raised. + stdout = capturer.stdout.getvalue() + stderr = capturer.stderr.getvalue() + # Reconfigure logging to the terminal because it is very + # likely that the entry point function has changed the + # configured log level. + configure_logging() + except BaseException as e: + if isinstance(e, SystemExit): + logger.debug("Intercepting return code %s from SystemExit exception.", e.code) + returncode = e.code + else: + logger.warning("Defaulting return code to 1 due to raised exception.", exc_info=True) + returncode = 1 + else: + logger.debug("Command line entry point returned successfully!") + # Always log the output captured on stdout/stderr, to make it easier to + # diagnose test failures (but avoid duplicate logging when merged=True). + is_merged = options.get('merged', False) + merged_streams = [('merged streams', stdout)] + separate_streams = [('stdout', stdout), ('stderr', stderr)] + streams = merged_streams if is_merged else separate_streams + for name, value in streams: + if value: + logger.debug("Output on %s:\n%s", name, value) + else: + logger.debug("No output on %s.", name) + return returncode, stdout + + +def skip_on_raise(*exc_types): + """ + Decorate a test function to translation specific exception types to :exc:`unittest.SkipTest`. + + :param exc_types: One or more positional arguments give the exception + types to be translated to :exc:`unittest.SkipTest`. + :returns: A decorator function specialized to `exc_types`. + """ + def decorator(function): + @functools.wraps(function) + def wrapper(*args, **kw): + try: + return function(*args, **kw) + except exc_types as e: + logger.debug("Translating exception to unittest.SkipTest ..", exc_info=True) + raise unittest.SkipTest("skipping test because %s was raised" % type(e)) + return wrapper + return decorator + + +def touch(filename): + """ + The equivalent of the UNIX :man:`touch` program in Python. + + :param filename: The pathname of the file to touch (a string). + + Note that missing directories are automatically created using + :func:`make_dirs()`. + """ + make_dirs(os.path.dirname(filename)) + with open(filename, 'a'): + os.utime(filename, None) + + +class CallableTimedOut(Exception): + + """Raised by :func:`retry()` when the timeout expires.""" + + +class ContextManager(object): + + """Base class to enable composition of context managers.""" + + def __enter__(self): + """Enable use as context managers.""" + return self + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Enable use as context managers.""" + + +class PatchedAttribute(ContextManager): + + """Context manager that temporary replaces an object attribute using :func:`setattr()`.""" + + def __init__(self, obj, name, value): + """ + Initialize a :class:`PatchedAttribute` object. + + :param obj: The object to patch. + :param name: An attribute name. + :param value: The value to set. + """ + self.object_to_patch = obj + self.attribute_to_patch = name + self.patched_value = value + self.original_value = NOTHING + + def __enter__(self): + """ + Replace (patch) the attribute. + + :returns: The object whose attribute was patched. + """ + # Enable composition of context managers. + super(PatchedAttribute, self).__enter__() + # Patch the object's attribute. + self.original_value = getattr(self.object_to_patch, self.attribute_to_patch, NOTHING) + setattr(self.object_to_patch, self.attribute_to_patch, self.patched_value) + return self.object_to_patch + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Restore the attribute to its original value.""" + # Enable composition of context managers. + super(PatchedAttribute, self).__exit__(exc_type, exc_value, traceback) + # Restore the object's attribute. + if self.original_value is NOTHING: + delattr(self.object_to_patch, self.attribute_to_patch) + else: + setattr(self.object_to_patch, self.attribute_to_patch, self.original_value) + + +class PatchedItem(ContextManager): + + """Context manager that temporary replaces an object item using :meth:`~object.__setitem__()`.""" + + def __init__(self, obj, item, value): + """ + Initialize a :class:`PatchedItem` object. + + :param obj: The object to patch. + :param item: The item to patch. + :param value: The value to set. + """ + self.object_to_patch = obj + self.item_to_patch = item + self.patched_value = value + self.original_value = NOTHING + + def __enter__(self): + """ + Replace (patch) the item. + + :returns: The object whose item was patched. + """ + # Enable composition of context managers. + super(PatchedItem, self).__enter__() + # Patch the object's item. + try: + self.original_value = self.object_to_patch[self.item_to_patch] + except KeyError: + self.original_value = NOTHING + self.object_to_patch[self.item_to_patch] = self.patched_value + return self.object_to_patch + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Restore the item to its original value.""" + # Enable composition of context managers. + super(PatchedItem, self).__exit__(exc_type, exc_value, traceback) + # Restore the object's item. + if self.original_value is NOTHING: + del self.object_to_patch[self.item_to_patch] + else: + self.object_to_patch[self.item_to_patch] = self.original_value + + +class TemporaryDirectory(ContextManager): + + """ + Easy temporary directory creation & cleanup using the :keyword:`with` statement. + + Here's an example of how to use this: + + .. code-block:: python + + with TemporaryDirectory() as directory: + # Do something useful here. + assert os.path.isdir(directory) + """ + + def __init__(self, **options): + """ + Initialize a :class:`TemporaryDirectory` object. + + :param options: Any keyword arguments are passed on to + :func:`tempfile.mkdtemp()`. + """ + self.mkdtemp_options = options + self.temporary_directory = None + + def __enter__(self): + """ + Create the temporary directory using :func:`tempfile.mkdtemp()`. + + :returns: The pathname of the directory (a string). + """ + # Enable composition of context managers. + super(TemporaryDirectory, self).__enter__() + # Create the temporary directory. + self.temporary_directory = tempfile.mkdtemp(**self.mkdtemp_options) + return self.temporary_directory + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Cleanup the temporary directory using :func:`shutil.rmtree()`.""" + # Enable composition of context managers. + super(TemporaryDirectory, self).__exit__(exc_type, exc_value, traceback) + # Cleanup the temporary directory. + if self.temporary_directory is not None: + shutil.rmtree(self.temporary_directory) + self.temporary_directory = None + + +class MockedHomeDirectory(PatchedItem, TemporaryDirectory): + + """ + Context manager to temporarily change ``$HOME`` (the current user's profile directory). + + This class is a composition of the :class:`PatchedItem` and + :class:`TemporaryDirectory` context managers. + """ + + def __init__(self): + """Initialize a :class:`MockedHomeDirectory` object.""" + PatchedItem.__init__(self, os.environ, 'HOME', os.environ.get('HOME')) + TemporaryDirectory.__init__(self) + + def __enter__(self): + """ + Activate the custom ``$PATH``. + + :returns: The pathname of the directory that has + been added to ``$PATH`` (a string). + """ + # Get the temporary directory. + directory = TemporaryDirectory.__enter__(self) + # Override the value to patch now that we have + # the pathname of the temporary directory. + self.patched_value = directory + # Temporary patch $HOME. + PatchedItem.__enter__(self) + # Pass the pathname of the temporary directory to the caller. + return directory + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Deactivate the custom ``$HOME``.""" + super(MockedHomeDirectory, self).__exit__(exc_type, exc_value, traceback) + + +class CustomSearchPath(PatchedItem, TemporaryDirectory): + + """ + Context manager to temporarily customize ``$PATH`` (the executable search path). + + This class is a composition of the :class:`PatchedItem` and + :class:`TemporaryDirectory` context managers. + """ + + def __init__(self, isolated=False): + """ + Initialize a :class:`CustomSearchPath` object. + + :param isolated: :data:`True` to clear the original search path, + :data:`False` to add the temporary directory to the + start of the search path. + """ + # Initialize our own instance variables. + self.isolated_search_path = isolated + # Selectively initialize our superclasses. + PatchedItem.__init__(self, os.environ, 'PATH', self.current_search_path) + TemporaryDirectory.__init__(self) + + def __enter__(self): + """ + Activate the custom ``$PATH``. + + :returns: The pathname of the directory that has + been added to ``$PATH`` (a string). + """ + # Get the temporary directory. + directory = TemporaryDirectory.__enter__(self) + # Override the value to patch now that we have + # the pathname of the temporary directory. + self.patched_value = ( + directory if self.isolated_search_path + else os.pathsep.join([directory] + self.current_search_path.split(os.pathsep)) + ) + # Temporary patch the $PATH. + PatchedItem.__enter__(self) + # Pass the pathname of the temporary directory to the caller + # because they may want to `install' custom executables. + return directory + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Deactivate the custom ``$PATH``.""" + super(CustomSearchPath, self).__exit__(exc_type, exc_value, traceback) + + @property + def current_search_path(self): + """The value of ``$PATH`` or :data:`os.defpath` (a string).""" + return os.environ.get('PATH', os.defpath) + + +class MockedProgram(CustomSearchPath): + + """ + Context manager to mock the existence of a program (executable). + + This class extends the functionality of :class:`CustomSearchPath`. + """ + + def __init__(self, name, returncode=0, script=None): + """ + Initialize a :class:`MockedProgram` object. + + :param name: The name of the program (a string). + :param returncode: The return code that the program should emit (a + number, defaults to zero). + :param script: Shell script code to include in the mocked program (a + string or :data:`None`). This can be used to mock a + program that is expected to generate specific output. + """ + # Initialize our own instance variables. + self.program_name = name + self.program_returncode = returncode + self.program_script = script + self.program_signal_file = None + # Initialize our superclasses. + super(MockedProgram, self).__init__() + + def __enter__(self): + """ + Create the mock program. + + :returns: The pathname of the directory that has + been added to ``$PATH`` (a string). + """ + directory = super(MockedProgram, self).__enter__() + self.program_signal_file = os.path.join(directory, 'program-was-run-%s' % random_string(10)) + pathname = os.path.join(directory, self.program_name) + with open(pathname, 'w') as handle: + handle.write('#!/bin/sh\n') + handle.write('echo > %s\n' % pipes.quote(self.program_signal_file)) + if self.program_script: + handle.write('%s\n' % self.program_script.strip()) + handle.write('exit %i\n' % self.program_returncode) + os.chmod(pathname, 0o755) + return directory + + def __exit__(self, *args, **kw): + """ + Ensure that the mock program was run. + + :raises: :exc:`~exceptions.AssertionError` when + the mock program hasn't been run. + """ + try: + assert self.program_signal_file and os.path.isfile(self.program_signal_file), \ + ("It looks like %r was never run!" % self.program_name) + finally: + return super(MockedProgram, self).__exit__(*args, **kw) + + +class CaptureOutput(ContextManager): + + """ + Context manager that captures what's written to :data:`sys.stdout` and :data:`sys.stderr`. + + .. attribute:: stdin + + The :class:`~humanfriendly.compat.StringIO` object used to feed the standard input stream. + + .. attribute:: stdout + + The :class:`CaptureBuffer` object used to capture the standard output stream. + + .. attribute:: stderr + + The :class:`CaptureBuffer` object used to capture the standard error stream. + """ + + def __init__(self, merged=False, input='', enabled=True): + """ + Initialize a :class:`CaptureOutput` object. + + :param merged: :data:`True` to merge the streams, + :data:`False` to capture them separately. + :param input: The data that reads from :data:`sys.stdin` + should return (a string). + :param enabled: :data:`True` to enable capturing (the default), + :data:`False` otherwise. This makes it easy to + unconditionally use :class:`CaptureOutput` in + a :keyword:`with` block while preserving the + choice to opt out of capturing output. + """ + self.stdin = StringIO(input) + self.stdout = CaptureBuffer() + self.stderr = self.stdout if merged else CaptureBuffer() + self.patched_attributes = [] + if enabled: + self.patched_attributes.extend( + PatchedAttribute(sys, name, getattr(self, name)) + for name in ('stdin', 'stdout', 'stderr') + ) + + def __enter__(self): + """Start capturing what's written to :data:`sys.stdout` and :data:`sys.stderr`.""" + super(CaptureOutput, self).__enter__() + for context in self.patched_attributes: + context.__enter__() + return self + + def __exit__(self, exc_type=None, exc_value=None, traceback=None): + """Stop capturing what's written to :data:`sys.stdout` and :data:`sys.stderr`.""" + super(CaptureOutput, self).__exit__(exc_type, exc_value, traceback) + for context in self.patched_attributes: + context.__exit__(exc_type, exc_value, traceback) + + def get_lines(self): + """Get the contents of :attr:`stdout` split into separate lines.""" + return self.get_text().splitlines() + + def get_text(self): + """Get the contents of :attr:`stdout` as a Unicode string.""" + return self.stdout.get_text() + + def getvalue(self): + """Get the text written to :data:`sys.stdout`.""" + return self.stdout.getvalue() + + +class CaptureBuffer(StringIO): + + """ + Helper for :class:`CaptureOutput` to provide an easy to use API. + + The two methods defined by this subclass were specifically chosen to match + the names of the methods provided by my :pypi:`capturer` package which + serves a similar role as :class:`CaptureOutput` but knows how to simulate + an interactive terminal (tty). + """ + + def get_lines(self): + """Get the contents of the buffer split into separate lines.""" + return self.get_text().splitlines() + + def get_text(self): + """Get the contents of the buffer as a Unicode string.""" + return self.getvalue() + + +class TestCase(unittest.TestCase): + + """Subclass of :class:`unittest.TestCase` with automatic logging and other miscellaneous features.""" + + def __init__(self, *args, **kw): + """ + Initialize a :class:`TestCase` object. + + Any positional and/or keyword arguments are passed on to the + initializer of the superclass. + """ + super(TestCase, self).__init__(*args, **kw) + + def setUp(self, log_level=logging.DEBUG): + """setUp(log_level=logging.DEBUG) + Automatically configure logging to the terminal. + + :param log_level: Refer to :func:`configure_logging()`. + + The :func:`setUp()` method is automatically called by + :class:`unittest.TestCase` before each test method starts. + It does two things: + + - Logging to the terminal is configured using + :func:`configure_logging()`. + + - Before the test method starts a newline is emitted, to separate the + name of the test method (which will be printed to the terminal by + :mod:`unittest` or :pypi:`pytest`) from the first line of logging + output that the test method is likely going to generate. + """ + # Configure logging to the terminal. + configure_logging(log_level) + # Separate the name of the test method (printed by the superclass + # and/or py.test without a newline at the end) from the first line of + # logging output that the test method is likely going to generate. + sys.stderr.write("\n") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/tests.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/tests.py new file mode 100644 index 0000000000000000000000000000000000000000..72dad996b9f4623efbcd5161c160ebaf61c6fa4d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/tests.py @@ -0,0 +1,1495 @@ +#!/usr/bin/env python +# vim: fileencoding=utf-8 : + +# Tests for the `humanfriendly' package. +# +# Author: Peter Odding +# Last Change: June 11, 2021 +# URL: https://humanfriendly.readthedocs.io + +"""Test suite for the `humanfriendly` package.""" + +# Standard library modules. +import datetime +import math +import os +import random +import re +import subprocess +import sys +import time +import types +import unittest +import warnings + +# Modules included in our package. +from humanfriendly import ( + InvalidDate, + InvalidLength, + InvalidSize, + InvalidTimespan, + Timer, + coerce_boolean, + coerce_pattern, + format_length, + format_number, + format_path, + format_size, + format_timespan, + parse_date, + parse_length, + parse_path, + parse_size, + parse_timespan, + prompts, + round_number, +) +from humanfriendly.case import CaseInsensitiveDict, CaseInsensitiveKey +from humanfriendly.cli import main +from humanfriendly.compat import StringIO +from humanfriendly.decorators import cached +from humanfriendly.deprecation import DeprecationProxy, define_aliases, deprecated_args, get_aliases +from humanfriendly.prompts import ( + TooManyInvalidReplies, + prompt_for_confirmation, + prompt_for_choice, + prompt_for_input, +) +from humanfriendly.sphinx import ( + deprecation_note_callback, + man_role, + pypi_role, + setup, + special_methods_callback, + usage_message_callback, +) +from humanfriendly.tables import ( + format_pretty_table, + format_robust_table, + format_rst_table, + format_smart_table, +) +from humanfriendly.terminal import ( + ANSI_CSI, + ANSI_ERASE_LINE, + ANSI_HIDE_CURSOR, + ANSI_RESET, + ANSI_SGR, + ANSI_SHOW_CURSOR, + ansi_strip, + ansi_style, + ansi_width, + ansi_wrap, + clean_terminal_output, + connected_to_terminal, + find_terminal_size, + get_pager_command, + message, + output, + show_pager, + terminal_supports_colors, + warning, +) +from humanfriendly.terminal.html import html_to_ansi +from humanfriendly.terminal.spinners import AutomaticSpinner, Spinner +from humanfriendly.testing import ( + CallableTimedOut, + CaptureOutput, + MockedProgram, + PatchedAttribute, + PatchedItem, + TemporaryDirectory, + TestCase, + retry, + run_cli, + skip_on_raise, + touch, +) +from humanfriendly.text import ( + compact, + compact_empty_lines, + concatenate, + dedent, + generate_slug, + pluralize, + random_string, + trim_empty_lines, +) +from humanfriendly.usage import ( + find_meta_variables, + format_usage, + parse_usage, + render_usage, +) + +# Test dependencies. +from mock import MagicMock + + +class HumanFriendlyTestCase(TestCase): + + """Container for the `humanfriendly` test suite.""" + + def test_case_insensitive_dict(self): + """Test the CaseInsensitiveDict class.""" + # Test support for the dict(iterable) signature. + assert len(CaseInsensitiveDict([('key', True), ('KEY', False)])) == 1 + # Test support for the dict(iterable, **kw) signature. + assert len(CaseInsensitiveDict([('one', True), ('ONE', False)], one=False, two=True)) == 2 + # Test support for the dict(mapping) signature. + assert len(CaseInsensitiveDict(dict(key=True, KEY=False))) == 1 + # Test support for the dict(mapping, **kw) signature. + assert len(CaseInsensitiveDict(dict(one=True, ONE=False), one=False, two=True)) == 2 + # Test support for the dict(**kw) signature. + assert len(CaseInsensitiveDict(one=True, ONE=False, two=True)) == 2 + # Test support for dict.fromkeys(). + obj = CaseInsensitiveDict.fromkeys(["One", "one", "ONE", "Two", "two", "TWO"]) + assert len(obj) == 2 + # Test support for dict.get(). + obj = CaseInsensitiveDict(existing_key=42) + assert obj.get('Existing_Key') == 42 + # Test support for dict.pop(). + obj = CaseInsensitiveDict(existing_key=42) + assert obj.pop('Existing_Key') == 42 + assert len(obj) == 0 + # Test support for dict.setdefault(). + obj = CaseInsensitiveDict(existing_key=42) + assert obj.setdefault('Existing_Key') == 42 + obj.setdefault('other_key', 11) + assert obj['Other_Key'] == 11 + # Test support for dict.__contains__(). + obj = CaseInsensitiveDict(existing_key=42) + assert 'Existing_Key' in obj + # Test support for dict.__delitem__(). + obj = CaseInsensitiveDict(existing_key=42) + del obj['Existing_Key'] + assert len(obj) == 0 + # Test support for dict.__getitem__(). + obj = CaseInsensitiveDict(existing_key=42) + assert obj['Existing_Key'] == 42 + # Test support for dict.__setitem__(). + obj = CaseInsensitiveDict(existing_key=42) + obj['Existing_Key'] = 11 + assert obj['existing_key'] == 11 + + def test_case_insensitive_key(self): + """Test the CaseInsensitiveKey class.""" + # Test the __eq__() special method. + polite = CaseInsensitiveKey("Please don't shout") + rude = CaseInsensitiveKey("PLEASE DON'T SHOUT") + assert polite == rude + # Test the __hash__() special method. + mapping = {} + mapping[polite] = 1 + mapping[rude] = 2 + assert len(mapping) == 1 + + def test_capture_output(self): + """Test the CaptureOutput class.""" + with CaptureOutput() as capturer: + sys.stdout.write("Something for stdout.\n") + sys.stderr.write("And for stderr.\n") + assert capturer.stdout.get_lines() == ["Something for stdout."] + assert capturer.stderr.get_lines() == ["And for stderr."] + + def test_skip_on_raise(self): + """Test the skip_on_raise() decorator.""" + def test_fn(): + raise NotImplementedError() + decorator_fn = skip_on_raise(NotImplementedError) + decorated_fn = decorator_fn(test_fn) + self.assertRaises(NotImplementedError, test_fn) + self.assertRaises(unittest.SkipTest, decorated_fn) + + def test_retry_raise(self): + """Test :func:`~humanfriendly.testing.retry()` based on assertion errors.""" + # Define a helper function that will raise an assertion error on the + # first call and return a string on the second call. + def success_helper(): + if not hasattr(success_helper, 'was_called'): + setattr(success_helper, 'was_called', True) + assert False + else: + return 'yes' + assert retry(success_helper) == 'yes' + + # Define a helper function that always raises an assertion error. + def failure_helper(): + assert False + with self.assertRaises(AssertionError): + retry(failure_helper, timeout=1) + + def test_retry_return(self): + """Test :func:`~humanfriendly.testing.retry()` based on return values.""" + # Define a helper function that will return False on the first call and + # return a number on the second call. + def success_helper(): + if not hasattr(success_helper, 'was_called'): + # On the first call we return False. + setattr(success_helper, 'was_called', True) + return False + else: + # On the second call we return a number. + return 42 + assert retry(success_helper) == 42 + with self.assertRaises(CallableTimedOut): + retry(lambda: False, timeout=1) + + def test_mocked_program(self): + """Test :class:`humanfriendly.testing.MockedProgram`.""" + name = random_string() + script = dedent(''' + # This goes to stdout. + tr a-z A-Z + # This goes to stderr. + echo Fake warning >&2 + ''') + with MockedProgram(name=name, returncode=42, script=script) as directory: + assert os.path.isdir(directory) + assert os.path.isfile(os.path.join(directory, name)) + program = subprocess.Popen(name, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + stdout, stderr = program.communicate(input=b'hello world\n') + assert program.returncode == 42 + assert stdout == b'HELLO WORLD\n' + assert stderr == b'Fake warning\n' + + def test_temporary_directory(self): + """Test :class:`humanfriendly.testing.TemporaryDirectory`.""" + with TemporaryDirectory() as directory: + assert os.path.isdir(directory) + temporary_file = os.path.join(directory, 'some-file') + with open(temporary_file, 'w') as handle: + handle.write("Hello world!") + assert not os.path.exists(temporary_file) + assert not os.path.exists(directory) + + def test_touch(self): + """Test :func:`humanfriendly.testing.touch()`.""" + with TemporaryDirectory() as directory: + # Create a file in the temporary directory. + filename = os.path.join(directory, random_string()) + assert not os.path.isfile(filename) + touch(filename) + assert os.path.isfile(filename) + # Create a file in a subdirectory. + filename = os.path.join(directory, random_string(), random_string()) + assert not os.path.isfile(filename) + touch(filename) + assert os.path.isfile(filename) + + def test_patch_attribute(self): + """Test :class:`humanfriendly.testing.PatchedAttribute`.""" + class Subject(object): + my_attribute = 42 + instance = Subject() + assert instance.my_attribute == 42 + with PatchedAttribute(instance, 'my_attribute', 13) as return_value: + assert return_value is instance + assert instance.my_attribute == 13 + assert instance.my_attribute == 42 + + def test_patch_item(self): + """Test :class:`humanfriendly.testing.PatchedItem`.""" + instance = dict(my_item=True) + assert instance['my_item'] is True + with PatchedItem(instance, 'my_item', False) as return_value: + assert return_value is instance + assert instance['my_item'] is False + assert instance['my_item'] is True + + def test_run_cli_intercepts_exit(self): + """Test that run_cli() intercepts SystemExit.""" + returncode, output = run_cli(lambda: sys.exit(42)) + self.assertEqual(returncode, 42) + + def test_run_cli_intercepts_error(self): + """Test that run_cli() intercepts exceptions.""" + returncode, output = run_cli(self.run_cli_raise_other) + self.assertEqual(returncode, 1) + + def run_cli_raise_other(self): + """run_cli() sample that raises an exception.""" + raise ValueError() + + def test_run_cli_intercepts_output(self): + """Test that run_cli() intercepts output.""" + expected_output = random_string() + "\n" + returncode, output = run_cli(lambda: sys.stdout.write(expected_output)) + self.assertEqual(returncode, 0) + self.assertEqual(output, expected_output) + + def test_caching_decorator(self): + """Test the caching decorator.""" + # Confirm that the caching decorator works. + a = cached(lambda: random.random()) + b = cached(lambda: random.random()) + assert a() == a() + assert b() == b() + # Confirm that functions have their own cache. + assert a() != b() + + def test_compact(self): + """Test :func:`humanfriendly.text.compact()`.""" + assert compact(' a \n\n b ') == 'a b' + assert compact(''' + %s template notation + ''', 'Simple') == 'Simple template notation' + assert compact(''' + More {type} template notation + ''', type='readable') == 'More readable template notation' + + def test_compact_empty_lines(self): + """Test :func:`humanfriendly.text.compact_empty_lines()`.""" + # Simple strings pass through untouched. + assert compact_empty_lines('foo') == 'foo' + # Horizontal whitespace remains untouched. + assert compact_empty_lines('\tfoo') == '\tfoo' + # Line breaks should be preserved. + assert compact_empty_lines('foo\nbar') == 'foo\nbar' + # Vertical whitespace should be preserved. + assert compact_empty_lines('foo\n\nbar') == 'foo\n\nbar' + # Vertical whitespace should be compressed. + assert compact_empty_lines('foo\n\n\nbar') == 'foo\n\nbar' + assert compact_empty_lines('foo\n\n\n\nbar') == 'foo\n\nbar' + assert compact_empty_lines('foo\n\n\n\n\nbar') == 'foo\n\nbar' + + def test_dedent(self): + """Test :func:`humanfriendly.text.dedent()`.""" + assert dedent('\n line 1\n line 2\n\n') == 'line 1\n line 2\n' + assert dedent(''' + Dedented, %s text + ''', 'interpolated') == 'Dedented, interpolated text\n' + assert dedent(''' + Dedented, {op} text + ''', op='formatted') == 'Dedented, formatted text\n' + + def test_pluralization(self): + """Test :func:`humanfriendly.text.pluralize()`.""" + assert pluralize(1, 'word') == '1 word' + assert pluralize(2, 'word') == '2 words' + assert pluralize(1, 'box', 'boxes') == '1 box' + assert pluralize(2, 'box', 'boxes') == '2 boxes' + + def test_generate_slug(self): + """Test :func:`humanfriendly.text.generate_slug()`.""" + # Test the basic functionality. + self.assertEqual('some-random-text', generate_slug('Some Random Text!')) + # Test that previous output doesn't change. + self.assertEqual('some-random-text', generate_slug('some-random-text')) + # Test that inputs which can't be converted to a slug raise an exception. + with self.assertRaises(ValueError): + generate_slug(' ') + with self.assertRaises(ValueError): + generate_slug('-') + + def test_boolean_coercion(self): + """Test :func:`humanfriendly.coerce_boolean()`.""" + for value in [True, 'TRUE', 'True', 'true', 'on', 'yes', '1']: + self.assertEqual(True, coerce_boolean(value)) + for value in [False, 'FALSE', 'False', 'false', 'off', 'no', '0']: + self.assertEqual(False, coerce_boolean(value)) + with self.assertRaises(ValueError): + coerce_boolean('not a boolean') + + def test_pattern_coercion(self): + """Test :func:`humanfriendly.coerce_pattern()`.""" + empty_pattern = re.compile('') + # Make sure strings are converted to compiled regular expressions. + assert isinstance(coerce_pattern('foobar'), type(empty_pattern)) + # Make sure compiled regular expressions pass through untouched. + assert empty_pattern is coerce_pattern(empty_pattern) + # Make sure flags are respected. + pattern = coerce_pattern('foobar', re.IGNORECASE) + assert pattern.match('FOOBAR') + # Make sure invalid values raise the expected exception. + with self.assertRaises(ValueError): + coerce_pattern([]) + + def test_format_timespan(self): + """Test :func:`humanfriendly.format_timespan()`.""" + minute = 60 + hour = minute * 60 + day = hour * 24 + week = day * 7 + year = week * 52 + assert '1 nanosecond' == format_timespan(0.000000001, detailed=True) + assert '500 nanoseconds' == format_timespan(0.0000005, detailed=True) + assert '1 microsecond' == format_timespan(0.000001, detailed=True) + assert '500 microseconds' == format_timespan(0.0005, detailed=True) + assert '1 millisecond' == format_timespan(0.001, detailed=True) + assert '500 milliseconds' == format_timespan(0.5, detailed=True) + assert '0.5 seconds' == format_timespan(0.5, detailed=False) + assert '0 seconds' == format_timespan(0) + assert '0.54 seconds' == format_timespan(0.54321) + assert '1 second' == format_timespan(1) + assert '3.14 seconds' == format_timespan(math.pi) + assert '1 minute' == format_timespan(minute) + assert '1 minute and 20 seconds' == format_timespan(80) + assert '2 minutes' == format_timespan(minute * 2) + assert '1 hour' == format_timespan(hour) + assert '2 hours' == format_timespan(hour * 2) + assert '1 day' == format_timespan(day) + assert '2 days' == format_timespan(day * 2) + assert '1 week' == format_timespan(week) + assert '2 weeks' == format_timespan(week * 2) + assert '1 year' == format_timespan(year) + assert '2 years' == format_timespan(year * 2) + assert '6 years, 5 weeks, 4 days, 3 hours, 2 minutes and 500 milliseconds' == \ + format_timespan(year * 6 + week * 5 + day * 4 + hour * 3 + minute * 2 + 0.5, detailed=True) + assert '1 year, 2 weeks and 3 days' == \ + format_timespan(year + week * 2 + day * 3 + hour * 12) + # Make sure milliseconds are never shown separately when detailed=False. + # https://github.com/xolox/python-humanfriendly/issues/10 + assert '1 minute, 1 second and 100 milliseconds' == format_timespan(61.10, detailed=True) + assert '1 minute and 1.1 seconds' == format_timespan(61.10, detailed=False) + # Test for loss of precision as reported in issue 11: + # https://github.com/xolox/python-humanfriendly/issues/11 + assert '1 minute and 0.3 seconds' == format_timespan(60.300) + assert '5 minutes and 0.3 seconds' == format_timespan(300.300) + assert '1 second and 15 milliseconds' == format_timespan(1.015, detailed=True) + assert '10 seconds and 15 milliseconds' == format_timespan(10.015, detailed=True) + assert '1 microsecond and 50 nanoseconds' == format_timespan(0.00000105, detailed=True) + # Test the datetime.timedelta support: + # https://github.com/xolox/python-humanfriendly/issues/27 + now = datetime.datetime.now() + then = now - datetime.timedelta(hours=23) + assert '23 hours' == format_timespan(now - then) + + def test_parse_timespan(self): + """Test :func:`humanfriendly.parse_timespan()`.""" + self.assertEqual(0, parse_timespan('0')) + self.assertEqual(0, parse_timespan('0s')) + self.assertEqual(0.000000001, parse_timespan('1ns')) + self.assertEqual(0.000000051, parse_timespan('51ns')) + self.assertEqual(0.000001, parse_timespan('1us')) + self.assertEqual(0.000052, parse_timespan('52us')) + self.assertEqual(0.001, parse_timespan('1ms')) + self.assertEqual(0.001, parse_timespan('1 millisecond')) + self.assertEqual(0.5, parse_timespan('500 milliseconds')) + self.assertEqual(0.5, parse_timespan('0.5 seconds')) + self.assertEqual(5, parse_timespan('5s')) + self.assertEqual(5, parse_timespan('5 seconds')) + self.assertEqual(60 * 2, parse_timespan('2m')) + self.assertEqual(60 * 2, parse_timespan('2 minutes')) + self.assertEqual(60 * 3, parse_timespan('3 min')) + self.assertEqual(60 * 3, parse_timespan('3 mins')) + self.assertEqual(60 * 60 * 3, parse_timespan('3 h')) + self.assertEqual(60 * 60 * 3, parse_timespan('3 hours')) + self.assertEqual(60 * 60 * 24 * 4, parse_timespan('4d')) + self.assertEqual(60 * 60 * 24 * 4, parse_timespan('4 days')) + self.assertEqual(60 * 60 * 24 * 7 * 5, parse_timespan('5 w')) + self.assertEqual(60 * 60 * 24 * 7 * 5, parse_timespan('5 weeks')) + with self.assertRaises(InvalidTimespan): + parse_timespan('1z') + + def test_parse_date(self): + """Test :func:`humanfriendly.parse_date()`.""" + self.assertEqual((2013, 6, 17, 0, 0, 0), parse_date('2013-06-17')) + self.assertEqual((2013, 6, 17, 2, 47, 42), parse_date('2013-06-17 02:47:42')) + self.assertEqual((2016, 11, 30, 0, 47, 17), parse_date(u'2016-11-30 00:47:17')) + with self.assertRaises(InvalidDate): + parse_date('2013-06-XY') + + def test_format_size(self): + """Test :func:`humanfriendly.format_size()`.""" + self.assertEqual('0 bytes', format_size(0)) + self.assertEqual('1 byte', format_size(1)) + self.assertEqual('42 bytes', format_size(42)) + self.assertEqual('1 KB', format_size(1000 ** 1)) + self.assertEqual('1 MB', format_size(1000 ** 2)) + self.assertEqual('1 GB', format_size(1000 ** 3)) + self.assertEqual('1 TB', format_size(1000 ** 4)) + self.assertEqual('1 PB', format_size(1000 ** 5)) + self.assertEqual('1 EB', format_size(1000 ** 6)) + self.assertEqual('1 ZB', format_size(1000 ** 7)) + self.assertEqual('1 YB', format_size(1000 ** 8)) + self.assertEqual('1 KiB', format_size(1024 ** 1, binary=True)) + self.assertEqual('1 MiB', format_size(1024 ** 2, binary=True)) + self.assertEqual('1 GiB', format_size(1024 ** 3, binary=True)) + self.assertEqual('1 TiB', format_size(1024 ** 4, binary=True)) + self.assertEqual('1 PiB', format_size(1024 ** 5, binary=True)) + self.assertEqual('1 EiB', format_size(1024 ** 6, binary=True)) + self.assertEqual('1 ZiB', format_size(1024 ** 7, binary=True)) + self.assertEqual('1 YiB', format_size(1024 ** 8, binary=True)) + self.assertEqual('45 KB', format_size(1000 * 45)) + self.assertEqual('2.9 TB', format_size(1000 ** 4 * 2.9)) + + def test_parse_size(self): + """Test :func:`humanfriendly.parse_size()`.""" + self.assertEqual(0, parse_size('0B')) + self.assertEqual(42, parse_size('42')) + self.assertEqual(42, parse_size('42B')) + self.assertEqual(1000, parse_size('1k')) + self.assertEqual(1024, parse_size('1k', binary=True)) + self.assertEqual(1000, parse_size('1 KB')) + self.assertEqual(1000, parse_size('1 kilobyte')) + self.assertEqual(1024, parse_size('1 kilobyte', binary=True)) + self.assertEqual(1000 ** 2 * 69, parse_size('69 MB')) + self.assertEqual(1000 ** 3, parse_size('1 GB')) + self.assertEqual(1000 ** 4, parse_size('1 TB')) + self.assertEqual(1000 ** 5, parse_size('1 PB')) + self.assertEqual(1000 ** 6, parse_size('1 EB')) + self.assertEqual(1000 ** 7, parse_size('1 ZB')) + self.assertEqual(1000 ** 8, parse_size('1 YB')) + self.assertEqual(1000 ** 3 * 1.5, parse_size('1.5 GB')) + self.assertEqual(1024 ** 8 * 1.5, parse_size('1.5 YiB')) + with self.assertRaises(InvalidSize): + parse_size('1q') + with self.assertRaises(InvalidSize): + parse_size('a') + + def test_format_length(self): + """Test :func:`humanfriendly.format_length()`.""" + self.assertEqual('0 metres', format_length(0)) + self.assertEqual('1 metre', format_length(1)) + self.assertEqual('42 metres', format_length(42)) + self.assertEqual('1 km', format_length(1 * 1000)) + self.assertEqual('15.3 cm', format_length(0.153)) + self.assertEqual('1 cm', format_length(1e-02)) + self.assertEqual('1 mm', format_length(1e-03)) + self.assertEqual('1 nm', format_length(1e-09)) + + def test_parse_length(self): + """Test :func:`humanfriendly.parse_length()`.""" + self.assertEqual(0, parse_length('0m')) + self.assertEqual(42, parse_length('42')) + self.assertEqual(1.5, parse_length('1.5')) + self.assertEqual(42, parse_length('42m')) + self.assertEqual(1000, parse_length('1km')) + self.assertEqual(0.153, parse_length('15.3 cm')) + self.assertEqual(1e-02, parse_length('1cm')) + self.assertEqual(1e-03, parse_length('1mm')) + self.assertEqual(1e-09, parse_length('1nm')) + with self.assertRaises(InvalidLength): + parse_length('1z') + with self.assertRaises(InvalidLength): + parse_length('a') + + def test_format_number(self): + """Test :func:`humanfriendly.format_number()`.""" + self.assertEqual('1', format_number(1)) + self.assertEqual('1.5', format_number(1.5)) + self.assertEqual('1.56', format_number(1.56789)) + self.assertEqual('1.567', format_number(1.56789, 3)) + self.assertEqual('1,000', format_number(1000)) + self.assertEqual('1,000', format_number(1000.12, 0)) + self.assertEqual('1,000,000', format_number(1000000)) + self.assertEqual('1,000,000.42', format_number(1000000.42)) + # Regression test for https://github.com/xolox/python-humanfriendly/issues/40. + self.assertEqual('-285.67', format_number(-285.67)) + + def test_round_number(self): + """Test :func:`humanfriendly.round_number()`.""" + self.assertEqual('1', round_number(1)) + self.assertEqual('1', round_number(1.0)) + self.assertEqual('1.00', round_number(1, keep_width=True)) + self.assertEqual('3.14', round_number(3.141592653589793)) + + def test_format_path(self): + """Test :func:`humanfriendly.format_path()`.""" + friendly_path = os.path.join('~', '.vimrc') + absolute_path = os.path.join(os.environ['HOME'], '.vimrc') + self.assertEqual(friendly_path, format_path(absolute_path)) + + def test_parse_path(self): + """Test :func:`humanfriendly.parse_path()`.""" + friendly_path = os.path.join('~', '.vimrc') + absolute_path = os.path.join(os.environ['HOME'], '.vimrc') + self.assertEqual(absolute_path, parse_path(friendly_path)) + + def test_pretty_tables(self): + """Test :func:`humanfriendly.tables.format_pretty_table()`.""" + # The simplest case possible :-). + data = [['Just one column']] + assert format_pretty_table(data) == dedent(""" + ------------------- + | Just one column | + ------------------- + """).strip() + # A bit more complex: two rows, three columns, varying widths. + data = [['One', 'Two', 'Three'], ['1', '2', '3']] + assert format_pretty_table(data) == dedent(""" + --------------------- + | One | Two | Three | + | 1 | 2 | 3 | + --------------------- + """).strip() + # A table including column names. + column_names = ['One', 'Two', 'Three'] + data = [['1', '2', '3'], ['a', 'b', 'c']] + assert ansi_strip(format_pretty_table(data, column_names)) == dedent(""" + --------------------- + | One | Two | Three | + --------------------- + | 1 | 2 | 3 | + | a | b | c | + --------------------- + """).strip() + # A table that contains a column with only numeric data (will be right aligned). + column_names = ['Just a label', 'Important numbers'] + data = [['Row one', '15'], ['Row two', '300']] + assert ansi_strip(format_pretty_table(data, column_names)) == dedent(""" + ------------------------------------ + | Just a label | Important numbers | + ------------------------------------ + | Row one | 15 | + | Row two | 300 | + ------------------------------------ + """).strip() + + def test_robust_tables(self): + """Test :func:`humanfriendly.tables.format_robust_table()`.""" + column_names = ['One', 'Two', 'Three'] + data = [['1', '2', '3'], ['a', 'b', 'c']] + assert ansi_strip(format_robust_table(data, column_names)) == dedent(""" + -------- + One: 1 + Two: 2 + Three: 3 + -------- + One: a + Two: b + Three: c + -------- + """).strip() + column_names = ['One', 'Two', 'Three'] + data = [['1', '2', '3'], ['a', 'b', 'Here comes a\nmulti line column!']] + assert ansi_strip(format_robust_table(data, column_names)) == dedent(""" + ------------------ + One: 1 + Two: 2 + Three: 3 + ------------------ + One: a + Two: b + Three: + Here comes a + multi line column! + ------------------ + """).strip() + + def test_smart_tables(self): + """Test :func:`humanfriendly.tables.format_smart_table()`.""" + column_names = ['One', 'Two', 'Three'] + data = [['1', '2', '3'], ['a', 'b', 'c']] + assert ansi_strip(format_smart_table(data, column_names)) == dedent(""" + --------------------- + | One | Two | Three | + --------------------- + | 1 | 2 | 3 | + | a | b | c | + --------------------- + """).strip() + column_names = ['One', 'Two', 'Three'] + data = [['1', '2', '3'], ['a', 'b', 'Here comes a\nmulti line column!']] + assert ansi_strip(format_smart_table(data, column_names)) == dedent(""" + ------------------ + One: 1 + Two: 2 + Three: 3 + ------------------ + One: a + Two: b + Three: + Here comes a + multi line column! + ------------------ + """).strip() + + def test_rst_tables(self): + """Test :func:`humanfriendly.tables.format_rst_table()`.""" + # Generate a table with column names. + column_names = ['One', 'Two', 'Three'] + data = [['1', '2', '3'], ['a', 'b', 'c']] + self.assertEqual( + format_rst_table(data, column_names), + dedent(""" + === === ===== + One Two Three + === === ===== + 1 2 3 + a b c + === === ===== + """).rstrip(), + ) + # Generate a table without column names. + data = [['1', '2', '3'], ['a', 'b', 'c']] + self.assertEqual( + format_rst_table(data), + dedent(""" + = = = + 1 2 3 + a b c + = = = + """).rstrip(), + ) + + def test_concatenate(self): + """Test :func:`humanfriendly.text.concatenate()`.""" + assert concatenate([]) == '' + assert concatenate(['one']) == 'one' + assert concatenate(['one', 'two']) == 'one and two' + assert concatenate(['one', 'two', 'three']) == 'one, two and three' + # Test the 'conjunction' option. + assert concatenate(['one', 'two', 'three'], conjunction='or') == 'one, two or three' + # Test the 'serial_comma' option. + assert concatenate(['one', 'two', 'three'], serial_comma=True) == 'one, two, and three' + + def test_split(self): + """Test :func:`humanfriendly.text.split()`.""" + from humanfriendly.text import split + self.assertEqual(split(''), []) + self.assertEqual(split('foo'), ['foo']) + self.assertEqual(split('foo, bar'), ['foo', 'bar']) + self.assertEqual(split('foo, bar, baz'), ['foo', 'bar', 'baz']) + self.assertEqual(split('foo,bar,baz'), ['foo', 'bar', 'baz']) + + def test_timer(self): + """Test :func:`humanfriendly.Timer`.""" + for seconds, text in ((1, '1 second'), + (2, '2 seconds'), + (60, '1 minute'), + (60 * 2, '2 minutes'), + (60 * 60, '1 hour'), + (60 * 60 * 2, '2 hours'), + (60 * 60 * 24, '1 day'), + (60 * 60 * 24 * 2, '2 days'), + (60 * 60 * 24 * 7, '1 week'), + (60 * 60 * 24 * 7 * 2, '2 weeks')): + t = Timer(time.time() - seconds) + self.assertEqual(round_number(t.elapsed_time, keep_width=True), '%i.00' % seconds) + self.assertEqual(str(t), text) + # Test rounding to seconds. + t = Timer(time.time() - 2.2) + self.assertEqual(t.rounded, '2 seconds') + # Test automatic timer. + automatic_timer = Timer() + time.sleep(1) + # XXX The following normalize_timestamp(ndigits=0) calls are intended + # to compensate for unreliable clock sources in virtual machines + # like those encountered on Travis CI, see also: + # https://travis-ci.org/xolox/python-humanfriendly/jobs/323944263 + self.assertEqual(normalize_timestamp(automatic_timer.elapsed_time, 0), '1.00') + # Test resumable timer. + resumable_timer = Timer(resumable=True) + for i in range(2): + with resumable_timer: + time.sleep(1) + self.assertEqual(normalize_timestamp(resumable_timer.elapsed_time, 0), '2.00') + # Make sure Timer.__enter__() returns the timer object. + with Timer(resumable=True) as timer: + assert timer is not None + + def test_spinner(self): + """Test :func:`humanfriendly.Spinner`.""" + stream = StringIO() + spinner = Spinner(label='test spinner', total=4, stream=stream, interactive=True) + for progress in [1, 2, 3, 4]: + spinner.step(progress=progress) + time.sleep(0.2) + spinner.clear() + output = stream.getvalue() + output = (output.replace(ANSI_SHOW_CURSOR, '') + .replace(ANSI_HIDE_CURSOR, '')) + lines = [line for line in output.split(ANSI_ERASE_LINE) if line] + self.assertTrue(len(lines) > 0) + self.assertTrue(all('test spinner' in line for line in lines)) + self.assertTrue(all('%' in line for line in lines)) + self.assertEqual(sorted(set(lines)), sorted(lines)) + + def test_automatic_spinner(self): + """ + Test :func:`humanfriendly.AutomaticSpinner`. + + There's not a lot to test about the :class:`.AutomaticSpinner` class, + but by at least running it here we are assured that the code functions + on all supported Python versions. :class:`.AutomaticSpinner` is built + on top of the :class:`.Spinner` class so at least we also have the + tests for the :class:`.Spinner` class to back us up. + """ + with AutomaticSpinner(label='test spinner'): + time.sleep(1) + + def test_prompt_for_choice(self): + """Test :func:`humanfriendly.prompts.prompt_for_choice()`.""" + # Choice selection without any options should raise an exception. + with self.assertRaises(ValueError): + prompt_for_choice([]) + # If there's only one option no prompt should be rendered so we expect + # the following code to not raise an EOFError exception (despite + # connecting standard input to /dev/null). + with open(os.devnull) as handle: + with PatchedAttribute(sys, 'stdin', handle): + only_option = 'only one option (shortcut)' + assert prompt_for_choice([only_option]) == only_option + # Choice selection by full string match. + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: 'foo'): + assert prompt_for_choice(['foo', 'bar']) == 'foo' + # Choice selection by substring input. + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: 'f'): + assert prompt_for_choice(['foo', 'bar']) == 'foo' + # Choice selection by number. + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: '2'): + assert prompt_for_choice(['foo', 'bar']) == 'bar' + # Choice selection by going with the default. + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: ''): + assert prompt_for_choice(['foo', 'bar'], default='bar') == 'bar' + # Invalid substrings are refused. + replies = ['', 'q', 'z'] + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: replies.pop(0)): + assert prompt_for_choice(['foo', 'bar', 'baz']) == 'baz' + # Choice selection by substring input requires an unambiguous substring match. + replies = ['a', 'q'] + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: replies.pop(0)): + assert prompt_for_choice(['foo', 'bar', 'baz', 'qux']) == 'qux' + # Invalid numbers are refused. + replies = ['42', '2'] + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: replies.pop(0)): + assert prompt_for_choice(['foo', 'bar', 'baz']) == 'bar' + # Test that interactive prompts eventually give up on invalid replies. + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: ''): + with self.assertRaises(TooManyInvalidReplies): + prompt_for_choice(['a', 'b', 'c']) + + def test_prompt_for_confirmation(self): + """Test :func:`humanfriendly.prompts.prompt_for_confirmation()`.""" + # Test some (more or less) reasonable replies that indicate agreement. + for reply in 'yes', 'Yes', 'YES', 'y', 'Y': + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: reply): + assert prompt_for_confirmation("Are you sure?") is True + # Test some (more or less) reasonable replies that indicate disagreement. + for reply in 'no', 'No', 'NO', 'n', 'N': + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: reply): + assert prompt_for_confirmation("Are you sure?") is False + # Test that empty replies select the default choice. + for default_choice in True, False: + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: ''): + assert prompt_for_confirmation("Are you sure?", default=default_choice) is default_choice + # Test that a warning is shown when no input nor a default is given. + replies = ['', 'y'] + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: replies.pop(0)): + with CaptureOutput(merged=True) as capturer: + assert prompt_for_confirmation("Are you sure?") is True + assert "there's no default choice" in capturer.get_text() + # Test that the default reply is shown in uppercase. + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: 'y'): + for default_value, expected_text in (True, 'Y/n'), (False, 'y/N'), (None, 'y/n'): + with CaptureOutput(merged=True) as capturer: + assert prompt_for_confirmation("Are you sure?", default=default_value) is True + assert expected_text in capturer.get_text() + # Test that interactive prompts eventually give up on invalid replies. + with PatchedAttribute(prompts, 'interactive_prompt', lambda p: ''): + with self.assertRaises(TooManyInvalidReplies): + prompt_for_confirmation("Are you sure?") + + def test_prompt_for_input(self): + """Test :func:`humanfriendly.prompts.prompt_for_input()`.""" + with open(os.devnull) as handle: + with PatchedAttribute(sys, 'stdin', handle): + # If standard input isn't connected to a terminal the default value should be returned. + default_value = "To seek the holy grail!" + assert prompt_for_input("What is your quest?", default=default_value) == default_value + # If standard input isn't connected to a terminal and no default value + # is given the EOFError exception should be propagated to the caller. + with self.assertRaises(EOFError): + prompt_for_input("What is your favorite color?") + + def test_cli(self): + """Test the command line interface.""" + # Test that the usage message is printed by default. + returncode, output = run_cli(main) + assert 'Usage:' in output + # Test that the usage message can be requested explicitly. + returncode, output = run_cli(main, '--help') + assert 'Usage:' in output + # Test handling of invalid command line options. + returncode, output = run_cli(main, '--unsupported-option') + assert returncode != 0 + # Test `humanfriendly --format-number'. + returncode, output = run_cli(main, '--format-number=1234567') + assert output.strip() == '1,234,567' + # Test `humanfriendly --format-size'. + random_byte_count = random.randint(1024, 1024 * 1024) + returncode, output = run_cli(main, '--format-size=%i' % random_byte_count) + assert output.strip() == format_size(random_byte_count) + # Test `humanfriendly --format-size --binary'. + random_byte_count = random.randint(1024, 1024 * 1024) + returncode, output = run_cli(main, '--format-size=%i' % random_byte_count, '--binary') + assert output.strip() == format_size(random_byte_count, binary=True) + # Test `humanfriendly --format-length'. + random_len = random.randint(1024, 1024 * 1024) + returncode, output = run_cli(main, '--format-length=%i' % random_len) + assert output.strip() == format_length(random_len) + random_len = float(random_len) / 12345.6 + returncode, output = run_cli(main, '--format-length=%f' % random_len) + assert output.strip() == format_length(random_len) + # Test `humanfriendly --format-table'. + returncode, output = run_cli(main, '--format-table', '--delimiter=\t', input='1\t2\t3\n4\t5\t6\n7\t8\t9') + assert output.strip() == dedent(''' + ------------- + | 1 | 2 | 3 | + | 4 | 5 | 6 | + | 7 | 8 | 9 | + ------------- + ''').strip() + # Test `humanfriendly --format-timespan'. + random_timespan = random.randint(5, 600) + returncode, output = run_cli(main, '--format-timespan=%i' % random_timespan) + assert output.strip() == format_timespan(random_timespan) + # Test `humanfriendly --parse-size'. + returncode, output = run_cli(main, '--parse-size=5 KB') + assert int(output) == parse_size('5 KB') + # Test `humanfriendly --parse-size'. + returncode, output = run_cli(main, '--parse-size=5 YiB') + assert int(output) == parse_size('5 YB', binary=True) + # Test `humanfriendly --parse-length'. + returncode, output = run_cli(main, '--parse-length=5 km') + assert int(output) == parse_length('5 km') + returncode, output = run_cli(main, '--parse-length=1.05 km') + assert float(output) == parse_length('1.05 km') + # Test `humanfriendly --run-command'. + returncode, output = run_cli(main, '--run-command', 'bash', '-c', 'sleep 2 && exit 42') + assert returncode == 42 + # Test `humanfriendly --demo'. The purpose of this test is + # to ensure that the demo runs successfully on all versions + # of Python and outputs the expected sections (recognized by + # their headings) without triggering exceptions. This was + # written as a regression test after issue #28 was reported: + # https://github.com/xolox/python-humanfriendly/issues/28 + returncode, output = run_cli(main, '--demo') + assert returncode == 0 + lines = [ansi_strip(line) for line in output.splitlines()] + assert "Text styles:" in lines + assert "Foreground colors:" in lines + assert "Background colors:" in lines + assert "256 color mode (standard colors):" in lines + assert "256 color mode (high-intensity colors):" in lines + assert "256 color mode (216 colors):" in lines + assert "256 color mode (gray scale colors):" in lines + + def test_ansi_style(self): + """Test :func:`humanfriendly.terminal.ansi_style()`.""" + assert ansi_style(bold=True) == '%s1%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(faint=True) == '%s2%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(italic=True) == '%s3%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(underline=True) == '%s4%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(inverse=True) == '%s7%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(strike_through=True) == '%s9%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(color='blue') == '%s34%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(background='blue') == '%s44%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(color='blue', bright=True) == '%s94%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(color=214) == '%s38;5;214%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(background=214) == '%s39;5;214%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(color=(0, 0, 0)) == '%s38;2;0;0;0%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(color=(255, 255, 255)) == '%s38;2;255;255;255%s' % (ANSI_CSI, ANSI_SGR) + assert ansi_style(background=(50, 100, 150)) == '%s48;2;50;100;150%s' % (ANSI_CSI, ANSI_SGR) + with self.assertRaises(ValueError): + ansi_style(color='unknown') + + def test_ansi_width(self): + """Test :func:`humanfriendly.terminal.ansi_width()`.""" + text = "Whatever" + # Make sure ansi_width() works as expected on strings without ANSI escape sequences. + assert len(text) == ansi_width(text) + # Wrap a text in ANSI escape sequences and make sure ansi_width() treats it as expected. + wrapped = ansi_wrap(text, bold=True) + # Make sure ansi_wrap() changed the text. + assert wrapped != text + # Make sure ansi_wrap() added additional bytes. + assert len(wrapped) > len(text) + # Make sure the result of ansi_width() stays the same. + assert len(text) == ansi_width(wrapped) + + def test_ansi_wrap(self): + """Test :func:`humanfriendly.terminal.ansi_wrap()`.""" + text = "Whatever" + # Make sure ansi_wrap() does nothing when no keyword arguments are given. + assert text == ansi_wrap(text) + # Make sure ansi_wrap() starts the text with the CSI sequence. + assert ansi_wrap(text, bold=True).startswith(ANSI_CSI) + # Make sure ansi_wrap() ends the text by resetting the ANSI styles. + assert ansi_wrap(text, bold=True).endswith(ANSI_RESET) + + def test_html_to_ansi(self): + """Test the :func:`humanfriendly.terminal.html_to_ansi()` function.""" + assert html_to_ansi("Just some plain text") == "Just some plain text" + # Hyperlinks. + assert html_to_ansi('python.org') == \ + '\x1b[0m\x1b[4;94mpython.org\x1b[0m (\x1b[0m\x1b[4;94mhttps://python.org\x1b[0m)' + # Make sure `mailto:' prefixes are stripped (they're not at all useful in a terminal). + assert html_to_ansi('peter@peterodding.com') == \ + '\x1b[0m\x1b[4;94mpeter@peterodding.com\x1b[0m' + # Bold text. + assert html_to_ansi("Let's try bold") == "Let's try \x1b[0m\x1b[1mbold\x1b[0m" + assert html_to_ansi("Let's try bold") == \ + "Let's try \x1b[0m\x1b[1mbold\x1b[0m" + # Italic text. + assert html_to_ansi("Let's try italic") == \ + "Let's try \x1b[0m\x1b[3mitalic\x1b[0m" + assert html_to_ansi("Let's try italic") == \ + "Let's try \x1b[0m\x1b[3mitalic\x1b[0m" + # Underlined text. + assert html_to_ansi("Let's try underline") == \ + "Let's try \x1b[0m\x1b[4munderline\x1b[0m" + assert html_to_ansi("Let's try underline") == \ + "Let's try \x1b[0m\x1b[4munderline\x1b[0m" + # Strike-through text. + assert html_to_ansi("Let's try strike-through") == \ + "Let's try \x1b[0m\x1b[9mstrike-through\x1b[0m" + assert html_to_ansi("Let's try strike-through") == \ + "Let's try \x1b[0m\x1b[9mstrike-through\x1b[0m" + # Pre-formatted text. + assert html_to_ansi("Let's try pre-formatted") == \ + "Let's try \x1b[0m\x1b[33mpre-formatted\x1b[0m" + # Text colors (with a 6 digit hexadecimal color value). + assert html_to_ansi("Let's try text colors
") == \ + "Let's try \x1b[0m\x1b[38;2;170;187;204mtext colors\x1b[0m" + # Background colors (with an rgb(N, N, N) expression). + assert html_to_ansi("Let's try background colors") == \ + "Let's try \x1b[0m\x1b[48;2;50;50;50mbackground colors\x1b[0m" + # Line breaks. + assert html_to_ansi("Let's try some
line
breaks") == \ + "Let's try some\nline\nbreaks" + # Check that decimal entities are decoded. + assert html_to_ansi("&") == "&" + # Check that named entities are decoded. + assert html_to_ansi("&") == "&" + assert html_to_ansi(">") == ">" + assert html_to_ansi("<") == "<" + # Check that hexadecimal entities are decoded. + assert html_to_ansi("&") == "&" + # Check that the text callback is actually called. + + def callback(text): + return text.replace(':wink:', ';-)') + + assert ':wink:' not in html_to_ansi(':wink:', callback=callback) + # Check that the text callback doesn't process preformatted text. + assert ':wink:' in html_to_ansi(':wink:', callback=callback) + # Try a somewhat convoluted but nevertheless real life example from my + # personal chat archives that causes humanfriendly releases 4.15 and + # 4.15.1 to raise an exception. + assert html_to_ansi(u''' + Tweakers zit er idd nog steeds:

+ peter@peter-work> curl -s tweakers.net | grep -i hosting
+ <a href="http://www.true.nl/webhosting/" + rel="external" id="true" title="Hosting door True"></a>
+ Hosting door <a href="http://www.true.nl/vps/" + title="VPS hosting" rel="external">True + ''') + + def test_generate_output(self): + """Test the :func:`humanfriendly.terminal.output()` function.""" + text = "Standard output generated by output()" + with CaptureOutput(merged=False) as capturer: + output(text) + self.assertEqual([text], capturer.stdout.get_lines()) + self.assertEqual([], capturer.stderr.get_lines()) + + def test_generate_message(self): + """Test the :func:`humanfriendly.terminal.message()` function.""" + text = "Standard error generated by message()" + with CaptureOutput(merged=False) as capturer: + message(text) + self.assertEqual([], capturer.stdout.get_lines()) + self.assertEqual([text], capturer.stderr.get_lines()) + + def test_generate_warning(self): + """Test the :func:`humanfriendly.terminal.warning()` function.""" + from capturer import CaptureOutput + text = "Standard error generated by warning()" + with CaptureOutput(merged=False) as capturer: + warning(text) + self.assertEqual([], capturer.stdout.get_lines()) + self.assertEqual([ansi_wrap(text, color='red')], self.ignore_coverage_warning(capturer.stderr)) + + def ignore_coverage_warning(self, stream): + """ + Filter out coverage.py warning from standard error. + + This is intended to remove the following line from the lines captured + on the standard error stream: + + Coverage.py warning: No data was collected. (no-data-collected) + """ + return [line for line in stream.get_lines() if 'no-data-collected' not in line] + + def test_clean_output(self): + """Test :func:`humanfriendly.terminal.clean_terminal_output()`.""" + # Simple output should pass through unharmed (single line). + assert clean_terminal_output('foo') == ['foo'] + # Simple output should pass through unharmed (multiple lines). + assert clean_terminal_output('foo\nbar') == ['foo', 'bar'] + # Carriage returns and preceding substrings are removed. + assert clean_terminal_output('foo\rbar\nbaz') == ['bar', 'baz'] + # Carriage returns move the cursor to the start of the line without erasing text. + assert clean_terminal_output('aaa\rab') == ['aba'] + # Backspace moves the cursor one position back without erasing text. + assert clean_terminal_output('aaa\b\bb') == ['aba'] + # Trailing empty lines should be stripped. + assert clean_terminal_output('foo\nbar\nbaz\n\n\n') == ['foo', 'bar', 'baz'] + + def test_find_terminal_size(self): + """Test :func:`humanfriendly.terminal.find_terminal_size()`.""" + lines, columns = find_terminal_size() + # We really can't assert any minimum or maximum values here because it + # simply doesn't make any sense; it's impossible for me to anticipate + # on what environments this test suite will run in the future. + assert lines > 0 + assert columns > 0 + # The find_terminal_size_using_ioctl() function is the default + # implementation and it will likely work fine. This makes it hard to + # test the fall back code paths though. However there's an easy way to + # make find_terminal_size_using_ioctl() fail ... + saved_stdin = sys.stdin + saved_stdout = sys.stdout + saved_stderr = sys.stderr + try: + # What do you mean this is brute force?! ;-) + sys.stdin = StringIO() + sys.stdout = StringIO() + sys.stderr = StringIO() + # Now find_terminal_size_using_ioctl() should fail even though + # find_terminal_size_using_stty() might work fine. + lines, columns = find_terminal_size() + assert lines > 0 + assert columns > 0 + # There's also an ugly way to make `stty size' fail: The + # subprocess.Popen class uses os.execvp() underneath, so if we + # clear the $PATH it will break. + saved_path = os.environ['PATH'] + try: + os.environ['PATH'] = '' + # Now find_terminal_size_using_stty() should fail. + lines, columns = find_terminal_size() + assert lines > 0 + assert columns > 0 + finally: + os.environ['PATH'] = saved_path + finally: + sys.stdin = saved_stdin + sys.stdout = saved_stdout + sys.stderr = saved_stderr + + def test_terminal_capabilities(self): + """Test the functions that check for terminal capabilities.""" + from capturer import CaptureOutput + for test_stream in connected_to_terminal, terminal_supports_colors: + # This test suite should be able to run interactively as well as + # non-interactively, so we can't expect or demand that standard streams + # will always be connected to a terminal. Fortunately Capturer enables + # us to fake it :-). + for stream in sys.stdout, sys.stderr: + with CaptureOutput(): + assert test_stream(stream) + # Test something that we know can never be a terminal. + with open(os.devnull) as handle: + assert not test_stream(handle) + # Verify that objects without isatty() don't raise an exception. + assert not test_stream(object()) + + def test_show_pager(self): + """Test :func:`humanfriendly.terminal.show_pager()`.""" + original_pager = os.environ.get('PAGER', None) + try: + # We specifically avoid `less' because it would become awkward to + # run the test suite in an interactive terminal :-). + os.environ['PAGER'] = 'cat' + # Generate a significant amount of random text spread over multiple + # lines that we expect to be reported literally on the terminal. + random_text = "\n".join(random_string(25) for i in range(50)) + # Run the pager command and validate the output. + with CaptureOutput() as capturer: + show_pager(random_text) + assert random_text in capturer.get_text() + finally: + if original_pager is not None: + # Restore the original $PAGER value. + os.environ['PAGER'] = original_pager + else: + # Clear the custom $PAGER value. + os.environ.pop('PAGER') + + def test_get_pager_command(self): + """Test :func:`humanfriendly.terminal.get_pager_command()`.""" + # Make sure --RAW-CONTROL-CHARS isn't used when it's not needed. + assert '--RAW-CONTROL-CHARS' not in get_pager_command("Usage message") + # Make sure --RAW-CONTROL-CHARS is used when it's needed. + assert '--RAW-CONTROL-CHARS' in get_pager_command(ansi_wrap("Usage message", bold=True)) + # Make sure that less-specific options are only used when valid. + options_specific_to_less = ['--no-init', '--quit-if-one-screen'] + for pager in 'cat', 'less': + original_pager = os.environ.get('PAGER', None) + try: + # Set $PAGER to `cat' or `less'. + os.environ['PAGER'] = pager + # Get the pager command line. + command_line = get_pager_command() + # Check for less-specific options. + if pager == 'less': + assert all(opt in command_line for opt in options_specific_to_less) + else: + assert not any(opt in command_line for opt in options_specific_to_less) + finally: + if original_pager is not None: + # Restore the original $PAGER value. + os.environ['PAGER'] = original_pager + else: + # Clear the custom $PAGER value. + os.environ.pop('PAGER') + + def test_find_meta_variables(self): + """Test :func:`humanfriendly.usage.find_meta_variables()`.""" + assert sorted(find_meta_variables(""" + Here's one example: --format-number=VALUE + Here's another example: --format-size=BYTES + A final example: --format-timespan=SECONDS + This line doesn't contain a META variable. + """)) == sorted(['VALUE', 'BYTES', 'SECONDS']) + + def test_parse_usage_simple(self): + """Test :func:`humanfriendly.usage.parse_usage()` (a simple case).""" + introduction, options = self.preprocess_parse_result(""" + Usage: my-fancy-app [OPTIONS] + + Boring description. + + Supported options: + + -h, --help + + Show this message and exit. + """) + # The following fragments are (expected to be) part of the introduction. + assert "Usage: my-fancy-app [OPTIONS]" in introduction + assert "Boring description." in introduction + assert "Supported options:" in introduction + # The following fragments are (expected to be) part of the documented options. + assert "-h, --help" in options + assert "Show this message and exit." in options + + def test_parse_usage_tricky(self): + """Test :func:`humanfriendly.usage.parse_usage()` (a tricky case).""" + introduction, options = self.preprocess_parse_result(""" + Usage: my-fancy-app [OPTIONS] + + Here's the introduction to my-fancy-app. Some of the lines in the + introduction start with a command line option just to confuse the + parsing algorithm :-) + + For example + --an-awesome-option + is still part of the introduction. + + Supported options: + + -a, --an-awesome-option + + Explanation why this is an awesome option. + + -b, --a-boring-option + + Explanation why this is a boring option. + """) + # The following fragments are (expected to be) part of the introduction. + assert "Usage: my-fancy-app [OPTIONS]" in introduction + assert any('still part of the introduction' in p for p in introduction) + assert "Supported options:" in introduction + # The following fragments are (expected to be) part of the documented options. + assert "-a, --an-awesome-option" in options + assert "Explanation why this is an awesome option." in options + assert "-b, --a-boring-option" in options + assert "Explanation why this is a boring option." in options + + def test_parse_usage_commas(self): + """Test :func:`humanfriendly.usage.parse_usage()` against option labels containing commas.""" + introduction, options = self.preprocess_parse_result(""" + Usage: my-fancy-app [OPTIONS] + + Some introduction goes here. + + Supported options: + + -f, --first-option + + Explanation of first option. + + -s, --second-option=WITH,COMMA + + This should be a separate option's description. + """) + # The following fragments are (expected to be) part of the introduction. + assert "Usage: my-fancy-app [OPTIONS]" in introduction + assert "Some introduction goes here." in introduction + assert "Supported options:" in introduction + # The following fragments are (expected to be) part of the documented options. + assert "-f, --first-option" in options + assert "Explanation of first option." in options + assert "-s, --second-option=WITH,COMMA" in options + assert "This should be a separate option's description." in options + + def preprocess_parse_result(self, text): + """Ignore leading/trailing whitespace in usage parsing tests.""" + return tuple([p.strip() for p in r] for r in parse_usage(dedent(text))) + + def test_format_usage(self): + """Test :func:`humanfriendly.usage.format_usage()`.""" + # Test that options are highlighted. + usage_text = "Just one --option" + formatted_text = format_usage(usage_text) + assert len(formatted_text) > len(usage_text) + assert formatted_text.startswith("Just one ") + # Test that the "Usage: ..." line is highlighted. + usage_text = "Usage: humanfriendly [OPTIONS]" + formatted_text = format_usage(usage_text) + assert len(formatted_text) > len(usage_text) + assert usage_text in formatted_text + assert not formatted_text.startswith(usage_text) + # Test that meta variables aren't erroneously highlighted. + usage_text = ( + "--valid-option=VALID_METAVAR\n" + "VALID_METAVAR is bogus\n" + "INVALID_METAVAR should not be highlighted\n" + ) + formatted_text = format_usage(usage_text) + formatted_lines = formatted_text.splitlines() + # Make sure the meta variable in the second line is highlighted. + assert ANSI_CSI in formatted_lines[1] + # Make sure the meta variable in the third line isn't highlighted. + assert ANSI_CSI not in formatted_lines[2] + + def test_render_usage(self): + """Test :func:`humanfriendly.usage.render_usage()`.""" + assert render_usage("Usage: some-command WITH ARGS") == "**Usage:** `some-command WITH ARGS`" + assert render_usage("Supported options:") == "**Supported options:**" + assert 'code-block' in render_usage(dedent(""" + Here comes a shell command: + + $ echo test + test + """)) + assert all(token in render_usage(dedent(""" + Supported options: + + -n, --dry-run + + Don't change anything. + """)) for token in ('`-n`', '`--dry-run`')) + + def test_deprecated_args(self): + """Test the deprecated_args() decorator function.""" + @deprecated_args('foo', 'bar') + def test_function(**options): + assert options['foo'] == 'foo' + assert options.get('bar') in (None, 'bar') + return 42 + fake_fn = MagicMock() + with PatchedAttribute(warnings, 'warn', fake_fn): + assert test_function('foo', 'bar') == 42 + with self.assertRaises(TypeError): + test_function('foo', 'bar', 'baz') + assert fake_fn.was_called + + def test_alias_proxy_deprecation_warning(self): + """Test that the DeprecationProxy class emits deprecation warnings.""" + fake_fn = MagicMock() + with PatchedAttribute(warnings, 'warn', fake_fn): + module = sys.modules[__name__] + aliases = dict(concatenate='humanfriendly.text.concatenate') + proxy = DeprecationProxy(module, aliases) + assert proxy.concatenate == concatenate + assert fake_fn.was_called + + def test_alias_proxy_sphinx_compensation(self): + """Test that the DeprecationProxy class emits deprecation warnings.""" + with PatchedItem(sys.modules, 'sphinx', types.ModuleType('sphinx')): + define_aliases(__name__, concatenate='humanfriendly.text.concatenate') + assert "concatenate" in dir(sys.modules[__name__]) + assert "concatenate" in get_aliases(__name__) + + def test_alias_proxy_sphinx_integration(self): + """Test that aliases can be injected into generated documentation.""" + module = sys.modules[__name__] + define_aliases(__name__, concatenate='humanfriendly.text.concatenate') + lines = module.__doc__.splitlines() + deprecation_note_callback(app=None, what=None, name=None, obj=module, options=None, lines=lines) + # Check that something was injected. + assert "\n".join(lines) != module.__doc__ + + def test_sphinx_customizations(self): + """Test the :mod:`humanfriendly.sphinx` module.""" + class FakeApp(object): + + def __init__(self): + self.callbacks = {} + self.roles = {} + + def __documented_special_method__(self): + """Documented unofficial special method.""" + pass + + def __undocumented_special_method__(self): + # Intentionally not documented :-). + pass + + def add_role(self, name, callback): + self.roles[name] = callback + + def connect(self, event, callback): + self.callbacks.setdefault(event, []).append(callback) + + def bogus_usage(self): + """Usage: This is not supposed to be reformatted!""" + pass + + # Test event callback registration. + fake_app = FakeApp() + setup(fake_app) + assert man_role == fake_app.roles['man'] + assert pypi_role == fake_app.roles['pypi'] + assert deprecation_note_callback in fake_app.callbacks['autodoc-process-docstring'] + assert special_methods_callback in fake_app.callbacks['autodoc-skip-member'] + assert usage_message_callback in fake_app.callbacks['autodoc-process-docstring'] + # Test that `special methods' which are documented aren't skipped. + assert special_methods_callback( + app=None, what=None, name=None, + obj=FakeApp.__documented_special_method__, + skip=True, options=None, + ) is False + # Test that `special methods' which are undocumented are skipped. + assert special_methods_callback( + app=None, what=None, name=None, + obj=FakeApp.__undocumented_special_method__, + skip=True, options=None, + ) is True + # Test formatting of usage messages. obj/lines + from humanfriendly import cli, sphinx + # We expect the docstring in the `cli' module to be reformatted + # (because it contains a usage message in the expected format). + assert self.docstring_is_reformatted(cli) + # We don't expect the docstring in the `sphinx' module to be + # reformatted (because it doesn't contain a usage message). + assert not self.docstring_is_reformatted(sphinx) + # We don't expect the docstring of the following *method* to be + # reformatted because only *module* docstrings should be reformatted. + assert not self.docstring_is_reformatted(fake_app.bogus_usage) + + def docstring_is_reformatted(self, entity): + """Check whether :func:`.usage_message_callback()` reformats a module's docstring.""" + lines = trim_empty_lines(entity.__doc__).splitlines() + saved_lines = list(lines) + usage_message_callback( + app=None, what=None, name=None, + obj=entity, options=None, lines=lines, + ) + return lines != saved_lines + + +def normalize_timestamp(value, ndigits=1): + """ + Round timestamps to the given number of digits. + + This helps to make the test suite less sensitive to timing issues caused by + multitasking, processor scheduling, etc. + """ + return '%.2f' % round(float(value), ndigits=ndigits) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/text.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/text.py new file mode 100644 index 0000000000000000000000000000000000000000..a257a6a189ff70c95567e7765f8ed530bafca8c2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/text.py @@ -0,0 +1,449 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: December 1, 2020 +# URL: https://humanfriendly.readthedocs.io + +""" +Simple text manipulation functions. + +The :mod:`~humanfriendly.text` module contains simple functions to manipulate text: + +- The :func:`concatenate()` and :func:`pluralize()` functions make it easy to + generate human friendly output. + +- The :func:`format()`, :func:`compact()` and :func:`dedent()` functions + provide a clean and simple to use syntax for composing large text fragments + with interpolated variables. + +- The :func:`tokenize()` function parses simple user input. +""" + +# Standard library modules. +import numbers +import random +import re +import string +import textwrap + +# Public identifiers that require documentation. +__all__ = ( + 'compact', + 'compact_empty_lines', + 'concatenate', + 'dedent', + 'format', + 'generate_slug', + 'is_empty_line', + 'join_lines', + 'pluralize', + 'pluralize_raw', + 'random_string', + 'split', + 'split_paragraphs', + 'tokenize', + 'trim_empty_lines', +) + + +def compact(text, *args, **kw): + ''' + Compact whitespace in a string. + + Trims leading and trailing whitespace, replaces runs of whitespace + characters with a single space and interpolates any arguments using + :func:`format()`. + + :param text: The text to compact (a string). + :param args: Any positional arguments are interpolated using :func:`format()`. + :param kw: Any keyword arguments are interpolated using :func:`format()`. + :returns: The compacted text (a string). + + Here's an example of how I like to use the :func:`compact()` function, this + is an example from a random unrelated project I'm working on at the moment:: + + raise PortDiscoveryError(compact(""" + Failed to discover port(s) that Apache is listening on! + Maybe I'm parsing the wrong configuration file? ({filename}) + """, filename=self.ports_config)) + + The combination of :func:`compact()` and Python's multi line strings allows + me to write long text fragments with interpolated variables that are easy + to write, easy to read and work well with Python's whitespace + sensitivity. + ''' + non_whitespace_tokens = text.split() + compacted_text = ' '.join(non_whitespace_tokens) + return format(compacted_text, *args, **kw) + + +def compact_empty_lines(text): + """ + Replace repeating empty lines with a single empty line (similar to ``cat -s``). + + :param text: The text in which to compact empty lines (a string). + :returns: The text with empty lines compacted (a string). + """ + i = 0 + lines = text.splitlines(True) + while i < len(lines): + if i > 0 and is_empty_line(lines[i - 1]) and is_empty_line(lines[i]): + lines.pop(i) + else: + i += 1 + return ''.join(lines) + + +def concatenate(items, conjunction='and', serial_comma=False): + """ + Concatenate a list of items in a human friendly way. + + :param items: + + A sequence of strings. + + :param conjunction: + + The word to use before the last item (a string, defaults to "and"). + + :param serial_comma: + + :data:`True` to use a `serial comma`_, :data:`False` otherwise + (defaults to :data:`False`). + + :returns: + + A single string. + + >>> from humanfriendly.text import concatenate + >>> concatenate(["eggs", "milk", "bread"]) + 'eggs, milk and bread' + + .. _serial comma: https://en.wikipedia.org/wiki/Serial_comma + """ + items = list(items) + if len(items) > 1: + final_item = items.pop() + formatted = ', '.join(items) + if serial_comma: + formatted += ',' + return ' '.join([formatted, conjunction, final_item]) + elif items: + return items[0] + else: + return '' + + +def dedent(text, *args, **kw): + """ + Dedent a string (remove common leading whitespace from all lines). + + Removes common leading whitespace from all lines in the string using + :func:`textwrap.dedent()`, removes leading and trailing empty lines using + :func:`trim_empty_lines()` and interpolates any arguments using + :func:`format()`. + + :param text: The text to dedent (a string). + :param args: Any positional arguments are interpolated using :func:`format()`. + :param kw: Any keyword arguments are interpolated using :func:`format()`. + :returns: The dedented text (a string). + + The :func:`compact()` function's documentation contains an example of how I + like to use the :func:`compact()` and :func:`dedent()` functions. The main + difference is that I use :func:`compact()` for text that will be presented + to the user (where whitespace is not so significant) and :func:`dedent()` + for data file and code generation tasks (where newlines and indentation are + very significant). + """ + dedented_text = textwrap.dedent(text) + trimmed_text = trim_empty_lines(dedented_text) + return format(trimmed_text, *args, **kw) + + +def format(text, *args, **kw): + """ + Format a string using the string formatting operator and/or :meth:`str.format()`. + + :param text: The text to format (a string). + :param args: Any positional arguments are interpolated into the text using + the string formatting operator (``%``). If no positional + arguments are given no interpolation is done. + :param kw: Any keyword arguments are interpolated into the text using the + :meth:`str.format()` function. If no keyword arguments are given + no interpolation is done. + :returns: The text with any positional and/or keyword arguments + interpolated (a string). + + The implementation of this function is so trivial that it seems silly to + even bother writing and documenting it. Justifying this requires some + context :-). + + **Why format() instead of the string formatting operator?** + + For really simple string interpolation Python's string formatting operator + is ideal, but it does have some strange quirks: + + - When you switch from interpolating a single value to interpolating + multiple values you have to wrap them in tuple syntax. Because + :func:`format()` takes a `variable number of arguments`_ it always + receives a tuple (which saves me a context switch :-). Here's an + example: + + >>> from humanfriendly.text import format + >>> # The string formatting operator. + >>> print('the magic number is %s' % 42) + the magic number is 42 + >>> print('the magic numbers are %s and %s' % (12, 42)) + the magic numbers are 12 and 42 + >>> # The format() function. + >>> print(format('the magic number is %s', 42)) + the magic number is 42 + >>> print(format('the magic numbers are %s and %s', 12, 42)) + the magic numbers are 12 and 42 + + - When you interpolate a single value and someone accidentally passes in a + tuple your code raises a :exc:`~exceptions.TypeError`. Because + :func:`format()` takes a `variable number of arguments`_ it always + receives a tuple so this can never happen. Here's an example: + + >>> # How expecting to interpolate a single value can fail. + >>> value = (12, 42) + >>> print('the magic value is %s' % value) + Traceback (most recent call last): + File "", line 1, in + TypeError: not all arguments converted during string formatting + >>> # The following line works as intended, no surprises here! + >>> print(format('the magic value is %s', value)) + the magic value is (12, 42) + + **Why format() instead of the str.format() method?** + + When you're doing complex string interpolation the :meth:`str.format()` + function results in more readable code, however I frequently find myself + adding parentheses to force evaluation order. The :func:`format()` function + avoids this because of the relative priority between the comma and dot + operators. Here's an example: + + >>> "{adjective} example" + " " + "(can't think of anything less {adjective})".format(adjective='silly') + "{adjective} example (can't think of anything less silly)" + >>> ("{adjective} example" + " " + "(can't think of anything less {adjective})").format(adjective='silly') + "silly example (can't think of anything less silly)" + >>> format("{adjective} example" + " " + "(can't think of anything less {adjective})", adjective='silly') + "silly example (can't think of anything less silly)" + + The :func:`compact()` and :func:`dedent()` functions are wrappers that + combine :func:`format()` with whitespace manipulation to make it easy to + write nice to read Python code. + + .. _variable number of arguments: https://docs.python.org/2/tutorial/controlflow.html#arbitrary-argument-lists + """ + if args: + text %= args + if kw: + text = text.format(**kw) + return text + + +def generate_slug(text, delimiter="-"): + """ + Convert text to a normalized "slug" without whitespace. + + :param text: The original text, for example ``Some Random Text!``. + :param delimiter: The delimiter used to separate words + (defaults to the ``-`` character). + :returns: The slug text, for example ``some-random-text``. + :raises: :exc:`~exceptions.ValueError` when the provided + text is nonempty but results in an empty slug. + """ + slug = text.lower() + escaped = delimiter.replace("\\", "\\\\") + slug = re.sub("[^a-z0-9]+", escaped, slug) + slug = slug.strip(delimiter) + if text and not slug: + msg = "The provided text %r results in an empty slug!" + raise ValueError(format(msg, text)) + return slug + + +def is_empty_line(text): + """ + Check if a text is empty or contains only whitespace. + + :param text: The text to check for "emptiness" (a string). + :returns: :data:`True` if the text is empty or contains only whitespace, + :data:`False` otherwise. + """ + return len(text) == 0 or text.isspace() + + +def join_lines(text): + """ + Remove "hard wrapping" from the paragraphs in a string. + + :param text: The text to reformat (a string). + :returns: The text without hard wrapping (a string). + + This function works by removing line breaks when the last character before + a line break and the first character after the line break are both + non-whitespace characters. This means that common leading indentation will + break :func:`join_lines()` (in that case you can use :func:`dedent()` + before calling :func:`join_lines()`). + """ + return re.sub(r'(\S)\n(\S)', r'\1 \2', text) + + +def pluralize(count, singular, plural=None): + """ + Combine a count with the singular or plural form of a word. + + :param count: The count (a number). + :param singular: The singular form of the word (a string). + :param plural: The plural form of the word (a string or :data:`None`). + :returns: The count and singular or plural word concatenated (a string). + + See :func:`pluralize_raw()` for the logic underneath :func:`pluralize()`. + """ + return '%s %s' % (count, pluralize_raw(count, singular, plural)) + + +def pluralize_raw(count, singular, plural=None): + """ + Select the singular or plural form of a word based on a count. + + :param count: The count (a number). + :param singular: The singular form of the word (a string). + :param plural: The plural form of the word (a string or :data:`None`). + :returns: The singular or plural form of the word (a string). + + When the given count is exactly 1.0 the singular form of the word is + selected, in all other cases the plural form of the word is selected. + + If the plural form of the word is not provided it is obtained by + concatenating the singular form of the word with the letter "s". Of course + this will not always be correct, which is why you have the option to + specify both forms. + """ + if not plural: + plural = singular + 's' + return singular if float(count) == 1.0 else plural + + +def random_string(length=(25, 100), characters=string.ascii_letters): + """random_string(length=(25, 100), characters=string.ascii_letters) + Generate a random string. + + :param length: The length of the string to be generated (a number or a + tuple with two numbers). If this is a tuple then a random + number between the two numbers given in the tuple is used. + :param characters: The characters to be used (a string, defaults + to :data:`string.ascii_letters`). + :returns: A random string. + + The :func:`random_string()` function is very useful in test suites; by the + time I included it in :mod:`humanfriendly.text` I had already included + variants of this function in seven different test suites :-). + """ + if not isinstance(length, numbers.Number): + length = random.randint(length[0], length[1]) + return ''.join(random.choice(characters) for _ in range(length)) + + +def split(text, delimiter=','): + """ + Split a comma-separated list of strings. + + :param text: The text to split (a string). + :param delimiter: The delimiter to split on (a string). + :returns: A list of zero or more nonempty strings. + + Here's the default behavior of Python's built in :meth:`str.split()` + function: + + >>> 'foo,bar, baz,'.split(',') + ['foo', 'bar', ' baz', ''] + + In contrast here's the default behavior of the :func:`split()` function: + + >>> from humanfriendly.text import split + >>> split('foo,bar, baz,') + ['foo', 'bar', 'baz'] + + Here is an example that parses a nested data structure (a mapping of + logging level names to one or more styles per level) that's encoded in a + string so it can be set as an environment variable: + + >>> from pprint import pprint + >>> encoded_data = 'debug=green;warning=yellow;error=red;critical=red,bold' + >>> parsed_data = dict((k, split(v, ',')) for k, v in (split(kv, '=') for kv in split(encoded_data, ';'))) + >>> pprint(parsed_data) + {'debug': ['green'], + 'warning': ['yellow'], + 'error': ['red'], + 'critical': ['red', 'bold']} + """ + return [token.strip() for token in text.split(delimiter) if token and not token.isspace()] + + +def split_paragraphs(text): + """ + Split a string into paragraphs (one or more lines delimited by an empty line). + + :param text: The text to split into paragraphs (a string). + :returns: A list of strings. + """ + paragraphs = [] + for chunk in text.split('\n\n'): + chunk = trim_empty_lines(chunk) + if chunk and not chunk.isspace(): + paragraphs.append(chunk) + return paragraphs + + +def tokenize(text): + """ + Tokenize a text into numbers and strings. + + :param text: The text to tokenize (a string). + :returns: A list of strings and/or numbers. + + This function is used to implement robust tokenization of user input in + functions like :func:`.parse_size()` and :func:`.parse_timespan()`. It + automatically coerces integer and floating point numbers, ignores + whitespace and knows how to separate numbers from strings even without + whitespace. Some examples to make this more concrete: + + >>> from humanfriendly.text import tokenize + >>> tokenize('42') + [42] + >>> tokenize('42MB') + [42, 'MB'] + >>> tokenize('42.5MB') + [42.5, 'MB'] + >>> tokenize('42.5 MB') + [42.5, 'MB'] + """ + tokenized_input = [] + for token in re.split(r'(\d+(?:\.\d+)?)', text): + token = token.strip() + if re.match(r'\d+\.\d+', token): + tokenized_input.append(float(token)) + elif token.isdigit(): + tokenized_input.append(int(token)) + elif token: + tokenized_input.append(token) + return tokenized_input + + +def trim_empty_lines(text): + """ + Trim leading and trailing empty lines from the given text. + + :param text: The text to trim (a string). + :returns: The trimmed text (a string). + """ + lines = text.splitlines(True) + while lines and is_empty_line(lines[0]): + lines.pop(0) + while lines and is_empty_line(lines[-1]): + lines.pop(-1) + return ''.join(lines) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/usage.py b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/usage.py new file mode 100644 index 0000000000000000000000000000000000000000..81ba943ae094854da1392380308b683bbbc23058 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/humanfriendly/usage.py @@ -0,0 +1,351 @@ +# Human friendly input/output in Python. +# +# Author: Peter Odding +# Last Change: June 11, 2021 +# URL: https://humanfriendly.readthedocs.io + +""" +Parsing and reformatting of usage messages. + +The :mod:`~humanfriendly.usage` module parses and reformats usage messages: + +- The :func:`format_usage()` function takes a usage message and inserts ANSI + escape sequences that highlight items of special significance like command + line options, meta variables, etc. The resulting usage message is (intended + to be) easier to read on a terminal. + +- The :func:`render_usage()` function takes a usage message and rewrites it to + reStructuredText_ suitable for inclusion in the documentation of a Python + package. This provides a DRY solution to keeping a single authoritative + definition of the usage message while making it easily available in + documentation. As a cherry on the cake it's not just a pre-formatted dump of + the usage message but a nicely formatted reStructuredText_ fragment. + +- The remaining functions in this module support the two functions above. + +Usage messages in general are free format of course, however the functions in +this module assume a certain structure from usage messages in order to +successfully parse and reformat them, refer to :func:`parse_usage()` for +details. + +.. _DRY: https://en.wikipedia.org/wiki/Don%27t_repeat_yourself +.. _reStructuredText: https://en.wikipedia.org/wiki/ReStructuredText +""" + +# Standard library modules. +import csv +import functools +import logging +import re + +# Standard library module or external dependency (see setup.py). +from importlib import import_module + +# Modules included in our package. +from humanfriendly.compat import StringIO +from humanfriendly.text import dedent, split_paragraphs, trim_empty_lines + +# Public identifiers that require documentation. +__all__ = ( + 'find_meta_variables', + 'format_usage', + 'import_module', # previously exported (backwards compatibility) + 'inject_usage', + 'parse_usage', + 'render_usage', + 'USAGE_MARKER', +) + +USAGE_MARKER = "Usage:" +"""The string that starts the first line of a usage message.""" + +START_OF_OPTIONS_MARKER = "Supported options:" +"""The string that marks the start of the documented command line options.""" + +# Compiled regular expression used to tokenize usage messages. +USAGE_PATTERN = re.compile(r''' + # Make sure whatever we're matching isn't preceded by a non-whitespace + # character. + (?=6.5; extra == "gui" +Requires-Dist: Pillow; extra == "gui" +Requires-Dist: reportlab; extra == "gui" +Requires-Dist: scikit-learn; extra == "gui" +Provides-Extra: face3d +Requires-Dist: cython; extra == "face3d" +Requires-Dist: albumentations; extra == "face3d" +Requires-Dist: matplotlib; extra == "face3d" +Dynamic: author +Dynamic: author-email +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: provides-extra +Dynamic: requires-dist +Dynamic: summary + +# InsightFace Python Library + +## License + +The code of InsightFace Python Library is released under the MIT License. There is no limitation for both academic and commercial usage. + +**The pretrained models we provided with this library are available for non-commercial research purposes only, including both auto-downloading models and manual-downloading models.** + +## Install + +### Install Inference Backend + +For ``insightface<=0.1.5``, we use MXNet as inference backend. + +Starting from insightface>=0.2, we use onnxruntime as inference backend. + +You have to install ``onnxruntime-gpu`` manually to enable GPU inference, or install ``onnxruntime`` to use CPU only inference. + +### Install InsightFace Evaluation Studio GUI + +InsightFace 1.0.1 includes a local desktop GUI: + +``` +pip install "insightface[gui]" +insightface-gui +``` + +Development install: + +``` +cd python-package +pip install -e ".[gui]" +insightface-gui +``` + +Equivalent launch commands: + +``` +insightface-eval-studio +insightface-desktop +python -m insightface.gui +``` + +The GUI is called **InsightFace Evaluation Studio**. It provides local 1:1 face +compare, People Library management, 1:N face search, multi-face photo +recognition, batch folder processing, album people clustering, enterprise +evaluation reports, and a face swap entry point. User images, videos, +embeddings, databases, and reports are stored locally by default under +``~/.insightface/gui`` and are not uploaded automatically. +Image and video previews are clickable upload targets: click +``Click to upload or drag a file here`` or drop a file onto the preview. The +preview changes color on hover and during drag-over. Loaded previews show a +small delete button and can be replaced by dragging in another file. + +The desktop app uses mode-based navigation. Choose **Face Recognition**, +**Album Management**, **Face Swap**, or **Enterprise Evaluation** from the +persistent **Workflows** rail on the left side of the window. Face Recognition +is a single **Query & Gallery** workspace: upload +one query image and one gallery image for 1:1 compare, or upload multiple +gallery images / a folder for 1:N gallery search. Album Management uses a +single **Album** workspace for adding one or more folders, refreshing new +images, DBSCAN clustering with a default cosine similarity threshold of `0.48`, +and reviewing original photo thumbnails. Album directories and clustering results are saved +locally for the next launch. Enterprise Evaluation is a single workspace for +local 1:1 and 1:N identity-folder evaluation, Auto Split, metrics, and PDF +report export. Enterprise datasets must pass validation before evaluation; the +validator checks folder layout, gallery/probe rules, and the selected +multi-face handling policy. +Global utilities are available from the top bar and **Tools** menu: +**Settings**, **Models**, and **License**. **Settings** controls the UI theme +and language. Language defaults to the operating system when it is supported, +otherwise English. Supported GUI languages are English, Chinese, Japanese, +Korean, Spanish, French, German, Portuguese, and Russian. Available themes +include System, Precision Light, Studio Dark, Graphite Pro, Azure Lab, Emerald +Focus, and Crimson Audit. Workspace paths are chosen on first launch and are +not changed from the settings dialog. + +Models are not downloaded automatically by the GUI. Open **Models > Downloads**, +click **Refresh Download URLs** to read the latest GitHub Releases +asset URLs, then explicitly download the selected package. Downloaded zip files +are cached under ``~/.insightface/gui/cache/models`` and extracted under +``~/.insightface/models//``. +The Downloads tab also lists GFPGANv1.4 as a third-party face restoration +model. After it is downloaded, enable **GFPGAN post-processing** in +**Models > Runtime** to run 512x512 GFPGAN restoration after face swap. +Detection size defaults to **Auto**, which runs joint 128x128 and 640x640 +detection. Face swap models are selected in **Models > Runtime** from already +downloaded swap models only; the Face Swap workspace loads the configured swap +model only when a swap is run. + +### Optional face3d Build + +InsightFace 1.0.1 does not build the optional ``face3d`` Cython/C++ extension by +default. This keeps the default install lighter and avoids local compiler +requirements. Users who need the legacy mask renderer / face3d path can opt in: + +``` +pip install -e ".[face3d]" --no-build-isolation --config-settings editable_mode=compat +python setup.py build_ext --inplace --with-face3d +``` + +The same build can also be enabled with: + +``` +INSIGHTFACE_WITH_FACE3D=1 python setup.py build_ext --inplace +``` + +More details: + +- ``docs/gui.md`` +- ``docs/commercial_evaluation.md`` +- ``docs/gui_packaging.md`` + +## Change Log + +### [1.0.1] - 2026-05-23 + +#### Changed + +- Remove the PyPI package metadata license classifier field while keeping the README license guidance. +- Move direct `Pillow` and `scikit-learn` requirements to the GUI extra, and `matplotlib` to the optional `face3d` extra. +- Remove unused base dependencies on `easydict` and `prettytable`. + +### [1.0] - 2026-05-23 + +#### Added + +- Add **InsightFace Evaluation Studio**, a cross-platform PySide6 desktop GUI for local face recognition, album grouping, enterprise evaluation/report export, and face swap trials. +- Add GUI launch commands: ``insightface-gui``, ``insightface-eval-studio``, ``insightface-desktop``, and ``python -m insightface.gui``. + +#### Changed + +- Default ``FaceAnalysis.prepare()`` detection size is now Auto, running SCRFD at both 128x128 and 640x640 before unified NMS. +- Route detection models loaded by ``model_zoo.get_model()`` through ``SCRFD`` by default. +- The optional ``face3d`` Cython/C++ extension is no longer built by default; use ``--with-face3d`` or ``INSIGHTFACE_WITH_FACE3D=1`` to opt in. + +### [0.7.1] - 2022-12-14 + +#### Changed + +- Change model downloading provider to cloudfront. + +### [0.7] - 2022-11-28 + +#### Added + +- Add face swapping model and example. + +#### Changed + +- Set default ORT provider to CUDA and CPU. + +### [0.6] - 2022-01-29 + +#### Added + +- Add pose estimation in face-analysis app. + +#### Changed + +- Change model automated downloading url, to ucloud. + + +## Quick Example + +``` +import cv2 +import numpy as np +import insightface +from insightface.app import FaceAnalysis +from insightface.data import get_image as ins_get_image + +app = FaceAnalysis(providers=['CUDAExecutionProvider', 'CPUExecutionProvider']) +app.prepare(ctx_id=0) # Auto detection size: 128x128 + 640x640 +img = ins_get_image('t1') +faces = app.get(img) +rimg = app.draw_on(img, faces) +cv2.imwrite("./t1_output.jpg", rimg) +``` + +This quick example will detect faces from the ``t1.jpg`` image and draw detection results on it. + + + +## Model Zoo + +In the latest version of insightface library, we provide following model packs: + +Name in **bold** is the default model pack. **Auto** means we can download the model pack through the python library directly. + +Once you manually downloaded the zip model pack, unzip it under `~/.insightface/models/` first before you call the program. + +| Name | Detection Model | Recognition Model | Alignment | Attributes | Model-Size | Link | Auto | +| ------------- | --------------- | -------------------- | ------------ | ---------- | ---------- | ------------------------------------------------------------ | ------------- | +| antelopev2 | SCRFD-10GF | ResNet100@Glint360K | 2d106 & 3d68 | Gender&Age | 407MB | [link](https://drive.google.com/file/d/18wEUfMNohBJ4K3Ly5wpTejPfDzp-8fI8/view?usp=sharing) | N | +| **buffalo_l** | SCRFD-10GF | ResNet50@WebFace600K | 2d106 & 3d68 | Gender&Age | 326MB | [link](https://drive.google.com/file/d/1qXsQJ8ZT42_xSmWIYy85IcidpiZudOCB/view?usp=sharing) | Y | +| buffalo_m | SCRFD-2.5GF | ResNet50@WebFace600K | 2d106 & 3d68 | Gender&Age | 313MB | [link](https://drive.google.com/file/d/1net68yNxF33NNV6WP7k56FS6V53tq-64/view?usp=sharing) | N | +| buffalo_s | SCRFD-500MF | MBF@WebFace600K | 2d106 & 3d68 | Gender&Age | 159MB | [link](https://drive.google.com/file/d/1pKIusApEfoHKDjeBTXYB3yOQ0EtTonNE/view?usp=sharing) | N | +| buffalo_sc | SCRFD-500MF | MBF@WebFace600K | - | - | 16MB | [link](https://drive.google.com/file/d/19I-MZdctYKmVf3nu5Da3HS6KH5LBfdzG/view?usp=sharing) | N | + + + +Recognition Accuracy: + +| Name | MR-ALL | African | Caucasian | South Asian | East Asian | LFW | CFP-FP | AgeDB-30 | IJB-C(E4) | +| :-------- | ------ | ------- | --------- | ----------- | ---------- | ----- | ------ | -------- | --------- | +| buffalo_l | 91.25 | 90.29 | 94.70 | 93.16 | 74.96 | 99.83 | 99.33 | 98.23 | 97.25 | +| buffalo_s | 71.87 | 69.45 | 80.45 | 73.39 | 51.03 | 99.70 | 98.00 | 96.58 | 95.02 | + +*buffalo_m has the same accuracy with buffalo_l.* + +*buffalo_sc has the same accuracy with buffalo_s.* + + + +**Note that these models are available for non-commercial research purposes only.** + + + +For insightface>=0.3.3, models will be downloaded automatically once we init ``app = FaceAnalysis()`` instance. + +For insightface==0.3.2, you must first download the model package by command: + +``` +insightface-cli model.download buffalo_l +``` + +## Use Your Own Licensed Model + +You can simply create a new model directory under ``~/.insightface/models/`` and replace the pretrained models we provide with your own models. And then call ``app = FaceAnalysis(name='your_model_zoo')`` to load these models. + +## Call Models + +The latest insightface libary only supports onnx models. Once you have trained detection or recognition models by PyTorch, MXNet or any other frameworks, you can convert it to the onnx format and then they can be called with insightface library. + +### Call Detection Models + +``` +import cv2 +import numpy as np +import insightface +from insightface.app import FaceAnalysis +from insightface.data import get_image as ins_get_image + +# Method-1, use FaceAnalysis +app = FaceAnalysis(allowed_modules=['detection']) # enable detection model only +app.prepare(ctx_id=0) # Auto detection size: 128x128 + 640x640 + +# Method-2, load model directly +detector = insightface.model_zoo.get_model('your_detection_model.onnx') +detector.prepare(ctx_id=0) # SCRFD defaults to Auto: 128x128 + 640x640 + +``` + +### Call Recognition Models + +``` +import cv2 +import numpy as np +import insightface +from insightface.app import FaceAnalysis +from insightface.data import get_image as ins_get_image + +handler = insightface.model_zoo.get_model('your_recognition_model.onnx') +handler.prepare(ctx_id=0) + +``` diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/RECORD b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..9221dd0f7c5d508bf923af7ecdc2c32302e95434 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/RECORD @@ -0,0 +1,252 @@ +../../bin/insightface-cli,sha256=wQjfsCz53-f-1A17AB8kcyZNt-pfow-fidwwunosbb0,208 +../../bin/insightface-desktop,sha256=wiwDptMx9PH7p-huwjNc7oZUG2iDkeIROXwQD-jj_G4,196 +../../bin/insightface-eval-studio,sha256=wiwDptMx9PH7p-huwjNc7oZUG2iDkeIROXwQD-jj_G4,196 +../../bin/insightface-gui,sha256=wiwDptMx9PH7p-huwjNc7oZUG2iDkeIROXwQD-jj_G4,196 +insightface-1.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +insightface-1.0.1.dist-info/METADATA,sha256=rxG5pUobS78YoGKuT5P05bGTFpZ3WMYS_oeLT3JPEJw,11712 +insightface-1.0.1.dist-info/RECORD,, +insightface-1.0.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +insightface-1.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91 +insightface-1.0.1.dist-info/entry_points.txt,sha256=tWdF_FWnE-pr_pdwBcAZ77T4D9FHb0Br-1GkaNYw-O8,234 +insightface-1.0.1.dist-info/top_level.txt,sha256=tb2FTDa8Fids6iMl84QCWJSTqtEOGoN8z-N4uY1vpyY,12 +insightface-1.0.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1 +insightface/__init__.py,sha256=cXGEtfcQAfFAjzEyIxAHYWJVESiIUF_RglaJvpOHCGE,423 +insightface/__pycache__/__init__.cpython-311.pyc,, +insightface/app/__init__.py,sha256=uHGbJE5UdRweLoaLzr81IN3g4wkbc2d5ZRfthLDDbgY,331 +insightface/app/__pycache__/__init__.cpython-311.pyc,, +insightface/app/__pycache__/common.cpython-311.pyc,, +insightface/app/__pycache__/face_analysis.cpython-311.pyc,, +insightface/app/__pycache__/mask_renderer.cpython-311.pyc,, +insightface/app/common.py,sha256=wn7GENFs20WdpmH-HqFqTbAerRRbDmWQZDJYUhXVZGg,1436 +insightface/app/face_analysis.py,sha256=dZJxr3Itr6H2AjVFUM39hM1wXeAYSmO0N1KYJjW89f8,4876 +insightface/app/mask_renderer.py,sha256=T_t9VfdJ2dyK1MRADRWiNv8XJIRxGh07HXVYsU9lioY,9846 +insightface/commands/__init__.py,sha256=zh1ULAhm-S6H0Im8PbvtQXhmMEgSXMcS1Y8i2EHcsHI,315 +insightface/commands/__pycache__/__init__.cpython-311.pyc,, +insightface/commands/__pycache__/insightface_cli.cpython-311.pyc,, +insightface/commands/__pycache__/model_download.cpython-311.pyc,, +insightface/commands/__pycache__/rec_add_mask_param.cpython-311.pyc,, +insightface/commands/insightface_cli.py,sha256=AakpVIhm8sJ9k9Q8rUQ79O7i8PY73tk1OgOwu0hbgKw,724 +insightface/commands/model_download.py,sha256=rKmPuV-kyN0O_5nj3Hw_UVt9t4PyYAx1KmFurJDPi78,1236 +insightface/commands/rec_add_mask_param.py,sha256=_tvoyVWu1ObunR0hyvoSVklqm2hX2CikYAfO9rdDRd0,3878 +insightface/data/__init__.py,sha256=S_OQMhtce5Jobn6x4R6XJ_nQ0o-DCOq3Cu4Q51cxNKA,67 +insightface/data/__pycache__/__init__.cpython-311.pyc,, +insightface/data/__pycache__/image.cpython-311.pyc,, +insightface/data/__pycache__/pickle_object.cpython-311.pyc,, +insightface/data/__pycache__/rec_builder.cpython-311.pyc,, +insightface/data/image.py,sha256=WXrEGJcexdR0jGqcQYDUpbHSlv7cg61ujkfygSb34Ck,769 +insightface/data/images/Tom_Hanks_54745.png,sha256=hUXaKU6MfHmREWnDkV_thSjxlgzQ7Zm5JFN4jKQnUIM,12123 +insightface/data/images/mask_black.jpg,sha256=2BxAx3oOOHF9x-HUyplOK8WO-oBEZf-NCdkV2u3fLIM,21308 +insightface/data/images/mask_blue.jpg,sha256=pV7CsYHeQUOvJ8RBhS67S702T7DgucRrsXYxxZvEyEA,44728 +insightface/data/images/mask_green.jpg,sha256=eVJrWjHvdct_5RInq8adWJ5Le6Odu_UeeRR9pXej8VQ,6116 +insightface/data/images/mask_white.jpg,sha256=Ot7mumaA0mGXu-qV3rnTNSUtAcLFHq0j4Br5eEwxCqY,78905 +insightface/data/images/t1.jpg,sha256=R_aC6UW2Wfk6nkkLnJxKKoZKvmTazp4aKJOEXd_WlIk,128824 +insightface/data/objects/meanshape_68.pkl,sha256=Of_s-EunPw0Nfkk4CDO6iHE8n83sUd9PesRaSLj0zFE,974 +insightface/data/pickle_object.py,sha256=1cOkh6aQg94fimmgcyrs5q3ZZ3sZI8w79eZRtWF5TYw,587 +insightface/data/rec_builder.py,sha256=jyNLB5kl0bmONpRKTzEM_xMYUBgoPogw-swv5To1owU,2511 +insightface/gui/__init__.py,sha256=ZcKfDwqRGKyCzd6a-4OSe0FTKEZYaYYN37dj-IWfTAU,374 +insightface/gui/__main__.py,sha256=sn8kguLzeHiZjPAMTuzAUelFdNsHFNBIc055YwHC-X4,1625 +insightface/gui/__pycache__/__init__.cpython-311.pyc,, +insightface/gui/__pycache__/__main__.cpython-311.pyc,, +insightface/gui/__pycache__/app.cpython-311.pyc,, +insightface/gui/__pycache__/main_window.cpython-311.pyc,, +insightface/gui/__pycache__/page_registry.cpython-311.pyc,, +insightface/gui/__pycache__/resources.cpython-311.pyc,, +insightface/gui/app.py,sha256=sDobvNU56gOGGbg_fvYSYWKI_Pb2dg26w7oqJ9LGU4s,5195 +insightface/gui/assets/app_icon.icns,sha256=HNL-l3OsWYwMW4WX6cml8uvX0OMsHJ5g0VUkqGO_v_U,71940 +insightface/gui/assets/app_icon.ico,sha256=3Uh7dfSDXJ-zZtB0Q5vXM6eep-5EJQeHcBEeO2vihSQ,77226 +insightface/gui/assets/app_icon.png,sha256=gqo_6eAXEFmUuSMmTnqv1ZJRN1fC7BesLmg_REzFKdM,50157 +insightface/gui/core/__init__.py,sha256=o8Yyd61EjCPnomTikZYRt1khpbB6sZYZRLXey6wElYk,55 +insightface/gui/core/__pycache__/__init__.cpython-311.pyc,, +insightface/gui/core/__pycache__/camera.cpython-311.pyc,, +insightface/gui/core/__pycache__/clustering.cpython-311.pyc,, +insightface/gui/core/__pycache__/config.cpython-311.pyc,, +insightface/gui/core/__pycache__/constants.cpython-311.pyc,, +insightface/gui/core/__pycache__/evaluation.cpython-311.pyc,, +insightface/gui/core/__pycache__/exporters.cpython-311.pyc,, +insightface/gui/core/__pycache__/face_engine.cpython-311.pyc,, +insightface/gui/core/__pycache__/i18n.cpython-311.pyc,, +insightface/gui/core/__pycache__/licensing.cpython-311.pyc,, +insightface/gui/core/__pycache__/links.cpython-311.pyc,, +insightface/gui/core/__pycache__/logging.cpython-311.pyc,, +insightface/gui/core/__pycache__/model_downloads.cpython-311.pyc,, +insightface/gui/core/__pycache__/models.cpython-311.pyc,, +insightface/gui/core/__pycache__/navigation.cpython-311.pyc,, +insightface/gui/core/__pycache__/paths.cpython-311.pyc,, +insightface/gui/core/__pycache__/quality.cpython-311.pyc,, +insightface/gui/core/__pycache__/recognition.cpython-311.pyc,, +insightface/gui/core/__pycache__/reporting.cpython-311.pyc,, +insightface/gui/core/__pycache__/storage.cpython-311.pyc,, +insightface/gui/core/__pycache__/swap.cpython-311.pyc,, +insightface/gui/core/__pycache__/theme.cpython-311.pyc,, +insightface/gui/core/__pycache__/tooltips.cpython-311.pyc,, +insightface/gui/core/__pycache__/utils.cpython-311.pyc,, +insightface/gui/core/__pycache__/video.cpython-311.pyc,, +insightface/gui/core/camera.py,sha256=GwFembtOIZDXjflcjKJo0hC9sv8hTDmXJs3MV301CoA,414 +insightface/gui/core/clustering.py,sha256=3js84VpLG_ND-Glfbxh4JEMhufR8e1NypCfiKhEo9yA,2192 +insightface/gui/core/config.py,sha256=2a-_Njkdiu66Pd0ClA0SO_uBtRs-X4bwekN2PyOuKPA,4407 +insightface/gui/core/constants.py,sha256=6Xy50FPGrsdCpF98_t_2NaRDbvQu307IMROThT0JchE,1631 +insightface/gui/core/evaluation.py,sha256=ovXdAFLZ0UmL88TvkWxUES_phIndN2Gy_E2uYIrSbEk,50337 +insightface/gui/core/exporters.py,sha256=mPvWWUJlLGocKCsHZgE87rheMBJQSEsm66WE_ZGEpxQ,1624 +insightface/gui/core/face_engine.py,sha256=TMdjeE9TRkgFK2u1za5z2WbWcpkLfHzn2dC2FWPZ6HQ,17809 +insightface/gui/core/i18n.py,sha256=LsEnYUvMgNataATcTfQ1b1wS-_dycqKgZeybI60GwEw,227365 +insightface/gui/core/licensing.py,sha256=6hh9v3k2KyHmmbcJuR-Mp9G5Svi9hUBbBvZ1yx8jItc,1553 +insightface/gui/core/links.py,sha256=ogVh1gMtzuHSXYlaJ2dfYFlx8p5LIYMXZ9CgxpWc3nY,1539 +insightface/gui/core/logging.py,sha256=PEHJJ8-phogOL9oObR6Y4vPxyZzK5KGJPEyzrbZLzCM,822 +insightface/gui/core/model_downloads.py,sha256=2AnkPFd9RvxzH0OrOlGYxrVcDA70ZtmD2J0VoPTJjK8,13020 +insightface/gui/core/models.py,sha256=bGgocoz3XR-wxltBURNF-34eSuAo_1vVkFT1EVbSdpw,3604 +insightface/gui/core/navigation.py,sha256=rTKodZyOtlH-I5XbJUXnaT-OLqi_RkOhQwlS5HCZUwM,2943 +insightface/gui/core/paths.py,sha256=wIW-781mSBOaKsc2WEEr1NOS3ZDIXDej57jJ7r1WPAw,1251 +insightface/gui/core/quality.py,sha256=MqoNehm_bk8nYA4cIO20N4llXYI1z-GVBzybaDW0I9k,3487 +insightface/gui/core/recognition.py,sha256=PM4txsjmkW5ACr9H-LADUSkI4RwNPM_Wmoo1RMc1nKM,4166 +insightface/gui/core/reporting.py,sha256=tJbXk5X0n5b1Bjrj6y4MZzsAGmaSqt_7zHXwJcWN6Yg,37506 +insightface/gui/core/storage.py,sha256=Bp-IbEibeBk9gLQD_bk6o3VnH-jLVLGM34eqSriIZAA,29323 +insightface/gui/core/swap.py,sha256=3J4WuhHNGgzr-Ixppzz5FbcrAG6EuiNcwn-PbpGy9cM,4599 +insightface/gui/core/theme.py,sha256=fukdmvQKiu5aAEV-JrzfJQ-vwyC6b5k4hv94mVpJhxY,20571 +insightface/gui/core/tooltips.py,sha256=GUv4-mCLd00q8_wfSWHdtRNsR_lA1dt177xy9xxMWXo,5651 +insightface/gui/core/utils.py,sha256=hBIgOURw5zA1I1NVW2PTqwm1fQ_GXm0R-ny15VYOlBQ,4517 +insightface/gui/core/video.py,sha256=E4SYwwyu-Vl8ZYg0VHDGTbl_xi0mPUMbUK1fSd6msvo,1348 +insightface/gui/dialogs/__init__.py,sha256=pbRk6H8VOSU7nIQuqYWjMFlzR_H45yBF9uI9BUgD4oo,56 +insightface/gui/dialogs/__pycache__/__init__.cpython-311.pyc,, +insightface/gui/dialogs/__pycache__/license_dialog.cpython-311.pyc,, +insightface/gui/dialogs/__pycache__/model_manager_dialog.cpython-311.pyc,, +insightface/gui/dialogs/__pycache__/settings_dialog.cpython-311.pyc,, +insightface/gui/dialogs/license_dialog.py,sha256=vZOcAquf9akwq3HNvz4xFQLvqToWEy8RHgDNOQGSSNM,924 +insightface/gui/dialogs/model_manager_dialog.py,sha256=M5UpHHztD0-URJg2MQPmqOCVmIZcd87k9Ub4_HPmCWA,2767 +insightface/gui/dialogs/settings_dialog.py,sha256=s7xF4nPx_Wgk_ZEpR1EA1k7c42fUaejjLQuJYKzSTK8,3299 +insightface/gui/main_window.py,sha256=2VpjbrfS76EMGlryqCOcacs0Cv-V2qmQ7Fn7HNyMQ98,27011 +insightface/gui/page_registry.py,sha256=ywAK2gxH_as88A9naw1-h3PSMNA1iFQ03gELfF4xWzg,4798 +insightface/gui/pages/__init__.py,sha256=SnFsFlY0qbAEePfKBIAkfybTOBcWQHI5RsNgR28eL9E,42 +insightface/gui/pages/__pycache__/__init__.cpython-311.pyc,, +insightface/gui/pages/__pycache__/album_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/album_people_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/base.cpython-311.pyc,, +insightface/gui/pages/__pycache__/batch_processing_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/camera_recognition_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/compare_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/dashboard_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/enterprise_eval_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/face_search_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/face_swap_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/license_center_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/mode_dashboards.cpython-311.pyc,, +insightface/gui/pages/__pycache__/model_download_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/model_settings_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/multiface_photo_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/people_library_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/placeholder_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/reports_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/settings_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/verification_page.cpython-311.pyc,, +insightface/gui/pages/__pycache__/video_search_page.cpython-311.pyc,, +insightface/gui/pages/album_page.py,sha256=x8TdEXdtJhBG581risnEfswJk-8m2FS8TCD4yXTogeQ,26779 +insightface/gui/pages/album_people_page.py,sha256=WpAAWfXE2lqA1DJIe9H4hlOTLCtBO_r7I_SoPFuRpjE,4835 +insightface/gui/pages/base.py,sha256=hvuon420dZIbTT2ojh33xkXmR4LTtJVCo3AYZWOWeJ0,4079 +insightface/gui/pages/batch_processing_page.py,sha256=RMM_5DoHM3lVlL2KuDvXA9F3TqKRp5etPnRakpFfU90,6664 +insightface/gui/pages/camera_recognition_page.py,sha256=XMe9AhS2vDaHBansSWph5aDCtCZhxUYmwAofQqUcwfQ,1746 +insightface/gui/pages/compare_page.py,sha256=DnGld4XxniZglREWLfjpl_gp7RPJ_HtHtX4IH0b6mWk,7811 +insightface/gui/pages/dashboard_page.py,sha256=ZMQvTV_l7Tj7TnH5qbEcE-3L7gTexgI3ni0bHelyD2I,2763 +insightface/gui/pages/enterprise_eval_page.py,sha256=AOiTzs1nKfSt7AKNBgRv3rVWANLWRYehGndSMZ8hJkQ,46986 +insightface/gui/pages/face_search_page.py,sha256=QiHzlOSH1mPa2OmxH7fm30qQ-fW3nm2q7__DIwyycHs,8161 +insightface/gui/pages/face_swap_page.py,sha256=vVEBrrPyza4SDCZ_0pSSqDdjvoQpzDOkeazmEqvE9qw,14252 +insightface/gui/pages/license_center_page.py,sha256=WNkh0gZBsFBHC1QIdaqzFPkrRtVzB3D-QfyZxeF-ZN0,3087 +insightface/gui/pages/mode_dashboards.py,sha256=UWYiSPuV0uGe5OEHDFSts3AD4iekJ4T0TAsBkLFw2qc,5589 +insightface/gui/pages/model_download_page.py,sha256=7PgBwXf-iHCG-kWR3Hs8YmNgXhfy5PaHricVevE0P00,7580 +insightface/gui/pages/model_settings_page.py,sha256=9ZrFhC7EigZ3Ptpx86xORoFbHNnoNBcje4bcuzT0rVw,11681 +insightface/gui/pages/multiface_photo_page.py,sha256=rW_lFURydy9U7aIqrjXoM24-wf3PZvSASVhOwqMzJ7Q,6426 +insightface/gui/pages/people_library_page.py,sha256=EA0HhxL5cElklauA7wDw85zdn09CPdmCGApMjdbH29s,14988 +insightface/gui/pages/placeholder_page.py,sha256=2GHqToCOS2IAmmQOzZKoyGFbnjr0R7vQHyHGDcF3Fsw,2965 +insightface/gui/pages/reports_page.py,sha256=OdL032LCPwg9EPNx47G4sZPpehJS4VQFH_nQNkNlP6A,3805 +insightface/gui/pages/settings_page.py,sha256=zE9Pie1OwH3rEmvD4fGKzxedMaP1nSFY0NVPxXKQ8b0,5404 +insightface/gui/pages/verification_page.py,sha256=64gmBoyzlCc95mb7fJRvjntLQ8WyCOWZvmuguAm2gTM,28882 +insightface/gui/pages/video_search_page.py,sha256=eTL6ubz9RwLVwLLhVKQy_5F_Ssx5d3kpGqMHsUZVR1Y,5727 +insightface/gui/resources.py,sha256=HFOHQCDc-WCwd_KDM_MdfxC3bZrdGRMg7vno1Rvjl60,2738 +insightface/gui/widgets/__init__.py,sha256=aeWeTdZAdKqA6IPw90mzKqw6I6g4iwt33D9RpfGo3oU,61 +insightface/gui/widgets/__pycache__/__init__.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/drop_input.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/face_overlay.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/face_table.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/image_viewer.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/metric_card.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/person_card.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/progress_dialog.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/table_utils.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/threshold_slider.cpython-311.pyc,, +insightface/gui/widgets/__pycache__/upload_preview.cpython-311.pyc,, +insightface/gui/widgets/drop_input.py,sha256=K1Mb4YhH8XvrBPREr_hvmrZNMZ9cwD5wHlXDn8uQ-Eg,9509 +insightface/gui/widgets/face_overlay.py,sha256=OP8jWOkKU4U2-yNUgMxeAPWOlaLKi8N-L5y6Ac_9z2I,262 +insightface/gui/widgets/face_table.py,sha256=g2XiFvyvfjcFXWYyDo0ngibWF_0om7dzWgyj2NS_ffc,824 +insightface/gui/widgets/image_viewer.py,sha256=lzZJLClyiiLGkbsEAv5O9N1z85eAoJe7C475txK40Gc,4951 +insightface/gui/widgets/metric_card.py,sha256=CtWQsxyXDBsfJYqqHYrdlU8f1q0n_MxVnKuyIGdz6B4,672 +insightface/gui/widgets/person_card.py,sha256=mJgEfgw6pvYdo529ogYO5iwqlrb1flDLxxZQC-G13AA,730 +insightface/gui/widgets/progress_dialog.py,sha256=1-1at3sEAmiNSW2v-3auIftChju2-BCpMQEjlLZJeCw,649 +insightface/gui/widgets/table_utils.py,sha256=lvkZ9bgHTOIqeJ8aRUEBXLB8U1hQCKNsP01vltLL0yI,3011 +insightface/gui/widgets/threshold_slider.py,sha256=9_iUTh2qJ8E_RsyXppRKj1FvcgZpKWCJJTAwyerb7kg,1199 +insightface/gui/widgets/upload_preview.py,sha256=gxZH6YZvVsC1mIEFMxFEBwALemn_HZpV9_N_VzDKgyw,8553 +insightface/model_zoo/__init__.py,sha256=lwxUhQS9qMmp5UElxp9acWea-eeLfjLPFyb66Y_jua4,195 +insightface/model_zoo/__pycache__/__init__.cpython-311.pyc,, +insightface/model_zoo/__pycache__/arcface_onnx.cpython-311.pyc,, +insightface/model_zoo/__pycache__/attribute.cpython-311.pyc,, +insightface/model_zoo/__pycache__/inswapper.cpython-311.pyc,, +insightface/model_zoo/__pycache__/landmark.cpython-311.pyc,, +insightface/model_zoo/__pycache__/model_store.cpython-311.pyc,, +insightface/model_zoo/__pycache__/model_zoo.cpython-311.pyc,, +insightface/model_zoo/__pycache__/retinaface.cpython-311.pyc,, +insightface/model_zoo/__pycache__/scrfd.cpython-311.pyc,, +insightface/model_zoo/arcface_onnx.py,sha256=iQQWlKnC7J-ExQZ5eoELXclatX-JQH3lQd5ipv6pgak,3111 +insightface/model_zoo/attribute.py,sha256=kDEfRsQxXbMetgzVKtxOiBnDXM9bgUsEs9CFjxCIYfc,3351 +insightface/model_zoo/inswapper.py,sha256=J0O5MKxwd7EpBmPsRdZQHYVYXRCzwpPpVBlrOaNWaTI,4649 +insightface/model_zoo/landmark.py,sha256=oeO6SC_FPv5_E86Nw7AejeBLa1FQudPsfXnlKlPgQ48,4198 +insightface/model_zoo/model_store.py,sha256=Cu2-Wlxi5OJO7w19et-Ti7CgmUd0FwzGu2382c24uHY,3117 +insightface/model_zoo/model_zoo.py,sha256=aQBhKsmx8Tl89wESR_ICmmm4d6fzx8_pFJT70oDVS6I,3552 +insightface/model_zoo/retinaface.py,sha256=OWNa8Q4-ZaL-lehrrUSBW10oVdZPI5ZPZ54J0qn-AEo,13965 +insightface/model_zoo/scrfd.py,sha256=iJjR-QaQ1GvuNx4d4x0a9gg3mIJype75BMW6ieD7jYM,16065 +insightface/thirdparty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +insightface/thirdparty/__pycache__/__init__.cpython-311.pyc,, +insightface/thirdparty/face3d/__init__.py,sha256=qC23ro5v5CLJPBeI0RWeKfr4WHt0sDbKPVUKmzEtYpM,86 +insightface/thirdparty/face3d/__pycache__/__init__.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh/__init__.py,sha256=tXbK4GLByoYbaT9_tnYj08tayRVZ75zB3EEtnYMQ65M,286 +insightface/thirdparty/face3d/mesh/__pycache__/__init__.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh/__pycache__/io.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh/__pycache__/light.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh/__pycache__/render.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh/__pycache__/transform.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh/__pycache__/vis.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh/io.py,sha256=EgS9-zH-B4cmM7InJME_lW5_ecKP3a1Rpy0DjhiekNs,4938 +insightface/thirdparty/face3d/mesh/light.py,sha256=6Qy2BJEVC_AeTRbsMIVbnE7rSoilil0VADuTp75Rt1A,7492 +insightface/thirdparty/face3d/mesh/render.py,sha256=rtzU-Gzkel9tGQ9nmMT0jNk8mWjp3gcmmCSf9OBVeWI,4597 +insightface/thirdparty/face3d/mesh/transform.py,sha256=Iu9iHUkLn0nS_tXcvNEeyJNBZKVlq61sTU3siec0csc,12207 +insightface/thirdparty/face3d/mesh/vis.py,sha256=RKNnmTbZ4ZgsaaTjfLCcr6atXdlQ8Ca8atIumXDCnUY,791 +insightface/thirdparty/face3d/mesh_numpy/__init__.py,sha256=UhRCZrUyRx3dS0LvYZqeJPNB6yA-l2tcLVR9dhNxoFU,211 +insightface/thirdparty/face3d/mesh_numpy/__pycache__/__init__.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh_numpy/__pycache__/io.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh_numpy/__pycache__/light.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh_numpy/__pycache__/render.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh_numpy/__pycache__/transform.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh_numpy/__pycache__/vis.cpython-311.pyc,, +insightface/thirdparty/face3d/mesh_numpy/io.py,sha256=u2obdQD2QWtdIWc3xQOX_Aha0X4AUm3f3A5AhSIjZC8,5842 +insightface/thirdparty/face3d/mesh_numpy/light.py,sha256=avcc1j6-UHGXHhWzhVhXYvpiR3Hg6qX3f8K6zsPhtn8,7502 +insightface/thirdparty/face3d/mesh_numpy/render.py,sha256=2M3halQr-qhGReXbVp5Ubx0-9xwrbTLYlY2_tBGk28g,10426 +insightface/thirdparty/face3d/mesh_numpy/transform.py,sha256=Z5Ofjd5YE2PZusE8NBImj5P03JdM-Q-gTjwMqGw8f-U,12319 +insightface/thirdparty/face3d/mesh_numpy/vis.py,sha256=RKNnmTbZ4ZgsaaTjfLCcr6atXdlQ8Ca8atIumXDCnUY,791 +insightface/thirdparty/face3d/morphable_model/__init__.py,sha256=70jLsfRDOsImFMog6odLMYmZwenk6rgatBa4OmwqHhw,192 +insightface/thirdparty/face3d/morphable_model/__pycache__/__init__.cpython-311.pyc,, +insightface/thirdparty/face3d/morphable_model/__pycache__/fit.cpython-311.pyc,, +insightface/thirdparty/face3d/morphable_model/__pycache__/load.cpython-311.pyc,, +insightface/thirdparty/face3d/morphable_model/__pycache__/morphabel_model.cpython-311.pyc,, +insightface/thirdparty/face3d/morphable_model/fit.py,sha256=dZnXPjsmsxa9GqjRue9PJTbuHKQsyM8Qq8BjNInL0zE,8101 +insightface/thirdparty/face3d/morphable_model/load.py,sha256=38d1i_ptNuJjUloVX8UQIaLoR2pMFkDqNfP-Q3GVZL4,3765 +insightface/thirdparty/face3d/morphable_model/morphabel_model.py,sha256=_ldCV3qEYt3lkQCVgOXw5NWlTLNYKuUJE5vJFpjmX1g,5567 +insightface/utils/__init__.py,sha256=iA-IqUe-mpOd0qpnMomRgRXxT0MDKe7Pqk4mOp0bc7Y,609 +insightface/utils/__pycache__/__init__.cpython-311.pyc,, +insightface/utils/__pycache__/constant.cpython-311.pyc,, +insightface/utils/__pycache__/download.cpython-311.pyc,, +insightface/utils/__pycache__/face_align.cpython-311.pyc,, +insightface/utils/__pycache__/filesystem.cpython-311.pyc,, +insightface/utils/__pycache__/storage.cpython-311.pyc,, +insightface/utils/__pycache__/transform.cpython-311.pyc,, +insightface/utils/constant.py,sha256=gP9VIt4BVBVH_emno8PeP2lyBGsugc-sHXfjNMM5SRE,32 +insightface/utils/download.py,sha256=um-BvXJBOUtxKKk335TpMOlgIb8jQrVRRPd8kObUzbo,3360 +insightface/utils/face_align.py,sha256=qLNN3QZxb1yn51AUFcvTeJzLzhjbnlV7NeU3aVKQ2SI,3356 +insightface/utils/filesystem.py,sha256=_PCq77d6wiAb7da4s6LC7G6t9GXTY6St5oCiyWebzLU,4250 +insightface/utils/storage.py,sha256=eI287HAoM0RBnYLkg0ZlZXfkIP85NMFUwRHgjHCfmGY,1891 +insightface/utils/transform.py,sha256=UKQiNuEEHTw3iMubYO0_AY3KiN4tElMzPO8KocqG7wc,3379 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/REQUESTED b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/WHEEL b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..14a883f292bc96b20c2b76a3081991f2676523a9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (82.0.1) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/entry_points.txt b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..ffbd073edf6a9378563b295a5baa9bbceb181c8a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/entry_points.txt @@ -0,0 +1,5 @@ +[console_scripts] +insightface-cli = insightface.commands.insightface_cli:main +insightface-desktop = insightface.gui.__main__:main +insightface-eval-studio = insightface.gui.__main__:main +insightface-gui = insightface.gui.__main__:main diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/top_level.txt b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..850480f1406411117a82052929e74559fd8184da --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/top_level.txt @@ -0,0 +1 @@ +insightface diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/zip-safe b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/zip-safe new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface-1.0.1.dist-info/zip-safe @@ -0,0 +1 @@ + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..83a71904bd85cea6c0cceaf83a2201fbe5da9648 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/__init__.py @@ -0,0 +1,20 @@ +# coding: utf-8 +# pylint: disable=wrong-import-position +"""InsightFace: A Face Analysis Toolkit.""" +from __future__ import absolute_import + +try: + #import mxnet as mx + import onnxruntime +except ImportError: + raise ImportError( + "Unable to import dependency onnxruntime. " + ) + +__version__ = '1.0.1' + +from . import model_zoo +from . import utils +from . import app +from . import data +from . import thirdparty diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..16f4413362949526204d9b3a4d585fac2f8d1264 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/__init__.py @@ -0,0 +1,10 @@ +from .face_analysis import * +try: + import os + + os.environ.setdefault("NO_ALBUMENTATIONS_UPDATE", "1") + from .mask_renderer import * +except ImportError: + # The mask renderer depends on optional compiled face3d extensions. Keep the + # main InsightFace API importable in source-tree and GUI-safe environments. + pass diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/common.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/common.py new file mode 100644 index 0000000000000000000000000000000000000000..5d5645b196b0492f5872cd54428e2ca5b279e965 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/common.py @@ -0,0 +1,48 @@ +import numpy as np +from numpy.linalg import norm as l2norm + +class Face(dict): + + def __init__(self, d=None, **kwargs): + if d is None: + d = {} + if kwargs: + d.update(**kwargs) + for k, v in d.items(): + setattr(self, k, v) + # Class attributes + #for k in self.__class__.__dict__.keys(): + # if not (k.startswith('__') and k.endswith('__')) and not k in ('update', 'pop'): + # setattr(self, k, getattr(self, k)) + + def __setattr__(self, name, value): + if isinstance(value, (list, tuple)): + value = [self.__class__(x) + if isinstance(x, dict) else x for x in value] + elif isinstance(value, dict) and not isinstance(value, self.__class__): + value = self.__class__(value) + super(Face, self).__setattr__(name, value) + super(Face, self).__setitem__(name, value) + + __setitem__ = __setattr__ + + def __getattr__(self, name): + return None + + @property + def embedding_norm(self): + if self.embedding is None: + return None + return l2norm(self.embedding) + + @property + def normed_embedding(self): + if self.embedding is None: + return None + return self.embedding / self.embedding_norm + + @property + def sex(self): + if self.gender is None: + return None + return 'M' if self.gender==1 else 'F' diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/face_analysis.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/face_analysis.py new file mode 100644 index 0000000000000000000000000000000000000000..ea9f9719cb017acbb7d37731ba19fd22fd1fbd23 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/face_analysis.py @@ -0,0 +1,127 @@ +# -*- coding: utf-8 -*- +# @Organization : insightface.ai +# @Author : Jia Guo +# @Time : 2021-05-04 +# @Function : + + +from __future__ import division + +import glob +import os.path as osp + +import numpy as np +import onnxruntime +from numpy.linalg import norm + +from ..model_zoo import model_zoo +from ..utils import DEFAULT_MP_NAME, ensure_available +from .common import Face + +__all__ = ['FaceAnalysis'] + +DEFAULT_DET_SIZES = [(128, 128), (640, 640)] + + +def _is_auto_det_size(det_size): + if det_size is None: + return True + if isinstance(det_size, np.ndarray): + det_size = det_size.tolist() + if isinstance(det_size, (list, tuple)) and len(det_size) == 2: + first, second = det_size + if not isinstance(first, (list, tuple, np.ndarray)) and not isinstance(second, (list, tuple, np.ndarray)): + try: + return int(first) == 0 and int(second) == 0 + except (TypeError, ValueError): + return False + return False + + +class FaceAnalysis: + def __init__(self, name=DEFAULT_MP_NAME, root='~/.insightface', allowed_modules=None, **kwargs): + onnxruntime.set_default_logger_severity(3) + self.models = {} + self.model_dir = ensure_available('models', name, root=root) + onnx_files = glob.glob(osp.join(self.model_dir, '*.onnx')) + onnx_files = sorted(onnx_files) + for onnx_file in onnx_files: + model = model_zoo.get_model(onnx_file, **kwargs) + if model is None: + print('model not recognized:', onnx_file) + elif allowed_modules is not None and model.taskname not in allowed_modules: + print('model ignore:', onnx_file, model.taskname) + del model + elif model.taskname not in self.models and (allowed_modules is None or model.taskname in allowed_modules): + print('find model:', onnx_file, model.taskname, model.input_shape, model.input_mean, model.input_std) + self.models[model.taskname] = model + else: + print('duplicated model task type, ignore:', onnx_file, model.taskname) + del model + assert 'detection' in self.models + self.det_model = self.models['detection'] + + + def prepare(self, ctx_id, det_thresh=0.5, det_size=None): + self.det_thresh = det_thresh + if _is_auto_det_size(det_size): + det_size = list(DEFAULT_DET_SIZES) + print('set det-size:', det_size) + self.det_size = det_size + for taskname, model in self.models.items(): + if taskname=='detection': + model.prepare(ctx_id, input_size=det_size, det_thresh=det_thresh) + else: + model.prepare(ctx_id) + + def get(self, img, max_num=0, det_metric='default'): + bboxes, kpss = self.det_model.detect(img, + max_num=max_num, + metric=det_metric) + if bboxes.shape[0] == 0: + return [] + ret = [] + for i in range(bboxes.shape[0]): + bbox = bboxes[i, 0:4] + det_score = bboxes[i, 4] + kps = None + if kpss is not None: + kps = kpss[i] + face = Face(bbox=bbox, kps=kps, det_score=det_score) + for taskname, model in self.models.items(): + if taskname=='detection': + continue + model.get(img, face) + ret.append(face) + return ret + + def draw_on(self, img, faces): + import cv2 + dimg = img.copy() + for i in range(len(faces)): + face = faces[i] + box = face.bbox.astype(int) + color = (0, 0, 255) + cv2.rectangle(dimg, (box[0], box[1]), (box[2], box[3]), color, 2) + if face.kps is not None: + kps = face.kps.astype(int) + #print(landmark.shape) + for l in range(kps.shape[0]): + color = (0, 0, 255) + if l == 0 or l == 3: + color = (0, 255, 0) + cv2.circle(dimg, (kps[l][0], kps[l][1]), 1, color, + 2) + if face.gender is not None and face.age is not None: + cv2.putText(dimg,'%s,%d'%(face.sex,face.age), (box[0]-1, box[1]-4),cv2.FONT_HERSHEY_COMPLEX,0.7,(0,255,0),1) + + #for key, value in face.items(): + # if key.startswith('landmark_3d'): + # print(key, value.shape) + # print(value[0:10,:]) + # lmk = np.round(value).astype(int) + # for l in range(lmk.shape[0]): + # color = (255, 0, 0) + # cv2.circle(dimg, (lmk[l][0], lmk[l][1]), 1, color, + # 2) + return dimg diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/mask_renderer.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/mask_renderer.py new file mode 100644 index 0000000000000000000000000000000000000000..2815f5018ca92cdcc541e47309d9466cd5f669dc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/app/mask_renderer.py @@ -0,0 +1,232 @@ +import os, sys, datetime +import numpy as np +import os.path as osp +import albumentations as A +from albumentations.core.transforms_interface import ImageOnlyTransform +from .face_analysis import FaceAnalysis +from ..utils import get_model_dir +from ..thirdparty import face3d +from ..data import get_image as ins_get_image +from ..utils import DEFAULT_MP_NAME +import cv2 + +class MaskRenderer: + def __init__(self, name=DEFAULT_MP_NAME, root='~/.insightface', insfa=None): + #if insfa is None, enter render_only mode + self.mp_name = name + self.root = root + self.insfa = insfa + model_dir = get_model_dir(name, root) + bfm_file = osp.join(model_dir, 'BFM.mat') + assert osp.exists(bfm_file), 'should contains BFM.mat in your model directory' + self.bfm = face3d.morphable_model.MorphabelModel(bfm_file) + self.index_ind = self.bfm.kpt_ind + bfm_uv_file = osp.join(model_dir, 'BFM_UV.mat') + assert osp.exists(bfm_uv_file), 'should contains BFM_UV.mat in your model directory' + uv_coords = face3d.morphable_model.load.load_uv_coords(bfm_uv_file) + self.uv_size = (224,224) + self.mask_stxr = 0.1 + self.mask_styr = 0.33 + self.mask_etxr = 0.9 + self.mask_etyr = 0.7 + self.tex_h , self.tex_w, self.tex_c = self.uv_size[1] , self.uv_size[0],3 + texcoord = np.zeros_like(uv_coords) + texcoord[:, 0] = uv_coords[:, 0] * (self.tex_h - 1) + texcoord[:, 1] = uv_coords[:, 1] * (self.tex_w - 1) + texcoord[:, 1] = self.tex_w - texcoord[:, 1] - 1 + self.texcoord = np.hstack((texcoord, np.zeros((texcoord.shape[0], 1)))) + self.X_ind = self.bfm.kpt_ind + self.mask_image_names = ['mask_white', 'mask_blue', 'mask_black', 'mask_green'] + self.mask_aug_probs = [0.4, 0.4, 0.1, 0.1] + #self.mask_images = [] + #self.mask_images_rgb = [] + #for image_name in mask_image_names: + # mask_image = ins_get_image(image_name) + # self.mask_images.append(mask_image) + # mask_image_rgb = mask_image[:,:,::-1] + # self.mask_images_rgb.append(mask_image_rgb) + + + def prepare(self, ctx_id=0, det_thresh=0.5, det_size=(128, 128)): + self.pre_ctx_id = ctx_id + self.pre_det_thresh = det_thresh + self.pre_det_size = det_size + + def transform(self, shape3D, R): + s = 1.0 + shape3D[:2, :] = shape3D[:2, :] + shape3D = s * np.dot(R, shape3D) + return shape3D + + def preprocess(self, vertices, w, h): + R1 = face3d.mesh.transform.angle2matrix([0, 180, 180]) + t = np.array([-w // 2, -h // 2, 0]) + vertices = vertices.T + vertices += t + vertices = self.transform(vertices.T, R1).T + return vertices + + def project_to_2d(self,vertices,s,angles,t): + transformed_vertices = self.bfm.transform(vertices, s, angles, t) + projected_vertices = transformed_vertices.copy() # using stantard camera & orth projection + return projected_vertices[self.bfm.kpt_ind, :2] + + def params_to_vertices(self,params , H , W): + fitted_sp, fitted_ep, fitted_s, fitted_angles, fitted_t = params + fitted_vertices = self.bfm.generate_vertices(fitted_sp, fitted_ep) + transformed_vertices = self.bfm.transform(fitted_vertices, fitted_s, fitted_angles, + fitted_t) + transformed_vertices = self.preprocess(transformed_vertices.T, W, H) + image_vertices = face3d.mesh.transform.to_image(transformed_vertices, H, W) + return image_vertices + + def draw_lmk(self, face_image): + faces = self.insfa.get(face_image, max_num=1) + if len(faces)==0: + return face_image + return self.insfa.draw_on(face_image, faces) + + def build_params(self, face_image): + #landmark = self.if3d68_handler.get(face_image) + #if landmark is None: + # return None #face not found + if self.insfa is None: + self.insfa = FaceAnalysis(name=self.mp_name, root=self.root, allowed_modules=['detection', 'landmark_3d_68']) + self.insfa.prepare(ctx_id=self.pre_ctx_id, det_thresh=self.pre_det_thresh, det_size=self.pre_det_size) + + faces = self.insfa.get(face_image, max_num=1) + if len(faces)==0: + return None + landmark = faces[0].landmark_3d_68[:,:2] + fitted_sp, fitted_ep, fitted_s, fitted_angles, fitted_t = self.bfm.fit(landmark, self.X_ind, max_iter = 3) + return [fitted_sp, fitted_ep, fitted_s, fitted_angles, fitted_t] + + def generate_mask_uv(self,mask, positions): + uv_size = (self.uv_size[1], self.uv_size[0], 3) + h, w, c = uv_size + uv = np.zeros(shape=(self.uv_size[1],self.uv_size[0], 3), dtype=np.uint8) + stxr, styr = positions[0], positions[1] + etxr, etyr = positions[2], positions[3] + stx, sty = int(w * stxr), int(h * styr) + etx, ety = int(w * etxr), int(h * etyr) + height = ety - sty + width = etx - stx + mask = cv2.resize(mask, (width, height)) + uv[sty:ety, stx:etx] = mask + return uv + + def render_mask(self,face_image, mask_image, params, input_is_rgb=False, auto_blend = True, positions=[0.1, 0.33, 0.9, 0.7]): + if isinstance(mask_image, str): + to_rgb = True if input_is_rgb else False + mask_image = ins_get_image(mask_image, to_rgb=to_rgb) + uv_mask_image = self.generate_mask_uv(mask_image, positions) + h,w,c = face_image.shape + image_vertices = self.params_to_vertices(params ,h,w) + output = (1-face3d.mesh.render.render_texture(image_vertices, self.bfm.full_triangles , uv_mask_image, self.texcoord, self.bfm.full_triangles, h , w ))*255 + output = output.astype(np.uint8) + if auto_blend: + mask_bd = (output==255).astype(np.uint8) + final = face_image*mask_bd + (1-mask_bd)*output + return final + return output + + #def mask_augmentation(self, face_image, label, input_is_rgb=False, p=0.1): + # if np.random.random()0 + assert len(mask_names)==len(mask_probs) + self.mask_names = mask_names + self.mask_probs = mask_probs + self.h_low = h_low + self.h_high = h_high + #self.hlabel = None + + + def apply(self, image, hlabel, mask_name, h_pos, **params): + #print(params.keys()) + #hlabel = params.get('hlabel') + assert len(hlabel)==237 or len(hlabel)==235, 'make sure the rec dataset includes mask params' + if len(hlabel)==237: + if hlabel[1]<0.0: + return image + hlabel = hlabel[2:] + #print(len(hlabel)) + mask_params = self.renderer.decode_params(hlabel) + image = self.renderer.render_mask(image, mask_name, mask_params, input_is_rgb=True, positions=[0.1, h_pos, 0.9, 0.7]) + return image + + @property + def targets_as_params(self): + return ["image", "hlabel"] + + def get_params_dependent_on_targets(self, params): + hlabel = params['hlabel'] + mask_name = np.random.choice(self.mask_names, p=self.mask_probs) + h_pos = np.random.uniform(self.h_low, self.h_high) + return {'hlabel': hlabel, 'mask_name': mask_name, 'h_pos': h_pos} + + def get_transform_init_args_names(self): + #return ("hlabel", 'mask_names', 'mask_probs', 'h_low', 'h_high') + return ('mask_names', 'mask_probs', 'h_low', 'h_high') + + +if __name__ == "__main__": + tool = MaskRenderer('antelope') + tool.prepare(det_size=(128,128)) + image = cv2.imread("Tom_Hanks_54745.png") + params = tool.build_params(image) + #out = tool.draw_lmk(image) + #cv2.imwrite('output_lmk.jpg', out) + #mask_image = cv2.imread("masks/mask1.jpg") + #mask_image = cv2.imread("masks/black-mask.png") + #mask_image = cv2.imread("masks/mask2.jpg") + mask_out = tool.render_mask(image, 'mask_blue', params)# use single thread to test the time cost + + cv2.imwrite('output_mask.jpg', mask_out) + + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fedaa0dbb14464243e1ebef1b8134c7fe524cd8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/__init__.py @@ -0,0 +1,13 @@ +from abc import ABC, abstractmethod +from argparse import ArgumentParser + + +class BaseInsightFaceCLICommand(ABC): + @staticmethod + @abstractmethod + def register_subcommand(parser: ArgumentParser): + raise NotImplementedError() + + @abstractmethod + def run(self): + raise NotImplementedError() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/insightface_cli.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/insightface_cli.py new file mode 100644 index 0000000000000000000000000000000000000000..b8adbefcf0371c35689b2978c69510c1d3306846 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/insightface_cli.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python + +from argparse import ArgumentParser + +from .model_download import ModelDownloadCommand +from .rec_add_mask_param import RecAddMaskParamCommand + +def main(): + parser = ArgumentParser("InsightFace CLI tool", usage="insightface-cli []") + commands_parser = parser.add_subparsers(help="insightface-cli command-line helpers") + + # Register commands + ModelDownloadCommand.register_subcommand(commands_parser) + RecAddMaskParamCommand.register_subcommand(commands_parser) + + args = parser.parse_args() + + if not hasattr(args, "func"): + parser.print_help() + exit(1) + + # Run + service = args.func(args) + service.run() + + +if __name__ == "__main__": + main() + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/model_download.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/model_download.py new file mode 100644 index 0000000000000000000000000000000000000000..c5a14a33d7767b5fdc0a780f326e2e39ca619823 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/model_download.py @@ -0,0 +1,36 @@ +from argparse import ArgumentParser + +from . import BaseInsightFaceCLICommand +import os +import os.path as osp +import zipfile +import glob +from ..utils import download + + +def model_download_command_factory(args): + return ModelDownloadCommand(args.model, args.root, args.force) + + +class ModelDownloadCommand(BaseInsightFaceCLICommand): + #_url_format = '{repo_url}models/{file_name}.zip' + @staticmethod + def register_subcommand(parser: ArgumentParser): + download_parser = parser.add_parser("model.download") + download_parser.add_argument( + "--root", type=str, default='~/.insightface', help="Path to location to store the models" + ) + download_parser.add_argument( + "--force", action="store_true", help="Force the model to be download even if already in root-dir" + ) + download_parser.add_argument("model", type=str, help="Name of the model to download") + download_parser.set_defaults(func=model_download_command_factory) + + def __init__(self, model: str, root: str, force: bool): + self._model = model + self._root = root + self._force = force + + def run(self): + download('models', self._model, force=self._force, root=self._root) + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/rec_add_mask_param.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/rec_add_mask_param.py new file mode 100644 index 0000000000000000000000000000000000000000..f73173d5f3d50c725a964ca64307f9098f2d494d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/commands/rec_add_mask_param.py @@ -0,0 +1,107 @@ + +import numbers +import os +from argparse import ArgumentParser, Namespace + +import numpy as np + +from . import BaseInsightFaceCLICommand + + +def rec_add_mask_param_command_factory(args: Namespace): + + return RecAddMaskParamCommand( + args.input, args.output + ) + + +class RecAddMaskParamCommand(BaseInsightFaceCLICommand): + @staticmethod + def register_subcommand(parser: ArgumentParser): + _parser = parser.add_parser("rec.addmaskparam") + _parser.add_argument("input", type=str, help="input rec") + _parser.add_argument("output", type=str, help="output rec, with mask param") + _parser.set_defaults(func=rec_add_mask_param_command_factory) + + def __init__( + self, + input: str, + output: str, + ): + self._input = input + self._output = output + + + def run(self): + try: + import mxnet as mx + except ImportError as exc: + raise ImportError( + "The rec.addmaskparam command requires mxnet. " + "Please install mxnet before running this command." + ) from exc + try: + from ..app.mask_renderer import MaskRenderer + from ..data.rec_builder import RecBuilder + except ImportError as exc: + raise ImportError( + "The rec.addmaskparam command requires optional mask rendering " + "and MXNet record dependencies. Please install the required " + "optional dependencies before running this command." + ) from exc + + tool = MaskRenderer() + tool.prepare(ctx_id=0, det_size=(128,128)) + root_dir = self._input + path_imgrec = os.path.join(root_dir, 'train.rec') + path_imgidx = os.path.join(root_dir, 'train.idx') + imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r') + save_path = self._output + wrec=RecBuilder(path=save_path) + s = imgrec.read_idx(0) + header, _ = mx.recordio.unpack(s) + if header.flag > 0: + if len(header.label)==2: + imgidx = np.array(range(1, int(header.label[0]))) + else: + imgidx = np.array(list(self.imgrec.keys)) + else: + imgidx = np.array(list(self.imgrec.keys)) + stat = [0, 0] + print('total:', len(imgidx)) + for iid, idx in enumerate(imgidx): + #if iid==500000: + # break + if iid%1000==0: + print('processing:', iid) + s = imgrec.read_idx(idx) + header, img = mx.recordio.unpack(s) + label = header.label + if not isinstance(label, numbers.Number): + label = label[0] + sample = mx.image.imdecode(img).asnumpy() + bgr = sample[:,:,::-1] + params = tool.build_params(bgr) + #if iid<10: + # mask_out = tool.render_mask(bgr, 'mask_blue', params) + # cv2.imwrite('maskout_%d.jpg'%iid, mask_out) + stat[1] += 1 + if params is None: + wlabel = [label] + [-1.0]*236 + stat[0] += 1 + else: + #print(0, params[0].shape, params[0].dtype) + #print(1, params[1].shape, params[1].dtype) + #print(2, params[2]) + #print(3, len(params[3]), params[3][0].__class__) + #print(4, params[4].shape, params[4].dtype) + mask_label = tool.encode_params(params) + wlabel = [label, 0.0]+mask_label # 237 including idlabel, total mask params size is 235 + if iid==0: + print('param size:', len(mask_label), len(wlabel), label) + assert len(wlabel)==237 + wrec.add_image(img, wlabel) + #print(len(params)) + + wrec.close() + print('finished on', self._output, ', failed:', stat[0]) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..665c59ec99b6ebf12822015e0350969c7903e243 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/__init__.py @@ -0,0 +1,2 @@ +from .image import get_image +from .pickle_object import get_object diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/image.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/image.py new file mode 100644 index 0000000000000000000000000000000000000000..343ccc580afb5f9d45a341b17fb41c7ab9621500 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/image.py @@ -0,0 +1,28 @@ +import cv2 +import os +import os.path as osp +from pathlib import Path + +class ImageCache: + data = {} + +def get_image(name, to_rgb=False, use_cache=True): + key = (name, to_rgb) + if key in ImageCache.data: + return ImageCache.data[key] + images_dir = osp.join(Path(__file__).parent.absolute(), 'images') + ext_names = ['.jpg', '.png', '.jpeg'] + image_file = None + for ext_name in ext_names: + _image_file = osp.join(images_dir, "%s%s"%(name, ext_name)) + if osp.exists(_image_file): + image_file = _image_file + break + assert image_file is not None, '%s not found'%name + img = cv2.imread(image_file) + if to_rgb: + img = img[:,:,::-1] + if use_cache: + ImageCache.data[key] = img + return img + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/pickle_object.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/pickle_object.py new file mode 100644 index 0000000000000000000000000000000000000000..f028063e5c73c4c1262ef9132a079e05eee077bd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/pickle_object.py @@ -0,0 +1,27 @@ +import sys +import os +import os.path as osp +from pathlib import Path +import pickle + +def get_object(name): + if getattr(sys, 'frozen', False): + base_dir = sys._MEIPASS + else: + base_dir = Path(__file__).parent.absolute() + + objects_dir = osp.join(base_dir, 'objects') + + if not name.endswith('.pkl'): + name = name + ".pkl" + + filepath = osp.join(objects_dir, name) + + if not osp.exists(filepath): + print(f"[Error] File not found: {filepath}") + return None + + with open(filepath, 'rb') as f: + obj = pickle.load(f) + + return obj diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/rec_builder.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/rec_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..e02abc969da2f882639326f5bad3c7e8d08c1fde --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/data/rec_builder.py @@ -0,0 +1,71 @@ +import pickle +import numpy as np +import os +import os.path as osp +import sys +import mxnet as mx + + +class RecBuilder(): + def __init__(self, path, image_size=(112, 112)): + self.path = path + self.image_size = image_size + self.widx = 0 + self.wlabel = 0 + self.max_label = -1 + assert not osp.exists(path), '%s exists' % path + os.makedirs(path) + self.writer = mx.recordio.MXIndexedRecordIO(os.path.join(path, 'train.idx'), + os.path.join(path, 'train.rec'), + 'w') + self.meta = [] + + def add(self, imgs): + #!!! img should be BGR!!!! + #assert label >= 0 + #assert label > self.last_label + assert len(imgs) > 0 + label = self.wlabel + for img in imgs: + idx = self.widx + image_meta = {'image_index': idx, 'image_classes': [label]} + header = mx.recordio.IRHeader(0, label, idx, 0) + if isinstance(img, np.ndarray): + s = mx.recordio.pack_img(header,img,quality=95,img_fmt='.jpg') + else: + s = mx.recordio.pack(header, img) + self.writer.write_idx(idx, s) + self.meta.append(image_meta) + self.widx += 1 + self.max_label = label + self.wlabel += 1 + + + def add_image(self, img, label): + #!!! img should be BGR!!!! + #assert label >= 0 + #assert label > self.last_label + idx = self.widx + header = mx.recordio.IRHeader(0, label, idx, 0) + if isinstance(label, list): + idlabel = label[0] + else: + idlabel = label + image_meta = {'image_index': idx, 'image_classes': [idlabel]} + if isinstance(img, np.ndarray): + s = mx.recordio.pack_img(header,img,quality=95,img_fmt='.jpg') + else: + s = mx.recordio.pack(header, img) + self.writer.write_idx(idx, s) + self.meta.append(image_meta) + self.widx += 1 + self.max_label = max(self.max_label, idlabel) + + def close(self): + with open(osp.join(self.path, 'train.meta'), 'wb') as pfile: + pickle.dump(self.meta, pfile, protocol=pickle.HIGHEST_PROTOCOL) + print('stat:', self.widx, self.wlabel) + with open(os.path.join(self.path, 'property'), 'w') as f: + f.write("%d,%d,%d\n" % (self.max_label+1, self.image_size[0], self.image_size[1])) + f.write("%d\n" % (self.widx)) + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c326e5eff3f6dca28f57e1d8b721144d34d0a18c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/__init__.py @@ -0,0 +1,12 @@ +"""InsightFace Evaluation Studio. + +The GUI package is intentionally import-light. Importing ``insightface.gui`` +does not require PySide6; GUI dependencies are loaded by the entry point. +""" + +__version__ = "1.0.1" + +APP_NAME = "InsightFace Evaluation Studio" +APP_DISPLAY_NAME = "InsightFace Evaluation Studio v1.0.1" + +__all__ = ["__version__", "APP_NAME", "APP_DISPLAY_NAME"] diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/__main__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..3a97595e1beeaafcbdc7f7b4acc74a41de889230 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/__main__.py @@ -0,0 +1,46 @@ +"""Command line entry point for InsightFace Evaluation Studio.""" + +from __future__ import annotations + +import argparse +import sys + +from . import __version__ + + +def build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description="InsightFace Evaluation Studio") + parser.add_argument("--workspace", help="Use a specific local workspace directory") + parser.add_argument("--model", help="Model pack name or local model directory") + parser.add_argument("--provider", choices=["auto", "cpu", "cuda", "Auto", "CPU", "CUDA"], help="Execution provider") + parser.add_argument("--safe-mode", action="store_true", help="Open the GUI without loading a model") + parser.add_argument("--version", action="store_true", help="Print version information and exit") + return parser + + +def main(argv: list[str] | None = None) -> int: + parser = build_parser() + args = parser.parse_args(argv) + if args.version: + try: + import insightface + + insightface_version = getattr(insightface, "__version__", "1.0.1") + except Exception: + insightface_version = "1.0.1" + print(f"InsightFace Evaluation Studio {__version__}") + print(f"insightface {insightface_version}") + return 0 + try: + from .app import run_app + except ImportError as exc: + if "PySide6" in str(exc): + print("InsightFace GUI requires PySide6.") + print("Please install with: pip install insightface[gui]") + return 1 + raise + return run_app(args) + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/app.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/app.py new file mode 100644 index 0000000000000000000000000000000000000000..7373542df1b68a600c6dbfbd918f5715f41987b6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/app.py @@ -0,0 +1,162 @@ +"""Application bootstrap for InsightFace Evaluation Studio.""" + +from __future__ import annotations + +import os +import sys +from dataclasses import dataclass +from typing import Iterable, Optional + +from pathlib import Path + +from .core.config import AppConfig, load_config, save_config +from .core.face_engine import FaceEngine, is_cuda_provider_available, providers_from_choice +from .core.logging import setup_logging +from .core.storage import Storage + + +@dataclass +class StudioContext: + config: AppConfig + config_exists: bool + storage: Storage + engine: FaceEngine + log_file: str + runtime_safe_mode: bool = False + + +def _unique_existing_paths(paths: Iterable[Path]) -> list[Path]: + seen = set() + unique_paths = [] + for path in paths: + resolved = str(path) + if resolved in seen: + continue + seen.add(resolved) + if path.exists(): + unique_paths.append(path) + return unique_paths + + +def qt_plugin_root_candidates() -> list[Path]: + """Return plausible Qt plugin roots for PySide6 wheel and conda layouts.""" + + try: + import PySide6 + except ImportError: + return [] + + candidates = [] + for package_dir_raw in getattr(PySide6, "__path__", []): + package_dir = Path(package_dir_raw) + candidates.extend( + [ + package_dir / "Qt" / "plugins", + package_dir / "plugins", + ] + ) + + try: + from PySide6.QtCore import QLibraryInfo + + candidates.append(Path(QLibraryInfo.path(QLibraryInfo.LibraryPath.PluginsPath))) + except Exception: + pass + + candidates.extend( + [ + Path(sys.prefix) / "plugins", + Path(sys.prefix) / "Library" / "plugins", + Path(sys.prefix) / "lib" / "qt6" / "plugins", + ] + ) + return _unique_existing_paths(candidates) + + +def configure_qt_plugin_paths() -> None: + """Point Qt at PySide6-Essentials plugins when the PySide6 meta package is absent.""" + + for plugins in qt_plugin_root_candidates(): + platforms = plugins / "platforms" + if platforms.exists(): + if not os.environ.get("QT_PLUGIN_PATH"): + os.environ["QT_PLUGIN_PATH"] = str(plugins) + if not os.environ.get("QT_QPA_PLATFORM_PLUGIN_PATH"): + os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = str(platforms) + return + + +def create_context(args=None) -> StudioContext: + config_path = None + runtime_safe_mode = bool(args is not None and getattr(args, "safe_mode", False)) + if args is not None and getattr(args, "workspace", None): + config_path = Path(args.workspace).expanduser() / "config.json" + config, exists = load_config(config_path) + if args is not None: + if getattr(args, "workspace", None): + config.workspace_path = args.workspace + config.database_path = "" + config.crop_dir = "" + config.export_dir = "" + config.report_dir = "" + config.log_dir = "" + config.cache_dir = "" + config.apply_workspace_defaults() + if getattr(args, "model", None): + config.model_name = args.model + if getattr(args, "provider", None): + value = str(args.provider).upper() + if value == "CPU": + config.provider = "CPU" + elif value == "CUDA": + config.provider = "CUDA" if is_cuda_provider_available() else "Auto" + else: + config.provider = "Auto" + if config.safe_mode: + # safe-mode is a startup troubleshooting flag. Older builds persisted it + # into config.json, which made normal launches silently skip model load. + config.safe_mode = False + if not config.auto_load_model: + config.auto_load_model = True + if str(config.provider).strip().lower() == "cuda" and not is_cuda_provider_available(): + config.provider = "Auto" + config.apply_workspace_defaults() + save_config(config) + log_file = setup_logging(config.log_dir) + storage = Storage(config.database_path) + engine = FaceEngine( + model_name=config.model_name, + providers=providers_from_choice(config.provider), + det_size=config.det_size_tuple, + root=config.model_root, + custom_model_dir=config.custom_model_dir, + ) + return StudioContext( + config=config, + config_exists=exists, + storage=storage, + engine=engine, + log_file=str(log_file), + runtime_safe_mode=runtime_safe_mode, + ) + + +def run_app(args=None) -> int: + configure_qt_plugin_paths() + try: + from PySide6.QtWidgets import QApplication + except ImportError: + print("InsightFace GUI requires PySide6.") + print("Please install with: pip install insightface[gui]") + return 1 + + from .main_window import MainWindow + from .resources import configure_application_metadata + + app = QApplication.instance() or QApplication(sys.argv[:1]) + configure_application_metadata(app) + context = create_context(args) + window = MainWindow(context) + window.resize(1320, 860) + window.show() + return int(app.exec()) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/assets/app_icon.icns b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/assets/app_icon.icns new file mode 100644 index 0000000000000000000000000000000000000000..a555bc79b791628a2a436474590294830e90f422 Binary files /dev/null and b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/assets/app_icon.icns differ diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/assets/app_icon.ico b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/assets/app_icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..464538b5cd196125c78501e8cc2d1ef1fdb242d1 Binary files /dev/null and b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/assets/app_icon.ico differ diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..411634f51436d5204eab9aa9008ec8c945b985fc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/__init__.py @@ -0,0 +1 @@ +"""Core services for InsightFace Evaluation Studio.""" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/camera.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/camera.py new file mode 100644 index 0000000000000000000000000000000000000000..4fe6088a2f01df632630d3743c1f2611c988bb5c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/camera.py @@ -0,0 +1,19 @@ +"""Camera availability helpers.""" + +from __future__ import annotations + +from typing import List + + +def list_camera_indices(max_indices: int = 4) -> List[int]: + try: + import cv2 + except Exception: + return [] + indices = [] + for idx in range(max_indices): + cap = cv2.VideoCapture(idx) + if cap.isOpened(): + indices.append(idx) + cap.release() + return indices diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/clustering.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/clustering.py new file mode 100644 index 0000000000000000000000000000000000000000..36eefb710c5949b9ce97c9ddd96a19aabcf2c3c3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/clustering.py @@ -0,0 +1,65 @@ +"""Face embedding clustering helpers.""" + +from __future__ import annotations + +from typing import Dict, Iterable, List + +import numpy as np + +from .recognition import cosine_similarity, normalize_embedding + + +def cluster_embeddings( + embeddings: Iterable[np.ndarray], + threshold: float = 0.72, + min_samples: int = 2, +) -> List[int]: + labels, _ = cluster_embeddings_dbscan( + embeddings, + distance_threshold=max(0.01, 1.0 - float(threshold)), + min_samples=min_samples, + ) + return labels + + +def cluster_embeddings_dbscan( + embeddings: Iterable[np.ndarray], + distance_threshold: float = 0.28, + min_samples: int = 2, +) -> tuple[List[int], str]: + normalized = [normalize_embedding(embedding) for embedding in embeddings] + vectors = [embedding for embedding in normalized if embedding is not None] + if not vectors: + return [], "none" + matrix = np.vstack(vectors) + eps = max(0.01, float(distance_threshold)) + try: + from sklearn.cluster import DBSCAN + + labels = DBSCAN(eps=eps, min_samples=max(1, int(min_samples)), metric="cosine").fit_predict(matrix) + return [int(label) for label in labels], "DBSCAN" + except Exception: + labels: List[int] = [] + centroids: Dict[int, np.ndarray] = {} + counts: Dict[int, int] = {} + next_label = 0 + for vector in matrix: + best_label = None + best_score = -1.0 + for label, centroid in centroids.items(): + score = cosine_similarity(vector, centroid) + if score > best_score: + best_label = label + best_score = score + if best_label is not None and (1.0 - best_score) <= eps: + labels.append(best_label) + counts[best_label] += 1 + centroids[best_label] = normalize_embedding( + centroids[best_label] * (counts[best_label] - 1) + vector + ) + else: + labels.append(next_label) + centroids[next_label] = vector + counts[next_label] = 1 + next_label += 1 + return labels, "centroid fallback" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/config.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/config.py new file mode 100644 index 0000000000000000000000000000000000000000..48a6248d6b2d0e992d893191f6c70d9f68ab9a53 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/config.py @@ -0,0 +1,123 @@ +"""Configuration loading and saving.""" + +from __future__ import annotations + +import json +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Any, Dict, Optional + +from .constants import ( + DEFAULT_DET_SIZE, + DEFAULT_LICENSE_STATUS, + DEFAULT_MODEL_NAME, + DEFAULT_PROVIDER, + DEFAULT_THRESHOLD, + DEFAULT_TOP_K, +) +from .paths import default_config_path, default_workspace, ensure_workspace, expand_path + + +@dataclass +class AppConfig: + workspace_path: str = str(default_workspace()) + database_path: str = "" + crop_dir: str = "" + export_dir: str = "" + report_dir: str = "" + log_dir: str = "" + cache_dir: str = "" + mode: str = "Personal / Research" + model_name: str = DEFAULT_MODEL_NAME + model_root: str = "~/.insightface" + custom_model_dir: str = "" + provider: str = DEFAULT_PROVIDER + det_size: list[int] = None # type: ignore[assignment] + recognition_threshold: float = DEFAULT_THRESHOLD + default_top_k: int = DEFAULT_TOP_K + min_detection_score: float = 0.45 + min_face_size: int = 32 + save_crops: bool = True + save_recognition_logs: bool = True + anonymize_report_paths: bool = False + batch_worker_count: int = 2 + video_frame_interval: int = 10 + camera_frame_skip: int = 3 + ui_theme: str = "azure_lab" + ui_language: str = "system" + ui_default_mode: str = "face_verification" + ui_last_mode: str = "face_verification" + ui_last_page_face_verification: str = "verification" + ui_last_page_album_management: str = "album" + ui_last_page_face_swap: str = "image_face_swap" + ui_last_page_enterprise_evaluation: str = "enterprise_dashboard" + ui_window_width: int = 1320 + ui_window_height: int = 860 + ui_sidebar_width: int = 240 + ui_settings_dialog_last_tab: int = 0 + ui_sidebar_compact: bool = False + ui_show_status_chips: bool = True + license_status: str = DEFAULT_LICENSE_STATUS + safe_mode: bool = False + auto_load_model: bool = True + swap_model_path: str = "" + enable_gfpgan: bool = False + gfpgan_model_path: str = "" + + def __post_init__(self) -> None: + if self.det_size is None: + self.det_size = [DEFAULT_DET_SIZE[0], DEFAULT_DET_SIZE[1]] + self.apply_workspace_defaults() + + def apply_workspace_defaults(self) -> None: + paths = ensure_workspace(self.workspace_path) + self.workspace_path = str(paths["workspace"]) + self.database_path = self.database_path or str(paths["database"]) + self.crop_dir = self.crop_dir or str(paths["crops"]) + self.export_dir = self.export_dir or str(paths["exports"]) + self.report_dir = self.report_dir or str(paths["reports"]) + self.log_dir = self.log_dir or str(paths["logs"]) + self.cache_dir = self.cache_dir or str(paths["cache"]) + + @property + def det_size_tuple(self) -> tuple[int, int]: + return int(self.det_size[0]), int(self.det_size[1]) + + @property + def det_size_label(self) -> str: + width, height = self.det_size_tuple + if width <= 0 or height <= 0: + return "Auto" + return f"{width}x{height}" + + def to_dict(self) -> Dict[str, Any]: + return asdict(self) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "AppConfig": + allowed = {field.name for field in cls.__dataclass_fields__.values()} # type: ignore[attr-defined] + clean = {key: value for key, value in data.items() if key in allowed} + return cls(**clean) + + +def load_config(path: Optional[str | Path] = None) -> tuple[AppConfig, bool]: + config_path = expand_path(path) if path else default_config_path() + if not config_path.exists(): + if path is not None: + return AppConfig(workspace_path=str(config_path.parent)), False + return AppConfig(), False + try: + data = json.loads(config_path.read_text(encoding="utf-8")) + return AppConfig.from_dict(data), True + except Exception: + return AppConfig(), False + + +def save_config(config: AppConfig, path: Optional[str | Path] = None) -> Path: + config.apply_workspace_defaults() + config_path = expand_path(path) if path else Path(config.workspace_path) / "config.json" + config_path.parent.mkdir(parents=True, exist_ok=True) + config_path.write_text( + json.dumps(config.to_dict(), indent=2, sort_keys=True), encoding="utf-8" + ) + return config_path diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/constants.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..2488544f379163610ac41f421060819bcfaa3a91 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/constants.py @@ -0,0 +1,48 @@ +"""Shared constants and product copy.""" + +from __future__ import annotations + +APP_NAME = "InsightFace Evaluation Studio" +APP_VERSION = "1.0.1" +APP_ORGANIZATION = "InsightFace" +APP_DOMAIN = "insightface.ai" +APP_ID = "ai.insightface.evaluationstudio" +APP_PROCESS_NAME = APP_NAME +WINDOW_TITLE = "InsightFace Evaluation Studio v1.0.1" +SUBTITLE = ( + "Local face recognition, face search, photo organization, model evaluation, " + "and face swap studio." +) + +LOCAL_PROCESSING_NOTICE = ( + "All processing is local by default. No images, videos, embeddings, or reports " + "are uploaded automatically." +) + +LICENSE_NOTICE = ( + "Code and model files may have different licenses. Commercial deployment " + "requires appropriate model authorization." +) + +RESPONSIBLE_USE_NOTICE = ( + "This tool does not provide legal advice. Users are responsible for consent, " + "privacy, retention, and compliance with applicable biometric regulations." +) + +COMMERCIAL_NOTICE = ( + "This evaluation may use research or non-commercial model files. Production " + "or commercial deployment requires an appropriate commercial model license. " + "Please contact InsightFace for commercial model licensing, private model " + "evaluation, SDK/API access, SLA, or custom training." +) + +DEFAULT_MODEL_NAME = "buffalo_l" +DEFAULT_PROVIDER = "Auto" +DEFAULT_DET_SIZE = (0, 0) +AUTO_DET_SIZES = ((128, 128), (640, 640)) +DEFAULT_THRESHOLD = 0.4 +DEFAULT_TOP_K = 5 +DEFAULT_LICENSE_STATUS = "Research / Non-commercial" + +IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".bmp", ".webp"} +VIDEO_EXTENSIONS = {".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v"} diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/evaluation.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/evaluation.py new file mode 100644 index 0000000000000000000000000000000000000000..fbcfa20bc7e9e1f6f9143afd42d26f16fab75294 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/evaluation.py @@ -0,0 +1,1165 @@ +"""No-code enterprise evaluation routines.""" + +from __future__ import annotations + +import csv +import math +import platform +import time +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any, Dict, List, Optional + +import numpy as np + +from .constants import DEFAULT_LICENSE_STATUS, DEFAULT_THRESHOLD, IMAGE_EXTENSIONS +from .face_engine import FaceEngine +from .models import EvaluationResult +from .recognition import cosine_similarity +from .utils import list_images, read_image, utc_now_iso + +MULTI_FACE_REQUIRE_ONE = "require_exactly_one" +MULTI_FACE_USE_LARGEST = "use_largest_face" +MULTI_FACE_USE_CENTERED_LARGEST = "use_centered_largest_face" +MULTI_FACE_SKIP = "mark_as_skip" +MULTI_FACE_POLICIES = { + MULTI_FACE_REQUIRE_ONE, + MULTI_FACE_USE_LARGEST, + MULTI_FACE_USE_CENTERED_LARGEST, + MULTI_FACE_SKIP, +} + + +@dataclass +class DatasetValidationResult: + ok: bool + mode: str + auto_split: bool + multi_face_policy: str + root: str + summary: Dict[str, Any] = field(default_factory=dict) + errors: List[Dict[str, Any]] = field(default_factory=list) + warnings: List[Dict[str, Any]] = field(default_factory=list) + + +def hardware_info() -> Dict[str, Any]: + return { + "platform": platform.platform(), + "machine": platform.machine(), + "processor": platform.processor(), + "python": platform.python_version(), + } + + +def _metrics_at_threshold(rows: List[Dict[str, Any]], threshold: float) -> Dict[str, Any]: + positives = [row for row in rows if row.get("label") == 1 and row.get("similarity") is not None] + negatives = [row for row in rows if row.get("label") == 0 and row.get("similarity") is not None] + tp = sum(1 for row in positives if row["similarity"] >= threshold) + fn = sum(1 for row in positives if row["similarity"] < threshold) + fp = sum(1 for row in negatives if row["similarity"] >= threshold) + tn = sum(1 for row in negatives if row["similarity"] < threshold) + total = tp + tn + fp + fn + return { + "accuracy": (tp + tn) / total if total else 0.0, + "FAR": fp / max(1, len(negatives)), + "FRR": fn / max(1, len(positives)), + "TP": tp, + "TN": tn, + "FP": fp, + "FN": fn, + } + + +def recommend_threshold(rows: List[Dict[str, Any]]) -> Optional[float]: + similarities = sorted({float(row["similarity"]) for row in rows if row.get("similarity") is not None}) + if not similarities: + return None + best_threshold = similarities[0] + best_accuracy = -1.0 + for threshold in similarities: + metrics = _metrics_at_threshold(rows, threshold) + if metrics["accuracy"] > best_accuracy: + best_accuracy = metrics["accuracy"] + best_threshold = threshold + return float(best_threshold) + + +def tar_at_far(rows: List[Dict[str, Any]], target_far: float) -> Any: + positives = [row for row in rows if row.get("label") == 1 and row.get("similarity") is not None] + negatives = [row for row in rows if row.get("label") == 0 and row.get("similarity") is not None] + if len(negatives) < max(20, int(1 / max(target_far, 1e-9))): + return "insufficient data" + thresholds = sorted({float(row["similarity"]) for row in rows if row.get("similarity") is not None}, reverse=True) + best_tar = 0.0 + for threshold in thresholds: + far = sum(1 for row in negatives if row["similarity"] >= threshold) / max(1, len(negatives)) + if far <= target_far: + tar = sum(1 for row in positives if row["similarity"] >= threshold) / max(1, len(positives)) + best_tar = max(best_tar, tar) + return best_tar + + +def _identity_name(folder: Path) -> str: + return folder.name + + +def _identity_dirs(root: Path) -> List[Path]: + if not root.exists() or not root.is_dir(): + raise ValueError(f"Identity folder root not found: {root}") + return sorted(path for path in root.iterdir() if path.is_dir()) + + +def _auto_split_identity_images(identity_dir: Path) -> tuple[Path | None, List[Path]]: + images = sorted(list_images(identity_dir, recursive=True)) + if not images: + return None, [] + gallery_candidates = [path for path in images if "gallery" in path.stem.lower()] + gallery = sorted(gallery_candidates or images)[0] + probes = [path for path in images if path != gallery] + return gallery, probes + + +def _normalize_multi_face_policy(policy: str) -> str: + policy = (policy or MULTI_FACE_REQUIRE_ONE).strip() + return policy if policy in MULTI_FACE_POLICIES else MULTI_FACE_REQUIRE_ONE + + +def _face_bbox(face) -> np.ndarray: + bbox = getattr(face, "bbox", None) + if bbox is None: + bbox = face.bbox if hasattr(face, "bbox") else [0, 0, 0, 0] + return np.asarray(bbox, dtype=np.float32).reshape(-1)[:4] + + +def _face_area(face) -> float: + try: + bbox = _face_bbox(face) + return max(0.0, float(bbox[2]) - float(bbox[0])) * max(0.0, float(bbox[3]) - float(bbox[1])) + except Exception: + return 0.0 + + +def _largest_centered_face(faces, image_shape): + if len(faces) == 1: + return faces[0] + try: + det = np.vstack([_face_bbox(face) for face in faces]) + img_size = np.asarray(image_shape, dtype=np.float32)[0:2] + bounding_box_size = (det[:, 2] - det[:, 0]) * (det[:, 3] - det[:, 1]) + img_center = img_size / 2.0 + offsets = np.vstack( + [ + (det[:, 0] + det[:, 2]) / 2.0 - img_center[1], + (det[:, 1] + det[:, 3]) / 2.0 - img_center[0], + ] + ) + offset_dist_squared = np.sum(np.power(offsets, 2.0), axis=0) + return faces[int(np.argmax(bounding_box_size - offset_dist_squared * 2.0))] + except Exception: + return max(faces, key=_face_area) + + +def _select_face_from_faces(faces, image_shape, path: Path, policy: str, stage: str): + del path, stage + face_count = len(faces) + if face_count == 0: + raise ValueError("no face detected") + if face_count > 1 and policy == MULTI_FACE_REQUIRE_ONE: + raise ValueError(f"multiple faces detected ({face_count}); expected exactly one face") + if face_count > 1 and policy == MULTI_FACE_SKIP: + raise ValueError(f"skipped multi-face image ({face_count} faces)") + if face_count > 1 and policy == MULTI_FACE_USE_CENTERED_LARGEST: + return _largest_centered_face(faces, image_shape) + if face_count > 1: + return max(faces, key=_face_area) + return faces[0] + + +def select_face_by_policy(faces, image_shape, policy: str = MULTI_FACE_REQUIRE_ONE, path: str | Path = "", stage: str = ""): + return _select_face_from_faces( + faces, + image_shape, + Path(path) if path else Path("image"), + _normalize_multi_face_policy(policy), + stage, + ) + + +def multi_face_policy_help(policy: str) -> str: + policy = _normalize_multi_face_policy(policy) + if policy == MULTI_FACE_REQUIRE_ONE: + return "Multi-face policy: require exactly one face. Images with multiple detected faces fail with a clear error." + if policy == MULTI_FACE_USE_LARGEST: + return "Multi-face policy: use largest face. If an image has multiple faces, the largest detected face is used." + if policy == MULTI_FACE_USE_CENTERED_LARGEST: + return ( + "Multi-face policy: use largest centered face. If an image has multiple faces, the face with the best " + "area-minus-center-distance score is used." + ) + return ( + "Multi-face policy: mark as skip. Gallery images with multiple detected faces are skipped; a multi-face query " + "stops the current run." + ) + + +def _detect_faces_for_image(path: Path, engine: FaceEngine): + img = read_image(path) + if img is None: + raise ValueError("image read failure") + return img, engine.detect_faces(img, source_path=str(path)) + + +def _embedding_for_image( + path: Path, + engine: FaceEngine, + cache: Dict[str, np.ndarray], + errors: List[Dict[str, Any]], + stage: str, + multi_face_policy: str = MULTI_FACE_REQUIRE_ONE, +) -> Optional[np.ndarray]: + key = str(path) + if key in cache: + return cache[key] + policy = _normalize_multi_face_policy(multi_face_policy) + try: + image, faces = _detect_faces_for_image(path, engine) + face = _select_face_from_faces(faces, image.shape, path, policy, stage) + if face is None or face.normed_embedding is None: + raise ValueError("no face or embedding") + embedding = np.asarray(face.normed_embedding, dtype=np.float32).reshape(-1) + cache[key] = embedding + return embedding + except Exception as exc: + errors.append({"path": key, "error": str(exc), "stage": stage}) + return None + + +def _collect_verification_specs(root: Path, auto_split: bool) -> tuple[List[Dict[str, Any]], List[Dict[str, Any]]]: + identities = _identity_dirs(root) + specs: List[Dict[str, Any]] = [] + structure_errors: List[Dict[str, Any]] = [] + if auto_split: + for identity_dir in identities: + identity = _identity_name(identity_dir) + gallery, probes = _auto_split_identity_images(identity_dir) + if gallery is None: + structure_errors.append({"identity": identity, "error": "identity folder has no images"}) + continue + specs.append({"identity": identity, "path": gallery, "role": "gallery", "selected_gallery": True}) + specs.extend({"identity": identity, "path": path, "role": "probe"} for path in probes) + if not probes: + structure_errors.append( + {"identity": identity, "error": "Auto Split requires at least one probe image after the gallery image"} + ) + else: + for identity_dir in identities: + identity = _identity_name(identity_dir) + images = sorted(list_images(identity_dir, recursive=True)) + if not images: + structure_errors.append({"identity": identity, "error": "identity folder has no images"}) + specs.extend({"identity": identity, "path": path, "role": "probe"} for path in images) + return specs, structure_errors + + +def _collect_identification_specs(root: Path, auto_split: bool) -> tuple[List[Dict[str, Any]], List[Dict[str, Any]]]: + specs: List[Dict[str, Any]] = [] + structure_errors: List[Dict[str, Any]] = [] + if auto_split: + identities_root = _identity_root_for_auto_split(root) + identities = _identity_dirs(identities_root) + for identity_dir in identities: + identity = _identity_name(identity_dir) + gallery, probes = _auto_split_identity_images(identity_dir) + if gallery is None: + structure_errors.append({"identity": identity, "error": "identity folder has no images"}) + continue + specs.append({"identity": identity, "path": gallery, "role": "gallery", "selected_gallery": True}) + specs.extend({"identity": identity, "path": path, "role": "probe"} for path in probes) + if not probes: + structure_errors.append( + {"identity": identity, "error": "Auto Split requires at least one probe image after the gallery image"} + ) + else: + gallery_root = root / "gallery" + probe_root = root / "probe" + unknown_root = root / "unknown" + if not gallery_root.is_dir(): + structure_errors.append({"path": str(gallery_root), "error": "1:N without Auto Split requires gallery/"}) + if not probe_root.is_dir(): + structure_errors.append({"path": str(probe_root), "error": "1:N without Auto Split requires probe/"}) + if gallery_root.is_dir(): + for identity_dir in _identity_dirs(gallery_root): + identity = _identity_name(identity_dir) + images = sorted(list_images(identity_dir, recursive=True)) + if not images: + structure_errors.append({"identity": identity, "role": "gallery", "error": "gallery identity has no images"}) + specs.extend({"identity": identity, "path": path, "role": "gallery"} for path in images) + if probe_root.is_dir(): + for identity_dir in _identity_dirs(probe_root): + identity = _identity_name(identity_dir) + images = sorted(list_images(identity_dir, recursive=True)) + if not images: + structure_errors.append({"identity": identity, "role": "probe", "error": "probe identity has no images"}) + specs.extend({"identity": identity, "path": path, "role": "probe"} for path in images) + if unknown_root.is_dir(): + specs.extend({"identity": "Unknown", "path": path, "role": "unknown"} for path in sorted(list_images(unknown_root, recursive=True))) + return specs, structure_errors + + +def _validate_image_spec( + spec: Dict[str, Any], + engine: FaceEngine, + policy: str, + mode_key: str, +) -> Dict[str, Any]: + path = Path(spec["path"]) + row = { + "identity": spec.get("identity", ""), + "path": str(path), + "role": spec.get("role", ""), + "valid": False, + "skipped": False, + "face_count": 0, + } + try: + image, faces = _detect_faces_for_image(path, engine) + del image + row["face_count"] = len(faces) + if not faces: + row["error"] = "no face detected" + return row + if len(faces) > 1: + row["multi_face"] = True + if policy == MULTI_FACE_REQUIRE_ONE: + row["error"] = f"multiple faces detected ({len(faces)}); expected exactly one face" + return row + if policy == MULTI_FACE_SKIP: + row["skipped"] = True + row["warning"] = f"multi-face image skipped ({len(faces)} faces)" + if spec.get("role") == "gallery" or spec.get("selected_gallery"): + row["error"] = ( + "multi-face gallery image would be skipped, leaving this gallery sample unavailable" + ) + return row + if policy == MULTI_FACE_USE_CENTERED_LARGEST: + row["warning"] = f"multiple faces detected ({len(faces)}); largest centered face will be used" + else: + row["warning"] = f"multiple faces detected ({len(faces)}); largest face will be used" + row["valid"] = True + return row + except Exception as exc: + row["error"] = str(exc) + return row + + +def _quick_validation_specs(specs: List[Dict[str, Any]], policy: str) -> List[Dict[str, Any]]: + if policy == MULTI_FACE_REQUIRE_ONE: + return specs + gallery_specs = [spec for spec in specs if spec.get("role") == "gallery"] + if gallery_specs: + return gallery_specs + representatives: List[Dict[str, Any]] = [] + seen = set() + for spec in specs: + identity = spec.get("identity", "") + if identity in seen: + continue + seen.add(identity) + representatives.append(spec) + return representatives + + +def _validation_scope_label(policy: str, specs_to_check: List[Dict[str, Any]], specs: List[Dict[str, Any]]) -> str: + if policy == MULTI_FACE_REQUIRE_ONE: + return "all images" + if len(specs_to_check) == len(specs): + return "all gallery images" + return "gallery or representative images only" + + +def validate_enterprise_dataset( + dataset_root: str | Path, + mode: str, + auto_split: bool, + engine: FaceEngine, + multi_face_policy: str = MULTI_FACE_REQUIRE_ONE, + progress_callback=None, + cancel_callback=None, +) -> DatasetValidationResult: + root = Path(dataset_root).expanduser() + policy = _normalize_multi_face_policy(multi_face_policy) + result = DatasetValidationResult( + ok=False, + mode=mode, + auto_split=bool(auto_split), + multi_face_policy=policy, + root=str(root), + ) + if not root.is_dir(): + result.errors.append({"path": str(root), "error": "dataset root not found"}) + return result + + mode_key = "1n" if mode.strip().startswith("1:N") else "1to1" + try: + specs, structure_errors = ( + _collect_identification_specs(root, auto_split) + if mode_key == "1n" + else _collect_verification_specs(root, auto_split) + ) + except Exception as exc: + result.errors.append({"path": str(root), "error": str(exc)}) + return result + result.errors.extend(structure_errors) + if not specs: + result.errors.append({"path": str(root), "error": "no image files found for this evaluation mode"}) + if result.errors: + result.summary.update( + { + "total_images": len(specs), + "images_checked": 0, + "valid_images": 0, + "skipped_images": 0, + "multi_face_images": 0, + "validation_scope": "structure only", + "errors": len(result.errors), + "warnings": len(result.warnings), + } + ) + return result + + rows: List[Dict[str, Any]] = [] + specs_to_check = _quick_validation_specs(specs, policy) + for index, spec in enumerate(specs_to_check): + if cancel_callback and cancel_callback(): + result.errors.append({"error": "validation cancelled"}) + break + row = _validate_image_spec(spec, engine, policy, mode_key) + rows.append(row) + if row.get("error"): + result.errors.append({key: row[key] for key in ("identity", "path", "role", "face_count", "error") if key in row}) + elif row.get("warning"): + result.warnings.append({key: row[key] for key in ("identity", "path", "role", "face_count", "warning") if key in row}) + if progress_callback: + progress_callback(index + 1, max(1, len(specs_to_check)), f"Validated image {index + 1}/{len(specs_to_check)}") + if row.get("error"): + break + + if result.errors: + result.summary.update( + { + "total_images": len(specs), + "images_checked": len(rows), + "valid_images": sum(1 for row in rows if row.get("valid")), + "skipped_images": sum(1 for row in rows if row.get("skipped")), + "multi_face_images": sum(1 for row in rows if row.get("multi_face")), + "validation_scope": _validation_scope_label(policy, specs_to_check, specs), + "errors": len(result.errors), + "warnings": len(result.warnings), + } + ) + return result + + if policy == MULTI_FACE_REQUIRE_ONE: + valid_specs = [ + dict(spec, **{"path": str(spec["path"])}) + for spec, row in zip(specs_to_check, rows) + if row.get("valid") + ] + else: + valid_specs = [dict(spec, **{"path": str(spec["path"])}) for spec in specs] + valid_galleries = [spec for spec in valid_specs if spec.get("role") == "gallery"] + valid_probes = [spec for spec in valid_specs if spec.get("role") == "probe"] + + if mode_key == "1to1": + if auto_split: + gallery_by_identity = {spec["identity"] for spec in valid_galleries} + probe_by_identity = {spec["identity"] for spec in valid_probes} + expected_identities = {spec["identity"] for spec in specs} + for identity in sorted(expected_identities - gallery_by_identity): + result.errors.append({"identity": identity, "role": "gallery", "error": "identity has no valid gallery image"}) + for identity in sorted(expected_identities - probe_by_identity): + result.errors.append({"identity": identity, "role": "probe", "error": "identity has no valid probe image"}) + positive_pairs = sum(1 for probe in valid_probes for gallery in valid_galleries if probe["identity"] == gallery["identity"]) + negative_pairs = sum(1 for probe in valid_probes for gallery in valid_galleries if probe["identity"] != gallery["identity"]) + pair_count = positive_pairs + negative_pairs + else: + pair_count = positive_pairs = negative_pairs = 0 + for left_index, left in enumerate(valid_probes): + for right in valid_probes[left_index + 1 :]: + pair_count += 1 + if left["identity"] == right["identity"]: + positive_pairs += 1 + else: + negative_pairs += 1 + if pair_count <= 0: + result.errors.append({"error": "no valid 1:1 comparison pairs can be generated"}) + if positive_pairs <= 0: + result.errors.append({"error": "no positive 1:1 pairs can be generated"}) + if negative_pairs <= 0: + result.errors.append({"error": "no negative 1:1 pairs can be generated"}) + result.summary.update( + { + "valid_gallery_images": len(valid_galleries), + "valid_probe_images": len(valid_probes), + "comparison_pairs": pair_count, + "positive_pairs": positive_pairs, + "negative_pairs": negative_pairs, + } + ) + else: + gallery_identities = {spec["identity"] for spec in valid_galleries} + probe_identities = {spec["identity"] for spec in valid_probes} + if not valid_galleries: + result.errors.append({"role": "gallery", "error": "1:N evaluation requires at least one valid gallery image"}) + if not valid_probes: + result.errors.append({"role": "probe", "error": "1:N evaluation requires at least one valid known probe image"}) + missing_gallery = sorted(probe_identities - gallery_identities) + for identity in missing_gallery: + result.errors.append({"identity": identity, "role": "gallery", "error": "probe identity has no valid gallery image"}) + result.summary.update( + { + "valid_gallery_images": len(valid_galleries), + "gallery_identities": len(gallery_identities), + "valid_known_probe_images": len(valid_probes), + "probe_identities": len(probe_identities), + "unknown_images": sum(1 for spec in valid_specs if spec.get("role") == "unknown"), + } + ) + + result.summary.update( + { + "total_images": len(specs), + "images_checked": len(rows), + "valid_images": len(valid_specs), + "skipped_images": sum(1 for row in rows if row.get("skipped")), + "multi_face_images": sum(1 for row in rows if row.get("multi_face")), + "validation_scope": _validation_scope_label(policy, specs_to_check, specs), + "errors": len(result.errors), + "warnings": len(result.warnings), + } + ) + result.ok = not result.errors + return result + + +def _metrics_at_best_threshold(rows: List[Dict[str, Any]]) -> tuple[float, Dict[str, Any]]: + completed = [row for row in rows if row.get("similarity") is not None] + if not completed: + return 0.0, {"best_accuracy": 0.0, "best_cosine_threshold": 0.0} + positives = np.sort( + np.asarray([float(row["similarity"]) for row in completed if row.get("label") == 1], dtype=np.float64) + ) + negatives = np.sort( + np.asarray([float(row["similarity"]) for row in completed if row.get("label") == 0], dtype=np.float64) + ) + candidates = np.unique(np.asarray([float(row["similarity"]) for row in completed], dtype=np.float64)) + positive_total = int(positives.size) + negative_total = int(negatives.size) + tp = positive_total - np.searchsorted(positives, candidates, side="left") + fn = positive_total - tp + tn = np.searchsorted(negatives, candidates, side="left") + fp = negative_total - tn + total = positive_total + negative_total + accuracy = (tp + tn) / max(1, total) + best_index = int(np.argmax(accuracy)) + best_threshold = float(candidates[best_index]) + best_accuracy = float(accuracy[best_index]) + best_metrics = { + "accuracy": best_accuracy, + "FAR": float(fp[best_index] / max(1, negative_total)), + "FRR": float(fn[best_index] / max(1, positive_total)), + "TP": int(tp[best_index]), + "TN": int(tn[best_index]), + "FP": int(fp[best_index]), + "FN": int(fn[best_index]), + } + best_metrics["best_accuracy"] = best_accuracy + best_metrics["best_cosine_threshold"] = best_threshold + return best_threshold, best_metrics + + +def _tar_far_from_scores( + positive_scores: List[float], + positive_total: int, + negative_scores: List[float], + far_targets: List[float], +) -> Dict[str, Any]: + metrics: Dict[str, Any] = { + "positive_trials_for_tar": int(positive_total), + "negative_trials_for_far": len(negative_scores), + } + far_targets_with_budget = [ + far for far in far_targets if int(math.floor(far * len(negative_scores))) > 0 + ] + if positive_total <= 0 or not negative_scores: + for far in far_targets_with_budget: + label = _far_label(far) + metrics[f"TAR@FAR={label}"] = "insufficient data" + metrics[f"Threshold@FAR={label}"] = "insufficient data" + return metrics + + positives = np.sort(np.asarray(positive_scores, dtype=np.float64)) + negatives = np.sort(np.asarray(negative_scores, dtype=np.float64)) + all_scores = np.asarray(positive_scores + negative_scores, dtype=np.float64) + max_negative = float(negatives[-1]) + candidates = np.unique(np.concatenate(([np.nextafter(max_negative, np.inf)], all_scores))) + positive_accepts = positive_total - np.searchsorted(positives, candidates, side="left") + false_accepts_by_threshold = len(negative_scores) - np.searchsorted(negatives, candidates, side="left") + for far in far_targets_with_budget: + label = _far_label(far) + allowed_fp = int(math.floor(far * len(negative_scores))) + valid = false_accepts_by_threshold <= allowed_fp + if not np.any(valid): + metrics[f"TAR@FAR={label}"] = 0.0 + metrics[f"Threshold@FAR={label}"] = float(np.nextafter(max_negative, np.inf)) + metrics[f"Achieved FAR@{label}"] = 0.0 + metrics[f"False accept budget@{label}"] = allowed_fp + continue + valid_positive_accepts = positive_accepts[valid] + best_accepts = int(np.max(valid_positive_accepts)) + best_mask = valid & (positive_accepts == best_accepts) + best_threshold = float(np.min(candidates[best_mask])) + best_false_accepts = int( + false_accepts_by_threshold[np.where(candidates == best_threshold)[0][0]] + ) + best_tar = best_accepts / max(1, positive_total) + best_far = best_false_accepts / max(1, len(negative_scores)) + metrics[f"TAR@FAR={label}"] = max(0.0, best_tar) + metrics[f"Threshold@FAR={label}"] = best_threshold + metrics[f"Achieved FAR@{label}"] = best_far + metrics[f"False accept budget@{label}"] = allowed_fp + return metrics + + +def _far_label(value: float) -> str: + mantissa, exponent = f"{value:.0e}".split("e") + return f"{mantissa}e{int(exponent)}" + + +def run_identity_verification_evaluation( + identity_root: str | Path, + engine: FaceEngine, + auto_split: bool = True, + multi_face_policy: str = MULTI_FACE_REQUIRE_ONE, + license_status: str = DEFAULT_LICENSE_STATUS, + progress_callback=None, + cancel_callback=None, +) -> EvaluationResult: + root = Path(identity_root).expanduser() + identities = _identity_dirs(root) + errors: List[Dict[str, Any]] = [] + cache: Dict[str, np.ndarray] = {} + pair_specs: List[Dict[str, Any]] = [] + + if auto_split: + galleries: List[Dict[str, Any]] = [] + probes: List[Dict[str, Any]] = [] + for identity_dir in identities: + gallery, identity_probes = _auto_split_identity_images(identity_dir) + if gallery is None: + continue + identity = _identity_name(identity_dir) + galleries.append({"identity": identity, "path": gallery}) + probes.extend({"identity": identity, "path": path} for path in identity_probes) + for probe in probes: + for gallery in galleries: + pair_specs.append( + { + "image1_path": str(probe["path"]), + "image2_path": str(gallery["path"]), + "probe_identity": probe["identity"], + "gallery_identity": gallery["identity"], + "label": 1 if probe["identity"] == gallery["identity"] else 0, + } + ) + else: + images: List[Dict[str, Any]] = [] + for identity_dir in identities: + identity = _identity_name(identity_dir) + images.extend({"identity": identity, "path": path} for path in sorted(list_images(identity_dir, recursive=True))) + for left_index, left in enumerate(images): + for right in images[left_index + 1 :]: + pair_specs.append( + { + "image1_path": str(left["path"]), + "image2_path": str(right["path"]), + "probe_identity": left["identity"], + "gallery_identity": right["identity"], + "label": 1 if left["identity"] == right["identity"] else 0, + } + ) + + if not pair_specs: + raise ValueError("No verification pairs could be generated from the selected identity folders.") + + start_all = time.perf_counter() + rows: List[Dict[str, Any]] = [] + for index, spec in enumerate(pair_specs): + if cancel_callback and cancel_callback(): + break + start = time.perf_counter() + row = dict(spec) + emb1 = _embedding_for_image( + Path(spec["image1_path"]), + engine, + cache, + errors, + "verification", + multi_face_policy=multi_face_policy, + ) + emb2 = _embedding_for_image( + Path(spec["image2_path"]), + engine, + cache, + errors, + "verification", + multi_face_policy=multi_face_policy, + ) + if emb1 is None or emb2 is None: + row.update({"similarity": None, "error": "embedding unavailable"}) + else: + row.update( + { + "similarity": cosine_similarity(emb1, emb2), + "latency_ms": (time.perf_counter() - start) * 1000.0, + } + ) + rows.append(row) + if progress_callback: + progress_callback(index + 1, len(pair_specs), f"Processed 1:1 pair {index + 1}/{len(pair_specs)}") + + completed = [row for row in rows if row.get("similarity") is not None] + best_threshold, best_metrics = _metrics_at_best_threshold(completed) + positive_scores = [float(row["similarity"]) for row in completed if row.get("label") == 1] + negative_scores = [float(row["similarity"]) for row in completed if row.get("label") == 0] + metrics = { + "total_pairs": len(pair_specs), + "completed_pairs": len(completed), + "positive_pairs": sum(1 for row in pair_specs if row["label"] == 1), + "negative_pairs": sum(1 for row in pair_specs if row["label"] == 0), + "failed_pairs": len(pair_specs) - len(completed), + **best_metrics, + **_tar_far_from_scores(positive_scores, len(positive_scores), negative_scores, [1e-6, 1e-5, 1e-4, 1e-3]), + "average_latency_ms_per_pair": ( + float(np.mean([row["latency_ms"] for row in completed if row.get("latency_ms") is not None])) + if completed + else 0.0 + ), + } + return EvaluationResult( + scenario="Enterprise 1:1 Verification / Identity Folders", + model_name=engine.model_name, + provider=", ".join(engine.requested_providers), + threshold=best_threshold, + dataset_summary={ + "identity_root": str(root), + "auto_split": bool(auto_split), + "multi_face_policy": _normalize_multi_face_policy(multi_face_policy), + "identities": len(identities), + "pairing_rule": ( + "probe vs selected gallery for every identity" + if auto_split + else "all image pairs across identity folders" + ), + }, + metrics=metrics, + errors=errors, + latency={"total_elapsed_ms": (time.perf_counter() - start_all) * 1000.0, "hardware": hardware_info()}, + license_status=license_status, + created_at=utc_now_iso(), + raw_results=rows, + threshold_recommendation=best_threshold, + ) + + +def _identity_root_for_auto_split(root: Path) -> Path: + identities_root = root / "identities" + return identities_root if identities_root.is_dir() else root + + +def _collect_gallery_probe_auto_split(root: Path) -> tuple[List[Dict[str, Any]], List[Dict[str, Any]], List[Path]]: + gallery_items: List[Dict[str, Any]] = [] + probe_items: List[Dict[str, Any]] = [] + identities_root = _identity_root_for_auto_split(root) + for identity_dir in _identity_dirs(identities_root): + gallery, probes = _auto_split_identity_images(identity_dir) + if gallery is None: + continue + identity = _identity_name(identity_dir) + gallery_items.append({"identity": identity, "path": gallery}) + probe_items.extend({"identity": identity, "path": path} for path in probes) + return gallery_items, probe_items, [] + + +def _collect_gallery_probe_structured(root: Path) -> tuple[List[Dict[str, Any]], List[Dict[str, Any]], List[Path]]: + gallery_root = root / "gallery" + probe_root = root / "probe" + unknown_root = root / "unknown" + if not gallery_root.is_dir() or not probe_root.is_dir(): + raise ValueError("1:N without Auto Split requires gallery/ and probe/ folders.") + gallery_items: List[Dict[str, Any]] = [] + probe_items: List[Dict[str, Any]] = [] + for identity_dir in _identity_dirs(gallery_root): + identity = _identity_name(identity_dir) + gallery_items.extend({"identity": identity, "path": path} for path in sorted(list_images(identity_dir, recursive=True))) + for identity_dir in _identity_dirs(probe_root): + identity = _identity_name(identity_dir) + probe_items.extend({"identity": identity, "path": path} for path in sorted(list_images(identity_dir, recursive=True))) + unknown_items = sorted(list_images(unknown_root, recursive=True)) if unknown_root.is_dir() else [] + return gallery_items, probe_items, unknown_items + + +def _rank_identities(query_embedding: np.ndarray, gallery: List[Dict[str, Any]]) -> List[tuple[str, float]]: + best_by_identity: Dict[str, float] = {} + for sample in gallery: + score = cosine_similarity(query_embedding, sample["embedding"]) + identity = str(sample["identity"]) + if identity not in best_by_identity or score > best_by_identity[identity]: + best_by_identity[identity] = score + return sorted(best_by_identity.items(), key=lambda item: item[1], reverse=True) + + +def run_identity_identification_evaluation( + dataset_root: str | Path, + engine: FaceEngine, + auto_split: bool = False, + multi_face_policy: str = MULTI_FACE_REQUIRE_ONE, + license_status: str = DEFAULT_LICENSE_STATUS, + progress_callback=None, + cancel_callback=None, +) -> EvaluationResult: + root = Path(dataset_root).expanduser() + if not root.is_dir(): + raise ValueError(f"Dataset root not found: {root}") + gallery_items, probe_items, unknown_items = ( + _collect_gallery_probe_auto_split(root) if auto_split else _collect_gallery_probe_structured(root) + ) + if not gallery_items: + raise ValueError("1:N evaluation requires at least one gallery image.") + if not probe_items: + raise ValueError("1:N evaluation requires at least one known probe image.") + + errors: List[Dict[str, Any]] = [] + cache: Dict[str, np.ndarray] = {} + gallery: List[Dict[str, Any]] = [] + start_all = time.perf_counter() + for index, item in enumerate(gallery_items): + embedding = _embedding_for_image( + Path(item["path"]), + engine, + cache, + errors, + "gallery", + multi_face_policy=multi_face_policy, + ) + if embedding is not None: + gallery.append({"identity": item["identity"], "path": str(item["path"]), "embedding": embedding}) + if progress_callback: + progress_callback(index + 1, len(gallery_items), f"Indexed gallery {index + 1}/{len(gallery_items)}") + if not gallery: + raise ValueError("No gallery embeddings could be extracted.") + + rows: List[Dict[str, Any]] = [] + known_total = len(probe_items) + for index, item in enumerate(probe_items): + if cancel_callback and cancel_callback(): + break + embedding = _embedding_for_image( + Path(item["path"]), + engine, + cache, + errors, + "probe", + multi_face_policy=multi_face_policy, + ) + if embedding is None: + rows.append({"probe_path": str(item["path"]), "ground_truth": item["identity"], "error": "embedding unavailable"}) + else: + ranked = _rank_identities(embedding, gallery) + top1_identity, top1_score = ranked[0] if ranked else ("Unknown", 0.0) + top5 = [identity for identity, _score in ranked[:5]] + best_wrong = max([score for identity, score in ranked if identity != item["identity"]], default=None) + rows.append( + { + "probe_path": str(item["path"]), + "ground_truth": item["identity"], + "top1": top1_identity, + "top1_similarity": top1_score, + "top5": top5, + "correct_top1": top1_identity == item["identity"], + "best_wrong_similarity": best_wrong, + "label": "known", + } + ) + if progress_callback: + progress_callback(index + 1, known_total, f"Processed known probe {index + 1}/{known_total}") + + for index, path in enumerate(unknown_items): + if cancel_callback and cancel_callback(): + break + embedding = _embedding_for_image( + path, + engine, + cache, + errors, + "unknown", + multi_face_policy=multi_face_policy, + ) + if embedding is None: + rows.append({"probe_path": str(path), "ground_truth": "Unknown", "error": "embedding unavailable"}) + else: + ranked = _rank_identities(embedding, gallery) + top1_identity, top1_score = ranked[0] if ranked else ("Unknown", 0.0) + rows.append( + { + "probe_path": str(path), + "ground_truth": "Unknown", + "top1": top1_identity, + "top1_similarity": top1_score, + "top5": [identity for identity, _score in ranked[:5]], + "correct_top1": False, + "label": "unknown", + } + ) + if progress_callback: + progress_callback(index + 1, max(1, len(unknown_items)), f"Processed unknown probe {index + 1}/{len(unknown_items)}") + + known_rows = [row for row in rows if row.get("label") == "known" and row.get("top1_similarity") is not None] + correct_rows = [row for row in known_rows if row.get("correct_top1")] + positive_scores = [float(row["top1_similarity"]) for row in correct_rows] + negative_scores = [ + float(row["top1_similarity"]) + for row in rows + if row.get("label") == "unknown" and row.get("top1_similarity") is not None + ] + negative_scores.extend( + float(row["best_wrong_similarity"]) + for row in known_rows + if row.get("best_wrong_similarity") is not None + ) + metrics = { + "gallery_identities": len({item["identity"] for item in gallery}), + "gallery_images": len(gallery_items), + "gallery_embeddings": len(gallery), + "known_probe_images": len(probe_items), + "unknown_probe_images": len(unknown_items), + "completed_known_probes": len(known_rows), + "Top1": len(correct_rows) / max(1, len(known_rows)), + **_tar_far_from_scores(positive_scores, len(known_rows), negative_scores, [1e-5, 1e-4, 1e-3, 1e-2]), + } + threshold_recommendation = None + for key in ("Threshold@FAR=1e-3", "Threshold@FAR=1e-2", "Threshold@FAR=1e-4"): + value = metrics.get(key) + if isinstance(value, float): + threshold_recommendation = value + break + return EvaluationResult( + scenario="Enterprise 1:N Identification / Identity Folders", + model_name=engine.model_name, + provider=", ".join(engine.requested_providers), + threshold=threshold_recommendation or DEFAULT_THRESHOLD, + dataset_summary={ + "dataset_root": str(root), + "auto_split": bool(auto_split), + "multi_face_policy": _normalize_multi_face_policy(multi_face_policy), + "structured_rule": "gallery/probe/unknown" if not auto_split else "identities auto split", + "gallery_required": True, + }, + metrics=metrics, + errors=errors, + latency={"total_elapsed_ms": (time.perf_counter() - start_all) * 1000.0, "hardware": hardware_info()}, + license_status=license_status, + created_at=utc_now_iso(), + raw_results=rows, + threshold_recommendation=threshold_recommendation, + ) + + +def run_kyc_pairs_evaluation( + pairs_csv: str | Path, + engine: FaceEngine, + threshold: float = DEFAULT_THRESHOLD, + license_status: str = DEFAULT_LICENSE_STATUS, + progress_callback=None, + cancel_callback=None, +) -> EvaluationResult: + rows: List[Dict[str, Any]] = [] + errors: List[Dict[str, Any]] = [] + with Path(pairs_csv).open("r", newline="", encoding="utf-8-sig") as handle: + reader = csv.DictReader(handle) + pairs = list(reader) + start_all = time.perf_counter() + for index, row in enumerate(pairs): + if cancel_callback and cancel_callback(): + break + image1_path = row.get("image1_path") or row.get("image1") or "" + image2_path = row.get("image2_path") or row.get("image2") or "" + label = int(row.get("label", "0")) + item: Dict[str, Any] = {"image1_path": image1_path, "image2_path": image2_path, "label": label} + start = time.perf_counter() + try: + img1 = read_image(image1_path) + img2 = read_image(image2_path) + if img1 is None or img2 is None: + raise ValueError("image read failure") + face1 = engine.detect_best_face(img1, source_path=image1_path) + face2 = engine.detect_best_face(img2, source_path=image2_path) + if face1 is None or face2 is None: + raise ValueError("failed detection") + if face1.normed_embedding is None or face2.normed_embedding is None: + raise ValueError("embedding unavailable") + similarity = cosine_similarity(face1.normed_embedding, face2.normed_embedding) + item.update( + { + "similarity": similarity, + "predicted": 1 if similarity >= threshold else 0, + "latency_ms": (time.perf_counter() - start) * 1000.0, + } + ) + except Exception as exc: + item.update({"similarity": None, "predicted": None, "error": str(exc)}) + errors.append({"index": index, "error": str(exc), "row": dict(row)}) + rows.append(item) + if progress_callback: + progress_callback(index + 1, len(pairs), f"Processed pair {index + 1}/{len(pairs)}") + + completed = [row for row in rows if row.get("similarity") is not None] + metrics = _metrics_at_threshold(completed, threshold) + metrics.update( + { + "total_pairs": len(pairs), + "positive_pairs": sum(1 for row in rows if row.get("label") == 1), + "negative_pairs": sum(1 for row in rows if row.get("label") == 0), + "failed_detections": len(errors), + "TAR@FAR=1e-2": tar_at_far(completed, 1e-2), + "TAR@FAR=1e-3": tar_at_far(completed, 1e-3), + "TAR@FAR=1e-4": tar_at_far(completed, 1e-4), + "average_latency_ms_per_pair": ( + float(np.mean([row["latency_ms"] for row in completed])) if completed else 0.0 + ), + } + ) + return EvaluationResult( + scenario="KYC / 1:1 Verification", + model_name=engine.model_name, + provider=", ".join(engine.requested_providers), + threshold=threshold, + dataset_summary={ + "pairs_csv": str(pairs_csv), + "total_pairs": len(pairs), + "completed_pairs": len(completed), + }, + metrics=metrics, + errors=errors, + latency={ + "total_elapsed_ms": (time.perf_counter() - start_all) * 1000.0, + "hardware": hardware_info(), + }, + license_status=license_status, + created_at=utc_now_iso(), + raw_results=rows, + threshold_recommendation=recommend_threshold(completed), + ) + + +def run_identification_evaluation( + gallery_folder: str | Path, + probe_folder: str | Path, + engine: FaceEngine, + threshold: float = DEFAULT_THRESHOLD, + ground_truth_csv: Optional[str | Path] = None, + license_status: str = DEFAULT_LICENSE_STATUS, + progress_callback=None, + cancel_callback=None, +) -> EvaluationResult: + gallery: List[Dict[str, Any]] = [] + errors: List[Dict[str, Any]] = [] + gallery_root = Path(gallery_folder) + for person_dir in sorted(path for path in gallery_root.iterdir() if path.is_dir()): + for image_path in sorted(path for path in person_dir.rglob("*") if path.suffix.lower() in IMAGE_EXTENSIONS): + try: + img = read_image(image_path) + if img is None: + raise ValueError("image read failure") + face = engine.detect_best_face(img, source_path=str(image_path)) + if face is None or face.normed_embedding is None: + raise ValueError("no face or embedding") + gallery.append( + { + "person_id": person_dir.name, + "person_name": person_dir.name, + "sample_id": len(gallery) + 1, + "crop_path": "", + "embedding": face.normed_embedding, + } + ) + except Exception as exc: + errors.append({"path": str(image_path), "error": str(exc), "stage": "gallery"}) + + ground_truth: Dict[str, str] = {} + if ground_truth_csv: + with Path(ground_truth_csv).open("r", newline="", encoding="utf-8-sig") as handle: + for row in csv.DictReader(handle): + ground_truth[row.get("image_path", "")] = row.get("person_name", "") + + probes = list_images(probe_folder, recursive=True) + raw: List[Dict[str, Any]] = [] + start_all = time.perf_counter() + for index, probe in enumerate(probes): + if cancel_callback and cancel_callback(): + break + try: + img = read_image(probe) + if img is None: + raise ValueError("image read failure") + face = engine.detect_best_face(img, source_path=str(probe)) + if face is None or face.normed_embedding is None: + raise ValueError("no face or embedding") + from .recognition import search_gallery + + results = search_gallery(face.normed_embedding, gallery, top_k=5, threshold=threshold) + truth = ground_truth.get(str(probe), ground_truth.get(probe.name, "")) + row = { + "probe_path": str(probe), + "ground_truth": truth, + "top1": results[0].person_name if results else "Unknown", + "top1_similarity": results[0].similarity if results else 0.0, + "top5": [result.person_name for result in results], + "accepted": bool(results and results[0].similarity >= threshold), + } + raw.append(row) + except Exception as exc: + errors.append({"path": str(probe), "error": str(exc), "stage": "probe"}) + if progress_callback: + progress_callback(index + 1, len(probes), f"Processed probe {index + 1}/{len(probes)}") + + truth_rows = [row for row in raw if row.get("ground_truth")] + top1 = sum(1 for row in truth_rows if row["top1"] == row["ground_truth"]) / max(1, len(truth_rows)) + top5 = sum(1 for row in truth_rows if row["ground_truth"] in row["top5"]) / max(1, len(truth_rows)) + metrics = { + "gallery_persons": len({row["person_name"] for row in gallery}), + "gallery_face_samples": len(gallery), + "probe_images": len(probes), + "detected_probe_faces": len(raw), + "Top-1 accuracy": top1 if truth_rows else "ground truth not provided", + "Top-5 accuracy": top5 if truth_rows else "ground truth not provided", + "unknown_rejection_rate": sum(1 for row in raw if not row["accepted"]) / max(1, len(raw)), + "average_search_latency_ms": 0.0, + } + return EvaluationResult( + scenario="Access Control / 1:N Identification", + model_name=engine.model_name, + provider=", ".join(engine.requested_providers), + threshold=threshold, + dataset_summary={ + "gallery_folder": str(gallery_folder), + "probe_folder": str(probe_folder), + "ground_truth_csv": str(ground_truth_csv or ""), + }, + metrics=metrics, + errors=errors, + latency={"total_elapsed_ms": (time.perf_counter() - start_all) * 1000.0, "hardware": hardware_info()}, + license_status=license_status, + created_at=utc_now_iso(), + raw_results=raw, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/exporters.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/exporters.py new file mode 100644 index 0000000000000000000000000000000000000000..ccd76f512f9fbdfa41904119ab1258068022b00e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/exporters.py @@ -0,0 +1,51 @@ +"""Export helpers for JSON, CSV, Markdown, HTML, and annotated images.""" + +from __future__ import annotations + +import csv +import json +from pathlib import Path +from typing import Any, Iterable, Mapping + +from .utils import safe_json_dumps, save_image + + +def export_json(path: str | Path, data: Any) -> Path: + out = Path(path) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(data, indent=2, ensure_ascii=False, default=str), encoding="utf-8") + return out + + +def export_csv(path: str | Path, rows: Iterable[Mapping[str, Any]]) -> Path: + out = Path(path) + out.parent.mkdir(parents=True, exist_ok=True) + rows = list(rows) + fieldnames = sorted({key for row in rows for key in row.keys()}) + with out.open("w", newline="", encoding="utf-8") as handle: + writer = csv.DictWriter(handle, fieldnames=fieldnames) + writer.writeheader() + for row in rows: + writer.writerow({key: safe_json_dumps(value) if isinstance(value, (dict, list)) else value for key, value in row.items()}) + return out + + +def export_markdown(path: str | Path, text: str) -> Path: + out = Path(path) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(text, encoding="utf-8") + return out + + +def export_html(path: str | Path, html: str) -> Path: + out = Path(path) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(html, encoding="utf-8") + return out + + +def export_annotated_image(path: str | Path, image) -> Path: + out = Path(path) + if not save_image(out, image): + raise IOError(f"Unable to write image: {out}") + return out diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/face_engine.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/face_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..00f1992032a657528d87ae9535b5b2121492da94 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/face_engine.py @@ -0,0 +1,420 @@ +"""InsightFace runtime wrapper used by the GUI.""" + +from __future__ import annotations + +import glob +import os +import threading +import time +from pathlib import Path +from typing import Any, Dict, Iterable, List, Optional + +import numpy as np + +from .constants import AUTO_DET_SIZES, DEFAULT_DET_SIZE, DEFAULT_MODEL_NAME, DEFAULT_THRESHOLD +from .logging import get_logger +from .models import CompareResult, FaceRecord +from .quality import score_face +from .recognition import compare_embeddings, cosine_similarity, normalize_embedding +from .utils import crop_bbox + +LOGGER = get_logger("face_engine") + + +class ModelNotLoadedError(RuntimeError): + pass + + +class FaceEngine: + def __init__( + self, + model_name: str = DEFAULT_MODEL_NAME, + providers: Optional[Iterable[str]] = None, + det_size: tuple[int, int] = DEFAULT_DET_SIZE, + root: str | os.PathLike[str] | None = None, + custom_model_dir: str | os.PathLike[str] | None = None, + ): + self.model_name = model_name + self.root = Path(os.path.expanduser(str(root or "~/.insightface"))) + self.custom_model_dir = Path(os.path.expanduser(str(custom_model_dir))) if custom_model_dir else None + self.requested_providers = list(providers or ["CPUExecutionProvider"]) + self.det_size = det_size + self.det_sizes = self._resolve_det_sizes(det_size) + self.auto_det_size = len(self.det_sizes) > 1 + self.models: Dict[str, Any] = {} + self.det_model = None + self.loaded = False + self.last_error = "" + self.embedding_dim: Optional[int] = None + self.last_latency_ms: Dict[str, float] = {} + self.active_providers: List[str] = [] + self.ctx_id = -1 + self._prepared_det_size = None + self._lock = threading.RLock() + + def is_loaded(self) -> bool: + return self.loaded and self.det_model is not None + + def resolve_model_dir(self) -> Path: + if self.custom_model_dir and self.custom_model_dir.exists(): + return self.custom_model_dir + model_path = Path(os.path.expanduser(self.model_name)) + if model_path.exists() and model_path.is_dir(): + return model_path + return self.root / "models" / self.model_name + + def load(self) -> None: + with self._lock: + self.loaded = False + self.last_error = "" + self.models.clear() + start = time.perf_counter() + model_dir = self.resolve_model_dir() + if not model_dir.exists(): + self.last_error = ( + f"Model directory not found: {model_dir}. Configure a local model directory " + "or install the model pack first." + ) + LOGGER.warning(self.last_error) + return + onnx_files = sorted(glob.glob(str(model_dir / "*.onnx"))) + if not onnx_files: + self.last_error = f"No .onnx model files found in {model_dir}." + LOGGER.warning(self.last_error) + return + try: + from insightface.app.common import Face + except Exception as exc: + self.last_error = f"InsightFace runtime import failed: {exc}" + LOGGER.exception(self.last_error) + return + + del Face + try: + for onnx_file in onnx_files: + model = self._load_model_from_onnx(onnx_file) + if model is None: + continue + if model.taskname in self.models: + continue + self.models[model.taskname] = model + if "detection" not in self.models: + self.last_error = f"No detection model found in {model_dir}." + return + self.det_model = self.models["detection"] + ctx_id = 0 if any("CUDA" in provider for provider in self.requested_providers) else -1 + self.ctx_id = ctx_id + for taskname, model in self.models.items(): + if taskname == "detection": + self._prepare_detection() + else: + model.prepare(ctx_id) + self.loaded = True + self.embedding_dim = self._infer_embedding_dim() + self.active_providers = self.requested_providers + self.last_latency_ms["load"] = (time.perf_counter() - start) * 1000.0 + except Exception as exc: + self.last_error = f"Model load failed: {exc}" + LOGGER.exception(self.last_error) + self.loaded = False + + def _load_model_from_onnx(self, onnx_file: str): + """Load a model pack member, forcing GUI detection through SCRFD.""" + try: + from insightface.model_zoo.arcface_onnx import ArcFaceONNX + from insightface.model_zoo.attribute import Attribute + from insightface.model_zoo.inswapper import INSwapper + from insightface.model_zoo.landmark import Landmark + from insightface.model_zoo.model_zoo import PickableInferenceSession + from insightface.model_zoo.scrfd import SCRFD + except Exception as exc: + raise RuntimeError(f"InsightFace model imports failed: {exc}") from exc + + session_kwargs = { + "providers": self.requested_providers, + "provider_options": None, + } + session_options = self._quiet_onnxruntime_session_options() + if session_options is not None: + session_kwargs["sess_options"] = session_options + session = PickableInferenceSession(onnx_file, **session_kwargs) + LOGGER.info("Applied providers for %s: %s", onnx_file, getattr(session, "_providers", [])) + inputs = session.get_inputs() + if not inputs: + return None + input_shape = inputs[0].shape + outputs = session.get_outputs() + input_height = self._shape_dim(input_shape, 2) + input_width = self._shape_dim(input_shape, 3) + + if self._is_scrfd_detection_outputs(outputs): + LOGGER.info("GUI detection model routed to SCRFD: %s", onnx_file) + return SCRFD(model_file=onnx_file, session=session) + if input_height == 192 and input_width == 192: + return Landmark(model_file=onnx_file, session=session) + if input_height == 96 and input_width == 96: + return Attribute(model_file=onnx_file, session=session) + if len(inputs) == 2 and input_height == 128 and input_width == 128: + return INSwapper(model_file=onnx_file, session=session) + if ( + input_height is not None + and input_width is not None + and input_height == input_width + and input_height >= 112 + and input_height % 16 == 0 + ): + return ArcFaceONNX(model_file=onnx_file, session=session) + return None + + @staticmethod + def _shape_dim(shape, index: int) -> Optional[int]: + try: + value = shape[index] + except Exception: + return None + try: + return int(value) + except (TypeError, ValueError): + return None + + @staticmethod + def _is_scrfd_detection_outputs(outputs) -> bool: + return len(outputs) in {6, 9, 10, 15} + + @staticmethod + def _quiet_onnxruntime_session_options(): + try: + import onnxruntime + + onnxruntime.set_default_logger_severity(3) + session_options = onnxruntime.SessionOptions() + session_options.log_severity_level = 3 + return session_options + except Exception: + return None + + def _infer_embedding_dim(self) -> Optional[int]: + for model in self.models.values(): + if getattr(model, "taskname", "") == "recognition": + output_shape = getattr(model, "output_shape", None) + if output_shape: + try: + return int(output_shape[-1]) + except Exception: + return None + return None + + def warmup(self) -> Dict[str, Any]: + if not self.is_loaded(): + raise ModelNotLoadedError("Model is not loaded. Please open Models.") + warmup_width = max(size[0] for size in self.det_sizes) + warmup_height = max(size[1] for size in self.det_sizes) + image = np.zeros((warmup_height, warmup_width, 3), dtype=np.uint8) + start = time.perf_counter() + self.detect_faces(image) + elapsed = (time.perf_counter() - start) * 1000.0 + self.last_latency_ms["warmup"] = elapsed + return {"warmup_ms": elapsed} + + def detect_faces(self, image: np.ndarray, source_path: Optional[str] = None) -> List[FaceRecord]: + with self._lock: + if not self.is_loaded(): + raise ModelNotLoadedError("Model is not loaded. Please open Models.") + if image is None: + return [] + image = np.ascontiguousarray(image) + try: + from insightface.app.common import Face + except Exception as exc: + raise ModelNotLoadedError(f"InsightFace Face class import failed: {exc}") from exc + + start = time.perf_counter() + bboxes, kpss = self._detect_raw(image) + records: List[FaceRecord] = [] + if bboxes is None or bboxes.shape[0] == 0: + self.last_latency_ms["detect"] = (time.perf_counter() - start) * 1000.0 + return records + for idx in range(bboxes.shape[0]): + bbox = bboxes[idx, 0:4] + det_score = float(bboxes[idx, 4]) + kps = kpss[idx] if kpss is not None else None + face = Face(bbox=bbox, kps=kps, det_score=det_score) + for taskname, model in self.models.items(): + if taskname == "detection": + continue + model.get(image, face) + embedding = getattr(face, "embedding", None) + normed_embedding = getattr(face, "normed_embedding", None) + if normed_embedding is None and embedding is not None: + normed_embedding = normalize_embedding(embedding) + crop = crop_bbox(image, bbox) + quality_score, quality_flags = score_face(image, bbox, kps, det_score) + records.append( + FaceRecord( + face_id=f"{source_path or 'image'}:{idx}", + bbox=[float(v) for v in bbox], + kps=kps.tolist() if kps is not None else None, + det_score=det_score, + embedding=np.asarray(embedding, dtype=np.float32).reshape(-1) if embedding is not None else None, + normed_embedding=( + np.asarray(normed_embedding, dtype=np.float32).reshape(-1) + if normed_embedding is not None + else None + ), + gender=getattr(face, "gender", None), + age=getattr(face, "age", None), + quality_score=quality_score, + quality_flags=quality_flags, + crop=crop, + source_path=source_path, + ) + ) + self.last_latency_ms["detect"] = (time.perf_counter() - start) * 1000.0 + return records + + def detect_best_face(self, image: np.ndarray, source_path: Optional[str] = None) -> Optional[FaceRecord]: + faces = self.detect_faces(image, source_path=source_path) + if not faces: + return None + return max( + faces, + key=lambda face: ( + (face.bbox[2] - face.bbox[0]) * (face.bbox[3] - face.bbox[1]), + face.det_score, + ), + ) + + def compute_similarity(self, emb1: np.ndarray, emb2: np.ndarray) -> float: + return cosine_similarity(emb1, emb2) + + def compare_images( + self, + image1: np.ndarray, + image2: np.ndarray, + threshold: float = DEFAULT_THRESHOLD, + path1: Optional[str] = None, + path2: Optional[str] = None, + ) -> CompareResult: + with self._lock: + face_a = self.detect_best_face(image1, source_path=path1) + face_b = self.detect_best_face(image2, source_path=path2) + if face_a is None: + raise ValueError("No face detected in Image A.") + if face_b is None: + raise ValueError("No face detected in Image B.") + if face_a.normed_embedding is None or face_b.normed_embedding is None: + raise ValueError("Recognition embedding is unavailable for one or both faces.") + comparison = compare_embeddings(face_a.normed_embedding, face_b.normed_embedding, threshold) + notes = [] + for label, face in (("Image A", face_a), ("Image B", face_b)): + if face.quality_score is not None and face.quality_score < 0.45: + notes.append(f"{label} has low quality. Recognition may be unreliable.") + if face.quality_flags: + notes.append(f"{label}: {', '.join(face.quality_flags)}") + return CompareResult( + similarity=float(comparison["similarity"]), + threshold=threshold, + decision=str(comparison["decision"]), + face_a=face_a, + face_b=face_b, + notes=notes, + ) + + def get_runtime_info(self) -> Dict[str, Any]: + return { + "model_name": self.model_name, + "model_dir": str(self.resolve_model_dir()), + "providers": self.active_providers or self.requested_providers, + "detector": type(self.det_model).__name__ if self.det_model is not None else None, + "det_size": self._det_size_label(), + "embedding_dim": self.embedding_dim, + "loaded": self.is_loaded(), + "last_error": self.last_error, + "last_latency_ms": self.last_latency_ms, + } + + def _resolve_det_sizes(self, det_size: tuple[int, int]) -> list[tuple[int, int]]: + width, height = int(det_size[0]), int(det_size[1]) + if width <= 0 or height <= 0: + return [(int(width), int(height)) for width, height in AUTO_DET_SIZES] + return [(width, height)] + + def _det_size_label(self) -> str: + if self.auto_det_size: + return "Auto (" + " + ".join(f"{width}x{height}" for width, height in self.det_sizes) + ")" + width, height = self.det_sizes[0] + return f"{width}x{height}" + + def _prepare_detection(self) -> None: + if self.det_model is None: + return + input_size = self._detector_input_size() + if self._prepared_det_size == input_size: + return + LOGGER.debug("Preparing detection model with det_size=%s", input_size) + self.det_model.prepare(self.ctx_id, input_size=input_size, det_thresh=0.5) + self._prepared_det_size = input_size + + def _detect_raw(self, image: np.ndarray): + self._prepare_detection() + return self.det_model.detect(image, max_num=0, metric="default") + + def _detector_input_size(self): + if self.auto_det_size: + return list(self.det_sizes) + return self.det_sizes[0] + + @staticmethod + def _nms(boxes: np.ndarray, scores: np.ndarray, iou_threshold: float = 0.4) -> list[int]: + if boxes.size == 0: + return [] + x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3] + areas = np.maximum(0.0, x2 - x1 + 1.0) * np.maximum(0.0, y2 - y1 + 1.0) + order = scores.argsort()[::-1] + keep: list[int] = [] + while order.size > 0: + current = int(order[0]) + keep.append(current) + if order.size == 1: + break + xx1 = np.maximum(x1[current], x1[order[1:]]) + yy1 = np.maximum(y1[current], y1[order[1:]]) + xx2 = np.minimum(x2[current], x2[order[1:]]) + yy2 = np.minimum(y2[current], y2[order[1:]]) + width = np.maximum(0.0, xx2 - xx1 + 1.0) + height = np.maximum(0.0, yy2 - yy1 + 1.0) + inter = width * height + union = areas[current] + areas[order[1:]] - inter + iou = np.where(union > 0, inter / union, 0.0) + order = order[np.where(iou <= iou_threshold)[0] + 1] + return keep + + +def available_execution_providers() -> List[str]: + try: + import onnxruntime + + providers = onnxruntime.get_available_providers() + return [str(provider) for provider in providers] + except Exception as exc: + LOGGER.debug("Unable to inspect ONNX Runtime providers: %s", exc) + return [] + + +def is_cuda_provider_available() -> bool: + return "CUDAExecutionProvider" in available_execution_providers() + + +def providers_from_choice(choice: str) -> List[str]: + normalized = (choice or "CPU").strip().lower() + if normalized == "cpu": + return ["CPUExecutionProvider"] + if normalized == "cuda": + if is_cuda_provider_available(): + return ["CUDAExecutionProvider", "CPUExecutionProvider"] + LOGGER.warning("CUDA provider was requested but CUDAExecutionProvider is not available; using CPU.") + return ["CPUExecutionProvider"] + available = available_execution_providers() + if "CUDAExecutionProvider" in available: + return ["CUDAExecutionProvider", "CPUExecutionProvider"] + return ["CPUExecutionProvider"] diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/i18n.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/i18n.py new file mode 100644 index 0000000000000000000000000000000000000000..93d53d0d34034acae1edc68081703944c610f3ee --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/i18n.py @@ -0,0 +1,3078 @@ +"""Lightweight runtime localization for the desktop GUI.""" + +from __future__ import annotations + +import locale +from dataclasses import dataclass +from typing import Any + +from PySide6.QtCore import QLocale, QObject, Qt +from PySide6.QtGui import QAction +from PySide6.QtWidgets import ( + QAbstractButton, + QComboBox, + QDialog, + QGroupBox, + QLabel, + QLineEdit, + QMainWindow, + QMenu, + QTabWidget, + QTableWidget, + QWidget, +) + + +@dataclass(frozen=True) +class LanguageOption: + value: str + label: str + native_label: str + + +LANGUAGE_OPTIONS = [ + LanguageOption("system", "System default", "System default"), + LanguageOption("en", "English", "English"), + LanguageOption("zh", "Chinese", "中文"), + LanguageOption("ja", "Japanese", "日本語"), + LanguageOption("ko", "Korean", "한국어"), + LanguageOption("es", "Spanish", "Español"), + LanguageOption("fr", "French", "Français"), + LanguageOption("de", "German", "Deutsch"), + LanguageOption("pt", "Portuguese", "Português"), + LanguageOption("ru", "Russian", "Русский"), +] + +SUPPORTED_LANGUAGE_CODES = {option.value for option in LANGUAGE_OPTIONS if option.value != "system"} +_SOURCE_PROPERTY = "_insightface_i18n_source" +_PLACEHOLDER_PROPERTY = "_insightface_i18n_placeholder_source" +_GENERIC_BUTTON_TOOLTIP = { + "zh": "点击执行:{action}。", + "ja": "クリックして「{action}」を実行します。", + "ko": "클릭하여 {action}을 실행합니다.", + "es": "Haga clic para ejecutar: {action}.", + "fr": "Cliquez pour exécuter : {action}.", + "de": "Klicken, um auszuführen: {action}.", + "pt": "Clique para executar: {action}.", + "ru": "Нажмите, чтобы выполнить: {action}.", +} + + +def normalize_language(language: str | None) -> str: + value = (language or "system").strip().replace("-", "_").lower() + if value in {"auto", "default", "system_default"}: + return "system" + code = value.split("_", 1)[0] + if code in SUPPORTED_LANGUAGE_CODES: + return code + return "system" if not value or value == "system" else "en" + + +def detect_system_language() -> str: + candidates = [] + try: + candidates.append(QLocale.system().name()) + except Exception: + pass + try: + candidates.append(locale.getlocale()[0] or "") + except Exception: + pass + for candidate in candidates: + code = normalize_language(candidate) + if code in SUPPORTED_LANGUAGE_CODES: + return code + return "en" + + +def effective_language(language: str | None) -> str: + value = normalize_language(language) + return detect_system_language() if value == "system" else value + + +def language_label(language: str | None) -> str: + value = normalize_language(language) + for option in LANGUAGE_OPTIONS: + if option.value == value: + return option.native_label + return "English" + + +def tr(text: str, language: str | None = None) -> str: + if not text: + return text + lang = effective_language(language) + if lang == "en": + return text + return _TRANSLATIONS.get(lang, {}).get(text, text) + + +def apply_translations(root: Any, language: str | None) -> None: + """Translate common Qt widget texts in-place with English fallback.""" + lang = effective_language(language) + _translate_object(root, lang) + if hasattr(root, "findChildren"): + for obj in root.findChildren(QObject): + _translate_object(obj, lang) + + +def _source_text(obj: Any, text: str, prop: str = _SOURCE_PROPERTY) -> str: + source = obj.property(prop) if hasattr(obj, "property") else None + if source is None and hasattr(obj, "setProperty"): + obj.setProperty(prop, text) + return text + if source is not None and not _matches_source_or_translation(str(source), text) and hasattr(obj, "setProperty"): + obj.setProperty(prop, text) + return text + return str(source) + + +def _matches_source_or_translation(source: str, text: str) -> bool: + if text == source: + return True + return any(translations.get(source) == text for translations in _TRANSLATIONS.values()) + + +def _help_source_text(obj: Any, text: str, prop: str) -> str: + source = obj.property(prop) if hasattr(obj, "property") else None + if source is None and hasattr(obj, "setProperty"): + obj.setProperty(prop, text) + return text + if source is not None: + if _matches_source_or_translation(str(source), text): + return str(source) + if isinstance(obj, QAbstractButton) and _looks_like_generic_button_tooltip(text): + return str(source) + if hasattr(obj, "setProperty"): + obj.setProperty(prop, text) + return text + return str(source) + + +def _looks_like_generic_button_tooltip(text: str) -> bool: + for template in _GENERIC_BUTTON_TOOLTIP.values(): + prefix, suffix = template.split("{action}", 1) + if text.startswith(prefix) and text.endswith(suffix): + return True + return False + + +def _translate_object(obj: Any, lang: str) -> None: + _translate_object_help(obj, lang) + if isinstance(obj, (QDialog, QMainWindow)): + title = obj.windowTitle() + if title: + obj.setWindowTitle(tr(_source_text(obj, title), lang)) + if isinstance(obj, QMenu): + title = obj.title() + if title: + obj.setTitle(tr(_source_text(obj, title), lang)) + if isinstance(obj, QAction): + text = obj.text() + if text: + obj.setText(tr(_source_text(obj, text), lang)) + _translate_action_help(obj, lang) + if isinstance(obj, QLabel): + text = obj.text() + if text: + obj.setText(tr(_source_text(obj, text), lang)) + if isinstance(obj, QAbstractButton): + text = obj.text() + if text: + obj.setText(tr(_source_text(obj, text), lang)) + if isinstance(obj, QGroupBox): + title = obj.title() + if title: + obj.setTitle(tr(_source_text(obj, title), lang)) + if isinstance(obj, QLineEdit): + placeholder = obj.placeholderText() + if placeholder: + obj.setPlaceholderText(tr(_source_text(obj, placeholder, _PLACEHOLDER_PROPERTY), lang)) + if isinstance(obj, QTabWidget): + for index in range(obj.count()): + text = obj.tabText(index) + key = f"{_SOURCE_PROPERTY}_tab_{index}" + source = obj.property(key) + if source is None: + obj.setProperty(key, text) + source = text + obj.setTabText(index, tr(str(source), lang)) + if isinstance(obj, QComboBox) and obj.property("i18nItems"): + for index in range(obj.count()): + text = obj.itemText(index) + source = obj.itemData(index, Qt.UserRole + 3000) + if source is None: + obj.setItemData(index, text, Qt.UserRole + 3000) + source = text + obj.setItemText(index, tr(str(source), lang)) + if isinstance(obj, QTableWidget): + for index in range(obj.columnCount()): + item = obj.horizontalHeaderItem(index) + if item is not None: + source = item.data(Qt.UserRole + 3000) + if source is None: + source = item.text() + item.setData(Qt.UserRole + 3000, source) + item.setText(tr(str(source), lang)) + + +def _translate_object_help(obj: Any, lang: str) -> None: + if not isinstance(obj, QWidget): + return + tooltip = obj.toolTip() + if tooltip: + tooltip_source = _help_source_text(obj, tooltip, f"{_SOURCE_PROPERTY}_tooltip") + translated = tr(tooltip_source, lang) + if translated == tooltip_source and lang != "en" and isinstance(obj, QAbstractButton): + translated = _generic_button_tooltip(obj, lang) + obj.setToolTip(translated) + status_tip = obj.statusTip() + if status_tip: + obj.setStatusTip(tr(_source_text(obj, status_tip, f"{_SOURCE_PROPERTY}_status_tip"), lang)) + whats_this = obj.whatsThis() + if whats_this: + obj.setWhatsThis(tr(_source_text(obj, whats_this, f"{_SOURCE_PROPERTY}_whats_this"), lang)) + + +def _translate_action_help(action: QAction, lang: str) -> None: + tooltip = action.toolTip() + if tooltip: + action.setToolTip(tr(_source_text(action, tooltip, f"{_SOURCE_PROPERTY}_tooltip"), lang)) + status_tip = action.statusTip() + if status_tip: + action.setStatusTip(tr(_source_text(action, status_tip, f"{_SOURCE_PROPERTY}_status_tip"), lang)) + whats_this = action.whatsThis() + if whats_this: + action.setWhatsThis(tr(_source_text(action, whats_this, f"{_SOURCE_PROPERTY}_whats_this"), lang)) + + +def _generic_button_tooltip(button: QAbstractButton, lang: str) -> str: + source = button.property(_SOURCE_PROPERTY) + if source is None: + text = button.text().replace("&", "").strip() + source = "Remove" if text == "×" else text + action = tr(str(source), lang) + if not action or action == "×": + action = tr("Remove", lang) + return _GENERIC_BUTTON_TOOLTIP.get(lang, "{action}").format(action=action) + + +_TRANSLATIONS: dict[str, dict[str, str]] = { + "zh": { + "System default": "跟随系统", + "Settings": "设置", + "Application Settings": "应用设置", + "Only appearance settings are configurable here. Workspace paths are fixed after first launch.": "此处仅配置界面外观。工作目录在首次启动后保持固定。", + "UI theme": "界面主题", + "Language": "语言", + "Save": "保存", + "Apply": "应用", + "Cancel": "取消", + "Models": "模型", + "License": "授权", + "Research / Non-commercial": "研究 / 非商业", + "License Center": "授权中心", + "Workflows": "工作流", + "Choose the workspace for the task.": "选择当前任务的工作区。", + "Enterprise Help": "企业支持", + "All processing is local. No images, embeddings, or reports are uploaded automatically.": "所有处理默认在本地完成。图片、特征和报告不会自动上传。", + "Face Recognition": "人脸识别", + "Album Management": "相册管理", + "Face Swap": "人脸替换", + "Enterprise Evaluation": "企业评测", + "Query and gallery recognition": "查询图与底库识别", + "Photo clustering and review": "照片聚类与复核", + "Source + Target = Result": "源图 + 目标 = 结果", + "Datasets, metrics, and reports": "数据集、指标与报告", + "Upload a query face and recognize it against one gallery image or a local gallery.": "上传查询人脸,并与单张底库图或本地底库进行识别。", + "Organize local photos by people, clusters, and searchable face groups.": "按人物、聚类和可搜索人脸组整理本地照片。", + "Use a configured downloaded swap model for local image or video face swap.": "使用已配置并下载的换脸模型在本地处理图片或视频。", + "Run local 1:1 and 1:N model evaluations and export reports.": "运行本地 1:1 和 1:N 模型评测并导出报告。", + "Visit Homepage": "访问主页", + "Contact Enterprise Support": "联系企业支持", + "Usage": "用途", + "Status": "状态", + "Personal research": "个人研究", + "Internal evaluation": "内部评估", + "Commercial production": "商业生产", + "Redistribution": "再分发", + "SaaS / API usage": "SaaS / API 使用", + "Face swap commercial usage": "换脸商业使用", + "yes": "可以", + "depends on model license": "取决于模型授权", + "requires commercial model license": "需要商业模型授权", + "requires explicit permission": "需要明确许可", + "requires commercial agreement": "需要商业协议", + "A concise local-use and commercial-deployment summary.": "本地使用与商业部署的简明说明。", + "InsightFace Evaluation Studio runs locally and does not upload images, embeddings, videos, or reports automatically.": "InsightFace Evaluation Studio 在本地运行,不会自动上传图片、特征、视频或报告。", + "Code and model files may have different licenses, and commercial deployment requires appropriate model authorization.": "代码和模型文件可能适用不同授权;商业部署需要相应的模型授权。", + "Current package": "当前包", + "Evaluation Setup": "评测设置", + "Evaluation mode": "评测模式", + "Data split": "数据切分", + "Multi-face handling": "多人脸处理", + "Dataset": "数据集", + "Run": "运行", + "Dataset Rules": "数据集规则", + "Validate Dataset": "核验数据集", + "Run Evaluation": "运行评测", + "Export PDF": "导出 PDF", + "Open Report Folder": "打开报告目录", + "Validate the selected dataset and configuration before running evaluation.": "运行评测前请先核验所选数据集和配置。", + "Validate the dataset before running an evaluation.": "运行评测前请先核验数据集。", + "Dataset validation is required before running an evaluation.": "运行评测前需要完成数据集核验。", + "Evaluation Dataset Rules": "评测数据集规则", + "Prepare local identity folders using one of the supported layouts below.": "请按以下任一支持结构准备本地身份文件夹。", + "Recognition threshold": "识别阈值", + "Run Recognition": "运行识别", + "Clear": "清空", + "Query": "查询图", + "Gallery": "底库", + "Album": "相册", + "Album directories": "相册目录", + "Drag album folders into the directory list, or click Add Folder.": "将相册文件夹拖入目录列表,或点击“添加文件夹”。", + "Import / Refresh": "导入 / 刷新", + "Rebuild All": "全部重建", + "Add Folder": "添加文件夹", + "Remove Selected": "移除所选", + "Cosine threshold": "余弦阈值", + "Min samples": "最小样本数", + "Minimum face size": "最小人脸尺寸", + "Algorithm: DBSCAN": "算法:DBSCAN", + "Thumbnail": "缩略图", + "Photos": "照片", + "File": "文件", + "Faces in cluster": "聚类内人脸数", + "Run Face Swap": "运行换脸", + "Open Result Directory": "打开结果目录", + "Source": "源图", + "Target": "目标", + "Result": "结果", + "Result preview appears here. Video results are saved to the exports folder.": "结果预览会显示在这里。视频结果会保存到导出目录。", + "Select": "选择", + "Remove": "移除", + "Click to upload or drag a folder here.": "点击上传,或将文件夹拖到这里。", + "Click to upload or drag files here.": "点击上传,或将文件拖到这里。", + "Click to upload or drag a file here.": "点击上传,或将文件拖到这里。", + "File": "文件", + "Open Workspace Folder": "打开工作目录", + "Exit": "退出", + "Mode": "模式", + "Tools": "工具", + "Help": "帮助", + "About": "关于", + "Responsible Use Notice": "负责任使用提示", + "Ready": "就绪", + "Model": "模型", + "Provider": "运行后端", + "DB": "数据库", + "Coming soon": "即将推出", + }, + "ja": { + "System default": "システム既定", + "Settings": "設定", + "Application Settings": "アプリケーション設定", + "Only appearance settings are configurable here. Workspace paths are fixed after first launch.": "ここでは表示設定のみ変更できます。ワークスペースのパスは初回起動後に固定されます。", + "UI theme": "UI テーマ", + "Language": "言語", + "Save": "保存", + "Apply": "適用", + "Cancel": "キャンセル", + "Models": "モデル", + "License": "ライセンス", + "Research / Non-commercial": "研究 / 非商用", + "License Center": "ライセンスセンター", + "Workflows": "ワークフロー", + "Choose the workspace for the task.": "作業内容に応じたワークスペースを選択します。", + "Enterprise Help": "エンタープライズサポート", + "All processing is local. No images, embeddings, or reports are uploaded automatically.": "すべての処理はローカルで実行されます。画像、特徴量、レポートは自動的にアップロードされません。", + "Face Recognition": "顔認識", + "Album Management": "アルバム管理", + "Face Swap": "顔交換", + "Enterprise Evaluation": "エンタープライズ評価", + "Query and gallery recognition": "クエリとギャラリー認識", + "Photo clustering and review": "写真クラスタリングと確認", + "Source + Target = Result": "ソース + ターゲット = 結果", + "Datasets, metrics, and reports": "データセット、指標、レポート", + "Upload a query face and recognize it against one gallery image or a local gallery.": "クエリ顔画像をアップロードし、1枚のギャラリー画像またはローカルギャラリーと照合します。", + "Organize local photos by people, clusters, and searchable face groups.": "人物、クラスタ、検索可能な顔グループでローカル写真を整理します。", + "Use a configured downloaded swap model for local image or video face swap.": "設定済みのダウンロード済み顔交換モデルで、画像または動画をローカル処理します。", + "Run local 1:1 and 1:N model evaluations and export reports.": "ローカルの 1:1 / 1:N モデル評価を実行し、レポートを出力します。", + "Visit Homepage": "ホームページを開く", + "Contact Enterprise Support": "企業向けサポートに連絡", + "Usage": "用途", + "Status": "状態", + "Personal research": "個人研究", + "Internal evaluation": "社内評価", + "Commercial production": "商用本番利用", + "Redistribution": "再配布", + "SaaS / API usage": "SaaS / API 利用", + "Face swap commercial usage": "顔交換の商用利用", + "yes": "可", + "depends on model license": "モデルライセンスによります", + "requires commercial model license": "商用モデルライセンスが必要", + "requires explicit permission": "明示的な許可が必要", + "requires commercial agreement": "商用契約が必要", + "A concise local-use and commercial-deployment summary.": "ローカル利用と商用展開に関する簡潔な要約です。", + "InsightFace Evaluation Studio runs locally and does not upload images, embeddings, videos, or reports automatically.": "InsightFace Evaluation Studio はローカルで動作し、画像、特徴量、動画、レポートを自動アップロードしません。", + "Code and model files may have different licenses, and commercial deployment requires appropriate model authorization.": "コードとモデルファイルには異なるライセンスが適用される場合があり、商用展開には適切なモデル認可が必要です。", + "Current package": "現在のパッケージ", + "Evaluation Setup": "評価設定", + "Evaluation mode": "評価モード", + "Data split": "データ分割", + "Multi-face handling": "複数顔の処理", + "Dataset": "データセット", + "Run": "実行", + "Dataset Rules": "データセット規則", + "Validate Dataset": "データセットを検証", + "Run Evaluation": "評価を実行", + "Export PDF": "PDF を出力", + "Open Report Folder": "レポートフォルダを開く", + "Validate the selected dataset and configuration before running evaluation.": "評価を実行する前に、選択したデータセットと設定を検証してください。", + "Validate the dataset before running an evaluation.": "評価を実行する前にデータセットを検証してください。", + "Dataset validation is required before running an evaluation.": "評価を実行する前にデータセット検証が必要です。", + "Evaluation Dataset Rules": "評価データセット規則", + "Prepare local identity folders using one of the supported layouts below.": "以下のいずれかの対応レイアウトでローカルの ID フォルダを準備してください。", + "Recognition threshold": "認識しきい値", + "Run Recognition": "認識を実行", + "Clear": "クリア", + "Query": "クエリ", + "Gallery": "ギャラリー", + "Album": "アルバム", + "Album directories": "アルバムディレクトリ", + "Drag album folders into the directory list, or click Add Folder.": "アルバムフォルダをリストにドラッグするか、「フォルダを追加」をクリックします。", + "Import / Refresh": "インポート / 更新", + "Rebuild All": "すべて再構築", + "Add Folder": "フォルダを追加", + "Remove Selected": "選択項目を削除", + "Cosine threshold": "コサインしきい値", + "Min samples": "最小サンプル数", + "Minimum face size": "最小顔サイズ", + "Algorithm: DBSCAN": "アルゴリズム: DBSCAN", + "Thumbnail": "サムネイル", + "Photos": "写真", + "File": "ファイル", + "Faces in cluster": "クラスタ内の顔数", + "Run Face Swap": "顔交換を実行", + "Open Result Directory": "結果ディレクトリを開く", + "Source": "ソース", + "Target": "ターゲット", + "Result": "結果", + "Result preview appears here. Video results are saved to the exports folder.": "結果プレビューがここに表示されます。動画結果はエクスポートフォルダに保存されます。", + "Select": "選択", + "Remove": "削除", + "Click to upload or drag a folder here.": "クリックしてアップロード、またはフォルダをここにドラッグします。", + "Click to upload or drag files here.": "クリックしてアップロード、またはファイルをここにドラッグします。", + "Click to upload or drag a file here.": "クリックしてアップロード、またはファイルをここにドラッグします。", + "Open Workspace Folder": "ワークスペースフォルダを開く", + "Exit": "終了", + "Mode": "モード", + "Tools": "ツール", + "Help": "ヘルプ", + "About": "このアプリについて", + "Responsible Use Notice": "責任ある利用に関する注意", + "Ready": "準備完了", + "Model": "モデル", + "Provider": "プロバイダー", + "DB": "DB", + "Coming soon": "近日公開", + }, + "ko": { + "System default": "시스템 기본값", + "Settings": "설정", + "Application Settings": "애플리케이션 설정", + "Only appearance settings are configurable here. Workspace paths are fixed after first launch.": "여기서는 화면 표시 설정만 변경할 수 있습니다. 워크스페이스 경로는 최초 실행 후 고정됩니다.", + "UI theme": "UI 테마", + "Language": "언어", + "Save": "저장", + "Apply": "적용", + "Cancel": "취소", + "Models": "모델", + "License": "라이선스", + "Research / Non-commercial": "연구 / 비상업", + "License Center": "라이선스 센터", + "Workflows": "워크플로", + "Choose the workspace for the task.": "작업에 맞는 워크스페이스를 선택합니다.", + "Enterprise Help": "기업 지원", + "All processing is local. No images, embeddings, or reports are uploaded automatically.": "모든 처리는 로컬에서 수행됩니다. 이미지, 임베딩, 보고서는 자동으로 업로드되지 않습니다.", + "Face Recognition": "얼굴 인식", + "Album Management": "앨범 관리", + "Face Swap": "얼굴 교체", + "Enterprise Evaluation": "기업 평가", + "Query and gallery recognition": "쿼리 및 갤러리 인식", + "Photo clustering and review": "사진 클러스터링 및 검토", + "Source + Target = Result": "소스 + 타깃 = 결과", + "Datasets, metrics, and reports": "데이터셋, 지표, 보고서", + "Upload a query face and recognize it against one gallery image or a local gallery.": "쿼리 얼굴을 업로드하고 단일 갤러리 이미지 또는 로컬 갤러리와 비교합니다.", + "Organize local photos by people, clusters, and searchable face groups.": "로컬 사진을 인물, 클러스터, 검색 가능한 얼굴 그룹으로 정리합니다.", + "Use a configured downloaded swap model for local image or video face swap.": "설정된 다운로드 얼굴 교체 모델로 이미지 또는 비디오를 로컬 처리합니다.", + "Run local 1:1 and 1:N model evaluations and export reports.": "로컬 1:1 및 1:N 모델 평가를 실행하고 보고서를 내보냅니다.", + "Visit Homepage": "홈페이지 방문", + "Contact Enterprise Support": "기업 지원 문의", + "Usage": "용도", + "Status": "상태", + "Personal research": "개인 연구", + "Internal evaluation": "내부 평가", + "Commercial production": "상용 운영", + "Redistribution": "재배포", + "SaaS / API usage": "SaaS / API 사용", + "Face swap commercial usage": "얼굴 교체 상용 사용", + "yes": "가능", + "depends on model license": "모델 라이선스에 따라 다름", + "requires commercial model license": "상용 모델 라이선스 필요", + "requires explicit permission": "명시적 허가 필요", + "requires commercial agreement": "상용 계약 필요", + "A concise local-use and commercial-deployment summary.": "로컬 사용 및 상용 배포에 대한 간단한 요약입니다.", + "InsightFace Evaluation Studio runs locally and does not upload images, embeddings, videos, or reports automatically.": "InsightFace Evaluation Studio는 로컬에서 실행되며 이미지, 임베딩, 비디오, 보고서를 자동 업로드하지 않습니다.", + "Code and model files may have different licenses, and commercial deployment requires appropriate model authorization.": "코드와 모델 파일에는 서로 다른 라이선스가 적용될 수 있으며, 상용 배포에는 적절한 모델 승인이 필요합니다.", + "Current package": "현재 패키지", + "Evaluation Setup": "평가 설정", + "Evaluation mode": "평가 모드", + "Data split": "데이터 분할", + "Multi-face handling": "다중 얼굴 처리", + "Dataset": "데이터셋", + "Run": "실행", + "Dataset Rules": "데이터셋 규칙", + "Validate Dataset": "데이터셋 검증", + "Run Evaluation": "평가 실행", + "Export PDF": "PDF 내보내기", + "Open Report Folder": "보고서 폴더 열기", + "Recognition threshold": "인식 임계값", + "Run Recognition": "인식 실행", + "Clear": "지우기", + "Query": "쿼리", + "Gallery": "갤러리", + "Album": "앨범", + "Album directories": "앨범 디렉터리", + "Import / Refresh": "가져오기 / 새로고침", + "Rebuild All": "전체 재구축", + "Add Folder": "폴더 추가", + "Remove Selected": "선택 항목 제거", + "Cosine threshold": "코사인 임계값", + "Min samples": "최소 샘플 수", + "Minimum face size": "최소 얼굴 크기", + "Thumbnail": "썸네일", + "Photos": "사진", + "File": "파일", + "Faces in cluster": "클러스터 내 얼굴 수", + "Run Face Swap": "얼굴 교체 실행", + "Open Result Directory": "결과 디렉터리 열기", + "Source": "소스", + "Target": "타깃", + "Result": "결과", + "Select": "선택", + "Remove": "제거", + "Open Workspace Folder": "워크스페이스 폴더 열기", + "Exit": "종료", + "Mode": "모드", + "Tools": "도구", + "Help": "도움말", + "About": "정보", + "Responsible Use Notice": "책임 있는 사용 안내", + "Ready": "준비됨", + "Model": "모델", + "Provider": "프로바이더", + "DB": "DB", + "Coming soon": "출시 예정", + }, + "es": { + "System default": "Predeterminado del sistema", + "Settings": "Configuración", + "Application Settings": "Configuración de la aplicación", + "Only appearance settings are configurable here. Workspace paths are fixed after first launch.": "Aquí solo se configuran opciones de apariencia. Las rutas del espacio de trabajo quedan fijadas después del primer inicio.", + "UI theme": "Tema de interfaz", + "Language": "Idioma", + "Save": "Guardar", + "Apply": "Aplicar", + "Cancel": "Cancelar", + "Models": "Modelos", + "License": "Licencia", + "Research / Non-commercial": "Investigación / no comercial", + "License Center": "Centro de licencias", + "Workflows": "Flujos de trabajo", + "Choose the workspace for the task.": "Elija el espacio de trabajo para la tarea.", + "Enterprise Help": "Soporte empresarial", + "All processing is local. No images, embeddings, or reports are uploaded automatically.": "Todo el procesamiento es local. No se suben automáticamente imágenes, embeddings ni informes.", + "Face Recognition": "Reconocimiento facial", + "Album Management": "Gestión de álbumes", + "Face Swap": "Intercambio facial", + "Enterprise Evaluation": "Evaluación empresarial", + "Query and gallery recognition": "Reconocimiento de consulta y galería", + "Photo clustering and review": "Agrupación y revisión de fotos", + "Source + Target = Result": "Origen + destino = resultado", + "Datasets, metrics, and reports": "Conjuntos de datos, métricas e informes", + "Visit Homepage": "Visitar sitio principal", + "Contact Enterprise Support": "Contactar soporte empresarial", + "Usage": "Uso", + "Status": "Estado", + "Personal research": "Investigación personal", + "Internal evaluation": "Evaluación interna", + "Commercial production": "Producción comercial", + "Redistribution": "Redistribución", + "SaaS / API usage": "Uso SaaS / API", + "Face swap commercial usage": "Uso comercial de intercambio facial", + "yes": "sí", + "depends on model license": "depende de la licencia del modelo", + "requires commercial model license": "requiere licencia comercial del modelo", + "requires explicit permission": "requiere permiso explícito", + "requires commercial agreement": "requiere acuerdo comercial", + "Current package": "Paquete actual", + "Evaluation Setup": "Configuración de evaluación", + "Evaluation mode": "Modo de evaluación", + "Data split": "División de datos", + "Multi-face handling": "Tratamiento de varias caras", + "Dataset": "Datos", + "Run": "Ejecutar", + "Dataset Rules": "Reglas del conjunto de datos", + "Validate Dataset": "Validar datos", + "Run Evaluation": "Ejecutar evaluación", + "Export PDF": "Exportar PDF", + "Open Report Folder": "Abrir carpeta de informes", + "Recognition threshold": "Umbral de reconocimiento", + "Run Recognition": "Ejecutar reconocimiento", + "Clear": "Limpiar", + "Query": "Consulta", + "Gallery": "Galería", + "Album": "Álbum", + "Album directories": "Directorios de álbum", + "Import / Refresh": "Importar / actualizar", + "Rebuild All": "Reconstruir todo", + "Add Folder": "Añadir carpeta", + "Remove Selected": "Quitar selección", + "Cosine threshold": "Umbral coseno", + "Min samples": "Muestras mínimas", + "Minimum face size": "Tamaño mínimo de cara", + "Thumbnail": "Miniatura", + "Photos": "Fotos", + "File": "Archivo", + "Faces in cluster": "Caras en el grupo", + "Run Face Swap": "Ejecutar intercambio facial", + "Open Result Directory": "Abrir directorio de resultados", + "Source": "Origen", + "Target": "Destino", + "Result": "Resultado", + "Select": "Seleccionar", + "Remove": "Quitar", + "Open Workspace Folder": "Abrir carpeta de trabajo", + "Exit": "Salir", + "Mode": "Modo", + "Tools": "Herramientas", + "Help": "Ayuda", + "About": "Acerca de", + "Responsible Use Notice": "Aviso de uso responsable", + "Ready": "Listo", + "Model": "Modelo", + "Provider": "Proveedor", + "DB": "BD", + "Coming soon": "Próximamente", + }, + "fr": { + "System default": "Valeur système", + "Settings": "Paramètres", + "Application Settings": "Paramètres de l’application", + "Only appearance settings are configurable here. Workspace paths are fixed after first launch.": "Seuls les paramètres d’apparence sont configurables ici. Les chemins de l’espace de travail sont figés après le premier lancement.", + "UI theme": "Thème d’interface", + "Language": "Langue", + "Save": "Enregistrer", + "Apply": "Appliquer", + "Cancel": "Annuler", + "Models": "Modèles", + "License": "Licence", + "Research / Non-commercial": "Recherche / non commercial", + "License Center": "Centre de licences", + "Workflows": "Flux de travail", + "Choose the workspace for the task.": "Choisissez l’espace de travail adapté à la tâche.", + "Enterprise Help": "Support entreprise", + "All processing is local. No images, embeddings, or reports are uploaded automatically.": "Tous les traitements sont locaux. Aucune image, embedding ni rapport n’est téléversé automatiquement.", + "Face Recognition": "Reconnaissance faciale", + "Album Management": "Gestion d’albums", + "Face Swap": "Échange de visages", + "Enterprise Evaluation": "Évaluation entreprise", + "Query and gallery recognition": "Reconnaissance requête et galerie", + "Photo clustering and review": "Clustering et revue des photos", + "Source + Target = Result": "Source + cible = résultat", + "Datasets, metrics, and reports": "Jeux de données, métriques et rapports", + "Visit Homepage": "Visiter le site", + "Contact Enterprise Support": "Contacter le support entreprise", + "Usage": "Usage", + "Status": "Statut", + "Personal research": "Recherche personnelle", + "Internal evaluation": "Évaluation interne", + "Commercial production": "Production commerciale", + "Redistribution": "Redistribution", + "SaaS / API usage": "Usage SaaS / API", + "Face swap commercial usage": "Usage commercial du face swap", + "yes": "oui", + "depends on model license": "dépend de la licence du modèle", + "requires commercial model license": "requiert une licence commerciale du modèle", + "requires explicit permission": "requiert une autorisation explicite", + "requires commercial agreement": "requiert un accord commercial", + "Current package": "Package actuel", + "Evaluation Setup": "Configuration de l’évaluation", + "Evaluation mode": "Mode d’évaluation", + "Data split": "Répartition des données", + "Multi-face handling": "Gestion des visages multiples", + "Dataset": "Jeu de données", + "Run": "Exécuter", + "Dataset Rules": "Règles du jeu de données", + "Validate Dataset": "Valider le jeu de données", + "Run Evaluation": "Lancer l’évaluation", + "Export PDF": "Exporter en PDF", + "Open Report Folder": "Ouvrir le dossier des rapports", + "Recognition threshold": "Seuil de reconnaissance", + "Run Recognition": "Lancer la reconnaissance", + "Clear": "Effacer", + "Query": "Requête", + "Gallery": "Galerie", + "Album": "Album", + "Album directories": "Dossiers d’album", + "Import / Refresh": "Importer / actualiser", + "Rebuild All": "Tout reconstruire", + "Add Folder": "Ajouter un dossier", + "Remove Selected": "Retirer la sélection", + "Cosine threshold": "Seuil cosinus", + "Min samples": "Échantillons min.", + "Minimum face size": "Taille minimale du visage", + "Thumbnail": "Vignette", + "Photos": "Photos", + "File": "Fichier", + "Faces in cluster": "Visages dans le cluster", + "Run Face Swap": "Lancer le face swap", + "Open Result Directory": "Ouvrir le dossier des résultats", + "Source": "Source", + "Target": "Cible", + "Result": "Résultat", + "Select": "Sélectionner", + "Remove": "Retirer", + "Open Workspace Folder": "Ouvrir l’espace de travail", + "Exit": "Quitter", + "Mode": "Mode", + "Tools": "Outils", + "Help": "Aide", + "About": "À propos", + "Responsible Use Notice": "Avis d’utilisation responsable", + "Ready": "Prêt", + "Model": "Modèle", + "Provider": "Fournisseur", + "DB": "BD", + "Coming soon": "Bientôt disponible", + }, + "de": { + "System default": "Systemstandard", + "Settings": "Einstellungen", + "Application Settings": "Anwendungseinstellungen", + "Only appearance settings are configurable here. Workspace paths are fixed after first launch.": "Hier können nur Darstellungseinstellungen geändert werden. Workspace-Pfade sind nach dem ersten Start festgelegt.", + "UI theme": "UI-Design", + "Language": "Sprache", + "Save": "Speichern", + "Apply": "Anwenden", + "Cancel": "Abbrechen", + "Models": "Modelle", + "License": "Lizenz", + "Research / Non-commercial": "Forschung / nicht kommerziell", + "License Center": "Lizenzzentrum", + "Workflows": "Workflows", + "Choose the workspace for the task.": "Wählen Sie den Arbeitsbereich für die Aufgabe.", + "Enterprise Help": "Enterprise-Support", + "All processing is local. No images, embeddings, or reports are uploaded automatically.": "Alle Verarbeitung erfolgt lokal. Bilder, Embeddings und Berichte werden nicht automatisch hochgeladen.", + "Face Recognition": "Gesichtserkennung", + "Album Management": "Albumverwaltung", + "Face Swap": "Face Swap", + "Enterprise Evaluation": "Enterprise-Evaluierung", + "Query and gallery recognition": "Query- und Galerieerkennung", + "Photo clustering and review": "Fotoclustering und Prüfung", + "Source + Target = Result": "Quelle + Ziel = Ergebnis", + "Datasets, metrics, and reports": "Datensätze, Metriken und Berichte", + "Visit Homepage": "Homepage besuchen", + "Contact Enterprise Support": "Enterprise-Support kontaktieren", + "Usage": "Nutzung", + "Status": "Status", + "Personal research": "Persönliche Forschung", + "Internal evaluation": "Interne Evaluierung", + "Commercial production": "Kommerzieller Produktivbetrieb", + "Redistribution": "Weiterverteilung", + "SaaS / API usage": "SaaS- / API-Nutzung", + "Face swap commercial usage": "Kommerzielle Face-Swap-Nutzung", + "yes": "ja", + "depends on model license": "abhängig von der Modelllizenz", + "requires commercial model license": "erfordert eine kommerzielle Modelllizenz", + "requires explicit permission": "erfordert ausdrückliche Genehmigung", + "requires commercial agreement": "erfordert eine kommerzielle Vereinbarung", + "Current package": "Aktuelles Paket", + "Evaluation Setup": "Evaluierung einrichten", + "Evaluation mode": "Evaluierungsmodus", + "Data split": "Datenaufteilung", + "Multi-face handling": "Umgang mit mehreren Gesichtern", + "Dataset": "Datensatz", + "Run": "Ausführen", + "Dataset Rules": "Datensatzregeln", + "Validate Dataset": "Datensatz validieren", + "Run Evaluation": "Evaluierung starten", + "Export PDF": "PDF exportieren", + "Open Report Folder": "Berichtsordner öffnen", + "Recognition threshold": "Erkennungsschwelle", + "Run Recognition": "Erkennung starten", + "Clear": "Leeren", + "Query": "Abfrage", + "Gallery": "Galerie", + "Album": "Album", + "Album directories": "Albumordner", + "Import / Refresh": "Importieren / aktualisieren", + "Rebuild All": "Alles neu erstellen", + "Add Folder": "Ordner hinzufügen", + "Remove Selected": "Auswahl entfernen", + "Cosine threshold": "Kosinus-Schwelle", + "Min samples": "Min. Stichproben", + "Minimum face size": "Minimale Gesichtsgröße", + "Thumbnail": "Miniatur", + "Photos": "Fotos", + "File": "Datei", + "Faces in cluster": "Gesichter im Cluster", + "Run Face Swap": "Face Swap ausführen", + "Open Result Directory": "Ergebnisordner öffnen", + "Source": "Quelle", + "Target": "Ziel", + "Result": "Ergebnis", + "Select": "Auswählen", + "Remove": "Entfernen", + "Open Workspace Folder": "Workspace-Ordner öffnen", + "Exit": "Beenden", + "Mode": "Modus", + "Tools": "Werkzeuge", + "Help": "Hilfe", + "About": "Info", + "Responsible Use Notice": "Hinweis zur verantwortungsvollen Nutzung", + "Ready": "Bereit", + "Model": "Modell", + "Provider": "Provider", + "DB": "DB", + "Coming soon": "Demnächst", + }, + "pt": { + "System default": "Padrão do sistema", + "Settings": "Definições", + "Application Settings": "Definições da aplicação", + "Only appearance settings are configurable here. Workspace paths are fixed after first launch.": "Aqui só pode configurar a aparência. Os caminhos do workspace ficam fixos após o primeiro arranque.", + "UI theme": "Tema da interface", + "Language": "Idioma", + "Save": "Guardar", + "Apply": "Aplicar", + "Cancel": "Cancelar", + "Models": "Modelos", + "License": "Licença", + "Research / Non-commercial": "Investigação / não comercial", + "License Center": "Centro de licenças", + "Workflows": "Fluxos de trabalho", + "Choose the workspace for the task.": "Escolha o workspace para a tarefa.", + "Enterprise Help": "Suporte empresarial", + "All processing is local. No images, embeddings, or reports are uploaded automatically.": "Todo o processamento é local. Imagens, embeddings e relatórios não são carregados automaticamente.", + "Face Recognition": "Reconhecimento facial", + "Album Management": "Gestão de álbuns", + "Face Swap": "Troca de rostos", + "Enterprise Evaluation": "Avaliação empresarial", + "Query and gallery recognition": "Reconhecimento de consulta e galeria", + "Photo clustering and review": "Agrupamento e revisão de fotos", + "Source + Target = Result": "Origem + destino = resultado", + "Datasets, metrics, and reports": "Conjuntos de dados, métricas e relatórios", + "Visit Homepage": "Visitar página inicial", + "Contact Enterprise Support": "Contactar suporte empresarial", + "Usage": "Utilização", + "Status": "Estado", + "Personal research": "Investigação pessoal", + "Internal evaluation": "Avaliação interna", + "Commercial production": "Produção comercial", + "Redistribution": "Redistribuição", + "SaaS / API usage": "Utilização SaaS / API", + "Face swap commercial usage": "Uso comercial de troca de rostos", + "yes": "sim", + "depends on model license": "depende da licença do modelo", + "requires commercial model license": "requer licença comercial do modelo", + "requires explicit permission": "requer autorização explícita", + "requires commercial agreement": "requer acordo comercial", + "Current package": "Pacote atual", + "Evaluation Setup": "Configuração da avaliação", + "Evaluation mode": "Modo de avaliação", + "Data split": "Divisão de dados", + "Multi-face handling": "Tratamento de múltiplos rostos", + "Dataset": "Dados", + "Run": "Executar", + "Dataset Rules": "Regras do conjunto de dados", + "Validate Dataset": "Validar dados", + "Run Evaluation": "Executar avaliação", + "Export PDF": "Exportar PDF", + "Open Report Folder": "Abrir pasta de relatórios", + "Recognition threshold": "Limiar de reconhecimento", + "Run Recognition": "Executar reconhecimento", + "Clear": "Limpar", + "Query": "Consulta", + "Gallery": "Galeria", + "Album": "Álbum", + "Album directories": "Diretórios de álbum", + "Import / Refresh": "Importar / atualizar", + "Rebuild All": "Reconstruir tudo", + "Add Folder": "Adicionar pasta", + "Remove Selected": "Remover seleção", + "Cosine threshold": "Limiar de cosseno", + "Min samples": "Amostras mínimas", + "Minimum face size": "Tamanho mínimo do rosto", + "Thumbnail": "Miniatura", + "Photos": "Fotos", + "File": "Ficheiro", + "Faces in cluster": "Rostos no cluster", + "Run Face Swap": "Executar troca de rostos", + "Open Result Directory": "Abrir diretório de resultados", + "Source": "Origem", + "Target": "Destino", + "Result": "Resultado", + "Select": "Selecionar", + "Remove": "Remover", + "Open Workspace Folder": "Abrir pasta do workspace", + "Exit": "Sair", + "Mode": "Modo", + "Tools": "Ferramentas", + "Help": "Ajuda", + "About": "Sobre", + "Responsible Use Notice": "Aviso de utilização responsável", + "Ready": "Pronto", + "Model": "Modelo", + "Provider": "Fornecedor", + "DB": "BD", + "Coming soon": "Em breve", + }, + "ru": { + "System default": "Как в системе", + "Settings": "Настройки", + "Application Settings": "Настройки приложения", + "Only appearance settings are configurable here. Workspace paths are fixed after first launch.": "Здесь настраивается только внешний вид. Пути рабочей области фиксируются после первого запуска.", + "UI theme": "Тема интерфейса", + "Language": "Язык", + "Save": "Сохранить", + "Apply": "Применить", + "Cancel": "Отмена", + "Models": "Модели", + "License": "Лицензия", + "Research / Non-commercial": "Исследование / некоммерческое использование", + "License Center": "Центр лицензий", + "Workflows": "Рабочие процессы", + "Choose the workspace for the task.": "Выберите рабочую область для задачи.", + "Enterprise Help": "Поддержка для бизнеса", + "All processing is local. No images, embeddings, or reports are uploaded automatically.": "Вся обработка выполняется локально. Изображения, эмбеддинги и отчёты не загружаются автоматически.", + "Face Recognition": "Распознавание лиц", + "Album Management": "Управление альбомами", + "Face Swap": "Замена лиц", + "Enterprise Evaluation": "Корпоративная оценка", + "Query and gallery recognition": "Распознавание запроса и галереи", + "Photo clustering and review": "Кластеризация и проверка фото", + "Source + Target = Result": "Источник + цель = результат", + "Datasets, metrics, and reports": "Датасеты, метрики и отчёты", + "Visit Homepage": "Открыть сайт", + "Contact Enterprise Support": "Связаться с поддержкой", + "Usage": "Использование", + "Status": "Статус", + "Personal research": "Личное исследование", + "Internal evaluation": "Внутренняя оценка", + "Commercial production": "Коммерческий продакшен", + "Redistribution": "Повторное распространение", + "SaaS / API usage": "Использование SaaS / API", + "Face swap commercial usage": "Коммерческое использование замены лиц", + "yes": "да", + "depends on model license": "зависит от лицензии модели", + "requires commercial model license": "требуется коммерческая лицензия модели", + "requires explicit permission": "требуется явное разрешение", + "requires commercial agreement": "требуется коммерческое соглашение", + "Current package": "Текущий пакет", + "Evaluation Setup": "Настройка оценки", + "Evaluation mode": "Режим оценки", + "Data split": "Разделение данных", + "Multi-face handling": "Обработка нескольких лиц", + "Dataset": "Датасет", + "Run": "Запуск", + "Dataset Rules": "Правила датасета", + "Validate Dataset": "Проверить датасет", + "Run Evaluation": "Запустить оценку", + "Export PDF": "Экспорт PDF", + "Open Report Folder": "Открыть папку отчётов", + "Recognition threshold": "Порог распознавания", + "Run Recognition": "Запустить распознавание", + "Clear": "Очистить", + "Query": "Запрос", + "Gallery": "Галерея", + "Album": "Альбом", + "Album directories": "Папки альбомов", + "Import / Refresh": "Импорт / обновление", + "Rebuild All": "Перестроить всё", + "Add Folder": "Добавить папку", + "Remove Selected": "Удалить выбранное", + "Cosine threshold": "Косинусный порог", + "Min samples": "Мин. образцов", + "Minimum face size": "Мин. размер лица", + "Thumbnail": "Миниатюра", + "Photos": "Фото", + "File": "Файл", + "Faces in cluster": "Лиц в кластере", + "Run Face Swap": "Запустить замену лиц", + "Open Result Directory": "Открыть папку результатов", + "Source": "Источник", + "Target": "Цель", + "Result": "Результат", + "Select": "Выбрать", + "Remove": "Удалить", + "Open Workspace Folder": "Открыть рабочую папку", + "Exit": "Выход", + "Mode": "Режим", + "Tools": "Инструменты", + "Help": "Справка", + "About": "О программе", + "Responsible Use Notice": "Уведомление об ответственном использовании", + "Ready": "Готово", + "Model": "Модель", + "Provider": "Провайдер", + "DB": "БД", + "Coming soon": "Скоро", + }, +} + + +_EXTRA_TRANSLATIONS: dict[str, dict[str, str]] = { + "zh": { + "About": "关于", + "Add Person": "添加人员", + "Add as New Person": "添加为新人员", + "Anonymize report paths": "匿名化报告路径", + "Assign to Existing Person": "分配给已有人员", + "Auto": "自动", + "Browse": "浏览", + "Camera index": "摄像头索引", + "Check Cameras": "检查摄像头", + "Click to import an image or folder, or drag one here. Folders are imported recursively.": "点击导入图片或文件夹,或拖拽到这里。文件夹会递归导入。", + "Click to upload images or a folder, or drag them here": "点击上传图片或文件夹,或拖拽到这里", + "Clustering is approximate. Please review and correct groups manually.": "聚类结果是近似的,请人工复核并修正分组。", + "Compare": "比对", + "Custom model directory": "自定义模型目录", + "DBSCAN distance threshold": "DBSCAN 距离阈值", + "Delete": "删除", + "Delete Selected": "删除所选", + "Download Selected": "下载所选", + "Download GFPGANv1.4.onnx from Models > Downloads first.": "请先在 Models > Downloads 中下载 GFPGANv1.4.onnx。", + "Download inswapper_128.onnx from Models > Downloads first.": "请先在 Models > Downloads 中下载 inswapper_128.onnx。", + "Downloads are manual only. The GUI does not auto-download models. Model files may have different licenses from code; review usage before deployment.": "模型下载仅由用户手动触发,GUI 不会自动下载模型。模型文件和代码可能适用不同授权,部署前请核查使用范围。", + "Drag one or more album folders here, or use Add Folder.": "将一个或多个相册文件夹拖到这里,或使用“添加文件夹”。", + "Export": "导出", + "Export All Summary": "导出全部摘要", + "Export Annotated Image": "导出标注图片", + "Export CSV": "导出 CSV", + "Export CSV / JSON": "导出 CSV / JSON", + "Export Result": "导出结果", + "Export Results": "导出结果", + "Export Settings": "导出设置", + "Export Summary": "导出摘要", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "根据使用场景和模型授权,换脸功能可能需要单独的商业授权。请仅在拥有适当权利和同意的情况下使用。", + "Faces whose bounding box width or height is smaller than this value are skipped.": "边界框宽度或高度小于该值的人脸会被跳过。", + "Frame interval": "帧间隔", + "Frame skip": "跳帧", + "ID": "ID", + "Identify people": "识别人员", + "Import Image or Folder": "导入图片或文件夹", + "Import Settings": "导入设置", + "Minimum neighboring faces needed for a DBSCAN core point.": "DBSCAN 核心点所需的最少邻近人脸数。", + "Name": "名称", + "No downloaded GFPGAN models": "没有已下载的 GFPGAN 模型", + "No downloaded swap models": "没有已下载的换脸模型", + "No images": "没有图片", + "Only downloaded GFPGAN restore models are shown.": "仅显示已下载的 GFPGAN 修复模型。", + "Only downloaded swap models are shown.": "仅显示已下载的换脸模型。", + "Open": "打开", + "Open GitHub Releases": "打开 GitHub Releases", + "Open License Center": "打开授权中心", + "Open Model Folder": "打开模型目录", + "Open Reports": "打开报告", + "Open Selected Report": "打开所选报告", + "People": "人员", + "Privacy": "隐私", + "Production or commercial deployment requires an appropriate commercial model license. This page summarizes common commercial paths; it does not provide legal advice.": "生产或商业部署需要适当的商业模型授权。本页总结常见商业路径,但不构成法律建议。", + "Re-export Selected": "重新导出所选", + "Recognize Faces": "识别人脸", + "Recursive": "递归", + "Refresh": "刷新", + "Refresh Download URLs": "刷新下载地址", + "Refresh People": "刷新人员", + "Register Current Face": "注册当前人脸", + "Reset": "重置", + "Reset Settings": "重置设置", + "Save Details": "保存详情", + "Save crops": "保存裁剪图", + "Save face crops": "保存人脸裁剪图", + "Save recognition logs": "保存识别日志", + "Scan and Cluster": "扫描并聚类", + "Search": "搜索", + "Select Folder": "选择文件夹", + "Select Image": "选择图片", + "Select gallery images or folders": "选择 Gallery 图片或文件夹", + "Select one or more image files or folders. Folders are scanned recursively.": "选择一个或多个图片文件或文件夹。文件夹会递归扫描。", + "Start": "开始", + "Stop": "停止", + "Target person": "目标人员", + "Test Model Load": "测试模型加载", + "Threshold": "阈值", + "Use Selected Model": "使用所选模型", + "Warmup": "预热", + "quality_score": "质量分数", + "rank": "排名", + "thumbnail": "缩略图", + "gallery_file": "Gallery 文件", + "similarity": "相似度", + "threshold": "阈值", + "decision": "判定", + "det_score": "检测分数", + "person_id": "人员 ID", + "person_name": "人员名称", + "status": "状态", + "sample_id": "样本 ID", + "crop_path": "裁剪路径", + "image_path": "图片路径", + "face_index": "人脸序号", + "bbox": "检测框", + "video_path": "视频路径", + "timestamp_ms": "时间戳 ms", + "timestamp_hhmmss": "时间", + "frame_index": "帧序号", + "id": "ID", + "date": "日期", + "scenario": "场景", + "model": "模型", + "provider": "运行后端", + "report_path": "报告路径", + "asset": "资源", + "source": "来源", + "kind": "类型", + "release": "版本", + "size": "大小", + "updated_at": "更新时间", + "local status": "本地状态", + "download url": "下载地址", + "Close": "关闭", + "First Launch Wizard": "首次启动向导", + "Workspace": "工作目录", + "Model package": "模型包", + "Provider": "运行后端", + "License notice": "授权提示", + "Personal / Research": "个人 / 研究", + "Enterprise Evaluation": "企业评测", + "custom model directory": "自定义模型目录", + "Runtime": "运行时", + "Downloads": "下载", + "Model Settings": "模型设置", + "Model Downloads": "模型下载", + "Runtime information": "运行时信息", + "Detection size": "检测尺寸", + "Face swap model": "换脸模型", + "GFPGAN post-processing": "GFPGAN 后处理", + "GFPGAN model": "GFPGAN 模型", + "GFPGAN is unavailable until a GFPGAN model is downloaded.": "下载 GFPGAN 模型后才能启用 GFPGAN。", + "Run GFPGAN face restoration after face swap.": "换脸后运行 GFPGAN 人脸修复。", + "Enable GFPGAN restore after face swap": "换脸后启用 GFPGAN 修复", + "Save Settings": "保存设置", + "Open Model Downloads": "打开模型下载", + "Test Model Load": "测试模型加载", + "Warmup": "预热", + "1:1 Verification": "1:1 验证", + "1:N Identification": "1:N 识别", + "Auto Split": "自动切分", + "Require exactly one face": "要求恰好一张脸", + "Use largest face": "使用最大人脸", + "Use largest centered face": "使用最大且居中的人脸", + "Mark as skip": "标记为跳过", + "Identity Folders / Dataset Root": "身份文件夹 / 数据集根目录", + "Open Dataset Rules for detailed folder examples.": "打开“数据集规则”查看详细目录示例。", + "1:1 verification expects one identity per subfolder. Auto Split selects one gallery image per identity and compares every probe against every identity gallery.": "1:1 验证要求每个子目录对应一个身份。自动切分会为每个身份选择一张 gallery 图,并将每张 probe 与所有身份的 gallery 逐一比对。", + "1:1 verification expects one identity per subfolder. Auto Split is off, so every image is treated as a probe and full pairwise probe-vs-probe comparisons are generated.": "1:1 验证要求每个子目录对应一个身份。关闭自动切分后,每张图片都作为 probe,并生成完整的 probe-vs-probe 两两比对。", + "1:N Auto Split can use identities/ or identity folders directly. Each identity must provide a gallery image and at least one probe.": "1:N 自动切分可使用 identities/<身份文件夹>,也可以直接使用身份文件夹。每个身份必须能生成一张 gallery 图和至少一张 probe 图。", + "1:N structured evaluation requires gallery/ and probe/. unknown/ is optional and contributes impostor scores for FAR thresholds.": "1:N 结构化评测要求包含 gallery/<身份> 和 probe/<身份>。unknown/ 为可选目录,会为 FAR 阈值提供冒名负样本分数。", + "Dataset validation passed. Evaluation is ready to run.": "数据集核验通过,可以运行评测。", + "Dataset validation failed. Fix the listed issues before running evaluation.": "数据集核验失败。请先修复列出的问题再运行评测。", + "Evaluation Dataset Rules": "评测数据集规则", + "Prepare local identity folders using one of the supported layouts below.": "请按以下任一支持结构准备本地身份文件夹。", + "Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.": "打开 1:1、1:N 和自动切分的身份文件夹详细规则。", + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image.": "自动从文件名包含 gallery 的图片中选择每个身份的 gallery 图;如果不存在,则选择排序后的第一张图片。", + "Choose how evaluation handles images where more than one face is detected.": "选择评测中检测到多张人脸时的处理方式。", + "Similarity threshold for matching query and gallery faces.": "用于匹配查询人脸和底库人脸的相似度阈值。", + "Choose how query and gallery images handle multiple detected faces.": "选择查询图和底库图中检测到多张人脸时的处理方式。", + "Gallery face embeddings are cached in memory after the first run and reused while the gallery image list and multi-face policy are unchanged. Changing only the query image reuses the cached gallery; adding, removing, clearing gallery images, or changing multi-face handling clears and recomputes it.": "Gallery 人脸特征在首次运行后会常驻内存;只要底库图片列表和多人脸策略不变就会复用。仅更换 Query 会复用缓存;添加、移除、清空 Gallery 图片或修改多人脸处理策略会清空并重新计算。", + "Multi-face policy: require exactly one face. Images with multiple detected faces fail with a clear error.": "多人脸策略:要求恰好一张脸。检测到多张脸的图片会明确报错。", + "Multi-face policy: use largest face. If an image has multiple faces, the largest detected face is used.": "多人脸策略:使用最大人脸。如果图片中有多张脸,将使用检测框最大的那张脸。", + "Multi-face policy: use largest centered face. If an image has multiple faces, the face with the best area-minus-center-distance score is used.": "多人脸策略:使用最大且居中的人脸。如果图片中有多张脸,将使用面积与中心位置综合评分最高的人脸。", + "Multi-face policy: mark as skip. Gallery images with multiple detected faces are skipped; a multi-face query stops the current run.": "多人脸策略:标记为跳过。Gallery 中多脸图片会跳过;Query 中多脸会停止当前运行。", + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help.": "打开 InsightFace 联系页面,获取企业评测、授权、SDK/API、SLA 或定制训练支持。", + "CUDAExecutionProvider is available.": "CUDAExecutionProvider 可用。", + "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first.": "CUDAExecutionProvider 不可用。请先安装匹配的 onnxruntime-gpu、CUDA 运行时和 GPU 驱动。", + "Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.": "Auto 会在 CUDAExecutionProvider 可用时使用 CUDA,否则使用 CPU。", + "Click to open the saved result file.": "点击打开已保存的结果文件。", + }, + "ja": { + "Close": "閉じる", + "First Launch Wizard": "初回起動ウィザード", + "Workspace": "ワークスペース", + "Model package": "モデルパッケージ", + "License notice": "ライセンス通知", + "Personal / Research": "個人 / 研究", + "Runtime": "ランタイム", + "Downloads": "ダウンロード", + "Model Settings": "モデル設定", + "Model Downloads": "モデルダウンロード", + "Runtime information": "ランタイム情報", + "Detection size": "検出サイズ", + "Face swap model": "顔交換モデル", + "GFPGAN post-processing": "GFPGAN 後処理", + "GFPGAN model": "GFPGAN モデル", + "1:1 Verification": "1:1 検証", + "1:N Identification": "1:N 識別", + "Auto Split": "自動分割", + "Require exactly one face": "顔を1つだけ要求", + "Use largest face": "最大の顔を使用", + "Use largest centered face": "中央寄りの最大顔を使用", + "Mark as skip": "スキップとして扱う", + "Identity Folders / Dataset Root": "IDフォルダ / データセットルート", + "Open Dataset Rules for detailed folder examples.": "詳細なフォルダ例は「データセット規則」を開いて確認してください。", + "Dataset validation passed. Evaluation is ready to run.": "データセット検証に合格しました。評価を実行できます。", + "Dataset validation failed. Fix the listed issues before running evaluation.": "データセット検証に失敗しました。評価前に表示された問題を修正してください。", + "Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.": "1:1、1:N、自動分割の詳細なIDフォルダ規則を開きます。", + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image.": "各IDの gallery 画像を、ファイル名に gallery を含む画像、またはソート順の最初の画像から自動選択します。", + "Choose how evaluation handles images where more than one face is detected.": "評価時に複数の顔が検出された画像の処理方法を選択します。", + "Similarity threshold for matching query and gallery faces.": "クエリ顔とギャラリー顔の照合に使う類似度しきい値です。", + "Choose how query and gallery images handle multiple detected faces.": "クエリ画像とギャラリー画像で複数顔が検出された場合の処理方法を選択します。", + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help.": "エンタープライズ評価、ライセンス、SDK/API、SLA、カスタム学習の相談ページを開きます。", + "Click to open the saved result file.": "クリックして保存済み結果ファイルを開きます。", + }, + "ko": { + "Close": "닫기", + "First Launch Wizard": "첫 실행 마법사", + "Workspace": "워크스페이스", + "Model package": "모델 패키지", + "License notice": "라이선스 안내", + "Personal / Research": "개인 / 연구", + "Runtime": "런타임", + "Downloads": "다운로드", + "Model Settings": "모델 설정", + "Model Downloads": "모델 다운로드", + "Runtime information": "런타임 정보", + "Detection size": "검출 크기", + "Face swap model": "얼굴 교체 모델", + "GFPGAN post-processing": "GFPGAN 후처리", + "GFPGAN model": "GFPGAN 모델", + "1:1 Verification": "1:1 검증", + "1:N Identification": "1:N 식별", + "Auto Split": "자동 분할", + "Require exactly one face": "정확히 한 얼굴만 허용", + "Use largest face": "가장 큰 얼굴 사용", + "Use largest centered face": "중앙에 가까운 가장 큰 얼굴 사용", + "Mark as skip": "건너뛰기로 처리", + "Identity Folders / Dataset Root": "ID 폴더 / 데이터셋 루트", + "Open Dataset Rules for detailed folder examples.": "자세한 폴더 예시는 데이터셋 규칙을 여십시오.", + "Dataset validation passed. Evaluation is ready to run.": "데이터셋 검증을 통과했습니다. 평가를 실행할 수 있습니다.", + "Dataset validation failed. Fix the listed issues before running evaluation.": "데이터셋 검증에 실패했습니다. 평가 전에 표시된 문제를 수정하십시오.", + "Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.": "1:1, 1:N, 자동 분할의 상세 ID 폴더 규칙을 엽니다.", + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image.": "각 ID의 gallery 이미지를 파일명에 gallery가 포함된 이미지 또는 정렬된 첫 이미지에서 자동 선택합니다.", + "Choose how evaluation handles images where more than one face is detected.": "평가 중 여러 얼굴이 검출된 이미지의 처리 방식을 선택합니다.", + "Similarity threshold for matching query and gallery faces.": "쿼리 얼굴과 갤러리 얼굴 매칭에 사용할 유사도 임계값입니다.", + "Choose how query and gallery images handle multiple detected faces.": "쿼리 및 갤러리 이미지에서 여러 얼굴이 검출될 때의 처리 방식을 선택합니다.", + "Click to open the saved result file.": "저장된 결과 파일을 열려면 클릭하십시오.", + }, + "es": { + "Close": "Cerrar", + "First Launch Wizard": "Asistente de primer inicio", + "Workspace": "Espacio de trabajo", + "Model package": "Paquete de modelo", + "License notice": "Aviso de licencia", + "Personal / Research": "Personal / investigación", + "Runtime": "Ejecución", + "Downloads": "Descargas", + "Model Settings": "Configuración de modelos", + "Model Downloads": "Descargas de modelos", + "Runtime information": "Información de ejecución", + "Detection size": "Tamaño de detección", + "Face swap model": "Modelo de intercambio facial", + "GFPGAN post-processing": "Posprocesamiento GFPGAN", + "GFPGAN model": "Modelo GFPGAN", + "1:1 Verification": "Verificación 1:1", + "1:N Identification": "Identificación 1:N", + "Auto Split": "División automática", + "Require exactly one face": "Exigir exactamente una cara", + "Use largest face": "Usar la cara más grande", + "Use largest centered face": "Usar la cara más grande y centrada", + "Mark as skip": "Marcar como omitida", + "Identity Folders / Dataset Root": "Carpetas de identidad / raíz del dataset", + "Open Dataset Rules for detailed folder examples.": "Abra Reglas del dataset para ver ejemplos detallados de carpetas.", + "Dataset validation passed. Evaluation is ready to run.": "La validación del dataset se completó correctamente. La evaluación está lista.", + "Dataset validation failed. Fix the listed issues before running evaluation.": "La validación del dataset falló. Corrija los problemas listados antes de ejecutar la evaluación.", + "Choose how evaluation handles images where more than one face is detected.": "Elija cómo tratar imágenes con más de una cara detectada durante la evaluación.", + "Similarity threshold for matching query and gallery faces.": "Umbral de similitud para comparar caras de consulta y galería.", + "Choose how query and gallery images handle multiple detected faces.": "Elija cómo tratar varias caras detectadas en imágenes de consulta y galería.", + "Click to open the saved result file.": "Haga clic para abrir el archivo de resultado guardado.", + }, + "fr": { + "Close": "Fermer", + "First Launch Wizard": "Assistant de premier lancement", + "Workspace": "Espace de travail", + "Model package": "Package de modèle", + "License notice": "Avis de licence", + "Personal / Research": "Personnel / recherche", + "Runtime": "Exécution", + "Downloads": "Téléchargements", + "Model Settings": "Paramètres des modèles", + "Model Downloads": "Téléchargements de modèles", + "Runtime information": "Informations d’exécution", + "Detection size": "Taille de détection", + "Face swap model": "Modèle de face swap", + "GFPGAN post-processing": "Post-traitement GFPGAN", + "GFPGAN model": "Modèle GFPGAN", + "1:1 Verification": "Vérification 1:1", + "1:N Identification": "Identification 1:N", + "Auto Split": "Découpage automatique", + "Require exactly one face": "Exiger exactement un visage", + "Use largest face": "Utiliser le plus grand visage", + "Use largest centered face": "Utiliser le plus grand visage centré", + "Mark as skip": "Marquer comme ignoré", + "Identity Folders / Dataset Root": "Dossiers d’identité / racine du jeu de données", + "Open Dataset Rules for detailed folder examples.": "Ouvrez les règles du jeu de données pour des exemples de dossiers détaillés.", + "Dataset validation passed. Evaluation is ready to run.": "La validation du jeu de données a réussi. L’évaluation peut être lancée.", + "Dataset validation failed. Fix the listed issues before running evaluation.": "La validation du jeu de données a échoué. Corrigez les problèmes listés avant l’évaluation.", + "Choose how evaluation handles images where more than one face is detected.": "Choisissez comment traiter les images contenant plusieurs visages détectés.", + "Similarity threshold for matching query and gallery faces.": "Seuil de similarité pour associer les visages requête et galerie.", + "Choose how query and gallery images handle multiple detected faces.": "Choisissez comment traiter plusieurs visages détectés dans la requête et la galerie.", + "Click to open the saved result file.": "Cliquez pour ouvrir le fichier de résultat enregistré.", + }, + "de": { + "Close": "Schließen", + "First Launch Wizard": "Assistent für den ersten Start", + "Workspace": "Arbeitsbereich", + "Model package": "Modellpaket", + "License notice": "Lizenzhinweis", + "Personal / Research": "Privat / Forschung", + "Runtime": "Laufzeit", + "Downloads": "Downloads", + "Model Settings": "Modelleinstellungen", + "Model Downloads": "Modelldownloads", + "Runtime information": "Laufzeitinformationen", + "Detection size": "Erkennungsgröße", + "Face swap model": "Face-Swap-Modell", + "GFPGAN post-processing": "GFPGAN-Nachbearbeitung", + "GFPGAN model": "GFPGAN-Modell", + "1:1 Verification": "1:1-Verifikation", + "1:N Identification": "1:N-Identifikation", + "Auto Split": "Automatische Aufteilung", + "Require exactly one face": "Genau ein Gesicht verlangen", + "Use largest face": "Größtes Gesicht verwenden", + "Use largest centered face": "Größtes zentriertes Gesicht verwenden", + "Mark as skip": "Als überspringen markieren", + "Identity Folders / Dataset Root": "Identitätsordner / Datensatzwurzel", + "Open Dataset Rules for detailed folder examples.": "Öffnen Sie die Datensatzregeln für detaillierte Ordnerbeispiele.", + "Dataset validation passed. Evaluation is ready to run.": "Die Datensatzvalidierung war erfolgreich. Die Evaluierung kann gestartet werden.", + "Dataset validation failed. Fix the listed issues before running evaluation.": "Die Datensatzvalidierung ist fehlgeschlagen. Beheben Sie die aufgeführten Probleme vor der Evaluierung.", + "Choose how evaluation handles images where more than one face is detected.": "Wählen Sie, wie Bilder mit mehr als einem erkannten Gesicht behandelt werden.", + "Similarity threshold for matching query and gallery faces.": "Ähnlichkeitsschwelle für den Abgleich von Abfrage- und Galeriegesichtern.", + "Choose how query and gallery images handle multiple detected faces.": "Wählen Sie, wie mehrere erkannte Gesichter in Abfrage- und Galeriebildern behandelt werden.", + "Click to open the saved result file.": "Klicken, um die gespeicherte Ergebnisdatei zu öffnen.", + }, + "pt": { + "Close": "Fechar", + "First Launch Wizard": "Assistente do primeiro arranque", + "Workspace": "Workspace", + "Model package": "Pacote de modelo", + "License notice": "Aviso de licença", + "Personal / Research": "Pessoal / investigação", + "Runtime": "Execução", + "Downloads": "Transferências", + "Model Settings": "Definições de modelos", + "Model Downloads": "Transferências de modelos", + "Runtime information": "Informação de execução", + "Detection size": "Tamanho de deteção", + "Face swap model": "Modelo de troca de rostos", + "GFPGAN post-processing": "Pós-processamento GFPGAN", + "GFPGAN model": "Modelo GFPGAN", + "1:1 Verification": "Verificação 1:1", + "1:N Identification": "Identificação 1:N", + "Auto Split": "Divisão automática", + "Require exactly one face": "Exigir exatamente um rosto", + "Use largest face": "Usar o maior rosto", + "Use largest centered face": "Usar o maior rosto centrado", + "Mark as skip": "Marcar como ignorado", + "Identity Folders / Dataset Root": "Pastas de identidade / raiz do dataset", + "Open Dataset Rules for detailed folder examples.": "Abra as regras do dataset para exemplos detalhados de pastas.", + "Dataset validation passed. Evaluation is ready to run.": "A validação do dataset passou. A avaliação está pronta.", + "Dataset validation failed. Fix the listed issues before running evaluation.": "A validação do dataset falhou. Corrija os problemas listados antes da avaliação.", + "Choose how evaluation handles images where more than one face is detected.": "Escolha como a avaliação trata imagens com mais de um rosto detetado.", + "Similarity threshold for matching query and gallery faces.": "Limiar de similaridade para comparar rostos de consulta e galeria.", + "Choose how query and gallery images handle multiple detected faces.": "Escolha como tratar múltiplos rostos em imagens de consulta e galeria.", + "Click to open the saved result file.": "Clique para abrir o ficheiro de resultado guardado.", + }, + "ru": { + "Close": "Закрыть", + "First Launch Wizard": "Мастер первого запуска", + "Workspace": "Рабочая область", + "Model package": "Пакет модели", + "License notice": "Уведомление о лицензии", + "Personal / Research": "Личное / исследовательское", + "Runtime": "Среда выполнения", + "Downloads": "Загрузки", + "Model Settings": "Настройки моделей", + "Model Downloads": "Загрузки моделей", + "Runtime information": "Информация о среде выполнения", + "Detection size": "Размер детекции", + "Face swap model": "Модель замены лиц", + "GFPGAN post-processing": "Постобработка GFPGAN", + "GFPGAN model": "Модель GFPGAN", + "1:1 Verification": "Верификация 1:1", + "1:N Identification": "Идентификация 1:N", + "Auto Split": "Авторазделение", + "Require exactly one face": "Требовать ровно одно лицо", + "Use largest face": "Использовать самое крупное лицо", + "Use largest centered face": "Использовать самое крупное центральное лицо", + "Mark as skip": "Помечать как пропуск", + "Identity Folders / Dataset Root": "Папки идентичностей / корень датасета", + "Open Dataset Rules for detailed folder examples.": "Откройте правила датасета для подробных примеров структуры папок.", + "Dataset validation passed. Evaluation is ready to run.": "Проверка датасета пройдена. Оценку можно запускать.", + "Dataset validation failed. Fix the listed issues before running evaluation.": "Проверка датасета не пройдена. Исправьте перечисленные проблемы перед запуском оценки.", + "Choose how evaluation handles images where more than one face is detected.": "Выберите, как оценка будет обрабатывать изображения с несколькими найденными лицами.", + "Similarity threshold for matching query and gallery faces.": "Порог сходства для сопоставления лиц запроса и галереи.", + "Choose how query and gallery images handle multiple detected faces.": "Выберите обработку нескольких лиц в изображениях запроса и галереи.", + "Click to open the saved result file.": "Нажмите, чтобы открыть сохранённый файл результата.", + }, +} + +for _lang, _values in _EXTRA_TRANSLATIONS.items(): + _TRANSLATIONS.setdefault(_lang, {}).update(_values) + + +_ADDITIONAL_UI_TRANSLATIONS: dict[str, dict[str, str]] = { + "zh": { + "Browse": "浏览", + "This application runs locally. Code and model licenses may differ. Research models may be limited to non-commercial use. Commercial deployment requires appropriate model license. This tool does not provide legal advice.": "本应用在本地运行。代码与模型文件可能适用不同授权。研究模型可能仅限非商业使用。商业部署需要相应的模型授权。本工具不提供法律建议。", + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. DBSCAN internally uses cosine distance = 1 - cosine threshold.": "余弦阈值是人脸相似度截断值:数值越高,聚类越严格。DBSCAN 内部使用的余弦距离为 1 - 余弦阈值。", + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48.": "余弦相似度阈值。数值越高,聚类越严格;默认值为 0.48。", + "CUDA is unavailable on this machine, so Auto will use CPU.": "当前机器不可用 CUDA,因此 Auto 将使用 CPU。", + "Name, notes, and tags are shown here.": "姓名、备注和标签会显示在这里。", + "cluster_id": "聚类 ID", + "face_count": "人脸数", + "photo_count": "照片数", + "average_quality": "平均质量", + "sample_paths": "样本路径", + "model_name": "模型名称", + "source_image_path": "源图片路径", + "Min det score %": "最低检测分数 %", + "InsightFace Evaluation Studio": "InsightFace Evaluation Studio", + }, + "ja": { + "Browse": "参照", + "InsightFace Evaluation Studio": "InsightFace Evaluation Studio", + "custom model directory": "カスタムモデルディレクトリ", + "Custom model directory": "カスタムモデルディレクトリ", + "Auto": "自動", + "Browse": "参照", + "Add Person": "人物を追加", + "Add as New Person": "新しい人物として追加", + "Assign to Existing Person": "既存の人物に割り当て", + "Compare": "比較", + "Search": "検索", + "Export": "エクスポート", + "Export Result": "結果をエクスポート", + "Export Results": "結果をエクスポート", + "Export Summary": "概要をエクスポート", + "Export Settings": "設定をエクスポート", + "Import Settings": "設定をインポート", + "Delete": "削除", + "Delete Selected": "選択項目を削除", + "Reset": "リセット", + "Reset Settings": "設定をリセット", + "Refresh": "更新", + "Start": "開始", + "Stop": "停止", + "Open": "開く", + "Save Settings": "設定を保存", + "Save Details": "詳細を保存", + "Save crops": "クロップを保存", + "Save face crops": "顔クロップを保存", + "Save recognition logs": "認識ログを保存", + "Anonymize report paths": "レポートパスを匿名化", + "Privacy": "プライバシー", + "Recursive": "再帰的に処理", + "Identify people": "人物を識別", + "Camera index": "カメラインデックス", + "Frame skip": "フレームスキップ", + "Frame interval": "フレーム間隔", + "Target person": "対象人物", + "Check Cameras": "カメラを確認", + "Register Current Face": "現在の顔を登録", + "Refresh People": "人物リストを更新", + "Recognize Faces": "顔を認識", + "Test Model Load": "モデル読み込みをテスト", + "Warmup": "ウォームアップ", + "Export Annotated Image": "注釈付き画像をエクスポート", + "Export CSV": "CSV をエクスポート", + "Export CSV / JSON": "CSV / JSON をエクスポート", + "Refresh Download URLs": "ダウンロード URL を更新", + "Download Selected": "選択項目をダウンロード", + "Use Selected Model": "選択したモデルを使用", + "Open Model Folder": "モデルフォルダを開く", + "Open GitHub Releases": "GitHub Releases を開く", + "Open Model Downloads": "モデルダウンロードを開く", + "Open License Center": "ライセンスセンターを開く", + "Open Reports": "レポートを開く", + "Open Selected Report": "選択したレポートを開く", + "Re-export Selected": "選択項目を再エクスポート", + "Export All Summary": "全概要をエクスポート", + "Import Image or Folder": "画像またはフォルダをインポート", + "Select Image": "画像を選択", + "Select Folder": "フォルダを選択", + "Select gallery images or folders": "ギャラリー画像またはフォルダを選択", + "Select one or more image files or folders. Folders are scanned recursively.": "1つ以上の画像ファイルまたはフォルダを選択してください。フォルダは再帰的にスキャンされます。", + "Click to import an image or folder, or drag one here. Folders are imported recursively.": "画像またはフォルダをクリックしてインポートするか、ここにドラッグしてください。フォルダは再帰的にインポートされます。", + "Click to upload images or a folder, or drag them here": "画像またはフォルダをクリックしてアップロードするか、ここにドラッグしてください", + "Drag one or more album folders here, or use Add Folder.": "1つ以上のアルバムフォルダをここにドラッグするか、「フォルダを追加」を使用してください。", + "Drag album folders into the directory list, or click Add Folder.": "アルバムフォルダをディレクトリ一覧にドラッグするか、「フォルダを追加」をクリックしてください。", + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. DBSCAN internally uses cosine distance = 1 - cosine threshold.": "コサインしきい値は顔類似度の判定基準です。値が高いほどクラスタリングは厳しくなります。DBSCAN では内部的にコサイン距離 = 1 - コサインしきい値を使用します。", + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48.": "コサイン類似度のしきい値です。値が高いほどクラスタリングは厳しくなります。既定値は 0.48 です。", + "DBSCAN distance threshold": "DBSCAN 距離しきい値", + "Algorithm: DBSCAN": "アルゴリズム: DBSCAN", + "Scan and Cluster": "スキャンしてクラスタリング", + "Minimum neighboring faces needed for a DBSCAN core point.": "DBSCAN のコア点に必要な近傍顔数です。", + "Faces whose bounding box width or height is smaller than this value are skipped.": "バウンディングボックスの幅または高さがこの値より小さい顔はスキップされます。", + "No images": "画像なし", + "People": "人物", + "ID": "ID", + "Name": "名前", + "Name, notes, and tags are shown here.": "名前、メモ、タグがここに表示されます。", + "Threshold": "しきい値", + "This application runs locally. Code and model licenses may differ. Research models may be limited to non-commercial use. Commercial deployment requires appropriate model license. This tool does not provide legal advice.": "このアプリケーションはローカルで動作します。コードとモデルのライセンスは異なる場合があります。研究用モデルは非商用利用に制限されることがあります。商用展開には適切なモデルライセンスが必要です。本ツールは法的助言を提供しません。", + "CUDA is unavailable on this machine, so Auto will use CPU.": "このマシンでは CUDA を利用できないため、自動設定では CPU を使用します。", + "Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.": "CUDAExecutionProvider が利用可能な場合は自動で CUDA を使用し、それ以外は CPU を使用します。", + "CUDAExecutionProvider is available.": "CUDAExecutionProvider を利用できます。", + "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first.": "CUDAExecutionProvider を利用できません。対応する onnxruntime-gpu、CUDA ランタイム、GPU ドライバを先にインストールしてください。", + "No downloaded swap models": "ダウンロード済みの顔交換モデルがありません", + "Only downloaded swap models are shown.": "ダウンロード済みの顔交換モデルのみ表示されます。", + "Download inswapper_128.onnx from Models > Downloads first.": "先に Models > Downloads から inswapper_128.onnx をダウンロードしてください。", + "No downloaded GFPGAN models": "ダウンロード済みの GFPGAN モデルがありません", + "Only downloaded GFPGAN restore models are shown.": "ダウンロード済みの GFPGAN 復元モデルのみ表示されます。", + "Download GFPGANv1.4.onnx from Models > Downloads first.": "先に Models > Downloads から GFPGANv1.4.onnx をダウンロードしてください。", + "GFPGAN is unavailable until a GFPGAN model is downloaded.": "GFPGAN モデルをダウンロードするまで GFPGAN は利用できません。", + "Run GFPGAN face restoration after face swap.": "顔交換後に GFPGAN 顔復元を実行します。", + "Enable GFPGAN restore after face swap": "顔交換後に GFPGAN 復元を有効化", + "Validate the dataset before running an evaluation.": "評価を実行する前にデータセットを検証してください。", + "Validate the selected dataset and configuration before running evaluation.": "評価を実行する前に、選択したデータセットと設定を検証してください。", + "Result preview appears here. Video results are saved to the exports folder.": "結果プレビューがここに表示されます。動画結果はエクスポートフォルダに保存されます。", + "Min det score %": "最小検出スコア %", + "asset": "アセット", + "source": "ソース", + "kind": "種類", + "release": "リリース", + "size": "サイズ", + "updated_at": "更新日時", + "local status": "ローカル状態", + "download url": "ダウンロード URL", + "rank": "順位", + "thumbnail": "サムネイル", + "gallery_file": "ギャラリーファイル", + "similarity": "類似度", + "threshold": "しきい値", + "decision": "判定", + "det_score": "検出スコア", + "person_id": "人物 ID", + "person_name": "人物名", + "status": "状態", + "sample_id": "サンプル ID", + "crop_path": "クロップパス", + "image_path": "画像パス", + "face_index": "顔インデックス", + "bbox": "バウンディングボックス", + "video_path": "動画パス", + "timestamp_ms": "タイムスタンプ ms", + "timestamp_hhmmss": "時刻", + "frame_index": "フレーム番号", + "id": "ID", + "date": "日付", + "scenario": "シナリオ", + "model": "モデル", + "provider": "プロバイダ", + "report_path": "レポートパス", + "quality_score": "品質スコア", + "cluster_id": "クラスタ ID", + "face_count": "顔数", + "photo_count": "写真数", + "average_quality": "平均品質", + "sample_paths": "サンプルパス", + "model_name": "モデル名", + "source_image_path": "元画像パス", + }, + "ko": { + "Browse": "찾아보기", + "InsightFace Evaluation Studio": "InsightFace Evaluation Studio", + "custom model directory": "사용자 지정 모델 디렉터리", + "Custom model directory": "사용자 지정 모델 디렉터리", + "Auto": "자동", + "Browse": "찾아보기", + "Add Person": "사람 추가", + "Add as New Person": "새 사람으로 추가", + "Assign to Existing Person": "기존 사람에게 지정", + "Compare": "비교", + "Search": "검색", + "Export": "내보내기", + "Export Result": "결과 내보내기", + "Export Results": "결과 내보내기", + "Export Summary": "요약 내보내기", + "Export Settings": "설정 내보내기", + "Import Settings": "설정 가져오기", + "Delete": "삭제", + "Delete Selected": "선택 항목 삭제", + "Reset": "초기화", + "Reset Settings": "설정 초기화", + "Refresh": "새로고침", + "Start": "시작", + "Stop": "중지", + "Open": "열기", + "Save Settings": "설정 저장", + "Save Details": "세부 정보 저장", + "Save crops": "크롭 저장", + "Save face crops": "얼굴 크롭 저장", + "Save recognition logs": "인식 로그 저장", + "Anonymize report paths": "보고서 경로 익명화", + "Privacy": "개인정보", + "Recursive": "재귀적으로 처리", + "Identify people": "사람 식별", + "Camera index": "카메라 인덱스", + "Frame skip": "프레임 건너뛰기", + "Frame interval": "프레임 간격", + "Target person": "대상 사람", + "Check Cameras": "카메라 확인", + "Register Current Face": "현재 얼굴 등록", + "Refresh People": "사람 목록 새로고침", + "Recognize Faces": "얼굴 인식", + "Test Model Load": "모델 로드 테스트", + "Warmup": "워밍업", + "Export Annotated Image": "주석 이미지 내보내기", + "Export CSV": "CSV 내보내기", + "Export CSV / JSON": "CSV / JSON 내보내기", + "Refresh Download URLs": "다운로드 URL 새로고침", + "Download Selected": "선택 항목 다운로드", + "Use Selected Model": "선택한 모델 사용", + "Open Model Folder": "모델 폴더 열기", + "Open GitHub Releases": "GitHub Releases 열기", + "Open Model Downloads": "모델 다운로드 열기", + "Open License Center": "라이선스 센터 열기", + "Open Reports": "보고서 열기", + "Open Selected Report": "선택한 보고서 열기", + "Re-export Selected": "선택 항목 다시 내보내기", + "Export All Summary": "전체 요약 내보내기", + "Import Image or Folder": "이미지 또는 폴더 가져오기", + "Select Image": "이미지 선택", + "Select Folder": "폴더 선택", + "Select gallery images or folders": "갤러리 이미지 또는 폴더 선택", + "Select one or more image files or folders. Folders are scanned recursively.": "하나 이상의 이미지 파일 또는 폴더를 선택하십시오. 폴더는 재귀적으로 스캔됩니다.", + "Click to import an image or folder, or drag one here. Folders are imported recursively.": "이미지 또는 폴더를 클릭해 가져오거나 여기로 끌어오십시오. 폴더는 재귀적으로 가져옵니다.", + "Click to upload images or a folder, or drag them here": "이미지 또는 폴더를 클릭해 업로드하거나 여기로 끌어오십시오", + "Drag one or more album folders here, or use Add Folder.": "하나 이상의 앨범 폴더를 여기로 끌어오거나 폴더 추가를 사용하십시오.", + "Drag album folders into the directory list, or click Add Folder.": "앨범 폴더를 디렉터리 목록으로 끌어오거나 폴더 추가를 클릭하십시오.", + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. DBSCAN internally uses cosine distance = 1 - cosine threshold.": "코사인 임계값은 얼굴 유사도의 기준값입니다. 값이 높을수록 클러스터가 더 엄격해집니다. DBSCAN은 내부적으로 코사인 거리 = 1 - 코사인 임계값을 사용합니다.", + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48.": "코사인 유사도 임계값입니다. 값이 높을수록 클러스터가 더 엄격해지며 기본값은 0.48입니다.", + "DBSCAN distance threshold": "DBSCAN 거리 임계값", + "Algorithm: DBSCAN": "알고리즘: DBSCAN", + "Scan and Cluster": "스캔 및 클러스터링", + "Minimum neighboring faces needed for a DBSCAN core point.": "DBSCAN 핵심점에 필요한 최소 이웃 얼굴 수입니다.", + "Faces whose bounding box width or height is smaller than this value are skipped.": "바운딩 박스의 너비 또는 높이가 이 값보다 작은 얼굴은 건너뜁니다.", + "No images": "이미지 없음", + "People": "사람", + "ID": "ID", + "Name": "이름", + "Name, notes, and tags are shown here.": "이름, 메모, 태그가 여기에 표시됩니다.", + "Threshold": "임계값", + "This application runs locally. Code and model licenses may differ. Research models may be limited to non-commercial use. Commercial deployment requires appropriate model license. This tool does not provide legal advice.": "이 애플리케이션은 로컬에서 실행됩니다. 코드와 모델 라이선스는 다를 수 있습니다. 연구용 모델은 비상업적 사용으로 제한될 수 있습니다. 상용 배포에는 적절한 모델 라이선스가 필요합니다. 이 도구는 법률 자문을 제공하지 않습니다.", + "CUDA is unavailable on this machine, so Auto will use CPU.": "이 컴퓨터에서 CUDA를 사용할 수 없어 자동 설정은 CPU를 사용합니다.", + "Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.": "CUDAExecutionProvider를 사용할 수 있으면 자동으로 CUDA를 사용하고, 그렇지 않으면 CPU를 사용합니다.", + "CUDAExecutionProvider is available.": "CUDAExecutionProvider를 사용할 수 있습니다.", + "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first.": "CUDAExecutionProvider를 사용할 수 없습니다. 먼저 호환되는 onnxruntime-gpu, CUDA 런타임, GPU 드라이버를 설치하십시오.", + "No downloaded swap models": "다운로드된 얼굴 교체 모델 없음", + "Only downloaded swap models are shown.": "다운로드된 얼굴 교체 모델만 표시됩니다.", + "Download inswapper_128.onnx from Models > Downloads first.": "먼저 Models > Downloads에서 inswapper_128.onnx를 다운로드하십시오.", + "No downloaded GFPGAN models": "다운로드된 GFPGAN 모델 없음", + "Only downloaded GFPGAN restore models are shown.": "다운로드된 GFPGAN 복원 모델만 표시됩니다.", + "Download GFPGANv1.4.onnx from Models > Downloads first.": "먼저 Models > Downloads에서 GFPGANv1.4.onnx를 다운로드하십시오.", + "GFPGAN is unavailable until a GFPGAN model is downloaded.": "GFPGAN 모델을 다운로드하기 전에는 GFPGAN을 사용할 수 없습니다.", + "Run GFPGAN face restoration after face swap.": "얼굴 교체 후 GFPGAN 얼굴 복원을 실행합니다.", + "Enable GFPGAN restore after face swap": "얼굴 교체 후 GFPGAN 복원 활성화", + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help.": "기업 평가, 라이선스, SDK/API, SLA 또는 맞춤 학습 지원을 위해 InsightFace 문의 페이지를 엽니다.", + "Evaluation Dataset Rules": "평가 데이터셋 규칙", + "Prepare local identity folders using one of the supported layouts below.": "아래 지원 레이아웃 중 하나로 로컬 ID 폴더를 준비하십시오.", + "Validate the dataset before running an evaluation.": "평가를 실행하기 전에 데이터셋을 검증하십시오.", + "Validate the selected dataset and configuration before running evaluation.": "평가를 실행하기 전에 선택한 데이터셋과 구성을 검증하십시오.", + "Result preview appears here. Video results are saved to the exports folder.": "결과 미리보기가 여기에 표시됩니다. 비디오 결과는 내보내기 폴더에 저장됩니다.", + "Min det score %": "최소 검출 점수 %", + "asset": "자산", + "source": "소스", + "kind": "종류", + "release": "릴리스", + "size": "크기", + "updated_at": "업데이트 시간", + "local status": "로컬 상태", + "download url": "다운로드 URL", + "rank": "순위", + "thumbnail": "썸네일", + "gallery_file": "갤러리 파일", + "similarity": "유사도", + "threshold": "임계값", + "decision": "판정", + "det_score": "검출 점수", + "person_id": "사람 ID", + "person_name": "사람 이름", + "status": "상태", + "sample_id": "샘플 ID", + "crop_path": "크롭 경로", + "image_path": "이미지 경로", + "face_index": "얼굴 인덱스", + "bbox": "바운딩 박스", + "video_path": "비디오 경로", + "timestamp_ms": "타임스탬프 ms", + "timestamp_hhmmss": "시간", + "frame_index": "프레임 인덱스", + "id": "ID", + "date": "날짜", + "scenario": "시나리오", + "model": "모델", + "provider": "제공자", + "report_path": "보고서 경로", + "quality_score": "품질 점수", + "cluster_id": "클러스터 ID", + "face_count": "얼굴 수", + "photo_count": "사진 수", + "average_quality": "평균 품질", + "sample_paths": "샘플 경로", + "model_name": "모델 이름", + "source_image_path": "원본 이미지 경로", + }, + "es": { + "Browse": "Explorar", + "InsightFace Evaluation Studio": "InsightFace Evaluation Studio", + "custom model directory": "directorio de modelo personalizado", + "Custom model directory": "Directorio de modelo personalizado", + "Auto": "Automático", + "Browse": "Explorar", + "Add Person": "Añadir persona", + "Add as New Person": "Añadir como nueva persona", + "Assign to Existing Person": "Asignar a una persona existente", + "Compare": "Comparar", + "Search": "Buscar", + "Export": "Exportar", + "Export Result": "Exportar resultado", + "Export Results": "Exportar resultados", + "Export Summary": "Exportar resumen", + "Export Settings": "Exportar configuración", + "Import Settings": "Importar configuración", + "Delete": "Eliminar", + "Delete Selected": "Eliminar selección", + "Reset": "Restablecer", + "Reset Settings": "Restablecer configuración", + "Refresh": "Actualizar", + "Start": "Iniciar", + "Stop": "Detener", + "Open": "Abrir", + "Save Settings": "Guardar configuración", + "Save Details": "Guardar detalles", + "Save crops": "Guardar recortes", + "Save face crops": "Guardar recortes de rostro", + "Save recognition logs": "Guardar registros de reconocimiento", + "Anonymize report paths": "Anonimizar rutas de informes", + "Privacy": "Privacidad", + "Recursive": "Recursivo", + "Identify people": "Identificar personas", + "Camera index": "Índice de cámara", + "Frame skip": "Salto de fotogramas", + "Frame interval": "Intervalo de fotogramas", + "Target person": "Persona objetivo", + "Check Cameras": "Comprobar cámaras", + "Register Current Face": "Registrar rostro actual", + "Refresh People": "Actualizar personas", + "Recognize Faces": "Reconocer rostros", + "Test Model Load": "Probar carga del modelo", + "Warmup": "Calentamiento", + "Export Annotated Image": "Exportar imagen anotada", + "Export CSV": "Exportar CSV", + "Export CSV / JSON": "Exportar CSV / JSON", + "Refresh Download URLs": "Actualizar URL de descarga", + "Download Selected": "Descargar selección", + "Use Selected Model": "Usar modelo seleccionado", + "Open Model Folder": "Abrir carpeta de modelos", + "Open GitHub Releases": "Abrir GitHub Releases", + "Open Model Downloads": "Abrir descargas de modelos", + "Open License Center": "Abrir centro de licencias", + "Open Reports": "Abrir informes", + "Open Selected Report": "Abrir informe seleccionado", + "Re-export Selected": "Reexportar selección", + "Export All Summary": "Exportar resumen completo", + "Import Image or Folder": "Importar imagen o carpeta", + "Select Image": "Seleccionar imagen", + "Select Folder": "Seleccionar carpeta", + "Select gallery images or folders": "Seleccionar imágenes o carpetas de galería", + "Select one or more image files or folders. Folders are scanned recursively.": "Seleccione uno o más archivos de imagen o carpetas. Las carpetas se escanean de forma recursiva.", + "Click to import an image or folder, or drag one here. Folders are imported recursively.": "Haga clic para importar una imagen o carpeta, o arrástrela aquí. Las carpetas se importan de forma recursiva.", + "Click to upload images or a folder, or drag them here": "Haga clic para subir imágenes o una carpeta, o arrástrelas aquí", + "Drag one or more album folders here, or use Add Folder.": "Arrastre aquí una o más carpetas de álbum, o use Añadir carpeta.", + "Drag album folders into the directory list, or click Add Folder.": "Arrastre carpetas de álbum a la lista de directorios, o haga clic en Añadir carpeta.", + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. DBSCAN internally uses cosine distance = 1 - cosine threshold.": "El umbral de coseno es el corte de similitud facial: valores más altos hacen que los clústeres sean más estrictos. DBSCAN usa internamente distancia de coseno = 1 - umbral de coseno.", + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48.": "Umbral de similitud de coseno. Valores más altos hacen que los clústeres sean más estrictos; el valor predeterminado es 0,48.", + "DBSCAN distance threshold": "Umbral de distancia DBSCAN", + "Algorithm: DBSCAN": "Algoritmo: DBSCAN", + "Scan and Cluster": "Escanear y agrupar", + "Minimum neighboring faces needed for a DBSCAN core point.": "Número mínimo de rostros vecinos necesarios para un punto núcleo de DBSCAN.", + "Faces whose bounding box width or height is smaller than this value are skipped.": "Se omiten los rostros cuyo cuadro delimitador tenga anchura o altura menor que este valor.", + "No images": "Sin imágenes", + "People": "Personas", + "ID": "ID", + "Name": "Nombre", + "Name, notes, and tags are shown here.": "Aquí se muestran el nombre, las notas y las etiquetas.", + "Threshold": "Umbral", + "This application runs locally. Code and model licenses may differ. Research models may be limited to non-commercial use. Commercial deployment requires appropriate model license. This tool does not provide legal advice.": "Esta aplicación se ejecuta localmente. Las licencias del código y de los modelos pueden ser diferentes. Los modelos de investigación pueden estar limitados a uso no comercial. El despliegue comercial requiere una licencia de modelo adecuada. Esta herramienta no ofrece asesoramiento legal.", + "CUDA is unavailable on this machine, so Auto will use CPU.": "CUDA no está disponible en esta máquina, por lo que Automático usará CPU.", + "Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.": "Automático usa CUDA cuando CUDAExecutionProvider está disponible; en caso contrario usa CPU.", + "CUDAExecutionProvider is available.": "CUDAExecutionProvider está disponible.", + "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first.": "CUDAExecutionProvider no está disponible. Instale primero una versión compatible de onnxruntime-gpu, el runtime CUDA y el controlador GPU.", + "No downloaded swap models": "No hay modelos de intercambio facial descargados", + "Only downloaded swap models are shown.": "Solo se muestran modelos de intercambio facial descargados.", + "Download inswapper_128.onnx from Models > Downloads first.": "Descargue primero inswapper_128.onnx desde Models > Downloads.", + "No downloaded GFPGAN models": "No hay modelos GFPGAN descargados", + "Only downloaded GFPGAN restore models are shown.": "Solo se muestran modelos de restauración GFPGAN descargados.", + "Download GFPGANv1.4.onnx from Models > Downloads first.": "Descargue primero GFPGANv1.4.onnx desde Models > Downloads.", + "GFPGAN is unavailable until a GFPGAN model is downloaded.": "GFPGAN no estará disponible hasta descargar un modelo GFPGAN.", + "Run GFPGAN face restoration after face swap.": "Ejecutar restauración facial GFPGAN después del intercambio.", + "Enable GFPGAN restore after face swap": "Activar restauración GFPGAN después del intercambio facial", + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image.": "Seleccione automáticamente la imagen de galería de cada identidad desde un archivo que contenga “gallery”, o la primera imagen ordenada.", + "Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.": "Abra las reglas detalladas de carpetas de identidad para 1:1, 1:N y División automática.", + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help.": "Abrir la página de contacto de InsightFace para evaluación empresarial, licencias, SDK/API, SLA o formación personalizada.", + "Evaluation Dataset Rules": "Reglas del dataset de evaluación", + "Prepare local identity folders using one of the supported layouts below.": "Prepare carpetas locales de identidad usando uno de los formatos admitidos a continuación.", + "Validate the dataset before running an evaluation.": "Valide el dataset antes de ejecutar una evaluación.", + "Validate the selected dataset and configuration before running evaluation.": "Valide el dataset y la configuración seleccionados antes de ejecutar la evaluación.", + "Result preview appears here. Video results are saved to the exports folder.": "La vista previa del resultado aparece aquí. Los resultados de vídeo se guardan en la carpeta de exportaciones.", + "Min det score %": "Puntuación mínima de detección %", + "asset": "recurso", + "source": "origen", + "kind": "tipo", + "release": "versión", + "size": "tamaño", + "updated_at": "actualizado", + "local status": "estado local", + "download url": "URL de descarga", + "rank": "posición", + "thumbnail": "miniatura", + "gallery_file": "archivo de galería", + "similarity": "similitud", + "threshold": "umbral", + "decision": "decisión", + "det_score": "puntuación de detección", + "person_id": "ID de persona", + "person_name": "nombre de persona", + "status": "estado", + "sample_id": "ID de muestra", + "crop_path": "ruta del recorte", + "image_path": "ruta de imagen", + "face_index": "índice de rostro", + "bbox": "cuadro", + "video_path": "ruta de vídeo", + "timestamp_ms": "marca temporal ms", + "timestamp_hhmmss": "hora", + "frame_index": "índice de fotograma", + "id": "ID", + "date": "fecha", + "scenario": "escenario", + "model": "modelo", + "provider": "proveedor", + "report_path": "ruta del informe", + "quality_score": "puntuación de calidad", + "cluster_id": "ID de clúster", + "face_count": "rostros", + "photo_count": "fotos", + "average_quality": "calidad media", + "sample_paths": "rutas de muestra", + "model_name": "nombre del modelo", + "source_image_path": "ruta de imagen origen", + }, + "fr": { + "Browse": "Parcourir", + "InsightFace Evaluation Studio": "InsightFace Evaluation Studio", + "custom model directory": "répertoire de modèle personnalisé", + "Custom model directory": "Répertoire de modèle personnalisé", + "Auto": "Auto", + "Browse": "Parcourir", + "Add Person": "Ajouter une personne", + "Add as New Person": "Ajouter comme nouvelle personne", + "Assign to Existing Person": "Attribuer à une personne existante", + "Compare": "Comparer", + "Search": "Rechercher", + "Export": "Exporter", + "Export Result": "Exporter le résultat", + "Export Results": "Exporter les résultats", + "Export Summary": "Exporter le résumé", + "Export Settings": "Exporter les paramètres", + "Import Settings": "Importer les paramètres", + "Delete": "Supprimer", + "Delete Selected": "Supprimer la sélection", + "Reset": "Réinitialiser", + "Reset Settings": "Réinitialiser les paramètres", + "Refresh": "Actualiser", + "Start": "Démarrer", + "Stop": "Arrêter", + "Open": "Ouvrir", + "Save Settings": "Enregistrer les paramètres", + "Save Details": "Enregistrer les détails", + "Save crops": "Enregistrer les recadrages", + "Save face crops": "Enregistrer les recadrages de visage", + "Save recognition logs": "Enregistrer les journaux de reconnaissance", + "Anonymize report paths": "Anonymiser les chemins des rapports", + "Privacy": "Confidentialité", + "Recursive": "Récursif", + "Identify people": "Identifier les personnes", + "Camera index": "Index de caméra", + "Frame skip": "Saut d’images", + "Frame interval": "Intervalle d’images", + "Target person": "Personne cible", + "Check Cameras": "Vérifier les caméras", + "Register Current Face": "Enregistrer le visage actuel", + "Refresh People": "Actualiser les personnes", + "Recognize Faces": "Reconnaître les visages", + "Test Model Load": "Tester le chargement du modèle", + "Warmup": "Préchauffage", + "Export Annotated Image": "Exporter l’image annotée", + "Export CSV": "Exporter CSV", + "Export CSV / JSON": "Exporter CSV / JSON", + "Refresh Download URLs": "Actualiser les URL de téléchargement", + "Download Selected": "Télécharger la sélection", + "Use Selected Model": "Utiliser le modèle sélectionné", + "Open Model Folder": "Ouvrir le dossier des modèles", + "Open GitHub Releases": "Ouvrir GitHub Releases", + "Open Model Downloads": "Ouvrir les téléchargements de modèles", + "Open License Center": "Ouvrir le centre de licences", + "Open Reports": "Ouvrir les rapports", + "Open Selected Report": "Ouvrir le rapport sélectionné", + "Re-export Selected": "Réexporter la sélection", + "Export All Summary": "Exporter le résumé complet", + "Import Image or Folder": "Importer une image ou un dossier", + "Select Image": "Sélectionner une image", + "Select Folder": "Sélectionner un dossier", + "Select gallery images or folders": "Sélectionner des images ou dossiers de galerie", + "Select one or more image files or folders. Folders are scanned recursively.": "Sélectionnez un ou plusieurs fichiers image ou dossiers. Les dossiers sont analysés récursivement.", + "Click to import an image or folder, or drag one here. Folders are imported recursively.": "Cliquez pour importer une image ou un dossier, ou faites-le glisser ici. Les dossiers sont importés récursivement.", + "Click to upload images or a folder, or drag them here": "Cliquez pour charger des images ou un dossier, ou faites-les glisser ici", + "Drag one or more album folders here, or use Add Folder.": "Faites glisser un ou plusieurs dossiers d’album ici, ou utilisez Ajouter un dossier.", + "Drag album folders into the directory list, or click Add Folder.": "Faites glisser des dossiers d’album dans la liste, ou cliquez sur Ajouter un dossier.", + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. DBSCAN internally uses cosine distance = 1 - cosine threshold.": "Le seuil cosinus est le seuil de similarité faciale : plus il est élevé, plus les clusters sont stricts. DBSCAN utilise en interne la distance cosinus = 1 - seuil cosinus.", + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48.": "Seuil de similarité cosinus. Plus la valeur est élevée, plus les clusters sont stricts ; la valeur par défaut est 0,48.", + "DBSCAN distance threshold": "Seuil de distance DBSCAN", + "Algorithm: DBSCAN": "Algorithme : DBSCAN", + "Scan and Cluster": "Analyser et regrouper", + "Minimum neighboring faces needed for a DBSCAN core point.": "Nombre minimal de visages voisins nécessaire pour un point cœur DBSCAN.", + "Faces whose bounding box width or height is smaller than this value are skipped.": "Les visages dont la boîte englobante est plus petite que cette valeur en largeur ou hauteur sont ignorés.", + "No images": "Aucune image", + "People": "Personnes", + "ID": "ID", + "Name": "Nom", + "Name, notes, and tags are shown here.": "Le nom, les notes et les tags apparaissent ici.", + "Threshold": "Seuil", + "This application runs locally. Code and model licenses may differ. Research models may be limited to non-commercial use. Commercial deployment requires appropriate model license. This tool does not provide legal advice.": "Cette application s’exécute localement. Les licences du code et des modèles peuvent différer. Les modèles de recherche peuvent être limités à un usage non commercial. Un déploiement commercial requiert une licence de modèle appropriée. Cet outil ne fournit pas de conseil juridique.", + "CUDA is unavailable on this machine, so Auto will use CPU.": "CUDA n’est pas disponible sur cette machine ; le mode Auto utilisera donc le CPU.", + "Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.": "Le mode Auto utilise CUDA lorsque CUDAExecutionProvider est disponible, sinon le CPU.", + "CUDAExecutionProvider is available.": "CUDAExecutionProvider est disponible.", + "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first.": "CUDAExecutionProvider n’est pas disponible. Installez d’abord une version compatible de onnxruntime-gpu, le runtime CUDA et le pilote GPU.", + "No downloaded swap models": "Aucun modèle de face swap téléchargé", + "Only downloaded swap models are shown.": "Seuls les modèles de face swap téléchargés sont affichés.", + "Download inswapper_128.onnx from Models > Downloads first.": "Téléchargez d’abord inswapper_128.onnx depuis Models > Downloads.", + "No downloaded GFPGAN models": "Aucun modèle GFPGAN téléchargé", + "Only downloaded GFPGAN restore models are shown.": "Seuls les modèles de restauration GFPGAN téléchargés sont affichés.", + "Download GFPGANv1.4.onnx from Models > Downloads first.": "Téléchargez d’abord GFPGANv1.4.onnx depuis Models > Downloads.", + "GFPGAN is unavailable until a GFPGAN model is downloaded.": "GFPGAN est indisponible tant qu’un modèle GFPGAN n’a pas été téléchargé.", + "Run GFPGAN face restoration after face swap.": "Exécuter la restauration de visage GFPGAN après le face swap.", + "Enable GFPGAN restore after face swap": "Activer la restauration GFPGAN après le face swap", + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image.": "Sélectionne automatiquement l’image de galerie de chaque identité à partir d’un fichier contenant « gallery », ou la première image triée.", + "Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.": "Ouvre les règles détaillées des dossiers d’identité pour 1:1, 1:N et le découpage automatique.", + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help.": "Ouvrir la page de contact InsightFace pour l’évaluation entreprise, les licences, SDK/API, SLA ou l’entraînement personnalisé.", + "Evaluation Dataset Rules": "Règles du jeu de données d’évaluation", + "Prepare local identity folders using one of the supported layouts below.": "Préparez des dossiers d’identité locaux selon l’une des structures prises en charge ci-dessous.", + "Validate the dataset before running an evaluation.": "Validez le jeu de données avant de lancer une évaluation.", + "Validate the selected dataset and configuration before running evaluation.": "Validez le jeu de données et la configuration sélectionnés avant de lancer l’évaluation.", + "Result preview appears here. Video results are saved to the exports folder.": "L’aperçu du résultat apparaît ici. Les résultats vidéo sont enregistrés dans le dossier d’export.", + "Min det score %": "Score de détection min. %", + "asset": "ressource", + "source": "source", + "kind": "type", + "release": "version", + "size": "taille", + "updated_at": "mis à jour", + "local status": "état local", + "download url": "URL de téléchargement", + "rank": "rang", + "thumbnail": "vignette", + "gallery_file": "fichier galerie", + "similarity": "similarité", + "threshold": "seuil", + "decision": "décision", + "det_score": "score de détection", + "person_id": "ID personne", + "person_name": "nom de personne", + "status": "état", + "sample_id": "ID échantillon", + "crop_path": "chemin du recadrage", + "image_path": "chemin image", + "face_index": "index visage", + "bbox": "boîte", + "video_path": "chemin vidéo", + "timestamp_ms": "horodatage ms", + "timestamp_hhmmss": "temps", + "frame_index": "index image", + "id": "ID", + "date": "date", + "scenario": "scénario", + "model": "modèle", + "provider": "fournisseur", + "report_path": "chemin du rapport", + "quality_score": "score qualité", + "cluster_id": "ID cluster", + "face_count": "visages", + "photo_count": "photos", + "average_quality": "qualité moyenne", + "sample_paths": "chemins des échantillons", + "model_name": "nom du modèle", + "source_image_path": "chemin de l’image source", + }, + "de": { + "Browse": "Durchsuchen", + "InsightFace Evaluation Studio": "InsightFace Evaluation Studio", + "custom model directory": "benutzerdefiniertes Modellverzeichnis", + "Custom model directory": "Benutzerdefiniertes Modellverzeichnis", + "Auto": "Auto", + "Browse": "Durchsuchen", + "Add Person": "Person hinzufügen", + "Add as New Person": "Als neue Person hinzufügen", + "Assign to Existing Person": "Bestehender Person zuweisen", + "Compare": "Vergleichen", + "Search": "Suchen", + "Export": "Exportieren", + "Export Result": "Ergebnis exportieren", + "Export Results": "Ergebnisse exportieren", + "Export Summary": "Zusammenfassung exportieren", + "Export Settings": "Einstellungen exportieren", + "Import Settings": "Einstellungen importieren", + "Delete": "Löschen", + "Delete Selected": "Auswahl löschen", + "Reset": "Zurücksetzen", + "Reset Settings": "Einstellungen zurücksetzen", + "Refresh": "Aktualisieren", + "Start": "Starten", + "Stop": "Stoppen", + "Open": "Öffnen", + "Save Settings": "Einstellungen speichern", + "Save Details": "Details speichern", + "Save crops": "Ausschnitte speichern", + "Save face crops": "Gesichtsausschnitte speichern", + "Save recognition logs": "Erkennungsprotokolle speichern", + "Anonymize report paths": "Berichtspfade anonymisieren", + "Privacy": "Datenschutz", + "Recursive": "Rekursiv", + "Identify people": "Personen identifizieren", + "Camera index": "Kameraindex", + "Frame skip": "Frames überspringen", + "Frame interval": "Frameintervall", + "Target person": "Zielperson", + "Check Cameras": "Kameras prüfen", + "Register Current Face": "Aktuelles Gesicht registrieren", + "Refresh People": "Personen aktualisieren", + "Recognize Faces": "Gesichter erkennen", + "Test Model Load": "Modellladen testen", + "Warmup": "Aufwärmen", + "Export Annotated Image": "Annotiertes Bild exportieren", + "Export CSV": "CSV exportieren", + "Export CSV / JSON": "CSV / JSON exportieren", + "Refresh Download URLs": "Download-URLs aktualisieren", + "Download Selected": "Auswahl herunterladen", + "Use Selected Model": "Ausgewähltes Modell verwenden", + "Open Model Folder": "Modellordner öffnen", + "Open GitHub Releases": "GitHub Releases öffnen", + "Open Model Downloads": "Modelldownloads öffnen", + "Open License Center": "Lizenzcenter öffnen", + "Open Reports": "Berichte öffnen", + "Open Selected Report": "Ausgewählten Bericht öffnen", + "Re-export Selected": "Auswahl erneut exportieren", + "Export All Summary": "Gesamtübersicht exportieren", + "Import Image or Folder": "Bild oder Ordner importieren", + "Select Image": "Bild auswählen", + "Select Folder": "Ordner auswählen", + "Select gallery images or folders": "Galeriebilder oder Ordner auswählen", + "Select one or more image files or folders. Folders are scanned recursively.": "Wählen Sie eine oder mehrere Bilddateien oder Ordner aus. Ordner werden rekursiv gescannt.", + "Click to import an image or folder, or drag one here. Folders are imported recursively.": "Klicken Sie, um ein Bild oder einen Ordner zu importieren, oder ziehen Sie ihn hierher. Ordner werden rekursiv importiert.", + "Click to upload images or a folder, or drag them here": "Klicken Sie zum Hochladen von Bildern oder eines Ordners, oder ziehen Sie sie hierher", + "Drag one or more album folders here, or use Add Folder.": "Ziehen Sie einen oder mehrere Albumordner hierher oder verwenden Sie Ordner hinzufügen.", + "Drag album folders into the directory list, or click Add Folder.": "Ziehen Sie Albumordner in die Verzeichnisliste oder klicken Sie auf Ordner hinzufügen.", + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. DBSCAN internally uses cosine distance = 1 - cosine threshold.": "Der Kosinusschwellenwert ist die Grenze für Gesichtähnlichkeit: höhere Werte machen Cluster strenger. DBSCAN verwendet intern Kosinusdistanz = 1 - Kosinusschwellenwert.", + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48.": "Kosinussimilaritätsschwelle. Höhere Werte machen Cluster strenger; Standard ist 0,48.", + "DBSCAN distance threshold": "DBSCAN-Distanzschwelle", + "Algorithm: DBSCAN": "Algorithmus: DBSCAN", + "Scan and Cluster": "Scannen und clustern", + "Minimum neighboring faces needed for a DBSCAN core point.": "Mindestanzahl benachbarter Gesichter für einen DBSCAN-Kernpunkt.", + "Faces whose bounding box width or height is smaller than this value are skipped.": "Gesichter, deren Boxbreite oder -höhe kleiner als dieser Wert ist, werden übersprungen.", + "No images": "Keine Bilder", + "People": "Personen", + "ID": "ID", + "Name": "Name", + "Name, notes, and tags are shown here.": "Name, Notizen und Tags werden hier angezeigt.", + "Threshold": "Schwelle", + "This application runs locally. Code and model licenses may differ. Research models may be limited to non-commercial use. Commercial deployment requires appropriate model license. This tool does not provide legal advice.": "Diese Anwendung läuft lokal. Code- und Modelllizenzen können sich unterscheiden. Forschungsmodelle können auf nichtkommerzielle Nutzung beschränkt sein. Kommerzielle Bereitstellung erfordert eine geeignete Modelllizenz. Dieses Tool bietet keine Rechtsberatung.", + "CUDA is unavailable on this machine, so Auto will use CPU.": "CUDA ist auf diesem Rechner nicht verfügbar; Auto verwendet daher die CPU.", + "Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.": "Auto verwendet CUDA, wenn CUDAExecutionProvider verfügbar ist, andernfalls CPU.", + "CUDAExecutionProvider is available.": "CUDAExecutionProvider ist verfügbar.", + "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first.": "CUDAExecutionProvider ist nicht verfügbar. Installieren Sie zuerst passendes onnxruntime-gpu, CUDA Runtime und GPU-Treiber.", + "No downloaded swap models": "Keine heruntergeladenen Face-Swap-Modelle", + "Only downloaded swap models are shown.": "Es werden nur heruntergeladene Face-Swap-Modelle angezeigt.", + "Download inswapper_128.onnx from Models > Downloads first.": "Laden Sie zuerst inswapper_128.onnx unter Models > Downloads herunter.", + "No downloaded GFPGAN models": "Keine heruntergeladenen GFPGAN-Modelle", + "Only downloaded GFPGAN restore models are shown.": "Es werden nur heruntergeladene GFPGAN-Wiederherstellungsmodelle angezeigt.", + "Download GFPGANv1.4.onnx from Models > Downloads first.": "Laden Sie zuerst GFPGANv1.4.onnx unter Models > Downloads herunter.", + "GFPGAN is unavailable until a GFPGAN model is downloaded.": "GFPGAN ist erst nach dem Herunterladen eines GFPGAN-Modells verfügbar.", + "Run GFPGAN face restoration after face swap.": "GFPGAN-Gesichtswiederherstellung nach dem Face Swap ausführen.", + "Enable GFPGAN restore after face swap": "GFPGAN-Wiederherstellung nach Face Swap aktivieren", + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image.": "Wählt das Galeriebild jeder Identität automatisch aus einer Datei mit „gallery“ im Namen oder dem ersten sortierten Bild.", + "Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.": "Öffnet die detaillierten Identitätsordnerregeln für 1:1, 1:N und automatische Aufteilung.", + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help.": "Öffnet die InsightFace-Kontaktseite für Unternehmensevaluierung, Lizenzierung, SDK/API, SLA oder individuelles Training.", + "Evaluation Dataset Rules": "Regeln für Evaluierungsdatensätze", + "Prepare local identity folders using one of the supported layouts below.": "Bereiten Sie lokale Identitätsordner mit einer der unten unterstützten Strukturen vor.", + "Validate the dataset before running an evaluation.": "Validieren Sie den Datensatz, bevor Sie eine Evaluierung starten.", + "Validate the selected dataset and configuration before running evaluation.": "Validieren Sie den ausgewählten Datensatz und die Konfiguration vor der Evaluierung.", + "Result preview appears here. Video results are saved to the exports folder.": "Die Ergebnisvorschau erscheint hier. Videoergebnisse werden im Exportordner gespeichert.", + "Min det score %": "Min. Detektionsscore %", + "asset": "Asset", + "source": "Quelle", + "kind": "Art", + "release": "Release", + "size": "Größe", + "updated_at": "aktualisiert", + "local status": "lokaler Status", + "download url": "Download-URL", + "rank": "Rang", + "thumbnail": "Miniatur", + "gallery_file": "Galeriedatei", + "similarity": "Ähnlichkeit", + "threshold": "Schwelle", + "decision": "Entscheidung", + "det_score": "Detektionsscore", + "person_id": "Personen-ID", + "person_name": "Personenname", + "status": "Status", + "sample_id": "Sample-ID", + "crop_path": "Ausschnittspfad", + "image_path": "Bildpfad", + "face_index": "Gesichtsindex", + "bbox": "Box", + "video_path": "Videopfad", + "timestamp_ms": "Zeitstempel ms", + "timestamp_hhmmss": "Zeit", + "frame_index": "Frameindex", + "id": "ID", + "date": "Datum", + "scenario": "Szenario", + "model": "Modell", + "provider": "Provider", + "report_path": "Berichtspfad", + "quality_score": "Qualitätsscore", + "cluster_id": "Cluster-ID", + "face_count": "Gesichter", + "photo_count": "Fotos", + "average_quality": "Durchschnittsqualität", + "sample_paths": "Sample-Pfade", + "model_name": "Modellname", + "source_image_path": "Quellbildpfad", + }, + "pt": { + "Browse": "Procurar", + "InsightFace Evaluation Studio": "InsightFace Evaluation Studio", + "custom model directory": "diretório de modelo personalizado", + "Custom model directory": "Diretório de modelo personalizado", + "Auto": "Automático", + "Browse": "Procurar", + "Add Person": "Adicionar pessoa", + "Add as New Person": "Adicionar como nova pessoa", + "Assign to Existing Person": "Atribuir a pessoa existente", + "Compare": "Comparar", + "Search": "Pesquisar", + "Export": "Exportar", + "Export Result": "Exportar resultado", + "Export Results": "Exportar resultados", + "Export Summary": "Exportar resumo", + "Export Settings": "Exportar definições", + "Import Settings": "Importar definições", + "Delete": "Eliminar", + "Delete Selected": "Eliminar seleção", + "Reset": "Repor", + "Reset Settings": "Repor definições", + "Refresh": "Atualizar", + "Start": "Iniciar", + "Stop": "Parar", + "Open": "Abrir", + "Save Settings": "Guardar definições", + "Save Details": "Guardar detalhes", + "Save crops": "Guardar recortes", + "Save face crops": "Guardar recortes de rosto", + "Save recognition logs": "Guardar registos de reconhecimento", + "Anonymize report paths": "Anonimizar caminhos dos relatórios", + "Privacy": "Privacidade", + "Recursive": "Recursivo", + "Identify people": "Identificar pessoas", + "Camera index": "Índice da câmara", + "Frame skip": "Saltar fotogramas", + "Frame interval": "Intervalo de fotogramas", + "Target person": "Pessoa alvo", + "Check Cameras": "Verificar câmaras", + "Register Current Face": "Registar rosto atual", + "Refresh People": "Atualizar pessoas", + "Recognize Faces": "Reconhecer rostos", + "Test Model Load": "Testar carregamento do modelo", + "Warmup": "Aquecimento", + "Export Annotated Image": "Exportar imagem anotada", + "Export CSV": "Exportar CSV", + "Export CSV / JSON": "Exportar CSV / JSON", + "Refresh Download URLs": "Atualizar URLs de transferência", + "Download Selected": "Transferir seleção", + "Use Selected Model": "Usar modelo selecionado", + "Open Model Folder": "Abrir pasta de modelos", + "Open GitHub Releases": "Abrir GitHub Releases", + "Open Model Downloads": "Abrir transferências de modelos", + "Open License Center": "Abrir centro de licenças", + "Open Reports": "Abrir relatórios", + "Open Selected Report": "Abrir relatório selecionado", + "Re-export Selected": "Reexportar seleção", + "Export All Summary": "Exportar resumo completo", + "Import Image or Folder": "Importar imagem ou pasta", + "Select Image": "Selecionar imagem", + "Select Folder": "Selecionar pasta", + "Select gallery images or folders": "Selecionar imagens ou pastas da galeria", + "Select one or more image files or folders. Folders are scanned recursively.": "Selecione um ou mais ficheiros de imagem ou pastas. As pastas são analisadas recursivamente.", + "Click to import an image or folder, or drag one here. Folders are imported recursively.": "Clique para importar uma imagem ou pasta, ou arraste-a para aqui. As pastas são importadas recursivamente.", + "Click to upload images or a folder, or drag them here": "Clique para carregar imagens ou uma pasta, ou arraste-as para aqui", + "Drag one or more album folders here, or use Add Folder.": "Arraste uma ou mais pastas de álbum para aqui, ou use Adicionar pasta.", + "Drag album folders into the directory list, or click Add Folder.": "Arraste pastas de álbum para a lista de diretórios, ou clique em Adicionar pasta.", + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. DBSCAN internally uses cosine distance = 1 - cosine threshold.": "O limiar de cosseno é o corte de similaridade facial: valores mais altos tornam os clusters mais rigorosos. O DBSCAN usa internamente distância de cosseno = 1 - limiar de cosseno.", + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48.": "Limiar de similaridade de cosseno. Valores mais altos tornam os clusters mais rigorosos; predefinição 0,48.", + "DBSCAN distance threshold": "Limiar de distância DBSCAN", + "Algorithm: DBSCAN": "Algoritmo: DBSCAN", + "Scan and Cluster": "Analisar e agrupar", + "Minimum neighboring faces needed for a DBSCAN core point.": "Número mínimo de rostos vizinhos necessário para um ponto central do DBSCAN.", + "Faces whose bounding box width or height is smaller than this value are skipped.": "Rostos cuja caixa delimitadora tenha largura ou altura inferior a este valor são ignorados.", + "No images": "Sem imagens", + "People": "Pessoas", + "ID": "ID", + "Name": "Nome", + "Name, notes, and tags are shown here.": "O nome, notas e etiquetas aparecem aqui.", + "Threshold": "Limiar", + "This application runs locally. Code and model licenses may differ. Research models may be limited to non-commercial use. Commercial deployment requires appropriate model license. This tool does not provide legal advice.": "Esta aplicação é executada localmente. As licenças do código e dos modelos podem diferir. Modelos de investigação podem estar limitados a uso não comercial. A implantação comercial requer uma licença de modelo adequada. Esta ferramenta não fornece aconselhamento jurídico.", + "CUDA is unavailable on this machine, so Auto will use CPU.": "CUDA não está disponível nesta máquina, por isso Automático usará CPU.", + "Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.": "Automático usa CUDA quando CUDAExecutionProvider está disponível; caso contrário usa CPU.", + "CUDAExecutionProvider is available.": "CUDAExecutionProvider está disponível.", + "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first.": "CUDAExecutionProvider não está disponível. Instale primeiro onnxruntime-gpu compatível, runtime CUDA e driver GPU.", + "No downloaded swap models": "Não há modelos de troca de rostos transferidos", + "Only downloaded swap models are shown.": "Só são mostrados modelos de troca de rostos transferidos.", + "Download inswapper_128.onnx from Models > Downloads first.": "Transfira primeiro inswapper_128.onnx em Models > Downloads.", + "No downloaded GFPGAN models": "Não há modelos GFPGAN transferidos", + "Only downloaded GFPGAN restore models are shown.": "Só são mostrados modelos GFPGAN de restauro transferidos.", + "Download GFPGANv1.4.onnx from Models > Downloads first.": "Transfira primeiro GFPGANv1.4.onnx em Models > Downloads.", + "GFPGAN is unavailable until a GFPGAN model is downloaded.": "GFPGAN fica indisponível até transferir um modelo GFPGAN.", + "Run GFPGAN face restoration after face swap.": "Executar restauro facial GFPGAN após a troca de rostos.", + "Enable GFPGAN restore after face swap": "Ativar restauro GFPGAN após troca de rostos", + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image.": "Seleciona automaticamente a imagem de galeria de cada identidade a partir de um ficheiro que contenha “gallery”, ou da primeira imagem ordenada.", + "Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.": "Abre as regras detalhadas de pastas de identidade para 1:1, 1:N e Divisão automática.", + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help.": "Abrir a página de contacto da InsightFace para avaliação empresarial, licenciamento, SDK/API, SLA ou treino personalizado.", + "Evaluation Dataset Rules": "Regras do dataset de avaliação", + "Prepare local identity folders using one of the supported layouts below.": "Prepare pastas locais de identidade usando uma das estruturas suportadas abaixo.", + "Validate the dataset before running an evaluation.": "Valide o dataset antes de executar uma avaliação.", + "Validate the selected dataset and configuration before running evaluation.": "Valide o dataset e a configuração selecionados antes de executar a avaliação.", + "Result preview appears here. Video results are saved to the exports folder.": "A pré-visualização do resultado aparece aqui. Os resultados de vídeo são guardados na pasta de exportações.", + "Min det score %": "Pontuação mínima de deteção %", + "asset": "recurso", + "source": "origem", + "kind": "tipo", + "release": "versão", + "size": "tamanho", + "updated_at": "atualizado", + "local status": "estado local", + "download url": "URL de transferência", + "rank": "classificação", + "thumbnail": "miniatura", + "gallery_file": "ficheiro da galeria", + "similarity": "similaridade", + "threshold": "limiar", + "decision": "decisão", + "det_score": "pontuação de deteção", + "person_id": "ID da pessoa", + "person_name": "nome da pessoa", + "status": "estado", + "sample_id": "ID da amostra", + "crop_path": "caminho do recorte", + "image_path": "caminho da imagem", + "face_index": "índice do rosto", + "bbox": "caixa", + "video_path": "caminho do vídeo", + "timestamp_ms": "timestamp ms", + "timestamp_hhmmss": "hora", + "frame_index": "índice do fotograma", + "id": "ID", + "date": "data", + "scenario": "cenário", + "model": "modelo", + "provider": "fornecedor", + "report_path": "caminho do relatório", + "quality_score": "pontuação de qualidade", + "cluster_id": "ID do cluster", + "face_count": "rostos", + "photo_count": "fotos", + "average_quality": "qualidade média", + "sample_paths": "caminhos das amostras", + "model_name": "nome do modelo", + "source_image_path": "caminho da imagem de origem", + }, + "ru": { + "Browse": "Обзор", + "InsightFace Evaluation Studio": "InsightFace Evaluation Studio", + "custom model directory": "пользовательский каталог модели", + "Custom model directory": "Пользовательский каталог модели", + "Auto": "Авто", + "Browse": "Обзор", + "Add Person": "Добавить человека", + "Add as New Person": "Добавить как нового человека", + "Assign to Existing Person": "Назначить существующему человеку", + "Compare": "Сравнить", + "Search": "Поиск", + "Export": "Экспорт", + "Export Result": "Экспорт результата", + "Export Results": "Экспорт результатов", + "Export Summary": "Экспорт сводки", + "Export Settings": "Экспорт настроек", + "Import Settings": "Импорт настроек", + "Delete": "Удалить", + "Delete Selected": "Удалить выбранное", + "Reset": "Сброс", + "Reset Settings": "Сбросить настройки", + "Refresh": "Обновить", + "Start": "Старт", + "Stop": "Стоп", + "Open": "Открыть", + "Save Settings": "Сохранить настройки", + "Save Details": "Сохранить детали", + "Save crops": "Сохранять кадры", + "Save face crops": "Сохранять кадры лиц", + "Save recognition logs": "Сохранять журналы распознавания", + "Anonymize report paths": "Анонимизировать пути в отчётах", + "Privacy": "Конфиденциальность", + "Recursive": "Рекурсивно", + "Identify people": "Идентифицировать людей", + "Camera index": "Индекс камеры", + "Frame skip": "Пропуск кадров", + "Frame interval": "Интервал кадров", + "Target person": "Целевая персона", + "Check Cameras": "Проверить камеры", + "Register Current Face": "Зарегистрировать текущее лицо", + "Refresh People": "Обновить людей", + "Recognize Faces": "Распознать лица", + "Test Model Load": "Проверить загрузку модели", + "Warmup": "Прогрев", + "Export Annotated Image": "Экспортировать размеченное изображение", + "Export CSV": "Экспорт CSV", + "Export CSV / JSON": "Экспорт CSV / JSON", + "Refresh Download URLs": "Обновить URL загрузки", + "Download Selected": "Загрузить выбранное", + "Use Selected Model": "Использовать выбранную модель", + "Open Model Folder": "Открыть папку моделей", + "Open GitHub Releases": "Открыть GitHub Releases", + "Open Model Downloads": "Открыть загрузки моделей", + "Open License Center": "Открыть центр лицензий", + "Open Reports": "Открыть отчёты", + "Open Selected Report": "Открыть выбранный отчёт", + "Re-export Selected": "Переэкспортировать выбранное", + "Export All Summary": "Экспорт общей сводки", + "Import Image or Folder": "Импортировать изображение или папку", + "Select Image": "Выбрать изображение", + "Select Folder": "Выбрать папку", + "Select gallery images or folders": "Выбрать изображения или папки галереи", + "Select one or more image files or folders. Folders are scanned recursively.": "Выберите один или несколько файлов изображений или папок. Папки сканируются рекурсивно.", + "Click to import an image or folder, or drag one here. Folders are imported recursively.": "Нажмите для импорта изображения или папки либо перетащите сюда. Папки импортируются рекурсивно.", + "Click to upload images or a folder, or drag them here": "Нажмите для загрузки изображений или папки либо перетащите их сюда", + "Drag one or more album folders here, or use Add Folder.": "Перетащите сюда одну или несколько папок альбома либо используйте «Добавить папку».", + "Drag album folders into the directory list, or click Add Folder.": "Перетащите папки альбома в список каталогов или нажмите «Добавить папку».", + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. DBSCAN internally uses cosine distance = 1 - cosine threshold.": "Косинусный порог задаёт отсечку сходства лиц: чем выше значение, тем строже кластеры. DBSCAN внутренне использует косинусную дистанцию = 1 - косинусный порог.", + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48.": "Порог косинусного сходства. Более высокие значения делают кластеры строже; значение по умолчанию 0,48.", + "DBSCAN distance threshold": "Порог дистанции DBSCAN", + "Algorithm: DBSCAN": "Алгоритм: DBSCAN", + "Scan and Cluster": "Сканировать и кластеризовать", + "Minimum neighboring faces needed for a DBSCAN core point.": "Минимальное число соседних лиц для ядровой точки DBSCAN.", + "Faces whose bounding box width or height is smaller than this value are skipped.": "Лица, ширина или высота рамки которых меньше этого значения, пропускаются.", + "No images": "Нет изображений", + "People": "Люди", + "ID": "ID", + "Name": "Имя", + "Name, notes, and tags are shown here.": "Здесь отображаются имя, заметки и теги.", + "Threshold": "Порог", + "This application runs locally. Code and model licenses may differ. Research models may be limited to non-commercial use. Commercial deployment requires appropriate model license. This tool does not provide legal advice.": "Это приложение работает локально. Лицензии кода и моделей могут различаться. Исследовательские модели могут быть ограничены некоммерческим использованием. Коммерческое развертывание требует соответствующей лицензии на модель. Этот инструмент не предоставляет юридических консультаций.", + "CUDA is unavailable on this machine, so Auto will use CPU.": "CUDA недоступна на этом компьютере, поэтому Авто будет использовать CPU.", + "Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.": "Авто использует CUDA, когда доступен CUDAExecutionProvider, иначе CPU.", + "CUDAExecutionProvider is available.": "CUDAExecutionProvider доступен.", + "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first.": "CUDAExecutionProvider недоступен. Сначала установите совместимые onnxruntime-gpu, CUDA runtime и драйвер GPU.", + "No downloaded swap models": "Нет загруженных моделей замены лиц", + "Only downloaded swap models are shown.": "Показаны только загруженные модели замены лиц.", + "Download inswapper_128.onnx from Models > Downloads first.": "Сначала загрузите inswapper_128.onnx в Models > Downloads.", + "No downloaded GFPGAN models": "Нет загруженных моделей GFPGAN", + "Only downloaded GFPGAN restore models are shown.": "Показаны только загруженные модели восстановления GFPGAN.", + "Download GFPGANv1.4.onnx from Models > Downloads first.": "Сначала загрузите GFPGANv1.4.onnx в Models > Downloads.", + "GFPGAN is unavailable until a GFPGAN model is downloaded.": "GFPGAN недоступен, пока модель GFPGAN не загружена.", + "Run GFPGAN face restoration after face swap.": "Запускать восстановление лиц GFPGAN после замены лиц.", + "Enable GFPGAN restore after face swap": "Включить восстановление GFPGAN после замены лиц", + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image.": "Автоматически выбирает галерейное изображение каждой идентичности из файла с «gallery» в имени или первое изображение по сортировке.", + "Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.": "Открыть подробные правила папок идентичностей для 1:1, 1:N и авторазделения.", + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help.": "Открыть страницу контактов InsightFace для корпоративной оценки, лицензирования, SDK/API, SLA или индивидуального обучения.", + "Evaluation Dataset Rules": "Правила датасета оценки", + "Prepare local identity folders using one of the supported layouts below.": "Подготовьте локальные папки идентичностей в одной из поддерживаемых структур ниже.", + "Validate the dataset before running an evaluation.": "Проверьте датасет перед запуском оценки.", + "Validate the selected dataset and configuration before running evaluation.": "Проверьте выбранный датасет и конфигурацию перед запуском оценки.", + "Result preview appears here. Video results are saved to the exports folder.": "Предпросмотр результата появится здесь. Видео сохраняются в папку экспорта.", + "Min det score %": "Мин. score детекции %", + "asset": "ресурс", + "source": "источник", + "kind": "тип", + "release": "релиз", + "size": "размер", + "updated_at": "обновлено", + "local status": "локальный статус", + "download url": "URL загрузки", + "rank": "ранг", + "thumbnail": "миниатюра", + "gallery_file": "файл галереи", + "similarity": "сходство", + "threshold": "порог", + "decision": "решение", + "det_score": "score детекции", + "person_id": "ID человека", + "person_name": "имя человека", + "status": "статус", + "sample_id": "ID образца", + "crop_path": "путь кадра", + "image_path": "путь изображения", + "face_index": "индекс лица", + "bbox": "рамка", + "video_path": "путь видео", + "timestamp_ms": "временная метка ms", + "timestamp_hhmmss": "время", + "frame_index": "индекс кадра", + "id": "ID", + "date": "дата", + "scenario": "сценарий", + "model": "модель", + "provider": "провайдер", + "report_path": "путь отчёта", + "quality_score": "score качества", + "cluster_id": "ID кластера", + "face_count": "лиц", + "photo_count": "фото", + "average_quality": "среднее качество", + "sample_paths": "пути образцов", + "model_name": "имя модели", + "source_image_path": "путь исходного изображения", + }, +} + +for _lang, _values in _ADDITIONAL_UI_TRANSLATIONS.items(): + _TRANSLATIONS.setdefault(_lang, {}).update(_values) + + +_DYNAMIC_UI_TRANSLATIONS: dict[str, dict[str, str]] = { + "zh": { + "Click to upload or drag a file here": "点击上传,或将文件拖到这里", + "Drop another file to replace it": "拖入另一个文件可替换当前文件", + "Click or drag more images or folders to add to Gallery.": "点击或继续拖入图片/文件夹以添加到 Gallery。", + "Image swap saved. Click Result to open it.": "图片换脸结果已保存。点击结果区域可打开文件。", + "Video swap saved. Click Result to open it.": "视频换脸结果已保存。点击结果区域可打开文件。", + "image": "image", + "images": "images", + }, + "ja": { + "Click to upload or drag a file here": "クリックしてアップロードするか、ファイルをここにドラッグしてください", + "Drop another file to replace it": "別のファイルをドロップすると置き換えられます", + "Click or drag more images or folders to add to Gallery.": "クリックするか画像/フォルダをさらにドラッグしてギャラリーに追加します。", + "Image swap saved. Click Result to open it.": "画像の顔交換結果を保存しました。結果エリアをクリックして開けます。", + "Video swap saved. Click Result to open it.": "動画の顔交換結果を保存しました。結果エリアをクリックして開けます。", + "image": "画像", + "images": "画像", + }, + "ko": { + "Click to upload or drag a file here": "클릭하여 업로드하거나 파일을 여기로 끌어오십시오", + "Drop another file to replace it": "다른 파일을 놓으면 현재 파일을 교체합니다", + "Click or drag more images or folders to add to Gallery.": "클릭하거나 이미지/폴더를 더 끌어와 Gallery에 추가하십시오.", + "Image swap saved. Click Result to open it.": "이미지 얼굴 교체 결과가 저장되었습니다. 결과 영역을 클릭하면 열 수 있습니다.", + "Video swap saved. Click Result to open it.": "비디오 얼굴 교체 결과가 저장되었습니다. 결과 영역을 클릭하면 열 수 있습니다.", + "image": "이미지", + "images": "이미지", + }, + "es": { + "Click to upload or drag a file here": "Haga clic para subir un archivo o arrástrelo aquí", + "Drop another file to replace it": "Suelte otro archivo para reemplazarlo", + "Click or drag more images or folders to add to Gallery.": "Haga clic o arrastre más imágenes o carpetas para añadirlas a la galería.", + "Image swap saved. Click Result to open it.": "Intercambio de imagen guardado. Haga clic en el área de resultado para abrirlo.", + "Video swap saved. Click Result to open it.": "Intercambio de vídeo guardado. Haga clic en el área de resultado para abrirlo.", + "image": "imagen", + "images": "imágenes", + }, + "fr": { + "Click to upload or drag a file here": "Cliquez pour charger un fichier ou faites-le glisser ici", + "Drop another file to replace it": "Déposez un autre fichier pour le remplacer", + "Click or drag more images or folders to add to Gallery.": "Cliquez ou faites glisser d’autres images ou dossiers pour les ajouter à la galerie.", + "Image swap saved. Click Result to open it.": "Face swap d’image enregistré. Cliquez sur la zone de résultat pour l’ouvrir.", + "Video swap saved. Click Result to open it.": "Face swap vidéo enregistré. Cliquez sur la zone de résultat pour l’ouvrir.", + "image": "image", + "images": "images", + }, + "de": { + "Click to upload or drag a file here": "Klicken Sie zum Hochladen oder ziehen Sie eine Datei hierher", + "Drop another file to replace it": "Legen Sie eine andere Datei ab, um sie zu ersetzen", + "Click or drag more images or folders to add to Gallery.": "Klicken oder ziehen Sie weitere Bilder oder Ordner hierher, um sie zur Galerie hinzuzufügen.", + "Image swap saved. Click Result to open it.": "Bild-Face-Swap gespeichert. Klicken Sie auf den Ergebnisbereich, um ihn zu öffnen.", + "Video swap saved. Click Result to open it.": "Video-Face-Swap gespeichert. Klicken Sie auf den Ergebnisbereich, um ihn zu öffnen.", + "image": "Bild", + "images": "Bilder", + }, + "pt": { + "Click to upload or drag a file here": "Clique para carregar um ficheiro ou arraste-o para aqui", + "Drop another file to replace it": "Largue outro ficheiro para substituir", + "Click or drag more images or folders to add to Gallery.": "Clique ou arraste mais imagens ou pastas para adicionar à galeria.", + "Image swap saved. Click Result to open it.": "Troca de rosto em imagem guardada. Clique na área de resultado para abrir.", + "Video swap saved. Click Result to open it.": "Troca de rosto em vídeo guardada. Clique na área de resultado para abrir.", + "image": "imagem", + "images": "imagens", + }, + "ru": { + "Click to upload or drag a file here": "Нажмите для загрузки файла или перетащите его сюда", + "Drop another file to replace it": "Перетащите другой файл, чтобы заменить текущий", + "Click or drag more images or folders to add to Gallery.": "Нажмите или перетащите дополнительные изображения/папки, чтобы добавить их в галерею.", + "Image swap saved. Click Result to open it.": "Результат замены лиц на изображении сохранён. Нажмите область результата, чтобы открыть его.", + "Video swap saved. Click Result to open it.": "Результат замены лиц в видео сохранён. Нажмите область результата, чтобы открыть его.", + "image": "изображение", + "images": "изображений", + }, +} + +for _lang, _values in _DYNAMIC_UI_TRANSLATIONS.items(): + _TRANSLATIONS.setdefault(_lang, {}).update(_values) + + +_STATUS_ERROR_TRANSLATIONS: dict[str, dict[str, str]] = { + "zh": { + "Select album folder": "选择相册文件夹", + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?": "当前没有选择相册目录。全部重建将清空已保存的相册聚类结果。是否继续?", + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?": "全部重建会重新处理所选相册目录中的每张图片,并替换已保存的聚类结果。是否继续?", + "Model is not loaded. Please open Models.": "模型尚未加载。请打开 Models。", + "Image read failure.": "图片读取失败。", + "Please upload a query image.": "请上传查询图片。", + "Please upload one or more gallery images or folders.": "请上传一个或多个 Gallery 图片或文件夹。", + "Please select identity folders or a dataset root.": "请选择身份文件夹或数据集根目录。", + "Please validate this dataset and configuration before running evaluation.": "请先核验该数据集和配置,再运行评测。", + "Run an evaluation first.": "请先运行一次评测。", + "PDF export is unavailable. Please install reportlab.": "PDF 导出不可用。请安装 reportlab。", + "Select a source image first.": "请先选择源图。", + "Select a target image or video first.": "请先选择目标图片或视频。", + "Face swap model not found. Please download and choose a swap model in Models.": "未找到换脸模型。请在 Models 中下载并选择换脸模型。", + "Unsupported target file type.": "不支持的目标文件类型。", + "No saved result file to open.": "没有可打开的已保存结果文件。", + "Add one or more album directories first.": "请先添加一个或多个相册目录。", + "No supported images found in the selected directories.": "所选目录中没有找到支持的图片。", + "Select a model asset first.": "请先选择一个模型资源。", + "Selected asset cannot be used as a model package.": "所选资源不能作为模型包使用。", + "Model settings saved.": "模型设置已保存。", + "Model loaded successfully.": "模型加载成功。", + "Model loaded.": "模型已加载。", + "Cleared.": "已清空。", + "Multi-face handling changed. Gallery embeddings will be recomputed.": "多人脸处理策略已更改,Gallery 特征将重新计算。", + "Dataset validation passed.": "数据集核验通过。", + "Dataset validation failed.": "数据集核验失败。", + "Album directories cleared. Existing clustering results are still available.": "相册目录已清空。已有聚类结果仍可查看。", + "Saved album clustering results were cleared.": "已保存的相册聚类结果已清空。", + "Opened InsightFace homepage.": "已打开 InsightFace 主页。", + "Opened InsightFace enterprise contact page.": "已打开 InsightFace 企业联系页面。", + }, + "ja": { + "Select album folder": "アルバムフォルダを選択", + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?": "アルバムディレクトリが選択されていません。すべて再構築すると保存済みのクラスタリング結果が消去されます。続行しますか?", + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?": "すべて再構築すると、選択したアルバムディレクトリ内の全画像を再処理し、保存済みのクラスタリング結果を置き換えます。続行しますか?", + "Model is not loaded. Please open Models.": "モデルが読み込まれていません。Models を開いてください。", + "Image read failure.": "画像の読み込みに失敗しました。", + "Please upload a query image.": "クエリ画像をアップロードしてください。", + "Please upload one or more gallery images or folders.": "1つ以上のギャラリー画像またはフォルダをアップロードしてください。", + "Please select identity folders or a dataset root.": "IDフォルダまたはデータセットルートを選択してください。", + "Please validate this dataset and configuration before running evaluation.": "評価を実行する前に、このデータセットと設定を検証してください。", + "Run an evaluation first.": "先に評価を実行してください。", + "PDF export is unavailable. Please install reportlab.": "PDF 出力は利用できません。reportlab をインストールしてください。", + "Select a source image first.": "先にソース画像を選択してください。", + "Select a target image or video first.": "先にターゲット画像または動画を選択してください。", + "Face swap model not found. Please download and choose a swap model in Models.": "顔交換モデルが見つかりません。Models でモデルをダウンロードして選択してください。", + "Unsupported target file type.": "サポートされていないターゲットファイル形式です。", + "No saved result file to open.": "開ける保存済み結果ファイルがありません。", + "Add one or more album directories first.": "先に1つ以上のアルバムディレクトリを追加してください。", + "No supported images found in the selected directories.": "選択したディレクトリに対応画像が見つかりません。", + "Select a model asset first.": "先にモデルアセットを選択してください。", + "Selected asset cannot be used as a model package.": "選択したアセットはモデルパッケージとして使用できません。", + "Model settings saved.": "モデル設定を保存しました。", + "Model loaded successfully.": "モデルを正常に読み込みました。", + "Model loaded.": "モデルを読み込みました。", + "Cleared.": "クリアしました。", + "Multi-face handling changed. Gallery embeddings will be recomputed.": "複数顔の処理方法が変更されました。ギャラリー特徴量を再計算します。", + "Dataset validation passed.": "データセット検証に合格しました。", + "Dataset validation failed.": "データセット検証に失敗しました。", + "Album directories cleared. Existing clustering results are still available.": "アルバムディレクトリをクリアしました。既存のクラスタリング結果は引き続き利用できます。", + "Saved album clustering results were cleared.": "保存済みのアルバムクラスタリング結果を消去しました。", + "Opened InsightFace homepage.": "InsightFace ホームページを開きました。", + "Opened InsightFace enterprise contact page.": "InsightFace 企業向けお問い合わせページを開きました。", + }, + "ko": { + "Select album folder": "앨범 폴더 선택", + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?": "선택된 앨범 디렉터리가 없습니다. 전체 재빌드는 저장된 앨범 클러스터링 결과를 지웁니다. 계속하시겠습니까?", + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?": "전체 재빌드는 선택한 앨범 디렉터리의 모든 이미지를 다시 처리하고 저장된 클러스터링 결과를 교체합니다. 계속하시겠습니까?", + "Model is not loaded. Please open Models.": "모델이 로드되지 않았습니다. Models를 여십시오.", + "Image read failure.": "이미지를 읽지 못했습니다.", + "Please upload a query image.": "쿼리 이미지를 업로드하십시오.", + "Please upload one or more gallery images or folders.": "하나 이상의 갤러리 이미지 또는 폴더를 업로드하십시오.", + "Please select identity folders or a dataset root.": "ID 폴더 또는 데이터셋 루트를 선택하십시오.", + "Please validate this dataset and configuration before running evaluation.": "평가 실행 전에 이 데이터셋과 구성을 검증하십시오.", + "Run an evaluation first.": "먼저 평가를 실행하십시오.", + "PDF export is unavailable. Please install reportlab.": "PDF 내보내기를 사용할 수 없습니다. reportlab을 설치하십시오.", + "Select a source image first.": "먼저 소스 이미지를 선택하십시오.", + "Select a target image or video first.": "먼저 대상 이미지 또는 비디오를 선택하십시오.", + "Face swap model not found. Please download and choose a swap model in Models.": "얼굴 교체 모델을 찾을 수 없습니다. Models에서 모델을 다운로드하고 선택하십시오.", + "Unsupported target file type.": "지원되지 않는 대상 파일 형식입니다.", + "No saved result file to open.": "열 수 있는 저장된 결과 파일이 없습니다.", + "Add one or more album directories first.": "먼저 하나 이상의 앨범 디렉터리를 추가하십시오.", + "No supported images found in the selected directories.": "선택한 디렉터리에서 지원되는 이미지를 찾지 못했습니다.", + "Select a model asset first.": "먼저 모델 자산을 선택하십시오.", + "Selected asset cannot be used as a model package.": "선택한 자산은 모델 패키지로 사용할 수 없습니다.", + "Model settings saved.": "모델 설정이 저장되었습니다.", + "Model loaded successfully.": "모델을 성공적으로 로드했습니다.", + "Model loaded.": "모델이 로드되었습니다.", + "Cleared.": "지웠습니다.", + "Multi-face handling changed. Gallery embeddings will be recomputed.": "다중 얼굴 처리 방식이 변경되었습니다. Gallery 임베딩을 다시 계산합니다.", + "Dataset validation passed.": "데이터셋 검증을 통과했습니다.", + "Dataset validation failed.": "데이터셋 검증에 실패했습니다.", + "Album directories cleared. Existing clustering results are still available.": "앨범 디렉터리가 지워졌습니다. 기존 클러스터링 결과는 계속 사용할 수 있습니다.", + "Saved album clustering results were cleared.": "저장된 앨범 클러스터링 결과가 지워졌습니다.", + "Opened InsightFace homepage.": "InsightFace 홈페이지를 열었습니다.", + "Opened InsightFace enterprise contact page.": "InsightFace 기업 문의 페이지를 열었습니다.", + }, + "es": { + "Select album folder": "Seleccionar carpeta de álbum", + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?": "No hay directorios de álbum seleccionados. Rebuild All borrará los resultados de agrupación guardados. ¿Continuar?", + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?": "Rebuild All reprocesará todas las imágenes de los directorios seleccionados y reemplazará los resultados guardados. ¿Continuar?", + "Model is not loaded. Please open Models.": "El modelo no está cargado. Abra Models.", + "Image read failure.": "Error al leer la imagen.", + "Please upload a query image.": "Suba una imagen de consulta.", + "Please upload one or more gallery images or folders.": "Suba una o más imágenes o carpetas de galería.", + "Please select identity folders or a dataset root.": "Seleccione carpetas de identidad o la raíz de un dataset.", + "Please validate this dataset and configuration before running evaluation.": "Valide este dataset y configuración antes de ejecutar la evaluación.", + "Run an evaluation first.": "Ejecute primero una evaluación.", + "PDF export is unavailable. Please install reportlab.": "La exportación PDF no está disponible. Instale reportlab.", + "Select a source image first.": "Seleccione primero una imagen fuente.", + "Select a target image or video first.": "Seleccione primero una imagen o vídeo de destino.", + "Face swap model not found. Please download and choose a swap model in Models.": "No se encontró el modelo de intercambio facial. Descárguelo y selecciónelo en Models.", + "Unsupported target file type.": "Tipo de archivo de destino no compatible.", + "No saved result file to open.": "No hay archivo de resultado guardado para abrir.", + "Add one or more album directories first.": "Añada primero uno o más directorios de álbum.", + "No supported images found in the selected directories.": "No se encontraron imágenes compatibles en los directorios seleccionados.", + "Select a model asset first.": "Seleccione primero un recurso de modelo.", + "Selected asset cannot be used as a model package.": "El recurso seleccionado no puede usarse como paquete de modelo.", + "Model settings saved.": "Configuración del modelo guardada.", + "Model loaded successfully.": "Modelo cargado correctamente.", + "Model loaded.": "Modelo cargado.", + "Cleared.": "Borrado.", + "Multi-face handling changed. Gallery embeddings will be recomputed.": "Cambió el manejo de múltiples rostros. Se recalcularán los embeddings de la galería.", + "Dataset validation passed.": "Validación del dataset superada.", + "Dataset validation failed.": "Validación del dataset fallida.", + "Album directories cleared. Existing clustering results are still available.": "Directorios de álbum borrados. Los resultados de agrupación existentes siguen disponibles.", + "Saved album clustering results were cleared.": "Se borraron los resultados de agrupación guardados.", + "Opened InsightFace homepage.": "Página principal de InsightFace abierta.", + "Opened InsightFace enterprise contact page.": "Página de contacto empresarial de InsightFace abierta.", + }, + "fr": { + "Select album folder": "Sélectionner un dossier d’album", + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?": "Aucun dossier d’album n’est sélectionné. Rebuild All effacera les résultats de clustering enregistrés. Continuer ?", + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?": "Rebuild All retraitera toutes les images des dossiers sélectionnés et remplacera les résultats enregistrés. Continuer ?", + "Model is not loaded. Please open Models.": "Le modèle n’est pas chargé. Ouvrez Models.", + "Image read failure.": "Échec de lecture de l’image.", + "Please upload a query image.": "Chargez une image de requête.", + "Please upload one or more gallery images or folders.": "Chargez une ou plusieurs images ou dossiers de galerie.", + "Please select identity folders or a dataset root.": "Sélectionnez des dossiers d’identité ou la racine d’un jeu de données.", + "Please validate this dataset and configuration before running evaluation.": "Validez ce jeu de données et cette configuration avant l’évaluation.", + "Run an evaluation first.": "Lancez d’abord une évaluation.", + "PDF export is unavailable. Please install reportlab.": "L’export PDF est indisponible. Installez reportlab.", + "Select a source image first.": "Sélectionnez d’abord une image source.", + "Select a target image or video first.": "Sélectionnez d’abord une image ou vidéo cible.", + "Face swap model not found. Please download and choose a swap model in Models.": "Modèle de face swap introuvable. Téléchargez et choisissez un modèle dans Models.", + "Unsupported target file type.": "Type de fichier cible non pris en charge.", + "No saved result file to open.": "Aucun fichier de résultat enregistré à ouvrir.", + "Add one or more album directories first.": "Ajoutez d’abord un ou plusieurs dossiers d’album.", + "No supported images found in the selected directories.": "Aucune image prise en charge trouvée dans les dossiers sélectionnés.", + "Select a model asset first.": "Sélectionnez d’abord une ressource de modèle.", + "Selected asset cannot be used as a model package.": "La ressource sélectionnée ne peut pas être utilisée comme package de modèle.", + "Model settings saved.": "Paramètres du modèle enregistrés.", + "Model loaded successfully.": "Modèle chargé avec succès.", + "Model loaded.": "Modèle chargé.", + "Cleared.": "Effacé.", + "Multi-face handling changed. Gallery embeddings will be recomputed.": "La gestion multi-visages a changé. Les embeddings de galerie seront recalculés.", + "Dataset validation passed.": "Validation du jeu de données réussie.", + "Dataset validation failed.": "Validation du jeu de données échouée.", + "Album directories cleared. Existing clustering results are still available.": "Dossiers d’album effacés. Les résultats de clustering existants restent disponibles.", + "Saved album clustering results were cleared.": "Les résultats de clustering enregistrés ont été effacés.", + "Opened InsightFace homepage.": "Page d’accueil InsightFace ouverte.", + "Opened InsightFace enterprise contact page.": "Page de contact entreprise InsightFace ouverte.", + }, + "de": { + "Select album folder": "Albumordner auswählen", + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?": "Es sind keine Albumordner ausgewählt. Rebuild All löscht gespeicherte Clustering-Ergebnisse. Fortfahren?", + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?": "Rebuild All verarbeitet jedes Bild in den ausgewählten Albumordnern erneut und ersetzt gespeicherte Clustering-Ergebnisse. Fortfahren?", + "Model is not loaded. Please open Models.": "Das Modell ist nicht geladen. Öffnen Sie Models.", + "Image read failure.": "Bild konnte nicht gelesen werden.", + "Please upload a query image.": "Laden Sie ein Abfragebild hoch.", + "Please upload one or more gallery images or folders.": "Laden Sie ein oder mehrere Galeriebilder oder Ordner hoch.", + "Please select identity folders or a dataset root.": "Wählen Sie Identitätsordner oder eine Datensatzwurzel aus.", + "Please validate this dataset and configuration before running evaluation.": "Validieren Sie diesen Datensatz und die Konfiguration vor der Evaluierung.", + "Run an evaluation first.": "Führen Sie zuerst eine Evaluierung aus.", + "PDF export is unavailable. Please install reportlab.": "PDF-Export ist nicht verfügbar. Installieren Sie reportlab.", + "Select a source image first.": "Wählen Sie zuerst ein Quellbild aus.", + "Select a target image or video first.": "Wählen Sie zuerst ein Zielbild oder Video aus.", + "Face swap model not found. Please download and choose a swap model in Models.": "Face-Swap-Modell nicht gefunden. Laden Sie in Models ein Modell herunter und wählen Sie es aus.", + "Unsupported target file type.": "Nicht unterstützter Zieldateityp.", + "No saved result file to open.": "Keine gespeicherte Ergebnisdatei zum Öffnen.", + "Add one or more album directories first.": "Fügen Sie zuerst einen oder mehrere Albumordner hinzu.", + "No supported images found in the selected directories.": "In den ausgewählten Ordnern wurden keine unterstützten Bilder gefunden.", + "Select a model asset first.": "Wählen Sie zuerst ein Modell-Asset aus.", + "Selected asset cannot be used as a model package.": "Das ausgewählte Asset kann nicht als Modellpaket verwendet werden.", + "Model settings saved.": "Modelleinstellungen gespeichert.", + "Model loaded successfully.": "Modell erfolgreich geladen.", + "Model loaded.": "Modell geladen.", + "Cleared.": "Geleert.", + "Multi-face handling changed. Gallery embeddings will be recomputed.": "Die Mehrgesicht-Verarbeitung wurde geändert. Galerie-Embeddings werden neu berechnet.", + "Dataset validation passed.": "Datensatzvalidierung bestanden.", + "Dataset validation failed.": "Datensatzvalidierung fehlgeschlagen.", + "Album directories cleared. Existing clustering results are still available.": "Albumordner geleert. Bestehende Clustering-Ergebnisse bleiben verfügbar.", + "Saved album clustering results were cleared.": "Gespeicherte Album-Clustering-Ergebnisse wurden gelöscht.", + "Opened InsightFace homepage.": "InsightFace-Homepage geöffnet.", + "Opened InsightFace enterprise contact page.": "InsightFace-Kontaktseite für Unternehmen geöffnet.", + }, + "pt": { + "Select album folder": "Selecionar pasta de álbum", + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?": "Não há diretórios de álbum selecionados. Rebuild All irá limpar os resultados de clustering guardados. Continuar?", + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?": "Rebuild All irá reprocessar todas as imagens nos diretórios selecionados e substituir os resultados guardados. Continuar?", + "Model is not loaded. Please open Models.": "O modelo não está carregado. Abra Models.", + "Image read failure.": "Falha ao ler a imagem.", + "Please upload a query image.": "Carregue uma imagem de consulta.", + "Please upload one or more gallery images or folders.": "Carregue uma ou mais imagens ou pastas da galeria.", + "Please select identity folders or a dataset root.": "Selecione pastas de identidade ou a raiz de um dataset.", + "Please validate this dataset and configuration before running evaluation.": "Valide este dataset e configuração antes de executar a avaliação.", + "Run an evaluation first.": "Execute primeiro uma avaliação.", + "PDF export is unavailable. Please install reportlab.": "A exportação PDF não está disponível. Instale reportlab.", + "Select a source image first.": "Selecione primeiro uma imagem de origem.", + "Select a target image or video first.": "Selecione primeiro uma imagem ou vídeo de destino.", + "Face swap model not found. Please download and choose a swap model in Models.": "Modelo de troca de rostos não encontrado. Transfira e escolha um modelo em Models.", + "Unsupported target file type.": "Tipo de ficheiro de destino não suportado.", + "No saved result file to open.": "Não há ficheiro de resultado guardado para abrir.", + "Add one or more album directories first.": "Adicione primeiro um ou mais diretórios de álbum.", + "No supported images found in the selected directories.": "Não foram encontradas imagens suportadas nos diretórios selecionados.", + "Select a model asset first.": "Selecione primeiro um recurso de modelo.", + "Selected asset cannot be used as a model package.": "O recurso selecionado não pode ser usado como pacote de modelo.", + "Model settings saved.": "Definições do modelo guardadas.", + "Model loaded successfully.": "Modelo carregado com sucesso.", + "Model loaded.": "Modelo carregado.", + "Cleared.": "Limpo.", + "Multi-face handling changed. Gallery embeddings will be recomputed.": "O tratamento de múltiplos rostos mudou. Os embeddings da galeria serão recalculados.", + "Dataset validation passed.": "Validação do dataset concluída.", + "Dataset validation failed.": "Validação do dataset falhou.", + "Album directories cleared. Existing clustering results are still available.": "Diretórios de álbum limpos. Os resultados de clustering existentes continuam disponíveis.", + "Saved album clustering results were cleared.": "Os resultados de clustering guardados foram limpos.", + "Opened InsightFace homepage.": "Página inicial InsightFace aberta.", + "Opened InsightFace enterprise contact page.": "Página de contacto empresarial InsightFace aberta.", + }, + "ru": { + "Select album folder": "Выбрать папку альбома", + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?": "Папки альбомов не выбраны. Rebuild All очистит сохранённые результаты кластеризации. Продолжить?", + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?": "Rebuild All заново обработает все изображения в выбранных папках и заменит сохранённые результаты кластеризации. Продолжить?", + "Model is not loaded. Please open Models.": "Модель не загружена. Откройте Models.", + "Image read failure.": "Не удалось прочитать изображение.", + "Please upload a query image.": "Загрузите изображение запроса.", + "Please upload one or more gallery images or folders.": "Загрузите одно или несколько изображений/папок галереи.", + "Please select identity folders or a dataset root.": "Выберите папки идентичностей или корень датасета.", + "Please validate this dataset and configuration before running evaluation.": "Проверьте этот датасет и конфигурацию перед запуском оценки.", + "Run an evaluation first.": "Сначала запустите оценку.", + "PDF export is unavailable. Please install reportlab.": "Экспорт PDF недоступен. Установите reportlab.", + "Select a source image first.": "Сначала выберите исходное изображение.", + "Select a target image or video first.": "Сначала выберите целевое изображение или видео.", + "Face swap model not found. Please download and choose a swap model in Models.": "Модель замены лиц не найдена. Загрузите и выберите модель в Models.", + "Unsupported target file type.": "Неподдерживаемый тип целевого файла.", + "No saved result file to open.": "Нет сохранённого файла результата для открытия.", + "Add one or more album directories first.": "Сначала добавьте одну или несколько папок альбомов.", + "No supported images found in the selected directories.": "В выбранных папках не найдены поддерживаемые изображения.", + "Select a model asset first.": "Сначала выберите ресурс модели.", + "Selected asset cannot be used as a model package.": "Выбранный ресурс нельзя использовать как пакет модели.", + "Model settings saved.": "Настройки модели сохранены.", + "Model loaded successfully.": "Модель успешно загружена.", + "Model loaded.": "Модель загружена.", + "Cleared.": "Очищено.", + "Multi-face handling changed. Gallery embeddings will be recomputed.": "Обработка нескольких лиц изменена. Эмбеддинги галереи будут пересчитаны.", + "Dataset validation passed.": "Проверка датасета пройдена.", + "Dataset validation failed.": "Проверка датасета не пройдена.", + "Album directories cleared. Existing clustering results are still available.": "Папки альбомов очищены. Существующие результаты кластеризации всё ещё доступны.", + "Saved album clustering results were cleared.": "Сохранённые результаты кластеризации альбома очищены.", + "Opened InsightFace homepage.": "Домашняя страница InsightFace открыта.", + "Opened InsightFace enterprise contact page.": "Страница контактов InsightFace для предприятий открыта.", + }, +} + +for _lang, _values in _STATUS_ERROR_TRANSLATIONS.items(): + _TRANSLATIONS.setdefault(_lang, {}).update(_values) + + +_PAGE_COPY_TRANSLATIONS: dict[str, dict[str, str]] = { + "zh": { + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.": "导入或刷新本地相册文件夹,对检测到的人脸进行聚类,并查看每个人物组中的照片。", + "All album processing is local. Import / Refresh scans every selected folder, extracts features only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold.": "所有相册处理均在本地完成。导入 / 刷新会扫描每个已选择的文件夹,仅为新增图片提取特征,然后使用所选余弦阈值对全部已索引人脸运行 DBSCAN 聚类。", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.": "上传一张查询图片,以及一张 Gallery 图片、一组图片或一个文件夹。只有一张 Gallery 图片时执行 1:1 比对;多张 Gallery 图片时执行 1:N Gallery 搜索。", + "Configure model packs, execution provider, face swap models, and runtime checks.": "配置模型包、运行后端、换脸模型和运行时检查。", + "Manually refresh GitHub release model URLs and download selected model packages locally.": "手动刷新 GitHub Release 模型下载地址,并将所选模型包下载到本地。", + "Code and model files may have different licenses. Commercial deployment requires appropriate model authorization.": "代码和模型文件可能适用不同授权。商业部署需要相应的模型授权。", + "Refresh source": "刷新来源", + "Local model root": "本地模型根目录", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.": "源图 + 目标 = 结果。目标可以是图片或视频,工作流会自动选择图片换脸或视频换脸。", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "根据使用场景和模型授权,换脸功能可能需要单独的商业授权。请仅在拥有适当权利和同意的情况下使用。", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.": "基于身份文件夹运行本地 1:1 验证或 1:N 识别评测,并导出可用于采购决策的报告。", + }, + "ja": { + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.": "ローカルのアルバムフォルダをインポートまたは更新し、検出された顔をクラスタリングして、各人物グループの写真を確認します。", + "All album processing is local. Import / Refresh scans every selected folder, extracts features only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold.": "すべてのアルバム処理はローカルで実行されます。インポート / 更新では選択された各フォルダをスキャンし、新しい画像のみ特徴量を抽出してから、選択したコサインしきい値で全インデックス済み顔に DBSCAN クラスタリングを実行します。", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.": "1枚のクエリ画像と、ギャラリー画像、画像セット、またはフォルダをアップロードします。ギャラリーが1枚なら 1:1 比較、複数なら 1:N ギャラリー検索を実行します。", + "Configure model packs, execution provider, face swap models, and runtime checks.": "モデルパック、実行プロバイダ、顔交換モデル、ランタイム確認を設定します。", + "Manually refresh GitHub release model URLs and download selected model packages locally.": "GitHub Release のモデル URL を手動で更新し、選択したモデルパッケージをローカルにダウンロードします。", + "Code and model files may have different licenses. Commercial deployment requires appropriate model authorization.": "コードとモデルファイルには異なるライセンスが適用される場合があります。商用展開には適切なモデル認可が必要です。", + "Refresh source": "更新元", + "Local model root": "ローカルモデルルート", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.": "ソース + ターゲット = 結果。ターゲットは画像または動画に対応し、ワークフローが画像または動画の顔交換を自動的に選択します。", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "利用目的やモデルライセンスによっては、顔交換に別途商用許諾が必要になる場合があります。適切な権利と同意がある場合にのみ使用してください。", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.": "IDフォルダからローカルの 1:1 検証または 1:N 識別評価を実行し、調達判断に使えるレポートを出力します。", + }, + "ko": { + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.": "로컬 앨범 폴더를 가져오거나 새로고침하고, 검출된 얼굴을 클러스터링한 뒤 각 사람 그룹의 사진을 검토합니다.", + "All album processing is local. Import / Refresh scans every selected folder, extracts features only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold.": "모든 앨범 처리는 로컬에서 수행됩니다. 가져오기 / 새로고침은 선택한 모든 폴더를 스캔하고 새 이미지에 대해서만 특징을 추출한 다음, 선택한 코사인 임계값으로 모든 인덱싱된 얼굴에 DBSCAN 클러스터링을 실행합니다.", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.": "쿼리 이미지 하나와 갤러리 이미지, 이미지 세트 또는 폴더를 업로드합니다. 갤러리 이미지가 하나이면 1:1 비교를 실행하고, 여러 장이면 1:N 갤러리 검색을 실행합니다.", + "Configure model packs, execution provider, face swap models, and runtime checks.": "모델 패키지, 실행 제공자, 얼굴 교체 모델, 런타임 점검을 구성합니다.", + "Manually refresh GitHub release model URLs and download selected model packages locally.": "GitHub Release 모델 URL을 수동으로 새로고침하고 선택한 모델 패키지를 로컬에 다운로드합니다.", + "Code and model files may have different licenses. Commercial deployment requires appropriate model authorization.": "코드와 모델 파일에는 서로 다른 라이선스가 적용될 수 있습니다. 상용 배포에는 적절한 모델 승인이 필요합니다.", + "Refresh source": "새로고침 소스", + "Local model root": "로컬 모델 루트", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.": "소스 + 타깃 = 결과. 타깃은 이미지 또는 비디오일 수 있으며, 워크플로가 이미지 또는 비디오 얼굴 교체를 자동으로 선택합니다.", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "사용 목적과 모델 라이선스에 따라 얼굴 교체에는 별도의 상업적 허가가 필요할 수 있습니다. 적절한 권리와 동의가 있는 경우에만 사용하십시오.", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.": "ID 폴더에서 로컬 1:1 검증 또는 1:N 식별 평가를 실행하고 구매 검토용 보고서를 내보냅니다.", + }, + "es": { + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.": "Importe o actualice carpetas de álbum locales, agrupe los rostros detectados y revise las fotos de cada grupo de personas.", + "All album processing is local. Import / Refresh scans every selected folder, extracts features only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold.": "Todo el procesamiento del álbum es local. Importar / Actualizar escanea cada carpeta seleccionada, extrae características solo de imágenes nuevas y luego ejecuta DBSCAN sobre todos los rostros indexados con el umbral de coseno seleccionado.", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.": "Suba una imagen de consulta y una imagen de galería, un conjunto de imágenes o una carpeta. Una sola imagen de galería ejecuta comparación 1:1; varias imágenes ejecutan búsqueda 1:N en la galería.", + "Configure model packs, execution provider, face swap models, and runtime checks.": "Configure paquetes de modelos, proveedor de ejecución, modelos de intercambio facial y comprobaciones de runtime.", + "Manually refresh GitHub release model URLs and download selected model packages locally.": "Actualice manualmente las URL de modelos de GitHub Releases y descargue localmente los paquetes seleccionados.", + "Code and model files may have different licenses. Commercial deployment requires appropriate model authorization.": "El código y los archivos de modelo pueden tener licencias diferentes. El despliegue comercial requiere autorización de modelo adecuada.", + "Refresh source": "Fuente de actualización", + "Local model root": "Raíz local de modelos", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.": "Origen + destino = resultado. El destino puede ser una imagen o un vídeo; el flujo elige automáticamente intercambio en imagen o vídeo.", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "El intercambio facial puede requerir autorización comercial separada según el uso y la licencia del modelo. Úselo solo con los derechos y consentimientos adecuados.", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.": "Ejecute evaluación local de verificación 1:1 o identificación 1:N desde carpetas de identidad y exporte informes listos para compras.", + }, + "fr": { + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.": "Importez ou actualisez des dossiers d’album locaux, regroupez les visages détectés et examinez les photos de chaque groupe de personnes.", + "All album processing is local. Import / Refresh scans every selected folder, extracts features only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold.": "Tout le traitement de l’album est local. Importer / Actualiser analyse chaque dossier sélectionné, extrait des caractéristiques uniquement pour les nouvelles images, puis exécute DBSCAN sur tous les visages indexés avec le seuil cosinus choisi.", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.": "Chargez une image de requête et une image de galerie, un ensemble d’images ou un dossier. Une seule image de galerie lance une comparaison 1:1 ; plusieurs images lancent une recherche 1:N dans la galerie.", + "Configure model packs, execution provider, face swap models, and runtime checks.": "Configurez les packages de modèles, le fournisseur d’exécution, les modèles de face swap et les vérifications runtime.", + "Manually refresh GitHub release model URLs and download selected model packages locally.": "Actualisez manuellement les URL des modèles GitHub Releases et téléchargez localement les packages sélectionnés.", + "Code and model files may have different licenses. Commercial deployment requires appropriate model authorization.": "Le code et les fichiers de modèle peuvent avoir des licences différentes. Un déploiement commercial requiert une autorisation de modèle appropriée.", + "Refresh source": "Source d’actualisation", + "Local model root": "Racine locale des modèles", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.": "Source + cible = résultat. La cible peut être une image ou une vidéo ; le workflow choisit automatiquement le mode de face swap adapté.", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "Le face swap peut nécessiter une autorisation commerciale distincte selon l’usage et la licence du modèle. Utilisez-le uniquement avec les droits et consentements appropriés.", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.": "Exécutez une évaluation locale de vérification 1:1 ou d’identification 1:N depuis des dossiers d’identité et exportez des rapports prêts pour les achats.", + }, + "de": { + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.": "Importieren oder aktualisieren Sie lokale Albumordner, clustern Sie erkannte Gesichter und prüfen Sie die Fotos jeder Personengruppe.", + "All album processing is local. Import / Refresh scans every selected folder, extracts features only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold.": "Die gesamte Albumverarbeitung erfolgt lokal. Importieren / Aktualisieren scannt jeden ausgewählten Ordner, extrahiert Merkmale nur für neue Bilder und führt anschließend DBSCAN-Clustering über alle indizierten Gesichter mit dem gewählten Kosinusschwellenwert aus.", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.": "Laden Sie ein Abfragebild und ein Galeriebild, einen Bildsatz oder einen Ordner hoch. Ein Galeriebild startet einen 1:1-Vergleich; mehrere Galeriebilder starten eine 1:N-Galeriesuche.", + "Configure model packs, execution provider, face swap models, and runtime checks.": "Konfigurieren Sie Modellpakete, Ausführungsprovider, Face-Swap-Modelle und Laufzeitprüfungen.", + "Manually refresh GitHub release model URLs and download selected model packages locally.": "Aktualisieren Sie GitHub-Release-Modell-URLs manuell und laden Sie ausgewählte Modellpakete lokal herunter.", + "Code and model files may have different licenses. Commercial deployment requires appropriate model authorization.": "Code- und Modelldateien können unterschiedliche Lizenzen haben. Kommerzielle Bereitstellung erfordert eine geeignete Modellautorisierung.", + "Refresh source": "Aktualisierungsquelle", + "Local model root": "Lokaler Modellstamm", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.": "Quelle + Ziel = Ergebnis. Das Ziel kann ein Bild oder Video sein; der Workflow wählt automatisch Bild- oder Video-Face-Swap.", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "Face Swap kann je nach Nutzung und Modelllizenz eine separate kommerzielle Genehmigung erfordern. Verwenden Sie es nur mit geeigneten Rechten und Einwilligungen.", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.": "Führen Sie lokale 1:1-Verifikation oder 1:N-Identifikation aus Identitätsordnern aus und exportieren Sie beschaffungsreife Berichte.", + }, + "pt": { + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.": "Importe ou atualize pastas de álbum locais, agrupe os rostos detetados e reveja as fotos de cada grupo de pessoas.", + "All album processing is local. Import / Refresh scans every selected folder, extracts features only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold.": "Todo o processamento do álbum é local. Importar / Atualizar analisa cada pasta selecionada, extrai características apenas de imagens novas e depois executa DBSCAN sobre todos os rostos indexados usando o limiar de cosseno selecionado.", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.": "Carregue uma imagem de consulta e uma imagem de galeria, conjunto de imagens ou pasta. Uma imagem de galeria executa comparação 1:1; várias imagens executam pesquisa 1:N na galeria.", + "Configure model packs, execution provider, face swap models, and runtime checks.": "Configure pacotes de modelos, fornecedor de execução, modelos de troca de rostos e verificações de runtime.", + "Manually refresh GitHub release model URLs and download selected model packages locally.": "Atualize manualmente os URLs de modelos do GitHub Releases e transfira localmente os pacotes selecionados.", + "Code and model files may have different licenses. Commercial deployment requires appropriate model authorization.": "O código e os ficheiros de modelo podem ter licenças diferentes. A implantação comercial requer autorização de modelo adequada.", + "Refresh source": "Fonte de atualização", + "Local model root": "Raiz local dos modelos", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.": "Origem + destino = resultado. O destino pode ser imagem ou vídeo; o fluxo escolhe automaticamente troca em imagem ou vídeo.", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "A troca de rostos pode exigir autorização comercial separada dependendo do uso e da licença do modelo. Use apenas com direitos e consentimento adequados.", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.": "Execute avaliação local de verificação 1:1 ou identificação 1:N a partir de pastas de identidade e exporte relatórios prontos para aquisição.", + }, + "ru": { + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.": "Импортируйте или обновляйте локальные папки альбомов, кластеризуйте обнаруженные лица и просматривайте фотографии в каждой группе людей.", + "All album processing is local. Import / Refresh scans every selected folder, extracts features only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold.": "Вся обработка альбомов выполняется локально. Import / Refresh сканирует каждую выбранную папку, извлекает признаки только для новых изображений, затем запускает DBSCAN по всем индексированным лицам с выбранным косинусным порогом.", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.": "Загрузите одно изображение запроса и изображение галереи, набор изображений или папку. Одно изображение галереи запускает сравнение 1:1; несколько изображений запускают поиск 1:N по галерее.", + "Configure model packs, execution provider, face swap models, and runtime checks.": "Настройте пакеты моделей, провайдер выполнения, модели замены лиц и проверки runtime.", + "Manually refresh GitHub release model URLs and download selected model packages locally.": "Вручную обновляйте URL моделей из GitHub Releases и загружайте выбранные пакеты моделей локально.", + "Code and model files may have different licenses. Commercial deployment requires appropriate model authorization.": "Код и файлы моделей могут иметь разные лицензии. Коммерческое развертывание требует соответствующей авторизации модели.", + "Refresh source": "Источник обновления", + "Local model root": "Локальный корень моделей", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.": "Источник + цель = результат. Целью может быть изображение или видео; рабочий процесс автоматически выбирает замену лиц для изображения или видео.", + "Face swap may require separate commercial authorization depending on usage and model license. Use only with appropriate rights and consent.": "Замена лиц может требовать отдельного коммерческого разрешения в зависимости от использования и лицензии модели. Используйте только при наличии соответствующих прав и согласия.", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.": "Запускайте локальную оценку верификации 1:1 или идентификации 1:N из папок идентичностей и экспортируйте отчёты для закупочных решений.", + }, +} + +for _lang, _values in _PAGE_COPY_TRANSLATIONS.items(): + _TRANSLATIONS.setdefault(_lang, {}).update(_values) + + +_REPORT_UI_TRANSLATIONS: dict[str, dict[str, str]] = { + "zh": { + "Evaluation complete. Report saved to:": "评测完成。报告已保存至:", + "Evaluation report saved": "评测报告已保存", + "Evaluation report saved to:": "评测报告已保存至:", + "Scenario": "场景", + "Dataset": "数据集", + "Report PDF": "PDF 报告", + "Report Markdown": "Markdown 报告", + "Report HTML": "HTML 报告", + "not exported": "未导出", + "Metrics": "指标", + "Errors": "错误", + "First errors": "前几个错误", + "Selected dataset:": "已选择数据集:", + "No dataset selected.": "尚未选择数据集。", + }, + "ja": { + "Evaluation complete. Report saved to:": "評価が完了しました。レポートの保存先:", + "Evaluation report saved": "評価レポートを保存しました", + "Evaluation report saved to:": "評価レポートの保存先:", + "Scenario": "シナリオ", + "Dataset": "データセット", + "Report PDF": "PDF レポート", + "Report Markdown": "Markdown レポート", + "Report HTML": "HTML レポート", + "not exported": "未出力", + "Metrics": "指標", + "Errors": "エラー", + "First errors": "最初のエラー", + "Selected dataset:": "選択中のデータセット:", + "No dataset selected.": "データセットが選択されていません。", + }, + "ko": { + "Evaluation complete. Report saved to:": "평가가 완료되었습니다. 보고서 저장 위치:", + "Evaluation report saved": "평가 보고서 저장됨", + "Evaluation report saved to:": "평가 보고서 저장 위치:", + "Scenario": "시나리오", + "Dataset": "데이터셋", + "Report PDF": "PDF 보고서", + "Report Markdown": "Markdown 보고서", + "Report HTML": "HTML 보고서", + "not exported": "내보내지 않음", + "Metrics": "지표", + "Errors": "오류", + "First errors": "첫 번째 오류", + "Selected dataset:": "선택한 데이터셋:", + "No dataset selected.": "선택한 데이터셋이 없습니다.", + }, + "es": { + "Evaluation complete. Report saved to:": "Evaluación completa. Informe guardado en:", + "Evaluation report saved": "Informe de evaluación guardado", + "Evaluation report saved to:": "Informe de evaluación guardado en:", + "Scenario": "Escenario", + "Dataset": "Dataset", + "Report PDF": "Informe PDF", + "Report Markdown": "Informe Markdown", + "Report HTML": "Informe HTML", + "not exported": "no exportado", + "Metrics": "Métricas", + "Errors": "Errores", + "First errors": "Primeros errores", + "Selected dataset:": "Dataset seleccionado:", + "No dataset selected.": "No se ha seleccionado ningún dataset.", + }, + "fr": { + "Evaluation complete. Report saved to:": "Évaluation terminée. Rapport enregistré dans :", + "Evaluation report saved": "Rapport d’évaluation enregistré", + "Evaluation report saved to:": "Rapport d’évaluation enregistré dans :", + "Scenario": "Scénario", + "Dataset": "Jeu de données", + "Report PDF": "Rapport PDF", + "Report Markdown": "Rapport Markdown", + "Report HTML": "Rapport HTML", + "not exported": "non exporté", + "Metrics": "Métriques", + "Errors": "Erreurs", + "First errors": "Premières erreurs", + "Selected dataset:": "Jeu de données sélectionné :", + "No dataset selected.": "Aucun jeu de données sélectionné.", + }, + "de": { + "Evaluation complete. Report saved to:": "Evaluierung abgeschlossen. Bericht gespeichert unter:", + "Evaluation report saved": "Evaluierungsbericht gespeichert", + "Evaluation report saved to:": "Evaluierungsbericht gespeichert unter:", + "Scenario": "Szenario", + "Dataset": "Datensatz", + "Report PDF": "PDF-Bericht", + "Report Markdown": "Markdown-Bericht", + "Report HTML": "HTML-Bericht", + "not exported": "nicht exportiert", + "Metrics": "Metriken", + "Errors": "Fehler", + "First errors": "Erste Fehler", + "Selected dataset:": "Ausgewählter Datensatz:", + "No dataset selected.": "Kein Datensatz ausgewählt.", + }, + "pt": { + "Evaluation complete. Report saved to:": "Avaliação concluída. Relatório guardado em:", + "Evaluation report saved": "Relatório de avaliação guardado", + "Evaluation report saved to:": "Relatório de avaliação guardado em:", + "Scenario": "Cenário", + "Dataset": "Dataset", + "Report PDF": "Relatório PDF", + "Report Markdown": "Relatório Markdown", + "Report HTML": "Relatório HTML", + "not exported": "não exportado", + "Metrics": "Métricas", + "Errors": "Erros", + "First errors": "Primeiros erros", + "Selected dataset:": "Dataset selecionado:", + "No dataset selected.": "Nenhum dataset selecionado.", + }, + "ru": { + "Evaluation complete. Report saved to:": "Оценка завершена. Отчёт сохранён в:", + "Evaluation report saved": "Отчёт оценки сохранён", + "Evaluation report saved to:": "Отчёт оценки сохранён в:", + "Scenario": "Сценарий", + "Dataset": "Датасет", + "Report PDF": "PDF-отчёт", + "Report Markdown": "Markdown-отчёт", + "Report HTML": "HTML-отчёт", + "not exported": "не экспортировано", + "Metrics": "Метрики", + "Errors": "Ошибки", + "First errors": "Первые ошибки", + "Selected dataset:": "Выбранный датасет:", + "No dataset selected.": "Датасет не выбран.", + }, +} + +for _lang, _values in _REPORT_UI_TRANSLATIONS.items(): + _TRANSLATIONS.setdefault(_lang, {}).update(_values) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/licensing.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/licensing.py new file mode 100644 index 0000000000000000000000000000000000000000..baff5a34f8a9fbc9f93e2db67d5a92911d745421 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/licensing.py @@ -0,0 +1,46 @@ +"""License center helpers.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Dict + +from .constants import COMMERCIAL_NOTICE, LICENSE_NOTICE, RESPONSIBLE_USE_NOTICE + + +def find_license_text(start: str | Path) -> str: + root = Path(start).resolve() + candidates = [root / "LICENSE", root / "LICENSE.md", root.parent / "LICENSE", root.parent / "LICENSE.md"] + for path in candidates: + if path.exists(): + text = path.read_text(encoding="utf-8", errors="ignore").strip() + return text[:4000] + return "Please refer to the LICENSE file in this repository for the code license." + + +def allowed_usage_summary() -> Dict[str, str]: + return { + "Personal research": "yes", + "Internal evaluation": "depends on model license", + "Commercial production": "requires commercial model license", + "Redistribution": "requires explicit permission", + "SaaS / API usage": "requires commercial agreement", + "Face swap commercial usage": "requires commercial agreement", + } + + +def license_summary_text(status: str, model_name: str, provider: str, workspace: str) -> str: + lines = [ + "# InsightFace License Summary", + "", + f"- Current status: {status}", + f"- Model: {model_name}", + f"- Provider: {provider}", + f"- Workspace: {workspace}", + "", + LICENSE_NOTICE, + COMMERCIAL_NOTICE, + RESPONSIBLE_USE_NOTICE, + "This tool does not provide legal advice.", + ] + return "\n".join(lines) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/links.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/links.py new file mode 100644 index 0000000000000000000000000000000000000000..eb0e8e82b01240d60a84ac40c1e506408e63b44b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/links.py @@ -0,0 +1,40 @@ +"""External link helpers for GUI-origin attribution.""" + +from __future__ import annotations + +from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit + +from PySide6.QtCore import QUrl +from PySide6.QtGui import QDesktopServices + +INSIGHTFACE_LINK_HOSTS = {"insightface.ai", "www.insightface.ai"} +GUI_UTM_SOURCE = "insightface_gui" + + +def add_gui_referrer(url: str, *, content: str | None = None) -> str: + """Add GUI source attribution to InsightFace website URLs. + + Native desktop apps cannot reliably set the browser's HTTP Referer header + when delegating a URL to the user's default browser. Query attribution is + therefore the stable, privacy-visible path for website-side analytics. + + The `content` argument is accepted for API compatibility but intentionally + not emitted; Vercel UTM reporting only needs `utm_source` for this app. + """ + + parts = urlsplit(url) + if parts.scheme not in {"http", "https"} or parts.hostname not in INSIGHTFACE_LINK_HOSTS: + return url + + params = parse_qsl(parts.query, keep_blank_values=True) + existing = {key for key, _ in params} + if "utm_source" not in existing: + params.append(("utm_source", GUI_UTM_SOURCE)) + + return urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(params), parts.fragment)) + + +def open_insightface_url(url: str, *, content: str | None = None) -> bool: + """Open an InsightFace website URL with GUI attribution parameters.""" + + return QDesktopServices.openUrl(QUrl(add_gui_referrer(url, content=content))) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/logging.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/logging.py new file mode 100644 index 0000000000000000000000000000000000000000..45ae94a1e83a59196754485a358d133bfda8d57f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/logging.py @@ -0,0 +1,25 @@ +"""Logging setup.""" + +from __future__ import annotations + +import logging +from pathlib import Path + + +def setup_logging(log_dir: str | Path) -> Path: + path = Path(log_dir).expanduser() + path.mkdir(parents=True, exist_ok=True) + log_file = path / "app.log" + logger = logging.getLogger("insightface.gui") + logger.setLevel(logging.INFO) + if not any(isinstance(handler, logging.FileHandler) and handler.baseFilename == str(log_file) for handler in logger.handlers): + handler = logging.FileHandler(log_file, encoding="utf-8") + handler.setFormatter( + logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s") + ) + logger.addHandler(handler) + return log_file + + +def get_logger(name: str) -> logging.Logger: + return logging.getLogger(f"insightface.gui.{name}") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/model_downloads.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/model_downloads.py new file mode 100644 index 0000000000000000000000000000000000000000..3604b1207e21657adcc011f99305324231a2b158 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/model_downloads.py @@ -0,0 +1,356 @@ +"""Manual model download catalog and helpers. + +The GUI never downloads models automatically. Users must open Model Downloads, +refresh URLs, and explicitly start a download. +""" + +from __future__ import annotations + +import json +import os +import shutil +import time +import urllib.error +import urllib.request +import zipfile +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Callable, Iterable, List, Optional + +from .utils import safe_json_dumps, utc_now_iso + +GITHUB_RELEASES_URL = "https://github.com/deepinsight/insightface/releases" +GITHUB_LATEST_RELEASE_API = "https://api.github.com/repos/deepinsight/insightface/releases/latest" +FALLBACK_RELEASE_TAG = "v0.7" +FALLBACK_RELEASE_NAME = "insightface v0.7 model packages" +GFPGAN_MODEL_NAME = "GFPGANv1.4.onnx" +GFPGAN_DOWNLOAD_URL = ( + "https://github.com/harisreedhar/Face-Upscalers-ONNX/releases/download/" + "Models/GFPGANv1.4.onnx" +) + + +@dataclass +class ModelAsset: + name: str + browser_download_url: str + tag_name: str = FALLBACK_RELEASE_TAG + release_name: str = FALLBACK_RELEASE_NAME + size: int = 0 + content_type: str = "" + updated_at: str = "" + source: str = "InsightFace" + + @property + def stem(self) -> str: + if self.name.endswith(".zip"): + return self.name[:-4] + if self.name.endswith(".onnx"): + return self.name[:-5] + return Path(self.name).stem + + @property + def kind(self) -> str: + if self.source.lower() != "insightface": + return "third-party restore model" + if self.name.endswith(".zip"): + return "model package" + if self.name.endswith(".onnx"): + return "onnx model" + return "asset" + + +def fallback_model_assets() -> List[ModelAsset]: + # Latest GitHub release is v0.7. GitHub's HTML page reports nine assets, + # and the SourceForge mirror lists the uploaded model files. The GitHub + # download URLs follow the release asset URL pattern. + names = [ + "antelopev2.zip", + "buffalo_l.zip", + "buffalo_m.zip", + "buffalo_s.zip", + "buffalo_sc.zip", + "inswapper_128.onnx", + "scrfd_person_2.5g.onnx", + ] + assets = [ + ModelAsset( + name=name, + browser_download_url=f"https://github.com/deepinsight/insightface/releases/download/{FALLBACK_RELEASE_TAG}/{name}", + tag_name=FALLBACK_RELEASE_TAG, + release_name=FALLBACK_RELEASE_NAME, + ) + for name in names + ] + return merge_required_assets(assets) + + +def third_party_model_assets() -> List[ModelAsset]: + return [ + ModelAsset( + name=GFPGAN_MODEL_NAME, + browser_download_url=GFPGAN_DOWNLOAD_URL, + tag_name="third-party", + release_name="harisreedhar/Face-Upscalers-ONNX GFPGAN v1.4", + size=340 * 1024 * 1024, + content_type="application/octet-stream", + source="third party", + ) + ] + + +def merge_required_assets(assets: Iterable[ModelAsset]) -> List[ModelAsset]: + merged = list(assets) + seen = {asset.name for asset in merged} + for asset in third_party_model_assets(): + if asset.name not in seen: + merged.append(asset) + seen.add(asset.name) + return merged + + +def cache_file(gui_cache_dir: str | os.PathLike[str]) -> Path: + path = Path(gui_cache_dir).expanduser() / "model_download_urls.json" + path.parent.mkdir(parents=True, exist_ok=True) + return path + + +def asset_from_dict(data: dict) -> ModelAsset: + return ModelAsset( + name=str(data.get("name", "")), + browser_download_url=str(data.get("browser_download_url", "")), + tag_name=str(data.get("tag_name", data.get("release_tag", FALLBACK_RELEASE_TAG))), + release_name=str(data.get("release_name", FALLBACK_RELEASE_NAME)), + size=int(data.get("size") or 0), + content_type=str(data.get("content_type", "")), + updated_at=str(data.get("updated_at", "")), + source=str(data.get("source", "InsightFace")), + ) + + +def load_cached_assets(gui_cache_dir: str | os.PathLike[str]) -> List[ModelAsset]: + path = cache_file(gui_cache_dir) + if not path.exists(): + return fallback_model_assets() + try: + payload = json.loads(path.read_text(encoding="utf-8")) + assets = [asset_from_dict(item) for item in payload.get("assets", []) if item.get("browser_download_url")] + return merge_required_assets(assets) + except Exception: + return fallback_model_assets() + + +def save_cached_assets(gui_cache_dir: str | os.PathLike[str], assets: Iterable[ModelAsset], source: str = "") -> Path: + path = cache_file(gui_cache_dir) + payload = { + "source": source or GITHUB_LATEST_RELEASE_API, + "refreshed_at": utc_now_iso(), + "assets": [asdict(asset) for asset in assets], + } + path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8") + return path + + +def refresh_model_assets(gui_cache_dir: str | os.PathLike[str], timeout: int = 20) -> tuple[List[ModelAsset], str]: + request = urllib.request.Request( + GITHUB_LATEST_RELEASE_API, + headers={ + "Accept": "application/vnd.github+json", + "User-Agent": "InsightFace-Evaluation-Studio/1.0.1", + }, + ) + try: + with urllib.request.urlopen(request, timeout=timeout) as response: + payload = json.loads(response.read().decode("utf-8")) + except (urllib.error.URLError, TimeoutError, json.JSONDecodeError) as exc: + assets = fallback_model_assets() + save_cached_assets(gui_cache_dir, assets, source=f"fallback after refresh error: {exc}") + return assets, f"Refresh failed; using bundled {FALLBACK_RELEASE_TAG} URLs. Error: {exc}" + + tag = payload.get("tag_name") or FALLBACK_RELEASE_TAG + release_name = payload.get("name") or tag + assets = [] + for item in payload.get("assets", []): + name = item.get("name") or "" + url = item.get("browser_download_url") or "" + if not url or not (name.endswith(".zip") or name.endswith(".onnx")): + continue + assets.append( + ModelAsset( + name=name, + browser_download_url=url, + tag_name=tag, + release_name=release_name, + size=int(item.get("size") or 0), + content_type=item.get("content_type") or "", + updated_at=item.get("updated_at") or "", + ) + ) + if not assets: + assets = fallback_model_assets() + message = f"Latest release returned no model assets; using bundled {FALLBACK_RELEASE_TAG} URLs." + else: + assets = merge_required_assets(assets) + message = f"Refreshed {len(assets)} asset(s), including third-party restore models." + save_cached_assets(gui_cache_dir, assets, source=GITHUB_LATEST_RELEASE_API) + return assets, message + + +def local_model_status(asset: ModelAsset, model_root: str | os.PathLike[str]) -> str: + root = Path(model_root).expanduser() + if asset.name.endswith(".zip"): + target = root / "models" / asset.stem + if target.exists() and any(target.glob("*.onnx")): + return f"installed: {target}" + if target.exists(): + return f"folder exists: {target}" + return "not installed" + target_file = root / "models" / asset.stem / asset.name + if target_file.exists(): + return f"installed: {target_file}" + legacy_file = root / "models" / asset.name + if legacy_file.exists(): + return f"installed: {legacy_file}" + return "not installed" + + +def is_model_package_installed(model_name: str, model_root: str | os.PathLike[str]) -> bool: + target = Path(model_root).expanduser() / "models" / model_name + return target.exists() and any(target.glob("*.onnx")) + + +def list_installed_swap_models(model_root: str | os.PathLike[str]) -> list[Path]: + root = Path(model_root).expanduser() / "models" + if not root.exists(): + return [] + paths = [] + for path in root.rglob("*.onnx"): + name = path.name.lower() + parent = path.parent.name.lower() + if "swap" in name or "inswapper" in name or "swap" in parent or "inswapper" in parent: + paths.append(path) + return sorted(paths) + + +def list_installed_gfpgan_models(model_root: str | os.PathLike[str]) -> list[Path]: + root = Path(model_root).expanduser() / "models" + if not root.exists(): + return [] + return sorted(path for path in root.rglob("*.onnx") if "gfpgan" in path.name.lower()) + + +def _content_range_total(value: str | None) -> int: + if not value or "/" not in value: + return 0 + total = value.rsplit("/", 1)[-1].strip() + if not total or total == "*": + return 0 + try: + return int(total) + except ValueError: + return 0 + + +def _download_with_retries( + url: str, + destination: Path, + asset_name: str, + expected_size: int = 0, + progress: Optional[Callable[[int, int, str], None]] = None, + retries: int = 4, +) -> None: + partial = destination.with_suffix(destination.suffix + ".part") + last_error: Exception | None = None + for attempt in range(1, retries + 1): + existing = partial.stat().st_size if partial.exists() else 0 + headers = { + "Accept": "application/octet-stream,*/*", + "User-Agent": "Mozilla/5.0 InsightFace-Evaluation-Studio/1.0.1", + } + if existing: + headers["Range"] = f"bytes={existing}-" + request = urllib.request.Request(url, headers=headers) + try: + with urllib.request.urlopen(request, timeout=120) as response: + status = getattr(response, "status", response.getcode()) + content_length = int(response.headers.get("Content-Length") or 0) + content_range_total = _content_range_total(response.headers.get("Content-Range")) + if existing and status != 206: + existing = 0 + mode = "wb" + elif existing: + mode = "ab" + else: + mode = "wb" + if content_range_total: + total = content_range_total + elif status == 206: + total = existing + content_length + else: + total = content_length or expected_size + downloaded = existing if mode == "ab" else 0 + with partial.open(mode) as handle: + while True: + chunk = response.read(1024 * 1024) + if not chunk: + break + handle.write(chunk) + downloaded += len(chunk) + if progress: + progress(downloaded, total or downloaded, f"Downloading {asset_name}") + partial.replace(destination) + return + except (urllib.error.URLError, TimeoutError, ConnectionResetError, OSError) as exc: + if isinstance(exc, urllib.error.HTTPError) and exc.code == 416 and partial.exists(): + partial.replace(destination) + return + last_error = exc + if progress: + progress( + existing, + expected_size or existing or 1, + f"Download interrupted; retrying {asset_name} ({attempt}/{retries})", + ) + if attempt < retries: + time.sleep(min(2 * attempt, 8)) + raise RuntimeError(f"Download failed for {asset_name} after {retries} attempt(s): {last_error}") + + +def download_model_asset( + asset: ModelAsset, + model_root: str | os.PathLike[str], + gui_cache_dir: str | os.PathLike[str], + progress: Optional[Callable[[int, int, str], None]] = None, +) -> Path: + cache_dir = Path(gui_cache_dir).expanduser() / "models" + cache_dir.mkdir(parents=True, exist_ok=True) + model_root_path = Path(model_root).expanduser() / "models" + model_root_path.mkdir(parents=True, exist_ok=True) + + archive_path = cache_dir / asset.name + _download_with_retries( + asset.browser_download_url, + archive_path, + asset.name, + expected_size=asset.size, + progress=progress, + ) + + if asset.name.endswith(".zip"): + target_dir = model_root_path / asset.stem + if target_dir.exists(): + shutil.rmtree(target_dir) + target_dir.mkdir(parents=True, exist_ok=True) + with zipfile.ZipFile(archive_path) as zf: + zf.extractall(target_dir) + if progress: + progress(1, 1, f"Extracted to {target_dir}") + return target_dir + + target_dir = model_root_path / asset.stem + target_dir.mkdir(parents=True, exist_ok=True) + target_file = target_dir / asset.name + shutil.copy2(archive_path, target_file) + if progress: + progress(1, 1, f"Saved to {target_file}") + return target_file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/models.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/models.py new file mode 100644 index 0000000000000000000000000000000000000000..cbe3f8cf76733b2794b356e8fd23175a57387c90 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/models.py @@ -0,0 +1,119 @@ +"""Dataclasses used by the GUI core.""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Any, Dict, List, Optional + +import numpy as np + + +@dataclass +class FaceRecord: + bbox: List[float] + kps: Optional[List[List[float]]] + det_score: float + embedding: Optional[np.ndarray] + normed_embedding: Optional[np.ndarray] + face_id: Optional[str] = None + gender: Optional[int] = None + age: Optional[int] = None + quality_score: Optional[float] = None + quality_flags: List[str] = field(default_factory=list) + crop: Optional[np.ndarray] = None + source_path: Optional[str] = None + frame_index: Optional[int] = None + timestamp_ms: Optional[int] = None + + def to_json_dict(self, include_embedding: bool = False) -> Dict[str, Any]: + data: Dict[str, Any] = { + "face_id": self.face_id, + "bbox": self.bbox, + "kps": self.kps, + "det_score": self.det_score, + "gender": self.gender, + "age": self.age, + "source_path": self.source_path, + "frame_index": self.frame_index, + "timestamp_ms": self.timestamp_ms, + } + if include_embedding: + data["embedding"] = self.embedding.tolist() if self.embedding is not None else None + data["normed_embedding"] = ( + self.normed_embedding.tolist() if self.normed_embedding is not None else None + ) + return data + + +@dataclass +class CompareResult: + similarity: float + threshold: float + decision: str + face_a: FaceRecord + face_b: FaceRecord + notes: List[str] = field(default_factory=list) + + def to_json_dict(self) -> Dict[str, Any]: + return { + "similarity": self.similarity, + "threshold": self.threshold, + "decision": self.decision, + "face_a": self.face_a.to_json_dict(), + "face_b": self.face_b.to_json_dict(), + "notes": self.notes, + } + + +@dataclass +class SearchResult: + person_id: Optional[int] + person_name: str + sample_id: Optional[int] + similarity: float + status: str + crop_path: Optional[str] = None + + def to_json_dict(self) -> Dict[str, Any]: + return { + "person_id": self.person_id, + "person_name": self.person_name, + "sample_id": self.sample_id, + "similarity": self.similarity, + "status": self.status, + "crop_path": self.crop_path, + } + + +@dataclass +class EvaluationResult: + scenario: str + model_name: str + provider: str + threshold: float + dataset_summary: Dict[str, Any] + metrics: Dict[str, Any] + errors: List[Dict[str, Any]] + latency: Dict[str, Any] + license_status: str + created_at: str + raw_results: List[Dict[str, Any]] = field(default_factory=list) + threshold_recommendation: Optional[float] = None + report_path: Optional[str] = None + + def to_json_dict(self) -> Dict[str, Any]: + return { + "scenario": self.scenario, + "model_name": self.model_name, + "provider": self.provider, + "threshold": self.threshold, + "dataset_summary": self.dataset_summary, + "metrics": self.metrics, + "errors": self.errors, + "latency": self.latency, + "license_status": self.license_status, + "created_at": self.created_at, + "raw_results": self.raw_results, + "threshold_recommendation": self.threshold_recommendation, + "report_path": self.report_path, + } diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/navigation.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/navigation.py new file mode 100644 index 0000000000000000000000000000000000000000..abc69beb83a894ca1fa6ee868d78f08d101621db --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/navigation.py @@ -0,0 +1,91 @@ +"""Mode-based navigation specification for the desktop GUI.""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import Enum + + +class AppMode(str, Enum): + FACE_VERIFICATION = "face_verification" + ALBUM_MANAGEMENT = "album_management" + FACE_SWAP = "face_swap" + ENTERPRISE_EVALUATION = "enterprise_evaluation" + + +@dataclass(frozen=True) +class NavigationItem: + id: str + title: str + page_key: str + description: str = "" + icon: str | None = None + enabled: bool = True + coming_soon: bool = False + + +@dataclass(frozen=True) +class NavigationMode: + id: AppMode + title: str + description: str + items: tuple[NavigationItem, ...] + + +NAVIGATION_MODES: dict[AppMode, NavigationMode] = { + AppMode.FACE_VERIFICATION: NavigationMode( + id=AppMode.FACE_VERIFICATION, + title="Face Recognition", + description="Upload a query face and recognize it against one gallery image or a local gallery.", + items=( + NavigationItem("recognition", "Face Recognition", "verification", "Run 1:1 compare or 1:N gallery search from Query and Gallery uploads."), + ), + ), + AppMode.ALBUM_MANAGEMENT: NavigationMode( + id=AppMode.ALBUM_MANAGEMENT, + title="Album Management", + description="Organize local photos by people, clusters, and searchable face groups.", + items=( + NavigationItem("album", "Album", "album", "Import, refresh, cluster, and review local album folders."), + ), + ), + AppMode.FACE_SWAP: NavigationMode( + id=AppMode.FACE_SWAP, + title="Face Swap", + description="Use a configured downloaded swap model for local image or video face swap.", + items=( + NavigationItem("face_swap", "Face Swap", "image_face_swap", "Source + Target = Result for image or video swap."), + ), + ), + AppMode.ENTERPRISE_EVALUATION: NavigationMode( + id=AppMode.ENTERPRISE_EVALUATION, + title="Enterprise Evaluation", + description="Run local 1:1 and 1:N model evaluations and export reports.", + items=( + NavigationItem("enterprise_evaluation", "Enterprise Evaluation", "enterprise_evaluation", "Run local 1:1 or 1:N identity-folder evaluation and export reports."), + ), + ), +} + + +MODE_LABELS: dict[str, AppMode] = {mode.title: mode.id for mode in NAVIGATION_MODES.values()} + + +GLOBAL_PAGE_TITLES = {"Settings", "Model Settings", "Model Downloads", "License Center"} + + +def mode_from_value(value: str | AppMode | None) -> AppMode: + if isinstance(value, AppMode): + return value + if value: + for mode in AppMode: + if value == mode.value: + return mode + for mode in NAVIGATION_MODES.values(): + if value == mode.title: + return mode.id + return AppMode.FACE_VERIFICATION + + +def last_page_attr(mode: AppMode) -> str: + return f"ui_last_page_{mode.value}" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/paths.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/paths.py new file mode 100644 index 0000000000000000000000000000000000000000..7435470fc2460c52a3e3eb1e2b50bda129dbe912 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/paths.py @@ -0,0 +1,44 @@ +"""Workspace and filesystem helpers.""" + +from __future__ import annotations + +import os +from pathlib import Path +from typing import Dict + + +def default_workspace() -> Path: + return Path.home() / ".insightface" / "gui" + + +def default_config_path() -> Path: + return default_workspace() / "config.json" + + +def expand_path(value: str | os.PathLike[str] | None) -> Path: + if value is None or str(value).strip() == "": + return default_workspace() + return Path(os.path.expandvars(os.path.expanduser(str(value)))).resolve() + + +def workspace_paths(workspace: str | os.PathLike[str] | None = None) -> Dict[str, Path]: + root = expand_path(workspace) + return { + "workspace": root, + "database": root / "insightface_gui.db", + "crops": root / "crops", + "exports": root / "exports", + "reports": root / "reports", + "logs": root / "logs", + "cache": root / "cache", + } + + +def ensure_workspace(workspace: str | os.PathLike[str] | None = None) -> Dict[str, Path]: + paths = workspace_paths(workspace) + for path in paths.values(): + if path.suffix: + path.parent.mkdir(parents=True, exist_ok=True) + else: + path.mkdir(parents=True, exist_ok=True) + return paths diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/quality.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/quality.py new file mode 100644 index 0000000000000000000000000000000000000000..71966c4116b4884dfebe20107e58440de5b456f3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/quality.py @@ -0,0 +1,103 @@ +"""Heuristic face quality scoring.""" + +from __future__ import annotations + +from typing import Iterable, List, Optional, Tuple + +import numpy as np + + +def _to_gray(image: np.ndarray) -> np.ndarray: + arr = np.asarray(image) + if arr.ndim == 2: + return arr.astype(np.float32) + if arr.shape[2] >= 3: + return (0.114 * arr[..., 0] + 0.587 * arr[..., 1] + 0.299 * arr[..., 2]).astype(np.float32) + return arr[..., 0].astype(np.float32) + + +def blur_score(image: np.ndarray) -> float: + gray = _to_gray(image) + try: + import cv2 + + value = float(cv2.Laplacian(gray, cv2.CV_64F).var()) + except Exception: + gx = np.diff(gray, axis=1) + gy = np.diff(gray, axis=0) + value = float(np.var(gx) + np.var(gy)) + return max(0.0, value) + + +def _bbox_area_ratio(bbox: Iterable[float], image_shape: Tuple[int, ...]) -> float: + x1, y1, x2, y2 = [float(v) for v in bbox] + face_area = max(0.0, x2 - x1) * max(0.0, y2 - y1) + image_area = float(max(1, image_shape[0] * image_shape[1])) + return face_area / image_area + + +def _frontal_score(kps: Optional[Iterable[Iterable[float]]]) -> tuple[float, List[str]]: + if kps is None: + return 0.55, ["landmarks_missing"] + pts = np.asarray(list(kps), dtype=np.float32) + if pts.shape[0] < 5: + return 0.55, ["landmarks_incomplete"] + left_eye, right_eye, nose, left_mouth, right_mouth = pts[:5] + eye_mid = (left_eye + right_eye) / 2.0 + mouth_mid = (left_mouth + right_mouth) / 2.0 + eye_distance = max(float(np.linalg.norm(left_eye - right_eye)), 1.0) + nose_offset = abs(float(nose[0] - eye_mid[0])) / eye_distance + vertical_span = max(abs(float(mouth_mid[1] - eye_mid[1])), 1.0) + nose_vertical = abs(float(nose[1] - (eye_mid[1] + mouth_mid[1]) / 2.0)) / vertical_span + score = 1.0 - min(0.7, nose_offset) - min(0.3, nose_vertical * 0.3) + flags: List[str] = [] + if nose_offset > 0.35: + flags.append("side_face") + return max(0.0, min(1.0, score)), flags + + +def score_face( + image: np.ndarray, + bbox: Iterable[float], + kps: Optional[Iterable[Iterable[float]]] = None, + det_score: float = 1.0, +) -> tuple[float, List[str]]: + flags: List[str] = [] + det_component = max(0.0, min(1.0, float(det_score))) + if det_component < 0.55: + flags.append("low_detection_score") + + area_ratio = _bbox_area_ratio(bbox, image.shape) + if area_ratio < 0.01: + flags.append("face_too_small") + size_component = max(0.0, min(1.0, area_ratio / 0.08)) + + x1, y1, x2, y2 = [int(round(float(v))) for v in bbox] + x1, y1 = max(0, x1), max(0, y1) + x2, y2 = min(image.shape[1], x2), min(image.shape[0], y2) + crop = image[y1:y2, x1:x2] if x2 > x1 and y2 > y1 else image + + blur = blur_score(crop) + if blur < 45: + flags.append("blurry") + blur_component = max(0.0, min(1.0, blur / 250.0)) + + gray = _to_gray(crop) + brightness = float(np.mean(gray)) if gray.size else 128.0 + exposure_component = 1.0 - min(1.0, abs(brightness - 128.0) / 128.0) + if brightness < 45: + flags.append("too_dark") + elif brightness > 220: + flags.append("too_bright") + + frontal_component, frontal_flags = _frontal_score(kps) + flags.extend(frontal_flags) + + score = ( + 0.28 * det_component + + 0.22 * size_component + + 0.22 * blur_component + + 0.18 * frontal_component + + 0.10 * exposure_component + ) + return max(0.0, min(1.0, float(score))), sorted(set(flags)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/recognition.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/recognition.py new file mode 100644 index 0000000000000000000000000000000000000000..626df143345706c2e94ba824082eac627fde6397 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/recognition.py @@ -0,0 +1,118 @@ +"""Embedding normalization, comparison, and gallery search.""" + +from __future__ import annotations + +from collections import defaultdict +from typing import Any, Dict, Iterable, List, Optional + +import numpy as np + +from .constants import DEFAULT_THRESHOLD +from .models import SearchResult + + +def normalize_embedding(embedding: np.ndarray | Iterable[float] | None) -> Optional[np.ndarray]: + if embedding is None: + return None + arr = np.asarray(embedding, dtype=np.float32).reshape(-1) + norm = float(np.linalg.norm(arr)) + if norm <= 1e-12: + return arr + return arr / norm + + +def cosine_similarity(a: np.ndarray | Iterable[float] | None, b: np.ndarray | Iterable[float] | None) -> float: + na = normalize_embedding(a) + nb = normalize_embedding(b) + if na is None or nb is None or na.shape != nb.shape: + return 0.0 + return float(np.dot(na, nb)) + + +def compare_embeddings(a: np.ndarray, b: np.ndarray, threshold: float = DEFAULT_THRESHOLD) -> Dict[str, Any]: + similarity = cosine_similarity(a, b) + if similarity >= threshold: + decision = "Same Person" + elif similarity >= threshold - 0.05: + decision = "Uncertain" + else: + decision = "Different Person" + return {"similarity": similarity, "threshold": threshold, "decision": decision} + + +def search_gallery( + query_embedding: np.ndarray, + gallery_embeddings: Iterable[Dict[str, Any]], + top_k: int = 5, + threshold: float = DEFAULT_THRESHOLD, +) -> List[SearchResult]: + query = normalize_embedding(query_embedding) + if query is None: + return [] + best_by_person: Dict[Any, SearchResult] = {} + for item in gallery_embeddings: + emb = item.get("embedding") + if emb is None: + continue + emb_norm = normalize_embedding(emb) + if emb_norm is None or emb_norm.shape != query.shape: + continue + similarity = float(np.dot(query, emb_norm)) + person_id = item.get("person_id") + status = "matched" if similarity >= threshold else "below_threshold" + result = SearchResult( + person_id=person_id, + person_name=item.get("person_name") or "Unknown", + sample_id=item.get("sample_id"), + similarity=similarity, + status=status, + crop_path=item.get("crop_path"), + ) + existing = best_by_person.get(person_id) + if existing is None or result.similarity > existing.similarity: + best_by_person[person_id] = result + results = sorted(best_by_person.values(), key=lambda row: row.similarity, reverse=True) + return results[: max(1, int(top_k))] + + +def aggregate_person_embeddings(face_samples: Iterable[Dict[str, Any]], method: str = "mean") -> Dict[int, np.ndarray]: + grouped: Dict[int, List[np.ndarray]] = defaultdict(list) + for sample in face_samples: + person_id = sample.get("person_id") + emb = normalize_embedding(sample.get("embedding")) + if person_id is None or emb is None: + continue + grouped[int(person_id)].append(emb) + aggregated: Dict[int, np.ndarray] = {} + for person_id, embeddings in grouped.items(): + stack = np.vstack(embeddings) + if method == "max": + aggregated[person_id] = stack[0] + else: + aggregated[person_id] = normalize_embedding(np.mean(stack, axis=0)) # type: ignore[assignment] + return aggregated + + +def identify_face( + query_embedding: np.ndarray, + people_gallery: Iterable[Dict[str, Any]], + threshold: float = DEFAULT_THRESHOLD, + top_k: int = 5, +) -> List[SearchResult]: + results = search_gallery(query_embedding, people_gallery, top_k=top_k, threshold=threshold) + if not results: + return [ + SearchResult( + person_id=None, + person_name="Unknown", + sample_id=None, + similarity=0.0, + status="unknown", + ) + ] + for result in results: + if result.similarity < threshold: + result.status = "unknown" + if result.person_name == "": + result.person_name = "Unknown" + return results diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/reporting.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/reporting.py new file mode 100644 index 0000000000000000000000000000000000000000..d1b83fa083bed999baed543755f0d4e7d43aa151 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/reporting.py @@ -0,0 +1,760 @@ +"""Enterprise evaluation report generation.""" + +from __future__ import annotations + +import html +import sys +from pathlib import Path +from typing import Any, Dict, Iterable, List, Sequence, Tuple + +from .i18n import effective_language +from .models import EvaluationResult +from .utils import safe_json_dumps, timestamp_for_filename + + +_REPORT_TRANSLATIONS: dict[str, dict[str, str]] = { + "en": { + "title": "InsightFace Enterprise Evaluation Report", + "local_notice": "All processing is local. No images, embeddings, or reports are uploaded automatically.", + "executive_summary": "Executive Summary", + "evaluation_scenario": "Evaluation Scenario", + "dataset_summary": "Dataset Summary", + "model_runtime": "Model and Runtime", + "license_status": "License Status", + "metrics": "Metrics", + "threshold_recommendation": "Threshold Recommendation", + "error_analysis": "Error Analysis", + "latency_hardware": "Latency and Hardware", + "deployment_considerations": "Deployment Considerations", + "responsible_use": "Responsible Use and Compliance Notice", + "commercial_next_steps": "Commercial Licensing Next Steps", + "appendix_raw": "Appendix: Raw Results", + "scenario": "Scenario", + "created_at": "Created at", + "license": "License", + "model": "Model", + "provider": "Provider", + "threshold": "Threshold", + "field": "Field", + "value": "Value", + "metric": "Metric", + "not_available": "Not available", + "no_errors": "No failed cases were recorded.", + "raw_note": "Showing the first {count} raw result rows.", + "commercial_notice": "This evaluation may use research or non-commercial model files. Production or commercial deployment requires an appropriate commercial model license.", + "responsible_notice": "Users are responsible for consent, privacy, retention, and compliance with applicable biometric regulations.", + "legal_notice": "This report does not provide legal advice.", + "contact_notice": "For report interpretation, commercial model licensing, private model evaluation, SDK/API access, SLA, or custom training, contact InsightFace: https://www.insightface.ai/contact", + "generated_by": "Generated by InsightFace Evaluation Studio", + }, + "zh": { + "title": "InsightFace 企业评测报告", + "local_notice": "所有处理均在本地完成。图片、特征和报告不会被自动上传。", + "executive_summary": "执行摘要", + "evaluation_scenario": "评测场景", + "dataset_summary": "数据集摘要", + "model_runtime": "模型与运行环境", + "license_status": "授权状态", + "metrics": "指标", + "threshold_recommendation": "阈值建议", + "error_analysis": "错误分析", + "latency_hardware": "延迟与硬件", + "deployment_considerations": "部署考虑", + "responsible_use": "负责任使用与合规提示", + "commercial_next_steps": "商业授权下一步", + "appendix_raw": "附录:原始结果", + "scenario": "场景", + "created_at": "生成时间", + "license": "授权", + "model": "模型", + "provider": "运行后端", + "threshold": "阈值", + "field": "字段", + "value": "值", + "metric": "指标", + "not_available": "不可用", + "no_errors": "未记录失败样例。", + "raw_note": "仅显示前 {count} 条原始结果。", + "commercial_notice": "本次评测可能使用研究或非商业模型文件。生产或商业部署需要相应的商业模型授权。", + "responsible_notice": "用户需自行负责同意、隐私、数据留存以及适用生物识别法规的合规要求。", + "legal_notice": "本报告不构成法律建议。", + "contact_notice": "如需报告解读、商业模型授权、私有模型评测、SDK/API、SLA 或定制训练,请联系 InsightFace:https://www.insightface.ai/contact", + "generated_by": "由 InsightFace Evaluation Studio 生成", + }, + "ja": { + "title": "InsightFace エンタープライズ評価レポート", + "local_notice": "すべての処理はローカルで実行されます。画像、特徴量、レポートは自動アップロードされません。", + "executive_summary": "エグゼクティブサマリー", + "evaluation_scenario": "評価シナリオ", + "dataset_summary": "データセット概要", + "model_runtime": "モデルとランタイム", + "license_status": "ライセンス状況", + "metrics": "指標", + "threshold_recommendation": "しきい値推奨", + "error_analysis": "エラー分析", + "latency_hardware": "レイテンシとハードウェア", + "deployment_considerations": "導入時の考慮事項", + "responsible_use": "責任ある利用とコンプライアンス注意", + "commercial_next_steps": "商用ライセンスの次のステップ", + "appendix_raw": "付録:生データ結果", + "scenario": "シナリオ", + "created_at": "作成日時", + "license": "ライセンス", + "model": "モデル", + "provider": "プロバイダ", + "threshold": "しきい値", + "field": "項目", + "value": "値", + "metric": "指標", + "not_available": "利用不可", + "no_errors": "失敗ケースは記録されていません。", + "raw_note": "最初の {count} 件の生データ結果を表示しています。", + "commercial_notice": "この評価では研究用または非商用モデルファイルを使用している可能性があります。本番または商用展開には適切な商用モデルライセンスが必要です。", + "responsible_notice": "同意、プライバシー、保存期間、適用される生体情報規制への準拠は利用者の責任です。", + "legal_notice": "本レポートは法的助言ではありません。", + "contact_notice": "レポート内容の解釈、商用モデルライセンス、非公開モデル評価、SDK/API、SLA、カスタム学習については InsightFace までお問い合わせください: https://www.insightface.ai/contact", + "generated_by": "InsightFace Evaluation Studio により生成", + }, + "ko": { + "title": "InsightFace 엔터프라이즈 평가 보고서", + "local_notice": "모든 처리는 로컬에서 수행됩니다. 이미지, 임베딩, 보고서는 자동으로 업로드되지 않습니다.", + "executive_summary": "요약", + "evaluation_scenario": "평가 시나리오", + "dataset_summary": "데이터셋 요약", + "model_runtime": "모델 및 런타임", + "license_status": "라이선스 상태", + "metrics": "지표", + "threshold_recommendation": "임계값 권장", + "error_analysis": "오류 분석", + "latency_hardware": "지연 시간 및 하드웨어", + "deployment_considerations": "배포 고려 사항", + "responsible_use": "책임 있는 사용 및 컴플라이언스 고지", + "commercial_next_steps": "상용 라이선스 다음 단계", + "appendix_raw": "부록: 원시 결과", + "scenario": "시나리오", + "created_at": "생성 시간", + "license": "라이선스", + "model": "모델", + "provider": "제공자", + "threshold": "임계값", + "field": "항목", + "value": "값", + "metric": "지표", + "not_available": "사용 불가", + "no_errors": "기록된 실패 사례가 없습니다.", + "raw_note": "처음 {count}개의 원시 결과 행을 표시합니다.", + "commercial_notice": "이 평가는 연구용 또는 비상업용 모델 파일을 사용할 수 있습니다. 프로덕션 또는 상업적 배포에는 적절한 상용 모델 라이선스가 필요합니다.", + "responsible_notice": "동의, 개인정보, 보존, 적용 가능한 생체정보 규정 준수는 사용자 책임입니다.", + "legal_notice": "이 보고서는 법률 자문을 제공하지 않습니다.", + "contact_notice": "보고서 해석, 상용 모델 라이선스, 비공개 모델 평가, SDK/API, SLA 또는 맞춤 학습은 InsightFace에 문의하십시오: https://www.insightface.ai/contact", + "generated_by": "InsightFace Evaluation Studio에서 생성", + }, + "es": { + "title": "Informe de evaluación empresarial de InsightFace", + "local_notice": "Todo el procesamiento es local. Las imágenes, embeddings e informes no se suben automáticamente.", + "executive_summary": "Resumen ejecutivo", + "evaluation_scenario": "Escenario de evaluación", + "dataset_summary": "Resumen del dataset", + "model_runtime": "Modelo y runtime", + "license_status": "Estado de licencia", + "metrics": "Métricas", + "threshold_recommendation": "Recomendación de umbral", + "error_analysis": "Análisis de errores", + "latency_hardware": "Latencia y hardware", + "deployment_considerations": "Consideraciones de despliegue", + "responsible_use": "Uso responsable y aviso de cumplimiento", + "commercial_next_steps": "Próximos pasos de licencia comercial", + "appendix_raw": "Apéndice: resultados sin procesar", + "scenario": "Escenario", + "created_at": "Creado el", + "license": "Licencia", + "model": "Modelo", + "provider": "Proveedor", + "threshold": "Umbral", + "field": "Campo", + "value": "Valor", + "metric": "Métrica", + "not_available": "No disponible", + "no_errors": "No se registraron casos fallidos.", + "raw_note": "Se muestran las primeras {count} filas de resultados sin procesar.", + "commercial_notice": "Esta evaluación puede usar archivos de modelo de investigación o no comerciales. La producción o despliegue comercial requiere una licencia comercial de modelo adecuada.", + "responsible_notice": "Los usuarios son responsables del consentimiento, privacidad, retención y cumplimiento de la normativa biométrica aplicable.", + "legal_notice": "Este informe no proporciona asesoramiento legal.", + "contact_notice": "Para interpretar el informe, obtener licencias comerciales de modelos, evaluación privada, SDK/API, SLA o entrenamiento personalizado, contacte con InsightFace: https://www.insightface.ai/contact", + "generated_by": "Generado por InsightFace Evaluation Studio", + }, + "fr": { + "title": "Rapport d’évaluation entreprise InsightFace", + "local_notice": "Tout le traitement est local. Les images, embeddings et rapports ne sont pas téléversés automatiquement.", + "executive_summary": "Synthèse", + "evaluation_scenario": "Scénario d’évaluation", + "dataset_summary": "Résumé du jeu de données", + "model_runtime": "Modèle et runtime", + "license_status": "Statut de licence", + "metrics": "Métriques", + "threshold_recommendation": "Recommandation de seuil", + "error_analysis": "Analyse des erreurs", + "latency_hardware": "Latence et matériel", + "deployment_considerations": "Considérations de déploiement", + "responsible_use": "Usage responsable et conformité", + "commercial_next_steps": "Prochaines étapes de licence commerciale", + "appendix_raw": "Annexe : résultats bruts", + "scenario": "Scénario", + "created_at": "Créé le", + "license": "Licence", + "model": "Modèle", + "provider": "Fournisseur", + "threshold": "Seuil", + "field": "Champ", + "value": "Valeur", + "metric": "Métrique", + "not_available": "Non disponible", + "no_errors": "Aucun cas d’échec n’a été enregistré.", + "raw_note": "Affichage des {count} premières lignes de résultats bruts.", + "commercial_notice": "Cette évaluation peut utiliser des fichiers de modèle de recherche ou non commerciaux. Un déploiement en production ou commercial nécessite une licence commerciale appropriée.", + "responsible_notice": "Les utilisateurs sont responsables du consentement, de la confidentialité, de la conservation et du respect des réglementations biométriques applicables.", + "legal_notice": "Ce rapport ne fournit pas de conseil juridique.", + "contact_notice": "Pour l’interprétation du rapport, les licences commerciales, l’évaluation privée, l’accès SDK/API, les SLA ou l’entraînement personnalisé, contactez InsightFace : https://www.insightface.ai/contact", + "generated_by": "Généré par InsightFace Evaluation Studio", + }, + "de": { + "title": "InsightFace Enterprise-Evaluierungsbericht", + "local_notice": "Die gesamte Verarbeitung erfolgt lokal. Bilder, Embeddings und Berichte werden nicht automatisch hochgeladen.", + "executive_summary": "Management Summary", + "evaluation_scenario": "Evaluierungsszenario", + "dataset_summary": "Datensatzübersicht", + "model_runtime": "Modell und Laufzeit", + "license_status": "Lizenzstatus", + "metrics": "Metriken", + "threshold_recommendation": "Schwellenwertempfehlung", + "error_analysis": "Fehleranalyse", + "latency_hardware": "Latenz und Hardware", + "deployment_considerations": "Bereitstellungsaspekte", + "responsible_use": "Verantwortungsvolle Nutzung und Compliance-Hinweis", + "commercial_next_steps": "Nächste Schritte zur kommerziellen Lizenzierung", + "appendix_raw": "Anhang: Rohresultate", + "scenario": "Szenario", + "created_at": "Erstellt am", + "license": "Lizenz", + "model": "Modell", + "provider": "Provider", + "threshold": "Schwellenwert", + "field": "Feld", + "value": "Wert", + "metric": "Metrik", + "not_available": "Nicht verfügbar", + "no_errors": "Es wurden keine Fehlerfälle erfasst.", + "raw_note": "Angezeigt werden die ersten {count} Rohresultate.", + "commercial_notice": "Diese Evaluierung kann Forschungs- oder nicht-kommerzielle Modelldateien verwenden. Produktion oder kommerzielle Bereitstellung erfordert eine geeignete kommerzielle Modelllizenz.", + "responsible_notice": "Nutzer sind für Einwilligung, Datenschutz, Aufbewahrung und die Einhaltung geltender biometrischer Vorschriften verantwortlich.", + "legal_notice": "Dieser Bericht stellt keine Rechtsberatung dar.", + "contact_notice": "Für die Interpretation des Berichts, kommerzielle Modelllizenzen, private Modellevaluierung, SDK/API-Zugang, SLA oder individuelles Training kontaktieren Sie InsightFace: https://www.insightface.ai/contact", + "generated_by": "Erstellt mit InsightFace Evaluation Studio", + }, + "pt": { + "title": "Relatório de avaliação empresarial InsightFace", + "local_notice": "Todo o processamento é local. Imagens, embeddings e relatórios não são enviados automaticamente.", + "executive_summary": "Resumo executivo", + "evaluation_scenario": "Cenário de avaliação", + "dataset_summary": "Resumo do dataset", + "model_runtime": "Modelo e runtime", + "license_status": "Estado da licença", + "metrics": "Métricas", + "threshold_recommendation": "Recomendação de limiar", + "error_analysis": "Análise de erros", + "latency_hardware": "Latência e hardware", + "deployment_considerations": "Considerações de implantação", + "responsible_use": "Uso responsável e aviso de conformidade", + "commercial_next_steps": "Próximos passos de licenciamento comercial", + "appendix_raw": "Apêndice: resultados brutos", + "scenario": "Cenário", + "created_at": "Criado em", + "license": "Licença", + "model": "Modelo", + "provider": "Fornecedor", + "threshold": "Limiar", + "field": "Campo", + "value": "Valor", + "metric": "Métrica", + "not_available": "Não disponível", + "no_errors": "Nenhum caso de falha foi registado.", + "raw_note": "A mostrar as primeiras {count} linhas de resultados brutos.", + "commercial_notice": "Esta avaliação pode usar ficheiros de modelo de investigação ou não comerciais. Produção ou implantação comercial requer uma licença comercial de modelo adequada.", + "responsible_notice": "Os utilizadores são responsáveis por consentimento, privacidade, retenção e conformidade com regulamentos biométricos aplicáveis.", + "legal_notice": "Este relatório não fornece aconselhamento jurídico.", + "contact_notice": "Para interpretação do relatório, licenciamento comercial, avaliação privada, SDK/API, SLA ou treino personalizado, contacte a InsightFace: https://www.insightface.ai/contact", + "generated_by": "Gerado por InsightFace Evaluation Studio", + }, + "ru": { + "title": "Корпоративный отчёт оценки InsightFace", + "local_notice": "Вся обработка выполняется локально. Изображения, эмбеддинги и отчёты не загружаются автоматически.", + "executive_summary": "Резюме", + "evaluation_scenario": "Сценарий оценки", + "dataset_summary": "Сводка датасета", + "model_runtime": "Модель и среда выполнения", + "license_status": "Статус лицензии", + "metrics": "Метрики", + "threshold_recommendation": "Рекомендация порога", + "error_analysis": "Анализ ошибок", + "latency_hardware": "Задержка и оборудование", + "deployment_considerations": "Рекомендации по внедрению", + "responsible_use": "Ответственное использование и соответствие требованиям", + "commercial_next_steps": "Следующие шаги коммерческого лицензирования", + "appendix_raw": "Приложение: сырые результаты", + "scenario": "Сценарий", + "created_at": "Создано", + "license": "Лицензия", + "model": "Модель", + "provider": "Провайдер", + "threshold": "Порог", + "field": "Поле", + "value": "Значение", + "metric": "Метрика", + "not_available": "Недоступно", + "no_errors": "Случаи ошибок не зафиксированы.", + "raw_note": "Показаны первые {count} строк сырых результатов.", + "commercial_notice": "Эта оценка может использовать исследовательские или некоммерческие файлы моделей. Производственное или коммерческое внедрение требует соответствующей коммерческой лицензии модели.", + "responsible_notice": "Пользователи отвечают за согласие, конфиденциальность, хранение и соблюдение применимых биометрических норм.", + "legal_notice": "Этот отчёт не является юридической консультацией.", + "contact_notice": "Для разбора отчета, коммерческого лицензирования модели, приватной оценки, доступа к SDK/API, SLA или индивидуального обучения свяжитесь с InsightFace: https://www.insightface.ai/contact", + "generated_by": "Создано InsightFace Evaluation Studio", + }, +} + + +def _rt(key: str, language: str | None = None) -> str: + lang = effective_language(language) + return _REPORT_TRANSLATIONS.get(lang, _REPORT_TRANSLATIONS["en"]).get( + key, _REPORT_TRANSLATIONS["en"].get(key, key) + ) + + +def _value_to_text(value: Any) -> str: + if value is None: + return "" + if isinstance(value, float): + return f"{value:.6f}" + if isinstance(value, (dict, list, tuple)): + return safe_json_dumps(value) + return str(value) + + +def _metric_lines(metrics: Dict[str, Any]) -> Iterable[str]: + for key, value in metrics.items(): + yield f"- **{key}**: {_value_to_text(value)}" + + +def _markdown_escape(value: Any) -> str: + return _value_to_text(value).replace("|", "\\|").replace("\n", "
") + + +def _markdown_table(rows: Sequence[Tuple[str, Any]], language: str | None = None) -> List[str]: + lines = [ + f"| {_rt('field', language)} | {_rt('value', language)} |", + "| --- | --- |", + ] + for key, value in rows: + lines.append(f"| {_markdown_escape(key)} | {_markdown_escape(value)} |") + return lines + + +def _summary_rows(result: EvaluationResult, language: str | None) -> List[Tuple[str, Any]]: + threshold_recommendation = ( + f"{result.threshold_recommendation:.6f}" + if result.threshold_recommendation is not None + else _rt("not_available", language) + ) + return [ + (_rt("scenario", language), result.scenario), + (_rt("created_at", language), result.created_at), + (_rt("model", language), result.model_name), + (_rt("provider", language), result.provider), + (_rt("license", language), result.license_status), + (_rt("threshold_recommendation", language), threshold_recommendation), + ] + + +def generate_markdown_report(result: EvaluationResult, language: str | None = None) -> str: + raw_rows = result.raw_results[:50] + raw_block = safe_json_dumps(raw_rows) + lines = [ + f"# {_rt('title', language)}", + "", + f"> {_rt('local_notice', language)}", + "", + f"## 1. {_rt('executive_summary', language)}", + *_markdown_table(_summary_rows(result, language), language), + "", + f"## 2. {_rt('evaluation_scenario', language)}", + result.scenario, + "", + f"## 3. {_rt('dataset_summary', language)}", + *_markdown_table(list(result.dataset_summary.items()), language), + "", + f"## 4. {_rt('model_runtime', language)}", + *_markdown_table( + [ + (_rt("model", language), result.model_name), + (_rt("provider", language), result.provider), + (_rt("threshold", language), f"{result.threshold:.6f}"), + ], + language, + ), + "", + f"## 5. {_rt('license_status', language)}", + result.license_status, + "", + f"## 6. {_rt('metrics', language)}", + *list(_metric_lines(result.metrics)), + "", + f"## 7. {_rt('threshold_recommendation', language)}", + _summary_rows(result, language)[-1][1], + "", + f"## 8. {_rt('error_analysis', language)}", + safe_json_dumps(result.errors[:50]) if result.errors else _rt("no_errors", language), + "", + f"## 9. {_rt('latency_hardware', language)}", + *_markdown_table(list(result.latency.items()), language), + "", + f"## 10. {_rt('deployment_considerations', language)}", + _rt("commercial_notice", language), + "", + f"## 11. {_rt('responsible_use', language)}", + _rt("responsible_notice", language), + "", + _rt("legal_notice", language), + "", + f"## 12. {_rt('commercial_next_steps', language)}", + _rt("contact_notice", language), + "", + f"## 13. {_rt('appendix_raw', language)}", + _rt("raw_note", language).format(count=len(raw_rows)), + "", + "```json", + raw_block, + "```", + "", + ] + return "\n".join(str(line) for line in lines) + + +def generate_html_report(result: EvaluationResult, language: str | None = None) -> str: + markdown = generate_markdown_report(result, language) + lines = [] + in_code = False + for line in markdown.splitlines(): + if line.startswith("```"): + lines.append("
" if in_code else "
")
+            in_code = not in_code
+        elif in_code:
+            lines.append(html.escape(line))
+        elif line.startswith("# "):
+            lines.append(f"

{html.escape(line[2:])}

") + elif line.startswith("## "): + lines.append(f"

{html.escape(line[3:])}

") + elif line.startswith("> "): + lines.append(f"
{html.escape(line[2:])}
") + elif line.startswith("| "): + lines.append(f"

{html.escape(line)}

") + elif line.startswith("- "): + lines.append(f"

{html.escape(line)}

") + elif line.strip(): + lines.append(f"

{html.escape(line)}

") + else: + lines.append("") + return ( + "" + f"{html.escape(_rt('title', language))}" + "" + + "\n".join(lines) + + "" + ) + + +def _candidate_font_paths() -> List[Path]: + py_site = Path(sys.prefix) / "lib" / f"python{sys.version_info.major}.{sys.version_info.minor}" / "site-packages" + win_site = Path(sys.prefix) / "Lib" / "site-packages" + candidates = [ + py_site / "matplotlib" / "mpl-data" / "fonts" / "ttf" / "DejaVuSans.ttf", + py_site / "matplotlib" / "mpl-data" / "fonts" / "ttf" / "DejaVuSans-Bold.ttf", + win_site / "matplotlib" / "mpl-data" / "fonts" / "ttf" / "DejaVuSans.ttf", + win_site / "matplotlib" / "mpl-data" / "fonts" / "ttf" / "DejaVuSans-Bold.ttf", + Path("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"), + Path("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"), + Path("/usr/share/fonts/truetype/liberation2/LiberationSans-Regular.ttf"), + Path("/usr/share/fonts/truetype/liberation2/LiberationSans-Bold.ttf"), + Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"), + Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Bold.ttc"), + Path("/Library/Fonts/Arial Unicode.ttf"), + Path("/Library/Fonts/Arial.ttf"), + Path("/System/Library/Fonts/Supplemental/Arial.ttf"), + Path("/System/Library/Fonts/Supplemental/Arial Bold.ttf"), + Path("C:/Windows/Fonts/arial.ttf"), + Path("C:/Windows/Fonts/arialbd.ttf"), + Path("C:/Windows/Fonts/segoeui.ttf"), + Path("C:/Windows/Fonts/seguisb.ttf"), + ] + return [path for path in candidates if path.exists()] + + +def _register_pdf_fonts(language: str | None = None) -> Tuple[str, str]: + from reportlab.pdfbase import pdfmetrics + + lang = effective_language(language) + if lang in {"zh", "ja", "ko"}: + from reportlab.pdfbase.cidfonts import UnicodeCIDFont + + cid_name = {"zh": "STSong-Light", "ja": "HeiseiMin-W3", "ko": "HYSMyeongJo-Medium"}[lang] + try: + pdfmetrics.registerFont(UnicodeCIDFont(cid_name)) + return cid_name, cid_name + except Exception: + pass + + regular_path = None + bold_path = None + for path in _candidate_font_paths(): + lower = path.name.lower() + if regular_path is None and lower in {"dejavusans.ttf", "arial.ttf", "segoeui.ttf", "notosans-regular.ttf"}: + regular_path = path + if bold_path is None and lower in {"dejavusans-bold.ttf", "arialbd.ttf", "arial bold.ttf", "seguisb.ttf", "notosans-bold.ttf"}: + bold_path = path + if regular_path and bold_path: + break + + if regular_path: + try: + from reportlab.pdfbase.ttfonts import TTFont + + pdfmetrics.registerFont(TTFont("InsightFaceReport", str(regular_path))) + if bold_path: + pdfmetrics.registerFont(TTFont("InsightFaceReportBold", str(bold_path))) + return "InsightFaceReport", "InsightFaceReportBold" + return "InsightFaceReport", "InsightFaceReport" + except Exception: + pass + return "Helvetica", "Helvetica-Bold" + + +def _pdf_paragraph(text: Any, style): + from reportlab.platypus import Paragraph + + escaped = html.escape(_value_to_text(text)).replace("\n", "
") + return Paragraph(escaped, style) + + +def _pdf_table(rows: Sequence[Tuple[Any, Any]], styles, language: str | None = None, widths=None): + from reportlab.lib import colors + from reportlab.platypus import Table, TableStyle + + data = [ + [ + _pdf_paragraph(_rt("field", language), styles["TableHeader"]), + _pdf_paragraph(_rt("value", language), styles["TableHeader"]), + ] + ] + for key, value in rows: + data.append([_pdf_paragraph(key, styles["TableCellStrong"]), _pdf_paragraph(value, styles["TableCell"])]) + table = Table(data, colWidths=widths or [145, 340], repeatRows=1, hAlign="LEFT") + table.setStyle( + TableStyle( + [ + ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#dbeafe")), + ("TEXTCOLOR", (0, 0), (-1, 0), colors.HexColor("#0f172a")), + ("GRID", (0, 0), (-1, -1), 0.35, colors.HexColor("#cbd5e1")), + ("BACKGROUND", (0, 1), (-1, -1), colors.HexColor("#f8fafc")), + ("VALIGN", (0, 0), (-1, -1), "TOP"), + ("LEFTPADDING", (0, 0), (-1, -1), 8), + ("RIGHTPADDING", (0, 0), (-1, -1), 8), + ("TOPPADDING", (0, 0), (-1, -1), 6), + ("BOTTOMPADDING", (0, 0), (-1, -1), 6), + ] + ) + ) + return table + + +def _section(title: str, styles): + from reportlab.platypus import Paragraph, Spacer + + return [Spacer(1, 14), Paragraph(html.escape(title), styles["SectionHeading"]), Spacer(1, 7)] + + +def write_pdf_report(result: EvaluationResult, path: str | Path, language: str | None = None) -> Path: + from reportlab.lib import colors + from reportlab.lib.enums import TA_CENTER + from reportlab.lib.pagesizes import A4 + from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet + from reportlab.lib.units import mm + from reportlab.platypus import SimpleDocTemplate, Spacer + + regular_font, bold_font = _register_pdf_fonts(language) + root = Path(path) + root.parent.mkdir(parents=True, exist_ok=True) + + base = getSampleStyleSheet() + styles = { + "Title": ParagraphStyle( + "InsightFaceTitle", + parent=base["Title"], + fontName=bold_font, + fontSize=24, + leading=30, + textColor=colors.HexColor("#0f172a"), + alignment=TA_CENTER, + spaceAfter=8, + ), + "Subtitle": ParagraphStyle( + "InsightFaceSubtitle", + parent=base["BodyText"], + fontName=regular_font, + fontSize=10.5, + leading=14, + textColor=colors.HexColor("#475569"), + alignment=TA_CENTER, + ), + "Notice": ParagraphStyle( + "InsightFaceNotice", + parent=base["BodyText"], + fontName=regular_font, + fontSize=9.5, + leading=13, + textColor=colors.HexColor("#1e3a8a"), + backColor=colors.HexColor("#eaf3ff"), + borderColor=colors.HexColor("#93c5fd"), + borderWidth=0.8, + borderPadding=8, + spaceAfter=8, + ), + "SectionHeading": ParagraphStyle( + "InsightFaceSectionHeading", + parent=base["Heading2"], + fontName=bold_font, + fontSize=14, + leading=18, + textColor=colors.HexColor("#1e3a8a"), + spaceBefore=6, + spaceAfter=4, + ), + "Body": ParagraphStyle( + "InsightFaceBody", + parent=base["BodyText"], + fontName=regular_font, + fontSize=9.5, + leading=13.5, + textColor=colors.HexColor("#1f2937"), + ), + "TableHeader": ParagraphStyle( + "InsightFaceTableHeader", + parent=base["BodyText"], + fontName=bold_font, + fontSize=8.8, + leading=11, + textColor=colors.HexColor("#0f172a"), + ), + "TableCellStrong": ParagraphStyle( + "InsightFaceTableCellStrong", + parent=base["BodyText"], + fontName=bold_font, + fontSize=8.4, + leading=10.5, + textColor=colors.HexColor("#0f172a"), + ), + "TableCell": ParagraphStyle( + "InsightFaceTableCell", + parent=base["BodyText"], + fontName=regular_font, + fontSize=8.2, + leading=10.5, + textColor=colors.HexColor("#334155"), + ), + } + + story: List[Any] = [ + _pdf_paragraph(_rt("title", language), styles["Title"]), + _pdf_paragraph(f"{result.scenario} · {result.created_at}", styles["Subtitle"]), + Spacer(1, 8), + _pdf_paragraph(_rt("local_notice", language), styles["Notice"]), + ] + story.extend(_section(f"1. {_rt('executive_summary', language)}", styles)) + story.append(_pdf_table(_summary_rows(result, language), styles, language)) + story.extend(_section(f"2. {_rt('dataset_summary', language)}", styles)) + story.append(_pdf_table(list(result.dataset_summary.items()), styles, language)) + story.extend(_section(f"3. {_rt('model_runtime', language)}", styles)) + story.append( + _pdf_table( + [ + (_rt("model", language), result.model_name), + (_rt("provider", language), result.provider), + (_rt("threshold", language), f"{result.threshold:.6f}"), + ], + styles, + language, + ) + ) + story.extend(_section(f"4. {_rt('metrics', language)}", styles)) + story.append(_pdf_table(list(result.metrics.items()), styles, language)) + story.extend(_section(f"5. {_rt('error_analysis', language)}", styles)) + story.append( + _pdf_paragraph( + safe_json_dumps(result.errors[:50]) if result.errors else _rt("no_errors", language), + styles["Body"], + ) + ) + story.extend(_section(f"6. {_rt('latency_hardware', language)}", styles)) + story.append(_pdf_table(list(result.latency.items()), styles, language)) + story.extend(_section(f"7. {_rt('deployment_considerations', language)}", styles)) + story.append(_pdf_paragraph(_rt("commercial_notice", language), styles["Body"])) + story.extend(_section(f"8. {_rt('responsible_use', language)}", styles)) + story.append(_pdf_paragraph(_rt("responsible_notice", language), styles["Body"])) + story.append(_pdf_paragraph(_rt("legal_notice", language), styles["Body"])) + story.extend(_section(f"9. {_rt('commercial_next_steps', language)}", styles)) + story.append(_pdf_paragraph(_rt("contact_notice", language), styles["Body"])) + raw_rows = result.raw_results[:30] + story.extend(_section(f"10. {_rt('appendix_raw', language)}", styles)) + story.append(_pdf_paragraph(_rt("raw_note", language).format(count=len(raw_rows)), styles["Body"])) + story.append(_pdf_paragraph(safe_json_dumps(raw_rows), styles["Body"])) + + def footer(canvas, doc): + canvas.saveState() + canvas.setFillColor(colors.HexColor("#64748b")) + canvas.setFont(regular_font, 8) + canvas.drawString(18 * mm, 12 * mm, _rt("generated_by", language)) + canvas.drawRightString(192 * mm, 12 * mm, str(doc.page)) + canvas.restoreState() + + doc = SimpleDocTemplate( + str(root), + pagesize=A4, + rightMargin=18 * mm, + leftMargin=18 * mm, + topMargin=16 * mm, + bottomMargin=18 * mm, + title=_rt("title", language), + ) + doc.build(story, onFirstPage=footer, onLaterPages=footer) + return root + + +def write_reports(result: EvaluationResult, report_dir: str | Path, language: str | None = None) -> Dict[str, str]: + root = Path(report_dir) + root.mkdir(parents=True, exist_ok=True) + stem = f"insightface_evaluation_{timestamp_for_filename()}" + markdown_path = root / f"{stem}.md" + html_path = root / f"{stem}.html" + pdf_path = root / f"{stem}.pdf" + markdown_path.write_text(generate_markdown_report(result, language), encoding="utf-8") + html_path.write_text(generate_html_report(result, language), encoding="utf-8") + paths = {"markdown": str(markdown_path), "html": str(html_path)} + try: + write_pdf_report(result, pdf_path, language) + paths["pdf"] = str(pdf_path) + except Exception: + pass + result.report_path = paths.get("pdf") or paths["markdown"] + return paths diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/storage.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/storage.py new file mode 100644 index 0000000000000000000000000000000000000000..c65da732df23e7de3a624a8b675e1d7d05b1d57e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/storage.py @@ -0,0 +1,737 @@ +"""SQLite storage for local people, media, embeddings, and reports.""" + +from __future__ import annotations + +import json +import sqlite3 +from contextlib import contextmanager +from pathlib import Path +from typing import Any, Dict, Iterable, Iterator, List, Optional + +import numpy as np + +from .logging import get_logger +from .constants import DEFAULT_THRESHOLD +from .recognition import search_gallery +from .utils import safe_json_dumps, utc_now_iso + +LOGGER = get_logger("storage") +ALBUM_DIRECTORIES_SETTING = "album.directories" +ALBUM_RESULTS_SETTING = "album.results" + + +def embedding_to_blob(embedding: np.ndarray | Iterable[float] | None) -> tuple[Optional[bytes], int]: + if embedding is None: + return None, 0 + arr = np.asarray(embedding, dtype=np.float32).reshape(-1) + return arr.tobytes(), int(arr.shape[0]) + + +def blob_to_embedding(blob: bytes | memoryview | None, dim: int | None = None) -> Optional[np.ndarray]: + if blob is None: + return None + arr = np.frombuffer(blob, dtype=np.float32).copy() + if dim and arr.shape[0] != dim: + return None + return arr + + +class Storage: + def __init__(self, database_path: str | Path): + self.database_path = Path(database_path).expanduser() + self.database_path.parent.mkdir(parents=True, exist_ok=True) + self.init_db() + + @contextmanager + def connect(self) -> Iterator[sqlite3.Connection]: + conn = sqlite3.connect(str(self.database_path)) + conn.row_factory = sqlite3.Row + try: + yield conn + conn.commit() + except Exception: + conn.rollback() + LOGGER.exception("Database operation failed") + raise + finally: + conn.close() + + def init_db(self) -> None: + with self.connect() as conn: + conn.executescript( + """ + CREATE TABLE IF NOT EXISTS people ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL, + display_name TEXT, + notes TEXT, + tags TEXT, + cover_face_sample_id INTEGER, + created_at TEXT, + updated_at TEXT + ); + + CREATE TABLE IF NOT EXISTS face_samples ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + person_id INTEGER, + source_image_path TEXT, + crop_path TEXT, + embedding BLOB, + embedding_dim INTEGER, + bbox_json TEXT, + kps_json TEXT, + det_score REAL, + quality_score REAL, + model_name TEXT, + provider TEXT, + created_at TEXT, + updated_at TEXT + ); + + CREATE TABLE IF NOT EXISTS media_items ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + path TEXT UNIQUE, + media_type TEXT, + width INTEGER, + height INTEGER, + duration_ms INTEGER, + file_size INTEGER, + mtime REAL, + sha256 TEXT, + thumbnail BLOB, + thumbnail_mime TEXT, + processed_at TEXT, + created_at TEXT + ); + + CREATE TABLE IF NOT EXISTS media_faces ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + media_id INTEGER, + frame_index INTEGER, + timestamp_ms INTEGER, + crop_path TEXT, + thumbnail BLOB, + thumbnail_mime TEXT, + embedding BLOB, + embedding_dim INTEGER, + bbox_json TEXT, + kps_json TEXT, + det_score REAL, + quality_score REAL, + assigned_person_id INTEGER, + predicted_person_id INTEGER, + similarity REAL, + cluster_id INTEGER, + status TEXT, + created_at TEXT, + updated_at TEXT + ); + + CREATE TABLE IF NOT EXISTS clusters ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT, + cover_media_face_id INTEGER, + notes TEXT, + created_at TEXT, + updated_at TEXT + ); + + CREATE TABLE IF NOT EXISTS recognition_logs ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + source_type TEXT, + source_path TEXT, + query_face_sample_id INTEGER, + predicted_person_id INTEGER, + similarity REAL, + threshold REAL, + status TEXT, + payload_json TEXT, + created_at TEXT + ); + + CREATE TABLE IF NOT EXISTS evaluation_runs ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + scenario TEXT, + model_name TEXT, + provider TEXT, + threshold REAL, + dataset_summary_json TEXT, + metrics_json TEXT, + hardware_json TEXT, + report_path TEXT, + created_at TEXT + ); + + CREATE TABLE IF NOT EXISTS app_settings ( + key TEXT PRIMARY KEY, + value TEXT, + updated_at TEXT + ); + """ + ) + self._ensure_column(conn, "media_items", "thumbnail", "BLOB") + self._ensure_column(conn, "media_items", "thumbnail_mime", "TEXT") + self._ensure_column(conn, "media_faces", "thumbnail", "BLOB") + self._ensure_column(conn, "media_faces", "thumbnail_mime", "TEXT") + + @staticmethod + def _ensure_column(conn: sqlite3.Connection, table: str, column: str, definition: str) -> None: + rows = conn.execute(f"PRAGMA table_info({table})").fetchall() + existing = {str(row["name"]) for row in rows} + if column not in existing: + conn.execute(f"ALTER TABLE {table} ADD COLUMN {column} {definition}") + + def add_person( + self, + name: str, + display_name: Optional[str] = None, + notes: str = "", + tags: str = "", + ) -> int: + now = utc_now_iso() + with self.connect() as conn: + cur = conn.execute( + """ + INSERT INTO people (name, display_name, notes, tags, created_at, updated_at) + VALUES (?, ?, ?, ?, ?, ?) + """, + (name, display_name or name, notes, tags, now, now), + ) + return int(cur.lastrowid) + + def update_person(self, person_id: int, **fields: Any) -> None: + allowed = {"name", "display_name", "notes", "tags", "cover_face_sample_id"} + updates = {key: value for key, value in fields.items() if key in allowed} + if not updates: + return + updates["updated_at"] = utc_now_iso() + clause = ", ".join(f"{key}=?" for key in updates) + values = list(updates.values()) + [person_id] + with self.connect() as conn: + conn.execute(f"UPDATE people SET {clause} WHERE id=?", values) + + def delete_person(self, person_id: int, delete_samples: bool = False) -> None: + with self.connect() as conn: + if delete_samples: + conn.execute("DELETE FROM face_samples WHERE person_id=?", (person_id,)) + else: + conn.execute("UPDATE face_samples SET person_id=NULL WHERE person_id=?", (person_id,)) + conn.execute("UPDATE media_faces SET assigned_person_id=NULL WHERE assigned_person_id=?", (person_id,)) + conn.execute("DELETE FROM people WHERE id=?", (person_id,)) + + def merge_people(self, source_person_id: int, target_person_id: int) -> None: + now = utc_now_iso() + with self.connect() as conn: + conn.execute( + "UPDATE face_samples SET person_id=?, updated_at=? WHERE person_id=?", + (target_person_id, now, source_person_id), + ) + conn.execute( + "UPDATE media_faces SET assigned_person_id=? WHERE assigned_person_id=?", + (target_person_id, source_person_id), + ) + conn.execute("DELETE FROM people WHERE id=?", (source_person_id,)) + + def add_face_sample( + self, + person_id: Optional[int], + embedding: np.ndarray | Iterable[float] | None, + source_image_path: str = "", + crop_path: str = "", + bbox: Optional[Iterable[float]] = None, + kps: Optional[Iterable[Iterable[float]]] = None, + det_score: float = 0.0, + quality_score: Optional[float] = None, + model_name: str = "", + provider: str = "", + ) -> int: + blob, dim = embedding_to_blob(embedding) + now = utc_now_iso() + with self.connect() as conn: + cur = conn.execute( + """ + INSERT INTO face_samples ( + person_id, source_image_path, crop_path, embedding, embedding_dim, + bbox_json, kps_json, det_score, quality_score, model_name, provider, + created_at, updated_at + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + ( + person_id, + source_image_path, + crop_path, + blob, + dim, + safe_json_dumps(list(bbox) if bbox is not None else None), + safe_json_dumps(list(kps) if kps is not None else None), + det_score, + quality_score, + model_name, + provider, + now, + now, + ), + ) + sample_id = int(cur.lastrowid) + if person_id is not None: + conn.execute( + """ + UPDATE people + SET cover_face_sample_id=COALESCE(cover_face_sample_id, ?), updated_at=? + WHERE id=? + """, + (sample_id, now, person_id), + ) + return sample_id + + def delete_face_sample(self, sample_id: int) -> None: + with self.connect() as conn: + conn.execute("DELETE FROM face_samples WHERE id=?", (sample_id,)) + + def list_people(self) -> List[Dict[str, Any]]: + with self.connect() as conn: + rows = conn.execute( + """ + SELECT p.*, + COUNT(fs.id) AS sample_count, + AVG(fs.quality_score) AS avg_quality, + COALESCE( + ( + SELECT fs_cover.crop_path + FROM face_samples fs_cover + WHERE fs_cover.id = p.cover_face_sample_id + AND COALESCE(fs_cover.crop_path, '') <> '' + LIMIT 1 + ), + ( + SELECT fs2.crop_path + FROM face_samples fs2 + WHERE fs2.person_id = p.id AND COALESCE(fs2.crop_path, '') <> '' + ORDER BY fs2.id ASC + LIMIT 1 + ) + ) AS cover_crop_path + FROM people p + LEFT JOIN face_samples fs ON fs.person_id = p.id + GROUP BY p.id + ORDER BY LOWER(COALESCE(p.display_name, p.name)) + """ + ).fetchall() + return [dict(row) for row in rows] + + def list_face_samples(self, person_id: Optional[int] = None) -> List[Dict[str, Any]]: + query = "SELECT * FROM face_samples" + params: tuple[Any, ...] = () + if person_id is not None: + query += " WHERE person_id=?" + params = (person_id,) + query += " ORDER BY created_at DESC, id DESC" + with self.connect() as conn: + rows = conn.execute(query, params).fetchall() + return [self._decode_sample(row) for row in rows] + + def _decode_sample(self, row: sqlite3.Row) -> Dict[str, Any]: + data = dict(row) + data["embedding"] = blob_to_embedding(data.get("embedding"), data.get("embedding_dim")) + for key in ("bbox_json", "kps_json"): + try: + data[key.replace("_json", "")] = json.loads(data[key]) if data.get(key) else None + except Exception: + data[key.replace("_json", "")] = None + return data + + def add_media_item( + self, + path: str, + media_type: str = "image", + width: Optional[int] = None, + height: Optional[int] = None, + duration_ms: Optional[int] = None, + file_size: Optional[int] = None, + mtime: Optional[float] = None, + sha256: Optional[str] = None, + thumbnail: Optional[bytes] = None, + thumbnail_mime: str = "image/webp", + processed_at: Optional[str] = None, + ) -> int: + now = utc_now_iso() + with self.connect() as conn: + conn.execute( + """ + INSERT OR IGNORE INTO media_items ( + path, media_type, width, height, duration_ms, file_size, + mtime, sha256, thumbnail, thumbnail_mime, processed_at, created_at + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + ( + path, + media_type, + width, + height, + duration_ms, + file_size, + mtime, + sha256, + thumbnail, + thumbnail_mime if thumbnail else "", + processed_at, + now, + ), + ) + row = conn.execute("SELECT id FROM media_items WHERE path=?", (path,)).fetchone() + return int(row["id"]) + + def add_media_face( + self, + media_id: int, + embedding: np.ndarray | Iterable[float] | None, + crop_path: str = "", + thumbnail: Optional[bytes] = None, + thumbnail_mime: str = "image/webp", + bbox: Optional[Iterable[float]] = None, + kps: Optional[Iterable[Iterable[float]]] = None, + det_score: float = 0.0, + quality_score: Optional[float] = None, + frame_index: Optional[int] = None, + timestamp_ms: Optional[int] = None, + assigned_person_id: Optional[int] = None, + predicted_person_id: Optional[int] = None, + similarity: Optional[float] = None, + cluster_id: Optional[int] = None, + status: str = "unknown", + ) -> int: + blob, dim = embedding_to_blob(embedding) + now = utc_now_iso() + with self.connect() as conn: + cur = conn.execute( + """ + INSERT INTO media_faces ( + media_id, frame_index, timestamp_ms, crop_path, thumbnail, thumbnail_mime, embedding, embedding_dim, + bbox_json, kps_json, det_score, quality_score, assigned_person_id, + predicted_person_id, similarity, cluster_id, status, created_at, updated_at + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + ( + media_id, + frame_index, + timestamp_ms, + crop_path, + thumbnail, + thumbnail_mime if thumbnail else "", + blob, + dim, + safe_json_dumps(list(bbox) if bbox is not None else None), + safe_json_dumps(list(kps) if kps is not None else None), + det_score, + quality_score, + assigned_person_id, + predicted_person_id, + similarity, + cluster_id, + status, + now, + now, + ), + ) + return int(cur.lastrowid) + + def load_all_gallery_embeddings(self) -> List[Dict[str, Any]]: + with self.connect() as conn: + rows = conn.execute( + """ + SELECT fs.id AS sample_id, fs.person_id, fs.crop_path, fs.embedding, + fs.embedding_dim, + COALESCE(p.display_name, p.name, 'Unknown') AS person_name + FROM face_samples fs + LEFT JOIN people p ON p.id = fs.person_id + WHERE fs.embedding IS NOT NULL AND fs.person_id IS NOT NULL + """ + ).fetchall() + gallery = [] + for row in rows: + item = dict(row) + item["embedding"] = blob_to_embedding(item.get("embedding"), item.get("embedding_dim")) + gallery.append(item) + return gallery + + def search_embeddings( + self, + query_embedding: np.ndarray, + top_k: int = 5, + threshold: float = DEFAULT_THRESHOLD, + ): + return search_gallery(query_embedding, self.load_all_gallery_embeddings(), top_k=top_k, threshold=threshold) + + def log_recognition( + self, + source_type: str, + source_path: str, + predicted_person_id: Optional[int], + similarity: float, + threshold: float, + status: str, + payload: Optional[Dict[str, Any]] = None, + query_face_sample_id: Optional[int] = None, + ) -> int: + with self.connect() as conn: + cur = conn.execute( + """ + INSERT INTO recognition_logs ( + source_type, source_path, query_face_sample_id, predicted_person_id, + similarity, threshold, status, payload_json, created_at + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + ( + source_type, + source_path, + query_face_sample_id, + predicted_person_id, + similarity, + threshold, + status, + safe_json_dumps(payload or {}), + utc_now_iso(), + ), + ) + return int(cur.lastrowid) + + def save_evaluation_run( + self, + scenario: str, + model_name: str, + provider: str, + threshold: float, + dataset_summary: Dict[str, Any], + metrics: Dict[str, Any], + hardware: Dict[str, Any], + report_path: str = "", + created_at: Optional[str] = None, + ) -> int: + with self.connect() as conn: + cur = conn.execute( + """ + INSERT INTO evaluation_runs ( + scenario, model_name, provider, threshold, dataset_summary_json, + metrics_json, hardware_json, report_path, created_at + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + ( + scenario, + model_name, + provider, + threshold, + safe_json_dumps(dataset_summary), + safe_json_dumps(metrics), + safe_json_dumps(hardware), + report_path, + created_at or utc_now_iso(), + ), + ) + return int(cur.lastrowid) + + def list_evaluation_runs(self) -> List[Dict[str, Any]]: + with self.connect() as conn: + rows = conn.execute("SELECT * FROM evaluation_runs ORDER BY created_at DESC, id DESC").fetchall() + result = [] + for row in rows: + item = dict(row) + for key in ("dataset_summary_json", "metrics_json", "hardware_json"): + try: + item[key.replace("_json", "")] = json.loads(item.get(key) or "{}") + except Exception: + item[key.replace("_json", "")] = {} + result.append(item) + return result + + def delete_evaluation_run(self, run_id: int) -> None: + with self.connect() as conn: + conn.execute("DELETE FROM evaluation_runs WHERE id=?", (run_id,)) + + def get_setting(self, key: str, default: Optional[str] = None) -> Optional[str]: + with self.connect() as conn: + row = conn.execute("SELECT value FROM app_settings WHERE key=?", (key,)).fetchone() + return row["value"] if row else default + + def set_setting(self, key: str, value: Any) -> None: + with self.connect() as conn: + conn.execute( + """ + INSERT INTO app_settings (key, value, updated_at) + VALUES (?, ?, ?) + ON CONFLICT(key) DO UPDATE SET value=excluded.value, updated_at=excluded.updated_at + """, + (key, str(value), utc_now_iso()), + ) + + def delete_setting(self, key: str) -> None: + with self.connect() as conn: + conn.execute("DELETE FROM app_settings WHERE key=?", (key,)) + + def list_album_directories(self) -> List[str]: + raw = self.get_setting(ALBUM_DIRECTORIES_SETTING, "[]") + try: + values = json.loads(raw or "[]") + except Exception: + return [] + if not isinstance(values, list): + return [] + directories = [] + seen = set() + for value in values: + path = str(value) + if path and path not in seen: + directories.append(path) + seen.add(path) + return directories + + def save_album_directories(self, directories: Iterable[str]) -> None: + values = [] + seen = set() + for directory in directories: + path = str(directory) + if path and path not in seen: + values.append(path) + seen.add(path) + self.set_setting(ALBUM_DIRECTORIES_SETTING, json.dumps(values, ensure_ascii=False)) + + def save_album_results( + self, + clusters: Iterable[Dict[str, Any]], + cluster_items: Dict[int, List[Dict[str, Any]]], + algorithm: str, + cluster_threshold: Optional[float] = None, + min_samples: int = 2, + min_face_size: Optional[int] = None, + ) -> None: + now = utc_now_iso() + serializable_clusters: List[Dict[str, Any]] = [] + assignments: List[tuple[int, int]] = [] + for cluster in clusters: + cluster_id = int(cluster["id"]) + items = cluster_items.get(cluster_id, []) + face_ids = [int(item["id"]) for item in items if item.get("id") is not None] + for face_id in face_ids: + assignments.append((cluster_id, face_id)) + data = { + "id": cluster_id, + "label": cluster.get("label"), + "name": cluster.get("name", f"Album Person {cluster_id}"), + "source": cluster.get("source", "album"), + "face_count": int(cluster.get("face_count") or len(face_ids)), + "photo_count": int(cluster.get("photo_count") or 0), + "avg_quality": float(cluster.get("avg_quality") or 0.0), + "thumbnail_path": cluster.get("thumbnail_path") or "", + "thumbnail_face_id": cluster.get("thumbnail_face_id"), + "photos": list(cluster.get("photos") or []), + "face_ids": face_ids, + } + serializable_clusters.append(data) + payload = { + "version": 1, + "algorithm": algorithm, + "cluster_threshold": float(cluster_threshold) if cluster_threshold is not None else None, + "min_samples": int(min_samples), + "min_face_size": int(min_face_size) if min_face_size is not None else None, + "clusters": serializable_clusters, + "updated_at": now, + } + with self.connect() as conn: + conn.execute( + """ + INSERT INTO app_settings (key, value, updated_at) + VALUES (?, ?, ?) + ON CONFLICT(key) DO UPDATE SET value=excluded.value, updated_at=excluded.updated_at + """, + (ALBUM_RESULTS_SETTING, json.dumps(payload, ensure_ascii=False), now), + ) + conn.execute("UPDATE media_faces SET cluster_id=NULL, updated_at=?", (now,)) + conn.executemany( + "UPDATE media_faces SET cluster_id=?, status='clustered', updated_at=? WHERE id=?", + [(cluster_id, now, face_id) for cluster_id, face_id in assignments], + ) + + def load_album_results(self) -> Dict[str, Any]: + raw = self.get_setting(ALBUM_RESULTS_SETTING, "{}") + try: + data = json.loads(raw or "{}") + except Exception: + return {} + return data if isinstance(data, dict) else {} + + def clear_album_results(self) -> None: + now = utc_now_iso() + with self.connect() as conn: + conn.execute("DELETE FROM app_settings WHERE key=?", (ALBUM_RESULTS_SETTING,)) + conn.execute("UPDATE media_faces SET cluster_id=NULL, updated_at=?", (now,)) + + def delete_media_items_by_paths(self, paths: Iterable[str]) -> int: + values = [str(path) for path in paths] + if not values: + return 0 + deleted = 0 + with self.connect() as conn: + for index in range(0, len(values), 900): + chunk = values[index : index + 900] + placeholders = ",".join("?" for _ in chunk) + rows = conn.execute(f"SELECT id FROM media_items WHERE path IN ({placeholders})", chunk).fetchall() + media_ids = [int(row["id"]) for row in rows] + if not media_ids: + continue + id_placeholders = ",".join("?" for _ in media_ids) + conn.execute(f"DELETE FROM media_faces WHERE media_id IN ({id_placeholders})", media_ids) + conn.execute(f"DELETE FROM media_items WHERE id IN ({id_placeholders})", media_ids) + deleted += len(media_ids) + return deleted + + def existing_media_paths(self, paths: Iterable[str]) -> set[str]: + values = [str(path) for path in paths] + if not values: + return set() + existing: set[str] = set() + with self.connect() as conn: + for index in range(0, len(values), 900): + chunk = values[index : index + 900] + placeholders = ",".join("?" for _ in chunk) + rows = conn.execute(f"SELECT path FROM media_items WHERE path IN ({placeholders})", chunk).fetchall() + existing.update(str(row["path"]) for row in rows) + return existing + + def list_media_faces(self) -> List[Dict[str, Any]]: + with self.connect() as conn: + rows = conn.execute( + """ + SELECT mf.*, mi.path AS media_path, mi.media_type, mi.width, mi.height, + mi.thumbnail AS media_thumbnail, + mi.thumbnail_mime AS media_thumbnail_mime + FROM media_faces mf + JOIN media_items mi ON mi.id = mf.media_id + WHERE mf.embedding IS NOT NULL + ORDER BY mf.created_at DESC, mf.id DESC + """ + ).fetchall() + result = [] + for row in rows: + item = dict(row) + item["embedding"] = blob_to_embedding(item.get("embedding"), item.get("embedding_dim")) + for key in ("bbox_json", "kps_json"): + try: + item[key.replace("_json", "")] = json.loads(item[key]) if item.get(key) else None + except Exception: + item[key.replace("_json", "")] = None + result.append(item) + return result + + def counts(self) -> Dict[str, int]: + with self.connect() as conn: + return { + "people": int(conn.execute("SELECT COUNT(*) FROM people").fetchone()[0]), + "face_samples": int(conn.execute("SELECT COUNT(*) FROM face_samples").fetchone()[0]), + "media_items": int(conn.execute("SELECT COUNT(*) FROM media_items").fetchone()[0]), + "media_faces": int(conn.execute("SELECT COUNT(*) FROM media_faces").fetchone()[0]), + "evaluation_runs": int(conn.execute("SELECT COUNT(*) FROM evaluation_runs").fetchone()[0]), + } diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/swap.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/swap.py new file mode 100644 index 0000000000000000000000000000000000000000..4b06738d4921689a1774daca65bdcff097b656d8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/swap.py @@ -0,0 +1,116 @@ +"""Face swap model wrapper.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Optional + +import numpy as np + + +class GFPGANRestorer: + """Small ONNXRuntime wrapper for GFPGAN 512x512 face restoration.""" + + def __init__(self, model_path: str = "", providers: Optional[list[str]] = None): + self.model_path = model_path + self.providers = providers or ["CPUExecutionProvider"] + self.session = None + self.input_name = "" + self.output_name = "" + self.last_error = "" + + def load(self) -> bool: + path = Path(self.model_path).expanduser() + if not path.exists(): + self.last_error = "GFPGAN model not found. Download GFPGANv1.4.onnx in Models > Downloads first." + return False + try: + import onnxruntime + + onnxruntime.set_default_logger_severity(3) + self.session = onnxruntime.InferenceSession(str(path), providers=self.providers) + self.input_name = self.session.get_inputs()[0].name + self.output_name = self.session.get_outputs()[0].name + return True + except Exception as exc: + self.last_error = f"GFPGAN model load failed: {exc}" + return False + + def restore(self, image: np.ndarray) -> np.ndarray: + if self.session is None: + raise RuntimeError("GFPGAN model is not loaded.") + try: + import cv2 + except Exception as exc: + raise RuntimeError(f"OpenCV is required for GFPGAN post-processing: {exc}") from exc + + original_height, original_width = image.shape[:2] + resized = cv2.resize(image, (512, 512), interpolation=cv2.INTER_LINEAR) + rgb = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0 + tensor = ((rgb - 0.5) / 0.5).transpose(2, 0, 1)[None, :, :, :] + outputs = self.session.run([self.output_name], {self.input_name: tensor.astype(np.float32)}) + restored = np.asarray(outputs[0]) + if restored.ndim == 4: + restored = restored[0] + if restored.shape[0] == 3: + restored = restored.transpose(1, 2, 0) + restored = restored.astype(np.float32) + if float(restored.min()) < 0.0: + restored = (restored + 1.0) * 0.5 + restored = np.clip(restored, 0.0, 1.0) + restored = (restored * 255.0).round().astype(np.uint8) + bgr = cv2.cvtColor(restored, cv2.COLOR_RGB2BGR) + if (original_width, original_height) != (512, 512): + bgr = cv2.resize(bgr, (original_width, original_height), interpolation=cv2.INTER_LINEAR) + return bgr + + +class FaceSwapEngine: + def __init__( + self, + model_path: str = "", + providers: Optional[list[str]] = None, + gfpgan_model_path: str = "", + enable_gfpgan: bool = False, + ): + self.model_path = model_path + self.providers = providers or ["CPUExecutionProvider"] + self.model = None + self.enable_gfpgan = enable_gfpgan + self.restorer = GFPGANRestorer(gfpgan_model_path, self.providers) if enable_gfpgan else None + self.last_error = "" + + def is_available(self) -> bool: + return self.model is not None + + def load(self) -> bool: + path = Path(self.model_path).expanduser() + if not path.exists(): + self.last_error = ( + "Face swap model not found. Please configure a valid swap model in Models." + ) + return False + try: + import onnxruntime + from insightface.model_zoo import get_model + + onnxruntime.set_default_logger_severity(3) + self.model = get_model(str(path), providers=self.providers) + if self.model is None: + self.last_error = "Configured face swap model could not be recognized." + return False + if self.restorer is not None and not self.restorer.load(): + self.last_error = self.restorer.last_error + return False + return True + except Exception as exc: + self.last_error = f"Face swap model load failed: {exc}" + return False + + def swap(self, image: np.ndarray, target_face, source_face) -> np.ndarray: + if self.model is None: + raise RuntimeError("Face swap model not found. Please configure a valid swap model in Models.") + output = self.model.get(image, target_face, source_face, paste_back=True) + if self.restorer is not None: + output = self.restorer.restore(output) + return output diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/theme.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/theme.py new file mode 100644 index 0000000000000000000000000000000000000000..fbf2b99f5598aa6f82b7e01a5ce06d4d7af238d6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/theme.py @@ -0,0 +1,622 @@ +"""Qt stylesheet helpers for the desktop GUI.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from PySide6.QtCore import Qt +from PySide6.QtWidgets import QApplication + + +@dataclass(frozen=True) +class ThemeOption: + value: str + label: str + description: str + + +THEME_OPTIONS = [ + ThemeOption("system", "System", "Follow the operating system color scheme."), + ThemeOption("precision_light", "Precision Light", "Neutral white and graphite for long review sessions."), + ThemeOption("studio_dark", "Studio Dark", "Deep navy studio with violet and cyan model-workbench accents."), + ThemeOption("graphite_pro", "Graphite Pro", "Charcoal enterprise console with amber command accents."), + ThemeOption("azure_lab", "Azure Lab", "Bright blue laboratory workspace with crisp cyan interaction states."), + ThemeOption("emerald_focus", "Emerald Focus", "Green privacy-first workspace for local biometric review."), + ThemeOption("crimson_audit", "Crimson Audit", "Warm red audit theme for risk review and compliance workflows."), +] + +_THEME_ALIASES = { + "light": "precision_light", + "dark": "studio_dark", +} + +_LIGHT_THEME = "precision_light" +_DARK_THEME = "studio_dark" + + +def normalize_theme(theme: str | None) -> str: + value = (theme or "system").strip().lower() + value = _THEME_ALIASES.get(value, value) + valid = {option.value for option in THEME_OPTIONS} + return value if value in valid else "system" + + +def theme_label(theme: str | None) -> str: + value = normalize_theme(theme) + for option in THEME_OPTIONS: + if option.value == value: + return option.label + return "System" + + +def theme_description(theme: str | None) -> str: + value = normalize_theme(theme) + for option in THEME_OPTIONS: + if option.value == value: + return option.description + return THEME_OPTIONS[0].description + + +def effective_theme(theme: str | None) -> str: + value = normalize_theme(theme) + if value != "system": + return value + app = QApplication.instance() + if app is not None: + try: + if app.styleHints().colorScheme() == Qt.ColorScheme.Dark: + return _DARK_THEME + except Exception: + pass + return _LIGHT_THEME + + +def _palettes() -> dict[str, dict[str, str]]: + return { + "precision_light": { + "font": '"Segoe UI", "Inter", "Noto Sans", "Helvetica Neue", Arial, sans-serif', + "bg": "#f5f5f2", + "surface": "#ffffff", + "surface_alt": "#eceee9", + "panel": "#e2e4dd", + "panel_hover": "#d9dcd4", + "text": "#1f2428", + "muted": "#636a70", + "subtle": "#8a9096", + "border": "#d0d3ca", + "border_strong": "#a8ada4", + "accent": "#2f3a45", + "accent_2": "#5a6672", + "accent_soft": "#dfe3e7", + "accent_faint": "#f0f2f3", + "field": "#ffffff", + "button": "#ffffff", + "button_hover": "#ebece8", + "button_pressed": "#dfe3e7", + "selection": "#d2d8dd", + "success": "#2f855a", + "success_soft": "#dcefe5", + "warning": "#b7791f", + "danger": "#c53030", + "danger_hover": "#9b2c2c", + "upload_bg": "#f7f7f4", + "upload_hover": "#eceee9", + "upload_drag": "#e2f2e8", + "upload_file": "#ffffff", + "notice_bg": "#eceee9", + "notice_border": "#c8cdc4", + "table_alt": "#f7f7f4", + "header": "#e4e7e0", + "chip": "#f4f5f2", + }, + "studio_dark": { + "font": '"Segoe UI", "Inter", "Noto Sans", "Helvetica Neue", Arial, sans-serif', + "bg": "#070b1d", + "surface": "#0d1533", + "surface_alt": "#121d42", + "panel": "#18295b", + "panel_hover": "#213575", + "text": "#edf3ff", + "muted": "#a9b8d8", + "subtle": "#7284ae", + "border": "#27386f", + "border_strong": "#4a63b3", + "accent": "#7c5cff", + "accent_2": "#24d6ff", + "accent_soft": "#241d63", + "accent_faint": "#111949", + "field": "#080f28", + "button": "#14204a", + "button_hover": "#1b2d65", + "button_pressed": "#251f6d", + "selection": "#332b82", + "success": "#2ee6a6", + "success_soft": "#0e3a33", + "warning": "#ffca4f", + "danger": "#ff5c8a", + "danger_hover": "#d93668", + "upload_bg": "#0b1431", + "upload_hover": "#13265a", + "upload_drag": "#083840", + "upload_file": "#0d1533", + "notice_bg": "#121d54", + "notice_border": "#3750a4", + "table_alt": "#101a3d", + "header": "#17265a", + "chip": "#121d42", + }, + "graphite_pro": { + "font": '"Segoe UI", "Inter", "Noto Sans", "Helvetica Neue", Arial, sans-serif', + "bg": "#13110d", + "surface": "#1b1914", + "surface_alt": "#252119", + "panel": "#30291d", + "panel_hover": "#3a3122", + "text": "#f6f1e8", + "muted": "#c2b8a8", + "subtle": "#8d8375", + "border": "#3e3527", + "border_strong": "#6a5840", + "accent": "#f59e0b", + "accent_2": "#facc15", + "accent_soft": "#4a320d", + "accent_faint": "#2a2114", + "field": "#12100d", + "button": "#272218", + "button_hover": "#3a3122", + "button_pressed": "#4a320d", + "selection": "#62440f", + "success": "#84cc16", + "success_soft": "#26350f", + "warning": "#f97316", + "danger": "#f43f5e", + "danger_hover": "#be123c", + "upload_bg": "#19160f", + "upload_hover": "#2f2515", + "upload_drag": "#27340f", + "upload_file": "#1b1914", + "notice_bg": "#2a2114", + "notice_border": "#76541c", + "table_alt": "#211d16", + "header": "#30291d", + "chip": "#272218", + }, + "azure_lab": { + "font": '"Segoe UI", "Inter", "Noto Sans", "Helvetica Neue", Arial, sans-serif', + "bg": "#e5f2ff", + "surface": "#fafdff", + "surface_alt": "#d8ebff", + "panel": "#c3ddff", + "panel_hover": "#aed0ff", + "text": "#09264a", + "muted": "#31577d", + "subtle": "#6685a4", + "border": "#a9cbf3", + "border_strong": "#5b9bed", + "accent": "#075eea", + "accent_2": "#00a4ff", + "accent_soft": "#bfe0ff", + "accent_faint": "#eef8ff", + "field": "#ffffff", + "button": "#fafdff", + "button_hover": "#d8ebff", + "button_pressed": "#bfe0ff", + "selection": "#93c5fd", + "success": "#009b72", + "success_soft": "#c9f5e7", + "warning": "#c27200", + "danger": "#d92d5b", + "danger_hover": "#a61d42", + "upload_bg": "#fafdff", + "upload_hover": "#d8ebff", + "upload_drag": "#c9f5ff", + "upload_file": "#ffffff", + "notice_bg": "#d8ebff", + "notice_border": "#77b5f7", + "table_alt": "#eef7ff", + "header": "#cfe4ff", + "chip": "#e8f4ff", + }, + "emerald_focus": { + "font": '"Segoe UI", "Inter", "Noto Sans", "Helvetica Neue", Arial, sans-serif', + "bg": "#e8f7ef", + "surface": "#f8fff9", + "surface_alt": "#d7f2e2", + "panel": "#bfe8d1", + "panel_hover": "#a8ddc2", + "text": "#0d2f22", + "muted": "#3b6b58", + "subtle": "#6f927f", + "border": "#9bd2b5", + "border_strong": "#4fa878", + "accent": "#07844f", + "accent_2": "#00b894", + "accent_soft": "#b9ead1", + "accent_faint": "#eefbf3", + "field": "#ffffff", + "button": "#f8fff9", + "button_hover": "#d7f2e2", + "button_pressed": "#b9ead1", + "selection": "#8bdcb2", + "success": "#079455", + "success_soft": "#c6f6d5", + "warning": "#b7791f", + "danger": "#c2415b", + "danger_hover": "#9f1239", + "upload_bg": "#f8fff9", + "upload_hover": "#d7f2e2", + "upload_drag": "#c6f6d5", + "upload_file": "#ffffff", + "notice_bg": "#d7f2e2", + "notice_border": "#63bd8e", + "table_alt": "#eefaf3", + "header": "#cdebdc", + "chip": "#e9f8ef", + }, + "crimson_audit": { + "font": '"Segoe UI", "Inter", "Noto Sans", "Helvetica Neue", Arial, sans-serif', + "bg": "#190b10", + "surface": "#241018", + "surface_alt": "#321522", + "panel": "#451b2c", + "panel_hover": "#5a2438", + "text": "#fff1f4", + "muted": "#e5a9b5", + "subtle": "#ae7280", + "border": "#653046", + "border_strong": "#9f4965", + "accent": "#ff3b6b", + "accent_2": "#ff8a3d", + "accent_soft": "#5a1830", + "accent_faint": "#32101f", + "field": "#1b0c12", + "button": "#351724", + "button_hover": "#512236", + "button_pressed": "#641d36", + "selection": "#7f2946", + "success": "#22c55e", + "success_soft": "#123422", + "warning": "#f97316", + "danger": "#ff3b6b", + "danger_hover": "#be123c", + "upload_bg": "#1f0d15", + "upload_hover": "#42182b", + "upload_drag": "#2d2a10", + "upload_file": "#241018", + "notice_bg": "#3a1427", + "notice_border": "#8c3a55", + "table_alt": "#2b1320", + "header": "#3b1828", + "chip": "#321522", + }, + } + + +def application_stylesheet(theme: str | None) -> str: + palette = _palettes()[effective_theme(theme)] + + return f""" + * {{ + font-family: {palette["font"]}; + font-size: 13px; + }} + QMainWindow, QDialog {{ + background: {palette["bg"]}; + color: {palette["text"]}; + }} + QWidget {{ + color: {palette["text"]}; + selection-background-color: {palette["selection"]}; + selection-color: {palette["text"]}; + }} + QWidget#topAppBar {{ + background: {palette["surface"]}; + border-bottom: 1px solid {palette["border"]}; + }} + QWidget#modeRail {{ + background: {palette["surface"]}; + border-right: 1px solid {palette["border"]}; + }} + QWidget#modeSidebar {{ + background: {palette["surface_alt"]}; + border-right: 1px solid {palette["border"]}; + }} + QLabel[role="muted"], QLabel[role="status"], QLabel[role="secondary"] {{ + color: {palette["muted"]}; + }} + QLabel[role="statusChip"] {{ + padding: 4px 9px; + border: 1px solid {palette["border"]}; + border-radius: 6px; + background: {palette["chip"]}; + color: {palette["text"]}; + font-weight: 600; + }} + QLabel#noticeLabel {{ + background: {palette["notice_bg"]}; + border: 1px solid {palette["notice_border"]}; + border-radius: 6px; + color: {palette["text"]}; + padding: 9px 10px; + }} + QLabel#localProcessingNotice {{ + background: {palette["notice_bg"]}; + border: 1px solid {palette["notice_border"]}; + border-radius: 8px; + color: {palette["muted"]}; + padding: 9px 10px; + line-height: 1.25; + }} + QFrame#downloadSourceFooter {{ + background: {palette["surface_alt"]}; + border: 1px solid {palette["border"]}; + border-radius: 6px; + }} + QPushButton {{ + background: {palette["button"]}; + color: {palette["text"]}; + border: 1px solid {palette["border"]}; + border-radius: 6px; + padding: 7px 12px; + font-weight: 600; + }} + QPushButton:hover {{ + background: {palette["button_hover"]}; + border-color: {palette["border_strong"]}; + }} + QPushButton:pressed {{ + background: {palette["button_pressed"]}; + border-color: {palette["accent"]}; + }} + QPushButton:disabled {{ + color: {palette["subtle"]}; + background: {palette["surface_alt"]}; + border-color: {palette["border"]}; + }} + QPushButton#primaryButton {{ + background: {palette["accent"]}; + border-color: {palette["accent"]}; + color: #ffffff; + }} + QPushButton#primaryButton:hover {{ + background: {palette["accent_2"]}; + border-color: {palette["accent_2"]}; + }} + QPushButton#removeUpload {{ + background: {palette["button_pressed"]}; + color: {palette["text"]}; + border: 1px solid {palette["border_strong"]}; + border-radius: 11px; + font-weight: 700; + padding: 0; + }} + QPushButton#removeUpload:hover {{ + background: {palette["danger"]}; + border-color: {palette["danger"]}; + color: #ffffff; + }} + QLineEdit, QComboBox, QSpinBox, QDoubleSpinBox, QTextEdit, QPlainTextEdit {{ + background: {palette["field"]}; + color: {palette["text"]}; + border: 1px solid {palette["border"]}; + border-radius: 6px; + padding: 6px 8px; + }} + QLineEdit:focus, QComboBox:focus, QSpinBox:focus, QDoubleSpinBox:focus, + QTextEdit:focus, QPlainTextEdit:focus {{ + border-color: {palette["accent"]}; + background: {palette["surface"]}; + }} + QComboBox::drop-down {{ + border: 0; + width: 24px; + }} + QAbstractItemView {{ + background: {palette["surface"]}; + color: {palette["text"]}; + border: 1px solid {palette["border"]}; + selection-background-color: {palette["selection"]}; + }} + QComboBox QAbstractItemView::item:disabled {{ + color: {palette["subtle"]}; + background: {palette["surface_alt"]}; + }} + QListWidget {{ + background: transparent; + border: 0; + outline: 0; + }} + QListWidget::item {{ + border-radius: 6px; + padding: 8px 10px; + margin: 2px 0; + }} + QListWidget::item:selected {{ + background: {palette["accent_soft"]}; + color: {palette["text"]}; + }} + QListWidget::item:hover {{ + background: {palette["button_hover"]}; + }} + QListWidget#modeList::item {{ + border-radius: 8px; + padding: 10px 10px; + margin: 3px 0; + color: {palette["muted"]}; + border: 1px solid transparent; + }} + QListWidget#modeList::item:selected {{ + background: {palette["accent_soft"]}; + color: {palette["text"]}; + border: 1px solid {palette["accent"]}; + }} + QListWidget#modeList::item:hover {{ + background: {palette["button_hover"]}; + color: {palette["text"]}; + }} + QTableWidget, QTableView {{ + background: {palette["surface"]}; + alternate-background-color: {palette["table_alt"]}; + color: {palette["text"]}; + gridline-color: {palette["border"]}; + border: 1px solid {palette["border"]}; + border-radius: 6px; + selection-background-color: {palette["selection"]}; + }} + QTableWidget::item, QTableView::item {{ + padding: 4px; + }} + QTableWidget::item:selected, QTableView::item:selected {{ + background: {palette["selection"]}; + color: {palette["text"]}; + }} + QHeaderView::section {{ + background: {palette["header"]}; + color: {palette["text"]}; + border: 0; + border-bottom: 1px solid {palette["border"]}; + padding: 7px; + font-weight: 650; + }} + QFrame, QWidget#dashboardCard {{ + border-color: {palette["border"]}; + }} + QWidget#dashboardCard {{ + border: 1px solid {palette["border"]}; + border-radius: 6px; + background: {palette["surface"]}; + }} + QWidget#dashboardCard:hover {{ + border-color: {palette["accent"]}; + background: {palette["surface_alt"]}; + }} + QFrame#enterpriseCard {{ + border: 1px solid {palette["border"]}; + border-radius: 6px; + background: {palette["surface"]}; + padding: 10px; + }} + QLabel#enterpriseCardTitle {{ + color: {palette["text"]}; + }} + QFrame#uploadPreview, QFrame#dropInput, QFrame#galleryUpload, + QFrame#imageOrFolderImport, QListWidget#albumDirectoryList {{ + border: 1px dashed {palette["border_strong"]}; + border-radius: 6px; + background: {palette["upload_bg"]}; + padding: 8px; + }} + QFrame#uploadPreview[hoverActive="true"], QFrame#dropInput[hoverActive="true"], + QFrame#galleryUpload[hoverActive="true"], QFrame#imageOrFolderImport[hoverActive="true"], + QListWidget#albumDirectoryList[hoverActive="true"] {{ + border-color: {palette["accent"]}; + background: {palette["upload_hover"]}; + }} + QFrame#uploadPreview[dragActive="true"], QFrame#dropInput[dragActive="true"], + QFrame#galleryUpload[dragActive="true"], QFrame#imageOrFolderImport[dragActive="true"], + QListWidget#albumDirectoryList[dragActive="true"] {{ + border-color: {palette["success"]}; + background: {palette["upload_drag"]}; + }} + QFrame#uploadPreview[hasFile="true"], QFrame#dropInput[hasFiles="true"], + QFrame#galleryUpload[hasFiles="true"] {{ + border: 1px solid {palette["border"]}; + background: {palette["upload_file"]}; + }} + QFrame#uploadPreview QLabel, QFrame#dropInput QLabel, QFrame#galleryUpload QLabel, + QFrame#imageOrFolderImport QLabel {{ + background: transparent; + }} + QFrame#uploadPreview QGraphicsView, QFrame#galleryUpload QListWidget {{ + background: transparent; + border: 0; + }} + QGraphicsView#imageViewer {{ + background: {palette["upload_bg"]}; + border: 1px solid {palette["border"]}; + border-radius: 6px; + }} + QWidget#imageViewerViewport {{ + background: {palette["upload_bg"]}; + }} + QLabel#uploadPrompt, QLabel#dropPrompt {{ + color: {palette["muted"]}; + font-size: 15px; + font-weight: 650; + padding: 18px; + }} + QLabel#pathLabel {{ + color: {palette["muted"]}; + padding: 0 8px 8px 8px; + }} + QMenuBar, QMenu {{ + background: {palette["surface"]}; + color: {palette["text"]}; + border-color: {palette["border"]}; + }} + QMenuBar::item:selected, QMenu::item:selected {{ + background: {palette["accent_soft"]}; + }} + QTabWidget::pane {{ + border: 1px solid {palette["border"]}; + border-radius: 6px; + background: {palette["surface"]}; + }} + QTabBar::tab {{ + background: {palette["surface_alt"]}; + border: 1px solid {palette["border"]}; + border-bottom: 0; + padding: 7px 12px; + margin-right: 2px; + border-top-left-radius: 6px; + border-top-right-radius: 6px; + }} + QTabBar::tab:selected {{ + background: {palette["surface"]}; + color: {palette["accent"]}; + }} + QProgressBar {{ + background: {palette["surface_alt"]}; + border: 1px solid {palette["border"]}; + border-radius: 6px; + color: {palette["text"]}; + text-align: center; + }} + QProgressBar::chunk {{ + background: {palette["accent"]}; + border-radius: 5px; + }} + QSlider::groove:horizontal {{ + height: 6px; + background: {palette["surface_alt"]}; + border: 1px solid {palette["border"]}; + border-radius: 3px; + }} + QSlider::handle:horizontal {{ + background: {palette["accent"]}; + border: 1px solid {palette["accent"]}; + width: 16px; + height: 16px; + margin: -6px 0; + border-radius: 8px; + }} + QSplitter::handle {{ + background: {palette["bg"]}; + }} + QScrollArea {{ + background: transparent; + border: 0; + }} + QStatusBar {{ + background: {palette["surface"]}; + color: {palette["muted"]}; + border-top: 1px solid {palette["border"]}; + }} + QToolTip {{ + background: {palette["surface"]}; + color: {palette["text"]}; + border: 1px solid {palette["border"]}; + border-radius: 4px; + padding: 4px; + }} + """ diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/tooltips.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/tooltips.py new file mode 100644 index 0000000000000000000000000000000000000000..ea958ce810d6ef8ee4f7ce0db02fde584f673e31 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/tooltips.py @@ -0,0 +1,108 @@ +"""Shared button tooltip helpers.""" + +from __future__ import annotations + +import re + +from PySide6.QtWidgets import QAbstractButton, QWidget + + +BUTTON_TOOLTIPS = { + "Add Folder": "Add an album folder to the import list.", + "Add Person": "Create a new person entry in the local People Library.", + "Add as New Person": "Register the current face as a new person.", + "Apply": "Apply changes without closing this dialog.", + "Assign to Existing Person": "Assign the current face to an existing person.", + "Browse": "Choose a local file or folder.", + "Cancel": "Close without applying changes.", + "Check Cameras": "Check available local camera devices.", + "Clear": "Clear the current selection or form.", + "Compare": "Run 1:1 face comparison for the selected images.", + "Contact Enterprise Support": "Open the InsightFace enterprise support contact page.", + "Delete": "Delete the selected item.", + "Delete Selected": "Delete the selected record.", + "Download Selected": "Download the selected model package to the local model cache.", + "Exit": "Close the application.", + "Export": "Export the current results.", + "Export All Summary": "Export a summary of all available records.", + "Export Annotated Image": "Export the image with face labels drawn on it.", + "Export CSV": "Export the current table as CSV.", + "Export CSV / JSON": "Export current results as CSV and JSON.", + "Export License Summary": "Save a local license summary report.", + "Export Report": "Export the current evaluation report.", + "Export Result": "Export the current result.", + "Export Results": "Export the current results.", + "Export Settings": "Export application settings to a JSON file.", + "Import / Refresh": "Scan selected folders for new images and rebuild album clusters from indexed faces.", + "Import Image or Folder": "Import one image or a folder of images by clicking or dragging files here.", + "Import Settings": "Import application settings from a JSON file.", + "Open": "Open the selected item.", + "Open GitHub Releases": "Open the InsightFace GitHub Releases page.", + "Open License Center": "Open license and commercial usage information.", + "Open Model Downloads": "Open the model downloads tab.", + "Open Model Folder": "Open the local InsightFace model folder.", + "Open Report Folder": "Open the local folder where reports are saved.", + "Open Result Directory": "Open the local folder where face swap results are saved.", + "Open Selected Report": "Open the selected report file.", + "Open Workspace Folder": "Open the local workspace folder.", + "Re-export Selected": "Regenerate and export the selected report.", + "Rebuild All": "Reprocess selected album folders from scratch after confirmation.", + "Recognize Faces": "Detect and recognize all faces in the selected image.", + "Refresh": "Reload the current list from local storage.", + "Refresh Download URLs": "Refresh available model download URLs from GitHub Releases.", + "Refresh People": "Reload people from the local People Library.", + "Register Current Face": "Register the current camera face as a person.", + "Remove": "Remove the selected item.", + "Remove Selected": "Remove selected items from this list.", + "Request Commercial Model License": "Show contact options for commercial model licensing.", + "Request Face Swap Commercial License": "Show contact options for face swap commercial licensing.", + "Request Private Model Evaluation": "Show contact options for private model evaluation.", + "Request SDK / API": "Show contact options for SDK or API access.", + "Reset": "Reset this page to its initial state.", + "Reset Settings": "Reset application settings to their defaults.", + "Run Evaluation": "Run the selected local enterprise evaluation.", + "Run Face Swap": "Run face swap with the configured local swap model.", + "Run Recognition": "Run 1:1 comparison or 1:N gallery recognition.", + "Save": "Save changes and close this dialog.", + "Save Details": "Save the current person details.", + "Save Settings": "Save the current settings.", + "Scan": "Scan selected local data.", + "Scan and Cluster": "Scan images and cluster detected faces.", + "Search": "Search the local People Library for matching faces.", + "Select": "Select a local file or folder.", + "Start": "Start the current processing task.", + "Stop": "Stop the current processing task.", + "Test Model Load": "Test loading the selected model and runtime provider.", + "Use Selected Model": "Use the selected downloaded model package.", + "Visit Homepage": "Open the InsightFace homepage.", + "Warmup": "Run a short model warmup to measure startup latency.", + "×": "Remove the current file.", +} + + +def normalize_button_text(text: str) -> str: + value = str(text or "").replace("&", "").strip() + value = re.sub(r"\s+", " ", value) + return value + + +def tooltip_for_button(text: str) -> str: + label = normalize_button_text(text) + if not label: + return "Click this button to run the related action." + if label in BUTTON_TOOLTIPS: + return BUTTON_TOOLTIPS[label] + if label.lower() == "ok": + return "Confirm and continue." + return f"Click to {label[0].lower() + label[1:]}." + + +def set_button_tooltip(button: QAbstractButton, tooltip: str | None = None) -> None: + if button.toolTip(): + return + button.setToolTip(tooltip or tooltip_for_button(button.text())) + + +def apply_button_tooltips(widget: QWidget) -> None: + for button in widget.findChildren(QAbstractButton): + set_button_tooltip(button) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/utils.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..bd245da3dd4cef43373560bffa18ac4e4fdfe00d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/utils.py @@ -0,0 +1,149 @@ +"""General utilities for image and file handling.""" + +from __future__ import annotations + +import hashlib +import json +import os +from io import BytesIO +from datetime import datetime +from pathlib import Path +from typing import Any, Iterable, Optional + +import numpy as np + + +def utc_now_iso() -> str: + return datetime.utcnow().replace(microsecond=0).isoformat() + "Z" + + +def read_image(path: str | os.PathLike[str]) -> Optional[np.ndarray]: + file_path = Path(path) + try: + import cv2 + + data = np.fromfile(str(file_path), dtype=np.uint8) + img = cv2.imdecode(data, cv2.IMREAD_COLOR) + return img + except Exception: + try: + from PIL import Image + + with Image.open(file_path) as image: + rgb = image.convert("RGB") + arr = np.asarray(rgb) + return arr[..., ::-1].copy() + except Exception: + return None + + +def save_image(path: str | os.PathLike[str], image: np.ndarray) -> bool: + file_path = Path(path) + file_path.parent.mkdir(parents=True, exist_ok=True) + try: + import cv2 + + ext = file_path.suffix or ".png" + ok, data = cv2.imencode(ext, image) + if not ok: + return False + data.tofile(str(file_path)) + return True + except Exception: + try: + from PIL import Image + + rgb = image[..., ::-1] if image.ndim == 3 and image.shape[2] >= 3 else image + Image.fromarray(rgb).save(file_path) + return True + except Exception: + return False + + +def encode_webp_thumbnail( + image: np.ndarray | None, + max_side: int, + quality: int, +) -> bytes | None: + """Encode an image array as a small WebP thumbnail. + + GUI image arrays are BGR when loaded through OpenCV. The helper converts to + RGB for Pillow, keeps aspect ratio, and returns compressed bytes for SQLite. + """ + + if image is None or image.size == 0: + return None + try: + from PIL import Image + + arr = np.asarray(image) + if arr.ndim == 3 and arr.shape[2] >= 3: + arr = arr[..., :3][..., ::-1] + pil_image = Image.fromarray(arr).convert("RGB") + width, height = pil_image.size + longest = max(width, height) + if longest <= 0: + return None + scale = min(1.0, float(max_side) / float(longest)) + target = (max(1, int(round(width * scale))), max(1, int(round(height * scale)))) + if target != pil_image.size: + pil_image = pil_image.resize(target, Image.Resampling.LANCZOS) + buffer = BytesIO() + pil_image.save(buffer, format="WEBP", quality=int(quality), method=6) + return buffer.getvalue() + except Exception: + return None + + +def crop_bbox(image: np.ndarray, bbox: Iterable[float], padding: float = 0.10) -> np.ndarray: + x1, y1, x2, y2 = [float(v) for v in bbox] + width = x2 - x1 + height = y2 - y1 + x1 -= width * padding + x2 += width * padding + y1 -= height * padding + y2 += height * padding + ix1, iy1 = max(0, int(round(x1))), max(0, int(round(y1))) + ix2, iy2 = min(image.shape[1], int(round(x2))), min(image.shape[0], int(round(y2))) + if ix2 <= ix1 or iy2 <= iy1: + return image.copy() + return image[iy1:iy2, ix1:ix2].copy() + + +def file_sha256(path: str | os.PathLike[str], chunk_size: int = 1024 * 1024) -> str: + digest = hashlib.sha256() + with open(path, "rb") as handle: + for chunk in iter(lambda: handle.read(chunk_size), b""): + digest.update(chunk) + return digest.hexdigest() + + +def safe_json_dumps(data: Any) -> str: + def default(value: Any) -> Any: + if isinstance(value, np.ndarray): + return value.tolist() + if isinstance(value, (np.floating, np.integer)): + return value.item() + if isinstance(value, Path): + return str(value) + return str(value) + + return json.dumps(data, ensure_ascii=False, default=default) + + +def timestamp_for_filename() -> str: + return datetime.now().strftime("%Y%m%d_%H%M%S") + + +def list_images(folder: str | os.PathLike[str], recursive: bool = True) -> list[Path]: + from .constants import IMAGE_EXTENSIONS + + root = Path(folder) + iterator = root.rglob("*") if recursive else root.glob("*") + return sorted(path for path in iterator if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS) + + +def human_ms(ms: float) -> str: + if ms < 1000: + return f"{ms:.1f} ms" + return f"{ms / 1000:.2f} s" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/video.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/video.py new file mode 100644 index 0000000000000000000000000000000000000000..3ad5992ff1572538665f04e8cbdc4f2f82645388 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/core/video.py @@ -0,0 +1,51 @@ +"""Simple video helpers for local processing.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Iterator, Tuple + +import numpy as np + + +def timestamp_hhmmss(timestamp_ms: int) -> str: + seconds = timestamp_ms // 1000 + h = seconds // 3600 + m = (seconds % 3600) // 60 + s = seconds % 60 + return f"{h:02d}:{m:02d}:{s:02d}" + + +def iter_video_frames(path: str | Path, frame_interval: int = 10) -> Iterator[Tuple[int, int, np.ndarray]]: + import cv2 + + cap = cv2.VideoCapture(str(path)) + if not cap.isOpened(): + raise IOError(f"Unable to open video: {path}") + fps = cap.get(cv2.CAP_PROP_FPS) or 25.0 + index = 0 + try: + while True: + ok, frame = cap.read() + if not ok: + break + if index % max(1, int(frame_interval)) == 0: + timestamp_ms = int(index / fps * 1000) + yield index, timestamp_ms, frame + index += 1 + finally: + cap.release() + + +def read_video_thumbnail(path: str | Path) -> np.ndarray | None: + """Read the first decodable frame from a video for GUI preview.""" + import cv2 + + cap = cv2.VideoCapture(str(path)) + if not cap.isOpened(): + return None + try: + ok, frame = cap.read() + return frame if ok else None + finally: + cap.release() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..32f8e01bc366ca2494637fe595a5ed69fb9e98ab --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/__init__.py @@ -0,0 +1 @@ +"""Global dialogs for InsightFace Evaluation Studio.""" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/license_dialog.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/license_dialog.py new file mode 100644 index 0000000000000000000000000000000000000000..5bc6f58ecd33dd95356275a21b1f054c25c226c1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/license_dialog.py @@ -0,0 +1,27 @@ +"""License dialog.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QDialog, QLabel, QVBoxLayout + +from ..core.i18n import tr +from ..pages.license_center_page import LicenseCenterPage + + +class LicenseDialog(QDialog): + def __init__(self, context, parent=None): + super().__init__(parent) + self.context = context + self.setWindowTitle("License Center") + self.resize(900, 660) + layout = QVBoxLayout(self) + self.page = LicenseCenterPage(context) + layout.addWidget(self.page, 1) + self.status_label = QLabel("") + self.status_label.setWordWrap(True) + layout.addWidget(self.status_label) + + def set_status(self, message: str) -> None: + self.status_label.setText(tr(message, self.context.config.ui_language)) + if self.parent() is not None and hasattr(self.parent(), "set_status"): + self.parent().set_status(message) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/model_manager_dialog.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/model_manager_dialog.py new file mode 100644 index 0000000000000000000000000000000000000000..24c24d2387b41add8e76bae17b3abcf9eb04c256 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/model_manager_dialog.py @@ -0,0 +1,74 @@ +"""Model runtime and download manager dialog.""" + +from __future__ import annotations + +from PySide6.QtCore import Signal +from PySide6.QtWidgets import QDialog, QLabel, QTabWidget, QVBoxLayout + +from ..core.i18n import tr +from ..pages.model_download_page import ModelDownloadPage +from ..pages.model_settings_page import ModelSettingsPage + + +class ModelManagerDialog(QDialog): + modelChanged = Signal() + + def __init__(self, context, parent=None): + super().__init__(parent) + self.context = context + self.setWindowTitle("Models") + self.setMinimumSize(1120, 700) + self.resize(1240, 740) + layout = QVBoxLayout(self) + self.tabs = QTabWidget() + self.runtime_page = ModelSettingsPage(context) + self.downloads_page = ModelDownloadPage(context) + self.tabs.addTab(self.runtime_page, "Runtime") + self.tabs.addTab(self.downloads_page, "Downloads") + self.tabs.currentChanged.connect(self._refresh_current_tab) + layout.addWidget(self.tabs, 1) + self.status_label = QLabel("") + self.status_label.setWordWrap(True) + layout.addWidget(self.status_label) + + def open_page(self, label: str) -> None: + if label == "Model Downloads": + self.tabs.setCurrentWidget(self.downloads_page) + self.downloads_page.refresh() + elif label == "Model Settings": + self.tabs.setCurrentWidget(self.runtime_page) + self.runtime_page.refresh() + + def set_status(self, message: str) -> None: + self.status_label.setText(tr(message, self.context.config.ui_language)) + self.modelChanged.emit() + if self.parent() is not None and hasattr(self.parent(), "set_status"): + self.parent().set_status(message) + + def run_task(self, title: str, fn, on_result=None, show_dialog: bool = True) -> None: + parent = self.parent() + if parent is not None and hasattr(parent, "run_task"): + parent.run_task(title, fn, on_result, show_dialog=show_dialog) + return + try: + result = fn() + if on_result: + on_result(result) + except Exception as exc: + self.set_status(str(exc)) + + def refresh_model_pages(self) -> None: + self.runtime_page.refresh() + self.downloads_page.populate() + self.modelChanged.emit() + + def _refresh_current_tab(self, index: int | None = None) -> None: + del index + widget = self.tabs.currentWidget() + if hasattr(widget, "refresh"): + widget.refresh() + + def refresh_statusbar(self) -> None: + self.modelChanged.emit() + if self.parent() is not None and hasattr(self.parent(), "refresh_statusbar"): + self.parent().refresh_statusbar() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/settings_dialog.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/settings_dialog.py new file mode 100644 index 0000000000000000000000000000000000000000..175c66d3a1dda42e898cb8ee8ecb05741336bd59 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/dialogs/settings_dialog.py @@ -0,0 +1,75 @@ +"""Application settings dialog.""" + +from __future__ import annotations + +from PySide6.QtCore import Signal +from PySide6.QtWidgets import QComboBox, QDialog, QDialogButtonBox, QFormLayout, QLabel, QVBoxLayout + +from ..core.config import save_config +from ..core.i18n import LANGUAGE_OPTIONS, apply_translations, normalize_language, tr +from ..core.theme import THEME_OPTIONS, normalize_theme, theme_description + + +class SettingsDialog(QDialog): + settingsSaved = Signal() + + def __init__(self, context, parent=None): + super().__init__(parent) + self.context = context + self.setWindowTitle("Settings") + self.resize(620, 300) + + layout = QVBoxLayout(self) + title = QLabel("Application Settings") + title.setStyleSheet("font-size:18px; font-weight:700;") + note = QLabel("Only appearance settings are configurable here. Workspace paths are fixed after first launch.") + note.setWordWrap(True) + note.setProperty("role", "muted") + layout.addWidget(title) + layout.addWidget(note) + + form = QFormLayout() + form.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) + self.theme = QComboBox() + for option in THEME_OPTIONS: + self.theme.addItem(option.label, option.value) + current = normalize_theme(self.context.config.ui_theme) + current_index = self.theme.findData(current) + self.theme.setCurrentIndex(max(0, current_index)) + self.theme.currentIndexChanged.connect(self._update_theme_description) + form.addRow("UI theme", self.theme) + self.language = QComboBox() + for option in LANGUAGE_OPTIONS: + self.language.addItem(option.native_label, option.value) + current_language = normalize_language(self.context.config.ui_language) + language_index = self.language.findData(current_language) + self.language.setCurrentIndex(max(0, language_index)) + self.language.currentIndexChanged.connect(self._update_theme_description) + form.addRow("Language", self.language) + layout.addLayout(form, 1) + self.theme_help = QLabel("") + self.theme_help.setWordWrap(True) + self.theme_help.setProperty("role", "muted") + layout.addWidget(self.theme_help) + self._update_theme_description() + + buttons = QDialogButtonBox(QDialogButtonBox.Save | QDialogButtonBox.Apply | QDialogButtonBox.Cancel) + buttons.button(QDialogButtonBox.Save).clicked.connect(self.save_and_close) + buttons.button(QDialogButtonBox.Apply).clicked.connect(self.apply) + buttons.button(QDialogButtonBox.Cancel).clicked.connect(self.reject) + layout.addWidget(buttons) + apply_translations(self, self.context.config.ui_language) + + def apply(self) -> None: + self.context.config.ui_theme = self.theme.currentData() + self.context.config.ui_language = self.language.currentData() + save_config(self.context.config) + self.settingsSaved.emit() + apply_translations(self, self.context.config.ui_language) + + def save_and_close(self) -> None: + self.apply() + self.accept() + + def _update_theme_description(self) -> None: + self.theme_help.setText(tr(theme_description(self.theme.currentData()), self.language.currentData())) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/main_window.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/main_window.py new file mode 100644 index 0000000000000000000000000000000000000000..455271f6ef2ea99dedc5321e1dc6df0ee3893b23 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/main_window.py @@ -0,0 +1,616 @@ +"""Main window, mode navigation, and task orchestration.""" + +from __future__ import annotations + +import inspect +from pathlib import Path +from typing import Callable + +from PySide6.QtCore import QObject, QRunnable, QSize, Qt, QThreadPool, QTimer, QUrl, Signal, Slot +from PySide6.QtGui import QAction, QDesktopServices, QFontMetrics, QKeySequence +from PySide6.QtWidgets import ( + QApplication, + QComboBox, + QDialog, + QDialogButtonBox, + QFileDialog, + QFormLayout, + QHBoxLayout, + QLabel, + QLineEdit, + QListWidget, + QListWidgetItem, + QMainWindow, + QMessageBox, + QPushButton, + QStackedWidget, + QStatusBar, + QVBoxLayout, + QWidget, +) + +from .core.config import save_config +from .core.constants import APP_VERSION, LOCAL_PROCESSING_NOTICE, RESPONSIBLE_USE_NOTICE, WINDOW_TITLE +from .core.face_engine import is_cuda_provider_available +from .core.i18n import apply_translations, tr +from .core.links import open_insightface_url +from .core.navigation import ( + AppMode, + NAVIGATION_MODES, + last_page_attr, + mode_from_value, +) +from .core.theme import application_stylesheet +from .core.tooltips import apply_button_tooltips, set_button_tooltip +from .dialogs.license_dialog import LicenseDialog +from .dialogs.model_manager_dialog import ModelManagerDialog +from .dialogs.settings_dialog import SettingsDialog +from .page_registry import PageRegistry +from .pages.license_center_page import ENTERPRISE_HELP_URL +from .resources import app_icon +from .widgets.progress_dialog import StudioProgressDialog + + +class WorkerSignals(QObject): + result = Signal(object) + error = Signal(str) + progress = Signal(int, int, str) + finished = Signal() + + +class Worker(QRunnable): + def __init__(self, fn: Callable): + super().__init__() + self.fn = fn + self.signals = WorkerSignals() + self.cancelled = False + + def cancel(self) -> None: + self.cancelled = True + + @Slot() + def run(self) -> None: + try: + signature = inspect.signature(self.fn) + if "progress" in signature.parameters or "is_cancelled" in signature.parameters: + result = self.fn( + progress=lambda current, total, message="": self.signals.progress.emit(int(current), int(total), str(message)), + is_cancelled=lambda: self.cancelled, + ) + else: + result = self.fn() + self.signals.result.emit(result) + except Exception as exc: + self.signals.error.emit(str(exc)) + finally: + self.signals.finished.emit() + + +class FirstLaunchWizard(QDialog): + def __init__(self, config, parent=None): + super().__init__(parent) + self.setWindowTitle("First Launch Wizard") + self.config = config + layout = QVBoxLayout(self) + intro = QLabel( + "\n".join( + [ + "Welcome to InsightFace Evaluation Studio.", + LOCAL_PROCESSING_NOTICE, + RESPONSIBLE_USE_NOTICE, + ] + ) + ) + intro.setWordWrap(True) + layout.addWidget(intro) + form = QFormLayout() + self.workspace = QLineEdit(config.workspace_path) + browse = QLabel("Browse") + browse.linkActivated.connect(self.browse_workspace) + workspace_row = QWidget() + workspace_layout = QVBoxLayout(workspace_row) + workspace_layout.setContentsMargins(0, 0, 0, 0) + workspace_layout.addWidget(self.workspace) + workspace_layout.addWidget(browse) + self.mode = QComboBox() + self.mode.setProperty("i18nItems", True) + self.mode.addItem("Personal / Research", "Personal / Research") + self.mode.addItem("Enterprise Evaluation", "Enterprise Evaluation") + self.model = QComboBox() + self.model.addItems(["buffalo_l", "buffalo_s", "antelopev2", "custom model directory"]) + self.provider = QComboBox() + self.provider.addItems(["Auto", "CPU", "CUDA"]) + self._update_provider_availability() + self.license_notice = QLabel( + "This application runs locally. Code and model licenses may differ. " + "Research models may be limited to non-commercial use. Commercial deployment " + "requires appropriate model license. This tool does not provide legal advice." + ) + self.license_notice.setWordWrap(True) + form.addRow("Workspace", workspace_row) + form.addRow("Mode", self.mode) + form.addRow("Model package", self.model) + form.addRow("Provider", self.provider) + form.addRow("License notice", self.license_notice) + layout.addLayout(form) + buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) + buttons.accepted.connect(self.accept) + buttons.rejected.connect(self.reject) + layout.addWidget(buttons) + apply_button_tooltips(self) + + def browse_workspace(self) -> None: + folder = QFileDialog.getExistingDirectory(self, "Select workspace", str(Path.home())) + if folder: + self.workspace.setText(folder) + + def accept(self) -> None: + self.config.workspace_path = self.workspace.text().strip() + self.config.mode = str(self.mode.currentData() or self.mode.currentText()) + self.config.ui_last_mode = ( + AppMode.ENTERPRISE_EVALUATION.value + if self.config.mode == "Enterprise Evaluation" + else AppMode.FACE_VERIFICATION.value + ) + selected_model = self.model.currentText() + self.config.model_name = selected_model if selected_model != "custom model directory" else self.config.model_name + provider = self.provider.currentText() + self.config.provider = "Auto" if provider == "CUDA" and not is_cuda_provider_available() else provider + self.config.apply_workspace_defaults() + save_config(self.config) + super().accept() + + def _update_provider_availability(self) -> None: + cuda_available = is_cuda_provider_available() + cuda_index = self.provider.findText("CUDA") + if cuda_index >= 0: + item = self.provider.model().item(cuda_index) + if item is not None: + item.setEnabled(cuda_available) + item.setToolTip( + "CUDAExecutionProvider is available." + if cuda_available + else "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first." + ) + self.provider.setToolTip("Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.") + + +class MainWindow(QMainWindow): + LEGACY_PAGE_MAP = { + "Dashboard": "face_dashboard", + "Face Recognition": "verification", + "Verification": "verification", + "Verification Dashboard": "face_dashboard", + "Album Dashboard": "album_dashboard", + "Swap Dashboard": "swap_dashboard", + "Evaluation Dashboard": "enterprise_dashboard", + "1:1 Compare": "compare", + "1:N Face Search": "face_search", + "Multi-face Photo Recognition": "multiface_photo", + "Batch Folder Processing": "batch_processing", + "Camera Recognition": "camera_recognition", + "Video Person Search": "video_search", + "People Library": "people_library", + "Album People Clustering": "album_people_clustering", + "Enterprise Evaluation": "enterprise_evaluation", + "Reports": "reports", + "Image Face Swap": "image_face_swap", + } + + GLOBAL_PAGES = {"Settings", "Model Settings", "Model Downloads", "License Center"} + + def __init__(self, context, parent=None): + super().__init__(parent) + self.context = context + self.apply_theme() + self.setWindowTitle(WINDOW_TITLE) + icon = app_icon() + if icon is not None and not icon.isNull(): + self.setWindowIcon(icon) + self.resize(int(context.config.ui_window_width), int(context.config.ui_window_height)) + self.thread_pool = QThreadPool.globalInstance() + self.active_workers: set[Worker] = set() + self.page_registry = PageRegistry(context) + self.pages = self.page_registry.pages + self.current_mode = mode_from_value(context.config.ui_last_mode) + self.current_page_key = "" + + self.stack = QStackedWidget() + self.mode_rail = QWidget() + self.mode_rail.setObjectName("modeRail") + self.mode_rail.setFixedWidth(230) + self.mode_list = QListWidget() + self.mode_list.setObjectName("modeList") + self.mode_list.setAlternatingRowColors(False) + self.mode_list.setWordWrap(True) + self.mode_list.setSpacing(2) + self.mode_list.itemClicked.connect(self._mode_list_clicked) + self.sidebar = QWidget() + self.sidebar.setObjectName("modeSidebar") + self.sidebar.setFixedWidth(int(context.config.ui_sidebar_width or 240)) + self.sidebar_title = QLabel() + self.sidebar_title.setStyleSheet("font-size:18px; font-weight:700;") + self.sidebar_description = QLabel() + self.sidebar_description.setWordWrap(True) + self.sidebar_description.setProperty("role", "muted") + self.sidebar_list = QListWidget() + self.sidebar_list.setAlternatingRowColors(False) + self.sidebar_list.itemClicked.connect(self._sidebar_clicked) + + central = QWidget() + root = QVBoxLayout(central) + root.setContentsMargins(0, 0, 0, 0) + root.setSpacing(0) + root.addWidget(self._build_top_bar()) + body = QWidget() + body_layout = QHBoxLayout(body) + body_layout.setContentsMargins(0, 0, 0, 0) + body_layout.addWidget(self._build_mode_rail()) + sidebar_layout = QVBoxLayout(self.sidebar) + sidebar_layout.setContentsMargins(14, 14, 10, 14) + sidebar_layout.addWidget(self.sidebar_title) + sidebar_layout.addWidget(self.sidebar_description) + sidebar_layout.addWidget(self.sidebar_list, 1) + body_layout.addWidget(self.sidebar) + body_layout.addWidget(self.stack, 1) + root.addWidget(body, 1) + self.setCentralWidget(central) + + self._build_menu() + self._build_statusbar() + apply_button_tooltips(self) + self.change_mode(self.current_mode, restore_last=True, save=False) + self.apply_language() + self.refresh_statusbar() + if not self.context.config_exists: + QTimer.singleShot(100, self.show_first_launch) + if self.context.config.auto_load_model and not self.context.runtime_safe_mode: + QTimer.singleShot(250, self.auto_load_model) + + def _build_top_bar(self) -> QWidget: + bar = QWidget() + bar.setObjectName("topAppBar") + layout = QHBoxLayout(bar) + layout.setContentsMargins(14, 8, 14, 8) + title = QLabel("InsightFace Evaluation Studio") + title.setStyleSheet("font-size:18px; font-weight:700; border:0;") + version = QLabel(f"v{APP_VERSION}") + version.setProperty("role", "muted") + self.model_chip = QLabel() + self.provider_chip = QLabel() + self.license_chip = QLabel() + for chip in (self.model_chip, self.provider_chip, self.license_chip): + chip.setProperty("role", "statusChip") + layout.addWidget(title) + layout.addWidget(version) + layout.addStretch(1) + layout.addWidget(self.model_chip) + layout.addWidget(self.provider_chip) + layout.addWidget(self.license_chip) + layout.addWidget(self._top_button("Models", self.open_model_manager)) + layout.addWidget(self._top_button("License", self.open_license_dialog)) + layout.addWidget(self._top_button("Settings", self.open_settings_dialog)) + return bar + + def _top_button(self, text: str, callback: Callable) -> QPushButton: + button = QPushButton(text) + button.clicked.connect(callback) + set_button_tooltip(button) + return button + + def _build_mode_rail(self) -> QWidget: + layout = QVBoxLayout(self.mode_rail) + layout.setContentsMargins(14, 14, 12, 14) + layout.setSpacing(8) + title = QLabel("Workflows") + title.setObjectName("modeRailTitle") + title.setStyleSheet("font-size:14px; font-weight:700; border:0;") + description = QLabel("Choose the workspace for the task.") + description.setProperty("role", "muted") + description.setWordWrap(True) + layout.addWidget(title) + layout.addWidget(description) + for mode in NAVIGATION_MODES.values(): + item = QListWidgetItem(f"{mode.title}\n{self._mode_subtitle(mode.id)}") + item.setData(Qt.UserRole, mode.id.value) + item.setToolTip(mode.description) + item.setSizeHint(QSize(190, 58)) + self.mode_list.addItem(item) + layout.addWidget(self.mode_list, 1) + local_notice = QLabel("All processing is local. No images, embeddings, or reports are uploaded automatically.") + local_notice.setObjectName("localProcessingNotice") + local_notice.setWordWrap(True) + layout.addWidget(local_notice) + layout.addSpacing(6) + enterprise_help = QPushButton("Enterprise Help") + enterprise_help.setObjectName("enterpriseHelpButton") + enterprise_help.setToolTip( + "Open the InsightFace contact page for enterprise evaluation, licensing, SDK/API, SLA, or custom training help." + ) + enterprise_help.clicked.connect(self.open_enterprise_help) + layout.addWidget(enterprise_help) + return self.mode_rail + + def _mode_subtitle(self, mode: AppMode) -> str: + subtitles = { + AppMode.FACE_VERIFICATION: "Query and gallery recognition", + AppMode.ALBUM_MANAGEMENT: "Photo clustering and review", + AppMode.FACE_SWAP: "Source + Target = Result", + AppMode.ENTERPRISE_EVALUATION: "Datasets, metrics, and reports", + } + return tr(subtitles[mode], self.context.config.ui_language) + + def _build_menu(self) -> None: + file_menu = self.menuBar().addMenu("File") + open_workspace = file_menu.addAction("Open Workspace Folder") + open_workspace.triggered.connect(lambda: QDesktopServices.openUrl(QUrl.fromLocalFile(self.context.config.workspace_path))) + quit_action = file_menu.addAction("Exit") + quit_action.setShortcut(QKeySequence("Ctrl+Q")) + quit_action.triggered.connect(self.close) + + mode_menu = self.menuBar().addMenu("Mode") + for mode in NAVIGATION_MODES: + action = mode_menu.addAction(NAVIGATION_MODES[mode].title) + action.triggered.connect(lambda checked=False, target=mode: self.change_mode(target)) + + tools_menu = self.menuBar().addMenu("Tools") + models_action = QAction("Models", self) + models_action.setShortcut(QKeySequence("Ctrl+M")) + models_action.triggered.connect(self.open_model_manager) + settings_action = QAction("Settings", self) + settings_action.setShortcut(QKeySequence("Ctrl+,")) + settings_action.triggered.connect(self.open_settings_dialog) + license_action = QAction("License Center", self) + license_action.setShortcut(QKeySequence("Ctrl+L")) + license_action.triggered.connect(self.open_license_dialog) + tools_menu.addAction(models_action) + tools_menu.addAction(settings_action) + tools_menu.addAction(license_action) + + help_menu = self.menuBar().addMenu("Help") + about_action = help_menu.addAction("About") + about_action.triggered.connect( + lambda: QMessageBox.information( + self, + tr("About", self.context.config.ui_language), + f"InsightFace Evaluation Studio v{APP_VERSION}", + ) + ) + responsible_action = help_menu.addAction("Responsible Use Notice") + responsible_action.triggered.connect( + lambda: QMessageBox.information( + self, + tr("Responsible Use Notice", self.context.config.ui_language), + tr(RESPONSIBLE_USE_NOTICE, self.context.config.ui_language), + ) + ) + + def _build_statusbar(self) -> None: + self.status = QStatusBar() + self.setStatusBar(self.status) + self.status_labels = { + "model": QLabel(), + "provider": QLabel(), + "database": QLabel(), + "license": QLabel(), + "running": QLabel("Ready"), + } + for label in self.status_labels.values(): + self.status.addPermanentWidget(label) + + def _mode_list_clicked(self, item: QListWidgetItem) -> None: + mode = mode_from_value(item.data(Qt.UserRole)) + if mode != self.current_mode: + self.change_mode(mode) + + def change_mode(self, mode: AppMode | str, restore_last: bool = True, save: bool = True) -> None: + self.current_mode = mode_from_value(mode) + self._sync_mode_list_selection() + self._rebuild_sidebar() + page_key = getattr(self.context.config, last_page_attr(self.current_mode), "") if restore_last else "" + valid_keys = {item.page_key for item in NAVIGATION_MODES[self.current_mode].items} + if page_key not in valid_keys: + page_key = NAVIGATION_MODES[self.current_mode].items[0].page_key + if save: + self.context.config.ui_last_mode = self.current_mode.value + save_config(self.context.config) + self.open_page(page_key, from_mode_change=True) + + def _sync_mode_list_selection(self) -> None: + for row in range(self.mode_list.count()): + item = self.mode_list.item(row) + if item.data(Qt.UserRole) == self.current_mode.value: + self.mode_list.blockSignals(True) + self.mode_list.setCurrentItem(item) + self.mode_list.blockSignals(False) + break + + def _rebuild_sidebar(self) -> None: + mode = NAVIGATION_MODES[self.current_mode] + self.sidebar_title.setText(tr(mode.title, self.context.config.ui_language)) + self.sidebar_description.setText(tr(mode.description, self.context.config.ui_language)) + self.sidebar.setVisible(False) + self.sidebar_list.clear() + for nav_item in mode.items: + title = tr(nav_item.title, self.context.config.ui_language) + ( + " " + tr("Coming soon", self.context.config.ui_language) if nav_item.coming_soon else "" + ) + item = QListWidgetItem(title) + item.setData(Qt.UserRole, nav_item.page_key) + item.setToolTip(tr(nav_item.description, self.context.config.ui_language)) + if not nav_item.enabled: + item.setFlags(item.flags() & ~Qt.ItemIsEnabled) + item.setForeground(Qt.gray) + self.sidebar_list.addItem(item) + + def _sidebar_clicked(self, item: QListWidgetItem) -> None: + if item.flags() & Qt.ItemIsEnabled: + self.open_page(str(item.data(Qt.UserRole))) + + def open_page(self, page_key: str, from_mode_change: bool = False) -> None: + if page_key in self.GLOBAL_PAGES: + if page_key == "Settings": + self.open_settings_dialog() + elif page_key in {"Model Settings", "Model Downloads"}: + self.open_model_manager(initial=page_key) + elif page_key == "License Center": + self.open_license_dialog() + return + page_key = self.LEGACY_PAGE_MAP.get(page_key, page_key) + page = self.page_registry.get(page_key) + if self.stack.indexOf(page) < 0: + self.stack.addWidget(page) + apply_button_tooltips(page) + if hasattr(page, "refresh"): + page.refresh() + apply_translations(page, self.context.config.ui_language) + self.stack.setCurrentWidget(page) + self.current_page_key = page_key + for row in range(self.sidebar_list.count()): + item = self.sidebar_list.item(row) + if item.data(Qt.UserRole) == page_key: + self.sidebar_list.setCurrentItem(item) + break + if not from_mode_change: + setattr(self.context.config, last_page_attr(self.current_mode), page_key) + save_config(self.context.config) + self.set_status(self._page_title(page_key)) + + def _page_title(self, page_key: str) -> str: + for mode in NAVIGATION_MODES.values(): + for item in mode.items: + if item.page_key == page_key: + return tr(item.title, self.context.config.ui_language) + return page_key + + def show_first_launch(self) -> None: + wizard = FirstLaunchWizard(self.context.config, self) + apply_translations(wizard, self.context.config.ui_language) + if wizard.exec() == QDialog.Accepted: + self.context.storage = self.context.storage.__class__(self.context.config.database_path) + self.change_mode(mode_from_value(self.context.config.ui_last_mode), restore_last=False) + self.refresh_statusbar() + + def auto_load_model(self) -> None: + def task(): + self.context.engine.load() + return self.context.engine + + def done(engine): + self.refresh_statusbar() + if engine.is_loaded(): + self.set_status("Model loaded.") + elif engine.last_error: + self.set_status(engine.last_error) + + self.run_task("Loading model", task, done, show_dialog=False) + + def open_settings_dialog(self) -> None: + dialog = SettingsDialog(self.context, self) + apply_button_tooltips(dialog) + apply_translations(dialog, self.context.config.ui_language) + dialog.settingsSaved.connect(self._settings_saved) + dialog.exec() + self.refresh_statusbar() + + def _settings_saved(self) -> None: + self.apply_theme() + self.apply_language() + self.refresh_statusbar() + + def apply_theme(self) -> None: + qt_app = QApplication.instance() + if qt_app is not None: + qt_app.setStyleSheet(application_stylesheet(self.context.config.ui_theme)) + + def apply_language(self) -> None: + self._refresh_mode_list_texts() + self._rebuild_sidebar() + apply_translations(self, self.context.config.ui_language) + self.refresh_statusbar() + + def _refresh_mode_list_texts(self) -> None: + for row, mode in enumerate(NAVIGATION_MODES.values()): + item = self.mode_list.item(row) + if item is None: + continue + item.setText(f"{tr(mode.title, self.context.config.ui_language)}\n{self._mode_subtitle(mode.id)}") + item.setToolTip(tr(mode.description, self.context.config.ui_language)) + + def open_model_manager(self, initial: str | None = None) -> None: + dialog = ModelManagerDialog(self.context, self) + apply_button_tooltips(dialog) + apply_translations(dialog, self.context.config.ui_language) + dialog.modelChanged.connect(self.refresh_statusbar) + if initial: + dialog.open_page(initial) + apply_translations(dialog, self.context.config.ui_language) + dialog.exec() + self.refresh_statusbar() + + def open_license_dialog(self) -> None: + dialog = LicenseDialog(self.context, self) + apply_button_tooltips(dialog) + apply_translations(dialog, self.context.config.ui_language) + dialog.exec() + self.refresh_statusbar() + + def open_enterprise_help(self) -> None: + open_insightface_url(ENTERPRISE_HELP_URL, content="sidebar_enterprise_help") + self.set_status("Opened InsightFace enterprise contact page.") + + def set_status(self, message: str) -> None: + self.status_labels["running"].setText(self._elide(tr(message, self.context.config.ui_language), 180)) + + def refresh_statusbar(self) -> None: + cfg = self.context.config + self.model_chip.setVisible(cfg.ui_show_status_chips) + self.provider_chip.setVisible(cfg.ui_show_status_chips) + self.license_chip.setVisible(cfg.ui_show_status_chips) + self.model_chip.setText(self._elide(f"{tr('Model', cfg.ui_language)}: {cfg.model_name}", 150)) + self.provider_chip.setText(self._elide(f"{tr('Provider', cfg.ui_language)}: {cfg.provider}", 130)) + self.license_chip.setText(self._elide(tr(cfg.license_status, cfg.ui_language), 180)) + self.model_chip.setToolTip(cfg.model_name) + self.provider_chip.setToolTip(cfg.provider) + self.license_chip.setToolTip(cfg.license_status) + self.status_labels["model"].setText(self._elide(f"{tr('Model', cfg.ui_language)}: {cfg.model_name}", 160)) + self.status_labels["provider"].setText(f"{tr('Provider', cfg.ui_language)}: {cfg.provider}") + self.status_labels["database"].setText(self._elide(f"{tr('DB', cfg.ui_language)}: {cfg.database_path}", 280)) + self.status_labels["database"].setToolTip(cfg.database_path) + self.status_labels["license"].setText(self._elide(f"{tr('License', cfg.ui_language)}: {tr(cfg.license_status, cfg.ui_language)}", 220)) + + def run_task(self, title: str, fn: Callable, on_result: Callable | None = None, show_dialog: bool = True) -> None: + worker = Worker(fn) + worker.setAutoDelete(False) + self.active_workers.add(worker) + dialog = StudioProgressDialog(title, self) if show_dialog else None + if dialog: + dialog.canceled.connect(worker.cancel) + worker.signals.progress.connect(dialog.update_progress) + dialog.show() + worker.signals.result.connect(lambda result: on_result(result) if on_result else None) + worker.signals.error.connect( + lambda message: QMessageBox.warning( + self, + tr(title, self.context.config.ui_language), + tr(message, self.context.config.ui_language), + ) + ) + worker.signals.error.connect(self.set_status) + worker.signals.finished.connect(lambda: dialog.close() if dialog else None) + worker.signals.finished.connect(self.refresh_statusbar) + worker.signals.finished.connect(lambda: self.active_workers.discard(worker)) + worker.signals.finished.connect(worker.signals.deleteLater) + self.set_status(title) + self.thread_pool.start(worker) + + def closeEvent(self, event) -> None: # noqa: N802 + self.context.config.ui_window_width = max(800, self.width()) + self.context.config.ui_window_height = max(600, self.height()) + self.context.config.ui_sidebar_width = max(200, self.sidebar.width()) + save_config(self.context.config) + super().closeEvent(event) + + def _elide(self, text: str, width: int) -> str: + metrics = QFontMetrics(self.font()) + return metrics.elidedText(str(text), Qt.ElideMiddle, width) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/page_registry.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/page_registry.py new file mode 100644 index 0000000000000000000000000000000000000000..a94c47343895cdf38dd30193df14137796fac4c3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/page_registry.py @@ -0,0 +1,109 @@ +"""Lazy page registry used by mode-based navigation.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QWidget + +from .pages.album_page import AlbumPage +from .pages.album_people_page import AlbumPeoplePage +from .pages.batch_processing_page import BatchProcessingPage +from .pages.camera_recognition_page import CameraRecognitionPage +from .pages.compare_page import ComparePage +from .pages.enterprise_eval_page import EnterpriseEvalPage +from .pages.face_search_page import FaceSearchPage +from .pages.face_swap_page import FaceSwapPage +from .pages.mode_dashboards import ( + AlbumDashboardPage, + EnterpriseDashboardPage, + FaceDashboardPage, + SwapDashboardPage, +) +from .pages.multiface_photo_page import MultiFacePhotoPage +from .pages.people_library_page import PeopleLibraryPage +from .pages.placeholder_page import CommercialNextStepsPage, PlaceholderPage +from .pages.reports_page import ReportsPage +from .pages.verification_page import VerificationPage +from .pages.video_search_page import VideoSearchPage + + +class PageRegistry: + def __init__(self, context): + self.context = context + self._pages: dict[str, QWidget] = {} + + def get(self, page_key: str) -> QWidget: + if page_key not in self._pages: + self._pages[page_key] = self._create_page(page_key) + return self._pages[page_key] + + @property + def pages(self) -> dict[str, QWidget]: + return self._pages + + def _create_page(self, page_key: str) -> QWidget: + factories = { + "verification": VerificationPage, + "face_dashboard": FaceDashboardPage, + "album_dashboard": AlbumDashboardPage, + "album": AlbumPage, + "swap_dashboard": SwapDashboardPage, + "enterprise_dashboard": EnterpriseDashboardPage, + "compare": ComparePage, + "face_search": FaceSearchPage, + "multiface_photo": MultiFacePhotoPage, + "people_library": PeopleLibraryPage, + "batch_processing": BatchProcessingPage, + "camera_recognition": CameraRecognitionPage, + "video_search": VideoSearchPage, + "album_import_scan": BatchProcessingPage, + "album_people_clustering": AlbumPeoplePage, + "album_person_search": FaceSearchPage, + "image_face_swap": FaceSwapPage, + "enterprise_evaluation": EnterpriseEvalPage, + "reports": ReportsPage, + "commercial_next_steps": CommercialNextStepsPage, + } + if page_key in factories: + return factories[page_key](self.context) + placeholders = { + "album_multi_person_search": ( + "Multi-person Photo Search", + "Find photos that contain multiple selected people.", + "This page will search indexed album faces for photos containing combinations such as Alice and Bob.", + ), + "album_export": ( + "Export Album Results", + "Export local album organization results.", + "This page will export per-person folders, face crops, CSV summaries, and review queues.", + ), + "batch_image_swap": ( + "Batch Image Swap", + "Swap faces across a folder of images using the configured swap model.", + "Batch image swap is coming soon. Use Image Face Swap for single-image trials in v1.0.1.", + ), + "video_face_swap": ( + "Video Face Swap", + "Swap faces in local videos.", + "Video Face Swap is coming soon and may require separate commercial authorization.", + ), + "source_face_library": ( + "Source Face Library", + "Prepare high-quality source faces for future swap workflows.", + "This page will manage reusable source faces, consent notes, and quality review.", + ), + "enterprise_dataset_setup": ( + "Dataset Setup", + "Prepare local evaluation datasets and templates.", + "Dataset setup is currently built into Run Evaluation. A guided setup workspace is coming soon.", + ), + "threshold_calibration": ( + "Threshold Calibration", + "Review thresholds, FAR, FRR, and operating point recommendations.", + "Threshold calibration tables are currently generated in evaluation reports. A dedicated calibration page is coming soon.", + ), + } + title, description, body = placeholders.get( + page_key, + ("Coming Soon", "This workflow is planned for a future release.", "Coming soon."), + ) + return PlaceholderPage(self.context, title, description, body) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..02a11ea975490a349debc0a55a8ea90ce4f006c0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/__init__.py @@ -0,0 +1 @@ +"""Pages used by the main stacked GUI.""" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/album_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/album_page.py new file mode 100644 index 0000000000000000000000000000000000000000..82231931a9787384f29854b67f9b7856e66a9d0d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/album_page.py @@ -0,0 +1,627 @@ +"""Single-page album import, clustering, and review workflow.""" + +from __future__ import annotations + +from collections import defaultdict +from io import BytesIO +from pathlib import Path + +import numpy as np +from PySide6.QtCore import QEvent, QSize, Qt, QUrl, Signal +from PySide6.QtGui import QCursor, QDesktopServices, QIcon, QImage, QPixmap +from PySide6.QtWidgets import ( + QAbstractItemView, + QFileDialog, + QDoubleSpinBox, + QHBoxLayout, + QLabel, + QListWidget, + QMessageBox, + QPushButton, + QSpinBox, + QSplitter, + QTableWidget, + QTableWidgetItem, + QVBoxLayout, + QWidget, +) + +from ..core.clustering import cluster_embeddings_dbscan +from ..core.i18n import tr +from ..core.recognition import cosine_similarity, normalize_embedding +from ..core.tooltips import set_button_tooltip +from ..core.utils import crop_bbox, encode_webp_thumbnail, list_images, read_image, timestamp_for_filename +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from .base import BasePage + +DEFAULT_ALBUM_MIN_FACE_SIZE = 80 +DEFAULT_ALBUM_COSINE_THRESHOLD = 0.48 + + +class AlbumDirectoryList(QListWidget): + foldersChanged = Signal() + + def __init__(self, parent=None): + super().__init__(parent) + self.setObjectName("albumDirectoryList") + self.setAcceptDrops(True) + self.setMouseTracking(True) + self.setSelectionMode(QListWidget.ExtendedSelection) + self.setToolTip("Drag one or more album folders here, or use Add Folder.") + self.setProperty("hoverActive", False) + self.setProperty("dragActive", False) + self.installEventFilter(self) + self.viewport().installEventFilter(self) + + def add_folder(self, folder: str) -> None: + folder = str(Path(folder).expanduser()) + if folder and Path(folder).is_dir() and folder not in self.folders(): + self.addItem(folder) + self.foldersChanged.emit() + + def folders(self) -> list[str]: + return [self.item(index).text() for index in range(self.count())] + + def dragEnterEvent(self, event) -> None: # noqa: N802 + if self._has_folder_urls(event): + self._drag(True) + event.acceptProposedAction() + else: + event.ignore() + + def dragMoveEvent(self, event) -> None: # noqa: N802 + if self._has_folder_urls(event): + self._drag(True) + event.acceptProposedAction() + else: + event.ignore() + + def dragLeaveEvent(self, event) -> None: # noqa: N802 + self._drag(False) + super().dragLeaveEvent(event) + + def dropEvent(self, event) -> None: # noqa: N802 + self._drag(False) + added = False + for url in event.mimeData().urls(): + if url.isLocalFile() and Path(url.toLocalFile()).is_dir(): + self.add_folder(url.toLocalFile()) + added = True + if added: + event.acceptProposedAction() + else: + event.ignore() + + def _drag(self, active: bool) -> None: + self.setProperty("dragActive", active) + self.style().unpolish(self) + self.style().polish(self) + + @staticmethod + def _has_folder_urls(event) -> bool: + return event.mimeData().hasUrls() and any( + Path(url.toLocalFile()).is_dir() + for url in event.mimeData().urls() + if url.isLocalFile() + ) + + def eventFilter(self, watched, event) -> bool: # noqa: N802 + if event.type() == QEvent.Enter: + self._set_property("hoverActive", True) + return False + if event.type() == QEvent.Leave: + self._update_hover_from_cursor() + return False + return super().eventFilter(watched, event) + + def enterEvent(self, event) -> None: # noqa: N802 + self._set_property("hoverActive", True) + super().enterEvent(event) + + def leaveEvent(self, event) -> None: # noqa: N802 + self._update_hover_from_cursor() + super().leaveEvent(event) + + def _set_property(self, name: str, value) -> None: + self.setProperty(name, value) + self.style().unpolish(self) + self.style().polish(self) + + def _update_hover_from_cursor(self) -> None: + inside = self.rect().contains(self.mapFromGlobal(QCursor.pos())) + self._set_property("hoverActive", inside) + + +class AlbumPage(BasePage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Album", + "Import or refresh local album folders, cluster detected faces, and review the photos in each person group.", + parent, + ) + self.clusters: list[dict] = [] + self.cluster_items: dict[int, list[dict]] = {} + self._loaded_saved_state = False + + controls = QWidget() + controls_layout = QVBoxLayout(controls) + controls_layout.setContentsMargins(0, 0, 0, 0) + self.content.addWidget( + self.notice( + "All album processing is local. Import / Refresh scans every selected folder, extracts features " + "only for new images, then runs DBSCAN clustering over all indexed faces using the selected cosine threshold." + ) + ) + self.folder_list = AlbumDirectoryList() + self.folder_list.setMinimumHeight(90) + self.folder_list.foldersChanged.connect(self._save_directories) + controls_layout.addWidget(QLabel("Album directories")) + controls_layout.addWidget(self.folder_list) + hint = QLabel("Drag album folders into the directory list, or click Add Folder.") + hint.setProperty("role", "muted") + controls_layout.addWidget(hint) + button_row = QHBoxLayout() + self.import_button = self._button("Import / Refresh", self.import_refresh) + self.rebuild_button = self._button("Rebuild All", self.rebuild_all) + for button in [ + self._button("Add Folder", self.add_folder), + self._button("Remove Selected", self.remove_selected), + self._button("Clear", self.clear_directories), + self.import_button, + self.rebuild_button, + ]: + button_row.addWidget(button) + button_row.addStretch(1) + controls_layout.addLayout(button_row) + + threshold_help = QLabel( + "Cosine threshold is a face similarity cutoff: higher values make clusters stricter. " + "DBSCAN internally uses cosine distance = 1 - cosine threshold." + ) + threshold_help.setObjectName("albumThresholdHelp") + threshold_help.setProperty("role", "muted") + threshold_help.setWordWrap(True) + controls_layout.addWidget(threshold_help) + + settings_row = QHBoxLayout() + self.cluster_threshold = QDoubleSpinBox() + self.cluster_threshold.setRange(0.01, 0.99) + self.cluster_threshold.setSingleStep(0.01) + self.cluster_threshold.setDecimals(2) + self.cluster_threshold.setValue(DEFAULT_ALBUM_COSINE_THRESHOLD) + self.cluster_threshold.setToolTip( + "Cosine similarity threshold. Higher values make clusters stricter; default is 0.48." + ) + self.min_samples = QSpinBox() + self.min_samples.setRange(1, 50) + self.min_samples.setValue(2) + self.min_samples.setToolTip("Minimum neighboring faces needed for a DBSCAN core point.") + self.min_face_size = QSpinBox() + self.min_face_size.setRange(1, 4096) + self.min_face_size.setValue(DEFAULT_ALBUM_MIN_FACE_SIZE) + self.min_face_size.setToolTip( + "Faces whose bounding box width or height is smaller than this value are skipped." + ) + self.algorithm_label = QLabel("Algorithm: DBSCAN") + settings_row.addWidget(QLabel("Cosine threshold")) + settings_row.addWidget(self.cluster_threshold) + settings_row.addWidget(QLabel("Min samples")) + settings_row.addWidget(self.min_samples) + settings_row.addWidget(QLabel("Minimum face size")) + settings_row.addWidget(self.min_face_size) + settings_row.addWidget(self.algorithm_label) + settings_row.addStretch(1) + controls_layout.addLayout(settings_row) + self.content.addWidget(controls) + + splitter = QSplitter(Qt.Horizontal) + self.cluster_table = QTableWidget(0, 2) + self.cluster_table.setIconSize(QSize(56, 56)) + self.cluster_table.setSelectionBehavior(QAbstractItemView.SelectRows) + self.cluster_table.setSelectionMode(QAbstractItemView.SingleSelection) + self.cluster_table.setEditTriggers(QAbstractItemView.NoEditTriggers) + self.cluster_table.setHorizontalHeaderLabels(["Thumbnail", "Photos"]) + configure_table_columns(self.cluster_table, [120, 80]) + self.cluster_table.currentCellChanged.connect(self.cluster_selected) + splitter.addWidget(self.cluster_table) + + self.photo_table = QTableWidget(0, 3) + self.photo_table.setIconSize(QSize(96, 72)) + self.photo_table.setSelectionBehavior(QAbstractItemView.SelectRows) + self.photo_table.setSelectionMode(QAbstractItemView.SingleSelection) + self.photo_table.setEditTriggers(QAbstractItemView.NoEditTriggers) + self.photo_table.setHorizontalHeaderLabels(["Thumbnail", "File", "Faces in cluster"]) + configure_table_columns(self.photo_table, [120, 360, 130]) + self.photo_table.cellDoubleClicked.connect(self.open_photo) + splitter.addWidget(self.photo_table) + splitter.setStretchFactor(0, 2) + splitter.setStretchFactor(1, 3) + self.content.addWidget(splitter, 1) + + def _button(self, text: str, callback) -> QPushButton: + button = QPushButton(text) + button.clicked.connect(callback) + set_button_tooltip(button) + return button + + def add_folder(self) -> None: + folder = QFileDialog.getExistingDirectory( + self, + tr("Select album folder", self.context.config.ui_language), + str(Path.home()), + ) + if folder: + self.folder_list.add_folder(folder) + + def remove_selected(self) -> None: + for item in self.folder_list.selectedItems(): + self.folder_list.takeItem(self.folder_list.row(item)) + self._save_directories() + + def clear_directories(self) -> None: + self.folder_list.clear() + self._save_directories() + self.set_status("Album directories cleared. Existing clustering results are still available.") + + def import_refresh(self) -> None: + self._run_import_refresh(rebuild=False) + + def rebuild_all(self) -> None: + folders = [Path(folder) for folder in self.folder_list.folders()] + if not folders: + reply = QMessageBox.question( + self, + tr("Rebuild All", self.context.config.ui_language), + tr( + "No album directories are selected. Rebuild All will clear saved album clustering results. Continue?", + self.context.config.ui_language, + ), + QMessageBox.Yes | QMessageBox.No, + QMessageBox.No, + ) + if reply == QMessageBox.Yes: + self.context.storage.clear_album_results() + self.clusters = [] + self.cluster_items = {} + self._populate_clusters() + self.set_status("Saved album clustering results were cleared.") + return + reply = QMessageBox.question( + self, + tr("Rebuild All", self.context.config.ui_language), + tr( + "Rebuild All will reprocess every image in the selected album directories and replace saved clustering results. Continue?", + self.context.config.ui_language, + ), + QMessageBox.Yes | QMessageBox.No, + QMessageBox.No, + ) + if reply == QMessageBox.Yes: + self._run_import_refresh(rebuild=True) + + def _run_import_refresh(self, rebuild: bool = False) -> None: + folders = [Path(folder) for folder in self.folder_list.folders()] + if not folders: + self.show_error("Add one or more album directories first.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + self._save_directories() + all_paths = [] + for folder in folders: + all_paths.extend(str(path) for path in list_images(folder, recursive=True)) + if not all_paths: + self.show_error("No supported images found in the selected directories.") + return + cosine_threshold = float(self.cluster_threshold.value()) + min_samples = int(self.min_samples.value()) + min_face_size = int(self.min_face_size.value()) + existing = set() if rebuild else self.context.storage.existing_media_paths(all_paths) + new_paths = list(all_paths) if rebuild else [path for path in all_paths if path not in existing] + + def task(progress=None, is_cancelled=None): + deleted = 0 + if rebuild: + deleted = self.context.storage.delete_media_items_by_paths(all_paths) + imported = 0 + faces_saved = 0 + for index, path in enumerate(new_paths): + if is_cancelled and is_cancelled(): + break + image = read_image(path) + if image is None: + if progress: + progress(index + 1, len(new_paths), f"Skipped unreadable image: {Path(path).name}") + continue + media_id = self.context.storage.add_media_item( + path, + "image", + width=image.shape[1], + height=image.shape[0], + file_size=Path(path).stat().st_size if Path(path).exists() else None, + mtime=Path(path).stat().st_mtime if Path(path).exists() else None, + thumbnail=encode_webp_thumbnail(image, max_side=120, quality=35), + processed_at=timestamp_for_filename(), + ) + for face in self.context.engine.detect_faces(image, source_path=path): + if face.normed_embedding is None: + continue + if self._face_box_size(face.bbox) < min_face_size: + continue + face_image = face.crop if face.crop is not None else crop_bbox(image, face.bbox) + self.context.storage.add_media_face( + media_id, + face.normed_embedding, + crop_path="", + thumbnail=encode_webp_thumbnail(face_image, max_side=80, quality=70), + bbox=face.bbox, + kps=face.kps, + det_score=face.det_score, + quality_score=face.quality_score, + status="unknown", + ) + faces_saved += 1 + imported += 1 + if progress: + progress( + index + 1, + max(1, len(new_paths)), + f"Imported {imported} new images, saved {faces_saved} faces", + ) + faces = self._faces_for_folders(folders, min_face_size) + clusters, algorithm = self._cluster_faces(faces, cosine_threshold, min_samples) + self.context.storage.save_album_results( + clusters, + self.cluster_items, + algorithm, + cluster_threshold=cosine_threshold, + min_samples=min_samples, + min_face_size=min_face_size, + ) + return { + "deleted": deleted, + "imported": imported, + "faces_saved": faces_saved, + "clusters": clusters, + "algorithm": algorithm, + } + + def done(result): + self.clusters = result["clusters"] + self.algorithm_label.setText(f"Algorithm: {result['algorithm']}") + self._populate_clusters() + if rebuild: + self.set_status( + f"Rebuilt album from scratch: removed {result['deleted']} indexed image(s), " + f"processed {result['imported']} image(s), saved {result['faces_saved']} face(s), " + f"built {len(self.clusters)} cluster(s)." + ) + else: + self.set_status( + f"Imported {result['imported']} new image(s), saved {result['faces_saved']} face(s), " + f"built {len(self.clusters)} cluster(s)." + ) + + self.run_task("Rebuilding album" if rebuild else "Importing and clustering album", task, done) + + def _faces_for_folders(self, folders: list[Path], min_face_size: int) -> list[dict]: + roots = [folder.resolve() for folder in folders] + faces = [] + for face in self.context.storage.list_media_faces(): + try: + media_path = Path(face["media_path"]).resolve() + except Exception: + continue + if any(media_path == root or root in media_path.parents for root in roots): + if ( + face.get("embedding") is not None + and self._face_box_size(face.get("bbox")) >= min_face_size + ): + faces.append(face) + return faces + + def _cluster_faces( + self, + faces: list[dict], + cosine_threshold: float, + min_samples: int, + ) -> tuple[list[dict], str]: + embeddings = [face["embedding"] for face in faces] + distance_threshold = max(0.01, 1.0 - float(cosine_threshold)) + labels, algorithm = cluster_embeddings_dbscan( + embeddings, + distance_threshold=distance_threshold, + min_samples=min_samples, + ) + groups: dict[int, list[dict]] = defaultdict(list) + next_noise = max(labels, default=-1) + 1 + for face, label in zip(faces, labels): + if label < 0: + label = next_noise + next_noise += 1 + groups[int(label)].append(face) + next_album_id = 1 + clusters = [] + self.cluster_items = {} + for label, items in groups.items(): + vectors = [normalize_embedding(item["embedding"]) for item in items if item.get("embedding") is not None] + vectors = [vector for vector in vectors if vector is not None] + if not vectors: + continue + centroid = normalize_embedding(np.mean(np.vstack(vectors), axis=0)) + cluster_id = next_album_id + next_album_id += 1 + name = f"Album Person {cluster_id}" + representative = max(items, key=lambda item: cosine_similarity(centroid, item.get("embedding"))) + photos = sorted({item["media_path"] for item in items}) + cluster = { + "id": cluster_id, + "label": label, + "name": name, + "source": "album", + "face_count": len(items), + "photo_count": len(photos), + "avg_quality": sum(float(item.get("quality_score") or 0.0) for item in items) / max(1, len(items)), + "thumbnail_face_id": representative.get("id"), + "thumbnail_path": representative.get("media_path"), + "photos": photos, + } + clusters.append(cluster) + self.cluster_items[cluster_id] = items + return sorted(clusters, key=lambda row: (-row["face_count"], row["id"])), algorithm + + def _save_directories(self) -> None: + self.context.storage.save_album_directories(self.folder_list.folders()) + + def refresh(self) -> None: + if self._loaded_saved_state: + return + self._loaded_saved_state = True + self.folder_list.blockSignals(True) + self.folder_list.clear() + for folder in self.context.storage.list_album_directories(): + if Path(folder).expanduser().is_dir(): + self.folder_list.addItem(folder) + self.folder_list.blockSignals(False) + self._load_saved_results() + + def _load_saved_results(self) -> None: + data = self.context.storage.load_album_results() + clusters = data.get("clusters") if isinstance(data, dict) else None + if not isinstance(clusters, list): + return + faces_by_id = {int(face["id"]): face for face in self.context.storage.list_media_faces() if face.get("id") is not None} + self.clusters = [] + self.cluster_items = {} + for cluster in clusters: + try: + cluster_id = int(cluster["id"]) + except Exception: + continue + face_ids = [int(face_id) for face_id in cluster.get("face_ids", []) if str(face_id).isdigit()] + self.cluster_items[cluster_id] = [faces_by_id[face_id] for face_id in face_ids if face_id in faces_by_id] + self.clusters.append(cluster) + algorithm = data.get("algorithm") + if algorithm not in {"DBSCAN", "centroid fallback", "none"}: + algorithm = "DBSCAN" + self.algorithm_label.setText(f"Algorithm: {algorithm}") + if data.get("cluster_threshold") is not None: + self.cluster_threshold.setValue(float(data["cluster_threshold"])) + if data.get("min_samples") is not None: + self.min_samples.setValue(int(data["min_samples"])) + if data.get("min_face_size") is not None: + self.min_face_size.setValue(int(data["min_face_size"])) + self._populate_clusters() + + def _populate_clusters(self) -> None: + self.cluster_table.setRowCount(len(self.clusters)) + for row, cluster in enumerate(self.clusters): + values = [ + "", + cluster.get("photo_count", 0), + ] + for col, value in enumerate(values): + item = QTableWidgetItem(str(value)) + if col == 0: + icon = self._cluster_thumbnail_icon(cluster, QSize(56, 56)) + if icon: + item.setIcon(icon) + item.setData(Qt.UserRole, cluster.get("id")) + item.setTextAlignment(Qt.AlignCenter) + item.setToolTip( + f"ID: {cluster.get('id', '')}\n" + f"Name: {cluster.get('name', '')}\n" + f"Faces: {cluster.get('face_count', 0)}\n" + f"Photos: {cluster.get('photo_count', 0)}" + ) + self.cluster_table.setItem(row, col, item) + self.cluster_table.setRowHeight(row, 64) + refresh_table_columns(self.cluster_table) + if self.clusters: + self.cluster_table.selectRow(0) + self._populate_photos(int(self.clusters[0].get("id", 0))) + else: + self.photo_table.setRowCount(0) + + def cluster_selected(self, current_row: int, current_column: int, previous_row: int, previous_column: int) -> None: + del current_column, previous_row, previous_column + if current_row < 0 or current_row >= len(self.clusters): + self.photo_table.setRowCount(0) + return + self._populate_photos(int(self.clusters[current_row].get("id", 0))) + + def _populate_photos(self, cluster_id: int) -> None: + items = self.cluster_items.get(cluster_id, []) + grouped: dict[str, dict] = {} + for item in items: + path = item["media_path"] + if path not in grouped: + grouped[path] = {"count": 0, "thumbnail": item.get("media_thumbnail")} + grouped[path]["count"] += 1 + if not grouped: + for cluster in self.clusters: + if int(cluster.get("id", -1)) == cluster_id: + for path in cluster.get("photos", []): + grouped[str(path)] = {"count": 1, "thumbnail": None} + break + rows = sorted(grouped.items()) + self.photo_table.setRowCount(len(rows)) + for row, (path, data) in enumerate(rows): + thumb = QTableWidgetItem("") + icon = self._icon_from_bytes(data.get("thumbnail"), QSize(96, 72)) + if icon: + thumb.setIcon(icon) + thumb.setData(Qt.UserRole, path) + file_item = QTableWidgetItem(path) + file_item.setData(Qt.UserRole, path) + self.photo_table.setItem(row, 0, thumb) + self.photo_table.setItem(row, 1, file_item) + self.photo_table.setItem(row, 2, QTableWidgetItem(str(data["count"]))) + self.photo_table.setRowHeight(row, 80) + refresh_table_columns(self.photo_table) + + def open_photo(self, row: int, column: int) -> None: + item = self.photo_table.item(row, 0) or self.photo_table.item(row, 1) + if item is None: + return + path = item.data(Qt.UserRole) + if path: + QDesktopServices.openUrl(QUrl.fromLocalFile(str(path))) + + @staticmethod + def _face_box_size(bbox) -> float: + try: + x1, y1, x2, y2 = [float(value) for value in bbox[:4]] + except Exception: + return 0.0 + return min(abs(x2 - x1), abs(y2 - y1)) + + def _cluster_thumbnail_icon(self, cluster: dict, size: QSize) -> QIcon | None: + thumbnail_face_id = cluster.get("thumbnail_face_id") + if thumbnail_face_id is not None: + for item in self.cluster_items.get(int(cluster.get("id", -1)), []): + if item.get("id") == thumbnail_face_id: + return self._icon_from_bytes(item.get("thumbnail"), size) + for item in self.cluster_items.get(int(cluster.get("id", -1)), []): + icon = self._icon_from_bytes(item.get("thumbnail"), size) + if icon is not None: + return icon + return None + + @staticmethod + def _icon_from_bytes(data, size: QSize) -> QIcon | None: + if not data: + return None + try: + from PIL import Image + + with Image.open(BytesIO(bytes(data))) as image: + rgba = image.convert("RGBA") + raw = rgba.tobytes("raw", "RGBA") + qimage = QImage(raw, rgba.width, rgba.height, QImage.Format_RGBA8888).copy() + pixmap = QPixmap.fromImage(qimage) + except Exception: + return None + return QIcon(pixmap.scaled(size, Qt.KeepAspectRatio, Qt.SmoothTransformation)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/album_people_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/album_people_page.py new file mode 100644 index 0000000000000000000000000000000000000000..f12a4ee07cb0dc0bbe7389705c49356d9ad25046 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/album_people_page.py @@ -0,0 +1,98 @@ +"""Album people clustering page.""" + +from __future__ import annotations + +from collections import defaultdict +from pathlib import Path + +from PySide6.QtWidgets import QLabel, QDoubleSpinBox, QTableWidget, QTableWidgetItem + +from ..core.clustering import cluster_embeddings_dbscan +from ..core.exporters import export_csv +from ..core.utils import list_images, read_image, timestamp_for_filename +from ..widgets.drop_input import DropInput +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from .base import BasePage + + +class AlbumPeoplePage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Album People Clustering", "Approximate local person grouping for album review and correction.", parent) + self.folder = "" + self.rows = [] + self.threshold = QDoubleSpinBox() + self.threshold.setRange(0.01, 0.99) + self.threshold.setSingleStep(0.01) + self.threshold.setValue(0.28) + self.content.addWidget(self.notice("Clustering is approximate. Please review and correct groups manually.")) + self.folder_input = DropInput("Album Folder", mode="folder") + self.folder_input.pathsChanged.connect(lambda paths: self.set_folder(paths[0]) if paths else self.clear_folder()) + self.content.addWidget(self.folder_input) + self.content.addWidget(self.row(QLabel("DBSCAN distance threshold"), self.threshold, self.button("Scan and Cluster", self.scan), self.button("Export CSV", self.export))) + self.table = QTableWidget(0, 5) + self.table.setHorizontalHeaderLabels(["cluster_id", "face_count", "photo_count", "average_quality", "sample_paths"]) + configure_table_columns(self.table, [100, 100, 100, 120, 360]) + self.content.addWidget(self.table, 1) + + def set_folder(self, folder: str) -> None: + self.folder = folder + self.set_status(f"Selected album: {folder}") + + def clear_folder(self) -> None: + self.folder = "" + self.rows = [] + self.table.setRowCount(0) + + def scan(self) -> None: + if not self.folder: + self.show_error("Select an album folder first.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + paths = list_images(self.folder, recursive=True) + + def task(progress=None, is_cancelled=None): + faces = [] + embeddings = [] + for index, path in enumerate(paths): + if is_cancelled and is_cancelled(): + break + image = read_image(path) + if image is None: + continue + for face in self.context.engine.detect_faces(image, source_path=str(path)): + if face.normed_embedding is not None: + embeddings.append(face.normed_embedding) + faces.append({"path": str(path), "quality": face.quality_score or 0.0, "bbox": face.bbox}) + if progress: + progress(index + 1, len(paths), f"Scanned {index + 1}/{len(paths)} photos") + labels, _algorithm = cluster_embeddings_dbscan(embeddings, distance_threshold=self.threshold.value()) if embeddings else ([], "none") + clusters = defaultdict(list) + for face, label in zip(faces, labels): + clusters[int(label)].append(face) + rows = [] + for label, items in clusters.items(): + rows.append({"cluster_id": label, "face_count": len(items), "photo_count": len({item["path"] for item in items}), "average_quality": sum(item["quality"] for item in items) / max(1, len(items)), "sample_paths": "; ".join(item["path"] for item in items[:5])}) + return rows + + self.run_task("Album clustering", task, lambda rows: (setattr(self, "rows", rows), self._populate(), self.set_status(f"Created {len(rows)} cluster(s)."))) + + def _populate(self) -> None: + columns = ["cluster_id", "face_count", "photo_count", "average_quality", "sample_paths"] + self.table.setRowCount(len(self.rows)) + for row_index, row in enumerate(self.rows): + for col, key in enumerate(columns): + value = row[key] + if isinstance(value, float): + value = f"{value:.4f}" + self.table.setItem(row_index, col, QTableWidgetItem(str(value))) + refresh_table_columns(self.table) + + def export(self) -> None: + if not self.rows: + self.show_error("No clusters to export.") + return + path = Path(self.context.config.export_dir) / f"album_clusters_{timestamp_for_filename()}.csv" + export_csv(path, self.rows) + self.set_status(f"Clusters exported to {path}") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/base.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/base.py new file mode 100644 index 0000000000000000000000000000000000000000..c1579217a40f4c3984b2e0f538f94a7e4831ea97 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/base.py @@ -0,0 +1,114 @@ +"""Base page helpers.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Callable, Optional + +from PySide6.QtCore import Qt +from PySide6.QtWidgets import ( + QFileDialog, + QFrame, + QHBoxLayout, + QLabel, + QMessageBox, + QPushButton, + QVBoxLayout, + QWidget, +) + +from ..core.constants import LOCAL_PROCESSING_NOTICE +from ..core.i18n import tr +from ..core.tooltips import set_button_tooltip + + +class BasePage(QWidget): + def __init__(self, context, title: str, description: str = "", parent=None): + super().__init__(parent) + self.context = context + self.title = title + self.root_layout = QVBoxLayout(self) + self.root_layout.setSpacing(12) + header = QLabel(title) + header.setStyleSheet("font-size: 24px; font-weight: 700;") + self.root_layout.addWidget(header) + if description: + desc = QLabel(description) + desc.setWordWrap(True) + desc.setProperty("role", "muted") + self.root_layout.addWidget(desc) + self.status_label = QLabel("") + self.status_label.setWordWrap(True) + self.status_label.setProperty("role", "status") + self.content = QVBoxLayout() + self.root_layout.addLayout(self.content, 1) + self.root_layout.addWidget(self.status_label) + + def notice(self, text: str = LOCAL_PROCESSING_NOTICE) -> QLabel: + label = QLabel(text) + label.setObjectName("noticeLabel") + label.setWordWrap(True) + return label + + def card(self) -> tuple[QFrame, QVBoxLayout]: + frame = QFrame() + frame.setFrameShape(QFrame.StyledPanel) + layout = QVBoxLayout(frame) + return frame, layout + + def row(self, *widgets) -> QWidget: + wrapper = QWidget() + layout = QHBoxLayout(wrapper) + layout.setContentsMargins(0, 0, 0, 0) + for widget in widgets: + layout.addWidget(widget) + layout.addStretch(1) + return wrapper + + def button(self, text: str, callback: Callable, enabled: bool = True) -> QPushButton: + btn = QPushButton(text) + btn.clicked.connect(callback) + btn.setEnabled(enabled) + set_button_tooltip(btn) + return btn + + def choose_file(self, caption: str, filters: str = "Images (*.jpg *.jpeg *.png *.bmp *.webp);;All Files (*)") -> Optional[str]: + path, _ = QFileDialog.getOpenFileName(self, caption, str(Path.home()), filters) + return path or None + + def choose_files(self, caption: str, filters: str = "Images (*.jpg *.jpeg *.png *.bmp *.webp);;All Files (*)") -> list[str]: + paths, _ = QFileDialog.getOpenFileNames(self, caption, str(Path.home()), filters) + return paths + + def choose_folder(self, caption: str) -> Optional[str]: + path = QFileDialog.getExistingDirectory(self, caption, str(Path.home())) + return path or None + + def save_file(self, caption: str, default_name: str, filters: str) -> Optional[str]: + path, _ = QFileDialog.getSaveFileName(self, caption, default_name, filters) + return path or None + + def set_status(self, message: str) -> None: + self.status_label.setText(tr(message, self.context.config.ui_language)) + main = self.window() + if main is not self and hasattr(main, "set_status"): + main.set_status(message) + + def show_error(self, message: str) -> None: + self.set_status(message) + QMessageBox.warning(self, tr(self.title, self.context.config.ui_language), tr(message, self.context.config.ui_language)) + + def run_task(self, title: str, fn: Callable, on_result: Callable | None = None, show_dialog: bool = True) -> None: + main = self.window() + if hasattr(main, "run_task"): + main.run_task(title, fn, on_result, show_dialog=show_dialog) + else: + try: + result = fn() + if on_result: + on_result(result) + except Exception as exc: + self.show_error(str(exc)) + + def refresh(self) -> None: + pass diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/batch_processing_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/batch_processing_page.py new file mode 100644 index 0000000000000000000000000000000000000000..1b2679cf296d540ff540cc7bfc0dc99720791629 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/batch_processing_page.py @@ -0,0 +1,117 @@ +"""Batch folder processing page.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtWidgets import QCheckBox, QLabel, QProgressBar, QSpinBox, QTableWidget, QTableWidgetItem + +from ..core.exporters import export_csv, export_json +from ..core.utils import list_images, read_image, save_image, timestamp_for_filename +from ..widgets.drop_input import DropInput +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from .base import BasePage + + +class BatchProcessingPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Batch Folder Processing", "Scan a folder, detect faces, optionally identify people, and export batch results.", parent) + self.folder = "" + self.rows = [] + self.recursive = QCheckBox("Recursive") + self.recursive.setChecked(True) + self.identify = QCheckBox("Identify people") + self.identify.setChecked(True) + self.save_crops = QCheckBox("Save face crops") + self.save_crops.setChecked(context.config.save_crops) + self.min_score = QSpinBox() + self.min_score.setRange(0, 100) + self.min_score.setValue(int(context.config.min_detection_score * 100)) + self.progress = QProgressBar() + self.table = QTableWidget(0, 10) + self.table.setHorizontalHeaderLabels(["image_path", "face_index", "person_id", "person_name", "similarity", "threshold", "status", "bbox", "det_score", "crop_path"]) + configure_table_columns(self.table, [300, 80, 80, 160, 90, 90, 110, 220, 90, 260]) + self.folder_input = DropInput("Image Folder", mode="folder") + self.folder_input.pathsChanged.connect(lambda paths: self.set_folder(paths[0]) if paths else self.clear_folder()) + self.content.addWidget(self.folder_input) + self.content.addWidget(self.row(self.recursive, self.identify, self.save_crops, QLabel("Min det score %"), self.min_score, self.button("Start", self.start), self.button("Export", self.export))) + self.content.addWidget(self.progress) + self.content.addWidget(self.table, 1) + + def set_folder(self, folder: str) -> None: + self.folder = folder + self.set_status(f"Selected folder: {folder}") + + def clear_folder(self) -> None: + self.folder = "" + self.rows = [] + self.progress.setValue(0) + self.table.setRowCount(0) + + def start(self) -> None: + if not self.folder: + self.show_error("Select a folder first.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + paths = [str(path) for path in list_images(self.folder, recursive=self.recursive.isChecked())] + min_score = self.min_score.value() / 100.0 + + def task(progress=None, is_cancelled=None): + rows = [] + gallery = self.context.storage.load_all_gallery_embeddings() if self.identify.isChecked() else [] + for index, path in enumerate(paths): + if is_cancelled and is_cancelled(): + break + image = read_image(path) + if image is None: + rows.append({"image_path": path, "status": "error", "error": "image read failure"}) + continue + media_id = self.context.storage.add_media_item(path, "image", width=image.shape[1], height=image.shape[0], processed_at=timestamp_for_filename()) + faces = [face for face in self.context.engine.detect_faces(image, source_path=path) if face.det_score >= min_score] + for face_index, face in enumerate(faces): + result = None + if face.normed_embedding is not None and gallery: + matches = self.context.storage.search_embeddings(face.normed_embedding, self.context.config.default_top_k, self.context.config.recognition_threshold) + result = matches[0] if matches else None + person_name = result.person_name if result and result.similarity >= self.context.config.recognition_threshold else "Unknown" + similarity = result.similarity if result else 0.0 + status = "matched" if result and result.similarity >= self.context.config.recognition_threshold else "unknown" + crop_path = "" + if self.save_crops.isChecked() and face.crop is not None: + crop_path = str(Path(self.context.config.crop_dir) / f"batch_{media_id}_{face_index}_{timestamp_for_filename()}.png") + save_image(crop_path, face.crop) + self.context.storage.add_media_face(media_id, face.normed_embedding, crop_path=crop_path, bbox=face.bbox, kps=face.kps, det_score=face.det_score, predicted_person_id=result.person_id if result else None, similarity=similarity, status=status) + rows.append({"image_path": path, "face_index": face_index, "person_id": result.person_id if result else "", "person_name": person_name, "similarity": similarity, "threshold": self.context.config.recognition_threshold, "status": status, "bbox": face.bbox, "det_score": face.det_score, "crop_path": crop_path}) + if progress: + progress(index + 1, len(paths), f"Processed {index + 1}/{len(paths)} files") + return rows + + def done(rows): + self.rows = rows + self.progress.setValue(100) + self._populate() + self.set_status(f"Batch complete. {len(rows)} face row(s).") + + self.run_task("Batch folder processing", task, done) + + def _populate(self) -> None: + columns = ["image_path", "face_index", "person_id", "person_name", "similarity", "threshold", "status", "bbox", "det_score", "crop_path"] + self.table.setRowCount(len(self.rows)) + for row_index, row in enumerate(self.rows): + for col, key in enumerate(columns): + value = row.get(key, "") + if isinstance(value, float): + value = f"{value:.4f}" + self.table.setItem(row_index, col, QTableWidgetItem(str(value))) + refresh_table_columns(self.table) + + def export(self) -> None: + if not self.rows: + self.show_error("No batch results to export.") + return + path = Path(self.context.config.export_dir) / f"batch_results_{timestamp_for_filename()}.csv" + export_csv(path, self.rows) + export_json(path.with_suffix(".json"), self.rows) + self.set_status(f"Batch results exported to {path}") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/camera_recognition_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/camera_recognition_page.py new file mode 100644 index 0000000000000000000000000000000000000000..d74991837b5495678b5a372ab24b33568820fe36 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/camera_recognition_page.py @@ -0,0 +1,32 @@ +"""Camera recognition page.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QLabel, QSpinBox + +from ..core.camera import list_camera_indices +from ..core.constants import RESPONSIBLE_USE_NOTICE +from ..widgets.threshold_slider import ThresholdSlider +from .base import BasePage + + +class CameraRecognitionPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Camera Recognition", "Live recognition preview for lawful, consent-based controlled environments.", parent) + self.camera_index = QSpinBox() + self.camera_index.setRange(0, 16) + self.frame_skip = QSpinBox() + self.frame_skip.setRange(1, 60) + self.frame_skip.setValue(context.config.camera_frame_skip) + self.threshold = ThresholdSlider(context.config.recognition_threshold) + self.content.addWidget(self.row(QLabel("Camera index"), self.camera_index, QLabel("Frame skip"), self.frame_skip, self.button("Check Cameras", self.check), self.button("Start", self.unavailable), self.button("Stop", self.unavailable), self.button("Register Current Face", self.unavailable))) + self.content.addWidget(self.threshold) + self.content.addWidget(self.notice(RESPONSIBLE_USE_NOTICE + " Live recognition should only be used with consent and in lawful, controlled environments.")) + self.content.addStretch(1) + + def check(self) -> None: + indices = list_camera_indices() + self.set_status("Available camera indices: " + (", ".join(map(str, indices)) if indices else "none detected")) + + def unavailable(self) -> None: + self.show_error("Live camera loop is not enabled in this first desktop build. Camera settings and responsible use notice are available.") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/compare_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/compare_page.py new file mode 100644 index 0000000000000000000000000000000000000000..9db0c3d863e4379d7711103bad68680e56bfd299 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/compare_page.py @@ -0,0 +1,195 @@ +"""1:1 face compare page.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtWidgets import QSplitter, QTextEdit, QWidget, QVBoxLayout +from PySide6.QtCore import Qt + +from ..core.exporters import export_json, export_markdown +from ..core.utils import read_image, timestamp_for_filename +from ..widgets.threshold_slider import ThresholdSlider +from ..widgets.upload_preview import UploadPreview +from .base import BasePage + + +class ComparePage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "1:1 Face Compare", "Compare two local images and export a structured result.", parent) + self.path_a = "" + self.path_b = "" + self.image_a = None + self.image_b = None + self._compare_generation = 0 + self._compare_running = False + image_filter = "Images (*.jpg *.jpeg *.png *.bmp *.webp);;All Files (*)" + image_exts = [".jpg", ".jpeg", ".png", ".bmp", ".webp"] + self.input_a = UploadPreview("Image A", extensions=image_exts, dialog_filter=image_filter) + self.input_b = UploadPreview("Image B", extensions=image_exts, dialog_filter=image_filter) + self.input_a.pathChanged.connect(lambda path: self.load_a(path) if path else self.clear_a()) + self.input_b.pathChanged.connect(lambda path: self.load_b(path) if path else self.clear_b()) + self.compare_button = self.button("Compare", self.compare) + controls = self.row( + self.compare_button, + self.button("Reset", self.reset), + self.button("Export Result", self.export_result), + ) + self.content.addWidget(controls) + self.threshold = ThresholdSlider(context.config.recognition_threshold) + self.content.addWidget(self.threshold) + splitter = QSplitter(Qt.Horizontal) + left = QWidget() + left_layout = QVBoxLayout(left) + self.viewer_a = self.input_a + left_layout.addWidget(self.viewer_a) + right = QWidget() + right_layout = QVBoxLayout(right) + self.viewer_b = self.input_b + right_layout.addWidget(self.viewer_b) + splitter.addWidget(left) + splitter.addWidget(right) + self.content.addWidget(splitter, 1) + self.result_text = QTextEdit() + self.result_text.setReadOnly(True) + self.content.addWidget(self.result_text) + self.result = None + + def load_a(self, path: str) -> None: + self.path_a = path + self.image_a = read_image(path) + if self.image_a is None: + self.viewer_a.clear(emit=False) + self.show_error("Image read failure.") + return + self.viewer_a.set_image(self.image_a, path) + self._invalidate_result("Image A replaced.") + + def load_b(self, path: str) -> None: + self.path_b = path + self.image_b = read_image(path) + if self.image_b is None: + self.viewer_b.clear(emit=False) + self.show_error("Image read failure.") + return + self.viewer_b.set_image(self.image_b, path) + self._invalidate_result("Image B replaced.") + + def clear_a(self) -> None: + self.path_a = "" + self.image_a = None + self.viewer_a.set_image(None) + self._invalidate_result() + + def clear_b(self) -> None: + self.path_b = "" + self.image_b = None + self.viewer_b.set_image(None) + self._invalidate_result() + + def compare(self) -> None: + if self._compare_running: + self.set_status("Compare is already running.") + return + if self.image_a is None or self.image_b is None: + self.show_error("Please select both images first.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + image_a = self.image_a.copy() + image_b = self.image_b.copy() + path_a = self.path_a + path_b = self.path_b + threshold = self.threshold.value() + self._compare_generation += 1 + generation = self._compare_generation + self._compare_running = True + self.compare_button.setEnabled(False) + + def task(): + try: + result = self.context.engine.compare_images( + image_a, + image_b, + threshold=threshold, + path1=path_a, + path2=path_b, + ) + return {"generation": generation, "result": result, "error": ""} + except Exception as exc: + return {"generation": generation, "result": None, "error": str(exc)} + + def done(payload): + self._compare_running = False + self.compare_button.setEnabled(True) + if payload["generation"] != self._compare_generation: + self.set_status("Ignored stale compare result.") + return + if payload["error"]: + self.show_error(payload["error"]) + return + result = payload["result"] + self.result = result + self.viewer_a.set_faces([{"bbox": result.face_a.bbox, "label": "Face A"}]) + self.viewer_b.set_faces([{"bbox": result.face_b.bbox, "label": "Face B"}]) + self.result_text.setPlainText( + "\n".join( + [ + f"Similarity: {result.similarity:.4f}", + f"Threshold: {result.threshold:.4f}", + f"Decision: {result.decision}", + f"Det score A: {result.face_a.det_score:.4f}", + f"Det score B: {result.face_b.det_score:.4f}", + "Notes: " + ("; ".join(result.notes) if result.notes else "Both faces detected successfully."), + ] + ) + ) + self.set_status(f"Compare complete: {result.decision}") + + self.run_task("Comparing faces", task, done, show_dialog=False) + + def reset(self) -> None: + self.path_a = self.path_b = "" + self.image_a = self.image_b = None + self.result = None + self.input_a.clear(emit=False) + self.input_b.clear(emit=False) + self._invalidate_result("Compare page reset.") + self._compare_running = False + self.compare_button.setEnabled(True) + self.set_status("Compare page reset.") + + def _invalidate_result(self, status: str = "") -> None: + self._compare_generation += 1 + self.result = None + self.result_text.clear() + self.viewer_a.set_faces([]) + self.viewer_b.set_faces([]) + if status: + self.set_status(status) + + def export_result(self) -> None: + if self.result is None: + self.show_error("No compare result to export.") + return + default = str(Path(self.context.config.export_dir) / f"compare_{timestamp_for_filename()}.json") + path = self.save_file("Export Result", default, "JSON (*.json);;Markdown (*.md)") + if not path: + return + if path.lower().endswith(".md"): + text = "\n".join( + [ + "# InsightFace 1:1 Compare Result", + f"- Image A: {self.path_a}", + f"- Image B: {self.path_b}", + f"- Similarity: {self.result.similarity:.4f}", + f"- Threshold: {self.result.threshold:.4f}", + f"- Decision: {self.result.decision}", + f"- Notes: {'; '.join(self.result.notes)}", + ] + ) + export_markdown(path, text) + else: + export_json(path, self.result.to_json_dict()) + self.set_status(f"Result exported to {path}") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/dashboard_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/dashboard_page.py new file mode 100644 index 0000000000000000000000000000000000000000..a100da6e835ec58d4f0fdda97dcee24646cbb354 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/dashboard_page.py @@ -0,0 +1,59 @@ +"""Dashboard page.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QGridLayout, QPushButton, QWidget + +from ..core.constants import LOCAL_PROCESSING_NOTICE, SUBTITLE +from ..core.tooltips import set_button_tooltip +from ..widgets.metric_card import MetricCard +from .base import BasePage + + +class DashboardPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Dashboard", "Welcome to InsightFace Evaluation Studio.\n" + SUBTITLE, parent) + self.content.addWidget(self.notice(LOCAL_PROCESSING_NOTICE)) + grid_widget = QWidget() + self.grid = QGridLayout(grid_widget) + self.cards = { + "workspace": MetricCard("Workspace", context.config.workspace_path), + "model": MetricCard("Model", context.config.model_name), + "provider": MetricCard("Provider", context.config.provider), + "license": MetricCard("License", context.config.license_status), + "people": MetricCard("People", "0"), + "samples": MetricCard("Face samples", "0"), + "media": MetricCard("Indexed photos", "0"), + "faces": MetricCard("Detected faces", "0"), + } + for index, card in enumerate(self.cards.values()): + self.grid.addWidget(card, index // 2, index % 2) + self.content.addWidget(grid_widget) + shortcuts = QWidget() + shortcut_layout = QGridLayout(shortcuts) + for index, (label, page) in enumerate( + [ + ("Start 1:1 Compare", "1:1 Compare"), + ("Add People", "People Library"), + ("Scan Folder", "Batch Folder Processing"), + ("Run Enterprise Evaluation", "Enterprise Evaluation"), + ("Open License Center", "License Center"), + ] + ): + button = QPushButton(label) + button.clicked.connect(lambda checked=False, target=page: self.window().open_page(target)) + set_button_tooltip(button) + shortcut_layout.addWidget(button, index // 3, index % 3) + self.content.addWidget(shortcuts) + self.content.addStretch(1) + + def refresh(self) -> None: + counts = self.context.storage.counts() + self.cards["workspace"].set_value(self.context.config.workspace_path) + self.cards["model"].set_value(self.context.config.model_name) + self.cards["provider"].set_value(self.context.config.provider) + self.cards["license"].set_value(self.context.config.license_status) + self.cards["people"].set_value(counts["people"]) + self.cards["samples"].set_value(counts["face_samples"]) + self.cards["media"].set_value(counts["media_items"]) + self.cards["faces"].set_value(counts["media_faces"]) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/enterprise_eval_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/enterprise_eval_page.py new file mode 100644 index 0000000000000000000000000000000000000000..811400eb544dd0f88c4f97d1a44e5cd8b1a8b266 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/enterprise_eval_page.py @@ -0,0 +1,1255 @@ +"""Single-page enterprise 1:1 and 1:N evaluation workflow.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import QEvent, Qt +from PySide6.QtWidgets import ( + QCheckBox, + QComboBox, + QDialog, + QDialogButtonBox, + QFrame, + QGridLayout, + QHBoxLayout, + QLabel, + QMessageBox, + QTextEdit, + QVBoxLayout, + QWidget, +) + +from ..core.evaluation import ( + MULTI_FACE_REQUIRE_ONE, + MULTI_FACE_SKIP, + MULTI_FACE_USE_CENTERED_LARGEST, + MULTI_FACE_USE_LARGEST, + run_identity_identification_evaluation, + run_identity_verification_evaluation, + validate_enterprise_dataset, +) +from ..core.i18n import apply_translations, effective_language, tr +from ..core.reporting import write_reports +from ..widgets.drop_input import DropInput +from .base import BasePage + + +DATASET_RULES_TEXT = """Enterprise Evaluation Dataset Rules + +The Enterprise Evaluation page supports local 1:1 verification and 1:N identification evaluation from identity folders. No images, embeddings, or reports are uploaded automatically. + +1:1 Verification + +Auto Split enabled: + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Each subfolder is one identity. A file whose name contains "gallery" is selected as that identity's gallery image. If no such file exists, the first sorted image is selected as gallery. All other images are probes. Evaluation compares every probe against every identity gallery, so each trial is probe vs gallery. + +Auto Split disabled: + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Every image is treated as a probe. Evaluation runs full pairwise probe-vs-probe comparisons across all identity folders. + +1:N Identification + +Auto Split enabled: + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +The identities/ folder is preferred when present. If it is not present, the selected dataset root may contain identity folders directly. Gallery selection follows the same Auto Split rule as 1:1. + +Auto Split disabled: + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/ and probe/ are required. unknown/ is optional. 1:N evaluation always requires gallery images. + +Validation Checks + +- The selected root exists and matches the selected mode. +- Required gallery and probe folders/images exist. +- Auto Split can create valid gallery/probe sets. +- 1:1 can generate both positive and negative pairs. +- 1:N probe identities have valid gallery coverage. +- Each image can be read. +- Detected face count follows the selected multi-face handling policy. + +Multi-face Handling + +- Require exactly one face: validation fails on multi-face images. +- Use largest face: evaluation uses the largest detected face. +- Use largest centered face: evaluation uses area - center_distance^2 * 2.0. +- Mark as skip: multi-face images are skipped; skipped gallery images can make validation fail. + +Report Outputs + +1:1 reports include best cosine threshold accuracy, FAR/FRR, TAR@FAR, threshold recommendations, latency, and raw result examples. + +1:N reports include Top1, TAR@FAR, threshold recommendations, latency, and raw result examples. +""" + +DATASET_RULES_LOCAL_TEXT = { + "zh": """Enterprise Evaluation 页面支持从身份文件夹进行本地 1:1 验证和 1:N 识别评测。图片、特征和报告不会被自动上传。 + +1:1 验证 + +启用 Auto Split: + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +每个子文件夹代表一个身份。文件名中包含 "gallery" 的图片会被选为该身份的 gallery image。如果不存在这样的文件,则选择排序后的第一张图片作为 gallery。其余图片作为 probe。评测会将每个 probe 与每个身份的 gallery 做比对,因此每个 trial 都是 probe vs gallery。 + +关闭 Auto Split: + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +每张图片都会被视为 probe。评测会在所有身份文件夹中的图片之间执行完整的 probe-vs-probe 两两比对。 + +1:N 识别 + +启用 Auto Split: + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +如果存在 identities/ 文件夹,会优先使用它。如果不存在,所选数据集根目录也可以直接包含身份文件夹。Gallery 选择规则与 1:1 的 Auto Split 相同。 + +关闭 Auto Split: + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/ 和 probe/ 是必需的。unknown/ 是可选的。1:N 评测始终需要 gallery 图片。 + +核验内容 + +- 所选根目录存在,并且与当前评测模式匹配。 +- 必需的 gallery 和 probe 文件夹/图片存在。 +- Auto Split 能生成有效的 gallery/probe 集合。 +- 1:1 能生成正样本对和负样本对。 +- 1:N 的 probe 身份有对应的有效 gallery。 +- 每张需要核验的图片都可以读取。 +- 检测到的人脸数量符合所选多人脸处理策略。 + +多人脸处理 + +- Require exactly one face: 多人脸图片会在核验阶段失败。 +- Use largest face: 评测使用检测到的最大人脸。 +- Use largest centered face: 评测使用 area - center_distance^2 * 2.0 得分最高的人脸。 +- Mark as skip: 多人脸图片会被跳过;如果被跳过的是 gallery 图片,则可能导致核验失败。 + +报告输出 + +1:1 报告包含最佳 cosine 阈值下的 accuracy、FAR/FRR、TAR@FAR、阈值建议、延迟和原始结果样例。 + +1:N 报告包含 Top1、TAR@FAR、阈值建议、延迟和原始结果样例。""", + "ja": """Enterprise Evaluation ページでは、ID フォルダからローカルの 1:1 検証と 1:N 識別評価を実行できます。画像、特徴量、レポートは自動アップロードされません。 + +1:1 検証 + +Auto Split 有効: + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +各サブフォルダは 1 つの ID を表します。ファイル名に "gallery" を含む画像がその ID の gallery image として選択されます。該当ファイルがない場合は、ソート順で最初の画像が gallery になります。それ以外の画像は probe です。評価では各 probe をすべての ID の gallery と比較するため、各 trial は probe vs gallery です。 + +Auto Split 無効: + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +すべての画像が probe として扱われます。すべての ID フォルダ内の画像に対して、probe-vs-probe の総当たり比較を行います。 + +1:N 識別 + +Auto Split 有効: + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +identities/ フォルダが存在する場合は優先されます。存在しない場合、選択したデータセットルートに ID フォルダを直接置くこともできます。Gallery の選択規則は 1:1 の Auto Split と同じです。 + +Auto Split 無効: + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/ と probe/ は必須です。unknown/ は任意です。1:N 評価には常に gallery 画像が必要です。 + +検証項目 + +- 選択したルートが存在し、選択中の評価モードと一致していること。 +- 必須の gallery/probe フォルダまたは画像が存在すること。 +- Auto Split が有効な gallery/probe セットを作成できること。 +- 1:1 で正例ペアと負例ペアを生成できること。 +- 1:N の probe ID に有効な gallery があること。 +- 検証対象の画像を読み込めること。 +- 検出された顔数が選択した複数顔処理ポリシーに従うこと。 + +複数顔の処理 + +- Require exactly one face: 複数顔画像は検証で失敗します。 +- Use largest face: 検出された最大の顔を使用します。 +- Use largest centered face: area - center_distance^2 * 2.0 のスコアが最も高い顔を使用します。 +- Mark as skip: 複数顔画像をスキップします。gallery 画像がスキップされると検証失敗になる場合があります。 + +レポート出力 + +1:1 レポートには、最適な cosine しきい値での accuracy、FAR/FRR、TAR@FAR、しきい値推奨、レイテンシ、原始結果例が含まれます。 + +1:N レポートには、Top1、TAR@FAR、しきい値推奨、レイテンシ、原始結果例が含まれます。""", + "ko": """Enterprise Evaluation 페이지는 ID 폴더에서 로컬 1:1 검증 및 1:N 식별 평가를 수행합니다. 이미지, 임베딩, 보고서는 자동 업로드되지 않습니다. + +1:1 검증 + +Auto Split 켜짐: + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +각 하위 폴더는 하나의 ID입니다. 파일명에 "gallery"가 포함된 이미지가 해당 ID의 gallery image로 선택됩니다. 그런 파일이 없으면 정렬된 첫 번째 이미지가 gallery가 됩니다. 나머지 이미지는 probe입니다. 평가는 각 probe를 모든 ID의 gallery와 비교하므로 각 trial은 probe vs gallery입니다. + +Auto Split 꺼짐: + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +모든 이미지는 probe로 처리됩니다. 모든 ID 폴더의 이미지에 대해 전체 probe-vs-probe 쌍 비교를 수행합니다. + +1:N 식별 + +Auto Split 켜짐: + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +identities/ 폴더가 있으면 우선 사용됩니다. 없으면 선택한 데이터셋 루트에 ID 폴더를 직접 둘 수 있습니다. Gallery 선택 규칙은 1:1 Auto Split과 동일합니다. + +Auto Split 꺼짐: + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/와 probe/는 필수입니다. unknown/은 선택 사항입니다. 1:N 평가는 항상 gallery 이미지가 필요합니다. + +검증 항목 + +- 선택한 루트가 존재하고 선택한 평가 모드와 일치해야 합니다. +- 필요한 gallery/probe 폴더 또는 이미지가 있어야 합니다. +- Auto Split이 유효한 gallery/probe 세트를 만들 수 있어야 합니다. +- 1:1은 양성 쌍과 음성 쌍을 모두 생성할 수 있어야 합니다. +- 1:N probe ID에는 유효한 gallery가 있어야 합니다. +- 검증 대상 이미지를 읽을 수 있어야 합니다. +- 감지된 얼굴 수가 선택한 다중 얼굴 처리 정책을 따라야 합니다. + +다중 얼굴 처리 + +- Require exactly one face: 다중 얼굴 이미지는 검증에서 실패합니다. +- Use largest face: 감지된 가장 큰 얼굴을 사용합니다. +- Use largest centered face: area - center_distance^2 * 2.0 점수가 가장 높은 얼굴을 사용합니다. +- Mark as skip: 다중 얼굴 이미지는 건너뜁니다. gallery 이미지가 건너뛰어지면 검증이 실패할 수 있습니다. + +보고서 출력 + +1:1 보고서에는 최적 cosine 임계값의 accuracy, FAR/FRR, TAR@FAR, 임계값 권장, 지연 시간, 원시 결과 예시가 포함됩니다. + +1:N 보고서에는 Top1, TAR@FAR, 임계값 권장, 지연 시간, 원시 결과 예시가 포함됩니다。""", + "es": """La página Enterprise Evaluation admite evaluación local 1:1 y 1:N desde carpetas de identidad. Las imágenes, embeddings e informes no se suben automáticamente. + +Verificación 1:1 + +Auto Split activado: + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Cada subcarpeta representa una identidad. Una imagen cuyo nombre contiene "gallery" se selecciona como gallery image de esa identidad. Si no existe, se usa la primera imagen ordenada como gallery. Las demás imágenes son probes. La evaluación compara cada probe contra la gallery de cada identidad, por lo que cada trial es probe vs gallery. + +Auto Split desactivado: + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Cada imagen se trata como probe. La evaluación ejecuta comparaciones completas probe-vs-probe entre todas las carpetas de identidad. + +Identificación 1:N + +Auto Split activado: + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +La carpeta identities/ se prefiere cuando existe. Si no existe, la raíz seleccionada puede contener carpetas de identidad directamente. La selección de gallery sigue la misma regla de Auto Split que 1:1. + +Auto Split desactivado: + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/ y probe/ son obligatorias. unknown/ es opcional. La evaluación 1:N siempre requiere imágenes gallery. + +Comprobaciones de validación + +- La raíz seleccionada existe y coincide con el modo elegido. +- Las carpetas o imágenes gallery/probe requeridas existen. +- Auto Split puede crear conjuntos gallery/probe válidos. +- 1:1 puede generar pares positivos y negativos. +- Las identidades probe de 1:N tienen cobertura gallery válida. +- Cada imagen que debe validarse puede leerse. +- El número de caras detectadas sigue la política de manejo de múltiples caras. + +Manejo de múltiples caras + +- Require exactly one face: las imágenes con varias caras fallan en validación. +- Use largest face: se usa la cara detectada más grande. +- Use largest centered face: se usa la cara con mayor puntuación area - center_distance^2 * 2.0. +- Mark as skip: las imágenes con varias caras se omiten; omitir imágenes gallery puede hacer fallar la validación. + +Salidas del informe + +Los informes 1:1 incluyen accuracy con el mejor umbral cosine, FAR/FRR, TAR@FAR, recomendaciones de umbral, latencia y ejemplos de resultados sin procesar. + +Los informes 1:N incluyen Top1, TAR@FAR, recomendaciones de umbral, latencia y ejemplos de resultados sin procesar.""", + "fr": """La page Enterprise Evaluation prend en charge l’évaluation locale 1:1 et 1:N à partir de dossiers d’identité. Les images, embeddings et rapports ne sont pas téléversés automatiquement. + +Vérification 1:1 + +Auto Split activé : + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Chaque sous-dossier représente une identité. Une image dont le nom contient "gallery" est sélectionnée comme gallery image de cette identité. Si aucun fichier ne correspond, la première image triée est utilisée comme gallery. Les autres images sont des probes. L’évaluation compare chaque probe à la gallery de chaque identité ; chaque trial est donc probe vs gallery. + +Auto Split désactivé : + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Chaque image est traitée comme probe. L’évaluation exécute des comparaisons probe-vs-probe complètes entre tous les dossiers d’identité. + +Identification 1:N + +Auto Split activé : + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Le dossier identities/ est préféré lorsqu’il existe. Sinon, la racine sélectionnée peut contenir directement les dossiers d’identité. La sélection de gallery suit la même règle Auto Split que 1:1. + +Auto Split désactivé : + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/ et probe/ sont obligatoires. unknown/ est optionnel. L’évaluation 1:N nécessite toujours des images gallery. + +Contrôles de validation + +- La racine sélectionnée existe et correspond au mode choisi. +- Les dossiers ou images gallery/probe requis existent. +- Auto Split peut créer des ensembles gallery/probe valides. +- 1:1 peut générer des paires positives et négatives. +- Les identités probe de 1:N disposent d’une gallery valide. +- Chaque image à valider peut être lue. +- Le nombre de visages détectés respecte la politique multi-visage sélectionnée. + +Gestion multi-visage + +- Require exactly one face: les images multi-visages échouent à la validation. +- Use largest face: l’évaluation utilise le plus grand visage détecté. +- Use largest centered face: l’évaluation utilise le visage au meilleur score area - center_distance^2 * 2.0. +- Mark as skip: les images multi-visages sont ignorées ; ignorer une image gallery peut faire échouer la validation. + +Sorties de rapport + +Les rapports 1:1 incluent l’accuracy au meilleur seuil cosine, FAR/FRR, TAR@FAR, recommandations de seuil, latence et exemples de résultats bruts. + +Les rapports 1:N incluent Top1, TAR@FAR, recommandations de seuil, latence et exemples de résultats bruts.""", + "de": """Die Seite Enterprise Evaluation unterstützt lokale 1:1-Verifikation und 1:N-Identifikation aus Identitätsordnern. Bilder, Embeddings und Berichte werden nicht automatisch hochgeladen. + +1:1-Verifikation + +Auto Split aktiviert: + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Jeder Unterordner steht für eine Identität. Eine Datei, deren Name "gallery" enthält, wird als gallery image dieser Identität gewählt. Wenn keine solche Datei vorhanden ist, wird das erste sortierte Bild als gallery verwendet. Alle anderen Bilder sind probes. Die Evaluierung vergleicht jede probe mit der gallery jeder Identität; jeder trial ist also probe vs gallery. + +Auto Split deaktiviert: + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Jedes Bild wird als probe behandelt. Die Evaluierung führt vollständige probe-vs-probe-Paarvergleiche über alle Identitätsordner aus. + +1:N-Identifikation + +Auto Split aktiviert: + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Der Ordner identities/ wird bevorzugt, wenn er vorhanden ist. Falls nicht, kann der ausgewählte Dataset-Root Identitätsordner direkt enthalten. Die Gallery-Auswahl folgt derselben Auto-Split-Regel wie bei 1:1. + +Auto Split deaktiviert: + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/ und probe/ sind erforderlich. unknown/ ist optional. Eine 1:N-Evaluierung benötigt immer gallery-Bilder. + +Validierungsprüfungen + +- Der ausgewählte Root existiert und passt zum gewählten Modus. +- Erforderliche gallery/probe-Ordner oder Bilder existieren. +- Auto Split kann gültige gallery/probe-Sets erzeugen. +- 1:1 kann positive und negative Paare erzeugen. +- 1:N-probe-Identitäten haben gültige gallery-Abdeckung. +- Jedes zu validierende Bild kann gelesen werden. +- Die erkannte Gesichtszahl folgt der ausgewählten Mehrgesichter-Strategie. + +Mehrgesichter-Strategie + +- Require exactly one face: Bilder mit mehreren Gesichtern schlagen in der Validierung fehl. +- Use largest face: Das größte erkannte Gesicht wird verwendet. +- Use largest centered face: Das Gesicht mit dem besten Score area - center_distance^2 * 2.0 wird verwendet. +- Mark as skip: Bilder mit mehreren Gesichtern werden übersprungen; übersprungene gallery-Bilder können die Validierung fehlschlagen lassen. + +Berichtsausgaben + +1:1-Berichte enthalten accuracy beim besten cosine-Schwellenwert, FAR/FRR, TAR@FAR, Schwellenwertempfehlungen, Latenz und Beispiele roher Ergebnisse. + +1:N-Berichte enthalten Top1, TAR@FAR, Schwellenwertempfehlungen, Latenz und Beispiele roher Ergebnisse.""", + "pt": """A página Enterprise Evaluation suporta avaliação local 1:1 e identificação 1:N a partir de pastas de identidade. Imagens, embeddings e relatórios não são carregados automaticamente. + +Verificação 1:1 + +Auto Split ativado: + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Cada subpasta representa uma identidade. Uma imagem cujo nome contém "gallery" é escolhida como gallery image dessa identidade. Se não existir, a primeira imagem ordenada é usada como gallery. As restantes imagens são probes. A avaliação compara cada probe com a gallery de cada identidade; cada trial é probe vs gallery. + +Auto Split desativado: + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Cada imagem é tratada como probe. A avaliação executa comparações completas probe-vs-probe entre todas as pastas de identidade. + +Identificação 1:N + +Auto Split ativado: + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +A pasta identities/ é preferida quando existe. Se não existir, a raiz selecionada pode conter diretamente pastas de identidade. A seleção de gallery segue a mesma regra de Auto Split do 1:1. + +Auto Split desativado: + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/ e probe/ são obrigatórios. unknown/ é opcional. A avaliação 1:N sempre requer imagens gallery. + +Verificações de validação + +- A raiz selecionada existe e corresponde ao modo selecionado. +- As pastas ou imagens gallery/probe necessárias existem. +- Auto Split consegue criar conjuntos gallery/probe válidos. +- 1:1 consegue gerar pares positivos e negativos. +- Identidades probe de 1:N têm cobertura gallery válida. +- Cada imagem a validar pode ser lida. +- A contagem de faces detectadas segue a política de múltiplas faces selecionada. + +Tratamento de múltiplas faces + +- Require exactly one face: imagens com múltiplas faces falham na validação. +- Use largest face: a avaliação usa a maior face detectada. +- Use largest centered face: a avaliação usa a face com maior pontuação area - center_distance^2 * 2.0. +- Mark as skip: imagens com múltiplas faces são ignoradas; imagens gallery ignoradas podem fazer a validação falhar. + +Saídas do relatório + +Relatórios 1:1 incluem accuracy no melhor limiar cosine, FAR/FRR, TAR@FAR, recomendações de limiar, latência e exemplos de resultados brutos. + +Relatórios 1:N incluem Top1, TAR@FAR, recomendações de limiar, latência e exemplos de resultados brutos.""", + "ru": """Страница Enterprise Evaluation поддерживает локальную оценку 1:1 и 1:N из папок идентичностей. Изображения, эмбеддинги и отчеты не загружаются автоматически. + +Верификация 1:1 + +Auto Split включен: + +dataset_1v1/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Каждая подпапка представляет одну идентичность. Файл, имя которого содержит "gallery", выбирается как gallery image для этой идентичности. Если такого файла нет, первым gallery становится первое изображение в отсортированном списке. Все остальные изображения являются probes. Оценка сравнивает каждый probe с gallery каждой идентичности, поэтому каждый trial — это probe vs gallery. + +Auto Split отключен: + +dataset_1v1/ + 0001__Alice/ + img001.jpg + img002.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Каждое изображение считается probe. Оценка выполняет полные попарные сравнения probe-vs-probe по всем папкам идентичностей. + +Идентификация 1:N + +Auto Split включен: + +dataset/ + identities/ + 0001__Alice/ + gallery.jpg + img002.jpg + img003.jpg + 0002__Bob/ + img001.jpg + img002.jpg + +Папка identities/ используется с приоритетом, если она существует. Если ее нет, выбранный корень датасета может напрямую содержать папки идентичностей. Выбор gallery следует тому же правилу Auto Split, что и в 1:1. + +Auto Split отключен: + +dataset_1n/ + gallery/ + 0001__Alice/ + enroll_001.jpg + enroll_002.jpg + 0002__Bob/ + enroll_001.jpg + probe/ + 0001__Alice/ + test_001.jpg + test_002.jpg + 0002__Bob/ + test_001.jpg + unknown/ + unknown_001.jpg + unknown_002.jpg + +gallery/ и probe/ обязательны. unknown/ является опциональной. Оценка 1:N всегда требует gallery-изображения. + +Проверки валидации + +- Выбранный корень существует и соответствует выбранному режиму. +- Необходимые папки или изображения gallery/probe существуют. +- Auto Split может создать валидные наборы gallery/probe. +- 1:1 может создать положительные и отрицательные пары. +- Идентичности probe в 1:N имеют валидное покрытие gallery. +- Каждое проверяемое изображение можно прочитать. +- Число обнаруженных лиц соответствует выбранной политике обработки нескольких лиц. + +Обработка нескольких лиц + +- Require exactly one face: изображения с несколькими лицами не проходят валидацию. +- Use largest face: оценка использует самое крупное обнаруженное лицо. +- Use largest centered face: оценка использует лицо с лучшим счетом area - center_distance^2 * 2.0. +- Mark as skip: изображения с несколькими лицами пропускаются; пропуск gallery-изображения может привести к ошибке валидации. + +Вывод отчетов + +Отчеты 1:1 включают accuracy при лучшем cosine-пороге, FAR/FRR, TAR@FAR, рекомендации по порогу, задержку и примеры сырых результатов. + +Отчеты 1:N включают Top1, TAR@FAR, рекомендации по порогу, задержку и примеры сырых результатов.""", +} + + +def dataset_rules_text(language: str | None) -> str: + lang = effective_language(language) + text = DATASET_RULES_LOCAL_TEXT.get(lang) + if text: + return f"{tr('Evaluation Dataset Rules', lang)}\n\n{text}" + return DATASET_RULES_TEXT + + +class DatasetRulesDialog(QDialog): + def __init__(self, language: str | None = None, parent=None): + if parent is None and isinstance(language, QWidget): + parent = language + language = getattr(getattr(parent, "context", None), "config", None) + language = getattr(language, "ui_language", None) + super().__init__(parent) + self.setWindowTitle("Evaluation Dataset Rules") + self.resize(820, 680) + layout = QVBoxLayout(self) + intro = QLabel("Prepare local identity folders using one of the supported layouts below.") + intro.setWordWrap(True) + intro.setProperty("role", "muted") + layout.addWidget(intro) + text = QTextEdit() + text.setReadOnly(True) + text.setPlainText(dataset_rules_text(language)) + layout.addWidget(text, 1) + buttons = QDialogButtonBox(QDialogButtonBox.Close) + buttons.rejected.connect(self.close) + layout.addWidget(buttons) + apply_translations(self, language) + + +class EnterpriseEvalPage(BasePage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Enterprise Evaluation", + "Run local 1:1 verification or 1:N identification evaluation from identity folders and export procurement-ready reports.", + parent, + ) + self.eval_mode = QComboBox() + self.eval_mode.setProperty("i18nItems", True) + self.eval_mode.addItem("1:1 Verification", "1:1 Verification") + self.eval_mode.addItem("1:N Identification", "1:N Identification") + self.eval_mode.currentIndexChanged.connect(self._update_instructions) + self.auto_split = QCheckBox("Auto Split") + self.auto_split.setChecked(True) + self.auto_split.setToolTip( + "Automatically select each identity's gallery image from a file containing 'gallery', or the first sorted image." + ) + self.auto_split.stateChanged.connect(self._update_instructions) + self.multi_face_policy = QComboBox() + self.multi_face_policy.setProperty("i18nItems", True) + self.multi_face_policy.addItem("Require exactly one face", MULTI_FACE_REQUIRE_ONE) + self.multi_face_policy.addItem("Use largest face", MULTI_FACE_USE_LARGEST) + self.multi_face_policy.addItem("Use largest centered face", MULTI_FACE_USE_CENTERED_LARGEST) + self.multi_face_policy.addItem("Mark as skip", MULTI_FACE_SKIP) + self.multi_face_policy.setToolTip( + "Choose how evaluation handles images where more than one face is detected." + ) + self.multi_face_policy.currentIndexChanged.connect(self._update_instructions) + self.dataset_root = DropInput("Identity Folders / Dataset Root", mode="folder") + self.dataset_root.pathsChanged.connect(self._on_dataset_paths_changed) + self.mode_summary = QLabel() + self.mode_summary.setWordWrap(True) + self.mode_summary.setProperty("role", "muted") + self.validation_status = QLabel("Validate the dataset before running an evaluation.") + self.validation_status.setWordWrap(True) + self.validation_status.setProperty("role", "muted") + + workspace = QWidget() + workspace_layout = QGridLayout(workspace) + workspace_layout.setContentsMargins(0, 0, 0, 0) + workspace_layout.setHorizontalSpacing(14) + workspace_layout.setVerticalSpacing(12) + + setup_card, setup_layout = self._card("Evaluation Setup") + setup_layout.addWidget(self._field_row("Evaluation mode", self.eval_mode)) + setup_layout.addWidget(self._field_row("Data split", self.auto_split)) + setup_layout.addWidget(self._field_row("Multi-face handling", self.multi_face_policy)) + self.help_button = self.button("Dataset Rules", self.show_dataset_rules) + self.help_button.setToolTip("Open the detailed identity folder rules for 1:1, 1:N, and Auto Split.") + setup_layout.addWidget(self.help_button, alignment=Qt.AlignLeft) + setup_layout.addStretch(1) + + data_card, data_layout = self._card("Dataset") + data_card.setAcceptDrops(True) + data_card.installEventFilter(self) + self.dataset_drop_card = data_card + data_layout.addWidget(self.dataset_root) + data_layout.addWidget(self.mode_summary) + data_layout.addStretch(1) + + actions_card, actions_layout = self._card("Run") + actions_hint = QLabel("Validate the selected dataset and configuration before running evaluation.") + actions_hint.setWordWrap(True) + actions_hint.setProperty("role", "muted") + actions_layout.addWidget(actions_hint) + actions_layout.addWidget(self.validation_status) + button_row = QHBoxLayout() + self.validate_button = self.button("Validate Dataset", self.validate_dataset) + self.run_button = self.button("Run Evaluation", self.run, enabled=False) + self.open_reports_button = self.button("Open Report Folder", self.open_report_folder) + button_row.addWidget(self.validate_button) + button_row.addWidget(self.run_button) + button_row.addWidget(self.open_reports_button) + button_row.addStretch(1) + actions_layout.addLayout(button_row) + actions_layout.addStretch(1) + + workspace_layout.addWidget(setup_card, 0, 0) + workspace_layout.addWidget(data_card, 0, 1) + workspace_layout.addWidget(actions_card, 1, 0, 1, 2) + workspace_layout.setColumnStretch(0, 0) + workspace_layout.setColumnStretch(1, 1) + self.content.addWidget(workspace) + + self.output = QTextEdit() + self.output.setReadOnly(True) + self.output.setMinimumHeight(260) + self.content.addWidget(self.output, 1) + self.last_result = None + self.last_report_paths: dict[str, str] = {} + self.validation_result = None + self._validated_signature: tuple[str, bool, str, str] | None = None + self._update_instructions() + + def eventFilter(self, watched, event) -> bool: # noqa: N802 + dataset_targets = { + getattr(self, "dataset_drop_card", None), + } + if watched in dataset_targets: + if event.type() in (QEvent.DragEnter, QEvent.DragMove): + if self._dataset_drop_path(event): + self._set_dataset_drag_active(True) + event.acceptProposedAction() + return True + event.ignore() + return True + if event.type() == QEvent.DragLeave: + self._set_dataset_drag_active(False) + return False + if event.type() == QEvent.Drop: + path = self._dataset_drop_path(event) + self._set_dataset_drag_active(False) + if path: + self.dataset_root.set_path(path) + self.set_status(f"Dataset root selected: {path}") + event.acceptProposedAction() + return True + event.ignore() + return True + return super().eventFilter(watched, event) + + def _dataset_drop_path(self, event) -> str: + mime = event.mimeData() + if not mime.hasUrls(): + return "" + for url in mime.urls(): + if not url.isLocalFile(): + continue + path = Path(url.toLocalFile()).expanduser() + if path.is_dir(): + return str(path) + return "" + + def _set_dataset_drag_active(self, active: bool) -> None: + if hasattr(self.dataset_root, "_set_property"): + self.dataset_root._set_property("dragActive", bool(active)) + + def _on_dataset_paths_changed(self, paths=None) -> None: + del paths + self._invalidate_validation() + + def _update_instructions(self) -> None: + language = self.context.config.ui_language + mode = self._eval_mode() + auto_split = self.auto_split.isChecked() + policy = tr(self.multi_face_policy.currentText(), language) + if mode.startswith("1:1"): + split_text = ( + "Auto Split selects one gallery image per identity and compares every probe against every identity gallery." + if auto_split + else "Auto Split is off, so every image is treated as a probe and full pairwise probe-vs-probe comparisons are generated." + ) + text = f"1:1 verification expects one identity per subfolder. {split_text}" + elif auto_split: + text = ( + "1:N Auto Split can use identities/ or identity folders directly. " + "Each identity must provide a gallery image and at least one probe." + ) + else: + text = ( + "1:N structured evaluation requires gallery/ and probe/. " + "unknown/ is optional and contributes impostor scores for FAR thresholds." + ) + self.mode_summary.setText( + f"{tr(text, language)} {tr('Multi-face handling', language)}: {policy}. " + f"{tr('Open Dataset Rules for detailed folder examples.', language)}" + ) + self._invalidate_validation() + + def _card(self, title: str) -> tuple[QFrame, QVBoxLayout]: + frame = QFrame() + frame.setObjectName("enterpriseCard") + frame.setFrameShape(QFrame.StyledPanel) + layout = QVBoxLayout(frame) + layout.setSpacing(10) + heading = QLabel(title) + heading.setObjectName("enterpriseCardTitle") + heading.setStyleSheet("font-size: 15px; font-weight: 700;") + layout.addWidget(heading) + return frame, layout + + def _field_row(self, label: str, widget) -> QWidget: + row = QWidget() + layout = QGridLayout(row) + layout.setContentsMargins(0, 0, 0, 0) + layout.setHorizontalSpacing(10) + caption = QLabel(label) + caption.setMinimumWidth(150) + caption.setProperty("role", "secondary") + layout.addWidget(caption, 0, 0, Qt.AlignTop) + layout.addWidget(widget, 0, 1) + layout.setColumnStretch(1, 1) + return row + + def show_dataset_rules(self) -> None: + dialog = DatasetRulesDialog(self.context.config.ui_language, self) + dialog.exec() + + def _current_signature(self) -> tuple[str, bool, str, str]: + return ( + self._eval_mode(), + self.auto_split.isChecked(), + self._multi_face_policy(), + self.dataset_root.path().strip(), + ) + + def _eval_mode(self) -> str: + return str(self.eval_mode.currentData() or "1:1 Verification") + + def _multi_face_policy(self) -> str: + return str(self.multi_face_policy.currentData() or MULTI_FACE_REQUIRE_ONE) + + def _invalidate_validation(self, *args) -> None: + del args + self._validated_signature = None + if hasattr(self, "run_button"): + self.run_button.setEnabled(False) + if hasattr(self, "validation_status"): + self.validation_status.setText( + tr("Dataset validation is required before running an evaluation.", self.context.config.ui_language) + ) + + def validate_dataset(self) -> None: + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + root = self.dataset_root.path().strip() + if not root: + self.show_error("Please select identity folders or a dataset root.") + return + signature = self._current_signature() + mode = self._eval_mode() + auto_split = self.auto_split.isChecked() + multi_face_policy = self._multi_face_policy() + + def task(progress=None, is_cancelled=None): + return validate_enterprise_dataset( + root, + mode, + auto_split, + self.context.engine, + multi_face_policy=multi_face_policy, + progress_callback=progress, + cancel_callback=is_cancelled, + ) + + def done(result): + self.validation_result = result + self.output.setPlainText(self._validation_text(result)) + if result.ok: + self._validated_signature = signature + self.run_button.setEnabled(True) + self.validation_status.setText( + tr("Dataset validation passed. Evaluation is ready to run.", self.context.config.ui_language) + ) + self.set_status("Dataset validation passed.") + else: + self._validated_signature = None + self.run_button.setEnabled(False) + self.validation_status.setText( + tr( + "Dataset validation failed. Fix the listed issues before running evaluation.", + self.context.config.ui_language, + ) + ) + self.set_status("Dataset validation failed.") + + self.run_task("Dataset validation", task, done) + + def run(self) -> None: + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + root = self.dataset_root.path().strip() + if not root: + self.show_error("Please select identity folders or a dataset root.") + return + if self._validated_signature != self._current_signature(): + self.show_error("Please validate this dataset and configuration before running evaluation.") + return + mode = self._eval_mode() + auto_split = self.auto_split.isChecked() + multi_face_policy = self._multi_face_policy() + + def task(progress=None, is_cancelled=None): + if mode.startswith("1:1"): + return run_identity_verification_evaluation( + root, + self.context.engine, + auto_split=auto_split, + multi_face_policy=multi_face_policy, + license_status=self.context.config.license_status, + progress_callback=progress, + cancel_callback=is_cancelled, + ) + return run_identity_identification_evaluation( + root, + self.context.engine, + auto_split=auto_split, + multi_face_policy=multi_face_policy, + license_status=self.context.config.license_status, + progress_callback=progress, + cancel_callback=is_cancelled, + ) + + def done(result): + language = self.context.config.ui_language + self.last_result = result + self.last_report_paths = write_reports(result, self.context.config.report_dir, language=language) + report_path = self.last_report_paths.get("pdf") or self.last_report_paths.get("markdown", "") + self.context.storage.save_evaluation_run( + result.scenario, + result.model_name, + result.provider, + result.threshold, + result.dataset_summary, + result.metrics, + result.latency, + report_path, + created_at=result.created_at, + ) + self.output.setPlainText(self._summary_text(result, self.last_report_paths)) + self.set_status(f"{tr('Evaluation complete. Report saved to:', language)} {report_path}") + QMessageBox.information( + self, + tr("Evaluation report saved", language), + f"{tr('Evaluation report saved to:', language)}\n{report_path}", + ) + + self.run_task("Enterprise evaluation", task, done) + + def _validation_text(self, result) -> str: + lines = [ + "Dataset Validation", + f"Status: {'PASSED' if result.ok else 'FAILED'}", + f"Mode: {result.mode}", + f"Auto Split: {result.auto_split}", + f"Multi-face policy: {result.multi_face_policy}", + f"Root: {result.root}", + "", + "Summary:", + ] + for key, value in result.summary.items(): + lines.append(f"{key}: {value}") + if result.errors: + lines.extend(["", f"Errors: {len(result.errors)}"]) + for row in result.errors[:50]: + lines.append(str(row)) + if len(result.errors) > 50: + lines.append(f"... {len(result.errors) - 50} more errors") + if result.warnings: + lines.extend(["", f"Warnings: {len(result.warnings)}"]) + for row in result.warnings[:50]: + lines.append(str(row)) + if len(result.warnings) > 50: + lines.append(f"... {len(result.warnings) - 50} more warnings") + return "\n".join(lines) + + def _summary_text(self, result, paths: dict[str, str]) -> str: + language = self.context.config.ui_language + lines = [ + f"{tr('Scenario', language)}: {result.scenario}", + f"{tr('Dataset', language)}: {result.dataset_summary}", + f"{tr('Report PDF', language)}: {paths.get('pdf', tr('not exported', language))}", + f"{tr('Report Markdown', language)}: {paths.get('markdown', tr('not exported', language))}", + f"{tr('Report HTML', language)}: {paths.get('html', tr('not exported', language))}", + "", + f"{tr('Metrics', language)}:", + ] + for key, value in result.metrics.items(): + if isinstance(value, float): + lines.append(f"{key}: {value:.6f}") + else: + lines.append(f"{key}: {value}") + if result.errors: + lines.extend(["", f"{tr('Errors', language)}: {len(result.errors)}", f"{tr('First errors', language)}:"]) + for row in result.errors[:10]: + lines.append(str(row)) + return "\n".join(lines) + + def open_report_folder(self) -> None: + from PySide6.QtCore import QUrl + from PySide6.QtGui import QDesktopServices + + QDesktopServices.openUrl(QUrl.fromLocalFile(str(Path(self.context.config.report_dir)))) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/face_search_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/face_search_page.py new file mode 100644 index 0000000000000000000000000000000000000000..ad5d62944b98c131c3fa0c7b45e578003ea07f3f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/face_search_page.py @@ -0,0 +1,179 @@ +"""1:N face search page.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import QSize, Qt +from PySide6.QtGui import QIcon, QPixmap +from PySide6.QtWidgets import QInputDialog, QSplitter, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget + +from ..core.exporters import export_csv, export_json +from ..core.utils import read_image, save_image, timestamp_for_filename +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from ..widgets.threshold_slider import ThresholdSlider +from ..widgets.upload_preview import UploadPreview +from .base import BasePage + + +class FaceSearchPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "1:N Face Search", "Search a query face against the local People Library.", parent) + self.query_path = "" + self.query_image = None + self.query_face = None + self.results = [] + self.query_input = UploadPreview( + "Query Image", + extensions=[".jpg", ".jpeg", ".png", ".bmp", ".webp"], + dialog_filter="Images (*.jpg *.jpeg *.png *.bmp *.webp);;All Files (*)", + ) + self.query_input.pathChanged.connect(lambda path: self.load_query(path) if path else self.clear_query()) + self.content.addWidget( + self.row( + self.button("Search", self.search), + self.button("Add as New Person", self.add_as_new_person), + self.button("Assign to Existing Person", self.assign_existing), + self.button("Export Results", self.export_results), + ) + ) + self.threshold = ThresholdSlider(context.config.recognition_threshold) + self.content.addWidget(self.threshold) + splitter = QSplitter(Qt.Horizontal) + left = QWidget() + left_layout = QVBoxLayout(left) + self.viewer = self.query_input + left_layout.addWidget(self.viewer) + right = QWidget() + right_layout = QVBoxLayout(right) + self.table = QTableWidget(0, 8) + self.table.setIconSize(QSize(48, 48)) + self.table.setHorizontalHeaderLabels(["rank", "person_id", "thumbnail", "person_name", "similarity", "status", "sample_id", "crop_path"]) + configure_table_columns(self.table, [60, 90, 90, 190, 90, 110, 90, 280]) + right_layout.addWidget(self.table) + splitter.addWidget(left) + splitter.addWidget(right) + self.content.addWidget(splitter, 1) + + def load_query(self, path: str) -> None: + self.query_path = path + self.query_image = read_image(path) + if self.query_image is None: + self.viewer.clear(emit=False) + self.show_error("Image read failure.") + return + self.viewer.set_image(self.query_image, path) + + def clear_query(self) -> None: + self.query_path = "" + self.query_image = None + self.query_face = None + self.results = [] + self.viewer.clear(emit=False) + self.table.setRowCount(0) + + def search(self) -> None: + if self.query_image is None: + self.show_error("Please select a query image.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + if not self.context.storage.load_all_gallery_embeddings(): + self.show_error("No registered people. Please add people first.") + return + + def task(): + face = self.context.engine.detect_best_face(self.query_image, source_path=self.query_path) + if face is None or face.normed_embedding is None: + raise ValueError("No face detected or embedding unavailable.") + results = self.context.storage.search_embeddings(face.normed_embedding, top_k=self.context.config.default_top_k, threshold=self.threshold.value()) + return face, results + + def done(payload): + self.query_face, self.results = payload + self.viewer.set_faces([{"bbox": self.query_face.bbox, "label": "Query"}]) + self.table.setRowCount(len(self.results)) + for row, result in enumerate(self.results): + data = [ + row + 1, + result.person_id if result.person_id is not None else "", + "", + result.person_name, + f"{result.similarity:.4f}", + result.status, + result.sample_id, + result.crop_path or "", + ] + for col, value in enumerate(data): + item = QTableWidgetItem(str(value)) + if col == 2: + icon = self._thumbnail_icon(result.crop_path) + if icon is not None: + item.setIcon(icon) + self.table.setItem(row, col, item) + self.table.setRowHeight(row, 54) + refresh_table_columns(self.table) + self.set_status(f"Search complete. {len(self.results)} result(s).") + + self.run_task("Searching people library", task, done) + + def add_as_new_person(self) -> None: + if self.query_face is None or self.query_face.normed_embedding is None: + self.show_error("Run a search first.") + return + name, ok = QInputDialog.getText(self, "Add as New Person", "Person name") + if not ok or not name.strip(): + return + person_id = self.context.storage.add_person(name.strip()) + crop_path = Path(self.context.config.crop_dir) / f"person_{person_id}_{timestamp_for_filename()}.png" + if self.query_face.crop is not None: + save_image(crop_path, self.query_face.crop) + self.context.storage.add_face_sample( + person_id, + self.query_face.normed_embedding, + source_image_path=self.query_path, + crop_path=str(crop_path), + bbox=self.query_face.bbox, + kps=self.query_face.kps, + det_score=self.query_face.det_score, + quality_score=self.query_face.quality_score, + model_name=self.context.config.model_name, + provider=self.context.config.provider, + ) + self.set_status(f"Added {name.strip()} to People Library.") + + def assign_existing(self) -> None: + people = self.context.storage.list_people() + if self.query_face is None or self.query_face.normed_embedding is None: + self.show_error("Run a search first.") + return + if not people: + self.show_error("No registered people. Please add people first.") + return + names = [person["display_name"] or person["name"] for person in people] + name, ok = QInputDialog.getItem(self, "Assign to Existing Person", "Person", names, 0, False) + if not ok: + return + person = people[names.index(name)] + self.context.storage.add_face_sample(int(person["id"]), self.query_face.normed_embedding, source_image_path=self.query_path, bbox=self.query_face.bbox, kps=self.query_face.kps, det_score=self.query_face.det_score, quality_score=self.query_face.quality_score, model_name=self.context.config.model_name, provider=self.context.config.provider) + self.set_status(f"Assigned query face to {name}.") + + def export_results(self) -> None: + if not self.results: + self.show_error("No search results to export.") + return + path = Path(self.context.config.export_dir) / f"face_search_{timestamp_for_filename()}.csv" + rows = [result.to_json_dict() for result in self.results] + export_csv(path, rows) + export_json(path.with_suffix(".json"), rows) + self.set_status(f"Search results exported to {path}") + + @staticmethod + def _thumbnail_icon(path: str | None) -> QIcon | None: + if not path: + return None + pixmap = QPixmap(str(Path(path))) + if pixmap.isNull(): + return None + return QIcon(pixmap.scaled(48, 48, Qt.KeepAspectRatio, Qt.SmoothTransformation)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/face_swap_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/face_swap_page.py new file mode 100644 index 0000000000000000000000000000000000000000..f194147fd15c6b99349efd3156f5e8ccb92843a2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/face_swap_page.py @@ -0,0 +1,318 @@ +"""Source + Target face swap page for images and videos.""" + +from __future__ import annotations + +from pathlib import Path +from types import SimpleNamespace + +import numpy as np +from PySide6.QtCore import QEvent, Qt, QUrl +from PySide6.QtGui import QDesktopServices +from PySide6.QtWidgets import QLabel, QSplitter, QVBoxLayout, QWidget + +from ..core.constants import IMAGE_EXTENSIONS, VIDEO_EXTENSIONS +from ..core.face_engine import providers_from_choice +from ..core.i18n import tr +from ..core.model_downloads import list_installed_swap_models +from ..core.swap import FaceSwapEngine +from ..core.utils import read_image, save_image, timestamp_for_filename +from ..widgets.image_viewer import ImageViewer +from ..widgets.upload_preview import UploadPreview +from .base import BasePage + + +class FaceSwapPage(BasePage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Face Swap", + "Source + Target = Result. Target can be an image or a video; the workflow chooses image or video swap automatically.", + parent, + ) + self.source_path = "" + self.target_path = "" + self.target_kind = "" + self.output_image = None + self.output_video_path = "" + self.output_path = "" + self.source_image = None + self.target_image = None + self.content.addWidget( + self.notice( + "Face swap may require separate commercial authorization depending on usage and model license. " + "Use only with appropriate rights and consent." + ) + ) + + image_filter = "Images (*.jpg *.jpeg *.png *.bmp *.webp);;All Files (*)" + target_filter = "Images and videos (*.jpg *.jpeg *.png *.bmp *.webp *.mp4 *.mov *.avi *.mkv *.webm *.m4v);;All Files (*)" + self.content.addWidget( + self.row( + self.button("Run Face Swap", self.run_swap), + self.button("Open Result Directory", self.open_result_directory), + ) + ) + splitter = QSplitter(Qt.Horizontal) + self.source_view = UploadPreview("Source", extensions=IMAGE_EXTENSIONS, dialog_filter=image_filter) + self.target_view = UploadPreview("Target", extensions=IMAGE_EXTENSIONS | VIDEO_EXTENSIONS, dialog_filter=target_filter) + self.output_view = ImageViewer() + self.output_view.setToolTip("Click to open the saved result file.") + self.output_view.viewport().installEventFilter(self) + self.output_view.installEventFilter(self) + self.result_label = QLabel("Result preview appears here. Video results are saved to the exports folder.") + self.result_label.setWordWrap(True) + self.result_label.setProperty("role", "muted") + self.source_view.pathChanged.connect(lambda path: self.load_source(path) if path else self.clear_source()) + self.target_view.pathChanged.connect(lambda path: self.load_target(path) if path else self.clear_target()) + + for title, viewer in [("Source", self.source_view), ("Target", self.target_view)]: + panel = QWidget() + layout = QVBoxLayout(panel) + label = QLabel(title) + label.setStyleSheet("font-weight:700;") + layout.addWidget(label) + layout.addWidget(viewer) + splitter.addWidget(panel) + + result_panel = QWidget() + result_layout = QVBoxLayout(result_panel) + result_title = QLabel("Result") + result_title.setStyleSheet("font-weight:700;") + result_layout.addWidget(result_title) + result_layout.addWidget(self.output_view) + result_layout.addWidget(self.result_label) + splitter.addWidget(result_panel) + splitter.setStretchFactor(0, 1) + splitter.setStretchFactor(1, 1) + splitter.setStretchFactor(2, 1) + self.content.addWidget(splitter, 1) + + def load_source(self, path: str) -> None: + self.source_path = path + self.source_image = read_image(path) + if self.source_image is None: + self.source_view.clear(emit=False) + self.show_error("Image read failure.") + return + self._clear_output() + self.source_view.set_image(self.source_image, path) + + def clear_source(self) -> None: + self.source_path = "" + self.source_image = None + self.source_view.clear(emit=False) + self._clear_output() + + def load_target(self, path: str) -> None: + self.target_path = path + suffix = Path(path).suffix.lower() + self._clear_output() + if suffix in IMAGE_EXTENSIONS: + self.target_kind = "image" + self.target_image = read_image(path) + if self.target_image is None: + self.target_view.clear(emit=False) + self.show_error("Image read failure.") + return + self.target_view.set_image(self.target_image, path) + self.set_status(f"Selected target image: {Path(path).name}") + return + if suffix in VIDEO_EXTENSIONS: + self.target_kind = "video" + self.target_image = self._read_video_preview(path) + if self.target_image is not None: + self.target_view.set_image(self.target_image, path) + else: + self.target_view.set_path(path, emit=False) + self.set_status(f"Selected target video: {Path(path).name}") + return + self.target_kind = "" + self.target_image = None + self.target_view.clear(emit=False) + self.show_error("Unsupported target file type.") + + def clear_target(self) -> None: + self.target_path = "" + self.target_kind = "" + self.target_image = None + self.target_view.clear(emit=False) + self._clear_output() + + def run_swap(self) -> None: + if self.source_image is None or not self.source_path: + self.show_error("Select a source image first.") + return + if not self.target_path or self.target_kind not in {"image", "video"}: + self.show_error("Select a target image or video first.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + model_path = self._resolve_swap_model_path() + if not model_path: + self.show_error("Face swap model not found. Please download and choose a swap model in Models.") + return + + source_image = self.source_image.copy() + target_path = self.target_path + target_kind = self.target_kind + target_image = self.target_image.copy() if self.target_image is not None and target_kind == "image" else None + + def task(progress=None, is_cancelled=None): + swapper = FaceSwapEngine( + model_path, + providers_from_choice(self.context.config.provider), + gfpgan_model_path=getattr(self.context.config, "gfpgan_model_path", ""), + enable_gfpgan=bool(getattr(self.context.config, "enable_gfpgan", False)), + ) + if not swapper.load(): + raise ValueError(swapper.last_error) + source_face = self.context.engine.detect_best_face(source_image, source_path=self.source_path) + if source_face is None or source_face.normed_embedding is None: + raise ValueError("No usable face detected in source image.") + source_native = SimpleNamespace(normed_embedding=source_face.normed_embedding) + if target_kind == "image": + return self._swap_image(swapper, source_native, target_image, target_path) + return self._swap_video(swapper, source_native, target_path, progress, is_cancelled) + + def done(result): + if result["kind"] == "image": + self.output_image = result["image"] + self.output_video_path = "" + self.output_path = result["path"] + self.output_view.set_image(self.output_image) + self.result_label.setText( + tr("Image swap saved. Click Result to open it.", self.context.config.ui_language) + + f"\n{self.output_path}" + ) + else: + self.output_image = result.get("preview") + self.output_video_path = result["path"] + self.output_path = result["path"] + if self.output_image is not None: + self.output_view.set_image(self.output_image) + self.result_label.setText( + tr("Video swap saved. Click Result to open it.", self.context.config.ui_language) + + f"\n{self.output_video_path}" + ) + self.set_status(result["message"]) + + self.run_task("Running face swap", task, done) + + def open_result(self) -> None: + if self.output_path and Path(self.output_path).exists(): + QDesktopServices.openUrl(QUrl.fromLocalFile(self.output_path)) + return + self.show_error("No saved result file to open.") + + def open_result_directory(self) -> None: + folder = Path(self.output_path).parent if self.output_path else Path(self.context.config.export_dir) + folder.mkdir(parents=True, exist_ok=True) + QDesktopServices.openUrl(QUrl.fromLocalFile(str(folder))) + + def _swap_image(self, swapper: FaceSwapEngine, source_native, target_image, target_path: str) -> dict: + if target_image is None: + raise ValueError("Target image could not be read.") + target_face = self.context.engine.detect_best_face(target_image, source_path=target_path) + if target_face is None or target_face.kps is None: + raise ValueError("No usable face detected in target image.") + target_native = SimpleNamespace(kps=np.asarray(target_face.kps, dtype=np.float32)) + image = swapper.swap(target_image, target_native, source_native) + output_path = Path(self.context.config.export_dir) / f"face_swap_{timestamp_for_filename()}.png" + save_image(output_path, image) + return { + "kind": "image", + "image": image, + "path": str(output_path), + "message": f"Image face swap saved to {output_path}", + } + + def _swap_video(self, swapper: FaceSwapEngine, source_native, target_path: str, progress=None, is_cancelled=None) -> dict: + try: + import cv2 + except Exception as exc: + raise ValueError(f"OpenCV is required for video face swap: {exc}") from exc + + cap = cv2.VideoCapture(target_path) + if not cap.isOpened(): + raise ValueError("Video could not be opened.") + fps = cap.get(cv2.CAP_PROP_FPS) or 25.0 + width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 0) + height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0) + frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0) + if width <= 0 or height <= 0: + cap.release() + raise ValueError("Video dimensions could not be read.") + output_path = Path(self.context.config.export_dir) / f"face_swap_video_{timestamp_for_filename()}.mp4" + output_path.parent.mkdir(parents=True, exist_ok=True) + writer = cv2.VideoWriter(str(output_path), cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height)) + if not writer.isOpened(): + cap.release() + raise ValueError("Video writer could not be opened.") + + preview = None + swapped = 0 + processed = 0 + try: + while True: + if is_cancelled and is_cancelled(): + break + ok, frame = cap.read() + if not ok: + break + output_frame = frame + target_face = self.context.engine.detect_best_face(frame, source_path=target_path) + if target_face is not None and target_face.kps is not None: + target_native = SimpleNamespace(kps=np.asarray(target_face.kps, dtype=np.float32)) + output_frame = swapper.swap(frame, target_native, source_native) + swapped += 1 + if preview is None: + preview = output_frame.copy() + writer.write(output_frame) + processed += 1 + if progress: + progress(processed, frame_count or processed, f"Processed {processed} frame(s), swapped {swapped}") + finally: + writer.release() + cap.release() + return { + "kind": "video", + "path": str(output_path), + "preview": preview, + "message": f"Video face swap complete. Processed {processed} frame(s), swapped {swapped} frame(s).", + } + + def _resolve_swap_model_path(self) -> str: + configured = getattr(self.context.config, "swap_model_path", "") + if configured and Path(configured).expanduser().exists(): + return str(Path(configured).expanduser()) + installed = list_installed_swap_models(self.context.config.model_root) + return str(installed[0]) if installed else "" + + def _clear_output(self) -> None: + self.output_image = None + self.output_video_path = "" + self.output_path = "" + self.output_view.set_image(None) + self.result_label.setText( + tr("Result preview appears here. Video results are saved to the exports folder.", self.context.config.ui_language) + ) + + def eventFilter(self, watched, event) -> bool: # noqa: N802 + if watched in {self.output_view, self.output_view.viewport()} and event.type() == QEvent.MouseButtonRelease: + if event.button() == Qt.LeftButton: + self.open_result() + return True + return super().eventFilter(watched, event) + + @staticmethod + def _read_video_preview(path: str) -> np.ndarray | None: + try: + import cv2 + + cap = cv2.VideoCapture(path) + ok, frame = cap.read() + cap.release() + return frame if ok else None + except Exception: + return None diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/license_center_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/license_center_page.py new file mode 100644 index 0000000000000000000000000000000000000000..9fc443259e1ceef1e1d491eb918a19166516b9ee --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/license_center_page.py @@ -0,0 +1,70 @@ +"""License Center page.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QLabel, QTableWidget, QTableWidgetItem + +from ..core.i18n import tr +from ..core.links import open_insightface_url +from ..core.licensing import allowed_usage_summary +from ..core.constants import APP_VERSION +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from .base import BasePage + +HOMEPAGE_URL = "https://www.insightface.ai" +ENTERPRISE_HELP_URL = "https://www.insightface.ai/contact" + + +class LicenseCenterPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "License Center", "A concise local-use and commercial-deployment summary.", parent) + self.summary = QLabel() + self.summary.setWordWrap(True) + self.content.addWidget(self.summary) + self.table = QTableWidget(0, 2) + self.table.setHorizontalHeaderLabels(["Usage", "Status"]) + self.table.setMinimumHeight(260) + configure_table_columns(self.table, [260, 420]) + self.content.addWidget(self.table) + self.content.addWidget( + self.row( + self.button("Visit Homepage", self.open_homepage), + self.button("Contact Enterprise Support", self.open_enterprise_help), + ) + ) + self.refresh() + + def refresh(self) -> None: + cfg = self.context.config + self.summary.setText( + " ".join( + [ + tr( + "InsightFace Evaluation Studio runs locally and does not upload images, embeddings, videos, or reports automatically.", + cfg.ui_language, + ), + tr( + "Code and model files may have different licenses, and commercial deployment requires appropriate model authorization.", + cfg.ui_language, + ), + f"{tr('Current package', cfg.ui_language)}: insightface {APP_VERSION}, GUI {APP_VERSION}, " + f"{tr('Model', cfg.ui_language).lower()} {cfg.model_name}, " + f"{tr('Provider', cfg.ui_language).lower()} {cfg.provider}, " + f"{tr('License', cfg.ui_language).lower()} {tr(cfg.license_status, cfg.ui_language)}.", + ] + ) + ) + summary = allowed_usage_summary() + self.table.setRowCount(len(summary)) + for row, (usage, status) in enumerate(summary.items()): + self.table.setItem(row, 0, QTableWidgetItem(tr(usage, cfg.ui_language))) + self.table.setItem(row, 1, QTableWidgetItem(tr(status, cfg.ui_language))) + refresh_table_columns(self.table) + + def open_homepage(self) -> None: + open_insightface_url(HOMEPAGE_URL, content="license_homepage") + self.set_status("Opened InsightFace homepage.") + + def open_enterprise_help(self) -> None: + open_insightface_url(ENTERPRISE_HELP_URL, content="license_enterprise_support") + self.set_status("Opened InsightFace enterprise contact page.") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/mode_dashboards.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/mode_dashboards.py new file mode 100644 index 0000000000000000000000000000000000000000..5dd0f61bf613adb8a889ed4a482dacbeac9c5ffe --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/mode_dashboards.py @@ -0,0 +1,116 @@ +"""Mode-specific dashboard pages.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QGridLayout, QLabel, QPushButton, QWidget + +from ..core.constants import LOCAL_PROCESSING_NOTICE, RESPONSIBLE_USE_NOTICE +from ..core.tooltips import set_button_tooltip +from .base import BasePage + + +class ModeDashboardPage(BasePage): + def __init__( + self, + context, + title: str, + description: str, + cards: list[tuple[str, str, str, str]], + notice: str = LOCAL_PROCESSING_NOTICE, + parent=None, + ): + super().__init__(context, title, description, parent) + self.content.addWidget(self.notice(notice)) + grid_widget = QWidget() + grid = QGridLayout(grid_widget) + grid.setSpacing(12) + for index, (card_title, body, page_key, action) in enumerate(cards): + card = QWidget() + card.setObjectName("dashboardCard") + layout = QGridLayout(card) + title_label = QLabel(card_title) + title_label.setStyleSheet("font-size:16px; font-weight:700; border:0;") + body_label = QLabel(body) + body_label.setWordWrap(True) + body_label.setProperty("role", "muted") + button = QPushButton(action) + button.clicked.connect(lambda checked=False, target=page_key: self.window().open_page(target)) + set_button_tooltip(button, body) + layout.addWidget(title_label, 0, 0) + layout.addWidget(body_label, 1, 0) + layout.addWidget(button, 2, 0) + grid.addWidget(card, index // 2, index % 2) + self.content.addWidget(grid_widget) + self.content.addStretch(1) + + +class FaceDashboardPage(ModeDashboardPage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Verification Dashboard", + "Compare, identify, and recognize faces from images, folders, camera, and video.", + [ + ("1:1 Compare", "Compare two local face images and export the decision.", "compare", "Open"), + ("1:N Search", "Search a query face against your local People Library.", "face_search", "Open"), + ("People Library", "Register people and manage local face samples.", "people_library", "Manage"), + ("Batch Processing", "Scan folders and identify known or unknown faces.", "batch_processing", "Scan"), + ("Camera Recognition", "Run live local recognition with consent.", "camera_recognition", "Open"), + ("Video Search", "Find a registered person in a local video.", "video_search", "Open"), + ], + parent=parent, + ) + + +class AlbumDashboardPage(ModeDashboardPage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Album Dashboard", + "Organize local photos by people, clusters, and searchable face groups.", + [ + ("Scan Photo Library", "Index local image folders for face organization.", "album_import_scan", "Scan"), + ("People Clustering", "Group unknown faces into approximate person clusters.", "album_people_clustering", "Cluster"), + ("People Library", "Review known people and high-quality samples.", "people_library", "Manage"), + ("Search by Person", "Find likely person matches in your local library.", "album_person_search", "Search"), + ("Export Results", "Prepare local CSV and folder exports.", "album_export", "Review"), + ], + parent=parent, + ) + + +class SwapDashboardPage(ModeDashboardPage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Swap Dashboard", + "Swap faces in images and videos using configured InsightFace swap models.", + [ + ("Image Face Swap", "Try a local image swap with a configured swap model.", "image_face_swap", "Open"), + ("Batch Image Swap", "Swap faces across a folder of images.", "batch_image_swap", "Preview"), + ("Video Face Swap", "Video swap workflows are planned for a future version.", "video_face_swap", "Preview"), + ("Source Face Library", "Prepare high-quality source faces for reuse.", "source_face_library", "Preview"), + ], + notice=( + RESPONSIBLE_USE_NOTICE + + " Face swap may require separate commercial authorization depending on usage and model license." + ), + parent=parent, + ) + + +class EnterpriseDashboardPage(ModeDashboardPage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Evaluation Dashboard", + "Evaluate InsightFace models on local business datasets and generate procurement-ready reports.", + [ + ("Run Evaluation", "Run KYC, 1:N, media, video, or swap evaluation scenarios.", "enterprise_evaluation", "Run"), + ("Dataset Setup", "Prepare local datasets and CSV templates.", "enterprise_dataset_setup", "Review"), + ("Reports", "Open and export historical evaluation reports.", "reports", "Open"), + ("Threshold Calibration", "Review threshold operating points and recommendations.", "threshold_calibration", "Review"), + ("Commercial Next Steps", "Understand licensing, SDK, API, SLA, and custom training paths.", "commercial_next_steps", "Open"), + ], + parent=parent, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/model_download_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/model_download_page.py new file mode 100644 index 0000000000000000000000000000000000000000..f29cd87205a3b785d4684a0bebccfdcf8886e827 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/model_download_page.py @@ -0,0 +1,186 @@ +"""Manual GitHub release model downloads.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import QUrl +from PySide6.QtGui import QDesktopServices +from PySide6.QtWidgets import QAbstractItemView, QFrame, QLabel, QTableWidget, QTableWidgetItem, QVBoxLayout + +from ..core.config import save_config +from ..core.constants import LICENSE_NOTICE +from ..core.i18n import tr +from ..core.model_downloads import ( + GITHUB_RELEASES_URL, + ModelAsset, + download_model_asset, + load_cached_assets, + local_model_status, + refresh_model_assets, +) +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from .base import BasePage + + +class ModelDownloadPage(BasePage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Model Downloads", + "Manually refresh GitHub release model URLs and download selected model packages locally.", + parent, + ) + self.assets: list[ModelAsset] = [] + self.content.addWidget( + self.notice( + "Downloads are manual only. The GUI does not auto-download models. " + "Model files may have different licenses from code; review usage before deployment." + ) + ) + self.content.addWidget(self.notice(LICENSE_NOTICE)) + self.content.addWidget( + self.row( + self.button("Refresh Download URLs", self.refresh_urls), + self.button("Download Selected", self.download_selected), + self.button("Use Selected Model", self.use_selected_model), + self.button("Open Model Folder", self.open_model_folder), + self.button("Open GitHub Releases", self.open_releases), + ) + ) + self.table = QTableWidget(0, 8) + self.table.setSelectionBehavior(QAbstractItemView.SelectRows) + self.table.setSelectionMode(QAbstractItemView.SingleSelection) + self.table.setEditTriggers(QAbstractItemView.NoEditTriggers) + self.table.setHorizontalHeaderLabels( + ["asset", "source", "kind", "release", "size", "updated_at", "local status", "download url"] + ) + configure_table_columns(self.table, [210, 100, 150, 130, 90, 170, 150, 360]) + self.table.setMinimumHeight(400) + self.content.addWidget(self.table, 1) + self.content.addSpacing(8) + self.source_footer = QFrame() + self.source_footer.setObjectName("downloadSourceFooter") + footer_layout = QVBoxLayout(self.source_footer) + footer_layout.setContentsMargins(10, 8, 10, 8) + self.url_label = QLabel() + self.url_label.setWordWrap(True) + self.url_label.setProperty("role", "muted") + footer_layout.addWidget(self.url_label) + self.content.addWidget(self.source_footer) + self.refresh() + + def refresh(self) -> None: + self.assets = load_cached_assets(self.context.config.cache_dir) + self.populate() + + def populate(self) -> None: + self.table.setRowCount(len(self.assets)) + for row, asset in enumerate(self.assets): + values = [ + asset.name, + asset.source, + asset.kind, + asset.tag_name, + self._format_size(asset.size), + asset.updated_at, + local_model_status(asset, self.context.config.model_root), + asset.browser_download_url, + ] + for col, value in enumerate(values): + self.table.setItem(row, col, QTableWidgetItem(str(value))) + refresh_table_columns(self.table) + language = self.context.config.ui_language + self.url_label.setText( + f"{tr('Refresh source', language)}: {GITHUB_RELEASES_URL}\n" + f"{tr('Local model root', language)}: {Path(self.context.config.model_root).expanduser() / 'models'}" + ) + + def selected_asset(self) -> ModelAsset | None: + row = self.table.currentRow() + if row < 0 or row >= len(self.assets): + self.show_error("Select a model asset first.") + return None + return self.assets[row] + + def refresh_urls(self) -> None: + def task(): + return refresh_model_assets(self.context.config.cache_dir) + + def done(payload): + self.assets, message = payload + self.populate() + self.set_status(message) + + self.run_task("Refreshing model download URLs", task, done) + + def download_selected(self) -> None: + asset = self.selected_asset() + if asset is None: + return + + def task(progress=None, is_cancelled=None): + del is_cancelled + if progress: + progress(0, asset.size or 1, f"Connecting to download {asset.name}") + return download_model_asset( + asset, + model_root=self.context.config.model_root, + gui_cache_dir=self.context.config.cache_dir, + progress=progress, + ) + + def done(path): + path = Path(path) + lower_name = asset.name.lower() + if "gfpgan" in lower_name: + self.context.config.gfpgan_model_path = str(path) + save_config(self.context.config) + elif "swap" in lower_name or "inswapper" in lower_name: + self.context.config.swap_model_path = str(path) + save_config(self.context.config) + self.populate() + manager = self.window() + if hasattr(manager, "refresh_model_pages"): + manager.refresh_model_pages() + self.set_status(f"Downloaded {asset.name} to {path}") + + self.run_task(f"Downloading {asset.name}", task, done) + + def use_selected_model(self) -> None: + asset = self.selected_asset() + if asset is None: + return + if asset.name.endswith(".zip"): + self.context.config.model_name = asset.stem + self.context.config.custom_model_dir = "" + save_config(self.context.config) + self.set_status(f"Model set to {asset.stem}. Open Models and test model load.") + elif asset.name.endswith(".onnx"): + path = Path(self.context.config.model_root).expanduser() / "models" / asset.stem / asset.name + if "gfpgan" in asset.name.lower(): + self.context.config.gfpgan_model_path = str(path) + save_config(self.context.config) + self.set_status(f"GFPGAN model set to {path}. Enable GFPGAN in Models > Runtime to use it after face swap.") + elif "swap" in asset.name.lower() or "inswapper" in asset.name.lower(): + self.context.config.swap_model_path = str(path) + save_config(self.context.config) + self.set_status(f"Face swap model set to {path}.") + else: + self.set_status(f"ONNX model path: {path}") + else: + self.set_status("Selected asset cannot be used as a model package.") + + def open_model_folder(self) -> None: + folder = Path(self.context.config.model_root).expanduser() / "models" + folder.mkdir(parents=True, exist_ok=True) + QDesktopServices.openUrl(QUrl.fromLocalFile(str(folder))) + + def open_releases(self) -> None: + QDesktopServices.openUrl(QUrl(GITHUB_RELEASES_URL)) + + @staticmethod + def _format_size(size: int) -> str: + if not size: + return "" + return f"{size / (1024 * 1024):.1f} MB" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/model_settings_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/model_settings_page.py new file mode 100644 index 0000000000000000000000000000000000000000..6f398305d78b70ffd159dc1f7d1a6b4c70c18a10 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/model_settings_page.py @@ -0,0 +1,234 @@ +"""Model settings page.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import Qt +from PySide6.QtGui import QColor, QBrush +from PySide6.QtWidgets import QCheckBox, QComboBox, QFormLayout, QLabel, QLineEdit, QTextEdit + +from ..core.config import save_config +from ..core.face_engine import FaceEngine, is_cuda_provider_available, providers_from_choice +from ..core.model_downloads import is_model_package_installed, list_installed_gfpgan_models, list_installed_swap_models +from .base import BasePage + + +class ModelSettingsPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Model Settings", "Configure model packs, execution provider, face swap models, and runtime checks.", parent) + form = QFormLayout() + self.model_combo = QComboBox() + self.model_packages = ["buffalo_l", "buffalo_m", "buffalo_s", "buffalo_sc", "antelopev2"] + self._rebuild_model_combo() + self.custom_dir = QLineEdit(context.config.custom_model_dir) + self.custom_dir_label = None + self._update_model_availability() + self.model_combo.currentIndexChanged.connect(self._update_custom_dir_visibility) + self.provider_combo = QComboBox() + self.provider_combo.addItems(["Auto", "CPU", "CUDA"]) + self.provider_combo.setCurrentText(context.config.provider) + self._update_provider_availability() + self.det_combo = QComboBox() + self.det_combo.addItems(["Auto", "128x128", "320x320", "640x640", "1024x1024"]) + self.det_combo.setCurrentText(context.config.det_size_label) + self.swap_model_combo = QComboBox() + self._update_swap_model_choices() + self.gfpgan_enabled = QCheckBox("Enable GFPGAN restore after face swap") + self.gfpgan_enabled.setChecked(bool(getattr(context.config, "enable_gfpgan", False))) + self.gfpgan_model_combo = QComboBox() + self._update_gfpgan_model_choices() + form.addRow("Model package", self.model_combo) + form.addRow("Custom model directory", self.custom_dir) + self.custom_dir_label = form.labelForField(self.custom_dir) + form.addRow("Provider", self.provider_combo) + form.addRow("Detection size", self.det_combo) + form.addRow("Face swap model", self.swap_model_combo) + form.addRow("GFPGAN post-processing", self.gfpgan_enabled) + form.addRow("GFPGAN model", self.gfpgan_model_combo) + self.content.addLayout(form) + self.runtime = QTextEdit() + self.runtime.setReadOnly(True) + self.content.addWidget(QLabel("Runtime information")) + self.content.addWidget(self.runtime) + self.content.addWidget( + self.row( + self.button("Save Settings", self.save), + self.button("Open Model Downloads", lambda: self.window().open_page("Model Downloads")), + self.button("Test Model Load", self.test_load), + self.button("Warmup", self.warmup), + ) + ) + self.refresh() + self._update_custom_dir_visibility() + + def _apply_to_config(self) -> None: + cfg = self.context.config + chosen = self.model_combo.currentData() + cfg.model_name = chosen if chosen != "custom model directory" else self.custom_dir.text().strip() + cfg.custom_model_dir = self.custom_dir.text().strip() + provider = self.provider_combo.currentText() + cfg.provider = "Auto" if provider == "CUDA" and not is_cuda_provider_available() else provider + if self.det_combo.currentText() == "Auto": + cfg.det_size = [0, 0] + else: + size = self.det_combo.currentText().split("x") + cfg.det_size = [int(size[0]), int(size[1])] + cfg.swap_model_path = str(self.swap_model_combo.currentData() or "") + cfg.gfpgan_model_path = str(self.gfpgan_model_combo.currentData() or "") + cfg.enable_gfpgan = bool(self.gfpgan_enabled.isChecked() and cfg.gfpgan_model_path) + + def save(self) -> None: + self._apply_to_config() + save_config(self.context.config) + self.set_status("Model settings saved.") + self.refresh() + + def test_load(self) -> None: + self._apply_to_config() + + def task(): + engine = FaceEngine( + model_name=self.context.config.model_name, + providers=providers_from_choice(self.context.config.provider), + det_size=self.context.config.det_size_tuple, + root=self.context.config.model_root, + custom_model_dir=self.context.config.custom_model_dir, + ) + engine.load() + return engine + + def done(engine): + self.context.engine = engine + self.window().context.engine = engine + self.refresh() + if engine.is_loaded(): + self.set_status("Model loaded successfully.") + else: + self.show_error(engine.last_error or "Model load failed.") + + self.run_task("Loading model", task, done) + + def warmup(self) -> None: + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + self.run_task("Model warmup", self.context.engine.warmup, lambda info: self.set_status(f"Warmup complete: {info['warmup_ms']:.1f} ms")) + + def refresh(self) -> None: + self._update_model_availability() + self._update_provider_availability() + self._update_swap_model_choices() + self._update_gfpgan_model_choices() + info = self.context.engine.get_runtime_info() + self.runtime.setPlainText("\n".join(f"{key}: {value}" for key, value in info.items())) + + def _update_provider_availability(self) -> None: + cuda_available = is_cuda_provider_available() + cuda_index = self.provider_combo.findText("CUDA") + if cuda_index >= 0: + item = self.provider_combo.model().item(cuda_index) + if item is not None: + item.setEnabled(cuda_available) + item.setToolTip( + "CUDAExecutionProvider is available." + if cuda_available + else "CUDAExecutionProvider is not available. Install a matching onnxruntime-gpu, CUDA runtime, and GPU driver first." + ) + if self.provider_combo.currentText() == "CUDA" and not cuda_available: + self.provider_combo.setCurrentText("Auto") + self.provider_combo.setToolTip("CUDA is unavailable on this machine, so Auto will use CPU.") + else: + self.provider_combo.setToolTip("Auto uses CUDA when CUDAExecutionProvider is available, otherwise CPU.") + + def _update_model_availability(self) -> None: + model = self.model_combo.model() + for index, package in enumerate(self.model_packages): + item = model.item(index) + if item is None: + continue + installed = is_model_package_installed(package, self.context.config.model_root) + item.setEnabled(installed) + item.setText(package if installed else f"{package} (not downloaded)") + item.setData(package, Qt.UserRole) + if installed: + item.setData(None, Qt.ForegroundRole) + else: + item.setForeground(QBrush(QColor("#9ca3af"))) + item.setToolTip( + f"{package} is installed under {self.context.config.model_root}/models." + if installed + else f"{package} is not downloaded. Open Models > Downloads to install it." + ) + custom_item = model.item(len(self.model_packages)) + if custom_item is not None: + custom_item.setEnabled(True) + custom_item.setText("custom model directory") + custom_item.setData("custom model directory", Qt.UserRole) + current = self.context.config.model_name if self.context.config.model_name in self.model_packages else "custom model directory" + index = self.model_combo.findData(current) + if index >= 0: + self.model_combo.setCurrentIndex(index) + self._update_custom_dir_visibility() + + def _rebuild_model_combo(self) -> None: + self.model_combo.clear() + for package in self.model_packages: + self.model_combo.addItem(package, package) + self.model_combo.addItem("custom model directory", "custom model directory") + + def _update_custom_dir_visibility(self) -> None: + is_custom = self.model_combo.currentData() == "custom model directory" + self.custom_dir.setVisible(is_custom) + if hasattr(self, "custom_dir_label") and self.custom_dir_label is not None: + self.custom_dir_label.setVisible(is_custom) + + def _update_swap_model_choices(self) -> None: + current = getattr(self.context.config, "swap_model_path", "") + paths = list_installed_swap_models(self.context.config.model_root) + self.swap_model_combo.blockSignals(True) + self.swap_model_combo.clear() + if not paths: + self.swap_model_combo.addItem("No downloaded swap models", "") + self.swap_model_combo.setEnabled(False) + self.swap_model_combo.setToolTip("Download inswapper_128.onnx from Models > Downloads first.") + else: + self.swap_model_combo.setEnabled(True) + self.swap_model_combo.setToolTip("Only downloaded swap models are shown.") + for path in paths: + label = f"{Path(path).parent.name}/{Path(path).name}" + self.swap_model_combo.addItem(label, str(path)) + index = self.swap_model_combo.findData(current) + if index >= 0: + self.swap_model_combo.setCurrentIndex(index) + elif current and Path(current).exists(): + self.swap_model_combo.addItem(Path(current).name, current) + self.swap_model_combo.setCurrentIndex(self.swap_model_combo.count() - 1) + self.swap_model_combo.blockSignals(False) + + def _update_gfpgan_model_choices(self) -> None: + current = getattr(self.context.config, "gfpgan_model_path", "") + paths = list_installed_gfpgan_models(self.context.config.model_root) + self.gfpgan_model_combo.blockSignals(True) + self.gfpgan_model_combo.clear() + if not paths: + self.gfpgan_model_combo.addItem("No downloaded GFPGAN models", "") + self.gfpgan_model_combo.setEnabled(False) + self.gfpgan_enabled.setEnabled(False) + self.gfpgan_model_combo.setToolTip("Download GFPGANv1.4.onnx from Models > Downloads first.") + self.gfpgan_enabled.setToolTip("GFPGAN is unavailable until a GFPGAN model is downloaded.") + else: + self.gfpgan_model_combo.setEnabled(True) + self.gfpgan_enabled.setEnabled(True) + self.gfpgan_model_combo.setToolTip("Only downloaded GFPGAN restore models are shown.") + self.gfpgan_enabled.setToolTip("Run GFPGAN face restoration after face swap.") + for path in paths: + label = f"{Path(path).parent.name}/{Path(path).name}" + self.gfpgan_model_combo.addItem(label, str(path)) + index = self.gfpgan_model_combo.findData(current) + if index >= 0: + self.gfpgan_model_combo.setCurrentIndex(index) + elif current and Path(current).exists(): + self.gfpgan_model_combo.addItem(Path(current).name, current) + self.gfpgan_model_combo.setCurrentIndex(self.gfpgan_model_combo.count() - 1) + self.gfpgan_model_combo.blockSignals(False) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/multiface_photo_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/multiface_photo_page.py new file mode 100644 index 0000000000000000000000000000000000000000..4d809e2aff43b2d1aa2185f5f860d79d15d84bd0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/multiface_photo_page.py @@ -0,0 +1,131 @@ +"""Multi-face photo recognition page.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import Qt +from PySide6.QtWidgets import QSplitter, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget + +from ..core.exporters import export_annotated_image, export_csv, export_json +from ..core.utils import read_image, save_image, timestamp_for_filename +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from ..widgets.upload_preview import UploadPreview +from .base import BasePage + + +class MultiFacePhotoPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Multi-face Photo Recognition", "Detect all faces in a group photo and match them against People Library.", parent) + self.image_path = "" + self.image = None + self.rows = [] + self.photo_input = UploadPreview( + "Photo", + extensions=[".jpg", ".jpeg", ".png", ".bmp", ".webp"], + dialog_filter="Images (*.jpg *.jpeg *.png *.bmp *.webp);;All Files (*)", + ) + self.photo_input.pathChanged.connect(lambda path: self.load_photo(path) if path else self.clear_photo()) + self.content.addWidget( + self.row( + self.button("Recognize Faces", self.recognize), + self.button("Export Annotated Image", self.export_image), + self.button("Export CSV / JSON", self.export_rows), + ) + ) + splitter = QSplitter(Qt.Horizontal) + left = QWidget() + left_layout = QVBoxLayout(left) + self.viewer = self.photo_input + left_layout.addWidget(self.viewer) + right = QWidget() + right_layout = QVBoxLayout(right) + self.table = QTableWidget(0, 6) + self.table.setHorizontalHeaderLabels(["face_index", "person_name", "similarity", "status", "bbox", "det_score"]) + configure_table_columns(self.table, [90, 180, 90, 110, 230, 90]) + right_layout.addWidget(self.table) + splitter.addWidget(left) + splitter.addWidget(right) + self.content.addWidget(splitter, 1) + + def load_photo(self, path: str) -> None: + self.image_path = path + self.image = read_image(path) + if self.image is None: + self.viewer.clear(emit=False) + self.show_error("Image read failure.") + return + self.viewer.set_image(self.image, path) + + def clear_photo(self) -> None: + self.image_path = "" + self.image = None + self.rows = [] + self.viewer.clear(emit=False) + self.table.setRowCount(0) + + def recognize(self) -> None: + if self.image is None: + self.show_error("Please select a photo.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + + def task(): + faces = self.context.engine.detect_faces(self.image, source_path=self.image_path) + gallery = self.context.storage.load_all_gallery_embeddings() + rows = [] + overlays = [] + media_id = self.context.storage.add_media_item(self.image_path, "image", width=self.image.shape[1], height=self.image.shape[0], processed_at=timestamp_for_filename()) + for index, face in enumerate(faces): + result = None + if face.normed_embedding is not None and gallery: + result_list = self.context.storage.search_embeddings(face.normed_embedding, self.context.config.default_top_k, self.context.config.recognition_threshold) + result = result_list[0] if result_list else None + name = result.person_name if result and result.similarity >= self.context.config.recognition_threshold else "Unknown" + similarity = result.similarity if result else 0.0 + status = "matched" if result and result.similarity >= self.context.config.recognition_threshold else "unknown" + crop_path = "" + if face.crop is not None: + crop_path = str(Path(self.context.config.crop_dir) / f"media_{media_id}_{index}_{timestamp_for_filename()}.png") + save_image(crop_path, face.crop) + self.context.storage.add_media_face(media_id, face.normed_embedding, crop_path=crop_path, bbox=face.bbox, kps=face.kps, det_score=face.det_score, predicted_person_id=result.person_id if result else None, similarity=similarity, status=status) + row = {"face_index": index, "person_name": name, "similarity": similarity, "status": status, "bbox": face.bbox, "det_score": face.det_score, "crop_path": crop_path} + rows.append(row) + overlays.append({"bbox": face.bbox, "label": name, "similarity": similarity}) + return rows, overlays + + def done(payload): + self.rows, overlays = payload + self.viewer.set_faces(overlays) + self.table.setRowCount(len(self.rows)) + columns = ["face_index", "person_name", "similarity", "status", "bbox", "det_score"] + for row_index, row in enumerate(self.rows): + for col, key in enumerate(columns): + value = row[key] + if isinstance(value, float): + value = f"{value:.4f}" + self.table.setItem(row_index, col, QTableWidgetItem(str(value))) + refresh_table_columns(self.table) + self.set_status(f"Recognized {len(self.rows)} face(s).") + + self.run_task("Recognizing photo", task, done) + + def export_image(self) -> None: + image = self.viewer.render_with_overlay() + if image is None: + self.show_error("No annotated image to export.") + return + path = Path(self.context.config.export_dir) / f"annotated_{timestamp_for_filename()}.png" + export_annotated_image(path, image) + self.set_status(f"Annotated image exported to {path}") + + def export_rows(self) -> None: + if not self.rows: + self.show_error("No recognition results to export.") + return + path = Path(self.context.config.export_dir) / f"multiface_{timestamp_for_filename()}.csv" + export_csv(path, self.rows) + export_json(path.with_suffix(".json"), self.rows) + self.set_status(f"Results exported to {path}") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/people_library_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/people_library_page.py new file mode 100644 index 0000000000000000000000000000000000000000..624a24bfd3a0ebf6b7038d876e70c77b8df56abc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/people_library_page.py @@ -0,0 +1,361 @@ +"""People library management page.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import QEvent, QSize, Qt, Signal +from PySide6.QtGui import QCursor, QIcon, QPixmap +from PySide6.QtWidgets import ( + QFileDialog, + QFrame, + QInputDialog, + QLabel, + QMenu, + QPushButton, + QSplitter, + QTableWidget, + QTableWidgetItem, + QTextEdit, + QVBoxLayout, + QWidget, +) + +from ..core.exporters import export_csv +from ..core.utils import list_images, read_image, save_image, timestamp_for_filename +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from .base import BasePage + + +IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".bmp", ".webp"} +IMAGE_FILTER = "Images (*.jpg *.jpeg *.png *.bmp *.webp);;All Files (*)" + + +class ImageOrFolderImportBox(QFrame): + pathsSelected = Signal(list) + + def __init__(self, parent=None): + super().__init__(parent) + self.setObjectName("imageOrFolderImport") + self.setAcceptDrops(True) + self.setMouseTracking(True) + self.setProperty("hoverActive", False) + self.setProperty("dragActive", False) + self.setProperty("hasFiles", False) + layout = QVBoxLayout(self) + title = QLabel("Import Image or Folder") + title.setAlignment(Qt.AlignCenter) + title.setStyleSheet("font-size:15px; font-weight:700;") + hint = QLabel("Click to import an image or folder, or drag one here. Folders are imported recursively.") + hint.setObjectName("dropPrompt") + hint.setAlignment(Qt.AlignCenter) + hint.setWordWrap(True) + self.button = QPushButton("Import Image or Folder") + self.button.clicked.connect(self._show_menu) + layout.addWidget(title) + layout.addWidget(hint) + layout.addWidget(self.button, 0, Qt.AlignHCenter) + for watched in (self, title, hint): + watched.installEventFilter(self) + + def _show_menu(self) -> None: + menu = QMenu(self) + menu.addAction("Select Image", self._select_image) + menu.addAction("Select Folder", self._select_folder) + menu.exec(self.button.mapToGlobal(self.button.rect().bottomLeft())) + + def _select_image(self) -> None: + path, _ = QFileDialog.getOpenFileName(self, "Select image", str(Path.home()), IMAGE_FILTER) + if path: + self.pathsSelected.emit([path]) + + def _select_folder(self) -> None: + folder = QFileDialog.getExistingDirectory(self, "Select image folder", str(Path.home())) + if folder: + self.pathsSelected.emit([str(path) for path in list_images(folder, recursive=True)]) + + def dragEnterEvent(self, event) -> None: # noqa: N802 + if event.mimeData().hasUrls() and self._accepted_urls(event.mimeData().urls()): + self._set_drag_active(True) + event.acceptProposedAction() + else: + event.ignore() + + def dragLeaveEvent(self, event) -> None: # noqa: N802 + self._set_drag_active(False) + super().dragLeaveEvent(event) + + def dropEvent(self, event) -> None: # noqa: N802 + self._set_drag_active(False) + paths: list[str] = [] + for url in event.mimeData().urls(): + if not url.isLocalFile(): + continue + path = Path(url.toLocalFile()) + if path.is_dir(): + paths.extend(str(item) for item in list_images(path, recursive=True)) + elif path.suffix.lower() in IMAGE_EXTENSIONS: + paths.append(str(path)) + if paths: + self.pathsSelected.emit(paths) + event.acceptProposedAction() + else: + event.ignore() + + def _accepted_urls(self, urls) -> bool: + for url in urls: + if not url.isLocalFile(): + continue + path = Path(url.toLocalFile()) + if path.is_dir() or path.suffix.lower() in IMAGE_EXTENSIONS: + return True + return False + + def _set_drag_active(self, value: bool) -> None: + self._set_property("dragActive", value) + + def eventFilter(self, watched, event) -> bool: # noqa: N802 + if event.type() == QEvent.Enter: + self._set_property("hoverActive", True) + return False + if event.type() == QEvent.Leave: + self._update_hover_from_cursor() + return False + if event.type() == QEvent.MouseButtonRelease and event.button() == Qt.LeftButton: + self._show_menu() + return True + return super().eventFilter(watched, event) + + def enterEvent(self, event) -> None: # noqa: N802 + self._set_property("hoverActive", True) + super().enterEvent(event) + + def leaveEvent(self, event) -> None: # noqa: N802 + self._update_hover_from_cursor() + super().leaveEvent(event) + + def _set_property(self, name: str, value) -> None: + self.setProperty(name, value) + self.style().unpolish(self) + self.style().polish(self) + + def _update_hover_from_cursor(self) -> None: + inside = self.rect().contains(self.mapFromGlobal(QCursor.pos())) + self._set_property("hoverActive", inside) + + +class PeopleLibraryPage(BasePage): + def __init__(self, context, parent=None): + super().__init__( + context, + "People Library", + "Build the local gallery used by 1:N Face Search. Imported images create people named from the file name by default.", + parent, + ) + self.selected_person_id = None + self.people = [] + splitter = QSplitter(Qt.Horizontal) + + left = QWidget() + left_layout = QVBoxLayout(left) + self.import_box = ImageOrFolderImportBox() + self.import_box.pathsSelected.connect(self.import_paths) + left_layout.addWidget(self.import_box) + left_layout.addWidget(QLabel("People")) + self.people_table = QTableWidget(0, 3) + self.people_table.setHorizontalHeaderLabels(["ID", "Thumbnail", "Name"]) + self.people_table.setIconSize(QSize(48, 48)) + configure_table_columns(self.people_table, [60, 90, 240]) + self.people_table.currentCellChanged.connect(self.on_person_selected) + left_layout.addWidget(self.people_table, 1) + left_layout.addWidget(self.row(self.button("Add Person", self.add_person), self.button("Delete", self.delete_person), self.button("Export Summary", self.export_summary))) + + right = QWidget() + right_layout = QVBoxLayout(right) + self.details = QTextEdit() + self.details.setPlaceholderText("Name, notes, and tags are shown here.") + right_layout.addWidget(self.details) + right_layout.addWidget(self.row(self.button("Save Details", self.save_details))) + self.samples_table = QTableWidget(0, 7) + self.samples_table.setHorizontalHeaderLabels(["id", "crop_path", "det_score", "quality_score", "model_name", "provider", "source_image_path"]) + configure_table_columns(self.samples_table, [60, 260, 90, 100, 130, 110, 320]) + right_layout.addWidget(self.samples_table) + + splitter.addWidget(left) + splitter.addWidget(right) + splitter.setStretchFactor(0, 2) + splitter.setStretchFactor(1, 3) + self.content.addWidget(splitter, 1) + self.refresh() + + def refresh(self) -> None: + current_id = self.selected_person_id + self.people = self.context.storage.list_people() + self.people_table.setRowCount(len(self.people)) + for row, person in enumerate(self.people): + id_item = QTableWidgetItem(str(person["id"])) + id_item.setData(Qt.UserRole, person["id"]) + thumb_item = QTableWidgetItem() + icon = self._thumbnail_icon(person.get("cover_crop_path")) + if icon is not None: + thumb_item.setIcon(icon) + name_item = QTableWidgetItem(person["display_name"] or person["name"]) + name_item.setData(Qt.UserRole, person["id"]) + self.people_table.setItem(row, 0, id_item) + self.people_table.setItem(row, 1, thumb_item) + self.people_table.setItem(row, 2, name_item) + self.people_table.setRowHeight(row, 54) + if current_id == person["id"]: + self.people_table.selectRow(row) + refresh_table_columns(self.people_table) + if current_id and any(person["id"] == current_id for person in self.people): + self.selected_person_id = current_id + elif self.people: + self.people_table.selectRow(0) + self.selected_person_id = self.people[0]["id"] + else: + self.selected_person_id = None + self._populate_details() + self.refresh_samples() + + def on_person_selected(self, current_row: int, current_column: int, previous_row: int, previous_column: int) -> None: + del current_column, previous_row, previous_column + if current_row < 0 or current_row >= len(self.people): + self.selected_person_id = None + else: + self.selected_person_id = int(self.people[current_row]["id"]) + self._populate_details() + self.refresh_samples() + + def _populate_details(self) -> None: + person = next((row for row in self.people if row["id"] == self.selected_person_id), None) + if not person: + self.details.clear() + return + self.details.setPlainText( + "\n".join( + [ + f"name: {person['name']}", + f"display_name: {person['display_name'] or ''}", + f"tags: {person['tags'] or ''}", + "notes:", + person["notes"] or "", + ] + ) + ) + + def add_person(self) -> None: + name, ok = QInputDialog.getText(self, "Add Person", "Person name") + if ok and name.strip(): + self.context.storage.add_person(name.strip()) + self.refresh() + + def delete_person(self) -> None: + if self.selected_person_id is None: + self.show_error("Select a person first.") + return + self.context.storage.delete_person(int(self.selected_person_id), delete_samples=False) + self.selected_person_id = None + self.refresh() + + def save_details(self) -> None: + if self.selected_person_id is None: + self.show_error("Select a person first.") + return + fields = {} + lines = self.details.toPlainText().splitlines() + notes_start = None + for idx, line in enumerate(lines): + if line.startswith("name:"): + fields["name"] = line.split(":", 1)[1].strip() + elif line.startswith("display_name:"): + fields["display_name"] = line.split(":", 1)[1].strip() + elif line.startswith("tags:"): + fields["tags"] = line.split(":", 1)[1].strip() + elif line.strip() == "notes:": + notes_start = idx + 1 + if notes_start is not None: + fields["notes"] = "\n".join(lines[notes_start:]).strip() + self.context.storage.update_person(int(self.selected_person_id), **fields) + self.refresh() + self.set_status("Person details saved.") + + def import_paths(self, paths: list[str]) -> None: + paths = [str(Path(path)) for path in paths if Path(path).suffix.lower() in IMAGE_EXTENSIONS] + if not paths: + self.show_error("No supported images found.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + + def task(progress=None, is_cancelled=None): + imported = 0 + skipped = 0 + for index, path in enumerate(paths): + if is_cancelled and is_cancelled(): + break + image = read_image(path) + if image is None: + skipped += 1 + if progress: + progress(index + 1, len(paths), f"Skipped unreadable image: {Path(path).name}") + continue + face = self.context.engine.detect_best_face(image, source_path=path) + if face is None or face.normed_embedding is None: + skipped += 1 + if progress: + progress(index + 1, len(paths), f"No usable face: {Path(path).name}") + continue + person_id = self.context.storage.add_person(Path(path).stem) + crop_path = Path(self.context.config.crop_dir) / f"person_{person_id}_{timestamp_for_filename()}_{index}.png" + if face.crop is not None: + save_image(crop_path, face.crop) + self.context.storage.add_face_sample( + person_id, + face.normed_embedding, + source_image_path=path, + crop_path=str(crop_path), + bbox=face.bbox, + kps=face.kps, + det_score=face.det_score, + quality_score=face.quality_score, + model_name=self.context.config.model_name, + provider=self.context.config.provider, + ) + imported += 1 + if progress: + progress(index + 1, len(paths), f"Imported {imported} people, skipped {skipped}") + return {"imported": imported, "skipped": skipped} + + def done(result): + self.refresh() + self.set_status(f"Imported {result['imported']} people. Skipped {result['skipped']} image(s).") + + self.run_task("Importing People Library", task, done) + + def refresh_samples(self) -> None: + if self.selected_person_id is None: + self.samples_table.setRowCount(0) + return + samples = self.context.storage.list_face_samples(self.selected_person_id) + self.samples_table.setRowCount(len(samples)) + columns = ["id", "crop_path", "det_score", "quality_score", "model_name", "provider", "source_image_path"] + for row, sample in enumerate(samples): + for col, key in enumerate(columns): + self.samples_table.setItem(row, col, QTableWidgetItem(str(sample.get(key, "")))) + refresh_table_columns(self.samples_table) + + def export_summary(self) -> None: + path = Path(self.context.config.export_dir) / f"people_summary_{timestamp_for_filename()}.csv" + export_csv(path, self.context.storage.list_people()) + self.set_status(f"People summary exported to {path}") + + @staticmethod + def _thumbnail_icon(path: str | None) -> QIcon | None: + if not path: + return None + pixmap = QPixmap(str(Path(path))) + if pixmap.isNull(): + return None + return QIcon(pixmap.scaled(48, 48, Qt.KeepAspectRatio, Qt.SmoothTransformation)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/placeholder_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/placeholder_page.py new file mode 100644 index 0000000000000000000000000000000000000000..e825c95f82cb38f303b89fdb560ee0d1f070ae82 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/placeholder_page.py @@ -0,0 +1,73 @@ +"""Reusable placeholder and commercial next-steps pages.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QLabel, QPushButton + +from ..core.tooltips import set_button_tooltip +from .base import BasePage + + +class PlaceholderPage(BasePage): + def __init__( + self, + context, + title: str, + description: str, + coming_soon_text: str = "Coming soon.", + ctas: list[tuple[str, str]] | None = None, + parent=None, + ): + super().__init__(context, title, description, parent) + status = QLabel(coming_soon_text) + status.setWordWrap(True) + status.setProperty("role", "muted") + status.setStyleSheet("font-size: 16px; font-weight: 600; padding:12px 0;") + self.content.addWidget(status) + if ctas: + buttons = [] + for label, page_key in ctas: + button = QPushButton(label) + button.clicked.connect(lambda checked=False, target=page_key: self.window().open_page(target)) + set_button_tooltip(button) + buttons.append(button) + self.content.addWidget(self.row(*buttons)) + self.content.addStretch(1) + + +class CommercialNextStepsPage(BasePage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Commercial Next Steps", + "Understand the business paths after local enterprise evaluation.", + parent, + ) + self.content.addWidget( + self.notice( + "Production or commercial deployment requires an appropriate commercial model license. " + "This page summarizes common commercial paths; it does not provide legal advice." + ) + ) + summary = QLabel( + "\n".join( + [ + "Commercial model license: authorize production use of approved model files.", + "Private model evaluation: validate models on your local business data before purchase.", + "SDK / API access: integrate InsightFace capabilities into internal products or services.", + "SLA and enterprise support: align support expectations for production deployment.", + "Custom training: evaluate private data requirements, consent, retention, and compliance before any training workflow.", + ] + ) + ) + summary.setWordWrap(True) + summary.setStyleSheet("line-height: 1.35;") + self.content.addWidget(summary) + self.content.addWidget( + self.row( + self.button("Open License Center", lambda: self.window().open_license_dialog()), + self.button("Run Evaluation", lambda: self.window().open_page("enterprise_evaluation")), + self.button("Open Reports", lambda: self.window().open_page("reports")), + ) + ) + self.content.addStretch(1) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/reports_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/reports_page.py new file mode 100644 index 0000000000000000000000000000000000000000..f1fa66a60e76bc09946aae761546b101f1313138 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/reports_page.py @@ -0,0 +1,77 @@ +"""Reports page.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import QUrl +from PySide6.QtGui import QDesktopServices +from PySide6.QtWidgets import QTableWidget, QTableWidgetItem + +from ..core.exporters import export_csv +from ..core.models import EvaluationResult +from ..core.reporting import write_reports +from ..core.utils import timestamp_for_filename, utc_now_iso +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from .base import BasePage + + +class ReportsPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Reports", "Browse and export historical enterprise evaluation runs.", parent) + self.runs = [] + self.content.addWidget(self.row(self.button("Refresh", self.refresh), self.button("Open Selected Report", self.open_selected), self.button("Re-export Selected", self.reexport_selected), self.button("Delete Selected", self.delete_selected), self.button("Export All Summary", self.export_summary))) + self.table = QTableWidget(0, 7) + self.table.setHorizontalHeaderLabels(["id", "date", "scenario", "model", "provider", "threshold", "report_path"]) + configure_table_columns(self.table, [60, 180, 180, 130, 110, 90, 360]) + self.content.addWidget(self.table, 1) + self.refresh() + + def refresh(self) -> None: + self.runs = self.context.storage.list_evaluation_runs() + self.table.setRowCount(len(self.runs)) + for row_index, run in enumerate(self.runs): + values = [run["id"], run["created_at"], run["scenario"], run["model_name"], run["provider"], run["threshold"], run["report_path"]] + for col, value in enumerate(values): + self.table.setItem(row_index, col, QTableWidgetItem(str(value))) + refresh_table_columns(self.table) + + def _selected_run(self): + row = self.table.currentRow() + if row < 0 or row >= len(self.runs): + self.show_error("Select a report row first.") + return None + return self.runs[row] + + def open_selected(self) -> None: + run = self._selected_run() + if not run: + return + path = run.get("report_path") or "" + if not path: + self.show_error("This run has no report path.") + return + QDesktopServices.openUrl(QUrl.fromLocalFile(path)) + + def reexport_selected(self) -> None: + run = self._selected_run() + if not run: + return + result = EvaluationResult(scenario=run["scenario"], model_name=run["model_name"], provider=run["provider"], threshold=float(run["threshold"]), dataset_summary=run.get("dataset_summary", {}), metrics=run.get("metrics", {}), errors=[], latency=run.get("hardware", {}), license_status=self.context.config.license_status, created_at=run.get("created_at") or utc_now_iso()) + paths = write_reports(result, self.context.config.report_dir, language=self.context.config.ui_language) + report_path = paths.get("pdf") or paths["markdown"] + self.context.storage.save_evaluation_run(result.scenario, result.model_name, result.provider, result.threshold, result.dataset_summary, result.metrics, result.latency, report_path, result.created_at) + self.refresh() + self.set_status(f"Report re-exported to {report_path}") + + def delete_selected(self) -> None: + run = self._selected_run() + if not run: + return + self.context.storage.delete_evaluation_run(int(run["id"])) + self.refresh() + + def export_summary(self) -> None: + path = Path(self.context.config.export_dir) / f"evaluation_summary_{timestamp_for_filename()}.csv" + export_csv(path, self.runs) + self.set_status(f"Evaluation summary exported to {path}") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/settings_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/settings_page.py new file mode 100644 index 0000000000000000000000000000000000000000..213c06b4162179fe5bc9efe6a6470be94460ffc4 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/settings_page.py @@ -0,0 +1,113 @@ +"""Application settings page.""" + +from __future__ import annotations + +import json +from pathlib import Path + +from PySide6.QtCore import QUrl +from PySide6.QtGui import QDesktopServices +from PySide6.QtWidgets import QCheckBox, QComboBox, QDoubleSpinBox, QFormLayout, QLineEdit, QSpinBox + +from ..core.config import AppConfig, save_config +from ..core.paths import ensure_workspace +from ..core.theme import THEME_OPTIONS, normalize_theme +from .base import BasePage + + +class SettingsPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Settings", "Configure workspace, database, export paths, privacy defaults, and UI preferences.", parent) + cfg = context.config + self.workspace = QLineEdit(cfg.workspace_path) + self.database = QLineEdit(cfg.database_path) + self.crops = QLineEdit(cfg.crop_dir) + self.reports = QLineEdit(cfg.report_dir) + self.exports = QLineEdit(cfg.export_dir) + self.cache = QLineEdit(cfg.cache_dir) + self.threshold = QDoubleSpinBox() + self.threshold.setRange(0, 1) + self.threshold.setSingleStep(0.01) + self.threshold.setValue(cfg.recognition_threshold) + self.top_k = QSpinBox() + self.top_k.setRange(1, 100) + self.top_k.setValue(cfg.default_top_k) + self.min_det = QDoubleSpinBox() + self.min_det.setRange(0, 1) + self.min_det.setSingleStep(0.01) + self.min_det.setValue(cfg.min_detection_score) + self.min_face = QSpinBox() + self.min_face.setRange(1, 4096) + self.min_face.setValue(cfg.min_face_size) + self.save_crops = QCheckBox("Save crops") + self.save_crops.setChecked(cfg.save_crops) + self.save_logs = QCheckBox("Save recognition logs") + self.save_logs.setChecked(cfg.save_recognition_logs) + self.anonymize = QCheckBox("Anonymize report paths") + self.anonymize.setChecked(cfg.anonymize_report_paths) + self.theme = QComboBox() + for option in THEME_OPTIONS: + self.theme.addItem(option.label, option.value) + self.theme.setCurrentIndex(max(0, self.theme.findData(normalize_theme(cfg.ui_theme)))) + form = QFormLayout() + for label, widget in [ + ("Workspace path", self.workspace), + ("Database path", self.database), + ("Crop output directory", self.crops), + ("Report output directory", self.reports), + ("Export output directory", self.exports), + ("Cache directory", self.cache), + ("Default recognition threshold", self.threshold), + ("Default Top-K", self.top_k), + ("Minimum detection score", self.min_det), + ("Minimum face size", self.min_face), + ("UI theme", self.theme), + ]: + form.addRow(label, widget) + form.addRow("Privacy", self.row(self.save_crops, self.save_logs, self.anonymize)) + self.content.addLayout(form) + self.content.addWidget(self.row(self.button("Save Settings", self.save), self.button("Open Workspace Folder", self.open_workspace), self.button("Export Settings", self.export_settings), self.button("Import Settings", self.import_settings), self.button("Reset Settings", self.reset))) + + def save(self) -> None: + cfg = self.context.config + cfg.workspace_path = self.workspace.text().strip() + paths = ensure_workspace(cfg.workspace_path) + cfg.database_path = self.database.text().strip() or str(paths["database"]) + cfg.crop_dir = self.crops.text().strip() or str(paths["crops"]) + cfg.report_dir = self.reports.text().strip() or str(paths["reports"]) + cfg.export_dir = self.exports.text().strip() or str(paths["exports"]) + cfg.cache_dir = self.cache.text().strip() or str(paths["cache"]) + cfg.recognition_threshold = float(self.threshold.value()) + cfg.default_top_k = int(self.top_k.value()) + cfg.min_detection_score = float(self.min_det.value()) + cfg.min_face_size = int(self.min_face.value()) + cfg.save_crops = self.save_crops.isChecked() + cfg.save_recognition_logs = self.save_logs.isChecked() + cfg.anonymize_report_paths = self.anonymize.isChecked() + cfg.ui_theme = self.theme.currentData() + save_config(cfg) + self.set_status("Settings saved.") + + def open_workspace(self) -> None: + QDesktopServices.openUrl(QUrl.fromLocalFile(self.workspace.text().strip())) + + def export_settings(self) -> None: + path = self.save_file("Export settings", str(Path(self.context.config.export_dir) / "insightface_gui_settings.json"), "JSON (*.json)") + if not path: + return + Path(path).write_text(json.dumps(self.context.config.to_dict(), indent=2), encoding="utf-8") + self.set_status(f"Settings exported to {path}") + + def import_settings(self) -> None: + path = self.choose_file("Import settings", "JSON (*.json)") + if not path: + return + data = json.loads(Path(path).read_text(encoding="utf-8")) + self.context.config = AppConfig.from_dict(data) + save_config(self.context.config) + self.set_status("Settings imported. Restart recommended.") + + def reset(self) -> None: + self.context.config = AppConfig() + save_config(self.context.config) + self.set_status("Settings reset to defaults. Restart recommended.") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/verification_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/verification_page.py new file mode 100644 index 0000000000000000000000000000000000000000..d8a0817a06fa62dc20e9b2fa107a713b11fbfc9e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/verification_page.py @@ -0,0 +1,696 @@ +"""Combined Query and Gallery verification workflow.""" + +from __future__ import annotations + +from pathlib import Path + +import numpy as np +from PySide6.QtCore import QDir, QEvent, QSize, Qt, QUrl, Signal +from PySide6.QtGui import QCursor, QDesktopServices, QIcon, QPixmap +from PySide6.QtWidgets import ( + QComboBox, + QDoubleSpinBox, + QFrame, + QHBoxLayout, + QLabel, + QListWidget, + QListWidgetItem, + QSizePolicy, + QAbstractItemView, + QDialog, + QDialogButtonBox, + QFileSystemModel, + QPushButton, + QSplitter, + QTableWidget, + QTableWidgetItem, + QTreeView, + QVBoxLayout, + QWidget, +) + +from ..core.config import save_config +from ..core.constants import DEFAULT_THRESHOLD, IMAGE_EXTENSIONS +from ..core.evaluation import ( + MULTI_FACE_REQUIRE_ONE, + MULTI_FACE_SKIP, + MULTI_FACE_USE_CENTERED_LARGEST, + MULTI_FACE_USE_LARGEST, + multi_face_policy_help, + select_face_by_policy, +) +from ..core.i18n import apply_translations, tr +from ..core.recognition import compare_embeddings +from ..core.tooltips import apply_button_tooltips, set_button_tooltip +from ..core.utils import list_images, read_image +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from ..widgets.upload_preview import UploadPreview +from .base import BasePage + + +class GalleryUploadPanel(QFrame): + """Clickable and draggable gallery input for image files or folders.""" + + pathsChanged = Signal(object) + + def __init__(self, parent=None): + super().__init__(parent) + self._paths: list[str] = [] + self.setObjectName("galleryUpload") + self.setAcceptDrops(True) + self.setMouseTracking(True) + self.setMinimumHeight(300) + self.setProperty("hoverActive", False) + self.setProperty("dragActive", False) + self.setProperty("hasFiles", False) + + layout = QVBoxLayout(self) + layout.setContentsMargins(10, 10, 10, 10) + header = QHBoxLayout() + title = QLabel("Gallery") + title.setStyleSheet("font-size:15px; font-weight:700;") + self.count_label = QLabel("No images") + self.count_label.setProperty("role", "muted") + self.remove_button = QPushButton("Remove Selected") + self.remove_button.clicked.connect(self.remove_selected) + self.clear_button = QPushButton("Clear") + self.clear_button.clicked.connect(self.clear) + set_button_tooltip(self.remove_button) + set_button_tooltip(self.clear_button) + header.addWidget(title) + header.addWidget(self.count_label) + header.addStretch(1) + header.addWidget(self.remove_button) + header.addWidget(self.clear_button) + layout.addLayout(header) + + self.prompt = QLabel("Click to upload images or a folder, or drag them here") + self.prompt.setObjectName("uploadPrompt") + self.prompt.setAlignment(Qt.AlignCenter) + self.prompt.setWordWrap(True) + self.prompt.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + layout.addWidget(self.prompt, 1) + + self.single_preview = QLabel() + self.single_preview.setAlignment(Qt.AlignCenter) + self.single_preview.setMinimumHeight(180) + self.single_preview.setStyleSheet("border:0; background:transparent;") + self.single_preview.hide() + self.single_hint = QLabel("") + self.single_hint.setObjectName("pathLabel") + self.single_hint.setAlignment(Qt.AlignCenter) + self.single_hint.setWordWrap(True) + self.single_hint.hide() + layout.addWidget(self.single_preview, 1) + layout.addWidget(self.single_hint) + + self.list_widget = QListWidget() + self.list_widget.setIconSize(QSize(56, 56)) + self.list_widget.itemDoubleClicked.connect(self.open_item) + layout.addWidget(self.list_widget, 1) + self.list_widget.hide() + self.remove_button.hide() + self.clear_button.hide() + + for watched in (self, self.prompt, self.single_preview, self.single_hint, self.list_widget, self.list_widget.viewport()): + watched.installEventFilter(self) + + def paths(self) -> list[str]: + return list(self._paths) + + def set_paths(self, paths: list[str], emit: bool = True) -> None: + resolved = self._expand_paths(paths) + self._paths = resolved + self._render() + if emit: + self.pathsChanged.emit(self.paths()) + + def add_paths(self, paths: list[str]) -> None: + self.set_paths(self._paths + paths) + + def clear(self) -> None: + self.set_paths([]) + + def remove_selected(self) -> None: + remove = {item.data(Qt.UserRole) for item in self.list_widget.selectedItems()} + if not remove: + return + self.set_paths([path for path in self._paths if path not in remove]) + + def browse(self) -> None: + dialog = QDialog(self) + dialog.setWindowTitle("Select gallery images or folders") + dialog.resize(760, 520) + layout = QVBoxLayout(dialog) + hint = QLabel("Select one or more image files or folders. Folders are scanned recursively.") + hint.setWordWrap(True) + layout.addWidget(hint) + model = QFileSystemModel(dialog) + model.setRootPath(str(Path.home())) + model.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot | QDir.Readable) + model.setNameFilters(["*.jpg", "*.jpeg", "*.png", "*.bmp", "*.webp"]) + model.setNameFilterDisables(False) + tree = QTreeView(dialog) + tree.setModel(model) + tree.setRootIndex(model.index(str(Path.home()))) + tree.setSelectionMode(QAbstractItemView.ExtendedSelection) + tree.setColumnWidth(0, 320) + tree.doubleClicked.connect(lambda index: tree.setRootIndex(index) if model.isDir(index) else None) + layout.addWidget(tree, 1) + buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) + buttons.accepted.connect(dialog.accept) + buttons.rejected.connect(dialog.reject) + layout.addWidget(buttons) + apply_button_tooltips(dialog) + apply_translations(dialog, self._language()) + if dialog.exec() == QDialog.Accepted: + indexes = tree.selectionModel().selectedRows(0) + paths = [model.filePath(index) for index in indexes] + if paths: + self.add_paths(paths) + + def eventFilter(self, watched, event) -> bool: # noqa: N802 + if event.type() in (QEvent.DragEnter, QEvent.DragMove): + if event.mimeData().hasUrls() and self._accepted_urls(event.mimeData().urls()): + self._set_property("dragActive", True) + event.acceptProposedAction() + return True + event.ignore() + return True + if event.type() == QEvent.DragLeave: + self._set_property("dragActive", False) + return False + if event.type() == QEvent.Drop: + self._set_property("dragActive", False) + paths = [url.toLocalFile() for url in event.mimeData().urls() if url.isLocalFile()] + expanded = self._expand_paths(paths) + if expanded: + self.add_paths(expanded) + event.acceptProposedAction() + return True + event.ignore() + return True + if event.type() == QEvent.Enter: + self._set_property("hoverActive", True) + return False + if event.type() == QEvent.Leave: + self._update_hover_from_cursor() + return False + if event.type() == QEvent.MouseButtonRelease and event.button() == Qt.LeftButton and watched in {self.prompt, self.single_preview, self.single_hint}: + self.browse() + return True + return super().eventFilter(watched, event) + + def mouseReleaseEvent(self, event) -> None: # noqa: N802 + if event.button() == Qt.LeftButton and not self._paths: + self.browse() + event.accept() + return + super().mouseReleaseEvent(event) + + def enterEvent(self, event) -> None: # noqa: N802 + self._set_property("hoverActive", True) + super().enterEvent(event) + + def leaveEvent(self, event) -> None: # noqa: N802 + self._update_hover_from_cursor() + super().leaveEvent(event) + + def open_item(self, item: QListWidgetItem) -> None: + path = item.data(Qt.UserRole) + if path: + QDesktopServices.openUrl(QUrl.fromLocalFile(str(path))) + + def _render(self) -> None: + self.list_widget.clear() + self.single_preview.clear() + for path in self._paths: + item = QListWidgetItem(Path(path).name) + icon = self._icon(path, QSize(56, 56)) + if icon is not None: + item.setIcon(icon) + item.setToolTip(path) + item.setData(Qt.UserRole, path) + self.list_widget.addItem(item) + has_files = bool(self._paths) + single = len(self._paths) == 1 + self.prompt.setVisible(not has_files) + self.single_preview.setVisible(single) + self.single_hint.setVisible(single) + self.list_widget.setVisible(has_files and not single) + self.remove_button.setVisible(has_files and not single) + self.clear_button.setVisible(has_files) + count = len(self._paths) + language = self._language() + if count: + image_label = "image" if count == 1 else "images" + self.count_label.setText(f"{count} {tr(image_label, language)}") + else: + self.count_label.setText(tr("No images", language)) + if single: + self._update_single_preview() + self._set_property("hasFiles", has_files) + + def resizeEvent(self, event) -> None: # noqa: N802 + super().resizeEvent(event) + if len(self._paths) == 1: + self._update_single_preview() + + def _expand_paths(self, paths: list[str]) -> list[str]: + collected: list[str] = [] + seen = set() + for raw_path in paths: + path = Path(raw_path).expanduser() + candidates: list[Path] + if path.is_dir(): + candidates = list_images(path, recursive=True) + elif path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS: + candidates = [path] + else: + candidates = [] + for candidate in candidates: + value = str(candidate) + if value not in seen and value not in collected: + collected.append(value) + seen.add(value) + return collected + + def _accepted_urls(self, urls) -> bool: + for url in urls: + if not url.isLocalFile(): + continue + path = Path(url.toLocalFile()).expanduser() + if path.is_dir() or (path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS): + return True + return False + + def _set_property(self, name: str, value) -> None: + self.setProperty(name, value) + self.style().unpolish(self) + self.style().polish(self) + + def _update_hover_from_cursor(self) -> None: + inside = self.rect().contains(self.mapFromGlobal(QCursor.pos())) + self._set_property("hoverActive", inside) + + @staticmethod + def _icon(path: str | None, size: QSize) -> QIcon | None: + if not path: + return None + pixmap = QPixmap(str(Path(path))) + if pixmap.isNull(): + return None + return QIcon(pixmap.scaled(size, Qt.KeepAspectRatio, Qt.SmoothTransformation)) + + def _update_single_preview(self) -> None: + if len(self._paths) != 1: + return + path = self._paths[0] + pixmap = QPixmap(str(Path(path))) + if pixmap.isNull(): + self.single_preview.setText(Path(path).name) + else: + size = self.single_preview.size() + target = QSize(max(180, size.width() - 24), max(150, size.height() - 12)) + self.single_preview.setPixmap(pixmap.scaled(target, Qt.KeepAspectRatio, Qt.SmoothTransformation)) + self.single_hint.setText( + f"{Path(path).name}\n{tr('Click or drag more images or folders to add to Gallery.', self._language())}" + ) + + def _language(self) -> str | None: + context = getattr(self.window(), "context", None) + config = getattr(context, "config", None) + return getattr(config, "ui_language", None) + + +class VerificationPage(BasePage): + def __init__(self, context, parent=None): + super().__init__( + context, + "Face Recognition", + "Upload one query image and a gallery image, image set, or folder. One gallery image runs 1:1 compare; multiple gallery images run 1:N gallery search.", + parent, + ) + self.query_path = "" + self.query_image: np.ndarray | None = None + self.gallery_paths: list[str] = [] + self._gallery_embedding_cache_key: tuple[str, ...] | None = None + self._gallery_embedding_cache: list[dict] | None = None + self.results: list[dict] = [] + if abs(float(context.config.recognition_threshold) - DEFAULT_THRESHOLD) > 1e-9: + context.config.recognition_threshold = DEFAULT_THRESHOLD + save_config(context.config) + + self.workflow_notice = self.notice("") + self.content.addWidget(self.workflow_notice) + splitter = QSplitter(Qt.Horizontal) + left = QWidget() + left_layout = QVBoxLayout(left) + left_layout.setContentsMargins(0, 0, 0, 0) + self.query_input = UploadPreview( + "Query", + extensions=[".jpg", ".jpeg", ".png", ".bmp", ".webp"], + dialog_filter="Images (*.jpg *.jpeg *.png *.bmp *.webp);;All Files (*)", + ) + self.query_input.pathChanged.connect(lambda path: self.load_query(path) if path else self.clear_query()) + left_layout.addWidget(self.query_input) + splitter.addWidget(left) + + right = QWidget() + right_layout = QVBoxLayout(right) + right_layout.setContentsMargins(0, 0, 0, 0) + self.gallery_input = GalleryUploadPanel() + self.gallery_input.pathsChanged.connect(self.set_gallery_paths) + right_layout.addWidget(self.gallery_input) + splitter.addWidget(right) + splitter.setStretchFactor(0, 1) + splitter.setStretchFactor(1, 1) + self.content.addWidget(splitter, 1) + + control_row = QHBoxLayout() + self.threshold = QDoubleSpinBox() + self.threshold.setRange(0.01, 0.99) + self.threshold.setSingleStep(0.01) + self.threshold.setDecimals(2) + self.threshold.setValue(DEFAULT_THRESHOLD) + self.threshold.setToolTip("Similarity threshold for matching query and gallery faces.") + self.multi_face_policy = QComboBox() + self.multi_face_policy.setProperty("i18nItems", True) + self.multi_face_policy.addItem("Require exactly one face", MULTI_FACE_REQUIRE_ONE) + self.multi_face_policy.addItem("Use largest face", MULTI_FACE_USE_LARGEST) + self.multi_face_policy.addItem("Use largest centered face", MULTI_FACE_USE_CENTERED_LARGEST) + self.multi_face_policy.addItem("Mark as skip", MULTI_FACE_SKIP) + self.multi_face_policy.setObjectName("verificationMultiFacePolicy") + self.multi_face_policy.setToolTip("Choose how query and gallery images handle multiple detected faces.") + default_policy_index = self.multi_face_policy.findData(MULTI_FACE_USE_CENTERED_LARGEST) + if default_policy_index >= 0: + self.multi_face_policy.setCurrentIndex(default_policy_index) + self.multi_face_policy.currentIndexChanged.connect(self._multi_face_policy_changed) + self.run_button = QPushButton("Run Recognition") + self.run_button.clicked.connect(self.run_verification) + self.clear_button = QPushButton("Clear") + self.clear_button.clicked.connect(self.clear_all) + set_button_tooltip(self.run_button) + set_button_tooltip(self.clear_button) + control_row.addWidget(QLabel("Recognition threshold")) + control_row.addWidget(self.threshold) + control_row.addWidget(QLabel("Multi-face handling")) + control_row.addWidget(self.multi_face_policy) + control_row.addStretch(1) + control_row.addWidget(self.run_button) + control_row.addWidget(self.clear_button) + self.content.addLayout(control_row) + + self.result_table = QTableWidget(0, 7) + self.result_table.setIconSize(QSize(56, 56)) + self.result_table.setSelectionBehavior(QAbstractItemView.SelectRows) + self.result_table.setSelectionMode(QAbstractItemView.SingleSelection) + self.result_table.setEditTriggers(QAbstractItemView.NoEditTriggers) + self.result_table.setHorizontalHeaderLabels( + ["rank", "thumbnail", "gallery_file", "similarity", "threshold", "decision", "det_score"] + ) + configure_table_columns(self.result_table, [56, 86, 320, 92, 92, 130, 92]) + self.result_table.cellDoubleClicked.connect(self.open_result) + self.content.addWidget(self.result_table, 1) + self._update_policy_notice() + + def load_query(self, path: str) -> None: + image = read_image(path) + if image is None: + self.query_input.clear(emit=False) + self.show_error("Image read failure.") + return + self.query_path = path + self.query_image = image + self.query_input.set_image(image, path) + self._update_mode_label() + + def clear_query(self) -> None: + self.query_path = "" + self.query_image = None + self.query_input.clear(emit=False) + self.query_input.set_faces([]) + self._update_mode_label() + + def set_gallery_paths(self, paths: list[str]) -> None: + new_paths = list(paths) + if tuple(new_paths) != tuple(self.gallery_paths): + self._clear_gallery_embedding_cache() + self.gallery_paths = new_paths + self.results = [] + self.result_table.setRowCount(0) + self._update_mode_label() + + def clear_all(self) -> None: + self.clear_query() + self.gallery_input.clear() + self.results = [] + self.result_table.setRowCount(0) + self.set_status("Cleared.") + + def run_verification(self) -> None: + if self.query_image is None or not self.query_path: + self.show_error("Please upload a query image.") + return + if not self.gallery_paths: + self.show_error("Please upload one or more gallery images or folders.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + + query_image = self.query_image.copy() + query_path = self.query_path + gallery_paths = list(self.gallery_paths) + multi_face_policy = self._multi_face_policy() + gallery_key = (multi_face_policy, *gallery_paths) + cached_gallery = ( + list(self._gallery_embedding_cache) + if self._gallery_embedding_cache_key == gallery_key and self._gallery_embedding_cache is not None + else None + ) + threshold = self.threshold.value() + + def task(progress=None, is_cancelled=None): + query_faces = self.context.engine.detect_faces(query_image, source_path=query_path) + query_face = select_face_by_policy( + query_faces, + query_image.shape, + multi_face_policy, + path=query_path, + stage="query", + ) + if query_face is None or query_face.normed_embedding is None: + raise ValueError("No face detected in the query image or embedding unavailable.") + if cached_gallery is not None: + gallery_cache = cached_gallery + if progress: + progress(1, 1, "Using cached gallery embeddings") + else: + gallery_cache = self._build_gallery_embedding_cache( + gallery_paths, + multi_face_policy, + progress, + is_cancelled, + ) + rows = self._compare_query_to_gallery_cache(query_face.normed_embedding, gallery_cache, threshold) + rows.sort( + key=lambda item: item["similarity"] if isinstance(item.get("similarity"), (int, float)) else -1.0, + reverse=True, + ) + for rank, row in enumerate(rows, start=1): + row["rank"] = rank + mode = "1:1 Compare" if len(gallery_paths) == 1 else "1:N Gallery Search" + return { + "query_bbox": query_face.bbox, + "results": rows, + "mode": mode, + "query_path": query_path, + "gallery_paths": tuple(gallery_paths), + "gallery_key": gallery_key, + "gallery_cache": gallery_cache, + "multi_face_policy": multi_face_policy, + } + + def done(payload): + if ( + self.query_path != payload["query_path"] + or tuple(self.gallery_paths) != payload["gallery_paths"] + or self._multi_face_policy() != payload["multi_face_policy"] + ): + self.set_status("Recognition result ignored because query, gallery, or multi-face handling changed during processing.") + return + if cached_gallery is None: + self._gallery_embedding_cache_key = payload["gallery_key"] + self._gallery_embedding_cache = payload["gallery_cache"] + self.results = payload["results"] + self.query_input.set_faces([{"bbox": payload["query_bbox"], "label": "Query"}]) + self._populate_results() + cache_status = "cached gallery embeddings" if cached_gallery is None else "reused cached gallery embeddings" + self.set_status(f"{payload['mode']} complete with {cache_status}. {len(self.results)} gallery result(s).") + + self.run_task("Running verification", task, done) + + def open_result(self, row: int, column: int) -> None: + del column + if row < 0 or row >= len(self.results): + return + path = self.results[row].get("path") + if path: + QDesktopServices.openUrl(QUrl.fromLocalFile(str(path))) + + def _populate_results(self) -> None: + self.result_table.setRowCount(len(self.results)) + for row_index, result in enumerate(self.results): + values = [ + result.get("rank", ""), + "", + Path(str(result.get("path", ""))).name if result.get("path") else "", + f"{float(result.get('similarity', 0.0)):.4f}" if result.get("similarity") is not None else "", + f"{float(result.get('threshold', 0.0)):.4f}" if result.get("threshold") is not None else "", + result.get("decision", ""), + f"{float(result.get('det_score', 0.0)):.4f}" if result.get("det_score") is not None else "", + ] + for col, value in enumerate(values): + item = QTableWidgetItem(str(value)) + if col == 1: + icon = GalleryUploadPanel._icon(result.get("path"), QSize(56, 56)) + if icon is not None: + item.setIcon(icon) + item.setToolTip(str(result.get("notes") or result.get("path") or "")) + item.setData(Qt.UserRole, result.get("path", "")) + self.result_table.setItem(row_index, col, item) + self.result_table.setRowHeight(row_index, 64) + refresh_table_columns(self.result_table) + + def _update_mode_label(self) -> None: + pass + + def _clear_gallery_embedding_cache(self) -> None: + self._gallery_embedding_cache_key = None + self._gallery_embedding_cache = None + + def _build_gallery_embedding_cache( + self, + gallery_paths: list[str], + multi_face_policy: str, + progress=None, + is_cancelled=None, + ) -> list[dict]: + cache: list[dict] = [] + for index, path in enumerate(gallery_paths): + if is_cancelled and is_cancelled(): + break + image = read_image(path) + if image is None: + cache.append(self._gallery_error_cache_item(path, "Image read failure.")) + else: + try: + faces = self.context.engine.detect_faces(image, source_path=path) + face = select_face_by_policy( + faces, + image.shape, + multi_face_policy, + path=path, + stage="gallery", + ) + if face is None or face.normed_embedding is None: + cache.append(self._gallery_error_cache_item(path, "No face detected.")) + else: + cache.append( + { + "path": path, + "embedding": np.asarray(face.normed_embedding, dtype=np.float32).copy(), + "det_score": face.det_score, + "bbox": face.bbox, + "notes": "", + } + ) + except Exception as exc: + cache.append(self._gallery_error_cache_item(path, str(exc))) + if progress: + progress( + index + 1, + len(gallery_paths), + f"Computed gallery embeddings for {index + 1} of {len(gallery_paths)} images", + ) + return cache + + def _compare_query_to_gallery_cache( + self, query_embedding: np.ndarray, gallery_cache: list[dict], threshold: float + ) -> list[dict]: + rows = [] + for item in gallery_cache: + embedding = item.get("embedding") + if embedding is None: + rows.append( + self._error_row( + str(item.get("path", "")), + str(item.get("notes") or "No face detected."), + threshold, + ) + ) + continue + result = compare_embeddings(query_embedding, embedding, threshold) + rows.append( + { + "rank": 0, + "path": item.get("path", ""), + "similarity": float(result["similarity"]), + "threshold": threshold, + "decision": str(result["decision"]), + "det_score": item.get("det_score"), + "bbox": item.get("bbox"), + "notes": item.get("notes", ""), + } + ) + return rows + + @staticmethod + def _gallery_error_cache_item(path: str, message: str) -> dict: + return { + "path": path, + "embedding": None, + "det_score": None, + "bbox": None, + "notes": message, + } + + @staticmethod + def _error_row(path: str, message: str, threshold: float) -> dict: + return { + "rank": 0, + "path": path, + "similarity": None, + "threshold": threshold, + "decision": message, + "det_score": None, + "bbox": None, + "notes": message, + } + + def _multi_face_policy(self) -> str: + return str(self.multi_face_policy.currentData() or MULTI_FACE_REQUIRE_ONE) + + def _multi_face_policy_changed(self) -> None: + self._clear_gallery_embedding_cache() + if hasattr(self, "result_table"): + self.results = [] + self.result_table.setRowCount(0) + if hasattr(self, "query_input"): + self.query_input.set_faces([]) + self.set_status("Multi-face handling changed. Gallery embeddings will be recomputed.") + self._update_policy_notice() + + def _update_policy_notice(self) -> None: + language = self.context.config.ui_language + self.workflow_notice.setText( + tr( + "Gallery face embeddings are cached in memory after the first run and reused while the gallery image list " + "and multi-face policy are unchanged. Changing only the query image reuses the cached gallery; adding, " + "removing, clearing gallery images, or changing multi-face handling clears and recomputes it.", + language, + ) + + " " + + tr(multi_face_policy_help(self._multi_face_policy()), language) + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/video_search_page.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/video_search_page.py new file mode 100644 index 0000000000000000000000000000000000000000..7aa9cc66c82c44d260766acae3c0caa8a7ba96ba --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/pages/video_search_page.py @@ -0,0 +1,109 @@ +"""Video person search page.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtWidgets import QComboBox, QLabel, QSpinBox, QTableWidget, QTableWidgetItem + +from ..core.exporters import export_csv +from ..core.recognition import search_gallery +from ..core.utils import save_image, timestamp_for_filename +from ..core.video import iter_video_frames, read_video_thumbnail, timestamp_hhmmss +from ..widgets.table_utils import configure_table_columns, refresh_table_columns +from ..widgets.upload_preview import UploadPreview +from .base import BasePage + + +class VideoSearchPage(BasePage): + def __init__(self, context, parent=None): + super().__init__(context, "Video Person Search", "Search for a registered person in a local video using simple frame sampling.", parent) + self.video_path = "" + self.rows = [] + self.person_combo = QComboBox() + self.interval = QSpinBox() + self.interval.setRange(1, 300) + self.interval.setValue(context.config.video_frame_interval) + self.video_input = UploadPreview( + "Video File", + extensions=[".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v"], + dialog_filter="Videos (*.mp4 *.mov *.avi *.mkv *.webm *.m4v);;All Files (*)", + ) + self.video_input.pathChanged.connect(lambda path: self.load_video(path) if path else self.clear_video()) + self.content.addWidget(self.video_input) + self.content.addWidget(self.row(QLabel("Target person"), self.person_combo, QLabel("Frame interval"), self.interval, self.button("Refresh People", self.refresh), self.button("Start", self.start), self.button("Export CSV", self.export))) + self.table = QTableWidget(0, 8) + self.table.setHorizontalHeaderLabels(["video_path", "timestamp_ms", "timestamp_hhmmss", "frame_index", "person_name", "similarity", "bbox", "crop_path"]) + configure_table_columns(self.table, [300, 120, 140, 100, 160, 90, 200, 260]) + self.content.addWidget(self.table, 1) + self.refresh() + + def refresh(self) -> None: + self.person_combo.clear() + for person in self.context.storage.list_people(): + self.person_combo.addItem(person["display_name"] or person["name"], person["id"]) + + def load_video(self, path: str) -> None: + self.video_path = path + self.rows = [] + self.table.setRowCount(0) + self.video_input.set_image(read_video_thumbnail(path), path) + self.set_status(f"Selected video: {path}") + + def clear_video(self) -> None: + self.video_path = "" + self.rows = [] + self.table.setRowCount(0) + self.video_input.clear(emit=False) + + def start(self) -> None: + if not self.video_path: + self.show_error("Select a video first.") + return + if not self.context.engine.is_loaded(): + self.show_error("Model is not loaded. Please open Models.") + return + person_id = self.person_combo.currentData() + gallery = [item for item in self.context.storage.load_all_gallery_embeddings() if item.get("person_id") == person_id] + if not gallery: + self.show_error("Target person has no registered face samples.") + return + + def task(progress=None, is_cancelled=None): + rows = [] + for frame_index, timestamp_ms, frame in iter_video_frames(self.video_path, self.interval.value()): + if is_cancelled and is_cancelled(): + break + for face in self.context.engine.detect_faces(frame, source_path=self.video_path): + if face.normed_embedding is None: + continue + matches = search_gallery(face.normed_embedding, gallery, top_k=1, threshold=self.context.config.recognition_threshold) + if matches and matches[0].similarity >= self.context.config.recognition_threshold: + crop_path = str(Path(self.context.config.crop_dir) / f"video_{frame_index}_{timestamp_for_filename()}.png") + if face.crop is not None: + save_image(crop_path, face.crop) + rows.append({"video_path": self.video_path, "timestamp_ms": timestamp_ms, "timestamp_hhmmss": timestamp_hhmmss(timestamp_ms), "frame_index": frame_index, "person_id": person_id, "person_name": matches[0].person_name, "similarity": matches[0].similarity, "bbox": face.bbox, "crop_path": crop_path}) + if progress: + progress(frame_index, frame_index + 1, f"Processed frame {frame_index}") + return rows + + self.run_task("Video person search", task, lambda rows: (setattr(self, "rows", rows), self._populate(), self.set_status(f"Video search complete. {len(rows)} hit(s)."))) + + def _populate(self) -> None: + columns = ["video_path", "timestamp_ms", "timestamp_hhmmss", "frame_index", "person_name", "similarity", "bbox", "crop_path"] + self.table.setRowCount(len(self.rows)) + for row_index, row in enumerate(self.rows): + for col, key in enumerate(columns): + value = row.get(key, "") + if isinstance(value, float): + value = f"{value:.4f}" + self.table.setItem(row_index, col, QTableWidgetItem(str(value))) + refresh_table_columns(self.table) + + def export(self) -> None: + if not self.rows: + self.show_error("No video results to export.") + return + path = Path(self.context.config.export_dir) / f"video_search_{timestamp_for_filename()}.csv" + export_csv(path, self.rows) + self.set_status(f"Video results exported to {path}") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/resources.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/resources.py new file mode 100644 index 0000000000000000000000000000000000000000..f015170e416ea191f0bb51ac52ada26f6d2dac6a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/resources.py @@ -0,0 +1,104 @@ +"""Application resources and desktop metadata helpers.""" + +from __future__ import annotations + +import sys +from pathlib import Path + +from .core.constants import ( + APP_DOMAIN, + APP_ID, + APP_NAME, + APP_ORGANIZATION, + APP_PROCESS_NAME, + APP_VERSION, +) + +ASSET_DIR = Path(__file__).resolve().parent / "assets" +APP_ICON_SVG = ASSET_DIR / "app_icon.svg" +APP_ICON_PNG = ASSET_DIR / "app_icon.png" +APP_ICON_ICO = ASSET_DIR / "app_icon.ico" +APP_ICON_ICNS = ASSET_DIR / "app_icon.icns" + + +def app_icon_path() -> Path: + """Return the best available runtime icon path.""" + + for path in (APP_ICON_PNG, APP_ICON_ICO, APP_ICON_ICNS, APP_ICON_SVG): + if path.exists(): + return path + return APP_ICON_PNG + + +def app_icon(): + """Create a QIcon for the studio, returning an empty icon if Qt is unavailable.""" + + try: + from PySide6.QtGui import QIcon + except Exception: + return None + for path in (APP_ICON_PNG, APP_ICON_ICO, APP_ICON_ICNS, APP_ICON_SVG): + if not path.exists(): + continue + icon = QIcon(str(path)) + if not icon.isNull(): + return icon + return QIcon() + + +def configure_application_metadata(app) -> None: + """Apply stable, non-localized desktop metadata to the Qt application. + + Process and app identifiers intentionally remain English brand strings. + User-facing UI text is localized separately; OS-level identifiers should stay + stable for task managers, crash logs, permissions, packaging, and automation. + """ + + app.setApplicationName(APP_NAME) + if hasattr(app, "setApplicationDisplayName"): + app.setApplicationDisplayName(APP_NAME) + app.setApplicationVersion(APP_VERSION) + app.setOrganizationName(APP_ORGANIZATION) + app.setOrganizationDomain(APP_DOMAIN) + if hasattr(app, "setDesktopFileName"): + app.setDesktopFileName(APP_ID) + icon = app_icon() + if icon is not None and not icon.isNull(): + app.setWindowIcon(icon) + _set_windows_app_user_model_id() + _set_process_title_best_effort(APP_PROCESS_NAME) + + +def _set_windows_app_user_model_id() -> None: + if not sys.platform.startswith("win"): + return + try: + import ctypes + + ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(APP_ID) + except Exception: + pass + + +def _set_process_title_best_effort(name: str) -> None: + try: + import setproctitle + + setproctitle.setproctitle(name) + except Exception: + pass + + +__all__ = [ + "APP_NAME", + "APP_VERSION", + "APP_ID", + "APP_PROCESS_NAME", + "APP_ICON_SVG", + "APP_ICON_PNG", + "APP_ICON_ICO", + "APP_ICON_ICNS", + "app_icon", + "app_icon_path", + "configure_application_metadata", +] diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0b731366ec19da9dfdcef98af660edbc94c77e87 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/__init__.py @@ -0,0 +1 @@ +"""Reusable Qt widgets for InsightFace Evaluation Studio.""" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/drop_input.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/drop_input.py new file mode 100644 index 0000000000000000000000000000000000000000..6f1a0733eed8b8bd6cdea1382cd8959e9ec325ce --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/drop_input.py @@ -0,0 +1,245 @@ +"""Reusable drag-and-drop file/folder input.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Iterable, Sequence + +from PySide6.QtCore import QEvent, Qt, Signal +from PySide6.QtGui import QCursor +from PySide6.QtWidgets import ( + QFileDialog, + QFrame, + QHBoxLayout, + QLabel, + QPushButton, + QVBoxLayout, +) + +from ..core.tooltips import set_button_tooltip + + +class DropInput(QFrame): + pathsChanged = Signal(list) + removed = Signal() + + def __init__( + self, + title: str, + mode: str = "file", + extensions: Iterable[str] | None = None, + dialog_filter: str = "All Files (*)", + show_select_button: bool = True, + parent=None, + ): + super().__init__(parent) + self.title = title + self.mode = mode + self.show_select_button = bool(show_select_button) + self.extensions = {ext.lower() if ext.startswith(".") else f".{ext.lower()}" for ext in (extensions or [])} + self.dialog_filter = dialog_filter + self._paths: list[str] = [] + self.setObjectName("dropInput") + self.setAcceptDrops(True) + self.setMouseTracking(True) + self.setProperty("hoverActive", False) + self.setProperty("dragActive", False) + self.setProperty("hasFiles", False) + self.setFrameShape(QFrame.StyledPanel) + layout = QVBoxLayout(self) + self.title_label = QLabel(title) + self.title_label.setAlignment(Qt.AlignCenter) + self.title_label.setStyleSheet("font-weight: 600;") + self.path_label = QLabel(self._empty_text()) + self.path_label.setObjectName("dropPrompt") + self.path_label.setAlignment(Qt.AlignCenter) + self.path_label.setWordWrap(True) + self.path_label.setMinimumHeight(72) + self.path_label.setTextInteractionFlags(Qt.TextSelectableByMouse) + buttons = QHBoxLayout() + self.select_button = QPushButton("Select") + self.remove_button = QPushButton("Remove") + self.remove_button.setEnabled(False) + self.remove_button.setVisible(False) + self.select_button.setVisible(self.show_select_button) + self.select_button.clicked.connect(self.browse) + self.remove_button.clicked.connect(self.clear) + set_button_tooltip(self.select_button) + set_button_tooltip(self.remove_button) + buttons.addStretch(1) + buttons.addWidget(self.select_button) + buttons.addWidget(self.remove_button) + buttons.addStretch(1) + layout.addWidget(self.title_label) + layout.addWidget(self.path_label) + layout.addLayout(buttons) + for watched in (self, self.title_label, self.path_label, self.select_button, self.remove_button): + watched.setAcceptDrops(True) + watched.setMouseTracking(True) + watched.installEventFilter(self) + + def paths(self) -> list[str]: + return list(self._paths) + + def path(self) -> str: + return self._paths[0] if self._paths else "" + + def set_path(self, path: str, emit: bool = True) -> None: + self.set_paths([path] if path else [], emit=emit) + + def set_paths(self, paths: Sequence[str], emit: bool = True) -> None: + accepted = [str(Path(path).expanduser()) for path in paths if self._accepts_path(path)] + if self.mode != "files": + accepted = accepted[:1] + self._paths = accepted + if accepted: + display_text = self._selected_text(accepted) + self.path_label.setText(display_text) + self.path_label.setToolTip("\n".join(accepted)) + self.select_button.setVisible(False) + self.remove_button.setEnabled(True) + self.remove_button.setVisible(True) + else: + self.path_label.setText(self._empty_text()) + self.path_label.setToolTip("") + self.select_button.setVisible(self.show_select_button) + self.remove_button.setEnabled(False) + self.remove_button.setVisible(False) + if emit: + self.pathsChanged.emit(self.paths()) + self._set_property("hasFiles", bool(accepted)) + + def clear(self) -> None: + self._paths = [] + self.path_label.setText(self._empty_text()) + self.path_label.setToolTip("") + self.select_button.setVisible(self.show_select_button) + self.remove_button.setEnabled(False) + self.remove_button.setVisible(False) + self._set_property("hasFiles", False) + self.removed.emit() + self.pathsChanged.emit([]) + + def browse(self) -> None: + if self.mode == "folder": + path = QFileDialog.getExistingDirectory(self, f"Select {self.title}", str(Path.home())) + if path: + self.set_path(path) + elif self.mode == "files": + paths, _ = QFileDialog.getOpenFileNames(self, f"Select {self.title}", str(Path.home()), self.dialog_filter) + if paths: + self.set_paths(paths) + else: + path, _ = QFileDialog.getOpenFileName(self, f"Select {self.title}", str(Path.home()), self.dialog_filter) + if path: + self.set_path(path) + + def dragEnterEvent(self, event) -> None: # noqa: N802 + if event.mimeData().hasUrls() and self._accepted_urls(event.mimeData().urls()): + self._set_property("dragActive", True) + event.acceptProposedAction() + else: + event.ignore() + + def dragMoveEvent(self, event) -> None: # noqa: N802 + if event.mimeData().hasUrls() and self._accepted_urls(event.mimeData().urls()): + self._set_property("dragActive", True) + event.acceptProposedAction() + else: + event.ignore() + + def dragLeaveEvent(self, event) -> None: # noqa: N802 + self._set_property("dragActive", False) + super().dragLeaveEvent(event) + + def dropEvent(self, event) -> None: # noqa: N802 + self._set_property("dragActive", False) + paths = [url.toLocalFile() for url in event.mimeData().urls() if url.isLocalFile()] + accepted = [path for path in paths if self._accepts_path(path)] + if accepted: + self.set_paths(accepted) + event.acceptProposedAction() + else: + event.ignore() + + def _accepted_urls(self, urls) -> bool: + return any(url.isLocalFile() and self._accepts_path(url.toLocalFile()) for url in urls) + + def _accepts_path(self, path: str) -> bool: + if not path: + return False + p = Path(path) + if self.mode == "folder": + return p.is_dir() + if p.is_dir(): + return self.mode == "folder" + if self.extensions: + return p.suffix.lower() in self.extensions + return p.exists() + + def _empty_text(self) -> str: + if self.mode == "folder": + return "Click to upload or drag a folder here." + if self.mode == "files": + return "Click to upload or drag files here." + return "Click to upload or drag a file here." + + def _selected_text(self, paths: Sequence[str]) -> str: + prefix = "Selected folder:" if self.mode == "folder" else "Selected files:" if self.mode == "files" else "Selected file:" + body = "\n".join(paths[:8]) + if len(paths) > 8: + body = f"{body}\n... {len(paths)} total" + return f"{prefix}\n{body}" + + def eventFilter(self, watched, event) -> bool: # noqa: N802 + if event.type() in (QEvent.DragEnter, QEvent.DragMove): + if event.mimeData().hasUrls() and self._accepted_urls(event.mimeData().urls()): + self._set_property("dragActive", True) + event.acceptProposedAction() + return True + event.ignore() + return True + if event.type() == QEvent.DragLeave: + self._set_property("dragActive", False) + return False + if event.type() == QEvent.Drop: + self._set_property("dragActive", False) + paths = [url.toLocalFile() for url in event.mimeData().urls() if url.isLocalFile()] + accepted = [path for path in paths if self._accepts_path(path)] + if accepted: + self.set_paths(accepted) + event.acceptProposedAction() + return True + event.ignore() + return True + if event.type() == QEvent.Enter: + self._set_property("hoverActive", True) + return False + if event.type() == QEvent.Leave: + self._update_hover_from_cursor() + return False + if ( + event.type() == QEvent.MouseButtonRelease + and event.button() == Qt.LeftButton + and watched in {self, self.title_label, self.path_label} + ): + self.browse() + return True + return super().eventFilter(watched, event) + + def enterEvent(self, event) -> None: # noqa: N802 + self._set_property("hoverActive", True) + super().enterEvent(event) + + def leaveEvent(self, event) -> None: # noqa: N802 + self._update_hover_from_cursor() + super().leaveEvent(event) + + def _set_property(self, name: str, value) -> None: + self.setProperty(name, value) + self.style().unpolish(self) + self.style().polish(self) + + def _update_hover_from_cursor(self) -> None: + inside = self.rect().contains(self.mapFromGlobal(QCursor.pos())) + self._set_property("hoverActive", inside) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/face_overlay.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/face_overlay.py new file mode 100644 index 0000000000000000000000000000000000000000..85f33385f0d8f301c96630ed4dabba2498fde3f2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/face_overlay.py @@ -0,0 +1,9 @@ +"""Overlay formatting helpers.""" + +from __future__ import annotations + + +def face_label(name: str = "Unknown", similarity: float | None = None) -> str: + if similarity is None: + return name or "Unknown" + return f"{name or 'Unknown'} {similarity:.2f}" diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/face_table.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/face_table.py new file mode 100644 index 0000000000000000000000000000000000000000..23a32a5b3887e735c606eee12554ea85e0f04ca4 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/face_table.py @@ -0,0 +1,22 @@ +"""Table helpers for face/search results.""" + +from __future__ import annotations + +from typing import Iterable, Mapping + +from PySide6.QtWidgets import QTableWidget, QTableWidgetItem + +from .table_utils import configure_table_columns, refresh_table_columns + + +class FaceTable(QTableWidget): + def set_rows(self, rows: Iterable[Mapping[str, object]], columns: list[str]) -> None: + rows = list(rows) + self.setColumnCount(len(columns)) + self.setHorizontalHeaderLabels(columns) + configure_table_columns(self, [140] * len(columns)) + self.setRowCount(len(rows)) + for row_index, row in enumerate(rows): + for col_index, column in enumerate(columns): + self.setItem(row_index, col_index, QTableWidgetItem(str(row.get(column, "")))) + refresh_table_columns(self) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/image_viewer.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/image_viewer.py new file mode 100644 index 0000000000000000000000000000000000000000..db0ba1ff1b50d0bafc40fd35b11e110a78b5a3a7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/image_viewer.py @@ -0,0 +1,117 @@ +"""Zoomable image viewer with face overlays.""" + +from __future__ import annotations + +from typing import Any, Iterable, List, Optional + +import numpy as np +from PySide6.QtCore import QPointF, QRectF, Qt, Signal +from PySide6.QtGui import QColor, QImage, QPainter, QPen, QPixmap +from PySide6.QtWidgets import QGraphicsPixmapItem, QGraphicsScene, QGraphicsView + + +def numpy_to_qimage(image: np.ndarray) -> QImage: + if image.ndim == 2: + arr = np.ascontiguousarray(image) + return QImage(arr.data, arr.shape[1], arr.shape[0], arr.strides[0], QImage.Format_Grayscale8).copy() + rgb = np.ascontiguousarray(image[..., ::-1]) + return QImage(rgb.data, rgb.shape[1], rgb.shape[0], rgb.strides[0], QImage.Format_RGB888).copy() + + +class ImageViewer(QGraphicsView): + faceClicked = Signal(int) + + def __init__(self, parent=None): + super().__init__(parent) + self.setObjectName("imageViewer") + self.viewport().setObjectName("imageViewerViewport") + self.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform) + self.setDragMode(QGraphicsView.ScrollHandDrag) + self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse) + self.scene = QGraphicsScene(self) + self.setScene(self.scene) + self.pixmap_item: Optional[QGraphicsPixmapItem] = None + self.image: Optional[np.ndarray] = None + self.faces: List[dict[str, Any]] = [] + + def set_image(self, image: Optional[np.ndarray]) -> None: + self.scene.clear() + self.image = image + self.faces = [] + self.pixmap_item = None + if image is None: + return + pixmap = QPixmap.fromImage(numpy_to_qimage(image)) + self.pixmap_item = self.scene.addPixmap(pixmap) + self.scene.setSceneRect(QRectF(pixmap.rect())) + self.draw_overlays() + self.fit_to_window() + + def set_faces(self, faces: Iterable[Any]) -> None: + self.faces = [] + for face in faces: + if hasattr(face, "bbox"): + label = getattr(face, "label", None) or getattr(face, "person_name", None) or "Face" + similarity = getattr(face, "similarity", None) + self.faces.append({"bbox": face.bbox, "label": label, "similarity": similarity}) + else: + self.faces.append(dict(face)) + self.draw_overlays() + + def draw_overlays(self) -> None: + if self.pixmap_item is None or self.image is None: + return + for item in list(self.scene.items()): + if item is not self.pixmap_item: + self.scene.removeItem(item) + for index, face in enumerate(self.faces): + x1, y1, x2, y2 = [float(value) for value in face.get("bbox", [0, 0, 0, 0])] + rect = QRectF(x1, y1, x2 - x1, y2 - y1) + pen = QPen(QColor("#10b981") if face.get("label") != "Unknown" else QColor("#f59e0b")) + pen.setWidth(3) + item = self.scene.addRect(rect, pen) + item.setData(0, index) + label = face.get("label", "Face") + similarity = face.get("similarity") + if similarity is not None: + label = f"{label} {float(similarity):.2f}" + text = self.scene.addText(label) + text.setDefaultTextColor(QColor("#111827")) + text.setPos(QPointF(x1, max(0, y1 - 24))) + text.setData(0, index) + + def fit_to_window(self) -> None: + if self.pixmap_item is not None: + self.fitInView(self.pixmap_item, Qt.KeepAspectRatio) + + def wheelEvent(self, event) -> None: # noqa: N802 + factor = 1.2 if event.angleDelta().y() > 0 else 1 / 1.2 + self.scale(factor, factor) + + def mousePressEvent(self, event) -> None: # noqa: N802 + scene_pos = self.mapToScene(event.pos()) + for index, face in enumerate(self.faces): + x1, y1, x2, y2 = [float(value) for value in face.get("bbox", [0, 0, 0, 0])] + if x1 <= scene_pos.x() <= x2 and y1 <= scene_pos.y() <= y2: + self.faceClicked.emit(index) + break + super().mousePressEvent(event) + + def render_with_overlay(self) -> Optional[np.ndarray]: + if self.image is None: + return None + image = self.image.copy() + try: + import cv2 + + for face in self.faces: + x1, y1, x2, y2 = [int(round(float(value))) for value in face.get("bbox", [0, 0, 0, 0])] + color = (16, 185, 129) if face.get("label") != "Unknown" else (245, 158, 11) + cv2.rectangle(image, (x1, y1), (x2, y2), color, 2) + label = face.get("label", "Face") + if face.get("similarity") is not None: + label = f"{label} {float(face['similarity']):.2f}" + cv2.putText(image, label, (x1, max(20, y1 - 8)), cv2.FONT_HERSHEY_SIMPLEX, 0.65, color, 2) + except Exception: + pass + return image diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/metric_card.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/metric_card.py new file mode 100644 index 0000000000000000000000000000000000000000..f80a9b9f0d95a6c224f8e5fa2751d610d94b94c2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/metric_card.py @@ -0,0 +1,20 @@ +"""Small metric display.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QFrame, QLabel, QVBoxLayout + + +class MetricCard(QFrame): + def __init__(self, title: str, value: str = "0", parent=None): + super().__init__(parent) + self.setFrameShape(QFrame.StyledPanel) + self.title_label = QLabel(title) + self.value_label = QLabel(value) + self.value_label.setStyleSheet("font-size: 24px; font-weight: 600;") + layout = QVBoxLayout(self) + layout.addWidget(self.title_label) + layout.addWidget(self.value_label) + + def set_value(self, value: object) -> None: + self.value_label.setText(str(value)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/person_card.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/person_card.py new file mode 100644 index 0000000000000000000000000000000000000000..6a42d5ebdec80f9a9d6f6f9521bcb55cacaeb5df --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/person_card.py @@ -0,0 +1,22 @@ +"""Compact person/cluster card.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QFrame, QLabel, QPushButton, QVBoxLayout + +from ..core.tooltips import set_button_tooltip + + +class PersonCard(QFrame): + def __init__(self, title: str, subtitle: str = "", parent=None): + super().__init__(parent) + self.setFrameShape(QFrame.StyledPanel) + self.title = QLabel(title) + self.title.setStyleSheet("font-weight: 600;") + self.subtitle = QLabel(subtitle) + self.action = QPushButton("Open") + set_button_tooltip(self.action) + layout = QVBoxLayout(self) + layout.addWidget(self.title) + layout.addWidget(self.subtitle) + layout.addWidget(self.action) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/progress_dialog.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/progress_dialog.py new file mode 100644 index 0000000000000000000000000000000000000000..35dedd42b348cf0b5f61c4669522b4705789e1f8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/progress_dialog.py @@ -0,0 +1,20 @@ +"""Cancelable progress dialog.""" + +from __future__ import annotations + +from PySide6.QtWidgets import QProgressDialog +from PySide6.QtCore import Qt + + +class StudioProgressDialog(QProgressDialog): + def __init__(self, title: str, parent=None): + super().__init__("", "Cancel", 0, 100, parent) + self.setWindowTitle(title) + self.setWindowModality(Qt.WindowModal) + self.setMinimumDuration(0) + + def update_progress(self, current: int, total: int, message: str = "") -> None: + total = max(1, int(total)) + self.setMaximum(total) + self.setValue(min(int(current), total)) + self.setLabelText(message) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/table_utils.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/table_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..7b4a90ab09efd7a4edbbf0dd4f98b13a9ba57eaa --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/table_utils.py @@ -0,0 +1,74 @@ +"""Table layout helpers for dense desktop review pages.""" + +from __future__ import annotations + +from PySide6.QtCore import QEvent, QObject, QTimer +from PySide6.QtWidgets import QAbstractItemView, QAbstractScrollArea, QHeaderView, QTableWidget + + +class _ProportionalTableSizer(QObject): + def __init__(self, table: QTableWidget, estimated_widths: list[int], minimum_width: int = 56): + super().__init__(table) + self.table = table + self.estimated_widths = [max(1, int(width)) for width in estimated_widths] + self.minimum_width = max(1, int(minimum_width)) + + def update(self, estimated_widths: list[int], minimum_width: int) -> None: + self.estimated_widths = [max(1, int(width)) for width in estimated_widths] + self.minimum_width = max(1, int(minimum_width)) + + def eventFilter(self, watched, event) -> bool: # noqa: N802 + if event.type() == QEvent.Resize: + QTimer.singleShot(0, self.apply) + return False + + def apply(self) -> None: + columns = self.table.columnCount() + if columns <= 0: + return + estimates = self.estimated_widths[:columns] + if len(estimates) < columns: + estimates.extend([self.minimum_width] * (columns - len(estimates))) + available = max(1, self.table.viewport().width()) + total = max(1, sum(estimates)) + used = 0 + for column in range(columns): + if column == columns - 1: + width = max(self.minimum_width, available - used) + else: + width = max(self.minimum_width, int(available * estimates[column] / total)) + used += width + self.table.setColumnWidth(column, width) + + +def configure_table_columns(table: QTableWidget, estimated_widths: list[int], minimum_width: int = 56) -> None: + """Make table columns fill available width using estimated relative widths.""" + + existing = getattr(table, "_proportional_table_sizer", None) + if existing is not None: + existing.update(estimated_widths, minimum_width) + existing.apply() + return + + table.setAlternatingRowColors(True) + table.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel) + table.setSizeAdjustPolicy(QAbstractScrollArea.AdjustIgnored) + header = table.horizontalHeader() + header.setStretchLastSection(False) + header.setMinimumSectionSize(minimum_width) + header.setSectionResizeMode(QHeaderView.Interactive) + sizer = _ProportionalTableSizer(table, estimated_widths, minimum_width) + table.installEventFilter(sizer) + table.viewport().installEventFilter(sizer) + table._proportional_table_sizer = sizer # type: ignore[attr-defined] + QTimer.singleShot(0, sizer.apply) + + +def refresh_table_columns(table: QTableWidget) -> None: + """Re-apply proportional sizing after table data changes.""" + + sizer = getattr(table, "_proportional_table_sizer", None) + if sizer is not None: + sizer.apply() + else: + table.resizeColumnsToContents() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/threshold_slider.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/threshold_slider.py new file mode 100644 index 0000000000000000000000000000000000000000..c33b051af379003518784a69bfd7aae9d546b2e7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/threshold_slider.py @@ -0,0 +1,38 @@ +"""Threshold slider widget.""" + +from __future__ import annotations + +from PySide6.QtCore import Signal +from PySide6.QtWidgets import QHBoxLayout, QLabel, QSlider, QWidget +from PySide6.QtCore import Qt + +from ..core.constants import DEFAULT_THRESHOLD + + +class ThresholdSlider(QWidget): + valueChanged = Signal(float) + + def __init__(self, value: float = DEFAULT_THRESHOLD, parent=None): + super().__init__(parent) + self.label = QLabel() + self.slider = QSlider(Qt.Horizontal) + self.slider.setRange(0, 100) + self.slider.valueChanged.connect(self._emit) + layout = QHBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) + layout.addWidget(QLabel("Threshold")) + layout.addWidget(self.slider) + layout.addWidget(self.label) + self.set_value(value) + + def _emit(self, raw: int) -> None: + value = raw / 100.0 + self.label.setText(f"{value:.2f}") + self.valueChanged.emit(value) + + def value(self) -> float: + return self.slider.value() / 100.0 + + def set_value(self, value: float) -> None: + self.slider.setValue(int(round(float(value) * 100))) + self.label.setText(f"{self.value():.2f}") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/upload_preview.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/upload_preview.py new file mode 100644 index 0000000000000000000000000000000000000000..bcc8e7e506186944911fe29474c59fa19b5e6eda --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/gui/widgets/upload_preview.py @@ -0,0 +1,236 @@ +"""Clickable drag-and-drop preview input for local images and videos.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Iterable, Optional + +import numpy as np +from PySide6.QtCore import QEvent, Qt, Signal +from PySide6.QtGui import QCursor +from PySide6.QtWidgets import ( + QFileDialog, + QFrame, + QLabel, + QPushButton, + QStackedLayout, + QVBoxLayout, +) + +from ..core.tooltips import set_button_tooltip +from ..core.i18n import tr +from .image_viewer import ImageViewer + + +class UploadPreview(QFrame): + """Preview box that doubles as a local file picker and drop target.""" + + pathChanged = Signal(str) + removed = Signal() + + def __init__( + self, + title: str, + extensions: Iterable[str], + dialog_filter: str, + prompt: str = "Click to upload or drag a file here", + parent=None, + ): + super().__init__(parent) + self.setObjectName("uploadPreview") + self.title = title + self.prompt = prompt + self.extensions = {ext.lower() if ext.startswith(".") else f".{ext.lower()}" for ext in extensions} + self.dialog_filter = dialog_filter + self._path = "" + self.setAcceptDrops(True) + self.setMinimumHeight(260) + self.setMouseTracking(True) + self.setProperty("hoverActive", False) + self.setProperty("dragActive", False) + self.setProperty("hasFile", False) + + layout = QVBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) + self.stack = QStackedLayout() + self.stack.setStackingMode(QStackedLayout.StackAll) + self.viewer = ImageViewer() + self.viewer.setAcceptDrops(True) + self.viewer.setMouseTracking(True) + self.viewer.setFrameShape(QFrame.NoFrame) + self.viewer.setStyleSheet("background:transparent; border:0;") + self.viewer.viewport().setAcceptDrops(True) + self.viewer.viewport().setMouseTracking(True) + self.viewer.viewport().setStyleSheet("background:transparent;") + self.placeholder = QLabel(self._placeholder_text()) + self.placeholder.setObjectName("uploadPrompt") + self.placeholder.setAlignment(Qt.AlignCenter) + self.placeholder.setWordWrap(True) + self.stack.addWidget(self.viewer) + self.stack.addWidget(self.placeholder) + layout.addLayout(self.stack, 1) + + self.file_label = QLabel("") + self.file_label.setObjectName("pathLabel") + self.file_label.setTextInteractionFlags(Qt.TextSelectableByMouse) + self.file_label.setAlignment(Qt.AlignCenter) + self.file_label.hide() + layout.addWidget(self.file_label) + + self.remove_button = QPushButton("×", self) + self.remove_button.setObjectName("removeUpload") + set_button_tooltip(self.remove_button) + self.remove_button.setFixedSize(22, 22) + self.remove_button.clicked.connect(self.clear) + self.remove_button.hide() + + for watched in (self, self.viewer, self.viewer.viewport(), self.placeholder): + watched.installEventFilter(self) + + def path(self) -> str: + return self._path + + def set_path(self, path: str, emit: bool = True) -> None: + if not self._accepts_path(path): + return + self._path = str(Path(path).expanduser()) + self._show_selected() + if emit: + self.pathChanged.emit(self._path) + + def set_image(self, image: Optional[np.ndarray], path: str | None = None) -> None: + if path: + self._path = str(Path(path).expanduser()) + self.viewer.set_image(image) + if image is None: + if self._path: + self._show_selected() + else: + self.clear(emit=False) + else: + self._show_selected(has_preview=True) + + def set_faces(self, faces) -> None: + self.viewer.set_faces(faces) + + def render_with_overlay(self): + return self.viewer.render_with_overlay() + + def clear(self, emit: bool = True) -> None: + self._path = "" + self.viewer.set_image(None) + self.viewer.set_faces([]) + self.placeholder.setText(self._placeholder_text()) + self.placeholder.show() + self.file_label.clear() + self.file_label.hide() + self.remove_button.hide() + self._set_property("hasFile", False) + if emit: + self.removed.emit() + self.pathChanged.emit("") + + def browse(self) -> None: + path, _ = QFileDialog.getOpenFileName( + self, + f"{tr('Select', self._language())} {tr(self.title, self._language())}", + str(Path.home()), + self.dialog_filter, + ) + if path: + self.set_path(path) + + def eventFilter(self, watched, event) -> bool: # noqa: N802 + if event.type() in (QEvent.DragEnter, QEvent.DragMove): + if event.mimeData().hasUrls() and self._accepted_urls(event.mimeData().urls()): + self._set_property("dragActive", True) + event.acceptProposedAction() + return True + event.ignore() + return True + if event.type() == QEvent.DragLeave: + self._set_property("dragActive", False) + return False + if event.type() == QEvent.Enter: + self._set_property("hoverActive", True) + return False + if event.type() == QEvent.Leave: + self._update_hover_from_cursor() + return False + if event.type() == QEvent.Drop: + self._set_property("dragActive", False) + paths = [url.toLocalFile() for url in event.mimeData().urls() if url.isLocalFile()] + accepted = [path for path in paths if self._accepts_path(path)] + if accepted: + self.set_path(accepted[0]) + event.acceptProposedAction() + return True + event.ignore() + return True + if event.type() == QEvent.MouseButtonRelease and event.button() == Qt.LeftButton and not self._path: + self.browse() + return True + return super().eventFilter(watched, event) + + def mouseReleaseEvent(self, event) -> None: # noqa: N802 + if event.button() == Qt.LeftButton and not self._path: + self.browse() + event.accept() + return + super().mouseReleaseEvent(event) + + def enterEvent(self, event) -> None: # noqa: N802 + self._set_property("hoverActive", True) + super().enterEvent(event) + + def leaveEvent(self, event) -> None: # noqa: N802 + self._update_hover_from_cursor() + super().leaveEvent(event) + + def resizeEvent(self, event) -> None: # noqa: N802 + super().resizeEvent(event) + self.remove_button.move(max(0, self.width() - 30), 8) + self.remove_button.raise_() + + def _show_selected(self, has_preview: bool = False) -> None: + self._set_property("hasFile", True) + self.remove_button.show() + self.remove_button.raise_() + if has_preview: + self.placeholder.hide() + else: + name = Path(self._path).name if self._path else self.title + self.placeholder.setText( + f"{tr(self.title, self._language())}\n{name}\n{tr('Drop another file to replace it', self._language())}" + ) + self.placeholder.show() + if self._path: + self.file_label.setText(str(self._path)) + self.file_label.show() + + def _placeholder_text(self) -> str: + language = self._language() + return f"{tr(self.title, language)}\n{tr(self.prompt, language)}" + + def _language(self) -> str | None: + context = getattr(self.window(), "context", None) + config = getattr(context, "config", None) + return getattr(config, "ui_language", None) + + def _accepted_urls(self, urls) -> bool: + return any(url.isLocalFile() and self._accepts_path(url.toLocalFile()) for url in urls) + + def _accepts_path(self, path: str) -> bool: + if not path: + return False + p = Path(path).expanduser() + return p.is_file() and (not self.extensions or p.suffix.lower() in self.extensions) + + def _set_property(self, name: str, value) -> None: + self.setProperty(name, value) + self.style().unpolish(self) + self.style().polish(self) + + def _update_hover_from_cursor(self) -> None: + inside = self.rect().contains(self.mapFromGlobal(QCursor.pos())) + self._set_property("hoverActive", inside) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..225623d6142c968b4040f391039bfab88bdd1b2a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/__init__.py @@ -0,0 +1,6 @@ +from .model_zoo import get_model +from .arcface_onnx import ArcFaceONNX +from .retinaface import RetinaFace +from .scrfd import SCRFD +from .landmark import Landmark +from .attribute import Attribute diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/arcface_onnx.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/arcface_onnx.py new file mode 100644 index 0000000000000000000000000000000000000000..b537ce2ee15d4a1834d54e185f34e336aab30a77 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/arcface_onnx.py @@ -0,0 +1,92 @@ +# -*- coding: utf-8 -*- +# @Organization : insightface.ai +# @Author : Jia Guo +# @Time : 2021-05-04 +# @Function : + +from __future__ import division +import numpy as np +import cv2 +import onnx +import onnxruntime +from ..utils import face_align + +__all__ = [ + 'ArcFaceONNX', +] + + +class ArcFaceONNX: + def __init__(self, model_file=None, session=None): + assert model_file is not None + self.model_file = model_file + self.session = session + self.taskname = 'recognition' + find_sub = False + find_mul = False + model = onnx.load(self.model_file) + graph = model.graph + for nid, node in enumerate(graph.node[:8]): + #print(nid, node.name) + if node.name.startswith('Sub') or node.name.startswith('_minus'): + find_sub = True + if node.name.startswith('Mul') or node.name.startswith('_mul'): + find_mul = True + if find_sub and find_mul: + #mxnet arcface model + input_mean = 0.0 + input_std = 1.0 + else: + input_mean = 127.5 + input_std = 127.5 + self.input_mean = input_mean + self.input_std = input_std + #print('input mean and std:', self.input_mean, self.input_std) + if self.session is None: + self.session = onnxruntime.InferenceSession(self.model_file, None) + input_cfg = self.session.get_inputs()[0] + input_shape = input_cfg.shape + input_name = input_cfg.name + self.input_size = tuple(input_shape[2:4][::-1]) + self.input_shape = input_shape + outputs = self.session.get_outputs() + output_names = [] + for out in outputs: + output_names.append(out.name) + self.input_name = input_name + self.output_names = output_names + assert len(self.output_names)==1 + self.output_shape = outputs[0].shape + + def prepare(self, ctx_id, **kwargs): + if ctx_id<0: + self.session.set_providers(['CPUExecutionProvider']) + + def get(self, img, face): + aimg = face_align.norm_crop(img, landmark=face.kps, image_size=self.input_size[0]) + face.embedding = self.get_feat(aimg).flatten() + return face.embedding + + def compute_sim(self, feat1, feat2): + from numpy.linalg import norm + feat1 = feat1.ravel() + feat2 = feat2.ravel() + sim = np.dot(feat1, feat2) / (norm(feat1) * norm(feat2)) + return sim + + def get_feat(self, imgs): + if not isinstance(imgs, list): + imgs = [imgs] + input_size = self.input_size + + blob = cv2.dnn.blobFromImages(imgs, 1.0 / self.input_std, input_size, + (self.input_mean, self.input_mean, self.input_mean), swapRB=True) + net_out = self.session.run(self.output_names, {self.input_name: blob})[0] + return net_out + + def forward(self, batch_data): + blob = (batch_data - self.input_mean) / self.input_std + net_out = self.session.run(self.output_names, {self.input_name: blob})[0] + return net_out + + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/attribute.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/attribute.py new file mode 100644 index 0000000000000000000000000000000000000000..40c34de3f0995499448cf5779004cc1e5f3564fb --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/attribute.py @@ -0,0 +1,94 @@ +# -*- coding: utf-8 -*- +# @Organization : insightface.ai +# @Author : Jia Guo +# @Time : 2021-06-19 +# @Function : + +from __future__ import division +import numpy as np +import cv2 +import onnx +import onnxruntime +from ..utils import face_align + +__all__ = [ + 'Attribute', +] + + +class Attribute: + def __init__(self, model_file=None, session=None): + assert model_file is not None + self.model_file = model_file + self.session = session + find_sub = False + find_mul = False + model = onnx.load(self.model_file) + graph = model.graph + for nid, node in enumerate(graph.node[:8]): + #print(nid, node.name) + if node.name.startswith('Sub') or node.name.startswith('_minus'): + find_sub = True + if node.name.startswith('Mul') or node.name.startswith('_mul'): + find_mul = True + if nid<3 and node.name=='bn_data': + find_sub = True + find_mul = True + if find_sub and find_mul: + #mxnet arcface model + input_mean = 0.0 + input_std = 1.0 + else: + input_mean = 127.5 + input_std = 128.0 + self.input_mean = input_mean + self.input_std = input_std + #print('input mean and std:', model_file, self.input_mean, self.input_std) + if self.session is None: + self.session = onnxruntime.InferenceSession(self.model_file, None) + input_cfg = self.session.get_inputs()[0] + input_shape = input_cfg.shape + input_name = input_cfg.name + self.input_size = tuple(input_shape[2:4][::-1]) + self.input_shape = input_shape + outputs = self.session.get_outputs() + output_names = [] + for out in outputs: + output_names.append(out.name) + self.input_name = input_name + self.output_names = output_names + assert len(self.output_names)==1 + output_shape = outputs[0].shape + #print('init output_shape:', output_shape) + if output_shape[1]==3: + self.taskname = 'genderage' + else: + self.taskname = 'attribute_%d'%output_shape[1] + + def prepare(self, ctx_id, **kwargs): + if ctx_id<0: + self.session.set_providers(['CPUExecutionProvider']) + + def get(self, img, face): + bbox = face.bbox + w, h = (bbox[2] - bbox[0]), (bbox[3] - bbox[1]) + center = (bbox[2] + bbox[0]) / 2, (bbox[3] + bbox[1]) / 2 + rotate = 0 + _scale = self.input_size[0] / (max(w, h)*1.5) + #print('param:', img.shape, bbox, center, self.input_size, _scale, rotate) + aimg, M = face_align.transform(img, center, self.input_size[0], _scale, rotate) + input_size = tuple(aimg.shape[0:2][::-1]) + #assert input_size==self.input_size + blob = cv2.dnn.blobFromImage(aimg, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True) + pred = self.session.run(self.output_names, {self.input_name : blob})[0][0] + if self.taskname=='genderage': + assert len(pred)==3 + gender = np.argmax(pred[:2]) + age = int(np.round(pred[2]*100)) + face['gender'] = gender + face['age'] = age + return gender, age + else: + return pred + + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/inswapper.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/inswapper.py new file mode 100644 index 0000000000000000000000000000000000000000..dcaceb1f2dc590e066431bed5b708af66f6c74e0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/inswapper.py @@ -0,0 +1,105 @@ +import time +import numpy as np +import onnxruntime +import cv2 +import onnx +from onnx import numpy_helper +from ..utils import face_align + + + + +class INSwapper(): + def __init__(self, model_file=None, session=None): + self.model_file = model_file + self.session = session + model = onnx.load(self.model_file) + graph = model.graph + self.emap = numpy_helper.to_array(graph.initializer[-1]) + self.input_mean = 0.0 + self.input_std = 255.0 + #print('input mean and std:', model_file, self.input_mean, self.input_std) + if self.session is None: + self.session = onnxruntime.InferenceSession(self.model_file, None) + inputs = self.session.get_inputs() + self.input_names = [] + for inp in inputs: + self.input_names.append(inp.name) + outputs = self.session.get_outputs() + output_names = [] + for out in outputs: + output_names.append(out.name) + self.output_names = output_names + assert len(self.output_names)==1 + output_shape = outputs[0].shape + input_cfg = inputs[0] + input_shape = input_cfg.shape + self.input_shape = input_shape + print('inswapper-shape:', self.input_shape) + self.input_size = tuple(input_shape[2:4][::-1]) + + def forward(self, img, latent): + img = (img - self.input_mean) / self.input_std + pred = self.session.run(self.output_names, {self.input_names[0]: img, self.input_names[1]: latent})[0] + return pred + + def get(self, img, target_face, source_face, paste_back=True): + aimg, M = face_align.norm_crop2(img, target_face.kps, self.input_size[0]) + blob = cv2.dnn.blobFromImage(aimg, 1.0 / self.input_std, self.input_size, + (self.input_mean, self.input_mean, self.input_mean), swapRB=True) + latent = source_face.normed_embedding.reshape((1,-1)) + latent = np.dot(latent, self.emap) + latent /= np.linalg.norm(latent) + pred = self.session.run(self.output_names, {self.input_names[0]: blob, self.input_names[1]: latent})[0] + #print(latent.shape, latent.dtype, pred.shape) + img_fake = pred.transpose((0,2,3,1))[0] + bgr_fake = np.clip(255 * img_fake, 0, 255).astype(np.uint8)[:,:,::-1] + if not paste_back: + return bgr_fake, M + else: + target_img = img + fake_diff = bgr_fake.astype(np.float32) - aimg.astype(np.float32) + fake_diff = np.abs(fake_diff).mean(axis=2) + fake_diff[:2,:] = 0 + fake_diff[-2:,:] = 0 + fake_diff[:,:2] = 0 + fake_diff[:,-2:] = 0 + IM = cv2.invertAffineTransform(M) + img_white = np.full((aimg.shape[0],aimg.shape[1]), 255, dtype=np.float32) + bgr_fake = cv2.warpAffine(bgr_fake, IM, (target_img.shape[1], target_img.shape[0]), borderValue=0.0) + img_white = cv2.warpAffine(img_white, IM, (target_img.shape[1], target_img.shape[0]), borderValue=0.0) + fake_diff = cv2.warpAffine(fake_diff, IM, (target_img.shape[1], target_img.shape[0]), borderValue=0.0) + img_white[img_white>20] = 255 + fthresh = 10 + fake_diff[fake_diff=fthresh] = 255 + img_mask = img_white + mask_h_inds, mask_w_inds = np.where(img_mask==255) + mask_h = np.max(mask_h_inds) - np.min(mask_h_inds) + mask_w = np.max(mask_w_inds) - np.min(mask_w_inds) + mask_size = int(np.sqrt(mask_h*mask_w)) + k = max(mask_size//10, 10) + #k = max(mask_size//20, 6) + #k = 6 + kernel = np.ones((k,k),np.uint8) + img_mask = cv2.erode(img_mask,kernel,iterations = 1) + kernel = np.ones((2,2),np.uint8) + fake_diff = cv2.dilate(fake_diff,kernel,iterations = 1) + k = max(mask_size//20, 5) + #k = 3 + #k = 3 + kernel_size = (k, k) + blur_size = tuple(2*i+1 for i in kernel_size) + img_mask = cv2.GaussianBlur(img_mask, blur_size, 0) + k = 5 + kernel_size = (k, k) + blur_size = tuple(2*i+1 for i in kernel_size) + fake_diff = cv2.GaussianBlur(fake_diff, blur_size, 0) + img_mask /= 255 + fake_diff /= 255 + #img_mask = fake_diff + img_mask = np.reshape(img_mask, [img_mask.shape[0],img_mask.shape[1],1]) + fake_merged = img_mask * bgr_fake + (1-img_mask) * target_img.astype(np.float32) + fake_merged = fake_merged.astype(np.uint8) + return fake_merged + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/landmark.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/landmark.py new file mode 100644 index 0000000000000000000000000000000000000000..598b4b29a2d0674d8bb25b681f921c61460d101c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/landmark.py @@ -0,0 +1,114 @@ +# -*- coding: utf-8 -*- +# @Organization : insightface.ai +# @Author : Jia Guo +# @Time : 2021-05-04 +# @Function : + +from __future__ import division +import numpy as np +import cv2 +import onnx +import onnxruntime +from ..utils import face_align +from ..utils import transform +from ..data import get_object + +__all__ = [ + 'Landmark', +] + + +class Landmark: + def __init__(self, model_file=None, session=None): + assert model_file is not None + self.model_file = model_file + self.session = session + find_sub = False + find_mul = False + model = onnx.load(self.model_file) + graph = model.graph + for nid, node in enumerate(graph.node[:8]): + #print(nid, node.name) + if node.name.startswith('Sub') or node.name.startswith('_minus'): + find_sub = True + if node.name.startswith('Mul') or node.name.startswith('_mul'): + find_mul = True + if nid<3 and node.name=='bn_data': + find_sub = True + find_mul = True + if find_sub and find_mul: + #mxnet arcface model + input_mean = 0.0 + input_std = 1.0 + else: + input_mean = 127.5 + input_std = 128.0 + self.input_mean = input_mean + self.input_std = input_std + #print('input mean and std:', model_file, self.input_mean, self.input_std) + if self.session is None: + self.session = onnxruntime.InferenceSession(self.model_file, None) + input_cfg = self.session.get_inputs()[0] + input_shape = input_cfg.shape + input_name = input_cfg.name + self.input_size = tuple(input_shape[2:4][::-1]) + self.input_shape = input_shape + outputs = self.session.get_outputs() + output_names = [] + for out in outputs: + output_names.append(out.name) + self.input_name = input_name + self.output_names = output_names + assert len(self.output_names)==1 + output_shape = outputs[0].shape + self.require_pose = False + #print('init output_shape:', output_shape) + if output_shape[1]==3309: + self.lmk_dim = 3 + self.lmk_num = 68 + self.mean_lmk = get_object('meanshape_68.pkl') + self.require_pose = True + else: + self.lmk_dim = 2 + self.lmk_num = output_shape[1]//self.lmk_dim + self.taskname = 'landmark_%dd_%d'%(self.lmk_dim, self.lmk_num) + + def prepare(self, ctx_id, **kwargs): + if ctx_id<0: + self.session.set_providers(['CPUExecutionProvider']) + + def get(self, img, face): + bbox = face.bbox + w, h = (bbox[2] - bbox[0]), (bbox[3] - bbox[1]) + center = (bbox[2] + bbox[0]) / 2, (bbox[3] + bbox[1]) / 2 + rotate = 0 + _scale = self.input_size[0] / (max(w, h)*1.5) + #print('param:', img.shape, bbox, center, self.input_size, _scale, rotate) + aimg, M = face_align.transform(img, center, self.input_size[0], _scale, rotate) + input_size = tuple(aimg.shape[0:2][::-1]) + #assert input_size==self.input_size + blob = cv2.dnn.blobFromImage(aimg, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True) + pred = self.session.run(self.output_names, {self.input_name : blob})[0][0] + if pred.shape[0] >= 3000: + pred = pred.reshape((-1, 3)) + else: + pred = pred.reshape((-1, 2)) + if self.lmk_num < pred.shape[0]: + pred = pred[self.lmk_num*-1:,:] + pred[:, 0:2] += 1 + pred[:, 0:2] *= (self.input_size[0] // 2) + if pred.shape[1] == 3: + pred[:, 2] *= (self.input_size[0] // 2) + + IM = cv2.invertAffineTransform(M) + pred = face_align.trans_points(pred, IM) + face[self.taskname] = pred + if self.require_pose: + P = transform.estimate_affine_matrix_3d23d(self.mean_lmk, pred) + s, R, t = transform.P2sRt(P) + rx, ry, rz = transform.matrix2angle(R) + pose = np.array( [rx, ry, rz], dtype=np.float32 ) + face['pose'] = pose #pitch, yaw, roll + return pred + + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/model_store.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/model_store.py new file mode 100644 index 0000000000000000000000000000000000000000..b62dc5892503093aeca7dae1c9dffc5bc239cfd3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/model_store.py @@ -0,0 +1,102 @@ +""" +This code file mainly comes from https://github.com/dmlc/gluon-cv/blob/master/gluoncv/model_zoo/model_store.py +""" +from __future__ import print_function + +__all__ = ['get_model_file'] +import os +import zipfile +import glob + +from ..utils import download, check_sha1 + +_model_sha1 = { + name: checksum + for checksum, name in [ + ('95be21b58e29e9c1237f229dae534bd854009ce0', 'arcface_r100_v1'), + ('', 'arcface_mfn_v1'), + ('39fd1e087a2a2ed70a154ac01fecaa86c315d01b', 'retinaface_r50_v1'), + ('2c9de8116d1f448fd1d4661f90308faae34c990a', 'retinaface_mnet025_v1'), + ('0db1d07921d005e6c9a5b38e059452fc5645e5a4', 'retinaface_mnet025_v2'), + ('7dd8111652b7aac2490c5dcddeb268e53ac643e6', 'genderage_v1'), + ] +} + +base_repo_url = 'https://insightface.ai/files/' +_url_format = '{repo_url}models/{file_name}.zip' + + +def short_hash(name): + if name not in _model_sha1: + raise ValueError( + 'Pretrained model for {name} is not available.'.format(name=name)) + return _model_sha1[name][:8] + + +def find_params_file(dir_path): + if not os.path.exists(dir_path): + return None + paths = glob.glob(os.path.join(dir_path, "*.params")) + if len(paths) == 0: + return None + paths = sorted(paths) + return paths[-1] + + +def get_model_file(name, root=os.path.join('~', '.insightface', 'models')): + r"""Return location for the pretrained on local file system. + + This function will download from online model zoo when model cannot be found or has mismatch. + The root directory will be created if it doesn't exist. + + Parameters + ---------- + name : str + Name of the model. + root : str, default '~/.mxnet/models' + Location for keeping the model parameters. + + Returns + ------- + file_path + Path to the requested pretrained model file. + """ + + file_name = name + root = os.path.expanduser(root) + dir_path = os.path.join(root, name) + file_path = find_params_file(dir_path) + #file_path = os.path.join(root, file_name + '.params') + sha1_hash = _model_sha1[name] + if file_path is not None: + if check_sha1(file_path, sha1_hash): + return file_path + else: + print( + 'Mismatch in the content of model file detected. Downloading again.' + ) + else: + print('Model file is not found. Downloading.') + + if not os.path.exists(root): + os.makedirs(root) + if not os.path.exists(dir_path): + os.makedirs(dir_path) + + zip_file_path = os.path.join(root, file_name + '.zip') + repo_url = base_repo_url + if repo_url[-1] != '/': + repo_url = repo_url + '/' + download(_url_format.format(repo_url=repo_url, file_name=file_name), + path=zip_file_path, + overwrite=True) + with zipfile.ZipFile(zip_file_path) as zf: + zf.extractall(dir_path) + os.remove(zip_file_path) + file_path = find_params_file(dir_path) + + if check_sha1(file_path, sha1_hash): + return file_path + else: + raise ValueError( + 'Downloaded file has different hash. Please try again.') diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/model_zoo.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/model_zoo.py new file mode 100644 index 0000000000000000000000000000000000000000..73c6a508686bd1e329e00334f05e8d2670c269c6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/model_zoo.py @@ -0,0 +1,97 @@ +# -*- coding: utf-8 -*- +# @Organization : insightface.ai +# @Author : Jia Guo +# @Time : 2021-05-04 +# @Function : + +import os +import os.path as osp +import glob +import onnxruntime +from .arcface_onnx import * +from .retinaface import * +from .scrfd import * +from .landmark import * +from .attribute import Attribute +from .inswapper import INSwapper +from ..utils import download_onnx + +__all__ = ['get_model'] + + +class PickableInferenceSession(onnxruntime.InferenceSession): + # This is a wrapper to make the current InferenceSession class pickable. + def __init__(self, model_path, **kwargs): + super().__init__(model_path, **kwargs) + self.model_path = model_path + + def __getstate__(self): + return {'model_path': self.model_path} + + def __setstate__(self, values): + model_path = values['model_path'] + self.__init__(model_path) + +class ModelRouter: + def __init__(self, onnx_file): + self.onnx_file = onnx_file + + def get_model(self, **kwargs): + session = PickableInferenceSession(self.onnx_file, **kwargs) + print(f'Applied providers: {session._providers}, with options: {session._provider_options}') + inputs = session.get_inputs() + input_cfg = inputs[0] + input_shape = input_cfg.shape + outputs = session.get_outputs() + + if len(outputs)>=5: + return SCRFD(model_file=self.onnx_file, session=session) + elif input_shape[2]==192 and input_shape[3]==192: + return Landmark(model_file=self.onnx_file, session=session) + elif input_shape[2]==96 and input_shape[3]==96: + return Attribute(model_file=self.onnx_file, session=session) + elif len(inputs)==2 and input_shape[2]==128 and input_shape[3]==128: + return INSwapper(model_file=self.onnx_file, session=session) + elif input_shape[2]==input_shape[3] and input_shape[2]>=112 and input_shape[2]%16==0: + return ArcFaceONNX(model_file=self.onnx_file, session=session) + else: + #raise RuntimeError('error on model routing') + return None + +def find_onnx_file(dir_path): + if not os.path.exists(dir_path): + return None + paths = glob.glob(osp.join(dir_path, "*.onnx")) + if len(paths) == 0: + return None + paths = sorted(paths) + return paths[-1] + +def get_default_providers(): + return ['CUDAExecutionProvider', 'CPUExecutionProvider'] + +def get_default_provider_options(): + return None + +def get_model(name, **kwargs): + root = kwargs.get('root', '~/.insightface') + root = os.path.expanduser(root) + model_root = osp.join(root, 'models') + allow_download = kwargs.get('download', False) + download_zip = kwargs.get('download_zip', False) + if not name.endswith('.onnx'): + model_dir = os.path.join(model_root, name) + model_file = find_onnx_file(model_dir) + if model_file is None: + return None + else: + model_file = name + if not osp.exists(model_file) and allow_download: + model_file = download_onnx('models', model_file, root=root, download_zip=download_zip) + assert osp.exists(model_file), 'model_file %s should exist'%model_file + assert osp.isfile(model_file), 'model_file %s should be a file'%model_file + router = ModelRouter(model_file) + providers = kwargs.get('providers', get_default_providers()) + provider_options = kwargs.get('provider_options', get_default_provider_options()) + model = router.get_model(providers=providers, provider_options=provider_options) + return model diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/retinaface.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/retinaface.py new file mode 100644 index 0000000000000000000000000000000000000000..731d70d3e6922c0fdd90a4276dbcdb017eaf8c61 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/retinaface.py @@ -0,0 +1,368 @@ +# -*- coding: utf-8 -*- +# @Organization : insightface.ai +# @Author : Jia Guo +# @Time : 2021-09-18 +# @Function : + +from __future__ import division +import datetime +import numpy as np +import onnx +import onnxruntime +import os +import os.path as osp +import cv2 +import sys + +def softmax(z): + assert len(z.shape) == 2 + s = np.max(z, axis=1) + s = s[:, np.newaxis] # necessary step to do broadcasting + e_x = np.exp(z - s) + div = np.sum(e_x, axis=1) + div = div[:, np.newaxis] # dito + return e_x / div + +def distance2bbox(points, distance, max_shape=None): + """Decode distance prediction to bounding box. + + Args: + points (Tensor): Shape (n, 2), [x, y]. + distance (Tensor): Distance from the given point to 4 + boundaries (left, top, right, bottom). + max_shape (tuple): Shape of the image. + + Returns: + Tensor: Decoded bboxes. + """ + x1 = points[:, 0] - distance[:, 0] + y1 = points[:, 1] - distance[:, 1] + x2 = points[:, 0] + distance[:, 2] + y2 = points[:, 1] + distance[:, 3] + if max_shape is not None: + x1 = x1.clamp(min=0, max=max_shape[1]) + y1 = y1.clamp(min=0, max=max_shape[0]) + x2 = x2.clamp(min=0, max=max_shape[1]) + y2 = y2.clamp(min=0, max=max_shape[0]) + return np.stack([x1, y1, x2, y2], axis=-1) + +def distance2kps(points, distance, max_shape=None): + """Decode distance prediction to bounding box. + + Args: + points (Tensor): Shape (n, 2), [x, y]. + distance (Tensor): Distance from the given point to 4 + boundaries (left, top, right, bottom). + max_shape (tuple): Shape of the image. + + Returns: + Tensor: Decoded bboxes. + """ + preds = [] + for i in range(0, distance.shape[1], 2): + px = points[:, i%2] + distance[:, i] + py = points[:, i%2+1] + distance[:, i+1] + if max_shape is not None: + px = px.clamp(min=0, max=max_shape[1]) + py = py.clamp(min=0, max=max_shape[0]) + preds.append(px) + preds.append(py) + return np.stack(preds, axis=-1) + +class RetinaFace: + def __init__(self, model_file=None, session=None): + import onnxruntime + self.model_file = model_file + self.session = session + self.taskname = 'detection' + if self.session is None: + assert self.model_file is not None + assert osp.exists(self.model_file) + self.session = onnxruntime.InferenceSession(self.model_file, None) + self.center_cache = {} + self.nms_thresh = 0.4 + self.det_thresh = 0.5 + self._init_vars() + + def _init_vars(self): + input_cfg = self.session.get_inputs()[0] + input_shape = input_cfg.shape + #print(input_shape) + if isinstance(input_shape[2], str): + self.static_input_size = None + else: + self.static_input_size = tuple(input_shape[2:4][::-1]) + self.input_size = self.static_input_size + self.input_sizes = [self.static_input_size] if self.static_input_size is not None else [] + self._debug_det_size_printed = False + #print('image_size:', self.image_size) + input_name = input_cfg.name + self.input_shape = input_shape + outputs = self.session.get_outputs() + output_names = [] + for o in outputs: + output_names.append(o.name) + self.input_name = input_name + self.output_names = output_names + self.input_mean = 127.5 + self.input_std = 128.0 + #print(self.output_names) + #assert len(outputs)==10 or len(outputs)==15 + self.use_kps = False + self._anchor_ratio = 1.0 + self._num_anchors = 1 + if len(outputs)==6: + self.fmc = 3 + self._feat_stride_fpn = [8, 16, 32] + self._num_anchors = 2 + elif len(outputs)==9: + self.fmc = 3 + self._feat_stride_fpn = [8, 16, 32] + self._num_anchors = 2 + self.use_kps = True + elif len(outputs)==10: + self.fmc = 5 + self._feat_stride_fpn = [8, 16, 32, 64, 128] + self._num_anchors = 1 + elif len(outputs)==15: + self.fmc = 5 + self._feat_stride_fpn = [8, 16, 32, 64, 128] + self._num_anchors = 1 + self.use_kps = True + + def prepare(self, ctx_id, **kwargs): + if ctx_id<0: + self.session.set_providers(['CPUExecutionProvider']) + nms_thresh = kwargs.get('nms_thresh', None) + if nms_thresh is not None: + self.nms_thresh = nms_thresh + det_thresh = kwargs.get('det_thresh', None) + if det_thresh is not None: + self.det_thresh = det_thresh + input_size = kwargs.get('input_size', None) + if input_size is not None: + if self.static_input_size is not None: + self.input_size = self.static_input_size + self.input_sizes = [self.static_input_size] + else: + self.input_sizes = self._normalize_input_sizes(input_size) + self.input_size = self.input_sizes[-1] + self._debug_det_size_printed = False + + def forward(self, img, threshold): + scores_list = [] + bboxes_list = [] + kpss_list = [] + input_size = tuple(img.shape[0:2][::-1]) + blob = cv2.dnn.blobFromImage(img, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True) + net_outs = self.session.run(self.output_names, {self.input_name : blob}) + + input_height = blob.shape[2] + input_width = blob.shape[3] + fmc = self.fmc + for idx, stride in enumerate(self._feat_stride_fpn): + scores = net_outs[idx] + bbox_preds = net_outs[idx+fmc] + bbox_preds = bbox_preds * stride + if self.use_kps: + kps_preds = net_outs[idx+fmc*2] * stride + height = input_height // stride + width = input_width // stride + K = height * width + key = (height, width, stride) + if key in self.center_cache: + anchor_centers = self.center_cache[key] + else: + #solution-1, c style: + #anchor_centers = np.zeros( (height, width, 2), dtype=np.float32 ) + #for i in range(height): + # anchor_centers[i, :, 1] = i + #for i in range(width): + # anchor_centers[:, i, 0] = i + + #solution-2: + #ax = np.arange(width, dtype=np.float32) + #ay = np.arange(height, dtype=np.float32) + #xv, yv = np.meshgrid(np.arange(width), np.arange(height)) + #anchor_centers = np.stack([xv, yv], axis=-1).astype(np.float32) + + #solution-3: + anchor_centers = np.stack(np.mgrid[:height, :width][::-1], axis=-1).astype(np.float32) + #print(anchor_centers.shape) + + anchor_centers = (anchor_centers * stride).reshape( (-1, 2) ) + if self._num_anchors>1: + anchor_centers = np.stack([anchor_centers]*self._num_anchors, axis=1).reshape( (-1,2) ) + if len(self.center_cache)<100: + self.center_cache[key] = anchor_centers + + pos_inds = np.where(scores>=threshold)[0] + bboxes = distance2bbox(anchor_centers, bbox_preds) + pos_scores = scores[pos_inds] + pos_bboxes = bboxes[pos_inds] + scores_list.append(pos_scores) + bboxes_list.append(pos_bboxes) + if self.use_kps: + kpss = distance2kps(anchor_centers, kps_preds) + #kpss = kps_preds + kpss = kpss.reshape( (kpss.shape[0], -1, 2) ) + pos_kpss = kpss[pos_inds] + kpss_list.append(pos_kpss) + return scores_list, bboxes_list, kpss_list + + def detect(self, img, input_size = None, max_num=0, metric='default'): + input_sizes = self._resolve_input_sizes(input_size) + assert input_sizes + pre_det_list = [] + kpss_det_list = [] + for input_size in input_sizes: + pre_det, kpss = self._detect_candidates(img, input_size) + if pre_det.shape[0] == 0: + continue + pre_det_list.append(pre_det) + if self.use_kps and kpss is not None: + kpss_det_list.append(kpss) + if not pre_det_list: + det = np.empty((0, 5), dtype=np.float32) + kpss = np.empty((0, 5, 2), dtype=np.float32) if self.use_kps else None + return det, kpss + pre_det = np.vstack(pre_det_list).astype(np.float32, copy=False) + order = pre_det[:, 4].argsort()[::-1] + pre_det = pre_det[order, :] + if self.use_kps and len(kpss_det_list) == len(pre_det_list): + kpss = np.vstack(kpss_det_list)[order, :, :] + else: + kpss = None + keep = self.nms(pre_det) + det = pre_det[keep, :] + if kpss is not None: + kpss = kpss[keep, :, :] + if max_num > 0 and det.shape[0] > max_num: + area = (det[:, 2] - det[:, 0]) * (det[:, 3] - + det[:, 1]) + img_center = img.shape[0] // 2, img.shape[1] // 2 + offsets = np.vstack([ + (det[:, 0] + det[:, 2]) / 2 - img_center[1], + (det[:, 1] + det[:, 3]) / 2 - img_center[0] + ]) + offset_dist_squared = np.sum(np.power(offsets, 2.0), 0) + if metric=='max': + values = area + else: + values = area - offset_dist_squared * 2.0 # some extra weight on the centering + bindex = np.argsort( + values)[::-1] # some extra weight on the centering + bindex = bindex[0:max_num] + det = det[bindex, :] + if kpss is not None: + kpss = kpss[bindex, :] + return det, kpss + + def _detect_candidates(self, img, input_size): + im_ratio = float(img.shape[0]) / img.shape[1] + model_ratio = float(input_size[1]) / input_size[0] + if im_ratio>model_ratio: + new_height = input_size[1] + new_width = int(new_height / im_ratio) + else: + new_width = input_size[0] + new_height = int(new_width * im_ratio) + det_scale = float(new_height) / img.shape[0] + resized_img = cv2.resize(img, (new_width, new_height)) + det_img = np.zeros( (input_size[1], input_size[0], 3), dtype=np.uint8 ) + det_img[:new_height, :new_width, :] = resized_img + + scores_list, bboxes_list, kpss_list = self.forward(det_img, self.det_thresh) + + if len(scores_list) == 0 or sum(score.size for score in scores_list) == 0: + kps_shape = (0, 5, 2) if self.use_kps else None + return np.empty((0, 5), dtype=np.float32), np.empty(kps_shape, dtype=np.float32) if kps_shape else None + scores = np.vstack(scores_list) + scores_ravel = scores.ravel() + order = scores_ravel.argsort()[::-1] + bboxes = np.vstack(bboxes_list) / det_scale + if self.use_kps: + kpss = np.vstack(kpss_list) / det_scale + pre_det = np.hstack((bboxes, scores)).astype(np.float32, copy=False) + pre_det = pre_det[order, :] + if self.use_kps: + kpss = kpss[order,:,:] + else: + kpss = None + return pre_det, kpss + + def _resolve_input_sizes(self, input_size): + if input_size is not None: + return self._normalize_input_sizes(input_size) + if self.input_sizes: + return list(self.input_sizes) + if self.input_size is not None: + return [self.input_size] + return [] + + @staticmethod + def _normalize_input_sizes(input_size): + if input_size is None: + return [] + if isinstance(input_size, np.ndarray): + input_size = input_size.tolist() + if ( + isinstance(input_size, (list, tuple)) + and len(input_size) > 0 + and isinstance(input_size[0], (list, tuple, np.ndarray)) + ): + values = input_size + else: + values = [input_size] + sizes = [] + for item in values: + if isinstance(item, np.ndarray): + item = item.tolist() + if len(item) != 2: + raise ValueError('det_size must be a pair or a list of pairs') + width, height = int(item[0]), int(item[1]) + if width <= 0 or height <= 0: + raise ValueError('det_size values must be positive') + size = (width, height) + if size not in sizes: + sizes.append(size) + return sizes + + def nms(self, dets): + thresh = self.nms_thresh + x1 = dets[:, 0] + y1 = dets[:, 1] + x2 = dets[:, 2] + y2 = dets[:, 3] + scores = dets[:, 4] + + areas = (x2 - x1 + 1) * (y2 - y1 + 1) + order = scores.argsort()[::-1] + + keep = [] + while order.size > 0: + i = order[0] + keep.append(i) + xx1 = np.maximum(x1[i], x1[order[1:]]) + yy1 = np.maximum(y1[i], y1[order[1:]]) + xx2 = np.minimum(x2[i], x2[order[1:]]) + yy2 = np.minimum(y2[i], y2[order[1:]]) + + w = np.maximum(0.0, xx2 - xx1 + 1) + h = np.maximum(0.0, yy2 - yy1 + 1) + inter = w * h + ovr = inter / (areas[i] + areas[order[1:]] - inter) + + inds = np.where(ovr <= thresh)[0] + order = order[inds + 1] + + return keep + +def get_retinaface(name, download=False, root='~/.insightface/models', **kwargs): + if not download: + assert os.path.exists(name) + return RetinaFace(name) + else: + from .model_store import get_model_file + _file = get_model_file("retinaface_%s" % name, root=root) + return retinaface(_file) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/scrfd.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/scrfd.py new file mode 100644 index 0000000000000000000000000000000000000000..32015ad908cc35f5ef573e58461816e58c40ecdc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/model_zoo/scrfd.py @@ -0,0 +1,424 @@ +# -*- coding: utf-8 -*- +# @Organization : insightface.ai +# @Author : Jia Guo +# @Time : 2021-05-04 +# @Function : + +from __future__ import division +import datetime +import numpy as np +import onnx +import onnxruntime +import os +import os.path as osp +import cv2 +import sys + +DEFAULT_DET_SIZES = [(128, 128), (640, 640)] + + +def softmax(z): + assert len(z.shape) == 2 + s = np.max(z, axis=1) + s = s[:, np.newaxis] # necessary step to do broadcasting + e_x = np.exp(z - s) + div = np.sum(e_x, axis=1) + div = div[:, np.newaxis] # dito + return e_x / div + +def distance2bbox(points, distance, max_shape=None): + """Decode distance prediction to bounding box. + + Args: + points (Tensor): Shape (n, 2), [x, y]. + distance (Tensor): Distance from the given point to 4 + boundaries (left, top, right, bottom). + max_shape (tuple): Shape of the image. + + Returns: + Tensor: Decoded bboxes. + """ + x1 = points[:, 0] - distance[:, 0] + y1 = points[:, 1] - distance[:, 1] + x2 = points[:, 0] + distance[:, 2] + y2 = points[:, 1] + distance[:, 3] + if max_shape is not None: + x1 = x1.clamp(min=0, max=max_shape[1]) + y1 = y1.clamp(min=0, max=max_shape[0]) + x2 = x2.clamp(min=0, max=max_shape[1]) + y2 = y2.clamp(min=0, max=max_shape[0]) + return np.stack([x1, y1, x2, y2], axis=-1) + +def distance2kps(points, distance, max_shape=None): + """Decode distance prediction to bounding box. + + Args: + points (Tensor): Shape (n, 2), [x, y]. + distance (Tensor): Distance from the given point to 4 + boundaries (left, top, right, bottom). + max_shape (tuple): Shape of the image. + + Returns: + Tensor: Decoded bboxes. + """ + preds = [] + for i in range(0, distance.shape[1], 2): + px = points[:, i%2] + distance[:, i] + py = points[:, i%2+1] + distance[:, i+1] + if max_shape is not None: + px = px.clamp(min=0, max=max_shape[1]) + py = py.clamp(min=0, max=max_shape[0]) + preds.append(px) + preds.append(py) + return np.stack(preds, axis=-1) + +class SCRFD: + def __init__(self, model_file=None, session=None): + import onnxruntime + self.model_file = model_file + self.session = session + self.taskname = 'detection' + self.batched = False + if self.session is None: + assert self.model_file is not None + assert osp.exists(self.model_file) + self.session = onnxruntime.InferenceSession(self.model_file, None) + self.center_cache = {} + self.nms_thresh = 0.4 + self.det_thresh = 0.5 + self._init_vars() + + def _init_vars(self): + input_cfg = self.session.get_inputs()[0] + input_shape = input_cfg.shape + #print(input_shape) + if isinstance(input_shape[2], str): + self.static_input_size = None + else: + self.static_input_size = tuple(input_shape[2:4][::-1]) + self.input_size = self.static_input_size if self.static_input_size is not None else DEFAULT_DET_SIZES[-1] + self.input_sizes = [self.static_input_size] if self.static_input_size is not None else list(DEFAULT_DET_SIZES) + self._debug_det_size_printed = False + #print('image_size:', self.image_size) + input_name = input_cfg.name + self.input_shape = input_shape + outputs = self.session.get_outputs() + if len(outputs[0].shape) == 3: + self.batched = True + output_names = [] + for o in outputs: + output_names.append(o.name) + self.input_name = input_name + self.output_names = output_names + self.input_mean = 127.5 + self.input_std = 128.0 + #print(self.output_names) + #assert len(outputs)==10 or len(outputs)==15 + self.use_kps = False + self._anchor_ratio = 1.0 + self._num_anchors = 1 + if len(outputs)==6: + self.fmc = 3 + self._feat_stride_fpn = [8, 16, 32] + self._num_anchors = 2 + elif len(outputs)==9: + self.fmc = 3 + self._feat_stride_fpn = [8, 16, 32] + self._num_anchors = 2 + self.use_kps = True + elif len(outputs)==10: + self.fmc = 5 + self._feat_stride_fpn = [8, 16, 32, 64, 128] + self._num_anchors = 1 + elif len(outputs)==15: + self.fmc = 5 + self._feat_stride_fpn = [8, 16, 32, 64, 128] + self._num_anchors = 1 + self.use_kps = True + + def prepare(self, ctx_id, **kwargs): + if ctx_id<0: + self.session.set_providers(['CPUExecutionProvider']) + nms_thresh = kwargs.get('nms_thresh', None) + if nms_thresh is not None: + self.nms_thresh = nms_thresh + det_thresh = kwargs.get('det_thresh', None) + if det_thresh is not None: + self.det_thresh = det_thresh + input_size = kwargs.get('input_size', None) + if input_size is not None: + if self.static_input_size is not None: + self.input_size = self.static_input_size + self.input_sizes = [self.static_input_size] + else: + self.input_sizes = self._normalize_input_sizes(input_size) + self.input_size = self.input_sizes[-1] + self._debug_det_size_printed = False + + def forward(self, img, threshold): + scores_list = [] + bboxes_list = [] + kpss_list = [] + input_size = tuple(img.shape[0:2][::-1]) + blob = cv2.dnn.blobFromImage(img, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True) + net_outs = self.session.run(self.output_names, {self.input_name : blob}) + + input_height = blob.shape[2] + input_width = blob.shape[3] + fmc = self.fmc + for idx, stride in enumerate(self._feat_stride_fpn): + # If model support batch dim, take first output + if self.batched: + scores = net_outs[idx][0] + bbox_preds = net_outs[idx + fmc][0] + bbox_preds = bbox_preds * stride + if self.use_kps: + kps_preds = net_outs[idx + fmc * 2][0] * stride + # If model doesn't support batching take output as is + else: + scores = net_outs[idx] + bbox_preds = net_outs[idx + fmc] + bbox_preds = bbox_preds * stride + if self.use_kps: + kps_preds = net_outs[idx + fmc * 2] * stride + + height = input_height // stride + width = input_width // stride + K = height * width + key = (height, width, stride) + if key in self.center_cache: + anchor_centers = self.center_cache[key] + else: + #solution-1, c style: + #anchor_centers = np.zeros( (height, width, 2), dtype=np.float32 ) + #for i in range(height): + # anchor_centers[i, :, 1] = i + #for i in range(width): + # anchor_centers[:, i, 0] = i + + #solution-2: + #ax = np.arange(width, dtype=np.float32) + #ay = np.arange(height, dtype=np.float32) + #xv, yv = np.meshgrid(np.arange(width), np.arange(height)) + #anchor_centers = np.stack([xv, yv], axis=-1).astype(np.float32) + + #solution-3: + anchor_centers = np.stack(np.mgrid[:height, :width][::-1], axis=-1).astype(np.float32) + #print(anchor_centers.shape) + + anchor_centers = (anchor_centers * stride).reshape( (-1, 2) ) + if self._num_anchors>1: + anchor_centers = np.stack([anchor_centers]*self._num_anchors, axis=1).reshape( (-1,2) ) + if len(self.center_cache)<100: + self.center_cache[key] = anchor_centers + + pos_inds = np.where(scores>=threshold)[0] + bboxes = distance2bbox(anchor_centers, bbox_preds) + pos_scores = scores[pos_inds] + pos_bboxes = bboxes[pos_inds] + scores_list.append(pos_scores) + bboxes_list.append(pos_bboxes) + if self.use_kps: + kpss = distance2kps(anchor_centers, kps_preds) + #kpss = kps_preds + kpss = kpss.reshape( (kpss.shape[0], -1, 2) ) + pos_kpss = kpss[pos_inds] + kpss_list.append(pos_kpss) + return scores_list, bboxes_list, kpss_list + + def detect(self, img, input_size = None, max_num=0, metric='default'): + input_sizes = self._resolve_input_sizes(input_size) + assert input_sizes + pre_det_list = [] + kpss_det_list = [] + for input_size in input_sizes: + pre_det, kpss = self._detect_candidates(img, input_size) + if pre_det.shape[0] == 0: + continue + pre_det_list.append(pre_det) + if self.use_kps and kpss is not None: + kpss_det_list.append(kpss) + if not pre_det_list: + det = np.empty((0, 5), dtype=np.float32) + kpss = np.empty((0, 5, 2), dtype=np.float32) if self.use_kps else None + return det, kpss + pre_det = np.vstack(pre_det_list).astype(np.float32, copy=False) + order = pre_det[:, 4].argsort()[::-1] + pre_det = pre_det[order, :] + if self.use_kps and len(kpss_det_list) == len(pre_det_list): + kpss = np.vstack(kpss_det_list)[order, :, :] + else: + kpss = None + keep = self.nms(pre_det) + det = pre_det[keep, :] + if kpss is not None: + kpss = kpss[keep, :, :] + if max_num > 0 and det.shape[0] > max_num: + area = (det[:, 2] - det[:, 0]) * (det[:, 3] - + det[:, 1]) + img_center = img.shape[0] // 2, img.shape[1] // 2 + offsets = np.vstack([ + (det[:, 0] + det[:, 2]) / 2 - img_center[1], + (det[:, 1] + det[:, 3]) / 2 - img_center[0] + ]) + offset_dist_squared = np.sum(np.power(offsets, 2.0), 0) + if metric=='max': + values = area + else: + values = area - offset_dist_squared * 2.0 # some extra weight on the centering + bindex = np.argsort( + values)[::-1] # some extra weight on the centering + bindex = bindex[0:max_num] + det = det[bindex, :] + if kpss is not None: + kpss = kpss[bindex, :] + return det, kpss + + def _detect_candidates(self, img, input_size): + im_ratio = float(img.shape[0]) / img.shape[1] + model_ratio = float(input_size[1]) / input_size[0] + if im_ratio>model_ratio: + new_height = input_size[1] + new_width = int(new_height / im_ratio) + else: + new_width = input_size[0] + new_height = int(new_width * im_ratio) + det_scale = float(new_height) / img.shape[0] + resized_img = cv2.resize(img, (new_width, new_height)) + det_img = np.zeros( (input_size[1], input_size[0], 3), dtype=np.uint8 ) + det_img[:new_height, :new_width, :] = resized_img + + scores_list, bboxes_list, kpss_list = self.forward(det_img, self.det_thresh) + + if len(scores_list) == 0 or sum(score.size for score in scores_list) == 0: + kps_shape = (0, 5, 2) if self.use_kps else None + return np.empty((0, 5), dtype=np.float32), np.empty(kps_shape, dtype=np.float32) if kps_shape else None + scores = np.vstack(scores_list) + scores_ravel = scores.ravel() + order = scores_ravel.argsort()[::-1] + bboxes = np.vstack(bboxes_list) / det_scale + if self.use_kps: + kpss = np.vstack(kpss_list) / det_scale + pre_det = np.hstack((bboxes, scores)).astype(np.float32, copy=False) + pre_det = pre_det[order, :] + if self.use_kps: + kpss = kpss[order,:,:] + else: + kpss = None + return pre_det, kpss + + def _resolve_input_sizes(self, input_size): + if input_size is not None: + return self._normalize_input_sizes(input_size) + if self.input_sizes: + return list(self.input_sizes) + if self.input_size is not None: + return [self.input_size] + return list(DEFAULT_DET_SIZES) + + @staticmethod + def _normalize_input_sizes(input_size): + if input_size is None: + return [] + if isinstance(input_size, np.ndarray): + input_size = input_size.tolist() + if ( + isinstance(input_size, (list, tuple)) + and len(input_size) > 0 + and isinstance(input_size[0], (list, tuple, np.ndarray)) + ): + values = input_size + else: + values = [input_size] + sizes = [] + for item in values: + if isinstance(item, np.ndarray): + item = item.tolist() + if len(item) != 2: + raise ValueError('det_size must be a pair or a list of pairs') + width, height = int(item[0]), int(item[1]) + if width == 0 and height == 0: + for size in DEFAULT_DET_SIZES: + if size not in sizes: + sizes.append(size) + continue + if width <= 0 or height <= 0: + raise ValueError('det_size values must be positive') + size = (width, height) + if size not in sizes: + sizes.append(size) + return sizes + + def nms(self, dets): + thresh = self.nms_thresh + x1 = dets[:, 0] + y1 = dets[:, 1] + x2 = dets[:, 2] + y2 = dets[:, 3] + scores = dets[:, 4] + + areas = (x2 - x1 + 1) * (y2 - y1 + 1) + order = scores.argsort()[::-1] + + keep = [] + while order.size > 0: + i = order[0] + keep.append(i) + xx1 = np.maximum(x1[i], x1[order[1:]]) + yy1 = np.maximum(y1[i], y1[order[1:]]) + xx2 = np.minimum(x2[i], x2[order[1:]]) + yy2 = np.minimum(y2[i], y2[order[1:]]) + + w = np.maximum(0.0, xx2 - xx1 + 1) + h = np.maximum(0.0, yy2 - yy1 + 1) + inter = w * h + ovr = inter / (areas[i] + areas[order[1:]] - inter) + + inds = np.where(ovr <= thresh)[0] + order = order[inds + 1] + + return keep + +def get_scrfd(name, download=False, root='~/.insightface/models', **kwargs): + if not download: + assert os.path.exists(name) + return SCRFD(name) + else: + from .model_store import get_model_file + _file = get_model_file("scrfd_%s" % name, root=root) + return SCRFD(_file) + + +def scrfd_2p5gkps(**kwargs): + return get_scrfd("2p5gkps", download=True, **kwargs) + + +if __name__ == '__main__': + import glob + detector = SCRFD(model_file='./det.onnx') + detector.prepare(-1) + img_paths = ['tests/data/t1.jpg'] + for img_path in img_paths: + img = cv2.imread(img_path) + + for _ in range(1): + ta = datetime.datetime.now() + #bboxes, kpss = detector.detect(img, 0.5, input_size = (640, 640)) + bboxes, kpss = detector.detect(img, 0.5) + tb = datetime.datetime.now() + print('all cost:', (tb-ta).total_seconds()*1000) + print(img_path, bboxes.shape) + if kpss is not None: + print(kpss.shape) + for i in range(bboxes.shape[0]): + bbox = bboxes[i] + x1,y1,x2,y2,score = bbox.astype(int) + cv2.rectangle(img, (x1,y1) , (x2,y2) , (255,0,0) , 2) + if kpss is not None: + kps = kpss[i] + for kp in kps: + kp = kp.astype(int) + cv2.circle(img, tuple(kp) , 1, (0,0,255) , 2) + filename = osp.basename(img_path) + print('output:', filename) + cv2.imwrite(osp.join('outputs', filename), img) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..68b284753ecf951292cf69347f797db4ec1ad41e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/__init__.py @@ -0,0 +1,4 @@ +#import mesh +#import morphable_model +from . import mesh +from . import morphable_model diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4e432960656282c76c1393f63d06c62e3a04c465 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/__init__.py @@ -0,0 +1,15 @@ +#from __future__ import absolute_import +#from cython import mesh_core_cython +#import io +#import vis +#import transform +#import light +#import render + +from .cython import mesh_core_cython +from . import io +from . import vis +from . import transform +from . import light +from . import render + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/io.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/io.py new file mode 100644 index 0000000000000000000000000000000000000000..4bb146012ecd8f78b7485153bafab00af092fe16 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/io.py @@ -0,0 +1,142 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import os +from skimage import io +from time import time + +from .cython import mesh_core_cython + +## TODO +## TODO: c++ version +def read_obj(obj_name): + ''' read mesh + ''' + return 0 + +# ------------------------- write +def write_asc(path, vertices): + ''' + Args: + vertices: shape = (nver, 3) + ''' + if path.split('.')[-1] == 'asc': + np.savetxt(path, vertices) + else: + np.savetxt(path + '.asc', vertices) + +def write_obj_with_colors(obj_name, vertices, triangles, colors): + ''' Save 3D face model with texture represented by colors. + Args: + obj_name: str + vertices: shape = (nver, 3) + triangles: shape = (ntri, 3) + colors: shape = (nver, 3) + ''' + triangles = triangles.copy() + triangles += 1 # meshlab start with 1 + + if obj_name.split('.')[-1] != 'obj': + obj_name = obj_name + '.obj' + + # write obj + with open(obj_name, 'w') as f: + + # write vertices & colors + for i in range(vertices.shape[0]): + # s = 'v {} {} {} \n'.format(vertices[0,i], vertices[1,i], vertices[2,i]) + s = 'v {} {} {} {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2], colors[i, 0], colors[i, 1], colors[i, 2]) + f.write(s) + + # write f: ver ind/ uv ind + [k, ntri] = triangles.shape + for i in range(triangles.shape[0]): + # s = 'f {} {} {}\n'.format(triangles[i, 0], triangles[i, 1], triangles[i, 2]) + s = 'f {} {} {}\n'.format(triangles[i, 2], triangles[i, 1], triangles[i, 0]) + f.write(s) + +## TODO: c++ version +def write_obj_with_texture(obj_name, vertices, triangles, texture, uv_coords): + ''' Save 3D face model with texture represented by texture map. + Ref: https://github.com/patrikhuber/eos/blob/bd00155ebae4b1a13b08bf5a991694d682abbada/include/eos/core/Mesh.hpp + Args: + obj_name: str + vertices: shape = (nver, 3) + triangles: shape = (ntri, 3) + texture: shape = (256,256,3) + uv_coords: shape = (nver, 3) max value<=1 + ''' + if obj_name.split('.')[-1] != 'obj': + obj_name = obj_name + '.obj' + mtl_name = obj_name.replace('.obj', '.mtl') + texture_name = obj_name.replace('.obj', '_texture.png') + + triangles = triangles.copy() + triangles += 1 # mesh lab start with 1 + + # write obj + with open(obj_name, 'w') as f: + # first line: write mtlib(material library) + s = "mtllib {}\n".format(os.path.abspath(mtl_name)) + f.write(s) + + # write vertices + for i in range(vertices.shape[0]): + s = 'v {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2]) + f.write(s) + + # write uv coords + for i in range(uv_coords.shape[0]): + s = 'vt {} {}\n'.format(uv_coords[i,0], 1 - uv_coords[i,1]) + f.write(s) + + f.write("usemtl FaceTexture\n") + + # write f: ver ind/ uv ind + for i in range(triangles.shape[0]): + s = 'f {}/{} {}/{} {}/{}\n'.format(triangles[i,2], triangles[i,2], triangles[i,1], triangles[i,1], triangles[i,0], triangles[i,0]) + f.write(s) + + # write mtl + with open(mtl_name, 'w') as f: + f.write("newmtl FaceTexture\n") + s = 'map_Kd {}\n'.format(os.path.abspath(texture_name)) # map to image + f.write(s) + + # write texture as png + imsave(texture_name, texture) + +# c++ version +def write_obj_with_colors_texture(obj_name, vertices, triangles, colors, texture, uv_coords): + ''' Save 3D face model with texture. + Ref: https://github.com/patrikhuber/eos/blob/bd00155ebae4b1a13b08bf5a991694d682abbada/include/eos/core/Mesh.hpp + Args: + obj_name: str + vertices: shape = (nver, 3) + triangles: shape = (ntri, 3) + colors: shape = (nver, 3) + texture: shape = (256,256,3) + uv_coords: shape = (nver, 3) max value<=1 + ''' + if obj_name.split('.')[-1] != 'obj': + obj_name = obj_name + '.obj' + mtl_name = obj_name.replace('.obj', '.mtl') + texture_name = obj_name.replace('.obj', '_texture.png') + + triangles = triangles.copy() + triangles += 1 # mesh lab start with 1 + + # write obj + vertices, colors, uv_coords = vertices.astype(np.float32).copy(), colors.astype(np.float32).copy(), uv_coords.astype(np.float32).copy() + mesh_core_cython.write_obj_with_colors_texture_core(str.encode(obj_name), str.encode(os.path.abspath(mtl_name)), vertices, triangles, colors, uv_coords, vertices.shape[0], triangles.shape[0], uv_coords.shape[0]) + + # write mtl + with open(mtl_name, 'w') as f: + f.write("newmtl FaceTexture\n") + s = 'map_Kd {}\n'.format(os.path.abspath(texture_name)) # map to image + f.write(s) + + # write texture as png + io.imsave(texture_name, texture) \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/light.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/light.py new file mode 100644 index 0000000000000000000000000000000000000000..5f0da63ed8ec6bbe8a12600e8d0f50cd75860129 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/light.py @@ -0,0 +1,213 @@ +''' +Functions about lighting mesh(changing colors/texture of mesh). +1. add light to colors/texture (shade each vertex) +2. fit light according to colors/texture & image. +''' + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +from .cython import mesh_core_cython + +def get_normal(vertices, triangles): + ''' calculate normal direction in each vertex + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + Returns: + normal: [nver, 3] + ''' + pt0 = vertices[triangles[:, 0], :] # [ntri, 3] + pt1 = vertices[triangles[:, 1], :] # [ntri, 3] + pt2 = vertices[triangles[:, 2], :] # [ntri, 3] + tri_normal = np.cross(pt0 - pt1, pt0 - pt2) # [ntri, 3]. normal of each triangle + + normal = np.zeros_like(vertices, dtype = np.float32).copy() # [nver, 3] + # for i in range(triangles.shape[0]): + # normal[triangles[i, 0], :] = normal[triangles[i, 0], :] + tri_normal[i, :] + # normal[triangles[i, 1], :] = normal[triangles[i, 1], :] + tri_normal[i, :] + # normal[triangles[i, 2], :] = normal[triangles[i, 2], :] + tri_normal[i, :] + mesh_core_cython.get_normal_core(normal, tri_normal.astype(np.float32).copy(), triangles.copy(), triangles.shape[0]) + + # normalize to unit length + mag = np.sum(normal**2, 1) # [nver] + zero_ind = (mag == 0) + mag[zero_ind] = 1; + normal[zero_ind, 0] = np.ones((np.sum(zero_ind))) + + normal = normal/np.sqrt(mag[:,np.newaxis]) + + return normal + +# TODO: test +def add_light_sh(vertices, triangles, colors, sh_coeff): + ''' + In 3d face, usually assume: + 1. The surface of face is Lambertian(reflect only the low frequencies of lighting) + 2. Lighting can be an arbitrary combination of point sources + --> can be expressed in terms of spherical harmonics(omit the lighting coefficients) + I = albedo * (sh(n) x sh_coeff) + + albedo: n x 1 + sh_coeff: 9 x 1 + Y(n) = (1, n_x, n_y, n_z, n_xn_y, n_xn_z, n_yn_z, n_x^2 - n_y^2, 3n_z^2 - 1)': n x 9 + # Y(n) = (1, n_x, n_y, n_z)': n x 4 + + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + colors: [nver, 3] albedo + sh_coeff: [9, 1] spherical harmonics coefficients + + Returns: + lit_colors: [nver, 3] + ''' + assert vertices.shape[0] == colors.shape[0] + nver = vertices.shape[0] + normal = get_normal(vertices, triangles) # [nver, 3] + sh = np.array((np.ones(nver), n[:,0], n[:,1], n[:,2], n[:,0]*n[:,1], n[:,0]*n[:,2], n[:,1]*n[:,2], n[:,0]**2 - n[:,1]**2, 3*(n[:,2]**2) - 1)) # [nver, 9] + ref = sh.dot(sh_coeff) #[nver, 1] + lit_colors = colors*ref + return lit_colors + + +def add_light(vertices, triangles, colors, light_positions = 0, light_intensities = 0): + ''' Gouraud shading. add point lights. + In 3d face, usually assume: + 1. The surface of face is Lambertian(reflect only the low frequencies of lighting) + 2. Lighting can be an arbitrary combination of point sources + 3. No specular (unless skin is oil, 23333) + + Ref: https://cs184.eecs.berkeley.edu/lecture/pipeline + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + light_positions: [nlight, 3] + light_intensities: [nlight, 3] + Returns: + lit_colors: [nver, 3] + ''' + nver = vertices.shape[0] + normals = get_normal(vertices, triangles) # [nver, 3] + + # ambient + # La = ka*Ia + + # diffuse + # Ld = kd*(I/r^2)max(0, nxl) + direction_to_lights = vertices[np.newaxis, :, :] - light_positions[:, np.newaxis, :] # [nlight, nver, 3] + direction_to_lights_n = np.sqrt(np.sum(direction_to_lights**2, axis = 2)) # [nlight, nver] + direction_to_lights = direction_to_lights/direction_to_lights_n[:, :, np.newaxis] + normals_dot_lights = normals[np.newaxis, :, :]*direction_to_lights # [nlight, nver, 3] + normals_dot_lights = np.sum(normals_dot_lights, axis = 2) # [nlight, nver] + diffuse_output = colors[np.newaxis, :, :]*normals_dot_lights[:, :, np.newaxis]*light_intensities[:, np.newaxis, :] + diffuse_output = np.sum(diffuse_output, axis = 0) # [nver, 3] + + # specular + # h = (v + l)/(|v + l|) bisector + # Ls = ks*(I/r^2)max(0, nxh)^p + # increasing p narrows the reflectionlob + + lit_colors = diffuse_output # only diffuse part here. + lit_colors = np.minimum(np.maximum(lit_colors, 0), 1) + return lit_colors + + + +## TODO. estimate light(sh coeff) +## -------------------------------- estimate. can not use now. +def fit_light(image, vertices, colors, triangles, vis_ind, lamb = 10, max_iter = 3): + [h, w, c] = image.shape + + # surface normal + norm = get_normal(vertices, triangles) + + nver = vertices.shape[1] + + # vertices --> corresponding image pixel + pt2d = vertices[:2, :] + + pt2d[0,:] = np.minimum(np.maximum(pt2d[0,:], 0), w - 1) + pt2d[1,:] = np.minimum(np.maximum(pt2d[1,:], 0), h - 1) + pt2d = np.round(pt2d).astype(np.int32) # 2 x nver + + image_pixel = image[pt2d[1,:], pt2d[0,:], :] # nver x 3 + image_pixel = image_pixel.T # 3 x nver + + # vertices --> corresponding mean texture pixel with illumination + # Spherical Harmonic Basis + harmonic_dim = 9 + nx = norm[0,:]; + ny = norm[1,:]; + nz = norm[2,:]; + harmonic = np.zeros((nver, harmonic_dim)) + + pi = np.pi + harmonic[:,0] = np.sqrt(1/(4*pi)) * np.ones((nver,)); + harmonic[:,1] = np.sqrt(3/(4*pi)) * nx; + harmonic[:,2] = np.sqrt(3/(4*pi)) * ny; + harmonic[:,3] = np.sqrt(3/(4*pi)) * nz; + harmonic[:,4] = 1/2. * np.sqrt(3/(4*pi)) * (2*nz**2 - nx**2 - ny**2); + harmonic[:,5] = 3 * np.sqrt(5/(12*pi)) * (ny*nz); + harmonic[:,6] = 3 * np.sqrt(5/(12*pi)) * (nx*nz); + harmonic[:,7] = 3 * np.sqrt(5/(12*pi)) * (nx*ny); + harmonic[:,8] = 3/2. * np.sqrt(5/(12*pi)) * (nx*nx - ny*ny); + + ''' + I' = sum(albedo * lj * hj) j = 0:9 (albedo = tex) + set A = albedo*h (n x 9) + alpha = lj (9 x 1) + Y = I (n x 1) + Y' = A.dot(alpha) + + opt function: + ||Y - A*alpha|| + lambda*(alpha'*alpha) + result: + A'*(Y - A*alpha) + lambda*alpha = 0 + ==> + (A'*A*alpha - lambda)*alpha = A'*Y + left: 9 x 9 + right: 9 x 1 + ''' + n_vis_ind = len(vis_ind) + n = n_vis_ind*c + + Y = np.zeros((n, 1)) + A = np.zeros((n, 9)) + light = np.zeros((3, 1)) + + for k in range(c): + Y[k*n_vis_ind:(k+1)*n_vis_ind, :] = image_pixel[k, vis_ind][:, np.newaxis] + A[k*n_vis_ind:(k+1)*n_vis_ind, :] = texture[k, vis_ind][:, np.newaxis] * harmonic[vis_ind, :] + Ac = texture[k, vis_ind][:, np.newaxis] + Yc = image_pixel[k, vis_ind][:, np.newaxis] + light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac)) + + for i in range(max_iter): + + Yc = Y.copy() + for k in range(c): + Yc[k*n_vis_ind:(k+1)*n_vis_ind, :] /= light[k] + + # update alpha + equation_left = np.dot(A.T, A) + lamb*np.eye(harmonic_dim); # why + ? + equation_right = np.dot(A.T, Yc) + alpha = np.dot(np.linalg.inv(equation_left), equation_right) + + # update light + for k in range(c): + Ac = A[k*n_vis_ind:(k+1)*n_vis_ind, :].dot(alpha) + Yc = Y[k*n_vis_ind:(k+1)*n_vis_ind, :] + light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac)) + + appearance = np.zeros_like(texture) + for k in range(c): + tmp = np.dot(harmonic*texture[k, :][:, np.newaxis], alpha*light[k]) + appearance[k,:] = tmp.T + + appearance = np.minimum(np.maximum(appearance, 0), 1) + + return appearance + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/render.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/render.py new file mode 100644 index 0000000000000000000000000000000000000000..19957222e7fd3841cf11cc3bdd06630f28509381 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/render.py @@ -0,0 +1,135 @@ +''' +functions about rendering mesh(from 3d obj to 2d image). +only use rasterization render here. +Note that: +1. Generally, render func includes camera, light, raterize. Here no camera and light(I write these in other files) +2. Generally, the input vertices are normalized to [-1,1] and cetered on [0, 0]. (in world space) + Here, the vertices are using image coords, which centers on [w/2, h/2] with the y-axis pointing to oppisite direction. + Means: render here only conducts interpolation.(I just want to make the input flexible) + +Author: Yao Feng +Mail: yaofeng1995@gmail.com +''' +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +from time import time + +from .cython import mesh_core_cython + +def rasterize_triangles(vertices, triangles, h, w): + ''' + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + h: height + w: width + Returns: + depth_buffer: [h, w] saves the depth, here, the bigger the z, the fronter the point. + triangle_buffer: [h, w] saves the tri id(-1 for no triangle). + barycentric_weight: [h, w, 3] saves corresponding barycentric weight. + + # Each triangle has 3 vertices & Each vertex has 3 coordinates x, y, z. + # h, w is the size of rendering + ''' + + # initial + depth_buffer = np.zeros([h, w]) - 999999. #set the initial z to the farest position + triangle_buffer = np.zeros([h, w], dtype = np.int32) - 1 # if tri id = -1, the pixel has no triangle correspondance + barycentric_weight = np.zeros([h, w, 3], dtype = np.float32) # + + vertices = vertices.astype(np.float32).copy() + triangles = triangles.astype(np.int32).copy() + + mesh_core_cython.rasterize_triangles_core( + vertices, triangles, + depth_buffer, triangle_buffer, barycentric_weight, + vertices.shape[0], triangles.shape[0], + h, w) + +def render_colors(vertices, triangles, colors, h, w, c = 3, BG = None): + ''' render mesh with colors + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + colors: [nver, 3] + h: height + w: width + c: channel + BG: background image + Returns: + image: [h, w, c]. rendered image./rendering. + ''' + + # initial + if BG is None: + image = np.zeros((h, w, c), dtype = np.float32) + else: + assert BG.shape[0] == h and BG.shape[1] == w and BG.shape[2] == c + image = BG + depth_buffer = np.zeros([h, w], dtype = np.float32, order = 'C') - 999999. + + # change orders. --> C-contiguous order(column major) + vertices = vertices.astype(np.float32).copy() + triangles = triangles.astype(np.int32).copy() + colors = colors.astype(np.float32).copy() + ### + st = time() + mesh_core_cython.render_colors_core( + image, vertices, triangles, + colors, + depth_buffer, + vertices.shape[0], triangles.shape[0], + h, w, c) + return image + + +def render_texture(vertices, triangles, texture, tex_coords, tex_triangles, h, w, c = 3, mapping_type = 'nearest', BG = None): + ''' render mesh with texture map + Args: + vertices: [3, nver] + triangles: [3, ntri] + texture: [tex_h, tex_w, 3] + tex_coords: [ntexcoords, 3] + tex_triangles: [ntri, 3] + h: height of rendering + w: width of rendering + c: channel + mapping_type: 'bilinear' or 'nearest' + ''' + # initial + if BG is None: + image = np.zeros((h, w, c), dtype = np.float32) + else: + assert BG.shape[0] == h and BG.shape[1] == w and BG.shape[2] == c + image = BG + + depth_buffer = np.zeros([h, w], dtype = np.float32, order = 'C') - 999999. + + tex_h, tex_w, tex_c = texture.shape + if mapping_type == 'nearest': + mt = int(0) + elif mapping_type == 'bilinear': + mt = int(1) + else: + mt = int(0) + + # -> C order + vertices = vertices.astype(np.float32).copy() + triangles = triangles.astype(np.int32).copy() + texture = texture.astype(np.float32).copy() + tex_coords = tex_coords.astype(np.float32).copy() + tex_triangles = tex_triangles.astype(np.int32).copy() + + mesh_core_cython.render_texture_core( + image, vertices, triangles, + texture, tex_coords, tex_triangles, + depth_buffer, + vertices.shape[0], tex_coords.shape[0], triangles.shape[0], + h, w, c, + tex_h, tex_w, tex_c, + mt) + return image + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/transform.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/transform.py new file mode 100644 index 0000000000000000000000000000000000000000..d91b09fae2bcead1ae2f29d8d43831e556494a2f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/transform.py @@ -0,0 +1,383 @@ +''' +Functions about transforming mesh(changing the position: modify vertices). +1. forward: transform(transform, camera, project). +2. backward: estimate transform matrix from correspondences. + +Author: Yao Feng +Mail: yaofeng1995@gmail.com +''' + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import math +from math import cos, sin + +def angle2matrix(angles): + ''' get rotation matrix from three rotation angles(degree). right-handed. + Args: + angles: [3,]. x, y, z angles + x: pitch. positive for looking down. + y: yaw. positive for looking left. + z: roll. positive for tilting head right. + Returns: + R: [3, 3]. rotation matrix. + ''' + x, y, z = np.deg2rad(angles[0]), np.deg2rad(angles[1]), np.deg2rad(angles[2]) + # x + Rx=np.array([[1, 0, 0], + [0, cos(x), -sin(x)], + [0, sin(x), cos(x)]]) + # y + Ry=np.array([[ cos(y), 0, sin(y)], + [ 0, 1, 0], + [-sin(y), 0, cos(y)]]) + # z + Rz=np.array([[cos(z), -sin(z), 0], + [sin(z), cos(z), 0], + [ 0, 0, 1]]) + + R=Rz.dot(Ry.dot(Rx)) + return R.astype(np.float32) + +def angle2matrix_3ddfa(angles): + ''' get rotation matrix from three rotation angles(radian). The same as in 3DDFA. + Args: + angles: [3,]. x, y, z angles + x: pitch. + y: yaw. + z: roll. + Returns: + R: 3x3. rotation matrix. + ''' + # x, y, z = np.deg2rad(angles[0]), np.deg2rad(angles[1]), np.deg2rad(angles[2]) + x, y, z = angles[0], angles[1], angles[2] + + # x + Rx=np.array([[1, 0, 0], + [0, cos(x), sin(x)], + [0, -sin(x), cos(x)]]) + # y + Ry=np.array([[ cos(y), 0, -sin(y)], + [ 0, 1, 0], + [sin(y), 0, cos(y)]]) + # z + Rz=np.array([[cos(z), sin(z), 0], + [-sin(z), cos(z), 0], + [ 0, 0, 1]]) + R = Rx.dot(Ry).dot(Rz) + return R.astype(np.float32) + + +## ------------------------------------------ 1. transform(transform, project, camera). +## ---------- 3d-3d transform. Transform obj in world space +def rotate(vertices, angles): + ''' rotate vertices. + X_new = R.dot(X). X: 3 x 1 + Args: + vertices: [nver, 3]. + rx, ry, rz: degree angles + rx: pitch. positive for looking down + ry: yaw. positive for looking left + rz: roll. positive for tilting head right + Returns: + rotated vertices: [nver, 3] + ''' + R = angle2matrix(angles) + rotated_vertices = vertices.dot(R.T) + + return rotated_vertices + +def similarity_transform(vertices, s, R, t3d): + ''' similarity transform. dof = 7. + 3D: s*R.dot(X) + t + Homo: M = [[sR, t],[0^T, 1]]. M.dot(X) + Args:(float32) + vertices: [nver, 3]. + s: [1,]. scale factor. + R: [3,3]. rotation matrix. + t3d: [3,]. 3d translation vector. + Returns: + transformed vertices: [nver, 3] + ''' + t3d = np.squeeze(np.array(t3d, dtype = np.float32)) + transformed_vertices = s * vertices.dot(R.T) + t3d[np.newaxis, :] + + return transformed_vertices + + +## -------------- Camera. from world space to camera space +# Ref: https://cs184.eecs.berkeley.edu/lecture/transforms-2 +def normalize(x): + epsilon = 1e-12 + norm = np.sqrt(np.sum(x**2, axis = 0)) + norm = np.maximum(norm, epsilon) + return x/norm + +def lookat_camera(vertices, eye, at = None, up = None): + """ 'look at' transformation: from world space to camera space + standard camera space: + camera located at the origin. + looking down negative z-axis. + vertical vector is y-axis. + Xcam = R(X - C) + Homo: [[R, -RC], [0, 1]] + Args: + vertices: [nver, 3] + eye: [3,] the XYZ world space position of the camera. + at: [3,] a position along the center of the camera's gaze. + up: [3,] up direction + Returns: + transformed_vertices: [nver, 3] + """ + if at is None: + at = np.array([0, 0, 0], np.float32) + if up is None: + up = np.array([0, 1, 0], np.float32) + + eye = np.array(eye).astype(np.float32) + at = np.array(at).astype(np.float32) + z_aixs = -normalize(at - eye) # look forward + x_aixs = normalize(np.cross(up, z_aixs)) # look right + y_axis = np.cross(z_aixs, x_aixs) # look up + + R = np.stack((x_aixs, y_axis, z_aixs))#, axis = 0) # 3 x 3 + transformed_vertices = vertices - eye # translation + transformed_vertices = transformed_vertices.dot(R.T) # rotation + return transformed_vertices + +## --------- 3d-2d project. from camera space to image plane +# generally, image plane only keeps x,y channels, here reserve z channel for calculating z-buffer. +def orthographic_project(vertices): + ''' scaled orthographic projection(just delete z) + assumes: variations in depth over the object is small relative to the mean distance from camera to object + x -> x*f/z, y -> x*f/z, z -> f. + for point i,j. zi~=zj. so just delete z + ** often used in face + Homo: P = [[1,0,0,0], [0,1,0,0], [0,0,1,0]] + Args: + vertices: [nver, 3] + Returns: + projected_vertices: [nver, 3] if isKeepZ=True. [nver, 2] if isKeepZ=False. + ''' + return vertices.copy() + +def perspective_project(vertices, fovy, aspect_ratio = 1., near = 0.1, far = 1000.): + ''' perspective projection. + Args: + vertices: [nver, 3] + fovy: vertical angular field of view. degree. + aspect_ratio : width / height of field of view + near : depth of near clipping plane + far : depth of far clipping plane + Returns: + projected_vertices: [nver, 3] + ''' + fovy = np.deg2rad(fovy) + top = near*np.tan(fovy) + bottom = -top + right = top*aspect_ratio + left = -right + + #-- homo + P = np.array([[near/right, 0, 0, 0], + [0, near/top, 0, 0], + [0, 0, -(far+near)/(far-near), -2*far*near/(far-near)], + [0, 0, -1, 0]]) + vertices_homo = np.hstack((vertices, np.ones((vertices.shape[0], 1)))) # [nver, 4] + projected_vertices = vertices_homo.dot(P.T) + projected_vertices = projected_vertices/projected_vertices[:,3:] + projected_vertices = projected_vertices[:,:3] + projected_vertices[:,2] = -projected_vertices[:,2] + + #-- non homo. only fovy + # projected_vertices = vertices.copy() + # projected_vertices[:,0] = -(near/right)*vertices[:,0]/vertices[:,2] + # projected_vertices[:,1] = -(near/top)*vertices[:,1]/vertices[:,2] + return projected_vertices + + +def to_image(vertices, h, w, is_perspective = False): + ''' change vertices to image coord system + 3d system: XYZ, center(0, 0, 0) + 2d image: x(u), y(v). center(w/2, h/2), flip y-axis. + Args: + vertices: [nver, 3] + h: height of the rendering + w : width of the rendering + Returns: + projected_vertices: [nver, 3] + ''' + image_vertices = vertices.copy() + if is_perspective: + # if perspective, the projected vertices are normalized to [-1, 1]. so change it to image size first. + image_vertices[:,0] = image_vertices[:,0]*w/2 + image_vertices[:,1] = image_vertices[:,1]*h/2 + # move to center of image + image_vertices[:,0] = image_vertices[:,0] + w/2 + image_vertices[:,1] = image_vertices[:,1] + h/2 + # flip vertices along y-axis. + image_vertices[:,1] = h - image_vertices[:,1] - 1 + return image_vertices + + +#### -------------------------------------------2. estimate transform matrix from correspondences. +def estimate_affine_matrix_3d23d(X, Y): + ''' Using least-squares solution + Args: + X: [n, 3]. 3d points(fixed) + Y: [n, 3]. corresponding 3d points(moving). Y = PX + Returns: + P_Affine: (3, 4). Affine camera matrix (the third row is [0, 0, 0, 1]). + ''' + X_homo = np.hstack((X, np.ones([X.shape[1],1]))) #n x 4 + P = np.linalg.lstsq(X_homo, Y)[0].T # Affine matrix. 3 x 4 + return P + +def estimate_affine_matrix_3d22d(X, x): + ''' Using Golden Standard Algorithm for estimating an affine camera + matrix P from world to image correspondences. + See Alg.7.2. in MVGCV + Code Ref: https://github.com/patrikhuber/eos/blob/master/include/eos/fitting/affine_camera_estimation.hpp + x_homo = X_homo.dot(P_Affine) + Args: + X: [n, 3]. corresponding 3d points(fixed) + x: [n, 2]. n>=4. 2d points(moving). x = PX + Returns: + P_Affine: [3, 4]. Affine camera matrix + ''' + X = X.T; x = x.T + assert(x.shape[1] == X.shape[1]) + n = x.shape[1] + assert(n >= 4) + + #--- 1. normalization + # 2d points + mean = np.mean(x, 1) # (2,) + x = x - np.tile(mean[:, np.newaxis], [1, n]) + average_norm = np.mean(np.sqrt(np.sum(x**2, 0))) + scale = np.sqrt(2) / average_norm + x = scale * x + + T = np.zeros((3,3), dtype = np.float32) + T[0, 0] = T[1, 1] = scale + T[:2, 2] = -mean*scale + T[2, 2] = 1 + + # 3d points + X_homo = np.vstack((X, np.ones((1, n)))) + mean = np.mean(X, 1) # (3,) + X = X - np.tile(mean[:, np.newaxis], [1, n]) + m = X_homo[:3,:] - X + average_norm = np.mean(np.sqrt(np.sum(X**2, 0))) + scale = np.sqrt(3) / average_norm + X = scale * X + + U = np.zeros((4,4), dtype = np.float32) + U[0, 0] = U[1, 1] = U[2, 2] = scale + U[:3, 3] = -mean*scale + U[3, 3] = 1 + + # --- 2. equations + A = np.zeros((n*2, 8), dtype = np.float32); + X_homo = np.vstack((X, np.ones((1, n)))).T + A[:n, :4] = X_homo + A[n:, 4:] = X_homo + b = np.reshape(x, [-1, 1]) + + # --- 3. solution + p_8 = np.linalg.pinv(A).dot(b) + P = np.zeros((3, 4), dtype = np.float32) + P[0, :] = p_8[:4, 0] + P[1, :] = p_8[4:, 0] + P[-1, -1] = 1 + + # --- 4. denormalization + P_Affine = np.linalg.inv(T).dot(P.dot(U)) + return P_Affine + +def P2sRt(P): + ''' decompositing camera matrix P + Args: + P: (3, 4). Affine Camera Matrix. + Returns: + s: scale factor. + R: (3, 3). rotation matrix. + t: (3,). translation. + ''' + t = P[:, 3] + R1 = P[0:1, :3] + R2 = P[1:2, :3] + s = (np.linalg.norm(R1) + np.linalg.norm(R2))/2.0 + r1 = R1/np.linalg.norm(R1) + r2 = R2/np.linalg.norm(R2) + r3 = np.cross(r1, r2) + + R = np.concatenate((r1, r2, r3), 0) + return s, R, t + +#Ref: https://www.learnopencv.com/rotation-matrix-to-euler-angles/ +def isRotationMatrix(R): + ''' checks if a matrix is a valid rotation matrix(whether orthogonal or not) + ''' + Rt = np.transpose(R) + shouldBeIdentity = np.dot(Rt, R) + I = np.identity(3, dtype = R.dtype) + n = np.linalg.norm(I - shouldBeIdentity) + return n < 1e-6 + +def matrix2angle(R): + ''' get three Euler angles from Rotation Matrix + Args: + R: (3,3). rotation matrix + Returns: + x: pitch + y: yaw + z: roll + ''' + assert(isRotationMatrix) + sy = math.sqrt(R[0,0] * R[0,0] + R[1,0] * R[1,0]) + + singular = sy < 1e-6 + + if not singular : + x = math.atan2(R[2,1] , R[2,2]) + y = math.atan2(-R[2,0], sy) + z = math.atan2(R[1,0], R[0,0]) + else : + x = math.atan2(-R[1,2], R[1,1]) + y = math.atan2(-R[2,0], sy) + z = 0 + + # rx, ry, rz = np.rad2deg(x), np.rad2deg(y), np.rad2deg(z) + rx, ry, rz = x*180/np.pi, y*180/np.pi, z*180/np.pi + return rx, ry, rz + +# def matrix2angle(R): +# ''' compute three Euler angles from a Rotation Matrix. Ref: http://www.gregslabaugh.net/publications/euler.pdf +# Args: +# R: (3,3). rotation matrix +# Returns: +# x: yaw +# y: pitch +# z: roll +# ''' +# # assert(isRotationMatrix(R)) + +# if R[2,0] !=1 or R[2,0] != -1: +# x = math.asin(R[2,0]) +# y = math.atan2(R[2,1]/cos(x), R[2,2]/cos(x)) +# z = math.atan2(R[1,0]/cos(x), R[0,0]/cos(x)) + +# else:# Gimbal lock +# z = 0 #can be anything +# if R[2,0] == -1: +# x = np.pi/2 +# y = z + math.atan2(R[0,1], R[0,2]) +# else: +# x = -np.pi/2 +# y = -z + math.atan2(-R[0,1], -R[0,2]) + +# return x, y, z \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/vis.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/vis.py new file mode 100644 index 0000000000000000000000000000000000000000..9db972f2c463a310fa4abde16d6a7baf02797c90 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh/vis.py @@ -0,0 +1,24 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import matplotlib.pyplot as plt +from skimage import measure +from mpl_toolkits.mplot3d import Axes3D + +def plot_mesh(vertices, triangles, subplot = [1,1,1], title = 'mesh', el = 90, az = -90, lwdt=.1, dist = 6, color = "grey"): + ''' + plot the mesh + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + ''' + ax = plt.subplot(subplot[0], subplot[1], subplot[2], projection = '3d') + ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2], triangles = triangles, lw = lwdt, color = color, alpha = 1) + ax.axis("off") + ax.view_init(elev = el, azim = az) + ax.dist = dist + plt.title(title) + +### -------------- Todo: use vtk to visualize mesh? or visvis? or VisPy? diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..65d503903b8bec3ab20bd1915618dbd467710207 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/__init__.py @@ -0,0 +1,10 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from . import io +from . import vis +from . import transform +from . import light +from . import render + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/io.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/io.py new file mode 100644 index 0000000000000000000000000000000000000000..0e48a76d21689c6f3b85cb1aa9ad6123058b3816 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/io.py @@ -0,0 +1,170 @@ +''' io: read&write mesh +1. read obj as array(TODO) +2. write arrays to obj + +Preparation knowledge: +representations of 3d face: mesh, point cloud... +storage format: obj, ply, bin, asc, mat... +''' + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import os +from skimage import io + +## TODO +## TODO: c++ version +def read_obj(obj_name): + ''' read mesh + ''' + return 0 + +# ------------------------- write +def write_asc(path, vertices): + ''' + Args: + vertices: shape = (nver, 3) + ''' + if path.split('.')[-1] == 'asc': + np.savetxt(path, vertices) + else: + np.savetxt(path + '.asc', vertices) + +def write_obj_with_colors(obj_name, vertices, triangles, colors): + ''' Save 3D face model with texture represented by colors. + Args: + obj_name: str + vertices: shape = (nver, 3) + triangles: shape = (ntri, 3) + colors: shape = (nver, 3) + ''' + triangles = triangles.copy() + triangles += 1 # meshlab start with 1 + + if obj_name.split('.')[-1] != 'obj': + obj_name = obj_name + '.obj' + + # write obj + with open(obj_name, 'w') as f: + + # write vertices & colors + for i in range(vertices.shape[0]): + # s = 'v {} {} {} \n'.format(vertices[0,i], vertices[1,i], vertices[2,i]) + s = 'v {} {} {} {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2], colors[i, 0], colors[i, 1], colors[i, 2]) + f.write(s) + + # write f: ver ind/ uv ind + [k, ntri] = triangles.shape + for i in range(triangles.shape[0]): + # s = 'f {} {} {}\n'.format(triangles[i, 0], triangles[i, 1], triangles[i, 2]) + s = 'f {} {} {}\n'.format(triangles[i, 2], triangles[i, 1], triangles[i, 0]) + f.write(s) + +## TODO: c++ version +def write_obj_with_texture(obj_name, vertices, triangles, texture, uv_coords): + ''' Save 3D face model with texture represented by texture map. + Ref: https://github.com/patrikhuber/eos/blob/bd00155ebae4b1a13b08bf5a991694d682abbada/include/eos/core/Mesh.hpp + Args: + obj_name: str + vertices: shape = (nver, 3) + triangles: shape = (ntri, 3) + texture: shape = (256,256,3) + uv_coords: shape = (nver, 3) max value<=1 + ''' + if obj_name.split('.')[-1] != 'obj': + obj_name = obj_name + '.obj' + mtl_name = obj_name.replace('.obj', '.mtl') + texture_name = obj_name.replace('.obj', '_texture.png') + + triangles = triangles.copy() + triangles += 1 # mesh lab start with 1 + + # write obj + with open(obj_name, 'w') as f: + # first line: write mtlib(material library) + s = "mtllib {}\n".format(os.path.abspath(mtl_name)) + f.write(s) + + # write vertices + for i in range(vertices.shape[0]): + s = 'v {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2]) + f.write(s) + + # write uv coords + for i in range(uv_coords.shape[0]): + # s = 'vt {} {}\n'.format(uv_coords[i,0], 1 - uv_coords[i,1]) + s = 'vt {} {}\n'.format(uv_coords[i,0], uv_coords[i,1]) + f.write(s) + + f.write("usemtl FaceTexture\n") + + # write f: ver ind/ uv ind + for i in range(triangles.shape[0]): + s = 'f {}/{} {}/{} {}/{}\n'.format(triangles[i,2], triangles[i,2], triangles[i,1], triangles[i,1], triangles[i,0], triangles[i,0]) + f.write(s) + + # write mtl + with open(mtl_name, 'w') as f: + f.write("newmtl FaceTexture\n") + s = 'map_Kd {}\n'.format(os.path.abspath(texture_name)) # map to image + f.write(s) + + # write texture as png + imsave(texture_name, texture) + + +def write_obj_with_colors_texture(obj_name, vertices, triangles, colors, texture, uv_coords): + ''' Save 3D face model with texture. + Ref: https://github.com/patrikhuber/eos/blob/bd00155ebae4b1a13b08bf5a991694d682abbada/include/eos/core/Mesh.hpp + Args: + obj_name: str + vertices: shape = (nver, 3) + triangles: shape = (ntri, 3) + colors: shape = (nver, 3) + texture: shape = (256,256,3) + uv_coords: shape = (nver, 3) max value<=1 + ''' + if obj_name.split('.')[-1] != 'obj': + obj_name = obj_name + '.obj' + mtl_name = obj_name.replace('.obj', '.mtl') + texture_name = obj_name.replace('.obj', '_texture.png') + + triangles = triangles.copy() + triangles += 1 # mesh lab start with 1 + + # write obj + with open(obj_name, 'w') as f: + # first line: write mtlib(material library) + s = "mtllib {}\n".format(os.path.abspath(mtl_name)) + f.write(s) + + # write vertices + for i in range(vertices.shape[0]): + s = 'v {} {} {} {} {} {}\n'.format(vertices[i, 0], vertices[i, 1], vertices[i, 2], colors[i, 0], colors[i, 1], colors[i, 2]) + f.write(s) + + # write uv coords + for i in range(uv_coords.shape[0]): + # s = 'vt {} {}\n'.format(uv_coords[i,0], 1 - uv_coords[i,1]) + s = 'vt {} {}\n'.format(uv_coords[i,0], uv_coords[i,1]) + f.write(s) + + f.write("usemtl FaceTexture\n") + + # write f: ver ind/ uv ind + for i in range(triangles.shape[0]): + # s = 'f {}/{} {}/{} {}/{}\n'.format(triangles[i,0], triangles[i,0], triangles[i,1], triangles[i,1], triangles[i,2], triangles[i,2]) + s = 'f {}/{} {}/{} {}/{}\n'.format(triangles[i,2], triangles[i,2], triangles[i,1], triangles[i,1], triangles[i,0], triangles[i,0]) + f.write(s) + + # write mtl + with open(mtl_name, 'w') as f: + f.write("newmtl FaceTexture\n") + s = 'map_Kd {}\n'.format(os.path.abspath(texture_name)) # map to image + f.write(s) + + # write texture as png + io.imsave(texture_name, texture) \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/light.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/light.py new file mode 100644 index 0000000000000000000000000000000000000000..bde57114bdd57b6e9a2bac59942bfcbfbf17cbe3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/light.py @@ -0,0 +1,215 @@ +''' +Functions about lighting mesh(changing colors/texture of mesh). +1. add light to colors/texture (shade each vertex) +2. fit light according to colors/texture & image. + +Preparation knowledge: +lighting: https://cs184.eecs.berkeley.edu/lecture/pipeline +spherical harmonics in human face: '3D Face Reconstruction from a Single Image Using a Single Reference Face Shape' +''' + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np + +def get_normal(vertices, triangles): + ''' calculate normal direction in each vertex + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + Returns: + normal: [nver, 3] + ''' + pt0 = vertices[triangles[:, 0], :] # [ntri, 3] + pt1 = vertices[triangles[:, 1], :] # [ntri, 3] + pt2 = vertices[triangles[:, 2], :] # [ntri, 3] + tri_normal = np.cross(pt0 - pt1, pt0 - pt2) # [ntri, 3]. normal of each triangle + + normal = np.zeros_like(vertices) # [nver, 3] + for i in range(triangles.shape[0]): + normal[triangles[i, 0], :] = normal[triangles[i, 0], :] + tri_normal[i, :] + normal[triangles[i, 1], :] = normal[triangles[i, 1], :] + tri_normal[i, :] + normal[triangles[i, 2], :] = normal[triangles[i, 2], :] + tri_normal[i, :] + + # normalize to unit length + mag = np.sum(normal**2, 1) # [nver] + zero_ind = (mag == 0) + mag[zero_ind] = 1; + normal[zero_ind, 0] = np.ones((np.sum(zero_ind))) + + normal = normal/np.sqrt(mag[:,np.newaxis]) + + return normal + +# TODO: test +def add_light_sh(vertices, triangles, colors, sh_coeff): + ''' + In 3d face, usually assume: + 1. The surface of face is Lambertian(reflect only the low frequencies of lighting) + 2. Lighting can be an arbitrary combination of point sources + --> can be expressed in terms of spherical harmonics(omit the lighting coefficients) + I = albedo * (sh(n) x sh_coeff) + + albedo: n x 1 + sh_coeff: 9 x 1 + Y(n) = (1, n_x, n_y, n_z, n_xn_y, n_xn_z, n_yn_z, n_x^2 - n_y^2, 3n_z^2 - 1)': n x 9 + # Y(n) = (1, n_x, n_y, n_z)': n x 4 + + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + colors: [nver, 3] albedo + sh_coeff: [9, 1] spherical harmonics coefficients + + Returns: + lit_colors: [nver, 3] + ''' + assert vertices.shape[0] == colors.shape[0] + nver = vertices.shape[0] + normal = get_normal(vertices, triangles) # [nver, 3] + sh = np.array((np.ones(nver), n[:,0], n[:,1], n[:,2], n[:,0]*n[:,1], n[:,0]*n[:,2], n[:,1]*n[:,2], n[:,0]**2 - n[:,1]**2, 3*(n[:,2]**2) - 1)) # [nver, 9] + ref = sh.dot(sh_coeff) #[nver, 1] + lit_colors = colors*ref + return lit_colors + + +def add_light(vertices, triangles, colors, light_positions = 0, light_intensities = 0): + ''' Gouraud shading. add point lights. + In 3d face, usually assume: + 1. The surface of face is Lambertian(reflect only the low frequencies of lighting) + 2. Lighting can be an arbitrary combination of point sources + 3. No specular (unless skin is oil, 23333) + + Ref: https://cs184.eecs.berkeley.edu/lecture/pipeline + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + light_positions: [nlight, 3] + light_intensities: [nlight, 3] + Returns: + lit_colors: [nver, 3] + ''' + nver = vertices.shape[0] + normals = get_normal(vertices, triangles) # [nver, 3] + + # ambient + # La = ka*Ia + + # diffuse + # Ld = kd*(I/r^2)max(0, nxl) + direction_to_lights = vertices[np.newaxis, :, :] - light_positions[:, np.newaxis, :] # [nlight, nver, 3] + direction_to_lights_n = np.sqrt(np.sum(direction_to_lights**2, axis = 2)) # [nlight, nver] + direction_to_lights = direction_to_lights/direction_to_lights_n[:, :, np.newaxis] + normals_dot_lights = normals[np.newaxis, :, :]*direction_to_lights # [nlight, nver, 3] + normals_dot_lights = np.sum(normals_dot_lights, axis = 2) # [nlight, nver] + diffuse_output = colors[np.newaxis, :, :]*normals_dot_lights[:, :, np.newaxis]*light_intensities[:, np.newaxis, :] + diffuse_output = np.sum(diffuse_output, axis = 0) # [nver, 3] + + # specular + # h = (v + l)/(|v + l|) bisector + # Ls = ks*(I/r^2)max(0, nxh)^p + # increasing p narrows the reflectionlob + + lit_colors = diffuse_output # only diffuse part here. + lit_colors = np.minimum(np.maximum(lit_colors, 0), 1) + return lit_colors + + + +## TODO. estimate light(sh coeff) +## -------------------------------- estimate. can not use now. +def fit_light(image, vertices, colors, triangles, vis_ind, lamb = 10, max_iter = 3): + [h, w, c] = image.shape + + # surface normal + norm = get_normal(vertices, triangles) + + nver = vertices.shape[1] + + # vertices --> corresponding image pixel + pt2d = vertices[:2, :] + + pt2d[0,:] = np.minimum(np.maximum(pt2d[0,:], 0), w - 1) + pt2d[1,:] = np.minimum(np.maximum(pt2d[1,:], 0), h - 1) + pt2d = np.round(pt2d).astype(np.int32) # 2 x nver + + image_pixel = image[pt2d[1,:], pt2d[0,:], :] # nver x 3 + image_pixel = image_pixel.T # 3 x nver + + # vertices --> corresponding mean texture pixel with illumination + # Spherical Harmonic Basis + harmonic_dim = 9 + nx = norm[0,:]; + ny = norm[1,:]; + nz = norm[2,:]; + harmonic = np.zeros((nver, harmonic_dim)) + + pi = np.pi + harmonic[:,0] = np.sqrt(1/(4*pi)) * np.ones((nver,)); + harmonic[:,1] = np.sqrt(3/(4*pi)) * nx; + harmonic[:,2] = np.sqrt(3/(4*pi)) * ny; + harmonic[:,3] = np.sqrt(3/(4*pi)) * nz; + harmonic[:,4] = 1/2. * np.sqrt(3/(4*pi)) * (2*nz**2 - nx**2 - ny**2); + harmonic[:,5] = 3 * np.sqrt(5/(12*pi)) * (ny*nz); + harmonic[:,6] = 3 * np.sqrt(5/(12*pi)) * (nx*nz); + harmonic[:,7] = 3 * np.sqrt(5/(12*pi)) * (nx*ny); + harmonic[:,8] = 3/2. * np.sqrt(5/(12*pi)) * (nx*nx - ny*ny); + + ''' + I' = sum(albedo * lj * hj) j = 0:9 (albedo = tex) + set A = albedo*h (n x 9) + alpha = lj (9 x 1) + Y = I (n x 1) + Y' = A.dot(alpha) + + opt function: + ||Y - A*alpha|| + lambda*(alpha'*alpha) + result: + A'*(Y - A*alpha) + lambda*alpha = 0 + ==> + (A'*A*alpha - lambda)*alpha = A'*Y + left: 9 x 9 + right: 9 x 1 + ''' + n_vis_ind = len(vis_ind) + n = n_vis_ind*c + + Y = np.zeros((n, 1)) + A = np.zeros((n, 9)) + light = np.zeros((3, 1)) + + for k in range(c): + Y[k*n_vis_ind:(k+1)*n_vis_ind, :] = image_pixel[k, vis_ind][:, np.newaxis] + A[k*n_vis_ind:(k+1)*n_vis_ind, :] = texture[k, vis_ind][:, np.newaxis] * harmonic[vis_ind, :] + Ac = texture[k, vis_ind][:, np.newaxis] + Yc = image_pixel[k, vis_ind][:, np.newaxis] + light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac)) + + for i in range(max_iter): + + Yc = Y.copy() + for k in range(c): + Yc[k*n_vis_ind:(k+1)*n_vis_ind, :] /= light[k] + + # update alpha + equation_left = np.dot(A.T, A) + lamb*np.eye(harmonic_dim); # why + ? + equation_right = np.dot(A.T, Yc) + alpha = np.dot(np.linalg.inv(equation_left), equation_right) + + # update light + for k in range(c): + Ac = A[k*n_vis_ind:(k+1)*n_vis_ind, :].dot(alpha) + Yc = Y[k*n_vis_ind:(k+1)*n_vis_ind, :] + light[k] = (Ac.T.dot(Yc))/(Ac.T.dot(Ac)) + + appearance = np.zeros_like(texture) + for k in range(c): + tmp = np.dot(harmonic*texture[k, :][:, np.newaxis], alpha*light[k]) + appearance[k,:] = tmp.T + + appearance = np.minimum(np.maximum(appearance, 0), 1) + + return appearance + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/render.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/render.py new file mode 100644 index 0000000000000000000000000000000000000000..eb0d92d31ee98dd17cffc9dd67180107f52340f2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/render.py @@ -0,0 +1,287 @@ +''' +functions about rendering mesh(from 3d obj to 2d image). +only use rasterization render here. +Note that: +1. Generally, render func includes camera, light, raterize. Here no camera and light(I write these in other files) +2. Generally, the input vertices are normalized to [-1,1] and cetered on [0, 0]. (in world space) + Here, the vertices are using image coords, which centers on [w/2, h/2] with the y-axis pointing to oppisite direction. +Means: render here only conducts interpolation.(I just want to make the input flexible) + +Preparation knowledge: +z-buffer: https://cs184.eecs.berkeley.edu/lecture/pipeline + +Author: Yao Feng +Mail: yaofeng1995@gmail.com +''' +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +from time import time + +def isPointInTri(point, tri_points): + ''' Judge whether the point is in the triangle + Method: + http://blackpawn.com/texts/pointinpoly/ + Args: + point: (2,). [u, v] or [x, y] + tri_points: (3 vertices, 2 coords). three vertices(2d points) of a triangle. + Returns: + bool: true for in triangle + ''' + tp = tri_points + + # vectors + v0 = tp[2,:] - tp[0,:] + v1 = tp[1,:] - tp[0,:] + v2 = point - tp[0,:] + + # dot products + dot00 = np.dot(v0.T, v0) + dot01 = np.dot(v0.T, v1) + dot02 = np.dot(v0.T, v2) + dot11 = np.dot(v1.T, v1) + dot12 = np.dot(v1.T, v2) + + # barycentric coordinates + if dot00*dot11 - dot01*dot01 == 0: + inverDeno = 0 + else: + inverDeno = 1/(dot00*dot11 - dot01*dot01) + + u = (dot11*dot02 - dot01*dot12)*inverDeno + v = (dot00*dot12 - dot01*dot02)*inverDeno + + # check if point in triangle + return (u >= 0) & (v >= 0) & (u + v < 1) + +def get_point_weight(point, tri_points): + ''' Get the weights of the position + Methods: https://gamedev.stackexchange.com/questions/23743/whats-the-most-efficient-way-to-find-barycentric-coordinates + -m1.compute the area of the triangles formed by embedding the point P inside the triangle + -m2.Christer Ericson's book "Real-Time Collision Detection". faster.(used) + Args: + point: (2,). [u, v] or [x, y] + tri_points: (3 vertices, 2 coords). three vertices(2d points) of a triangle. + Returns: + w0: weight of v0 + w1: weight of v1 + w2: weight of v3 + ''' + tp = tri_points + # vectors + v0 = tp[2,:] - tp[0,:] + v1 = tp[1,:] - tp[0,:] + v2 = point - tp[0,:] + + # dot products + dot00 = np.dot(v0.T, v0) + dot01 = np.dot(v0.T, v1) + dot02 = np.dot(v0.T, v2) + dot11 = np.dot(v1.T, v1) + dot12 = np.dot(v1.T, v2) + + # barycentric coordinates + if dot00*dot11 - dot01*dot01 == 0: + inverDeno = 0 + else: + inverDeno = 1/(dot00*dot11 - dot01*dot01) + + u = (dot11*dot02 - dot01*dot12)*inverDeno + v = (dot00*dot12 - dot01*dot02)*inverDeno + + w0 = 1 - u - v + w1 = v + w2 = u + + return w0, w1, w2 + +def rasterize_triangles(vertices, triangles, h, w): + ''' + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + h: height + w: width + Returns: + depth_buffer: [h, w] saves the depth, here, the bigger the z, the fronter the point. + triangle_buffer: [h, w] saves the tri id(-1 for no triangle). + barycentric_weight: [h, w, 3] saves corresponding barycentric weight. + + # Each triangle has 3 vertices & Each vertex has 3 coordinates x, y, z. + # h, w is the size of rendering + ''' + # initial + depth_buffer = np.zeros([h, w]) - 999999. #+ np.min(vertices[2,:]) - 999999. # set the initial z to the farest position + triangle_buffer = np.zeros([h, w], dtype = np.int32) - 1 # if tri id = -1, the pixel has no triangle correspondance + barycentric_weight = np.zeros([h, w, 3], dtype = np.float32) # + + for i in range(triangles.shape[0]): + tri = triangles[i, :] # 3 vertex indices + + # the inner bounding box + umin = max(int(np.ceil(np.min(vertices[tri, 0]))), 0) + umax = min(int(np.floor(np.max(vertices[tri, 0]))), w-1) + + vmin = max(int(np.ceil(np.min(vertices[tri, 1]))), 0) + vmax = min(int(np.floor(np.max(vertices[tri, 1]))), h-1) + + if umax depth_buffer[v, u]: + depth_buffer[v, u] = point_depth + triangle_buffer[v, u] = i + barycentric_weight[v, u, :] = np.array([w0, w1, w2]) + + return depth_buffer, triangle_buffer, barycentric_weight + + +def render_colors_ras(vertices, triangles, colors, h, w, c = 3): + ''' render mesh with colors(rasterize triangle first) + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + colors: [nver, 3] + h: height + w: width + c: channel + Returns: + image: [h, w, c]. rendering. + ''' + assert vertices.shape[0] == colors.shape[0] + + depth_buffer, triangle_buffer, barycentric_weight = rasterize_triangles(vertices, triangles, h, w) + + triangle_buffer_flat = np.reshape(triangle_buffer, [-1]) # [h*w] + barycentric_weight_flat = np.reshape(barycentric_weight, [-1, c]) #[h*w, c] + weight = barycentric_weight_flat[:, :, np.newaxis] # [h*w, 3(ver in tri), 1] + + colors_flat = colors[triangles[triangle_buffer_flat, :], :] # [h*w(tri id in pixel), 3(ver in tri), c(color in ver)] + colors_flat = weight*colors_flat # [h*w, 3, 3] + colors_flat = np.sum(colors_flat, 1) #[h*w, 3]. add tri. + + image = np.reshape(colors_flat, [h, w, c]) + # mask = (triangle_buffer[:,:] > -1).astype(np.float32) + # image = image*mask[:,:,np.newaxis] + return image + + +def render_colors(vertices, triangles, colors, h, w, c = 3): + ''' render mesh with colors + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + colors: [nver, 3] + h: height + w: width + Returns: + image: [h, w, c]. + ''' + assert vertices.shape[0] == colors.shape[0] + + # initial + image = np.zeros((h, w, c)) + depth_buffer = np.zeros([h, w]) - 999999. + + for i in range(triangles.shape[0]): + tri = triangles[i, :] # 3 vertex indices + + # the inner bounding box + umin = max(int(np.ceil(np.min(vertices[tri, 0]))), 0) + umax = min(int(np.floor(np.max(vertices[tri, 0]))), w-1) + + vmin = max(int(np.ceil(np.min(vertices[tri, 1]))), 0) + vmax = min(int(np.floor(np.max(vertices[tri, 1]))), h-1) + + if umax depth_buffer[v, u]: + depth_buffer[v, u] = point_depth + image[v, u, :] = w0*colors[tri[0], :] + w1*colors[tri[1], :] + w2*colors[tri[2], :] + return image + + +def render_texture(vertices, triangles, texture, tex_coords, tex_triangles, h, w, c = 3, mapping_type = 'nearest'): + ''' render mesh with texture map + Args: + vertices: [nver], 3 + triangles: [ntri, 3] + texture: [tex_h, tex_w, 3] + tex_coords: [ntexcoords, 3] + tex_triangles: [ntri, 3] + h: height of rendering + w: width of rendering + c: channel + mapping_type: 'bilinear' or 'nearest' + ''' + assert triangles.shape[0] == tex_triangles.shape[0] + tex_h, tex_w, _ = texture.shape + + # initial + image = np.zeros((h, w, c)) + depth_buffer = np.zeros([h, w]) - 999999. + + for i in range(triangles.shape[0]): + tri = triangles[i, :] # 3 vertex indices + tex_tri = tex_triangles[i, :] # 3 tex indice + + # the inner bounding box + umin = max(int(np.ceil(np.min(vertices[tri, 0]))), 0) + umax = min(int(np.floor(np.max(vertices[tri, 0]))), w-1) + + vmin = max(int(np.ceil(np.min(vertices[tri, 1]))), 0) + vmax = min(int(np.floor(np.max(vertices[tri, 1]))), h-1) + + if umax depth_buffer[v, u]: + # update depth + depth_buffer[v, u] = point_depth + + # tex coord + tex_xy = w0*tex_coords[tex_tri[0], :] + w1*tex_coords[tex_tri[1], :] + w2*tex_coords[tex_tri[2], :] + tex_xy[0] = max(min(tex_xy[0], float(tex_w - 1)), 0.0); + tex_xy[1] = max(min(tex_xy[1], float(tex_h - 1)), 0.0); + + # nearest + if mapping_type == 'nearest': + tex_xy = np.round(tex_xy).astype(np.int32) + tex_value = texture[tex_xy[1], tex_xy[0], :] + + # bilinear + elif mapping_type == 'bilinear': + # next 4 pixels + ul = texture[int(np.floor(tex_xy[1])), int(np.floor(tex_xy[0])), :] + ur = texture[int(np.floor(tex_xy[1])), int(np.ceil(tex_xy[0])), :] + dl = texture[int(np.ceil(tex_xy[1])), int(np.floor(tex_xy[0])), :] + dr = texture[int(np.ceil(tex_xy[1])), int(np.ceil(tex_xy[0])), :] + + yd = tex_xy[1] - np.floor(tex_xy[1]) + xd = tex_xy[0] - np.floor(tex_xy[0]) + tex_value = ul*(1-xd)*(1-yd) + ur*xd*(1-yd) + dl*(1-xd)*yd + dr*xd*yd + + image[v, u, :] = tex_value + return image \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/transform.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/transform.py new file mode 100644 index 0000000000000000000000000000000000000000..ab56e370ce6218650b4fa7cd6f503e3ac73be854 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/transform.py @@ -0,0 +1,385 @@ +''' +Functions about transforming mesh(changing the position: modify vertices). +1. forward: transform(transform, camera, project). +2. backward: estimate transform matrix from correspondences. + +Preparation knowledge: +transform&camera model: +https://cs184.eecs.berkeley.edu/lecture/transforms-2 +Part I: camera geometry and single view geometry in MVGCV +''' + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import math +from math import cos, sin + +def angle2matrix(angles): + ''' get rotation matrix from three rotation angles(degree). right-handed. + Args: + angles: [3,]. x, y, z angles + x: pitch. positive for looking down. + y: yaw. positive for looking left. + z: roll. positive for tilting head right. + Returns: + R: [3, 3]. rotation matrix. + ''' + x, y, z = np.deg2rad(angles[0]), np.deg2rad(angles[1]), np.deg2rad(angles[2]) + # x + Rx=np.array([[1, 0, 0], + [0, cos(x), -sin(x)], + [0, sin(x), cos(x)]]) + # y + Ry=np.array([[ cos(y), 0, sin(y)], + [ 0, 1, 0], + [-sin(y), 0, cos(y)]]) + # z + Rz=np.array([[cos(z), -sin(z), 0], + [sin(z), cos(z), 0], + [ 0, 0, 1]]) + + R=Rz.dot(Ry.dot(Rx)) + return R.astype(np.float32) + +def angle2matrix_3ddfa(angles): + ''' get rotation matrix from three rotation angles(radian). The same as in 3DDFA. + Args: + angles: [3,]. x, y, z angles + x: pitch. + y: yaw. + z: roll. + Returns: + R: 3x3. rotation matrix. + ''' + # x, y, z = np.deg2rad(angles[0]), np.deg2rad(angles[1]), np.deg2rad(angles[2]) + x, y, z = angles[0], angles[1], angles[2] + + # x + Rx=np.array([[1, 0, 0], + [0, cos(x), sin(x)], + [0, -sin(x), cos(x)]]) + # y + Ry=np.array([[ cos(y), 0, -sin(y)], + [ 0, 1, 0], + [sin(y), 0, cos(y)]]) + # z + Rz=np.array([[cos(z), sin(z), 0], + [-sin(z), cos(z), 0], + [ 0, 0, 1]]) + R = Rx.dot(Ry).dot(Rz) + return R.astype(np.float32) + + +## ------------------------------------------ 1. transform(transform, project, camera). +## ---------- 3d-3d transform. Transform obj in world space +def rotate(vertices, angles): + ''' rotate vertices. + X_new = R.dot(X). X: 3 x 1 + Args: + vertices: [nver, 3]. + rx, ry, rz: degree angles + rx: pitch. positive for looking down + ry: yaw. positive for looking left + rz: roll. positive for tilting head right + Returns: + rotated vertices: [nver, 3] + ''' + R = angle2matrix(angles) + rotated_vertices = vertices.dot(R.T) + + return rotated_vertices + +def similarity_transform(vertices, s, R, t3d): + ''' similarity transform. dof = 7. + 3D: s*R.dot(X) + t + Homo: M = [[sR, t],[0^T, 1]]. M.dot(X) + Args:(float32) + vertices: [nver, 3]. + s: [1,]. scale factor. + R: [3,3]. rotation matrix. + t3d: [3,]. 3d translation vector. + Returns: + transformed vertices: [nver, 3] + ''' + t3d = np.squeeze(np.array(t3d, dtype = np.float32)) + transformed_vertices = s * vertices.dot(R.T) + t3d[np.newaxis, :] + + return transformed_vertices + + +## -------------- Camera. from world space to camera space +# Ref: https://cs184.eecs.berkeley.edu/lecture/transforms-2 +def normalize(x): + epsilon = 1e-12 + norm = np.sqrt(np.sum(x**2, axis = 0)) + norm = np.maximum(norm, epsilon) + return x/norm + +def lookat_camera(vertices, eye, at = None, up = None): + """ 'look at' transformation: from world space to camera space + standard camera space: + camera located at the origin. + looking down negative z-axis. + vertical vector is y-axis. + Xcam = R(X - C) + Homo: [[R, -RC], [0, 1]] + Args: + vertices: [nver, 3] + eye: [3,] the XYZ world space position of the camera. + at: [3,] a position along the center of the camera's gaze. + up: [3,] up direction + Returns: + transformed_vertices: [nver, 3] + """ + if at is None: + at = np.array([0, 0, 0], np.float32) + if up is None: + up = np.array([0, 1, 0], np.float32) + + eye = np.array(eye).astype(np.float32) + at = np.array(at).astype(np.float32) + z_aixs = -normalize(at - eye) # look forward + x_aixs = normalize(np.cross(up, z_aixs)) # look right + y_axis = np.cross(z_aixs, x_aixs) # look up + + R = np.stack((x_aixs, y_axis, z_aixs))#, axis = 0) # 3 x 3 + transformed_vertices = vertices - eye # translation + transformed_vertices = transformed_vertices.dot(R.T) # rotation + return transformed_vertices + +## --------- 3d-2d project. from camera space to image plane +# generally, image plane only keeps x,y channels, here reserve z channel for calculating z-buffer. +def orthographic_project(vertices): + ''' scaled orthographic projection(just delete z) + assumes: variations in depth over the object is small relative to the mean distance from camera to object + x -> x*f/z, y -> x*f/z, z -> f. + for point i,j. zi~=zj. so just delete z + ** often used in face + Homo: P = [[1,0,0,0], [0,1,0,0], [0,0,1,0]] + Args: + vertices: [nver, 3] + Returns: + projected_vertices: [nver, 3] if isKeepZ=True. [nver, 2] if isKeepZ=False. + ''' + return vertices.copy() + +def perspective_project(vertices, fovy, aspect_ratio = 1., near = 0.1, far = 1000.): + ''' perspective projection. + Args: + vertices: [nver, 3] + fovy: vertical angular field of view. degree. + aspect_ratio : width / height of field of view + near : depth of near clipping plane + far : depth of far clipping plane + Returns: + projected_vertices: [nver, 3] + ''' + fovy = np.deg2rad(fovy) + top = near*np.tan(fovy) + bottom = -top + right = top*aspect_ratio + left = -right + + #-- homo + P = np.array([[near/right, 0, 0, 0], + [0, near/top, 0, 0], + [0, 0, -(far+near)/(far-near), -2*far*near/(far-near)], + [0, 0, -1, 0]]) + vertices_homo = np.hstack((vertices, np.ones((vertices.shape[0], 1)))) # [nver, 4] + projected_vertices = vertices_homo.dot(P.T) + projected_vertices = projected_vertices/projected_vertices[:,3:] + projected_vertices = projected_vertices[:,:3] + projected_vertices[:,2] = -projected_vertices[:,2] + + #-- non homo. only fovy + # projected_vertices = vertices.copy() + # projected_vertices[:,0] = -(near/right)*vertices[:,0]/vertices[:,2] + # projected_vertices[:,1] = -(near/top)*vertices[:,1]/vertices[:,2] + return projected_vertices + + +def to_image(vertices, h, w, is_perspective = False): + ''' change vertices to image coord system + 3d system: XYZ, center(0, 0, 0) + 2d image: x(u), y(v). center(w/2, h/2), flip y-axis. + Args: + vertices: [nver, 3] + h: height of the rendering + w : width of the rendering + Returns: + projected_vertices: [nver, 3] + ''' + image_vertices = vertices.copy() + if is_perspective: + # if perspective, the projected vertices are normalized to [-1, 1]. so change it to image size first. + image_vertices[:,0] = image_vertices[:,0]*w/2 + image_vertices[:,1] = image_vertices[:,1]*h/2 + # move to center of image + image_vertices[:,0] = image_vertices[:,0] + w/2 + image_vertices[:,1] = image_vertices[:,1] + h/2 + # flip vertices along y-axis. + image_vertices[:,1] = h - image_vertices[:,1] - 1 + return image_vertices + + +#### -------------------------------------------2. estimate transform matrix from correspondences. +def estimate_affine_matrix_3d23d(X, Y): + ''' Using least-squares solution + Args: + X: [n, 3]. 3d points(fixed) + Y: [n, 3]. corresponding 3d points(moving). Y = PX + Returns: + P_Affine: (3, 4). Affine camera matrix (the third row is [0, 0, 0, 1]). + ''' + X_homo = np.hstack((X, np.ones([X.shape[1],1]))) #n x 4 + P = np.linalg.lstsq(X_homo, Y)[0].T # Affine matrix. 3 x 4 + return P + +def estimate_affine_matrix_3d22d(X, x): + ''' Using Golden Standard Algorithm for estimating an affine camera + matrix P from world to image correspondences. + See Alg.7.2. in MVGCV + Code Ref: https://github.com/patrikhuber/eos/blob/master/include/eos/fitting/affine_camera_estimation.hpp + x_homo = X_homo.dot(P_Affine) + Args: + X: [n, 3]. corresponding 3d points(fixed) + x: [n, 2]. n>=4. 2d points(moving). x = PX + Returns: + P_Affine: [3, 4]. Affine camera matrix + ''' + X = X.T; x = x.T + assert(x.shape[1] == X.shape[1]) + n = x.shape[1] + assert(n >= 4) + + #--- 1. normalization + # 2d points + mean = np.mean(x, 1) # (2,) + x = x - np.tile(mean[:, np.newaxis], [1, n]) + average_norm = np.mean(np.sqrt(np.sum(x**2, 0))) + scale = np.sqrt(2) / average_norm + x = scale * x + + T = np.zeros((3,3), dtype = np.float32) + T[0, 0] = T[1, 1] = scale + T[:2, 2] = -mean*scale + T[2, 2] = 1 + + # 3d points + X_homo = np.vstack((X, np.ones((1, n)))) + mean = np.mean(X, 1) # (3,) + X = X - np.tile(mean[:, np.newaxis], [1, n]) + m = X_homo[:3,:] - X + average_norm = np.mean(np.sqrt(np.sum(X**2, 0))) + scale = np.sqrt(3) / average_norm + X = scale * X + + U = np.zeros((4,4), dtype = np.float32) + U[0, 0] = U[1, 1] = U[2, 2] = scale + U[:3, 3] = -mean*scale + U[3, 3] = 1 + + # --- 2. equations + A = np.zeros((n*2, 8), dtype = np.float32); + X_homo = np.vstack((X, np.ones((1, n)))).T + A[:n, :4] = X_homo + A[n:, 4:] = X_homo + b = np.reshape(x, [-1, 1]) + + # --- 3. solution + p_8 = np.linalg.pinv(A).dot(b) + P = np.zeros((3, 4), dtype = np.float32) + P[0, :] = p_8[:4, 0] + P[1, :] = p_8[4:, 0] + P[-1, -1] = 1 + + # --- 4. denormalization + P_Affine = np.linalg.inv(T).dot(P.dot(U)) + return P_Affine + +def P2sRt(P): + ''' decompositing camera matrix P + Args: + P: (3, 4). Affine Camera Matrix. + Returns: + s: scale factor. + R: (3, 3). rotation matrix. + t: (3,). translation. + ''' + t = P[:, 3] + R1 = P[0:1, :3] + R2 = P[1:2, :3] + s = (np.linalg.norm(R1) + np.linalg.norm(R2))/2.0 + r1 = R1/np.linalg.norm(R1) + r2 = R2/np.linalg.norm(R2) + r3 = np.cross(r1, r2) + + R = np.concatenate((r1, r2, r3), 0) + return s, R, t + +#Ref: https://www.learnopencv.com/rotation-matrix-to-euler-angles/ +def isRotationMatrix(R): + ''' checks if a matrix is a valid rotation matrix(whether orthogonal or not) + ''' + Rt = np.transpose(R) + shouldBeIdentity = np.dot(Rt, R) + I = np.identity(3, dtype = R.dtype) + n = np.linalg.norm(I - shouldBeIdentity) + return n < 1e-6 + +def matrix2angle(R): + ''' get three Euler angles from Rotation Matrix + Args: + R: (3,3). rotation matrix + Returns: + x: pitch + y: yaw + z: roll + ''' + assert(isRotationMatrix) + sy = math.sqrt(R[0,0] * R[0,0] + R[1,0] * R[1,0]) + + singular = sy < 1e-6 + + if not singular : + x = math.atan2(R[2,1] , R[2,2]) + y = math.atan2(-R[2,0], sy) + z = math.atan2(R[1,0], R[0,0]) + else : + x = math.atan2(-R[1,2], R[1,1]) + y = math.atan2(-R[2,0], sy) + z = 0 + + # rx, ry, rz = np.rad2deg(x), np.rad2deg(y), np.rad2deg(z) + rx, ry, rz = x*180/np.pi, y*180/np.pi, z*180/np.pi + return rx, ry, rz + +# def matrix2angle(R): +# ''' compute three Euler angles from a Rotation Matrix. Ref: http://www.gregslabaugh.net/publications/euler.pdf +# Args: +# R: (3,3). rotation matrix +# Returns: +# x: yaw +# y: pitch +# z: roll +# ''' +# # assert(isRotationMatrix(R)) + +# if R[2,0] !=1 or R[2,0] != -1: +# x = math.asin(R[2,0]) +# y = math.atan2(R[2,1]/cos(x), R[2,2]/cos(x)) +# z = math.atan2(R[1,0]/cos(x), R[0,0]/cos(x)) + +# else:# Gimbal lock +# z = 0 #can be anything +# if R[2,0] == -1: +# x = np.pi/2 +# y = z + math.atan2(R[0,1], R[0,2]) +# else: +# x = -np.pi/2 +# y = -z + math.atan2(-R[0,1], -R[0,2]) + +# return x, y, z \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/vis.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/vis.py new file mode 100644 index 0000000000000000000000000000000000000000..9db972f2c463a310fa4abde16d6a7baf02797c90 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/mesh_numpy/vis.py @@ -0,0 +1,24 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import matplotlib.pyplot as plt +from skimage import measure +from mpl_toolkits.mplot3d import Axes3D + +def plot_mesh(vertices, triangles, subplot = [1,1,1], title = 'mesh', el = 90, az = -90, lwdt=.1, dist = 6, color = "grey"): + ''' + plot the mesh + Args: + vertices: [nver, 3] + triangles: [ntri, 3] + ''' + ax = plt.subplot(subplot[0], subplot[1], subplot[2], projection = '3d') + ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2], triangles = triangles, lw = lwdt, color = color, alpha = 1) + ax.axis("off") + ax.view_init(elev = el, azim = az) + ax.dist = dist + plt.title(title) + +### -------------- Todo: use vtk to visualize mesh? or visvis? or VisPy? diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..19fc6a60231fc08fa728059bfc88db82703b0475 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/__init__.py @@ -0,0 +1,7 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from .. import mesh +from .morphabel_model import MorphabelModel +from . import load \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/fit.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/fit.py new file mode 100644 index 0000000000000000000000000000000000000000..480532c57c1c2824e0652be29d719a22b0ee871a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/fit.py @@ -0,0 +1,272 @@ +''' +Estimating parameters about vertices: shape para, exp para, pose para(s, R, t) +''' +import numpy as np +from .. import mesh + +''' TODO: a clear document. +Given: image_points, 3D Model, Camera Matrix(s, R, t2d) +Estimate: shape parameters, expression parameters + +Inference: + + projected_vertices = s*P*R(mu + shape + exp) + t2d --> image_points + s*P*R*shape + s*P*R(mu + exp) + t2d --> image_poitns + + # Define: + X = vertices + x_hat = projected_vertices + x = image_points + A = s*P*R + b = s*P*R(mu + exp) + t2d + ==> + x_hat = A*shape + b (2 x n) + + A*shape (2 x n) + shape = reshape(shapePC * sp) (3 x n) + shapePC*sp : (3n x 1) + + * flatten: + x_hat_flatten = A*shape + b_flatten (2n x 1) + A*shape (2n x 1) + --> A*shapePC (2n x 199) sp: 199 x 1 + + # Define: + pc_2d = A* reshape(shapePC) + pc_2d_flatten = flatten(pc_2d) (2n x 199) + + =====> + x_hat_flatten = pc_2d_flatten * sp + b_flatten ---> x_flatten (2n x 1) + + Goals: + (ignore flatten, pc_2d-->pc) + min E = || x_hat - x || + lambda*sum(sp/sigma)^2 + = || pc * sp + b - x || + lambda*sum(sp/sigma)^2 + + Solve: + d(E)/d(sp) = 0 + 2 * pc' * (pc * sp + b - x) + 2 * lambda * sp / (sigma' * sigma) = 0 + + Get: + (pc' * pc + lambda / (sigma'* sigma)) * sp = pc' * (x - b) + +''' + +def estimate_shape(x, shapeMU, shapePC, shapeEV, expression, s, R, t2d, lamb = 3000): + ''' + Args: + x: (2, n). image points (to be fitted) + shapeMU: (3n, 1) + shapePC: (3n, n_sp) + shapeEV: (n_sp, 1) + expression: (3, n) + s: scale + R: (3, 3). rotation matrix + t2d: (2,). 2d translation + lambda: regulation coefficient + + Returns: + shape_para: (n_sp, 1) shape parameters(coefficients) + ''' + x = x.copy() + assert(shapeMU.shape[0] == shapePC.shape[0]) + assert(shapeMU.shape[0] == x.shape[1]*3) + + dof = shapePC.shape[1] + + n = x.shape[1] + sigma = shapeEV + t2d = np.array(t2d) + P = np.array([[1, 0, 0], [0, 1, 0]], dtype = np.float32) + A = s*P.dot(R) + + # --- calc pc + pc_3d = np.resize(shapePC.T, [dof, n, 3]) # 199 x n x 3 + pc_3d = np.reshape(pc_3d, [dof*n, 3]) + pc_2d = pc_3d.dot(A.T.copy()) # 199 x n x 2 + + pc = np.reshape(pc_2d, [dof, -1]).T # 2n x 199 + + # --- calc b + # shapeMU + mu_3d = np.resize(shapeMU, [n, 3]).T # 3 x n + # expression + exp_3d = expression + # + b = A.dot(mu_3d + exp_3d) + np.tile(t2d[:, np.newaxis], [1, n]) # 2 x n + b = np.reshape(b.T, [-1, 1]) # 2n x 1 + + # --- solve + equation_left = np.dot(pc.T, pc) + lamb * np.diagflat(1/sigma**2) + x = np.reshape(x.T, [-1, 1]) + equation_right = np.dot(pc.T, x - b) + + shape_para = np.dot(np.linalg.inv(equation_left), equation_right) + + return shape_para + +def estimate_expression(x, shapeMU, expPC, expEV, shape, s, R, t2d, lamb = 2000): + ''' + Args: + x: (2, n). image points (to be fitted) + shapeMU: (3n, 1) + expPC: (3n, n_ep) + expEV: (n_ep, 1) + shape: (3, n) + s: scale + R: (3, 3). rotation matrix + t2d: (2,). 2d translation + lambda: regulation coefficient + + Returns: + exp_para: (n_ep, 1) shape parameters(coefficients) + ''' + x = x.copy() + assert(shapeMU.shape[0] == expPC.shape[0]) + assert(shapeMU.shape[0] == x.shape[1]*3) + + dof = expPC.shape[1] + + n = x.shape[1] + sigma = expEV + t2d = np.array(t2d) + P = np.array([[1, 0, 0], [0, 1, 0]], dtype = np.float32) + A = s*P.dot(R) + + # --- calc pc + pc_3d = np.resize(expPC.T, [dof, n, 3]) + pc_3d = np.reshape(pc_3d, [dof*n, 3]) + pc_2d = pc_3d.dot(A.T) + pc = np.reshape(pc_2d, [dof, -1]).T # 2n x 29 + + # --- calc b + # shapeMU + mu_3d = np.resize(shapeMU, [n, 3]).T # 3 x n + # expression + shape_3d = shape + # + b = A.dot(mu_3d + shape_3d) + np.tile(t2d[:, np.newaxis], [1, n]) # 2 x n + b = np.reshape(b.T, [-1, 1]) # 2n x 1 + + # --- solve + equation_left = np.dot(pc.T, pc) + lamb * np.diagflat(1/sigma**2) + x = np.reshape(x.T, [-1, 1]) + equation_right = np.dot(pc.T, x - b) + + exp_para = np.dot(np.linalg.inv(equation_left), equation_right) + + return exp_para + + +# ---------------- fit +def fit_points(x, X_ind, model, n_sp, n_ep, max_iter = 4): + ''' + Args: + x: (n, 2) image points + X_ind: (n,) corresponding Model vertex indices + model: 3DMM + max_iter: iteration + Returns: + sp: (n_sp, 1). shape parameters + ep: (n_ep, 1). exp parameters + s, R, t + ''' + x = x.copy().T + + #-- init + sp = np.zeros((n_sp, 1), dtype = np.float32) + ep = np.zeros((n_ep, 1), dtype = np.float32) + + #-------------------- estimate + X_ind_all = np.tile(X_ind[np.newaxis, :], [3, 1])*3 + X_ind_all[1, :] += 1 + X_ind_all[2, :] += 2 + valid_ind = X_ind_all.flatten('F') + + shapeMU = model['shapeMU'][valid_ind, :] + shapePC = model['shapePC'][valid_ind, :n_sp] + expPC = model['expPC'][valid_ind, :n_ep] + + for i in range(max_iter): + X = shapeMU + shapePC.dot(sp) + expPC.dot(ep) + X = np.reshape(X, [int(len(X)/3), 3]).T + + #----- estimate pose + P = mesh.transform.estimate_affine_matrix_3d22d(X.T, x.T) + s, R, t = mesh.transform.P2sRt(P) + rx, ry, rz = mesh.transform.matrix2angle(R) + #print('Iter:{}; estimated pose: s {}, rx {}, ry {}, rz {}, t1 {}, t2 {}'.format(i, s, rx, ry, rz, t[0], t[1])) + + #----- estimate shape + # expression + shape = shapePC.dot(sp) + shape = np.reshape(shape, [int(len(shape)/3), 3]).T + ep = estimate_expression(x, shapeMU, expPC, model['expEV'][:n_ep,:], shape, s, R, t[:2], lamb = 20) + + # shape + expression = expPC.dot(ep) + expression = np.reshape(expression, [int(len(expression)/3), 3]).T + if i == 0 : + sp = estimate_shape(x, shapeMU, shapePC, model['shapeEV'][:n_sp,:], expression, s, R, t[:2], lamb = 40) + + return sp, ep, s, R, t + + +# ---------------- fitting process +def fit_points_for_show(x, X_ind, model, n_sp, n_ep, max_iter = 4): + ''' + Args: + x: (n, 2) image points + X_ind: (n,) corresponding Model vertex indices + model: 3DMM + max_iter: iteration + Returns: + sp: (n_sp, 1). shape parameters + ep: (n_ep, 1). exp parameters + s, R, t + ''' + x = x.copy().T + + #-- init + sp = np.zeros((n_sp, 1), dtype = np.float32) + ep = np.zeros((n_ep, 1), dtype = np.float32) + + #-------------------- estimate + X_ind_all = np.tile(X_ind[np.newaxis, :], [3, 1])*3 + X_ind_all[1, :] += 1 + X_ind_all[2, :] += 2 + valid_ind = X_ind_all.flatten('F') + + shapeMU = model['shapeMU'][valid_ind, :] + shapePC = model['shapePC'][valid_ind, :n_sp] + expPC = model['expPC'][valid_ind, :n_ep] + + s = 4e-04 + R = mesh.transform.angle2matrix([0, 0, 0]) + t = [0, 0, 0] + lsp = []; lep = []; ls = []; lR = []; lt = [] + for i in range(max_iter): + X = shapeMU + shapePC.dot(sp) + expPC.dot(ep) + X = np.reshape(X, [int(len(X)/3), 3]).T + lsp.append(sp); lep.append(ep); ls.append(s), lR.append(R), lt.append(t) + + #----- estimate pose + P = mesh.transform.estimate_affine_matrix_3d22d(X.T, x.T) + s, R, t = mesh.transform.P2sRt(P) + lsp.append(sp); lep.append(ep); ls.append(s), lR.append(R), lt.append(t) + + #----- estimate shape + # expression + shape = shapePC.dot(sp) + shape = np.reshape(shape, [int(len(shape)/3), 3]).T + ep = estimate_expression(x, shapeMU, expPC, model['expEV'][:n_ep,:], shape, s, R, t[:2], lamb = 20) + lsp.append(sp); lep.append(ep); ls.append(s), lR.append(R), lt.append(t) + + # shape + expression = expPC.dot(ep) + expression = np.reshape(expression, [int(len(expression)/3), 3]).T + sp = estimate_shape(x, shapeMU, shapePC, model['shapeEV'][:n_sp,:], expression, s, R, t[:2], lamb = 40) + + # print('ls', ls) + # print('lR', lR) + return np.array(lsp), np.array(lep), np.array(ls), np.array(lR), np.array(lt) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/load.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/load.py new file mode 100644 index 0000000000000000000000000000000000000000..0b80665bde45447139ec3a4c066a9677ce8322b0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/load.py @@ -0,0 +1,110 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import scipy.io as sio + +### --------------------------------- load BFM data +def load_BFM(model_path): + ''' load BFM 3DMM model + Args: + model_path: path to BFM model. + Returns: + model: (nver = 53215, ntri = 105840). nver: number of vertices. ntri: number of triangles. + 'shapeMU': [3*nver, 1] + 'shapePC': [3*nver, 199] + 'shapeEV': [199, 1] + 'expMU': [3*nver, 1] + 'expPC': [3*nver, 29] + 'expEV': [29, 1] + 'texMU': [3*nver, 1] + 'texPC': [3*nver, 199] + 'texEV': [199, 1] + 'tri': [ntri, 3] (start from 1, should sub 1 in python and c++) + 'tri_mouth': [114, 3] (start from 1, as a supplement to mouth triangles) + 'kpt_ind': [68,] (start from 1) + PS: + You can change codes according to your own saved data. + Just make sure the model has corresponding attributes. + ''' + C = sio.loadmat(model_path) + model = C['model'] + model = model[0,0] + + # change dtype from double(np.float64) to np.float32, + # since big matrix process(espetially matrix dot) is too slow in python. + model['shapeMU'] = (model['shapeMU'] + model['expMU']).astype(np.float32) + model['shapePC'] = model['shapePC'].astype(np.float32) + model['shapeEV'] = model['shapeEV'].astype(np.float32) + model['expEV'] = model['expEV'].astype(np.float32) + model['expPC'] = model['expPC'].astype(np.float32) + + # matlab start with 1. change to 0 in python. + model['tri'] = model['tri'].T.copy(order = 'C').astype(np.int32) - 1 + model['tri_mouth'] = model['tri_mouth'].T.copy(order = 'C').astype(np.int32) - 1 + + # kpt ind + model['kpt_ind'] = (np.squeeze(model['kpt_ind']) - 1).astype(np.int32) + + return model + +def load_BFM_info(path = 'BFM_info.mat'): + ''' load 3DMM model extra information + Args: + path: path to BFM info. + Returns: + model_info: + 'symlist': 2 x 26720 + 'symlist_tri': 2 x 52937 + 'segbin': 4 x n (0: nose, 1: eye, 2: mouth, 3: cheek) + 'segbin_tri': 4 x ntri + 'face_contour': 1 x 28 + 'face_contour_line': 1 x 512 + 'face_contour_front': 1 x 28 + 'face_contour_front_line': 1 x 512 + 'nose_hole': 1 x 142 + 'nose_hole_right': 1 x 71 + 'nose_hole_left': 1 x 71 + 'parallel': 17 x 1 cell + 'parallel_face_contour': 28 x 1 cell + 'uv_coords': n x 2 + ''' + C = sio.loadmat(path) + model_info = C['model_info'] + model_info = model_info[0,0] + return model_info + +def load_uv_coords(path = 'BFM_UV.mat'): + ''' load uv coords of BFM + Args: + path: path to data. + Returns: + uv_coords: [nver, 2]. range: 0-1 + ''' + C = sio.loadmat(path) + uv_coords = C['UV'].copy(order = 'C') + return uv_coords + +def load_pncc_code(path = 'pncc_code.mat'): + ''' load pncc code of BFM + PNCC code: Defined in 'Face Alignment Across Large Poses: A 3D Solution Xiangyu' + download at http://www.cbsr.ia.ac.cn/users/xiangyuzhu/projects/3DDFA/main.htm. + Args: + path: path to data. + Returns: + pncc_code: [nver, 3] + ''' + C = sio.loadmat(path) + pncc_code = C['vertex_code'].T + return pncc_code + +## +def get_organ_ind(model_info): + ''' get nose, eye, mouth index + ''' + valid_bin = model_info['segbin'].astype(bool) + organ_ind = np.nonzero(valid_bin[0,:])[0] + for i in range(1, valid_bin.shape[0] - 1): + organ_ind = np.union1d(organ_ind, np.nonzero(valid_bin[i,:])[0]) + return organ_ind.astype(np.int32) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/morphabel_model.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/morphabel_model.py new file mode 100644 index 0000000000000000000000000000000000000000..abd677dacc76b93ee253114045b43c66a66bdc99 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/thirdparty/face3d/morphable_model/morphabel_model.py @@ -0,0 +1,143 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import scipy.io as sio +from .. import mesh +from . import fit +from . import load + +class MorphabelModel(object): + """docstring for MorphabelModel + model: nver: number of vertices. ntri: number of triangles. *: must have. ~: can generate ones array for place holder. + 'shapeMU': [3*nver, 1]. * + 'shapePC': [3*nver, n_shape_para]. * + 'shapeEV': [n_shape_para, 1]. ~ + 'expMU': [3*nver, 1]. ~ + 'expPC': [3*nver, n_exp_para]. ~ + 'expEV': [n_exp_para, 1]. ~ + 'texMU': [3*nver, 1]. ~ + 'texPC': [3*nver, n_tex_para]. ~ + 'texEV': [n_tex_para, 1]. ~ + 'tri': [ntri, 3] (start from 1, should sub 1 in python and c++). * + 'tri_mouth': [114, 3] (start from 1, as a supplement to mouth triangles). ~ + 'kpt_ind': [68,] (start from 1). ~ + """ + def __init__(self, model_path, model_type = 'BFM'): + super( MorphabelModel, self).__init__() + if model_type=='BFM': + self.model = load.load_BFM(model_path) + else: + print('sorry, not support other 3DMM model now') + exit() + + # fixed attributes + self.nver = self.model['shapePC'].shape[0]/3 + self.ntri = self.model['tri'].shape[0] + self.n_shape_para = self.model['shapePC'].shape[1] + self.n_exp_para = self.model['expPC'].shape[1] + self.n_tex_para = self.model['texMU'].shape[1] + + self.kpt_ind = self.model['kpt_ind'] + self.triangles = self.model['tri'] + self.full_triangles = np.vstack((self.model['tri'], self.model['tri_mouth'])) + + # ------------------------------------- shape: represented with mesh(vertices & triangles(fixed)) + def get_shape_para(self, type = 'random'): + if type == 'zero': + sp = np.random.zeros((self.n_shape_para, 1)) + elif type == 'random': + sp = np.random.rand(self.n_shape_para, 1)*1e04 + return sp + + def get_exp_para(self, type = 'random'): + if type == 'zero': + ep = np.zeros((self.n_exp_para, 1)) + elif type == 'random': + ep = -1.5 + 3*np.random.random([self.n_exp_para, 1]) + ep[6:, 0] = 0 + + return ep + + def generate_vertices(self, shape_para, exp_para): + ''' + Args: + shape_para: (n_shape_para, 1) + exp_para: (n_exp_para, 1) + Returns: + vertices: (nver, 3) + ''' + vertices = self.model['shapeMU'] + self.model['shapePC'].dot(shape_para) + self.model['expPC'].dot(exp_para) + vertices = np.reshape(vertices, [int(3), int(len(vertices)/3)], 'F').T + + return vertices + + # -------------------------------------- texture: here represented with rgb value(colors) in vertices. + def get_tex_para(self, type = 'random'): + if type == 'zero': + tp = np.zeros((self.n_tex_para, 1)) + elif type == 'random': + tp = np.random.rand(self.n_tex_para, 1) + return tp + + def generate_colors(self, tex_para): + ''' + Args: + tex_para: (n_tex_para, 1) + Returns: + colors: (nver, 3) + ''' + colors = self.model['texMU'] + self.model['texPC'].dot(tex_para*self.model['texEV']) + colors = np.reshape(colors, [int(3), int(len(colors)/3)], 'F').T/255. + + return colors + + + # ------------------------------------------- transformation + # ------------- transform + def rotate(self, vertices, angles): + ''' rotate face + Args: + vertices: [nver, 3] + angles: [3] x, y, z rotation angle(degree) + x: pitch. positive for looking down + y: yaw. positive for looking left + z: roll. positive for tilting head right + Returns: + vertices: rotated vertices + ''' + return mesh.transform.rotate(vertices, angles) + + def transform(self, vertices, s, angles, t3d): + R = mesh.transform.angle2matrix(angles) + return mesh.transform.similarity_transform(vertices, s, R, t3d) + + def transform_3ddfa(self, vertices, s, angles, t3d): # only used for processing 300W_LP data + R = mesh.transform.angle2matrix_3ddfa(angles) + return mesh.transform.similarity_transform(vertices, s, R, t3d) + + # --------------------------------------------------- fitting + def fit(self, x, X_ind, max_iter = 4, isShow = False): + ''' fit 3dmm & pose parameters + Args: + x: (n, 2) image points + X_ind: (n,) corresponding Model vertex indices + max_iter: iteration + isShow: whether to reserve middle results for show + Returns: + fitted_sp: (n_sp, 1). shape parameters + fitted_ep: (n_ep, 1). exp parameters + s, angles, t + ''' + if isShow: + fitted_sp, fitted_ep, s, R, t = fit.fit_points_for_show(x, X_ind, self.model, n_sp = self.n_shape_para, n_ep = self.n_exp_para, max_iter = max_iter) + angles = np.zeros((R.shape[0], 3)) + for i in range(R.shape[0]): + angles[i] = mesh.transform.matrix2angle(R[i]) + else: + fitted_sp, fitted_ep, s, R, t = fit.fit_points(x, X_ind, self.model, n_sp = self.n_shape_para, n_ep = self.n_exp_para, max_iter = max_iter) + angles = mesh.transform.matrix2angle(R) + return fitted_sp, fitted_ep, s, angles, t + + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d3ccb4e652e5e09aa7dba1d70b1d59ed26458fff --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/__init__.py @@ -0,0 +1,18 @@ +from __future__ import absolute_import + +#from . import bbox +#from . import viz +#from . import random +#from . import metrics +#from . import parallel + +from .storage import download, ensure_available, download_onnx +from .filesystem import get_model_dir +from .filesystem import makedirs, try_import_dali +from .constant import * +#from .bbox import bbox_iou +#from .block import recursive_visit, set_lr_mult, freeze_bn +#from .lr_scheduler import LRSequential, LRScheduler +#from .plot_history import TrainingHistory +#from .export_helper import export_block +#from .sync_loader_helper import split_data, split_and_load diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/constant.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/constant.py new file mode 100644 index 0000000000000000000000000000000000000000..8860ff077ae7227235591edfc84c0cdc227a6432 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/constant.py @@ -0,0 +1,3 @@ + +DEFAULT_MP_NAME = 'buffalo_l' + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/download.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/download.py new file mode 100644 index 0000000000000000000000000000000000000000..5cda84dede45b81dcd99161d87792b6c409fa279 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/download.py @@ -0,0 +1,95 @@ +""" +This code file mainly comes from https://github.com/dmlc/gluon-cv/blob/master/gluoncv/utils/download.py +""" +import os +import hashlib +import requests +from tqdm import tqdm + + +def check_sha1(filename, sha1_hash): + """Check whether the sha1 hash of the file content matches the expected hash. + Parameters + ---------- + filename : str + Path to the file. + sha1_hash : str + Expected sha1 hash in hexadecimal digits. + Returns + ------- + bool + Whether the file content matches the expected hash. + """ + sha1 = hashlib.sha1() + with open(filename, 'rb') as f: + while True: + data = f.read(1048576) + if not data: + break + sha1.update(data) + + sha1_file = sha1.hexdigest() + l = min(len(sha1_file), len(sha1_hash)) + return sha1.hexdigest()[0:l] == sha1_hash[0:l] + + +def download_file(url, path=None, overwrite=False, sha1_hash=None): + """Download an given URL + Parameters + ---------- + url : str + URL to download + path : str, optional + Destination path to store downloaded file. By default stores to the + current directory with same name as in url. + overwrite : bool, optional + Whether to overwrite destination file if already exists. + sha1_hash : str, optional + Expected sha1 hash in hexadecimal digits. Will ignore existing file when hash is specified + but doesn't match. + Returns + ------- + str + The file path of the downloaded file. + """ + if path is None: + fname = url.split('/')[-1] + else: + path = os.path.expanduser(path) + if os.path.isdir(path): + fname = os.path.join(path, url.split('/')[-1]) + else: + fname = path + + if overwrite or not os.path.exists(fname) or ( + sha1_hash and not check_sha1(fname, sha1_hash)): + dirname = os.path.dirname(os.path.abspath(os.path.expanduser(fname))) + if not os.path.exists(dirname): + os.makedirs(dirname) + + print('Downloading %s from %s...' % (fname, url)) + r = requests.get(url, stream=True) + if r.status_code != 200: + raise RuntimeError("Failed downloading url %s" % url) + total_length = r.headers.get('content-length') + with open(fname, 'wb') as f: + if total_length is None: # no content length header + for chunk in r.iter_content(chunk_size=1024): + if chunk: # filter out keep-alive new chunks + f.write(chunk) + else: + total_length = int(total_length) + for chunk in tqdm(r.iter_content(chunk_size=1024), + total=int(total_length / 1024. + 0.5), + unit='KB', + unit_scale=False, + dynamic_ncols=True): + f.write(chunk) + + if sha1_hash and not check_sha1(fname, sha1_hash): + raise UserWarning('File {} is downloaded but the content hash does not match. ' \ + 'The repo may be outdated or download may be incomplete. ' \ + 'If the "repo_url" is overridden, consider switching to ' \ + 'the default repo.'.format(fname)) + + return fname diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/face_align.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/face_align.py new file mode 100644 index 0000000000000000000000000000000000000000..226628b39cf743947df230feffbb97bf5c585e1d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/face_align.py @@ -0,0 +1,103 @@ +import cv2 +import numpy as np +from skimage import transform as trans + + +arcface_dst = np.array( + [[38.2946, 51.6963], [73.5318, 51.5014], [56.0252, 71.7366], + [41.5493, 92.3655], [70.7299, 92.2041]], + dtype=np.float32) + +def estimate_norm(lmk, image_size=112,mode='arcface'): + assert lmk.shape == (5, 2) + assert image_size%112==0 or image_size%128==0 + if image_size%112==0: + ratio = float(image_size)/112.0 + diff_x = 0 + else: + ratio = float(image_size)/128.0 + diff_x = 8.0*ratio + dst = arcface_dst * ratio + dst[:,0] += diff_x + tform = trans.SimilarityTransform() + tform.estimate(lmk, dst) + M = tform.params[0:2, :] + return M + +def norm_crop(img, landmark, image_size=112, mode='arcface'): + M = estimate_norm(landmark, image_size, mode) + warped = cv2.warpAffine(img, M, (image_size, image_size), borderValue=0.0) + return warped + +def norm_crop2(img, landmark, image_size=112, mode='arcface'): + M = estimate_norm(landmark, image_size, mode) + warped = cv2.warpAffine(img, M, (image_size, image_size), borderValue=0.0) + return warped, M + +def square_crop(im, S): + if im.shape[0] > im.shape[1]: + height = S + width = int(float(im.shape[1]) / im.shape[0] * S) + scale = float(S) / im.shape[0] + else: + width = S + height = int(float(im.shape[0]) / im.shape[1] * S) + scale = float(S) / im.shape[1] + resized_im = cv2.resize(im, (width, height)) + det_im = np.zeros((S, S, 3), dtype=np.uint8) + det_im[:resized_im.shape[0], :resized_im.shape[1], :] = resized_im + return det_im, scale + + +def transform(data, center, output_size, scale, rotation): + scale_ratio = scale + rot = float(rotation) * np.pi / 180.0 + #translation = (output_size/2-center[0]*scale_ratio, output_size/2-center[1]*scale_ratio) + t1 = trans.SimilarityTransform(scale=scale_ratio) + cx = center[0] * scale_ratio + cy = center[1] * scale_ratio + t2 = trans.SimilarityTransform(translation=(-1 * cx, -1 * cy)) + t3 = trans.SimilarityTransform(rotation=rot) + t4 = trans.SimilarityTransform(translation=(output_size / 2, + output_size / 2)) + t = t1 + t2 + t3 + t4 + M = t.params[0:2] + cropped = cv2.warpAffine(data, + M, (output_size, output_size), + borderValue=0.0) + return cropped, M + + +def trans_points2d(pts, M): + new_pts = np.zeros(shape=pts.shape, dtype=np.float32) + for i in range(pts.shape[0]): + pt = pts[i] + new_pt = np.array([pt[0], pt[1], 1.], dtype=np.float32) + new_pt = np.dot(M, new_pt) + #print('new_pt', new_pt.shape, new_pt) + new_pts[i] = new_pt[0:2] + + return new_pts + + +def trans_points3d(pts, M): + scale = np.sqrt(M[0][0] * M[0][0] + M[0][1] * M[0][1]) + #print(scale) + new_pts = np.zeros(shape=pts.shape, dtype=np.float32) + for i in range(pts.shape[0]): + pt = pts[i] + new_pt = np.array([pt[0], pt[1], 1.], dtype=np.float32) + new_pt = np.dot(M, new_pt) + #print('new_pt', new_pt.shape, new_pt) + new_pts[i][0:2] = new_pt[0:2] + new_pts[i][2] = pts[i][2] * scale + + return new_pts + + +def trans_points(pts, M): + if pts.shape[1] == 2: + return trans_points2d(pts, M) + else: + return trans_points3d(pts, M) + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/filesystem.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/filesystem.py new file mode 100644 index 0000000000000000000000000000000000000000..01e3851975bdcbbf7f5eeb7e68e70a36dc040535 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/filesystem.py @@ -0,0 +1,157 @@ +""" +This code file mainly comes from https://github.com/dmlc/gluon-cv/blob/master/gluoncv/utils/filesystem.py +""" +import os +import os.path as osp +import errno + + +def get_model_dir(name, root='~/.insightface'): + root = os.path.expanduser(root) + model_dir = osp.join(root, 'models', name) + return model_dir + +def makedirs(path): + """Create directory recursively if not exists. + Similar to `makedir -p`, you can skip checking existence before this function. + + Parameters + ---------- + path : str + Path of the desired dir + """ + try: + os.makedirs(path) + except OSError as exc: + if exc.errno != errno.EEXIST: + raise + + +def try_import(package, message=None): + """Try import specified package, with custom message support. + + Parameters + ---------- + package : str + The name of the targeting package. + message : str, default is None + If not None, this function will raise customized error message when import error is found. + + + Returns + ------- + module if found, raise ImportError otherwise + + """ + try: + return __import__(package) + except ImportError as e: + if not message: + raise e + raise ImportError(message) + + +def try_import_cv2(): + """Try import cv2 at runtime. + + Returns + ------- + cv2 module if found. Raise ImportError otherwise + + """ + msg = "cv2 is required, you can install by package manager, e.g. 'apt-get', \ + or `pip install opencv-python --user` (note that this is unofficial PYPI package)." + + return try_import('cv2', msg) + + +def try_import_mmcv(): + """Try import mmcv at runtime. + + Returns + ------- + mmcv module if found. Raise ImportError otherwise + + """ + msg = "mmcv is required, you can install by first `pip install Cython --user` \ + and then `pip install mmcv --user` (note that this is unofficial PYPI package)." + + return try_import('mmcv', msg) + + +def try_import_rarfile(): + """Try import rarfile at runtime. + + Returns + ------- + rarfile module if found. Raise ImportError otherwise + + """ + msg = "rarfile is required, you can install by first `sudo apt-get install unrar` \ + and then `pip install rarfile --user` (note that this is unofficial PYPI package)." + + return try_import('rarfile', msg) + + +def import_try_install(package, extern_url=None): + """Try import the specified package. + If the package not installed, try use pip to install and import if success. + + Parameters + ---------- + package : str + The name of the package trying to import. + extern_url : str or None, optional + The external url if package is not hosted on PyPI. + For example, you can install a package using: + "pip install git+http://github.com/user/repo/tarball/master/egginfo=xxx". + In this case, you can pass the url to the extern_url. + + Returns + ------- + + The imported python module. + + """ + try: + return __import__(package) + except ImportError: + try: + from pip import main as pipmain + except ImportError: + from pip._internal import main as pipmain + + # trying to install package + url = package if extern_url is None else extern_url + pipmain(['install', '--user', + url]) # will raise SystemExit Error if fails + + # trying to load again + try: + return __import__(package) + except ImportError: + import sys + import site + user_site = site.getusersitepackages() + if user_site not in sys.path: + sys.path.append(user_site) + return __import__(package) + return __import__(package) + + +def try_import_dali(): + """Try import NVIDIA DALI at runtime. + """ + try: + dali = __import__('nvidia.dali', fromlist=['pipeline', 'ops', 'types']) + dali.Pipeline = dali.pipeline.Pipeline + except ImportError: + + class dali: + class Pipeline: + def __init__(self): + raise NotImplementedError( + "DALI not found, please check if you installed it correctly." + ) + + return dali diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/storage.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/storage.py new file mode 100644 index 0000000000000000000000000000000000000000..5bf37e2d17b28dee2a8839484778815f87fc4a9c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/storage.py @@ -0,0 +1,52 @@ + +import os +import os.path as osp +import zipfile +from .download import download_file + +BASE_REPO_URL = 'https://github.com/deepinsight/insightface/releases/download/v0.7' + +def download(sub_dir, name, force=False, root='~/.insightface'): + _root = os.path.expanduser(root) + dir_path = os.path.join(_root, sub_dir, name) + if osp.exists(dir_path) and not force: + return dir_path + print('download_path:', dir_path) + zip_file_path = os.path.join(_root, sub_dir, name + '.zip') + model_url = "%s/%s.zip"%(BASE_REPO_URL, name) + download_file(model_url, + path=zip_file_path, + overwrite=True) + if not os.path.exists(dir_path): + os.makedirs(dir_path) + with zipfile.ZipFile(zip_file_path) as zf: + zf.extractall(dir_path) + #os.remove(zip_file_path) + return dir_path + +def ensure_available(sub_dir, name, root='~/.insightface'): + return download(sub_dir, name, force=False, root=root) + +def download_onnx(sub_dir, model_file, force=False, root='~/.insightface', download_zip=False): + _root = os.path.expanduser(root) + model_root = osp.join(_root, sub_dir) + new_model_file = osp.join(model_root, model_file) + if osp.exists(new_model_file) and not force: + return new_model_file + if not osp.exists(model_root): + os.makedirs(model_root) + print('download_path:', new_model_file) + if not download_zip: + model_url = "%s/%s"%(BASE_REPO_URL, model_file) + download_file(model_url, + path=new_model_file, + overwrite=True) + else: + model_url = "%s/%s.zip"%(BASE_REPO_URL, model_file) + zip_file_path = new_model_file+".zip" + download_file(model_url, + path=zip_file_path, + overwrite=True) + with zipfile.ZipFile(zip_file_path) as zf: + zf.extractall(model_root) + return new_model_file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/transform.py b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/transform.py new file mode 100644 index 0000000000000000000000000000000000000000..06531d257b694211a0b9a09c9d741b9b2ff53bfe --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/insightface/utils/transform.py @@ -0,0 +1,116 @@ +import cv2 +import math +import numpy as np +from skimage import transform as trans + + +def transform(data, center, output_size, scale, rotation): + scale_ratio = scale + rot = float(rotation) * np.pi / 180.0 + #translation = (output_size/2-center[0]*scale_ratio, output_size/2-center[1]*scale_ratio) + t1 = trans.SimilarityTransform(scale=scale_ratio) + cx = center[0] * scale_ratio + cy = center[1] * scale_ratio + t2 = trans.SimilarityTransform(translation=(-1 * cx, -1 * cy)) + t3 = trans.SimilarityTransform(rotation=rot) + t4 = trans.SimilarityTransform(translation=(output_size / 2, + output_size / 2)) + t = t1 + t2 + t3 + t4 + M = t.params[0:2] + cropped = cv2.warpAffine(data, + M, (output_size, output_size), + borderValue=0.0) + return cropped, M + + +def trans_points2d(pts, M): + new_pts = np.zeros(shape=pts.shape, dtype=np.float32) + for i in range(pts.shape[0]): + pt = pts[i] + new_pt = np.array([pt[0], pt[1], 1.], dtype=np.float32) + new_pt = np.dot(M, new_pt) + #print('new_pt', new_pt.shape, new_pt) + new_pts[i] = new_pt[0:2] + + return new_pts + + +def trans_points3d(pts, M): + scale = np.sqrt(M[0][0] * M[0][0] + M[0][1] * M[0][1]) + #print(scale) + new_pts = np.zeros(shape=pts.shape, dtype=np.float32) + for i in range(pts.shape[0]): + pt = pts[i] + new_pt = np.array([pt[0], pt[1], 1.], dtype=np.float32) + new_pt = np.dot(M, new_pt) + #print('new_pt', new_pt.shape, new_pt) + new_pts[i][0:2] = new_pt[0:2] + new_pts[i][2] = pts[i][2] * scale + + return new_pts + + +def trans_points(pts, M): + if pts.shape[1] == 2: + return trans_points2d(pts, M) + else: + return trans_points3d(pts, M) + +def estimate_affine_matrix_3d23d(X, Y): + ''' Using least-squares solution + Args: + X: [n, 3]. 3d points(fixed) + Y: [n, 3]. corresponding 3d points(moving). Y = PX + Returns: + P_Affine: (3, 4). Affine camera matrix (the third row is [0, 0, 0, 1]). + ''' + X_homo = np.hstack((X, np.ones([X.shape[0],1]))) #n x 4 + P = np.linalg.lstsq(X_homo, Y)[0].T # Affine matrix. 3 x 4 + return P + +def P2sRt(P): + ''' decompositing camera matrix P + Args: + P: (3, 4). Affine Camera Matrix. + Returns: + s: scale factor. + R: (3, 3). rotation matrix. + t: (3,). translation. + ''' + t = P[:, 3] + R1 = P[0:1, :3] + R2 = P[1:2, :3] + s = (np.linalg.norm(R1) + np.linalg.norm(R2))/2.0 + r1 = R1/np.linalg.norm(R1) + r2 = R2/np.linalg.norm(R2) + r3 = np.cross(r1, r2) + + R = np.concatenate((r1, r2, r3), 0) + return s, R, t + +def matrix2angle(R): + ''' get three Euler angles from Rotation Matrix + Args: + R: (3,3). rotation matrix + Returns: + x: pitch + y: yaw + z: roll + ''' + sy = math.sqrt(R[0,0] * R[0,0] + R[1,0] * R[1,0]) + + singular = sy < 1e-6 + + if not singular : + x = math.atan2(R[2,1] , R[2,2]) + y = math.atan2(-R[2,0], sy) + z = math.atan2(R[1,0], R[0,0]) + else : + x = math.atan2(-R[1,2], R[1,1]) + y = math.atan2(-R[2,0], sy) + z = 0 + + # rx, ry, rz = np.rad2deg(x), np.rad2deg(y), np.rad2deg(z) + rx, ry, rz = x*180/np.pi, y*180/np.pi, z*180/np.pi + return rx, ry, rz + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/METADATA b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..98c0db8fc38e1de9b9eabb062c66d483525f519b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/METADATA @@ -0,0 +1,268 @@ +Metadata-Version: 2.4 +Name: ml_dtypes +Version: 0.5.4 +Summary: ml_dtypes is a stand-alone implementation of several NumPy dtype extensions used in machine learning. +Author-email: ml_dtypes authors +License-Expression: Apache-2.0 +Project-URL: homepage, https://github.com/jax-ml/ml_dtypes +Project-URL: repository, https://github.com/jax-ml/ml_dtypes +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Intended Audience :: Science/Research +Requires-Python: >=3.9 +Description-Content-Type: text/markdown +License-File: LICENSE +License-File: LICENSE.eigen +Requires-Dist: numpy>=1.21 +Requires-Dist: numpy>=1.21.2; python_version >= "3.10" +Requires-Dist: numpy>=1.23.3; python_version >= "3.11" +Requires-Dist: numpy>=1.26.0; python_version >= "3.12" +Requires-Dist: numpy>=2.1.0; python_version >= "3.13" +Provides-Extra: dev +Requires-Dist: absl-py; extra == "dev" +Requires-Dist: pytest; extra == "dev" +Requires-Dist: pytest-xdist; extra == "dev" +Requires-Dist: pylint>=2.6.0; extra == "dev" +Requires-Dist: pyink; extra == "dev" +Dynamic: license-file + +# ml_dtypes + +[![Unittests](https://github.com/jax-ml/ml_dtypes/actions/workflows/test.yml/badge.svg)](https://github.com/jax-ml/ml_dtypes/actions/workflows/test.yml) +[![Wheel Build](https://github.com/jax-ml/ml_dtypes/actions/workflows/wheels.yml/badge.svg)](https://github.com/jax-ml/ml_dtypes/actions/workflows/wheels.yml) +[![PyPI version](https://badge.fury.io/py/ml_dtypes.svg)](https://badge.fury.io/py/ml_dtypes) + +`ml_dtypes` is a stand-alone implementation of several NumPy dtype extensions used in machine learning libraries, including: + +- [`bfloat16`](https://en.wikipedia.org/wiki/Bfloat16_floating-point_format): + an alternative to the standard [`float16`](https://en.wikipedia.org/wiki/Half-precision_floating-point_format) format +- 8-bit floating point representations, parameterized by number of exponent and + mantissa bits, as well as the bias (if any) and representability of infinity, + NaN, and signed zero. + * `float8_e3m4` + * `float8_e4m3` + * `float8_e4m3b11fnuz` + * `float8_e4m3fn` + * `float8_e4m3fnuz` + * `float8_e5m2` + * `float8_e5m2fnuz` + * `float8_e8m0fnu` +- Microscaling (MX) sub-byte floating point representations: + * `float4_e2m1fn` + * `float6_e2m3fn` + * `float6_e3m2fn` +- Narrow integer encodings: + * `int2` + * `int4` + * `uint2` + * `uint4` + +See below for specifications of these number formats. + +## Installation + +The `ml_dtypes` package is tested with Python versions 3.9-3.12, and can be installed +with the following command: +``` +pip install ml_dtypes +``` +To test your installation, you can run the following: +``` +pip install absl-py pytest +pytest --pyargs ml_dtypes +``` +To build from source, clone the repository and run: +``` +git submodule init +git submodule update +pip install . +``` + +## Example Usage + +```python +>>> from ml_dtypes import bfloat16 +>>> import numpy as np +>>> np.zeros(4, dtype=bfloat16) +array([0, 0, 0, 0], dtype=bfloat16) +``` +Importing `ml_dtypes` also registers the data types with numpy, so that they may +be referred to by their string name: + +```python +>>> np.dtype('bfloat16') +dtype(bfloat16) +>>> np.dtype('float8_e5m2') +dtype(float8_e5m2) +``` + +## Specifications of implemented floating point formats + +### `bfloat16` + +A `bfloat16` number is a single-precision float truncated at 16 bits. + +Exponent: 8, Mantissa: 7, exponent bias: 127. IEEE 754, with NaN and inf. + +### `float4_e2m1fn` + +Exponent: 2, Mantissa: 1, bias: 1. + +Extended range: no inf, no NaN. + +Microscaling format, 4 bits (encoding: `0bSEEM`) using byte storage (higher 4 +bits are unused). NaN representation is undefined. + +Possible absolute values: [`0`, `0.5`, `1`, `1.5`, `2`, `3`, `4`, `6`] + +### `float6_e2m3fn` + +Exponent: 2, Mantissa: 3, bias: 1. + +Extended range: no inf, no NaN. + +Microscaling format, 6 bits (encoding: `0bSEEMMM`) using byte storage (higher 2 +bits are unused). NaN representation is undefined. + +Possible values range: [`-7.5`; `7.5`] + +### `float6_e3m2fn` + +Exponent: 3, Mantissa: 2, bias: 3. + +Extended range: no inf, no NaN. + +Microscaling format, 4 bits (encoding: `0bSEEEMM`) using byte storage (higher 2 +bits are unused). NaN representation is undefined. + +Possible values range: [`-28`; `28`] + +### `float8_e3m4` + +Exponent: 3, Mantissa: 4, bias: 3. IEEE 754, with NaN and inf. + +### `float8_e4m3` + +Exponent: 4, Mantissa: 3, bias: 7. IEEE 754, with NaN and inf. + +### `float8_e4m3b11fnuz` + +Exponent: 4, Mantissa: 3, bias: 11. + +Extended range: no inf, NaN represented by 0b1000'0000. + +### `float8_e4m3fn` + +Exponent: 4, Mantissa: 3, bias: 7. + +Extended range: no inf, NaN represented by 0bS111'1111. + +The `fn` suffix is for consistency with the corresponding LLVM/MLIR type, signaling this type is not consistent with IEEE-754. The `f` indicates it is finite values only. The `n` indicates it includes NaNs, but only at the outer range. + +### `float8_e4m3fnuz` + +8-bit floating point with 3 bit mantissa. + +An 8-bit floating point type with 1 sign bit, 4 bits exponent and 3 bits mantissa. The suffix `fnuz` is consistent with LLVM/MLIR naming and is derived from the differences to IEEE floating point conventions. `F` is for "finite" (no infinities), `N` for with special NaN encoding, `UZ` for unsigned zero. + +This type has the following characteristics: + * bit encoding: S1E4M3 - `0bSEEEEMMM` + * exponent bias: 8 + * infinities: Not supported + * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s - `0b10000000` + * denormals when exponent is 0 + +### `float8_e5m2` + +Exponent: 5, Mantissa: 2, bias: 15. IEEE 754, with NaN and inf. + +### `float8_e5m2fnuz` + +8-bit floating point with 2 bit mantissa. + +An 8-bit floating point type with 1 sign bit, 5 bits exponent and 2 bits mantissa. The suffix `fnuz` is consistent with LLVM/MLIR naming and is derived from the differences to IEEE floating point conventions. `F` is for "finite" (no infinities), `N` for with special NaN encoding, `UZ` for unsigned zero. + +This type has the following characteristics: + * bit encoding: S1E5M2 - `0bSEEEEEMM` + * exponent bias: 16 + * infinities: Not supported + * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s - `0b10000000` + * denormals when exponent is 0 + +### `float8_e8m0fnu` + +[OpenCompute MX](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf) +scale format E8M0, which has the following properties: + * Unsigned format + * 8 exponent bits + * Exponent range from -127 to 127 + * No zero and infinity + * Single NaN value (0xFF). + +## `int2`, `int4`, `uint2` and `uint4` + +2 and 4-bit integer types, where each element is represented unpacked (i.e., +padded up to a byte in memory). + +NumPy does not support types smaller than a single byte: for example, the +distance between adjacent elements in an array (`.strides`) is expressed as +an integer number of bytes. Relaxing this restriction would be a considerable +engineering project. These types therefore use an unpacked representation, where +each element of the array is padded up to a byte in memory. The lower two or four +bits of each byte contain the representation of the number, whereas the remaining +upper bits are ignored. + +## Quirks of low-precision Arithmetic + +If you're exploring the use of low-precision dtypes in your code, you should be +careful to anticipate when the precision loss might lead to surprising results. +One example is the behavior of aggregations like `sum`; consider this `bfloat16` +summation in NumPy (run with version 1.24.2): + +```python +>>> from ml_dtypes import bfloat16 +>>> import numpy as np +>>> rng = np.random.default_rng(seed=0) +>>> vals = rng.uniform(size=10000).astype(bfloat16) +>>> vals.sum() +256 +``` +The true sum should be close to 5000, but numpy returns exactly 256: this is +because `bfloat16` does not have the precision to increment `256` by values less than +`1`: + +```python +>>> bfloat16(256) + bfloat16(1) +256 +``` +After 256, the next representable value in bfloat16 is 258: + +```python +>>> np.nextafter(bfloat16(256), bfloat16(np.inf)) +258 +``` +For better results you can specify that the accumulation should happen in a +higher-precision type like `float32`: + +```python +>>> vals.sum(dtype='float32').astype(bfloat16) +4992 +``` +In contrast to NumPy, projects like [JAX](http://jax.readthedocs.io/) which support +low-precision arithmetic more natively will often do these kinds of higher-precision +accumulations automatically: + +```python +>>> import jax.numpy as jnp +>>> jnp.array(vals).sum() +Array(4992, dtype=bfloat16) +``` + +## License + +*This is not an officially supported Google product.* + +The `ml_dtypes` source code is licensed under the Apache 2.0 license +(see [LICENSE](LICENSE)). Pre-compiled wheels are built with the +[EIGEN](https://eigen.tuxfamily.org/) project, which is released under the +MPL 2.0 license (see [LICENSE.eigen](LICENSE.eigen)). diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/RECORD b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..705858ec746bf5fdd00a5346365b1123c9ac86e7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/RECORD @@ -0,0 +1,11 @@ +ml_dtypes/__init__.py,sha256=hbw_lvtmy5M5Gc3ked8yGcqrP12Pa3V83ZQx7rA3Reg,2357 +ml_dtypes/_finfo.py,sha256=5Tqbe85x1_wSHiaxrCytPUGW-r5f9Oq3VcL9eKq7Vgg,22905 +ml_dtypes/_iinfo.py,sha256=GIsAHpvzKH8Qd6puw8AfaHRG8hCMSbiakaHv0fGR9WM,2027 +ml_dtypes/_ml_dtypes_ext.cpython-311-x86_64-linux-gnu.so,sha256=2RWTwWKncE8FWTXCSFni5tReU-iBmjdpzDkdHqslVIg,25060912 +ml_dtypes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ml_dtypes-0.5.4.dist-info/METADATA,sha256=UbVym0jOcXNnSLv0PU81VIX0K0SXfWAWcXu9axG338A,8908 +ml_dtypes-0.5.4.dist-info/WHEEL,sha256=3daP3VhxT_uXQ4g9qxjrsHJLh9a9x1Dc522TvcSo1E0,152 +ml_dtypes-0.5.4.dist-info/top_level.txt,sha256=meeeNkM1LLmTU5q_0ssFs21A_42VAoES24ntCrPqASw,10 +ml_dtypes-0.5.4.dist-info/RECORD,, +ml_dtypes-0.5.4.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +ml_dtypes-0.5.4.dist-info/licenses/LICENSE.eigen,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/WHEEL b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..877b63ad81f31e9e52588701b631478d58f56658 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: false +Tag: cp311-cp311-manylinux_2_27_x86_64 +Tag: cp311-cp311-manylinux_2_28_x86_64 + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/licenses/LICENSE b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/licenses/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/licenses/LICENSE.eigen b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/licenses/LICENSE.eigen new file mode 100644 index 0000000000000000000000000000000000000000..d0a1fa1482eea82e19510e7920cbe3a03e41f691 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/licenses/LICENSE.eigen @@ -0,0 +1,373 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at https://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/top_level.txt b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..a65a36928cdc346035db028b8162cb4d637c763f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes-0.5.4.dist-info/top_level.txt @@ -0,0 +1 @@ +ml_dtypes diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..197cf63b578e4fc00054cc66be9d6ce93e086f30 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/__init__.py @@ -0,0 +1,77 @@ +# Copyright 2022 The ml_dtypes Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +__version__ = "0.5.4" +__all__ = [ + "__version__", + "bfloat16", + "finfo", + "float4_e2m1fn", + "float6_e2m3fn", + "float6_e3m2fn", + "float8_e3m4", + "float8_e4m3", + "float8_e4m3b11fnuz", + "float8_e4m3fn", + "float8_e4m3fnuz", + "float8_e5m2", + "float8_e5m2fnuz", + "float8_e8m0fnu", + "iinfo", + "int2", + "int4", + "uint2", + "uint4", +] + +from typing import Type + +from ml_dtypes._finfo import finfo +from ml_dtypes._iinfo import iinfo +from ml_dtypes._ml_dtypes_ext import bfloat16 +from ml_dtypes._ml_dtypes_ext import float4_e2m1fn +from ml_dtypes._ml_dtypes_ext import float6_e2m3fn +from ml_dtypes._ml_dtypes_ext import float6_e3m2fn +from ml_dtypes._ml_dtypes_ext import float8_e3m4 +from ml_dtypes._ml_dtypes_ext import float8_e4m3 +from ml_dtypes._ml_dtypes_ext import float8_e4m3b11fnuz +from ml_dtypes._ml_dtypes_ext import float8_e4m3fn +from ml_dtypes._ml_dtypes_ext import float8_e4m3fnuz +from ml_dtypes._ml_dtypes_ext import float8_e5m2 +from ml_dtypes._ml_dtypes_ext import float8_e5m2fnuz +from ml_dtypes._ml_dtypes_ext import float8_e8m0fnu +from ml_dtypes._ml_dtypes_ext import int2 +from ml_dtypes._ml_dtypes_ext import int4 +from ml_dtypes._ml_dtypes_ext import uint2 +from ml_dtypes._ml_dtypes_ext import uint4 +import numpy as np + +bfloat16: Type[np.generic] +float4_e2m1fn: Type[np.generic] +float6_e2m3fn: Type[np.generic] +float6_e3m2fn: Type[np.generic] +float8_e3m4: Type[np.generic] +float8_e4m3: Type[np.generic] +float8_e4m3b11fnuz: Type[np.generic] +float8_e4m3fn: Type[np.generic] +float8_e4m3fnuz: Type[np.generic] +float8_e5m2: Type[np.generic] +float8_e5m2fnuz: Type[np.generic] +float8_e8m0fnu: Type[np.generic] +int2: Type[np.generic] +int4: Type[np.generic] +uint2: Type[np.generic] +uint4: Type[np.generic] + +del np, Type diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/_finfo.py b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/_finfo.py new file mode 100644 index 0000000000000000000000000000000000000000..26d62caf7b378619e14d74fefb2f4258fbb078f9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/_finfo.py @@ -0,0 +1,714 @@ +# Copyright 2023 The ml_dtypes Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Overload of numpy.finfo to handle dtypes defined in ml_dtypes.""" + +from ml_dtypes._ml_dtypes_ext import bfloat16 +from ml_dtypes._ml_dtypes_ext import float4_e2m1fn +from ml_dtypes._ml_dtypes_ext import float6_e2m3fn +from ml_dtypes._ml_dtypes_ext import float6_e3m2fn +from ml_dtypes._ml_dtypes_ext import float8_e3m4 +from ml_dtypes._ml_dtypes_ext import float8_e4m3 +from ml_dtypes._ml_dtypes_ext import float8_e4m3b11fnuz +from ml_dtypes._ml_dtypes_ext import float8_e4m3fn +from ml_dtypes._ml_dtypes_ext import float8_e4m3fnuz +from ml_dtypes._ml_dtypes_ext import float8_e5m2 +from ml_dtypes._ml_dtypes_ext import float8_e5m2fnuz +from ml_dtypes._ml_dtypes_ext import float8_e8m0fnu +import numpy as np + +_bfloat16_dtype = np.dtype(bfloat16) +_float4_e2m1fn_dtype = np.dtype(float4_e2m1fn) +_float6_e2m3fn_dtype = np.dtype(float6_e2m3fn) +_float6_e3m2fn_dtype = np.dtype(float6_e3m2fn) +_float8_e3m4_dtype = np.dtype(float8_e3m4) +_float8_e4m3_dtype = np.dtype(float8_e4m3) +_float8_e4m3b11fnuz_dtype = np.dtype(float8_e4m3b11fnuz) +_float8_e4m3fn_dtype = np.dtype(float8_e4m3fn) +_float8_e4m3fnuz_dtype = np.dtype(float8_e4m3fnuz) +_float8_e5m2_dtype = np.dtype(float8_e5m2) +_float8_e5m2fnuz_dtype = np.dtype(float8_e5m2fnuz) +_float8_e8m0fnu_dtype = np.dtype(float8_e8m0fnu) + + +class _Bfloat16MachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-126") + self.smallest_normal = bfloat16(smallest_normal) + smallest_subnormal = float.fromhex("0x1p-133") + self.smallest_subnormal = bfloat16(smallest_subnormal) + + +class _Float4E2m1fnMachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p0") + self.smallest_normal = float4_e2m1fn(smallest_normal) + smallest_subnormal = float.fromhex("0x0.8p0") + self.smallest_subnormal = float4_e2m1fn(smallest_subnormal) + + +class _Float6E2m3fnMachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p0") + self.smallest_normal = float6_e2m3fn(smallest_normal) + smallest_subnormal = float.fromhex("0x0.2p0") + self.smallest_subnormal = float6_e2m3fn(smallest_subnormal) + + +class _Float6E3m2fnMachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-2") + self.smallest_normal = float6_e3m2fn(smallest_normal) + smallest_subnormal = float.fromhex("0x0.4p-2") + self.smallest_subnormal = float6_e3m2fn(smallest_subnormal) + + +class _Float8E3m4MachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-2") + self.smallest_normal = float8_e3m4(smallest_normal) + smallest_subnormal = float.fromhex("0x0.1p-2") + self.smallest_subnormal = float8_e3m4(smallest_subnormal) + + +class _Float8E4m3MachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-6") + self.smallest_normal = float8_e4m3(smallest_normal) + smallest_subnormal = float.fromhex("0x0.2p-6") + self.smallest_subnormal = float8_e4m3(smallest_subnormal) + + +class _Float8E4m3b11fnuzMachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-10") + self.smallest_normal = float8_e4m3b11fnuz(smallest_normal) + smallest_subnormal = float.fromhex("0x1p-13") + self.smallest_subnormal = float8_e4m3b11fnuz(smallest_subnormal) + + +class _Float8E4m3fnMachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-6") + self.smallest_normal = float8_e4m3fn(smallest_normal) + smallest_subnormal = float.fromhex("0x1p-9") + self.smallest_subnormal = float8_e4m3fn(smallest_subnormal) + + +class _Float8E4m3fnuzMachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-7") + self.smallest_normal = float8_e4m3fnuz(smallest_normal) + smallest_subnormal = float.fromhex("0x1p-10") + self.smallest_subnormal = float8_e4m3fnuz(smallest_subnormal) + + +class _Float8E5m2MachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-14") + self.smallest_normal = float8_e5m2(smallest_normal) + smallest_subnormal = float.fromhex("0x1p-16") + self.smallest_subnormal = float8_e5m2(smallest_subnormal) + + +class _Float8E5m2fnuzMachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-15") + self.smallest_normal = float8_e5m2fnuz(smallest_normal) + smallest_subnormal = float.fromhex("0x1p-17") + self.smallest_subnormal = float8_e5m2fnuz(smallest_subnormal) + + +class _Float8E8m0fnuMachArLike: + + def __init__(self): + smallest_normal = float.fromhex("0x1p-127") + self.smallest_normal = float8_e8m0fnu(smallest_normal) + smallest_subnormal = float.fromhex("0x1p-127") + self.smallest_subnormal = float8_e8m0fnu(smallest_subnormal) + + +class finfo(np.finfo): # pylint: disable=invalid-name,missing-class-docstring + __doc__ = np.finfo.__doc__ + + @staticmethod + def _bfloat16_finfo(): + def float_to_str(f): + return "%12.4e" % float(f) + + tiny = float.fromhex("0x1p-126") + resolution = 0.01 + eps = float.fromhex("0x1p-7") + epsneg = float.fromhex("0x1p-8") + max_ = float.fromhex("0x1.FEp127") + + obj = object.__new__(np.finfo) + obj.dtype = _bfloat16_dtype + obj.bits = 16 + obj.eps = bfloat16(eps) + obj.epsneg = bfloat16(epsneg) + obj.machep = -7 + obj.negep = -8 + obj.max = bfloat16(max_) + obj.min = bfloat16(-max_) + obj.nexp = 8 + obj.nmant = 7 + obj.iexp = obj.nexp + obj.maxexp = 128 + obj.minexp = -126 + obj.precision = 2 + obj.resolution = bfloat16(resolution) + # pylint: disable=protected-access + obj._machar = _Bfloat16MachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = bfloat16(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float4_e2m1fn_finfo(): + eps = float.fromhex("0x0.8p0") # 0.5 + max_ = float.fromhex("0x1.8p2") # 6.0 + + obj = object.__new__(np.finfo) + obj.dtype = _float4_e2m1fn_dtype + obj.bits = 4 + obj.eps = eps + obj.epsneg = eps + obj.machep = -1 + obj.negep = -1 + obj.max = float4_e2m1fn(max_) + obj.min = float4_e2m1fn(-max_) + obj.nexp = 2 + obj.nmant = 1 + obj.iexp = obj.nexp + obj.maxexp = 3 + obj.minexp = 0 + obj.precision = 0 + obj.resolution = float4_e2m1fn(1.0) + # pylint: disable=protected-access + obj._machar = _Float4E2m1fnMachArLike() + tiny = obj._machar.smallest_normal + if not hasattr(obj, "tiny"): + obj.tiny = tiny + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = tiny + obj.smallest_subnormal = obj._machar.smallest_subnormal + + float_to_str = str + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(obj.max) + obj._str_epsneg = float_to_str(obj.epsneg) + obj._str_eps = float_to_str(obj.eps) + obj._str_resolution = float_to_str(obj.resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float6_e2m3fn_finfo(): + eps = float.fromhex("0x0.2p0") # 0.125 + max_ = float.fromhex("0x1.Ep2") # 7.5 + + obj = object.__new__(np.finfo) + obj.dtype = _float6_e2m3fn_dtype + obj.bits = 6 + obj.eps = eps + obj.epsneg = eps + obj.machep = -3 + obj.negep = -3 + obj.max = float6_e2m3fn(max_) + obj.min = float6_e2m3fn(-max_) + obj.nexp = 2 + obj.nmant = 3 + obj.iexp = obj.nexp + obj.maxexp = 3 + obj.minexp = 0 + obj.precision = 0 + obj.resolution = float6_e2m3fn(1.0) + # pylint: disable=protected-access + obj._machar = _Float6E2m3fnMachArLike() + tiny = obj._machar.smallest_normal + if not hasattr(obj, "tiny"): + obj.tiny = tiny + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = tiny + obj.smallest_subnormal = obj._machar.smallest_subnormal + + float_to_str = str + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(obj.max) + obj._str_epsneg = float_to_str(obj.epsneg) + obj._str_eps = float_to_str(obj.eps) + obj._str_resolution = float_to_str(obj.resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float6_e3m2fn_finfo(): + eps = float.fromhex("0x1p-2") # 0.25 + max_ = float.fromhex("0x1.Cp4") # 28 + + obj = object.__new__(np.finfo) + obj.dtype = _float6_e3m2fn_dtype + obj.bits = 6 + obj.eps = eps + obj.epsneg = eps / 2 + obj.machep = -2 + obj.negep = -3 + obj.max = float6_e3m2fn(max_) + obj.min = float6_e3m2fn(-max_) + obj.nexp = 3 + obj.nmant = 2 + obj.iexp = obj.nexp + obj.maxexp = 5 + obj.minexp = -2 + obj.precision = 0 + obj.resolution = float6_e3m2fn(1.0) + # pylint: disable=protected-access + obj._machar = _Float6E3m2fnMachArLike() + tiny = obj._machar.smallest_normal + if not hasattr(obj, "tiny"): + obj.tiny = tiny + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = tiny + obj.smallest_subnormal = obj._machar.smallest_subnormal + + float_to_str = str + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(obj.max) + obj._str_epsneg = float_to_str(obj.epsneg) + obj._str_eps = float_to_str(obj.eps) + obj._str_resolution = float_to_str(obj.resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float8_e3m4_finfo(): + def float_to_str(f): + return "%6.2e" % float(f) + + tiny = float.fromhex("0x1p-2") # 1/4 min normal + resolution = 0.1 + eps = float.fromhex("0x1p-4") # 1/16 + epsneg = float.fromhex("0x1p-5") # 1/32 + max_ = float.fromhex("0x1.Fp3") # 15.5 max normal + + obj = object.__new__(np.finfo) + obj.dtype = _float8_e3m4_dtype + obj.bits = 8 + obj.eps = float8_e3m4(eps) + obj.epsneg = float8_e3m4(epsneg) + obj.machep = -4 + obj.negep = -5 + obj.max = float8_e3m4(max_) + obj.min = float8_e3m4(-max_) + obj.nexp = 3 + obj.nmant = 4 + obj.iexp = obj.nexp + obj.maxexp = 4 + obj.minexp = -2 + obj.precision = 1 + obj.resolution = float8_e3m4(resolution) + # pylint: disable=protected-access + obj._machar = _Float8E3m4MachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = float8_e3m4(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float8_e4m3_finfo(): + def float_to_str(f): + return "%6.2e" % float(f) + + tiny = float.fromhex("0x1p-6") # 1/64 min normal + resolution = 0.1 + eps = float.fromhex("0x1p-3") # 1/8 + epsneg = float.fromhex("0x1p-4") # 1/16 + max_ = float.fromhex("0x1.Ep7") # 240 max normal + + obj = object.__new__(np.finfo) + obj.dtype = _float8_e4m3_dtype + obj.bits = 8 + obj.eps = float8_e4m3(eps) + obj.epsneg = float8_e4m3(epsneg) + obj.machep = -3 + obj.negep = -4 + obj.max = float8_e4m3(max_) + obj.min = float8_e4m3(-max_) + obj.nexp = 4 + obj.nmant = 3 + obj.iexp = obj.nexp + obj.maxexp = 8 + obj.minexp = -6 + obj.precision = 1 + obj.resolution = float8_e4m3(resolution) + # pylint: disable=protected-access + obj._machar = _Float8E4m3MachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = float8_e4m3(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float8_e4m3b11fnuz_finfo(): + def float_to_str(f): + return "%6.2e" % float(f) + + tiny = float.fromhex("0x1p-10") + resolution = 0.1 + eps = float.fromhex("0x1p-3") + epsneg = float.fromhex("0x1p-4") + max_ = float.fromhex("0x1.Ep4") + + obj = object.__new__(np.finfo) + obj.dtype = _float8_e4m3b11fnuz_dtype + obj.bits = 8 + obj.eps = float8_e4m3b11fnuz(eps) + obj.epsneg = float8_e4m3b11fnuz(epsneg) + obj.machep = -3 + obj.negep = -4 + obj.max = float8_e4m3b11fnuz(max_) + obj.min = float8_e4m3b11fnuz(-max_) + obj.nexp = 4 + obj.nmant = 3 + obj.iexp = obj.nexp + obj.maxexp = 5 + obj.minexp = -10 + obj.precision = 1 + obj.resolution = float8_e4m3b11fnuz(resolution) + # pylint: disable=protected-access + obj._machar = _Float8E4m3b11fnuzMachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = float8_e4m3b11fnuz(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float8_e4m3fn_finfo(): + def float_to_str(f): + return "%6.2e" % float(f) + + tiny = float.fromhex("0x1p-6") + resolution = 0.1 + eps = float.fromhex("0x1p-3") + epsneg = float.fromhex("0x1p-4") + max_ = float.fromhex("0x1.Cp8") + + obj = object.__new__(np.finfo) + obj.dtype = _float8_e4m3fn_dtype + obj.bits = 8 + obj.eps = float8_e4m3fn(eps) + obj.epsneg = float8_e4m3fn(epsneg) + obj.machep = -3 + obj.negep = -4 + obj.max = float8_e4m3fn(max_) + obj.min = float8_e4m3fn(-max_) + obj.nexp = 4 + obj.nmant = 3 + obj.iexp = obj.nexp + obj.maxexp = 9 + obj.minexp = -6 + obj.precision = 1 + obj.resolution = float8_e4m3fn(resolution) + # pylint: disable=protected-access + obj._machar = _Float8E4m3fnMachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = float8_e4m3fn(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float8_e4m3fnuz_finfo(): + def float_to_str(f): + return "%6.2e" % float(f) + + tiny = float.fromhex("0x1p-7") + resolution = 0.1 + eps = float.fromhex("0x1p-3") + epsneg = float.fromhex("0x1p-4") + max_ = float.fromhex("0x1.Ep7") + + obj = object.__new__(np.finfo) + obj.dtype = _float8_e4m3fnuz_dtype + obj.bits = 8 + obj.eps = float8_e4m3fnuz(eps) + obj.epsneg = float8_e4m3fnuz(epsneg) + obj.machep = -3 + obj.negep = -4 + obj.max = float8_e4m3fnuz(max_) + obj.min = float8_e4m3fnuz(-max_) + obj.nexp = 4 + obj.nmant = 3 + obj.iexp = obj.nexp + obj.maxexp = 8 + obj.minexp = -7 + obj.precision = 1 + obj.resolution = float8_e4m3fnuz(resolution) + # pylint: disable=protected-access + obj._machar = _Float8E4m3fnuzMachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = float8_e4m3fnuz(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float8_e5m2_finfo(): + def float_to_str(f): + return "%6.2e" % float(f) + + tiny = float.fromhex("0x1p-14") + resolution = 0.1 + eps = float.fromhex("0x1p-2") + epsneg = float.fromhex("0x1p-3") + max_ = float.fromhex("0x1.Cp15") + + obj = object.__new__(np.finfo) + obj.dtype = _float8_e5m2_dtype + obj.bits = 8 + obj.eps = float8_e5m2(eps) + obj.epsneg = float8_e5m2(epsneg) + obj.machep = -2 + obj.negep = -3 + obj.max = float8_e5m2(max_) + obj.min = float8_e5m2(-max_) + obj.nexp = 5 + obj.nmant = 2 + obj.iexp = obj.nexp + obj.maxexp = 16 + obj.minexp = -14 + obj.precision = 1 + obj.resolution = float8_e5m2(resolution) + # pylint: disable=protected-access + obj._machar = _Float8E5m2MachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = float8_e5m2(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float8_e5m2fnuz_finfo(): + def float_to_str(f): + return "%6.2e" % float(f) + + tiny = float.fromhex("0x1p-15") + resolution = 0.1 + eps = float.fromhex("0x1p-2") + epsneg = float.fromhex("0x1p-3") + max_ = float.fromhex("0x1.Cp15") + + obj = object.__new__(np.finfo) + obj.dtype = _float8_e5m2fnuz_dtype + obj.bits = 8 + obj.eps = float8_e5m2fnuz(eps) + obj.epsneg = float8_e5m2fnuz(epsneg) + obj.machep = -2 + obj.negep = -3 + obj.max = float8_e5m2fnuz(max_) + obj.min = float8_e5m2fnuz(-max_) + obj.nexp = 5 + obj.nmant = 2 + obj.iexp = obj.nexp + obj.maxexp = 16 + obj.minexp = -15 + obj.precision = 1 + obj.resolution = float8_e5m2fnuz(resolution) + # pylint: disable=protected-access + obj._machar = _Float8E5m2fnuzMachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = float8_e5m2fnuz(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + @staticmethod + def _float8_e8m0fnu_finfo(): + def float_to_str(f): + return "%6.2e" % float(f) + + tiny = float.fromhex("0x1p-127") + resolution = 0.1 + eps = float.fromhex("0x1p+0") + epsneg = float.fromhex("0x1p-1") + max_ = float.fromhex("0x1p+127") + + obj = object.__new__(np.finfo) + obj.dtype = _float8_e8m0fnu_dtype + obj.bits = 8 + obj.eps = float8_e8m0fnu(eps) + obj.epsneg = float8_e8m0fnu(epsneg) + obj.machep = 0 + obj.negep = -1 + obj.max = float8_e8m0fnu(max_) + obj.min = float8_e8m0fnu(tiny) + obj.nexp = 8 + obj.nmant = 0 + obj.iexp = obj.nexp + obj.maxexp = 128 + obj.minexp = -127 + obj.precision = 1 + obj.resolution = float8_e8m0fnu(resolution) + # pylint: disable=protected-access + obj._machar = _Float8E8m0fnuMachArLike() + if not hasattr(obj, "tiny"): + obj.tiny = float8_e8m0fnu(tiny) + if not hasattr(obj, "smallest_normal"): + obj.smallest_normal = obj._machar.smallest_normal + obj.smallest_subnormal = obj._machar.smallest_subnormal + + obj._str_tiny = float_to_str(tiny) + obj._str_smallest_normal = float_to_str(tiny) + obj._str_smallest_subnormal = float_to_str(obj.smallest_subnormal) + obj._str_max = float_to_str(max_) + obj._str_epsneg = float_to_str(epsneg) + obj._str_eps = float_to_str(eps) + obj._str_resolution = float_to_str(resolution) + # pylint: enable=protected-access + return obj + + _finfo_type_map = { + _bfloat16_dtype: _bfloat16_finfo, + _float4_e2m1fn_dtype: _float4_e2m1fn_finfo, + _float6_e2m3fn_dtype: _float6_e2m3fn_finfo, + _float6_e3m2fn_dtype: _float6_e3m2fn_finfo, + _float8_e3m4_dtype: _float8_e3m4_finfo, + _float8_e4m3_dtype: _float8_e4m3_finfo, + _float8_e4m3fn_dtype: _float8_e4m3fn_finfo, + _float8_e4m3fnuz_dtype: _float8_e4m3fnuz_finfo, + _float8_e4m3b11fnuz_dtype: _float8_e4m3b11fnuz_finfo, + _float8_e5m2_dtype: _float8_e5m2_finfo, + _float8_e5m2fnuz_dtype: _float8_e5m2fnuz_finfo, + _float8_e8m0fnu_dtype: _float8_e8m0fnu_finfo, + } + _finfo_name_map = {t.name: t for t in _finfo_type_map} + _finfo_cache = { + t: init_fn.__func__() # pytype: disable=attribute-error + for t, init_fn in _finfo_type_map.items() + } + + def __new__(cls, dtype): + if isinstance(dtype, str): + key = cls._finfo_name_map.get(dtype) + elif isinstance(dtype, np.dtype): + key = dtype + else: + key = np.dtype(dtype) + i = cls._finfo_cache.get(key) + if i is not None: + return i + return super().__new__(cls, dtype) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/_iinfo.py b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/_iinfo.py new file mode 100644 index 0000000000000000000000000000000000000000..e307f95d1c8ebbc8c012ac542267687da20a0bba --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/_iinfo.py @@ -0,0 +1,73 @@ +# Copyright 2023 The ml_dtypes Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Overload of numpy.iinfo to handle dtypes defined in ml_dtypes.""" + +from ml_dtypes._ml_dtypes_ext import int2 +from ml_dtypes._ml_dtypes_ext import int4 +from ml_dtypes._ml_dtypes_ext import uint2 +from ml_dtypes._ml_dtypes_ext import uint4 +import numpy as np + +_int2_dtype = np.dtype(int2) +_uint2_dtype = np.dtype(uint2) +_int4_dtype = np.dtype(int4) +_uint4_dtype = np.dtype(uint4) + + +class iinfo: # pylint: disable=invalid-name,missing-class-docstring + kind: str + bits: int + min: int + max: int + dtype: np.dtype + + def __init__(self, int_type): + if int_type == _int2_dtype: + self.dtype = _int2_dtype + self.kind = "i" + self.bits = 2 + self.min = -2 + self.max = 1 + elif int_type == _uint2_dtype: + self.dtype = _uint2_dtype + self.kind = "u" + self.bits = 2 + self.min = 0 + self.max = 3 + elif int_type == _int4_dtype: + self.dtype = _int4_dtype + self.kind = "i" + self.bits = 4 + self.min = -8 + self.max = 7 + elif int_type == _uint4_dtype: + self.dtype = _uint4_dtype + self.kind = "u" + self.bits = 4 + self.min = 0 + self.max = 15 + else: + ii = np.iinfo(int_type) + self.dtype = ii.dtype + self.kind = ii.kind + self.bits = ii.bits + self.min = ii.min + self.max = ii.max + + def __repr__(self): + return f"iinfo(min={self.min}, max={self.max}, dtype={self.dtype})" + + def __str__(self): + return repr(self) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/py.typed b/ScaleDF_rebuttal/python_dedup_pkgs/ml_dtypes/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/INSTALLER b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/METADATA b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..9b979735a670ba64f15c0455c7ed0872d706e643 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/METADATA @@ -0,0 +1,159 @@ +Metadata-Version: 2.4 +Name: onnx +Version: 1.22.0 +Summary: Open Neural Network Exchange +Author-Email: ONNX Contributors +License-Expression: Apache-2.0 +Classifier: Programming Language :: Python :: 3 +Project-URL: Homepage, https://onnx.ai/ +Project-URL: Repository, https://github.com/onnx/onnx +Requires-Python: >=3.10 +Requires-Dist: numpy>=1.23.2 +Requires-Dist: protobuf>=4.25.1 +Requires-Dist: typing_extensions>=4.15.0 +Requires-Dist: ml_dtypes>=0.5.4 +Provides-Extra: reference +Requires-Dist: Pillow; extra == "reference" +Description-Content-Type: text/markdown + + + +

+ +[![PyPI - Version](https://img.shields.io/pypi/v/onnx.svg)](https://pypi.org/project/onnx) +[![CI](https://github.com/onnx/onnx/actions/workflows/main.yml/badge.svg)](https://github.com/onnx/onnx/actions/workflows/main.yml) +[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/3313/badge)](https://bestpractices.coreinfrastructure.org/projects/3313) +[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/onnx/onnx/badge)](https://api.securityscorecards.dev/projects/github.com/onnx/onnx) +[![SLSA 2](https://slsa.dev/images/gh-badge-level2.svg)](https://slsa.dev) +[![REUSE compliant](https://api.reuse.software/badge/github.com/onnx/onnx)](https://api.reuse.software/info/github.com/onnx/onnx) +[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) +[![abi3 compatible](https://img.shields.io/badge/abi3-compatible-brightgreen)](https://docs.python.org/3/c-api/stable.html) + +[Open Neural Network Exchange (ONNX)](https://onnx.ai) is an open ecosystem that empowers AI developers +to choose the right tools as their project evolves. ONNX provides an open source format for AI models, both deep learning and traditional ML. It defines an extensible computation graph model, as well as definitions of built-in operators and standard +data types. Currently we focus on the capabilities needed for inferencing (scoring). + +ONNX is [widely supported](http://onnx.ai/supported-tools) and can be found in many frameworks, tools, and hardware. Enabling interoperability between different frameworks and streamlining the path from research to production helps increase the speed of innovation in the AI community. We invite the community to join us and further evolve ONNX. + + +# Use ONNX + +* [Documentation of ONNX Python Package](https://onnx.ai/onnx/) +* [Tutorials for creating ONNX models](https://github.com/onnx/tutorials) +* [Pre-trained ONNX models](https://github.com/onnx/models) + +# Learn about the ONNX spec + +* [Overview](https://github.com/onnx/onnx/blob/main/docs/Overview.md) +* [ONNX intermediate representation spec](https://github.com/onnx/onnx/blob/main/docs/IR.md) +* [Versioning principles of the spec](https://github.com/onnx/onnx/blob/main/docs/Versioning.md) +* [Operators documentation](https://github.com/onnx/onnx/blob/main/docs/Operators.md) +* [Operators documentation](https://onnx.ai/onnx/operators/index.html) (latest release) +* [Python API Overview](https://github.com/onnx/onnx/blob/main/docs/PythonAPIOverview.md) + +# Programming utilities for working with ONNX Graphs + +* [Shape and Type Inference](https://github.com/onnx/onnx/blob/main/docs/ShapeInference.md) +* [Graph Optimization](https://github.com/onnx/optimizer) +* [Opset Version Conversion](https://github.com/onnx/onnx/blob/main/docs/docsgen/source/api/version_converter.md) + +# Contribute + +ONNX is a community project and the open governance model is described [here](https://github.com/onnx/onnx/blob/main/community/readme.md). We encourage you to join the effort and contribute feedback, ideas, and code. You can participate in the [Special Interest Groups](https://github.com/onnx/onnx/blob/main/community/sigs.md) and [Working Groups](https://github.com/onnx/onnx/blob/main/community/working-groups.md) to shape the future of ONNX. + +Check out our [contribution guide](https://github.com/onnx/onnx/blob/main/CONTRIBUTING.md) to get started. + +If you think some operator should be added to ONNX specification, please read +[this document](https://github.com/onnx/onnx/blob/main/docs/AddNewOp.md). + +# Community meetings + +The schedules of the regular meetings of the Steering Committee, the working groups and the SIGs can be found [here](https://onnx.ai/calendar) + +Community Meetups are held at least once a year. Content from previous community meetups are at: + +* 2020.04.09 +* 2020.10.14 +* 2021.03.24 +* 2021.10.21 +* 2022.06.24 +* 2023.06.28 + +# Discuss + +We encourage you to open [Issues](https://github.com/onnx/onnx/issues), or use [Slack](https://lfaifoundation.slack.com/) (If you have not joined yet, please use this [link](https://join.slack.com/t/lfaifoundation/shared_invite/zt-3wx5vohc3-MeSYi3_dscb~u~cqs7zlPg) to join the group) for more real-time discussion. + +# Follow Us + +Stay up to date with the latest ONNX news. [[Facebook](https://www.facebook.com/onnxai/)] [[Twitter/X](https://twitter.com/onnxai)] + +# Roadmap + +A roadmap process takes place every year. More details can be found [here](https://github.com/onnx/steering-committee/tree/main/roadmap) + +# Installation + +ONNX released packages are published in PyPi. + +```sh +pip install onnx # or pip install onnx[reference] for optional reference implementation dependencies +``` + +[ONNX weekly packages](https://pypi.org/project/onnx-weekly/) are published in PyPI to enable experimentation and early testing. + +Detailed install instructions, including Common Build Options and Common Errors can be found [here](https://github.com/onnx/onnx/blob/main/INSTALL.md) + +# Python ABI3 Compatibility + +This package provides [abi3](https://docs.python.org/3/c-api/stable.html)-compatible wheels, allowing a single binary wheel to work across multiple Python versions (from 3.12 onwards). + + +# Testing + +ONNX uses [pytest](https://docs.pytest.org) as test driver. In order to run tests, you will first need to install `pytest`: + +```sh +pip install pytest +``` + +After installing pytest, use the following command to run tests. + +```sh +pytest +``` + +# Development + +Check out the [contributor guide](https://github.com/onnx/onnx/blob/main/CONTRIBUTING.md) for instructions. + +# Reproducible Builds (Linux) + +This project provides reproducible builds for Linux. + +A *reproducible build* means that the same source code will always produce identical binary outputs, no matter who builds it or where it is built. + +To achieve this, we use the [`SOURCE_DATE_EPOCH`](https://reproducible-builds.org/docs/source-date-epoch/) standard. This ensures that build timestamps and other time-dependent information are fixed, making the output bit-for-bit identical across different environments. + +### Why this matters +- **Transparency**: Anyone can verify that the distributed binaries were created from the published source code. +- **Security**: Prevents tampering or hidden changes in the build process. +- **Trust**: Users can be confident that the binaries they download are exactly what the maintainers intended. + +If you prefer, you can use the prebuilt reproducible binaries instead of building from source yourself. + +# License + +[Apache License v2.0](LICENSE) + +# Trademark +Checkout [https://trademarks.justia.com](https://trademarks.justia.com/877/25/onnx-87725026.html) for the trademark. + +[General rules of the Linux Foundation on Trademark usage](https://www.linuxfoundation.org/legal/trademark-usage) + +# Code of Conduct + +[ONNX Open Source Code of Conduct](https://onnx.ai/codeofconduct.html) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/RECORD b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..199c87c5714e0c6af3c507d9559a4f2b16359d13 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/RECORD @@ -0,0 +1,9019 @@ +onnx/__init__.py,sha256=vGKa41IMuFkZ6k2__KVWYrT-KgQsByykv8QVmpYAboQ,15429 +onnx/_mapping.py,sha256=1MfvUOLeZe8xMSM82wihX8tYeufIkyfgPSWIQg3Pdys,4207 +onnx/checker.cc,sha256=447tfAGZuONb-leVOYs24hdShrXEkI8XkMFYRnlhB5A,54554 +onnx/checker.h,sha256=vocTifb0wTgqOZ6EnCtyzrD9ckvEVenpFwSphIYc120,7040 +onnx/checker.py,sha256=p2d4df24Ugg19iOlj6CsEMa1whmv_M7Y7Ah9w9ryWbE,5504 +onnx/compose.py,sha256=Vtqd5qmUcVMpwx4AE04BCDnyrbxapV0YBM5k5NPgJ7E,27494 +onnx/cpp2py_export.cc,sha256=b9HYN-ziXog65LeyHVBfbE80B7Q2eivg52obFl0yYvk,41077 +onnx/external_data_helper.py,sha256=CnNxC96wqef7lPWzjlsu33iy6A9qF92iZVApMXL7TqA,15788 +onnx/gen_proto.py,sha256=1uNk28qepEftxR0D_42MwU22IEMJbQJLbvgtyupXVQk,8718 +onnx/helper.py,sha256=ah_Q02MNiLBriJ4NwCDmn51y_XMrfqn-TrkIp2H5Qis,46411 +onnx/inliner.py,sha256=MFFDRvsXfXxce0Yv1mkqqQJT7rdJE7MaS2yOlMDUHTY,2106 +onnx/model_container.py,sha256=lyGJhcNWi7mHltjWnWcLYu71KQJuEC8bUcNK1stW0Ck,12489 +onnx/numpy_helper.py,sha256=sOnTqcN2PTSA_YMs4KOL9xzI9vlu2JyoTlXX4xR6oTw,22186 +onnx/onnx-data.in.proto,sha256=9pzNeNuuNqtvAKo1ndKwQSbS8YTyD02lKmf1g5A_HW4,5101 +onnx/onnx-data.proto,sha256=uT6IhTRCU1e8nOgaZXi_2s_UZQkagyXMDAnP0efivCg,5182 +onnx/onnx-ml.proto,sha256=9Zlr2o1cRtKenqXdX1ZGXfp-mMIssxUp68vOfL6buro,43381 +onnx/onnx-operators-ml.proto,sha256=IeC_msLetFoVu-MtnJc1NcbRlxnO0VgbLFEDOeQJzbw,5304 +onnx/onnx-operators.in.proto,sha256=ue1dIV6Rax01cJXl1408fQYnIC5v4dMsPn0H_YkPQoE,5223 +onnx/onnx-operators.proto,sha256=tywA6edoeu2IMAUD2Kp3oWX_fl1lXjDt5cwclOtpSHg,5301 +onnx/onnx-operators_pb.h,sha256=gxmDEhSBMWfNOzLoj41x0zG0oi_AokOXRYqf6faig-A,229 +onnx/onnx.in.proto,sha256=9MvBmN86Dz9FGdTTjNImLo-EBXWDtzE-LQ-YGz9owhM,43315 +onnx/onnx.proto,sha256=oFz7zRNwYIuAnFuExE4xmNM2kDZFjgtfKX52zq-cThs,42918 +onnx/onnx_cpp2py_export.cpython-311-x86_64-linux-gnu.so,sha256=1Mo-7KKmfgEuyLlamdacw3FoOdZeWj81a4oAEMnKcgk,6426040 +onnx/onnx_data_pb.py,sha256=CvoDf7GzGNZS-_Rg-tvHlrdU-cji9nd1ykd4ZWnQpnM,96 +onnx/onnx_data_pb2.py,sha256=Unk9UxxQpVMdFryhDF8VCDfDbcGVPoqkEOG8lQ9eeX4,3090 +onnx/onnx_data_pb2.pyi,sha256=bKj4OSOkMllQfLliKbt3ixouZRHLUVwf-_t1dDvwQa4,5046 +onnx/onnx_ml_pb2.py,sha256=VESdnwgWnU8ikHSksvRVHD5JFXMAqC5GXvbCVhIw0FQ,15651 +onnx/onnx_ml_pb2.pyi,sha256=i-NO0RUhH0kxxqfnvVI6oJVQVYgGXH0yIDOJEjQrJH4,29033 +onnx/onnx_operators_ml_pb2.py,sha256=Nfl0Mvq555D6UITHkq7EDmOcuKaWlP3oeCjWGTq12ss,1921 +onnx/onnx_operators_ml_pb2.pyi,sha256=X7EFXJEDCYZMDiLF0jajcpStg_yVvnjxM-iqycK16SM,2315 +onnx/onnx_operators_pb.py,sha256=CfXrescQHTOXu0SuhN95UZpQWYTRV1XKaDssEdAlN7s,104 +onnx/onnx_pb.h,sha256=7oyN0MlZau7dG7853XhnxsKrj4fB4eprGeI4rqw2mEw,1743 +onnx/onnx_pb.py,sha256=m9nJl6NRL_PN0Lg0Hqg_1ENdDgb0gC_IK1_rR9elMKw,94 +onnx/parser.py,sha256=Fd5POgb_fpl4UGJ24mfgkJsMV3BKq-G-j6nhJrFJ8O4,1892 +onnx/printer.py,sha256=K6IxLj_E5ib8aWN_eDfFBmPhr4nAg2Cj3Lh7UaOWH3s,755 +onnx/proto_utils.h,sha256=Ybdo90S5rbHfBMP4aINMNTPx6gdIRb44HeWw28OLabE,2462 +onnx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +onnx/py_utils.h,sha256=G0VyQDhfEhVFq9ozWn73EkHP4syhJuozSJRXWYl0eLw,528 +onnx/serialization.py,sha256=dx5BvV4mb_QTdM5xN5imzP4r4BsEdEk-mBqWrsj_26Q,7911 +onnx/shape_inference.py,sha256=T9YAm6TRyO-20n3y5BK1eHS440oA9yde6GLIIOVGDzQ,5906 +onnx/string_utils.h,sha256=K7uUOG4IP54Sh2kiw82DDpKuHN6SQvCoaEu3-Qrn9TY,979 +onnx/utils.py,sha256=lRt9FneNZmIU4iO1doaLZKnPtlgmoMjMMSZF2zdmIy8,12743 +onnx/version.py,sha256=a16ZADKpF79NuiXXRtGpHpP3LYEt8Oq-F7VMb-zvyKs,473 +onnx/version_converter.py,sha256=Dm2OarPnEbucTrMQsXpq_sGsVx1fmqTvggQlft-FiaE,1267 +onnx/backend/__init__.py,sha256=x6thC2ykdnq7G6hJ-ENaxiRV3WfttWPcBYskup5sjig,82 +onnx/backend/base.py,sha256=23IFK5uk42mXDuBKvPNPpWOxnQOmpG1AxAW3Hm99Qkg,4862 +onnx/backend/sample/__init__.py,sha256=0mfJeTgGHjc1Ihv0iAklMTwcQY5rWQr167CoTJJcxXk,81 +onnx/backend/sample/ops/__init__.py,sha256=S9GK1oshOVe9M6sXTmxnZ7ATn6xyfMYYGSXfUEpwx_Q,862 +onnx/backend/sample/ops/abs.py,sha256=xXrV-_VyzIeZc8nXTmswmXl4U_EV9CzCQif-9OC_ka0,207 +onnx/backend/test/__init__.py,sha256=B3lPXdD2YFQo7C3i0UA3sOE55DuI7xHxuB9HwZYbsNc,232 +onnx/backend/test/cmd_tools.py,sha256=GHmbHf_9yZi4VHJeu0aI_P-SLucZUCSLZra_hKXuCBY,7738 +onnx/backend/test/stat_coverage.py,sha256=h8hRSuFG-PpymuP2u6eKHycifcpebTSOnG8DO4oeiGQ,11812 +onnx/backend/test/case/__init__.py,sha256=K3SsyfN2_MakvMFTs4HCZSEInFfjPb-LaTuQ4u8voqY,362 +onnx/backend/test/case/base.py,sha256=1QYtEA6d6eVz8Pp8cwh8W9cMRoBfp-d6v9sRbxGyRxs,1504 +onnx/backend/test/case/test_case.py,sha256=3z2KD6F276eGAnNLs0fiDELa3BN_aakr462soi9f9FQ,625 +onnx/backend/test/case/utils.py,sha256=sR6TlV5IlxIpd8YE6GyS4GOpkTarjFPQrmm2jsFKvJE,1040 +onnx/backend/test/case/model/__init__.py,sha256=5KGkzPXrj_Kf8KWJJZZXTvj07a_ugm-W_5hdDD8i0EU,2191 +onnx/backend/test/case/model/expand.py,sha256=hE9Sun1oVWWJq8TrlyD8PRVfC9-ZST7rYnLbtczsyVY,3300 +onnx/backend/test/case/model/gradient.py,sha256=svWLew6DKUioLxadQYTlrqkokZwJOlrcvl_gc8jpz5g,4010 +onnx/backend/test/case/model/sequence.py,sha256=zsuNOaQCFVOYkyubm4EM9ICKnKVvQZk7Hh0gFwdauzY,16039 +onnx/backend/test/case/model/shrink.py,sha256=6lnGSO3hQhVPyD7Pn0VGqHuBauWBtLUZSOrPdeK6flo,1200 +onnx/backend/test/case/model/sign.py,sha256=8Pc0ippKTl_tBLohtfgXTTA64_WgT48P0OZfTCOB2Eo,1151 +onnx/backend/test/case/model/single_relu.py,sha256=T8rvAlnv0gHJMG9XnqGn2XoPUs2k7qqgejGgDosE6mo,1086 +onnx/backend/test/case/model/stringnormalizer.py,sha256=GW-23U_Vb4Oz6oIAPsfWo672weMiAcQw2xAvuWXq-6s,6219 +onnx/backend/test/case/node/__init__.py,sha256=M0OXVdx3AO2xg0nn6DZdjNmEqIBm3AA4fTSjMKkX-8k,18723 +onnx/backend/test/case/node/_image_decoder_data.py,sha256=Mi38f49CTbJ3R0U7dr9OYxDkI-lEuFrHX3KS2aL-P6Q,210448 +onnx/backend/test/case/node/abs.py,sha256=ZpvbRg_HuPOW8n7QdsBBe0ic-0W-DyHBJsRV24NsReU,567 +onnx/backend/test/case/node/acos.py,sha256=OCbiDdrYyKUetQFIKKs4L2tCuBh2FAHiFkJwCpdMqo0,726 +onnx/backend/test/case/node/acosh.py,sha256=nxSn2E6X78_X2pS4VN3J85SAJxRqQUVKYus1LLjdJS0,797 +onnx/backend/test/case/node/adagrad.py,sha256=0NuixW7JgXWA8wz9lt-vM-KDeEkbC2HPVhIgl9Ri7_I,3747 +onnx/backend/test/case/node/adam.py,sha256=2ZzK0k_-BkEXzLVECkh2vBysx121epIzt-A8yYmsUwo,4417 +onnx/backend/test/case/node/add.py,sha256=_rhnPL019-IbWZVh4fPwaHgPPMqpqZNbglJmqFc-EO8,2244 +onnx/backend/test/case/node/affinegrid.py,sha256=vxFk_dbYuW89oabT8j1cVvNSI-tRSrqvomwqefXDgjo,6084 +onnx/backend/test/case/node/and_.py,sha256=T9w_7uP47pHz_Kq9bGnkw00Qy-X2Xnar7vHKavzPqAA,2504 +onnx/backend/test/case/node/argmax.py,sha256=B4h7Ynn7k4eaejdVx5mqTDv0WsOjjoPNs2gHJnJzo5E,8360 +onnx/backend/test/case/node/argmin.py,sha256=DkrexOn6zJFXdqwr6P0l0retJDEAVNDFxHJ0Ezo8CzI,8442 +onnx/backend/test/case/node/asin.py,sha256=11QNJziQ0BWtuU6X5jAsvEHs5olDPyzDtx4yDBqkEdE,726 +onnx/backend/test/case/node/asinh.py,sha256=vGKAVVoW0SPp-Ve-KwVph0R9q7wqdM1jWbeKYfqbwEY,780 +onnx/backend/test/case/node/atan.py,sha256=KjkvKcI_uMxsSsxZFZr1Y2aQuRqM6yUU37IFHPzh5gI,723 +onnx/backend/test/case/node/atanh.py,sha256=_qsOJ0W4Cq7hQf9b_CTV_i31lXs00haEzIGiPrjiXx8,798 +onnx/backend/test/case/node/attention.py,sha256=O7yB4AjsqkdMzlByydU1sGO1_-1thnmpVS6kaP-CjKY,66986 +onnx/backend/test/case/node/averagepool.py,sha256=wD1YNg51oVVeOkGFDpBbY2XTAd6YYgg6uRizhpvVDik,21173 +onnx/backend/test/case/node/batchnorm.py,sha256=l1QgnnqqzYzxznetv_-HavN2uBw4Af1V5-uI2uOgoqc,4732 +onnx/backend/test/case/node/bernoulli.py,sha256=TmYXHAqM31_qzIgG8dPXbHBo8JSP30pEO_QKCE3SGXY,1870 +onnx/backend/test/case/node/bitcast.py,sha256=F0I4XfEoieLgmH7eksPruQMHa1zqRoyrgaim07j9FKE,5158 +onnx/backend/test/case/node/bitshift.py,sha256=2PnLOiR1Q30EkSf73D5tMXkokJUQfdV_gmaajSSkzbM,3581 +onnx/backend/test/case/node/bitwiseand.py,sha256=xaP68kSax8AGg7oI_Odat0eYPC4vTsCBbuOattBXwBA,1673 +onnx/backend/test/case/node/bitwisenot.py,sha256=eJnxt907r1gXZ4iP8Zi04sgS8T36POe4RvJoREnkADU,1005 +onnx/backend/test/case/node/bitwiseor.py,sha256=7yGIi1E0WvfMv8AHFlActX_6ZSWNFP42AV53tte6eEI,1640 +onnx/backend/test/case/node/bitwisexor.py,sha256=OAFXlKz8rBRqPS5U7orq7uUmEF_M2K6T5vwCxU5CXgo,1672 +onnx/backend/test/case/node/blackmanwindow.py,sha256=Fe99n56Hd9ANoCD1ymkD4coHEwMgW7V-mei82gIVZtQ,1539 +onnx/backend/test/case/node/cast.py,sha256=nxgnbZFEvzPQsRpAeLRtp8qhJBeIFIRiP8kFXhEwBkM,13573 +onnx/backend/test/case/node/castlike.py,sha256=aqMVnDFR9vbeG5bT8rbLv8Mjka-y0kkMCxGRmFEd1CM,11394 +onnx/backend/test/case/node/causal_conv_with_state.py,sha256=Va11KakfCHL0qJ5HApCIladoUG1vdAo1F54QpsEaiP8,11846 +onnx/backend/test/case/node/ceil.py,sha256=_nqP6LO-bv8Ka0qMmhbtJ6BbcNx8zSEqKC-ZJTeAWZA,749 +onnx/backend/test/case/node/celu.py,sha256=gPMLL0bzjt7SGO1YcGscaRfcikHTdwMOfqnpMhy2pzE,1570 +onnx/backend/test/case/node/center_crop_pad.py,sha256=VhSHFh35aySCAjxt9qzrcUDuDOr8ftvIE8DY6yBhyRI,3939 +onnx/backend/test/case/node/clip.py,sha256=rQ35MOYgPeHJlFGBjtJp8Z1kYPeUlGXv-Jch0bPA918,4582 +onnx/backend/test/case/node/col2im.py,sha256=16SySG8WejFYZdSkvi6KPMlGfkoFoPVd_kMxyfxxnX0,11069 +onnx/backend/test/case/node/compress.py,sha256=1l92V-YhoJSAnJKV7aBCVY7ciL0DTSyfDGZ3HTRHwNk,2746 +onnx/backend/test/case/node/concat.py,sha256=7JO6U9bYP5l3JRPab4P6CZGmRgvGr0LjB-A4hVGU5hI,1928 +onnx/backend/test/case/node/constant.py,sha256=FJOFwM2lqKphS5uzitlw2D_6svO0T2acQHaXTVdHzq0,801 +onnx/backend/test/case/node/constantofshape.py,sha256=3iFZx6o8lVf_uplXlmwcAeAf8VgwYcVYV1px4IlMgc0,1872 +onnx/backend/test/case/node/conv.py,sha256=2ZI-tXhvCBGwMQ96THM-8eb1VGarzf6IdhwknZoNWjA,8173 +onnx/backend/test/case/node/convinteger.py,sha256=l_AhQg_XX5evYIElVFiaqQrM70-F3_OUYIqNtmPm6vo,2747 +onnx/backend/test/case/node/convtranspose.py,sha256=mh5QSjSrwiqq1W2HGPz1ufAcRfLoHyVCgxh-2lHYHoA,21372 +onnx/backend/test/case/node/cos.py,sha256=VRjOCd1vs0FCY0Ss9QrnXpzqMYTQ8ry7VoqSSAw7v2k,713 +onnx/backend/test/case/node/cosh.py,sha256=JsSWm4BA8dYBeTZDr8vEoFUr8-5N0HMoaMk4i1dSooc,769 +onnx/backend/test/case/node/cumprod.py,sha256=ke9OiKbO7gStsI2LDzobg4MCLxnddNqUwB-Z9QuHHkU,4714 +onnx/backend/test/case/node/cumsum.py,sha256=k62_hhQNZTwC9OhXGCGh31B9eg_3VQULJZAiAIlAExs,4319 +onnx/backend/test/case/node/deformconv.py,sha256=fOPT9OQOlGxqNbTKjNVmoVr1UNH-jF_TyFqom3dQYCc,5368 +onnx/backend/test/case/node/depthtospace.py,sha256=27oHRdoGlOh8lBfFrd6d9m4d75urbxC2u75VuKkPlQA,3570 +onnx/backend/test/case/node/dequantizelinear.py,sha256=Znh5UQkeuxlyGI0A5N9Tn8iTlBguZIDCsb6bKy_Vx1E,11175 +onnx/backend/test/case/node/det.py,sha256=_ULbiXsnOcJenX-lxwBgiY4BThI4pOI_ZN9wtlcsuG0,1010 +onnx/backend/test/case/node/dft.py,sha256=dkJhAfYzRnEYZKIhrcHdaLUZHFjj2r4cj0KXE6VyPvU,5913 +onnx/backend/test/case/node/div.py,sha256=tUw_y4QSrVDGPdRGtBupb5Bbow_KmRgfbrBz_7D_wIM,2847 +onnx/backend/test/case/node/dropout.py,sha256=jIP0GLNa8Lyvec-A_So5Mj9AxlnWIl1n3dS1Tv-etek,6341 +onnx/backend/test/case/node/dynamicquantizelinear.py,sha256=eEHuCE5SVACFqzYuZmDfUpfXFDfQ5WCk8rWGIAXNi_4,2477 +onnx/backend/test/case/node/einsum.py,sha256=j5cPn4IcXxZ7obw1MLss-sbM9xVbUCc9bhyba22j_qY,2693 +onnx/backend/test/case/node/elu.py,sha256=FmqSALzSpBnNjRhGrSd0SHOi2Z_gJm1GkMu-uSvT7_w,1259 +onnx/backend/test/case/node/equal.py,sha256=xkotyyZ6z_SuxV2ib-P3DdQaTE7EqZiJWK1yOd_gZME,3307 +onnx/backend/test/case/node/erf.py,sha256=NYqNf8mQX3Kf5q2TtziPB5xDWk8RK5m0BDI5PDpKpMk,620 +onnx/backend/test/case/node/exp.py,sha256=Rwinw_q4uFjX-pG7EMz7yxQjlpRPcL1v_p1bY2ZDGL4,761 +onnx/backend/test/case/node/expand.py,sha256=GWue9VJVMoCemQZt9AOFkQWKjwLjBpewYYZ9rkH-CtQ,1947 +onnx/backend/test/case/node/eyelike.py,sha256=7kCUx4fmJB1gogKEj721mjr2Z-7gbYqljSqmwjb3zyA,1749 +onnx/backend/test/case/node/flatten.py,sha256=eFMOBv4Koh7yzj-hjX5Hq8fIgfx2Br_zcZtXXedbB94,1932 +onnx/backend/test/case/node/flexattention.py,sha256=VG7oejNpC_BvUGZCgQxAJEAK904yX5NPs_HGL3dWu5U,20278 +onnx/backend/test/case/node/floor.py,sha256=uASUSTYDf7VD8rTeYlr6MIjWT7OWdKNUH9fIAQ_XX78,762 +onnx/backend/test/case/node/gather.py,sha256=NHHS7L_1G5Udeftb1teigVRlCNcZh1dMJ0Jtju2k4Cg,2378 +onnx/backend/test/case/node/gatherelements.py,sha256=z1NQbYLh-ZDk5BWXvB8778MZzIo-6kX23JQ9-CCLij8,2669 +onnx/backend/test/case/node/gathernd.py,sha256=sqxSTHJAjw_-zdgUsyVox9Vo04URuiEGuhfnMFX6Vc0,4041 +onnx/backend/test/case/node/gelu.py,sha256=dhTrM_dbuJwkuTL9qzU_HdgUlnSbl9n2sOHVyOffKOk,1806 +onnx/backend/test/case/node/gemm.py,sha256=7rcxulEv4PqPhhSck7VcfOtkZv6K9pcquFSI7YO1gGk,5938 +onnx/backend/test/case/node/globalaveragepool.py,sha256=TJW6C6iHfWhh7ozqnJhTZrk65Z04YEgNmIga7LVUX1M,1274 +onnx/backend/test/case/node/globalmaxpool.py,sha256=Fj81OzxifU8Cn-LD3kL9W46JPPN0hR31yhnlwh2PTl4,1249 +onnx/backend/test/case/node/greater.py,sha256=zyAT8q8q69ZQI0Rpz0RsY6GdoVDsPh75schE55j3h_s,2452 +onnx/backend/test/case/node/greater_equal.py,sha256=mWlyqWUyobNokBxRXo8T74W-eChNZ4_PZyG6BW37UXw,2574 +onnx/backend/test/case/node/gridsample.py,sha256=WMq5aqmr1zDRsTllv9LbofJjAS6sBaqMEU152w9EiO4,19717 +onnx/backend/test/case/node/groupnormalization.py,sha256=5m8lEmA5cFv-v58RKD3BHwkzPjIzHdGzkXMDnnnpD_I,2498 +onnx/backend/test/case/node/gru.py,sha256=EE1WWuTcj8U4sb--srFi5vMfUgAEAry4cb1NLdpTDUo,7853 +onnx/backend/test/case/node/hammingwindow.py,sha256=HgGD2mXvCGRL9XF8zg1QvUXYNHdZ7YzzhNAks87kU0c,1288 +onnx/backend/test/case/node/hannwindow.py,sha256=UGoM8d2dcI8Z4B_p7KX7FNv8MWLa7yQAg5NiifHiSMw,1222 +onnx/backend/test/case/node/hardmax.py,sha256=cn0gOig0yga2gSRvrp-N7RDgbm4NDk_ShSxNKSVofgA,2659 +onnx/backend/test/case/node/hardsigmoid.py,sha256=D0zzfntuxq20YHWilNa60KoFIJKecciBdL4rRwy2GJI,1256 +onnx/backend/test/case/node/hardswish.py,sha256=nOtQxXAgolMA-wAINwI8LQqH_Y3wGmEtBpOA6K4BfNg,734 +onnx/backend/test/case/node/identity.py,sha256=NjWOM3Cw7GpZwH8R1KJ-BjwKCofW4Oelah6iuhSjOgk,2369 +onnx/backend/test/case/node/if_.py,sha256=ccbDiscBU4Y-Ky163oqCvhk9ZoyWkQn4zy7s053_qJo,6475 +onnx/backend/test/case/node/image_decoder.py,sha256=zhnyt-pIFwzFKIm8R00rPr_LBHR8tVZTp53iwwbdi74,7381 +onnx/backend/test/case/node/instancenorm.py,sha256=G3uIY-bBJkz50mmCCKqMo9t0U170lzgh8IgQJ4PzwY0,2010 +onnx/backend/test/case/node/isinf.py,sha256=kSNdHfrMVa4WcuOG4sZ0RbupK9lcsPRJL2cq01AOUV0,1723 +onnx/backend/test/case/node/isnan.py,sha256=YyIKMX_VT7E_QZgKP2kbqRV_0-0AOuoEhF-uknTm-q4,962 +onnx/backend/test/case/node/layernormalization.py,sha256=036q41q4PzXUJQ7QuRtZtd68Y6qJWdF2qreKXrY1Fr0,6317 +onnx/backend/test/case/node/leakyrelu.py,sha256=OJvIRnsnBITPoetDvPUD2e61kIjQpMqx0PSNAD2t4ZM,1276 +onnx/backend/test/case/node/less.py,sha256=Tp32awh-eOh4Ig7kd_N229rsNOgaX2iTH-R0VQhKPy8,2386 +onnx/backend/test/case/node/less_equal.py,sha256=SUuUhNZg4TL1QK2QPwBM_xESe7MFNGWVtp7A7tQZALg,2508 +onnx/backend/test/case/node/linear_attention.py,sha256=ZIEI34xseB0O-0W96Gax9XgXQyu4z-R_Gay2ZOWuwOI,18779 +onnx/backend/test/case/node/log.py,sha256=yRBOF6G9UWEenqKD4svovKgRIJLoyBAygKWSa00KNsM,754 +onnx/backend/test/case/node/logsoftmax.py,sha256=8MilQ0Eb78nVoZZdmjIabYDmmwuyVMV5RcnduwyofXM,2773 +onnx/backend/test/case/node/loop.py,sha256=P1FDwU0vH-o9_ciMvU9Bn0-aHJqBJzdr87Zd_nXl5JM,14731 +onnx/backend/test/case/node/lpnormalization.py,sha256=tBATKWXjvq6oxknVLkUFXasUj33iADhxs9iVCK3AfP0,3152 +onnx/backend/test/case/node/lppool.py,sha256=AvVd4q96RDO3q3_CtZ7-Px9WdTHRw64dHw4ZU78t8tk,9007 +onnx/backend/test/case/node/lrn.py,sha256=-BYnNuEg-_PAcOVNHKuqujNmDcT3UzHHn2dJt2JyuVE,2096 +onnx/backend/test/case/node/lstm.py,sha256=PZZ8vXU3-TxyL22SVfbhdrMF1ul6Wo4UTbDirUsiHBE,8269 +onnx/backend/test/case/node/matmul.py,sha256=GfMCZlklY9ywwwAf3sh_yUFPseum6fGdZ8BJEXXJV8s,2040 +onnx/backend/test/case/node/matmulinteger.py,sha256=c0Vm-SfT7UGZzAFcSIBKZdjHeAnbwOZkoopexIIY33M,1331 +onnx/backend/test/case/node/max.py,sha256=I2Z43wijh9Uh0caGPHahM57soGITszWaD77iAAy0I_8,2044 +onnx/backend/test/case/node/maxpool.py,sha256=Zmc7wJ8S9Xxf8LSyNNKdLCrCjFpkYUobosUbqbUuFTc,22111 +onnx/backend/test/case/node/maxunpool.py,sha256=I2cWawXQ3r1BaY8rG1bfv9uAfijJ5Sbq1sAJVdz4Mbc,1954 +onnx/backend/test/case/node/mean.py,sha256=N-0TSfZSoVrZSBnled78o6qDA4X1BTVa1-U7kumUMPo,1367 +onnx/backend/test/case/node/meanvariancenormalization.py,sha256=WXeCOJlRo6CaBjWiZh5wZZo2tTf_4s1iFj_9qAh4jkA,1722 +onnx/backend/test/case/node/melweightmatrix.py,sha256=0Ut53xDYPGp-GpaH1lXwAD4J6gilnao9oNY58KQdUtk,3700 +onnx/backend/test/case/node/min.py,sha256=OOI3eiaveBp26qXfgk3y891B9aqSd9AvR0LSdQp_2cM,2044 +onnx/backend/test/case/node/mish.py,sha256=BmTmrzcsNLg32O_8k6bFPBjjOQL3ojyEBtJoLD9jSt8,655 +onnx/backend/test/case/node/mod.py,sha256=sVPbjKC8RYpJjOCfENAWb3WUMbLKBT5auyhYTQTPYew,6251 +onnx/backend/test/case/node/momentum.py,sha256=M6-GzDcWbkdSxvS5GH3pSCzVvTuE0SeisozovdDrQJA,5293 +onnx/backend/test/case/node/mul.py,sha256=k9RC2vlhb19NLIC9-RdfSp3PQ1qPmAeMqlko1Vr0wZs,2575 +onnx/backend/test/case/node/neg.py,sha256=lINwzp1guIA6MeVZ79NHAIGhvLHKs-0KTx2vrGVX8I4,750 +onnx/backend/test/case/node/negativeloglikelihoodloss.py,sha256=AkmANSHET9xZ1g8hdxUwoy8MU7qEgcSdfjASJewdwPc,19618 +onnx/backend/test/case/node/nonmaxsuppression.py,sha256=ctBkL-TE0K4fLlhhY2q-ZfSvlMBEDmJ-KlIkpQ_dqgo,16032 +onnx/backend/test/case/node/nonzero.py,sha256=HyZO-J-9_H5T7n1b5_9_kaFib2kgP5FGscrv4mEpQdk,723 +onnx/backend/test/case/node/not_.py,sha256=pocv1bTO60HRJz9jS6MKZF_lRKBKHCFkHJjaAKxGX3o,883 +onnx/backend/test/case/node/onehot.py,sha256=l_NVupGfAjGlLZL6l3m4vfIxgKNpz7YjJFEqFsHEW8w,3964 +onnx/backend/test/case/node/optionalgetelement.py,sha256=UifWMrF2v4RsI1OnxBG0w1H4j088q8kdQP9AjBi1kJw,2546 +onnx/backend/test/case/node/optionalhaselement.py,sha256=_5KovE2UCq1DviZdQTjE-p7hm_Y3SFDyCee9zWXByMw,3381 +onnx/backend/test/case/node/or_.py,sha256=wqVxfnf9cU1U-RPWEvc5I5JP20HaHXEu1Q6C6ZnGYn8,2482 +onnx/backend/test/case/node/pad.py,sha256=RvFV2vlZxzL6xFW15R5Ah1rximqLRDRSc1un7B9L5lw,3971 +onnx/backend/test/case/node/pow.py,sha256=zinfTJNod-TfScv-d85_MBUIPXFker-ASnOKeOewJ7I,3900 +onnx/backend/test/case/node/prelu.py,sha256=jGrIk397zBp0dwWVL0eo-5ArffRd37JMXi54Xnt1Ivc,1156 +onnx/backend/test/case/node/qlinearconv.py,sha256=RzbEzR7tqoVHXqWJvImb1gudZWOqaUS7iDUawcKpOSo,2295 +onnx/backend/test/case/node/qlinearmatmul.py,sha256=NyC7kmyJ_CGh2V7-qi3G9zna6hhmmBJfDkq3qJKgUB8,5202 +onnx/backend/test/case/node/quantizelinear.py,sha256=icM9d8Rgw58W9wag4YL8raXv0p1rR4kH-4zdkjfxgeg,13752 +onnx/backend/test/case/node/rangeop.py,sha256=CRznvTpuu5CfKoh2tuEW5yRxUaLrJdvVMHTmfrU9Bps,2828 +onnx/backend/test/case/node/reciprocal.py,sha256=GHpKRMoJolcZcB824IHfbXV7zw1KjHKKznXeVGyQq1o,790 +onnx/backend/test/case/node/reduce_log_sum.py,sha256=5QcDUAHeuavMUXfqQLiFgOS563hyNoX6xQNCe9-iU4k,3091 +onnx/backend/test/case/node/reduce_log_sum_exp.py,sha256=Edc8ypfSzrW4sFmFb5W8Q5O48z1SdG5W7iyQY_-p9xE,5778 +onnx/backend/test/case/node/reducel1.py,sha256=1nIrTeOk1Pz7yyk3FMfQ1NfsvvJTYSaSs_acHUk4Lqs,5604 +onnx/backend/test/case/node/reducel2.py,sha256=h2HbuG3zevg4HW9CBIXFrzpiEaXLKMKCQWU8wLHJcCc,6012 +onnx/backend/test/case/node/reducemax.py,sha256=N9nfeQOLELWXcYNZjfFYJjk2Xvn2WQZwJ4wVXEaUfOA,6721 +onnx/backend/test/case/node/reducemean.py,sha256=ljVhVspSOWHlQ5mO_bEPtxKz8wuFYmGZbdNbihnkLMw,4806 +onnx/backend/test/case/node/reducemin.py,sha256=eAmu0KephirQ63ieLLgp2wDdBA-mLHSXFnmZsz9N8Rk,6763 +onnx/backend/test/case/node/reduceprod.py,sha256=xirPwCytCdbkpdEAnMyjtiazScRsfzPOr3IYACPGCds,5303 +onnx/backend/test/case/node/reducesum.py,sha256=BxCKWYEjj-C4JifdMptAHJ3UZGHjPWmjXZe96mFQvkI,7155 +onnx/backend/test/case/node/reducesumsquare.py,sha256=fZIm10gWgSKciw8-VbUCsttOgsOVoGmlq7-dHv-mB98,5558 +onnx/backend/test/case/node/regex_full_match.py,sha256=osBUsG_aaKjBkRHPmLst6Db9PE7Kq12TjY87gs_fSXs,1914 +onnx/backend/test/case/node/relu.py,sha256=4BDK16A4cIVyKl4fOf5lm2mRIDQ23Hv8uglfdnLFNiQ,582 +onnx/backend/test/case/node/reshape.py,sha256=TyZpOQf41OdKl_dAajNBcfSWa8z4MPkoFSc-W2xcqr4,2889 +onnx/backend/test/case/node/resize.py,sha256=Sq4fz-H5TqQNBoYrAefhkI5yaMwuoJ9d8Dx5jM95LU4,51672 +onnx/backend/test/case/node/reversesequence.py,sha256=xdnlsxz6x7b8PHOqEzwvpUiyue8tYi1LNy55k6D1bEo,2240 +onnx/backend/test/case/node/rmsnormalization.py,sha256=VykCFn8SxYu61Ceg4-TfHbZe6VqvuIkdYkD8jiEVThI,3912 +onnx/backend/test/case/node/rnn.py,sha256=f_e6yNeXlxrZy9jKb5VbxHUz3KchuqQV1BVnekAQDR4,6425 +onnx/backend/test/case/node/roialign.py,sha256=P04pK0VpJcbPFn8WmBXv3JJAvSTe1SCUr3adSAIxUgQ,14904 +onnx/backend/test/case/node/rotaryembedding.py,sha256=LS8avZnb-FcSVN47cUpf3fdaFdVd8TghiKHm8fKUMNE,7829 +onnx/backend/test/case/node/round.py,sha256=OlDP75LGVbWAkWkTpYIuBGyn0XJAOd6ZCpCQ_qplu7I,1322 +onnx/backend/test/case/node/scan.py,sha256=6KZ7ucLh4dyshUaIg8YCuo3kNR1-x0yWhRUTQVeBdXo,5879 +onnx/backend/test/case/node/scatter.py,sha256=WTWqPQCX6IX8rU9LrPPnwC-GWB2iDRIaj3tshSpAZLc,3398 +onnx/backend/test/case/node/scatterelements.py,sha256=KLEB5USuLeg-z38-aZdLYIORGXwBDNWUPT3iAiSDCYc,8574 +onnx/backend/test/case/node/scatternd.py,sha256=JmrQcyRJNaYybw9RgKgbXomukgUd9pDMg5BT0itf6w4,8725 +onnx/backend/test/case/node/selu.py,sha256=6tVqvjOLtYFy5MQSKUlgRhbbLKkHSnqbazI92wY-n2k,1536 +onnx/backend/test/case/node/sequence_map.py,sha256=-LQ4LsAC-utck70Cwbv5DWwKtnlcwhCmWxfdoAd343o,10952 +onnx/backend/test/case/node/sequenceinsert.py,sha256=hdswDmJ7h8yS-uY5Le-k62s2GHcwhUgcbQreRb9cUJE,2589 +onnx/backend/test/case/node/shape.py,sha256=2cXLsniryxxgD4f6mWknwIyPf02HfA6EE0Ow75B0qdI,1688 +onnx/backend/test/case/node/shrink.py,sha256=TDG9BJLrRQTzRmHuzNfGWnVeS_2c83WBcPUmx0MX88Q,1053 +onnx/backend/test/case/node/sigmoid.py,sha256=rx68C13d1GBATDi9HhvB3CJY0OIhLBTjASXj2jGA9ic,853 +onnx/backend/test/case/node/sign.py,sha256=gnd51M30o-SYHYmyq_u2Rq1BXi_X2Bl7yRNex5GKx64,569 +onnx/backend/test/case/node/sin.py,sha256=ytQLDqxniR6BMco1TSnLQMCdYzu2pK683yfCZ_jJ8Jk,713 +onnx/backend/test/case/node/sinh.py,sha256=e_KG2Nb7tp7J3yhQBbJwB3PW4xNjH_YCETdqzzh4FJs,770 +onnx/backend/test/case/node/size.py,sha256=bwwQMnSHHYiaonwogFxl8YRK26Aw85ac_ePEsSciGsg,843 +onnx/backend/test/case/node/slice.py,sha256=JgYF_PVH5f7UDIrs2GMTeIurUNN84NQhnbyELpbOlMA,5270 +onnx/backend/test/case/node/softmax.py,sha256=8FKkHj916Ljzl8sUzZVipso-nYR0d2Y-G7_xnTuZDTs,2686 +onnx/backend/test/case/node/softmaxcrossentropy.py,sha256=Xg5kL_gMQRa-CT5QHWFjMOB6mA8LSShAroVk3KfNJUk,35653 +onnx/backend/test/case/node/softplus.py,sha256=28XPcm-di0LycJ6YBpT_z6qSMQCMNtdA1eol9phOfRA,835 +onnx/backend/test/case/node/softsign.py,sha256=vJRbLITh1-uVvTD5XhScYlxBHTXsZqlKhFbcNc2GIZk,777 +onnx/backend/test/case/node/spacetodepth.py,sha256=8isKu-O-pOBUHss1U0WLRig-z8ZJ87csq2Z9gMrRdJA,1939 +onnx/backend/test/case/node/split.py,sha256=Qfb4WD_fN0RgzphrPZHp89PUU-nG9OE2i7BLSOsUhhU,11845 +onnx/backend/test/case/node/splittosequence.py,sha256=NzVJttXq4MSI4-1EQxXtdw1rC-BTvKx4-QpKTaM42Ss,2129 +onnx/backend/test/case/node/sqrt.py,sha256=GmXODwH90fTnSbYsPPDtCY27e0jci0-t2tOtqtD1WSM,758 +onnx/backend/test/case/node/squeeze.py,sha256=1ah59mI-G-dsG7Exaofyf5L1jc7rTEjPlmEX9lFVVGY,1087 +onnx/backend/test/case/node/stft.py,sha256=D9ScFJKf1VM9MmK1R8a2URfjnkpOpt34DHm1_EKVTL4,2400 +onnx/backend/test/case/node/string_concat.py,sha256=CZsbcRyMo-oIpaXcUrqFt5lgwO5PXAOWyKk9GMZSOeg,1980 +onnx/backend/test/case/node/string_split.py,sha256=8UgQ0jcLVsf5tHf_p6dd50hXh9hZHRveT-Jj47KiB3Y,4128 +onnx/backend/test/case/node/stringnormalizer.py,sha256=_93q8mqHtmCKhJpZ8NAtFcuLOeJBYO1TGaQVoejnX9M,4428 +onnx/backend/test/case/node/sub.py,sha256=U5WnqQOcPV-E_JSR5So9IdBT5_f3KjruEwRHVERG_YU,2604 +onnx/backend/test/case/node/sum.py,sha256=UJ8_cGy5353yj0NDCVxqNxkJqOkf9uJIB2TCMS77eZA,1345 +onnx/backend/test/case/node/swish.py,sha256=ZaF8Jwvv-6uj6UKLSh839jQFmmW7GfiRikHTzg62XVg,851 +onnx/backend/test/case/node/tan.py,sha256=LpuSleikGrJWe8-1Po8AN76V28Y3vPU95Mb6kY601mc,713 +onnx/backend/test/case/node/tanh.py,sha256=B3f1GGwC1YFvaEeVyHUx7OTfusU6ZTtncPt9yRtgLVI,768 +onnx/backend/test/case/node/tensorscatter.py,sha256=CqIQZnPjk-5heKvG7T8Cdqy4R_F6MPvP7HkG2lTF4Xw,5207 +onnx/backend/test/case/node/tfidfvectorizer.py,sha256=m44dABdKZnJ4ZLr0CWTG89pdTjpyhY8O40WJmQsU6dw,8868 +onnx/backend/test/case/node/thresholdedrelu.py,sha256=XOah6W_3fLbiwZ2xMDPfXpaYnBmC-M7UWkrJ5xAbY-A,1298 +onnx/backend/test/case/node/tile.py,sha256=mmzJHGXklUv6UubLZrHO_w3b2FjQ9BkzGsl24V9Zix8,1103 +onnx/backend/test/case/node/topk.py,sha256=dTD1xNujcNcwPg1r0dMX-IEdLw5NRxzf33zVaa_dxfo,6761 +onnx/backend/test/case/node/transpose.py,sha256=WORevDhTJY4fdGsJWvAhtNXDu5tqD0G4DQzhDPudZS4,1391 +onnx/backend/test/case/node/trilu.py,sha256=WevCtEMH4IrDaMFltI82KWJO_IjEBpPdksWheEBVp2I,12514 +onnx/backend/test/case/node/unique.py,sha256=-sOVC46Dn3bUVwVXJLnn-OKrg2Nb570UyTAvR58dQ2I,7025 +onnx/backend/test/case/node/unsqueeze.py,sha256=7Zm1tne8v7J4BuA11dc_t7O9VzxyOZWBR2oa190aIcI,2767 +onnx/backend/test/case/node/upsample.py,sha256=GjmnZtOYUh6hlYpkVVE2BohgDtonQ9Reuw3xIHy0LPo,1372 +onnx/backend/test/case/node/where.py,sha256=ofNTYJrFOnq6fRBCbzdB4dwIlWtH9BExnELcrXAF4gI,1330 +onnx/backend/test/case/node/xor.py,sha256=97BoatckxHC9FiaLs747HKQJFsaNzrQgYzZn8xxfG18,2504 +onnx/backend/test/case/node/ai_onnx_ml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py,sha256=0hipRfyQKnXSG5tgZv686SDo78ZT9uzAo7DuvwFo3oM,826 +onnx/backend/test/case/node/ai_onnx_ml/binarizer.py,sha256=EgCFNr48lKRTTtY8OOOPYWQanGqLgGa1SiRFGXqZCMI,781 +onnx/backend/test/case/node/ai_onnx_ml/label_encoder.py,sha256=h0_bVuUz3UprQPRPm1kSuJzRmR4cqffFlkXJnm7jYZI,3045 +onnx/backend/test/case/node/ai_onnx_ml/tree_ensemble.py,sha256=Z20YeJbwmmTwKhOrduWNPSDRmvKptkB0EfBqmGypmnc,3907 +onnx/backend/test/data/light/light_bvlc_alexnet.onnx,sha256=Kvp4zvWoiu2dbj1j-5K9MwyRd6wVDRkYnGs-cgS6AhI,3968 +onnx/backend/test/data/light/light_bvlc_alexnet_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_densenet121.onnx,sha256=Sd21cSeX1hZPHYZL7arZJ95POQmtG0ujkKksL4FQ6fY,214344 +onnx/backend/test/data/light/light_densenet121_output_0.pb,sha256=9sxhMPy_kDFFImeGA7s9t-2POnl1SzfTrJXJouP03gw,4014 +onnx/backend/test/data/light/light_inception_v1.onnx,sha256=u3oObDcMcJ9WFe7vlhtDYo3hPQAJrk1vS_sNWupdgnA,36869 +onnx/backend/test/data/light/light_inception_v1_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_inception_v2.onnx,sha256=Ik131VsmVZqVnbYnw_QXpiP787MADSXwk5MnqpNdkz8,159024 +onnx/backend/test/data/light/light_inception_v2_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_resnet50.onnx,sha256=Bed6XJyc4JE_VJpQ1uus7V4P9oF7YeCbribkxb2QVeQ,79770 +onnx/backend/test/data/light/light_resnet50_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_shufflenet.onnx,sha256=xvQG1ivjbWtFclQsCVCiq9WfViNwaHkykGgLuon7r-U,67666 +onnx/backend/test/data/light/light_shufflenet_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_squeezenet.onnx,sha256=dwsPPIYj4Yv1i1N1TXEAUbTCaCSEIhQpgKEyu-bf6Qg,15618 +onnx/backend/test/data/light/light_squeezenet_output_0.pb,sha256=Mu7nS35YlymoBpJn3mW6aroogdDyQEGq6OUPaFMDwTY,4014 +onnx/backend/test/data/light/light_vgg19.onnx,sha256=jlR9cys6PWbuuPpkoCatuZTT21UvC71S5DbQYwDYmv4,9311 +onnx/backend/test/data/light/light_vgg19_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_zfnet512.onnx,sha256=ZES7WLmMPRT1UaO9uD7qnl234Ud5DbMRXER-nJqDOLA,4506 +onnx/backend/test/data/light/light_zfnet512_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/node/test_abs/model.onnx,sha256=h-jIWjxawEAXgf0TJ6BKjux7j6yN9-gTsr7VE0QDkFo,97 +onnx/backend/test/data/node/test_abs/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_abs/test_data_set_0/output_0.pb,sha256=2BNZUVKdYf3atI3XSL8OIxRDqBjEfFBVuhwUGkp0ndA,254 +onnx/backend/test/data/node/test_acos/model.onnx,sha256=2d7c_bcyxOqPcTXhvydGRRM0Nm6PVVHpbM2NIfaMC04,99 +onnx/backend/test/data/node/test_acos/test_data_set_0/input_0.pb,sha256=BcAjkpobMrS9vXiC_15TubU3Yu4pKcZr520PC6fKOT0,254 +onnx/backend/test/data/node/test_acos/test_data_set_0/output_0.pb,sha256=lRYNLwlHN1hfudhkE1gfGndrnWqvb6bqZ3YAu6Tf82Q,254 +onnx/backend/test/data/node/test_acos_example/model.onnx,sha256=qq_1hNEaqStnekpxiZvrRpEmvytsV28r4dYVZttSRU8,91 +onnx/backend/test/data/node/test_acos_example/test_data_set_0/input_0.pb,sha256=cD3gw75QWnhZYjV4loK8Tm8OhSPzT7cxIHtMB2cBq90,21 +onnx/backend/test/data/node/test_acos_example/test_data_set_0/output_0.pb,sha256=K2s964qJdp4TDGxtMjeynV0dAchEJfcNnxWvaSD8j_k,21 +onnx/backend/test/data/node/test_acosh/model.onnx,sha256=QZKg6nxtIAnh8EBVpuSaA-h95yYqwPHP9k3Tg62Phls,101 +onnx/backend/test/data/node/test_acosh/test_data_set_0/input_0.pb,sha256=MKsiayDTOWEgFMmPTwo5lylyk7-MtQrhW849Ff1C4-4,254 +onnx/backend/test/data/node/test_acosh/test_data_set_0/output_0.pb,sha256=Yrx90XQ3dzgx40XOm9v3vb5LQrD9rEhLfylCJBZFPpU,254 +onnx/backend/test/data/node/test_acosh_example/model.onnx,sha256=dVp7eRSUTLV6KFJQFcyyZe7pLmwa3-QngB7-Vl7VXSY,93 +onnx/backend/test/data/node/test_acosh_example/test_data_set_0/input_0.pb,sha256=NXIAFi1g76Ag1nr5wiDIiE6ilson7_t0kC_Qf5Ln6vg,21 +onnx/backend/test/data/node/test_acosh_example/test_data_set_0/output_0.pb,sha256=Gz3pLNpKQQzxib-93ikXb5WzkZogQuo8gOMoAOPLPH8,21 +onnx/backend/test/data/node/test_adagrad/model.onnx,sha256=W_0zemXPwyE0IPoGhB64im07jPvvYjUJn8SVDyyUv-g,320 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_2.pb,sha256=turuCuY1a0B6_bhynwjX2Kq-OrJi3HnwRSCOt5BZBLw,13 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_3.pb,sha256=hrgodO3LVW_LxTbUiK9tBvLA2Q7WZtXUW9itP9oqfQE,13 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_4.pb,sha256=kfqSznBP6jN2IJsiqQ1IeGKqLx8m6zYDnfqkjX-hUmk,13 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_0.pb,sha256=oCKisBmEjpP3XB3VhImrZp-lrCfEuSFzdJEk7DIOAw8,17 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_1.pb,sha256=-92hjiJXMpo3i8AkkMBKfoU_6I8-YQetue7lzslQneg,17 +onnx/backend/test/data/node/test_adagrad_multiple/model.onnx,sha256=0GfKCSbRa93cMC5F1SMr2KKHV-IIViABzwaCNRfA-Zk,465 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_2.pb,sha256=zSCQaDJuSfjV89lOKl_e8FAvaYdDg6UrH2n4eykC9bI,14 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_3.pb,sha256=A-40FgJNucPNFb_WksbMy0Z-E_EIV7RF0DP90kqbbC4,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_4.pb,sha256=CxeZGajewrwPha-MBoCdOi3nXJYzF9DgbGhOIwIqx3A,14 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_5.pb,sha256=stCGvEbBW8itgJbkRX1pnKZir080kytSIuTmZAkh41Y,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_6.pb,sha256=1-flVrzPmKolD0GSh-ld1wYZxSEIUx0TUpi_0ywedqA,14 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_7.pb,sha256=elUimbVps7sroUEVgzsr7m7OElV1YF29zVkzYA0YS-s,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_0.pb,sha256=UKTIQ4M58_6bp-LBagOe_d4VRwris7IFZ3ni0bWiVl8,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_1.pb,sha256=ipVVDyNyv3SavMDXeF1dVfWDMwjlgqbW33nRydOBFSI,22 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_2.pb,sha256=HonHMpF_AzJUt8IAnJmpNSnf38ARw54VShRtI15DTLQ,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_3.pb,sha256=0tufwJtRaRjRTHCQZDr7_arrlGvjPhOTqvCZJT9X2yM,22 +onnx/backend/test/data/node/test_adam/model.onnx,sha256=w9Ku8dNLby8i4QDTbajJOUXBeRMdrmvFW9GX1MGla3A,371 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_2.pb,sha256=q6Wsydvsci5ZJNiqDej1Kq17QzS3xOPWEruuLIgoorQ,17 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_3.pb,sha256=NQkKr3rClZp31gGf1Oyh_ECrr2_5AMVYn_fNdDazT8U,17 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_4.pb,sha256=6upGRVU5-O-5zKXoDu6cRsc2F036k6N02w_CNPHBGqA,17 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_5.pb,sha256=_sQAc0yH7uQipbdJe_N9EV_eMVJNNTb0bYSrlveTHSA,17 +onnx/backend/test/data/node/test_adam/test_data_set_0/output_0.pb,sha256=TVRVeKeatp47K62yu5zNe7emQcyoqRGVp2TET-REmdw,21 +onnx/backend/test/data/node/test_adam/test_data_set_0/output_1.pb,sha256=rK6Zk9eax3tUns3S7Oa55LN4GA_v8Udzv6uiSt35hMs,21 +onnx/backend/test/data/node/test_adam/test_data_set_0/output_2.pb,sha256=jn5qRVW1d5fDCKW6NTd6zhlOLzJWjh6PDwF_GotDvU0,21 +onnx/backend/test/data/node/test_adam_multiple/model.onnx,sha256=S--VdMqJo-UTG8-vT-1r-_Jujf10eAah5Gyv1N1Mk18,572 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_2.pb,sha256=zSCQaDJuSfjV89lOKl_e8FAvaYdDg6UrH2n4eykC9bI,14 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_3.pb,sha256=A-40FgJNucPNFb_WksbMy0Z-E_EIV7RF0DP90kqbbC4,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_4.pb,sha256=CxeZGajewrwPha-MBoCdOi3nXJYzF9DgbGhOIwIqx3A,14 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_5.pb,sha256=stCGvEbBW8itgJbkRX1pnKZir080kytSIuTmZAkh41Y,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_6.pb,sha256=Rc90FrQBRUlC-TzO9j8dMroSVATSdH027FaQzEtBeUA,14 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_7.pb,sha256=NPcgj_9FyMIJ3Ll5ChXoHxbUNPE7QquI-gnfMq4v000,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_8.pb,sha256=NP1McfMEN1DUKgTtTrLFqX-Q6nolS8o0IdLzi8r_YrA,14 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_9.pb,sha256=I1axqZFkXox9eUbvVASQWpaGtnfeL7UNt4kOQSINWY8,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_0.pb,sha256=gn-lzXgI1hDCYZ2_9ZQMcws-c0IlriCgT4tPfdZeMn8,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_1.pb,sha256=3poCofD7Nyg9KsIYTG-pJUfEtEz-G7JNKMvVq4fAIdc,22 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_2.pb,sha256=PhEvop64Uiv1n8ikOYjsoB_Wa2-5qXCpCJteJyKtgsM,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_3.pb,sha256=OFoiZH4lHPqV4YM4sO9JAUSITmDTLcFPGsDo_8g3nWk,22 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_4.pb,sha256=93pyGZX6OvmF1axeH3eJ18jCG9lt1X_Ne8aEOp2tcMs,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_5.pb,sha256=Gxk4rHZZEsF0zHPKYjeLAOb2bgc8Ty5pp4ow68emvvg,22 +onnx/backend/test/data/node/test_add/model.onnx,sha256=k88EOHBs3av2g63IsTyKF8S4sS2LzLGwQSaOH03_Ci0,129 +onnx/backend/test/data/node/test_add/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_add/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_add/test_data_set_0/output_0.pb,sha256=n_TAJ8n2D7D_tdElxet4CQ6etKybHAJmkYM7_MSHuy8,256 +onnx/backend/test/data/node/test_add_bcast/model.onnx,sha256=1WLvYrfpVB4rm_K1rmKXv-qn0UoZxok4gxiy3Np6FVA,127 +onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_add_bcast/test_data_set_0/output_0.pb,sha256=rG38BI9ZZ1bIw-G-vQNaVea2-iEFgzlnGrSk4JRQ6_s,256 +onnx/backend/test/data/node/test_add_int16/model.onnx,sha256=rYiol9wSb6JAWWoDfjUbvb5gJDlDn7dAwWcJLVtsZ_w,135 +onnx/backend/test/data/node/test_add_int16/test_data_set_0/input_0.pb,sha256=wl2xPpzkAZwHAMbv4knLCVdNyiJQYHaP5Qe1ue2nrDc,133 +onnx/backend/test/data/node/test_add_int16/test_data_set_0/input_1.pb,sha256=gTABZsLT2NLIbuU8igmJUMqiaPd-ps2PW-e6HLtII3o,133 +onnx/backend/test/data/node/test_add_int16/test_data_set_0/output_0.pb,sha256=fmY8ap8_F91KLPt4QDHQ3uJsmy0cDUvtF1O-6Fs_4mg,135 +onnx/backend/test/data/node/test_add_int8/model.onnx,sha256=lW3cSqf4meFg_UOWcCzvEY5QgatK5ynIplF5ySycKbY,134 +onnx/backend/test/data/node/test_add_int8/test_data_set_0/input_0.pb,sha256=-1zEaykKfLa3f5qr8dBDvr-gqoFvin0qw8CffkwoG9U,73 +onnx/backend/test/data/node/test_add_int8/test_data_set_0/input_1.pb,sha256=egKK8oCoEb8H4aGjzfFDNfyHyBDhR5BgxEi2ODHIVr0,73 +onnx/backend/test/data/node/test_add_int8/test_data_set_0/output_0.pb,sha256=bcv3JdoBFMRlWlhBsAtuh4bwtYqLclzb6NR31J7EeiU,75 +onnx/backend/test/data/node/test_add_uint16/model.onnx,sha256=EtWm4EOxhUvIIJ9CsVb9ZWQ4V2AJfmt7TAugLKfx4Ow,136 +onnx/backend/test/data/node/test_add_uint16/test_data_set_0/input_0.pb,sha256=Tl-U90VH-X3HK2DkuOG2ZUuePv4zbQ2iwClc_X_bq_Y,133 +onnx/backend/test/data/node/test_add_uint16/test_data_set_0/input_1.pb,sha256=6m28HUsBSX5xWH0yM7pobqd-zpSfb6cWpLhN5hkWO0E,133 +onnx/backend/test/data/node/test_add_uint16/test_data_set_0/output_0.pb,sha256=93EIsPeuCE1ICWzNj5eRoVSo_td16gGUu6VSGLCZ2X0,135 +onnx/backend/test/data/node/test_add_uint32/model.onnx,sha256=1W_EVO2E7CtYzDIVNgHf9PrVktJYidwZq3x0MrAx6pY,136 +onnx/backend/test/data/node/test_add_uint32/test_data_set_0/input_0.pb,sha256=qcy1RsZ7liy-jbG56aJlf2PUYVCH8nGPvu2rAoKPW9E,254 +onnx/backend/test/data/node/test_add_uint32/test_data_set_0/input_1.pb,sha256=q44AV8DGe251KqepdhpMQogLNBMw1cOe090VpH0TALM,254 +onnx/backend/test/data/node/test_add_uint32/test_data_set_0/output_0.pb,sha256=k2kMErHSDqj50A3nKZW3sktwW0qNS0RRESRWi6GPqSg,256 +onnx/backend/test/data/node/test_add_uint64/model.onnx,sha256=_EXAV4c6eIABXIZ2avHPlTgb5Hln_V2KxDThKsS_uzo,136 +onnx/backend/test/data/node/test_add_uint64/test_data_set_0/input_0.pb,sha256=TpMVTYd0Pu6U_POaifz9Khs0uH7mG8PEq94FxNRvv8s,494 +onnx/backend/test/data/node/test_add_uint64/test_data_set_0/input_1.pb,sha256=wD2sGRKL2eKZlqHxMih-LNsLbACWcqhuKEErZEKQhXM,494 +onnx/backend/test/data/node/test_add_uint64/test_data_set_0/output_0.pb,sha256=WODeKGb4X1j6HTbDKBlwrHl1kcZwbUXMZddIHB7nCxo,496 +onnx/backend/test/data/node/test_add_uint8/model.onnx,sha256=paL-5wnP160jtuJlWbv2GFpqDVJLSBw9E89HQMr8HjM,135 +onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_0.pb,sha256=EVUa5HxWewHuEcb4JNYJY8dWr4dBgZ0IMmFAeIPpzc4,73 +onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_1.pb,sha256=LwgHArxXsTueNTFHzvpvA1roIImjM1Qsq3dBlm8V6GE,73 +onnx/backend/test/data/node/test_add_uint8/test_data_set_0/output_0.pb,sha256=iraliI6zeDZmQrahTKGrXH7Iw2m8B9gWykqsmsLEaBE,75 +onnx/backend/test/data/node/test_affine_grid_2d/model.onnx,sha256=N1MYGhJOky81XKF5BJDmzv7JDq5WCJvO34xAh0We7Nw,182 +onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/input_0.pb,sha256=xNhlkk6TeMP0F2xjmLog6lBJCi2vqV0TLmDYgwOxYoY,65 +onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/input_1.pb,sha256=9IexbIORnsaGrx67T-L98-YYA-KmtPDfGzZD6aerfLI,44 +onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/output_0.pb,sha256=uRZQ1rXSePRYTb_ZVr4BLj02Aqz2t_o9_YQHAxrQmEU,499 +onnx/backend/test/data/node/test_affine_grid_2d_align_corners/model.onnx,sha256=gFQKW2xjdb1ehNLYBw1-qqZ3RzjeeZDxmTU1DWXZLBo,196 +onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/input_0.pb,sha256=xNhlkk6TeMP0F2xjmLog6lBJCi2vqV0TLmDYgwOxYoY,65 +onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/input_1.pb,sha256=9IexbIORnsaGrx67T-L98-YYA-KmtPDfGzZD6aerfLI,44 +onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/output_0.pb,sha256=CTfv2pPSSm_ufn5BP4gHTE0QxzdD3eUIvgjGL1FfUxA,499 +onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/model.onnx,sha256=Q-aiHyb8qkjxG8BntVqgr-R8UVFf3ONrvE-tvJyntRc,27753 +onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/input_0.pb,sha256=xNhlkk6TeMP0F2xjmLog6lBJCi2vqV0TLmDYgwOxYoY,65 +onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/input_1.pb,sha256=9IexbIORnsaGrx67T-L98-YYA-KmtPDfGzZD6aerfLI,44 +onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/output_0.pb,sha256=CTfv2pPSSm_ufn5BP4gHTE0QxzdD3eUIvgjGL1FfUxA,499 +onnx/backend/test/data/node/test_affine_grid_2d_expanded/model.onnx,sha256=uVLXuP4GRcKkbqFRMDq-d63jkG16eywVtohJBMsgoxM,22975 +onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/input_0.pb,sha256=xNhlkk6TeMP0F2xjmLog6lBJCi2vqV0TLmDYgwOxYoY,65 +onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/input_1.pb,sha256=9IexbIORnsaGrx67T-L98-YYA-KmtPDfGzZD6aerfLI,44 +onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/output_0.pb,sha256=uRZQ1rXSePRYTb_ZVr4BLj02Aqz2t_o9_YQHAxrQmEU,499 +onnx/backend/test/data/node/test_affine_grid_3d/model.onnx,sha256=vvTG1-5wXO-hfGRSMIm1JbO65u2SlgM_hOfgpciBbC4,186 +onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/input_0.pb,sha256=GKKhJUWROTNgqMF0BBN6u1jWxngTUkvfmq91xSw8ujE,113 +onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/input_1.pb,sha256=8ofzgCT9bt76McJqLRbG6-RVLDn_Fu3lLM5fvIQvlXk,52 +onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/output_0.pb,sha256=pUVBR8X7xyXEys7lztl4CGmzrN8w8qqcNraifjAZyjs,2901 +onnx/backend/test/data/node/test_affine_grid_3d_align_corners/model.onnx,sha256=6zPUSy7XbYX3riFyjKfV_3hK_PWis0vNtPFCePPSyQc,200 +onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/input_0.pb,sha256=GKKhJUWROTNgqMF0BBN6u1jWxngTUkvfmq91xSw8ujE,113 +onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/input_1.pb,sha256=8ofzgCT9bt76McJqLRbG6-RVLDn_Fu3lLM5fvIQvlXk,52 +onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/output_0.pb,sha256=ys1XMwqKQBT8wg-nNQiTLn0bqQ8cNSIVcIb-RIIZ1b0,2901 +onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/model.onnx,sha256=efWc8OfBgAOzmYmXcnVBfFBam6y9S23SMDkDEpTR79Y,27757 +onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/input_0.pb,sha256=GKKhJUWROTNgqMF0BBN6u1jWxngTUkvfmq91xSw8ujE,113 +onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/input_1.pb,sha256=8ofzgCT9bt76McJqLRbG6-RVLDn_Fu3lLM5fvIQvlXk,52 +onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/output_0.pb,sha256=ys1XMwqKQBT8wg-nNQiTLn0bqQ8cNSIVcIb-RIIZ1b0,2901 +onnx/backend/test/data/node/test_affine_grid_3d_expanded/model.onnx,sha256=mgQgiEhCSz4B5iN7ACEa7XUoUVanr7JXePPoMft5nqI,22979 +onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/input_0.pb,sha256=GKKhJUWROTNgqMF0BBN6u1jWxngTUkvfmq91xSw8ujE,113 +onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/input_1.pb,sha256=8ofzgCT9bt76McJqLRbG6-RVLDn_Fu3lLM5fvIQvlXk,52 +onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/output_0.pb,sha256=pUVBR8X7xyXEys7lztl4CGmzrN8w8qqcNraifjAZyjs,2901 +onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/model.onnx,sha256=-KqAy2YBDRwyqfinmfj87kNajZdOLQ5-h_HZqnrca1c,181 +onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_0.pb,sha256=XI00qhavYkKl_aHKei8a3IH_dsLyhI_Y57J38wFhkU0,59 +onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_1.pb,sha256=6bV-LPoUKmxMZqYVh7trsIYnlXnapYVYirqTx2WlSUs,25 +onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/output_0.pb,sha256=cT7VjDLALeCy6aKg9Vg7K9bxY5CnvFGrq3e2QRifANk,35 +onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/model.onnx,sha256=MGIz0rt69DiEaqhSFKzli15l4VhFz99Q_ysGnynGgv8,164 +onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/input_0.pb,sha256=IHiHIyablYLzOeKB32-oDw2gZhG5BoXro6hrposdegs,254 +onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/output_0.pb,sha256=WCPxC6xa9osg4LxN0y90PYcSuudpgzxjcx9gHKqwIxQ,254 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/model.onnx,sha256=BopT_IWMzV8xGG-EOoxKO-sCQHGxIoWvDwxZVsr8uwk,221 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/test_data_set_0/input_0.pb,sha256=EIRRN8kLHaDUGvwylx1GTclfNnQxZlqLbfifjMXq2nI,22 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/test_data_set_0/output_0.pb,sha256=oh_Q0pMP0Qv2ifITMtFSA-EiwxFl7OIKYlL75syu1SI,49 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/model.onnx,sha256=tEOvEj-q-C5bDPp-TRTczGefWLOPMSaI9OstQIoVeug,210 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/test_data_set_0/input_0.pb,sha256=EIRRN8kLHaDUGvwylx1GTclfNnQxZlqLbfifjMXq2nI,22 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/test_data_set_0/output_0.pb,sha256=h9Y93K7BmSLyWlaA97ZQq7wv4bwL9sGXYJwVOMcm7gA,49 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/model.onnx,sha256=_XiC_T8C4_tYJVfu6_cYYJ3yMjrmQMtEwcKJbbeyIXU,288 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/test_data_set_0/input_0.pb,sha256=EIRRN8kLHaDUGvwylx1GTclfNnQxZlqLbfifjMXq2nI,22 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/test_data_set_0/output_0.pb,sha256=xyaUKkcPIYhr44NLrN2_hh3bGKn8MXrJWypRsnY7wl8,19 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/model.onnx,sha256=2D1AghjlgsysNYKYNo-z9_2X_Aasq7OzyumqY-nFG0o,281 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/test_data_set_0/input_0.pb,sha256=EIRRN8kLHaDUGvwylx1GTclfNnQxZlqLbfifjMXq2nI,22 +onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/test_data_set_0/output_0.pb,sha256=xyaUKkcPIYhr44NLrN2_hh3bGKn8MXrJWypRsnY7wl8,19 +onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/model.onnx,sha256=9uNdicaEdAQjF_c6MPpDd6VgUBjtuMAz-exnLVLbxdI,656 +onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/test_data_set_0/input_0.pb,sha256=FA5pjARxPbin_jvJjIdpgk-hNLiGq24kabPh-rHs_Rg,35 +onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/test_data_set_0/output_0.pb,sha256=LG1b6rUx1h2kpOBLxnDF_P2oSn1fMgMlM6RXelI41P4,107 +onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/model.onnx,sha256=l7hQsQQZxkVR2dt5_eqYyo4pSaD7f4mW3CqhradvhTQ,598 +onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/test_data_set_0/input_0.pb,sha256=btAUcGyHALiwspzQrTF8GIeb1pflj31PZzD2dkxYU3A,59 +onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/test_data_set_0/output_0.pb,sha256=fciZjMVod9L3Q3eLk6i4Ttl-CgcNZxRtLU0jTKlQjEY,59 +onnx/backend/test/data/node/test_and2d/model.onnx,sha256=jvhZTvomeDvtnZRjIBB5C8xGTWc-N4woaVD1pjk_yfU,119 +onnx/backend/test/data/node/test_and2d/test_data_set_0/input_0.pb,sha256=LjNp_gf5HfToURj-fOV-TL_10b7cTqoOj8RfPTNPYLQ,23 +onnx/backend/test/data/node/test_and2d/test_data_set_0/input_1.pb,sha256=goZmxegiEZPjRTXScUiQU9fpxPndF4EqAZy8oeToa8k,23 +onnx/backend/test/data/node/test_and2d/test_data_set_0/output_0.pb,sha256=GcjmcM13wdXARvgFEuZBPW92lqso2-5sQMmJiIZovWI,25 +onnx/backend/test/data/node/test_and3d/model.onnx,sha256=jssi2o-pTtK6Si7NKEBEaxn9P5U4lmdUn0XF-YAJvnY,131 +onnx/backend/test/data/node/test_and3d/test_data_set_0/input_0.pb,sha256=Dr4k5dppNqEaWmFsMUXw_Pbp7QoEpqkXv4Bodqt7zMQ,73 +onnx/backend/test/data/node/test_and3d/test_data_set_0/input_1.pb,sha256=v5SpTzEGQijgxpt3GQdqFdpD-LCqlDgrPace75EL5pQ,73 +onnx/backend/test/data/node/test_and3d/test_data_set_0/output_0.pb,sha256=uCkMKeu3A5Fl999w3OJ0Fu3JjZpNFWJwCW-yupWBY78,75 +onnx/backend/test/data/node/test_and4d/model.onnx,sha256=fJ2a5gN50iVWK9QnSR_kCD16NE5gqeimgsReLfdAEgE,143 +onnx/backend/test/data/node/test_and4d/test_data_set_0/input_0.pb,sha256=sMKxU5gNQx6mv89ZOkmV0QCdEu9f8EhE-MZuoWNbcek,376 +onnx/backend/test/data/node/test_and4d/test_data_set_0/input_1.pb,sha256=9JaUvXVRf_NYTRwYWtPYsbSoKJDwOXPZuRBgFY7pYPc,376 +onnx/backend/test/data/node/test_and4d/test_data_set_0/output_0.pb,sha256=7z6DcqU4PYD4NBG0hBjBoQtn9AAU1HXoGQp_P6HX5ZY,378 +onnx/backend/test/data/node/test_and_bcast3v1d/model.onnx,sha256=V-L6MLM5UCLYeSkG6m8eMOy6OxDYPy3XvcGgesbt76E,131 +onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_0.pb,sha256=wF52hvLEXCfryTN0FvgWPKXSx3PPlpiaC_aAZ5IXCMc,73 +onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_1.pb,sha256=0cP0kHJ95VbmGsyJW3rlozPO38YQocSctc5buLas0ZI,14 +onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/output_0.pb,sha256=2zb5cHudGHSOWOFcjgMBQtTRJe48hbld128aQ2hbCy8,75 +onnx/backend/test/data/node/test_and_bcast3v2d/model.onnx,sha256=rkO8gZJ6USKFYpUWgKZDOVLVKrGaXIuHU-8heVXwwHo,135 +onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_0.pb,sha256=2Hi5gZzCyk3SWtB8dhtS5tIMipISnPJGI1SIjx08Fe0,73 +onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_1.pb,sha256=J1neLsOqZHTvGdagBF8_3O6sQk1byuUIMABR0wJxASA,31 +onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/output_0.pb,sha256=mdG-32ANjRiRrubGWEMBugaAkJKthCw74hqclFeUg0c,75 +onnx/backend/test/data/node/test_and_bcast4v2d/model.onnx,sha256=nQ71EhbbQRvGvdUrcCWMtA8gDvPy3CA3wyCmREtQu-4,143 +onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_0.pb,sha256=TG9PpNJBW-rhSdwYDpmwCMotWc8SOe2e2cLAoXaNQ8o,376 +onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_1.pb,sha256=D4JIlfVUzijC8rk152pkPsDWa33YJRlmutjMvkT-1FI,41 +onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/output_0.pb,sha256=BXDZEzEx30KZGRlX-QRAu_TfrftChYGi4jHGv64S9NI,378 +onnx/backend/test/data/node/test_and_bcast4v3d/model.onnx,sha256=lpW4vLVgx9F7FIKrqQ2KuHAfgS3hyDrL7HNjhnP7G40,147 +onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_0.pb,sha256=1gaunFCw_HO0ZAf_sAp9bfcwVRJW_aTJIwkv-2WYWMw,376 +onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_1.pb,sha256=26gLYNI9eQESqKzWzx1zrE8YDDCNIvfAE_0m_FoeT3E,133 +onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/output_0.pb,sha256=S4ncrzynkHE-cPqlleaq8UutgOSmUv4roECEsfI8u7o,378 +onnx/backend/test/data/node/test_and_bcast4v4d/model.onnx,sha256=TfEv0B9Q-1sIKlKXuKWAwVVrdJjWUkK6frFTvOHzfpM,151 +onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_0.pb,sha256=f63fGhPch5eTkAvMXCrJTC0FOIdhKnaSfJ8Ox9hnol0,39 +onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_1.pb,sha256=iCGDAU6H1-WHvqKKRCD44UWeluKsnFCWMpevbsJ5ASU,105 +onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/output_0.pb,sha256=WAS1y88UC7m0RqEGzxSzw4NBXEUt8_2JlykNVAzyVVM,378 +onnx/backend/test/data/node/test_argmax_default_axis_example/model.onnx,sha256=5gOsN-W4GWrgix75Y31K_ghoeSHrVbkLZ5U27gTbyvU,149 +onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/output_0.pb,sha256=NoozXBTfuGBGESaqTAVgvBaY_2_1KnEXaCBKowhZYgc,32 +onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/model.onnx,sha256=u0lNlP1UgUDRYDOHkWuB1E_PdfT8K2RLKi9q1vfJZgo,194 +onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/output_0.pb,sha256=NoozXBTfuGBGESaqTAVgvBaY_2_1KnEXaCBKowhZYgc,32 +onnx/backend/test/data/node/test_argmax_default_axis_random/model.onnx,sha256=-ioQatsDKz2cdDFAFf4kVlt_rTVhEEST2Iooz_Zo_Lc,157 +onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/output_0.pb,sha256=DhGaHjs8SV8OufGMy1I7s0-ROoSwvKKmES2wj44RaVU,114 +onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/model.onnx,sha256=8DJmQWRw4NmhbgZNFemfZDS2J1glGNrvaUFAejj1Mtk,201 +onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/output_0.pb,sha256=DhGaHjs8SV8OufGMy1I7s0-ROoSwvKKmES2wj44RaVU,114 +onnx/backend/test/data/node/test_argmax_keepdims_example/model.onnx,sha256=9r9MwZu1aFQ7Tuu-ALVKqHWJmPLJPAlEqr98a_PkcFg,159 +onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/output_0.pb,sha256=4F0-PRVXRwzEKW10dABm9QzkLNzVaRoMkYLi7CvSpnA,32 +onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/model.onnx,sha256=N5h3EbEADdYKk5cC1XlMHsxpoWPXDYCbsITbAdw0m8w,203 +onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=yjB4LORCAlt1ELQfYeptdZNSWozEnXkHE_Yw0FOF4Lk,32 +onnx/backend/test/data/node/test_argmax_keepdims_random/model.onnx,sha256=etLTCThXENf6WD3LX2dOaZ2FAddcKBgIggT4QA1788M,166 +onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/output_0.pb,sha256=xxKUj1nPly6oZ31Db1ZlT77n2WMOc93PhGls_r46NyI,82 +onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/model.onnx,sha256=xk8Wg2EFTAVwfXy_DALKhdY-MCHrdQW-9fEjHDNToC0,210 +onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=xxKUj1nPly6oZ31Db1ZlT77n2WMOc93PhGls_r46NyI,82 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/model.onnx,sha256=4BvTuA4BDbWrJS-mfVHt2bFqnhLgWfn8HRJvck064co,182 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/output_0.pb,sha256=4F0-PRVXRwzEKW10dABm9QzkLNzVaRoMkYLi7CvSpnA,32 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/model.onnx,sha256=oak-YBL_HjQVmKcqwkeld5P7mSMFHVVjk1kHxt25lkw,226 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=yjB4LORCAlt1ELQfYeptdZNSWozEnXkHE_Yw0FOF4Lk,32 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/model.onnx,sha256=jNr6hd_05wJ10QiWMMLcKORD2Hk-vUqJgX3J0Vavt_Q,189 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/output_0.pb,sha256=rr10tTLghcLkMi30lMGX-yxUk_YBi6rKL8m3VnjtsiI,66 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/model.onnx,sha256=CTLMBC-WEWztkyuVbzNLJGT2QJ-pB-pevX2SsHozLEY,233 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=rr10tTLghcLkMi30lMGX-yxUk_YBi6rKL8m3VnjtsiI,66 +onnx/backend/test/data/node/test_argmax_no_keepdims_example/model.onnx,sha256=rHuO3OTD5eRTyGpiTrFsGGyzDC8iDwVYuLDRbMAfRpU,158 +onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/output_0.pb,sha256=U570gmgD-FKNrX-L5G6HOIWOStTE8-Fpciy-B646kUU,30 +onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/model.onnx,sha256=O0jhRm19HyzVNZKWKApMpgR0TJ6aJux5d7YHF9Htfw4,202 +onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=q_pzvm7B9F06AGaDCm-ypSJ7iOO4k08SqKZnIWxn5YU,30 +onnx/backend/test/data/node/test_argmax_no_keepdims_random/model.onnx,sha256=aM8dVMPJE1DI3Up-JVkHJvVPRj_7UW7uNTxly9j-aVE,165 +onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/output_0.pb,sha256=Y4g-JZ7vtzt484_YeaxF0sGDj0IUC3Ow9h7-3AMEOwM,80 +onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/model.onnx,sha256=6mhwUs8s7PzTMl4Zm22UNCwAQjRhMF93a7u-BhqUVoU,209 +onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=Y4g-JZ7vtzt484_YeaxF0sGDj0IUC3Ow9h7-3AMEOwM,80 +onnx/backend/test/data/node/test_argmin_default_axis_example/model.onnx,sha256=iebLNVL1fxxh-j3DH5boBJGFNt8r2YAI_7_rP3LADu8,149 +onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/output_0.pb,sha256=Bj_kN290f3RUlkABfWUh5o5MQuxnM-jXtBc-onOuETk,32 +onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/model.onnx,sha256=qHYIVhWQ_8CbsMYeyYUWyg5wRPK25HQfuHsz_NjSr9E,194 +onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/output_0.pb,sha256=Bj_kN290f3RUlkABfWUh5o5MQuxnM-jXtBc-onOuETk,32 +onnx/backend/test/data/node/test_argmin_default_axis_random/model.onnx,sha256=_spSgaLvVIIaJFONNMGKGi5lR4DHEAcd-ZA0bUdo2Pg,157 +onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/output_0.pb,sha256=19x-g4YHmp9zWbUdC3zmRnrC_YGZiCXOH6ZYat-OKos,114 +onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/model.onnx,sha256=ONXMwWYnms6w9bXmYZQgtnyYEtnMbIa8Zg5mQb3rWl0,201 +onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/output_0.pb,sha256=19x-g4YHmp9zWbUdC3zmRnrC_YGZiCXOH6ZYat-OKos,114 +onnx/backend/test/data/node/test_argmin_keepdims_example/model.onnx,sha256=jG3yLmfOLrln-g0UAq1T54CRlzEEcIHedSy2su1NvvM,159 +onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/output_0.pb,sha256=Q0yB3rE94zUcdgoZieunw0TZyHYIKv7PGv-_zINGDwM,32 +onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/model.onnx,sha256=3VpWljrpe_M0zxcrpMYgTIxCNT4_Wy_cXHs3xP5EiXA,203 +onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=Q0yB3rE94zUcdgoZieunw0TZyHYIKv7PGv-_zINGDwM,32 +onnx/backend/test/data/node/test_argmin_keepdims_random/model.onnx,sha256=a8TjWBkgVRdOTdgVV47nuGKlqjkylM4H_7SVVa21Gxg,166 +onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/output_0.pb,sha256=n6D0HfXyUX61D0a6ma7Iu4yTDIR_AixA4NxI2eQ0xzo,82 +onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/model.onnx,sha256=yStGGRrrd8ILfWWnSVSQh-nB9jvwj0blZHRJHbpQdVo,210 +onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=n6D0HfXyUX61D0a6ma7Iu4yTDIR_AixA4NxI2eQ0xzo,82 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/model.onnx,sha256=Qdcw6P4ShcjduyyWa2edCGBhuC27PN_UAhDQCmDkqck,182 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/output_0.pb,sha256=Q0yB3rE94zUcdgoZieunw0TZyHYIKv7PGv-_zINGDwM,32 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/model.onnx,sha256=nu8X7vFhj97yEguRh_mA5BiMbyiUMuSwRGR07TklqeQ,226 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=Q0yB3rE94zUcdgoZieunw0TZyHYIKv7PGv-_zINGDwM,32 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/model.onnx,sha256=6J7PgD_k3Fi2wUdzP7doBFOHxEd4w4En7b9JIZ7rNuQ,189 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/output_0.pb,sha256=QiaUgxoImJVzGqsKXpeRoj5YIhs4TSmZNujE2jRpNYE,66 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/model.onnx,sha256=LqozWLlzhVSjSmkkRy5qE4bfDHr2zjeEhz2c0eLQmSs,233 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=QiaUgxoImJVzGqsKXpeRoj5YIhs4TSmZNujE2jRpNYE,66 +onnx/backend/test/data/node/test_argmin_no_keepdims_example/model.onnx,sha256=xk1tQnhxenLqqiNWasT9qPvWf03sxIHmWRWpIVL8zyQ,158 +onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/output_0.pb,sha256=orTottlTXJm72VAuuI4Z4Wm5MdszRna3fvV3HAflc64,30 +onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/model.onnx,sha256=M9mq_Nks8i-0ic_sUhv6nJt4wTL0hdfKLYQd8COtiJs,202 +onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=orTottlTXJm72VAuuI4Z4Wm5MdszRna3fvV3HAflc64,30 +onnx/backend/test/data/node/test_argmin_no_keepdims_random/model.onnx,sha256=BPo7t0D-DdFCNfgyDYp6CELjFD1Y7GOC1_b5jnpu_GQ,165 +onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/output_0.pb,sha256=1k5tX4X36O2Fo9-48qFsRj3eAH2qLSUtS2alMh32hKM,80 +onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/model.onnx,sha256=G24mWmUuUdRohHXsk32EnB_fkE3bIDiSeetlrHg5ysY,209 +onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=1k5tX4X36O2Fo9-48qFsRj3eAH2qLSUtS2alMh32hKM,80 +onnx/backend/test/data/node/test_asin/model.onnx,sha256=WI7ht4V4qPvmemfDJNtkUEWxSS26V7MNIRsjJmGosWo,99 +onnx/backend/test/data/node/test_asin/test_data_set_0/input_0.pb,sha256=BcAjkpobMrS9vXiC_15TubU3Yu4pKcZr520PC6fKOT0,254 +onnx/backend/test/data/node/test_asin/test_data_set_0/output_0.pb,sha256=u9s_EapOLdfpDm7_h7j6kMIc1Xc73Byi-SkQpYwk5is,254 +onnx/backend/test/data/node/test_asin_example/model.onnx,sha256=IXDi_XqNBsqHBXfv4Zuf0kk_qAs_duxjgRVN105EjeU,91 +onnx/backend/test/data/node/test_asin_example/test_data_set_0/input_0.pb,sha256=cD3gw75QWnhZYjV4loK8Tm8OhSPzT7cxIHtMB2cBq90,21 +onnx/backend/test/data/node/test_asin_example/test_data_set_0/output_0.pb,sha256=FllD0s9HRvharNPBoXUEszaIk91MR79Tz0s1OwzXoi8,21 +onnx/backend/test/data/node/test_asinh/model.onnx,sha256=R4ZQw0aLOgXVKlwBg5aG8aOGYMhjWdgM0AMSpMMhPho,101 +onnx/backend/test/data/node/test_asinh/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_asinh/test_data_set_0/output_0.pb,sha256=OSyeQFYbXqnXu9FHx2wqEGpOugaeCVOSoBT-ELGWS4U,254 +onnx/backend/test/data/node/test_asinh_example/model.onnx,sha256=Dhd9jj7Wt5aQNLHAjWHslDxIBUf_lhK8diUmtxTYRrg,93 +onnx/backend/test/data/node/test_asinh_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_asinh_example/test_data_set_0/output_0.pb,sha256=8Fz60rR3DIxDgwmw7EMak08D9yt0M6Bb9psXbH1p8kw,21 +onnx/backend/test/data/node/test_atan/model.onnx,sha256=raCkn93L_Hf70231Y2Koz89cPJ4SzPk1ZPvtJcHX17o,99 +onnx/backend/test/data/node/test_atan/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_atan/test_data_set_0/output_0.pb,sha256=kHD-XwUIE1V_kMPmW2vHkG1j1ghWwx0k1B2AxQ2p9W8,254 +onnx/backend/test/data/node/test_atan_example/model.onnx,sha256=olIEMUvIV0DEu59DthSfadWfsOm0tIPHGcmUefT_y9E,91 +onnx/backend/test/data/node/test_atan_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_atan_example/test_data_set_0/output_0.pb,sha256=kWWl9gDeCxk2l09E1LE-fw9VMRIYYxO2XDgPuZz1Ff8,21 +onnx/backend/test/data/node/test_atanh/model.onnx,sha256=OZUm91BEHFELgIzfRKAzaUgpjSBOuc-pkFpzW-OgYRk,101 +onnx/backend/test/data/node/test_atanh/test_data_set_0/input_0.pb,sha256=BcAjkpobMrS9vXiC_15TubU3Yu4pKcZr520PC6fKOT0,254 +onnx/backend/test/data/node/test_atanh/test_data_set_0/output_0.pb,sha256=r-fX1_Rxm17m9hCcqYIvuLdAs9mKxAt73siRxDdnWbA,254 +onnx/backend/test/data/node/test_atanh_example/model.onnx,sha256=TJq53DQkceHFfoxDW-C_-Hzrot7Qffp3AjefCWaGOuo,93 +onnx/backend/test/data/node/test_atanh_example/test_data_set_0/input_0.pb,sha256=cD3gw75QWnhZYjV4loK8Tm8OhSPzT7cxIHtMB2cBq90,21 +onnx/backend/test/data/node/test_atanh_example/test_data_set_0/output_0.pb,sha256=lnjpP4k_gQIoWj-p9POCPLQsNe7mT3U9ArJG73iZBro,21 +onnx/backend/test/data/node/test_attention_3d/model.onnx,sha256=aS5qG4J639pef7LBolGcq4EpW1jPIFWBeCNV-fDMGMM,210 +onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d/test_data_set_0/output_0.pb,sha256=cpAIXuUUwGOa9RQsQH9XnPL3iwrzWdx3ufLBNPqTt8w,782 +onnx/backend/test/data/node/test_attention_3d_attn_mask/model.onnx,sha256=lSg1TEEvXj1ahKaFIf0YPNG1Mk9ENoMvMT-fjhKztVs,260 +onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/output_0.pb,sha256=nXCWeyek2c14_jLt0Z8JqAsw0-MSt8aURAGfwRoF384,782 +onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/model.onnx,sha256=a-RAYY6VvFtQfGw84eG4IQRzKtdE9hqCT7jPpDUiMKY,13543 +onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/output_0.pb,sha256=nXCWeyek2c14_jLt0Z8JqAsw0-MSt8aURAGfwRoF384,782 +onnx/backend/test/data/node/test_attention_3d_causal/model.onnx,sha256=ExEYG7MNqdAf5eUHVnYoi-VHxtu8AUEZADx4AdFxJXU,235 +onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/output_0.pb,sha256=l3TzVYTIMhyWJNqF-FPtlXTG2-cKu3TyQd93c2EOjrI,782 +onnx/backend/test/data/node/test_attention_3d_causal_expanded/model.onnx,sha256=0O-GZBa0mTHPy4EL8J4U5Ay0F4SvmXN5KmAVa2voV5k,15629 +onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/output_0.pb,sha256=l3TzVYTIMhyWJNqF-FPtlXTG2-cKu3TyQd93c2EOjrI,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/model.onnx,sha256=ZLTU1gqwIyiRjnjXhyepNiLBddjYMyjfy9gCuuLUszM,227 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/output_0.pb,sha256=xEp7dJywtOQT08wU_4Rtohf1bTZ637uc40rySqmVM_8,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/model.onnx,sha256=kBqPS7vsphjOkiXq5y9qhhPThQ6GBqt9lnU0j8Dwsm4,277 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_3.pb,sha256=wvCfnJA1byd40Fz2GiQXfRn3WG4-dWv43rQPs0d5dJ8,115 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/output_0.pb,sha256=V7Ps_W2NhMmqY4eY6za0stncz6xxd9f6tDnSHc8F9Pk,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/model.onnx,sha256=Ypak8U8vO1x7c5d7TEmCqCZ7oh9GHt3FzrrwlimDRn8,16436 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_3.pb,sha256=wvCfnJA1byd40Fz2GiQXfRn3WG4-dWv43rQPs0d5dJ8,115 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/output_0.pb,sha256=V7Ps_W2NhMmqY4eY6za0stncz6xxd9f6tDnSHc8F9Pk,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/model.onnx,sha256=pAZOlJY3ZdJ2jYQZq7C782pMl1hCLZWp-dQf8God3Mc,252 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/output_0.pb,sha256=K6zh4voEFUjSB0GjsCoSztwSUoyePSdwHf6CFPdZNqs,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/model.onnx,sha256=GjpsI4dk5jPWRygfOUBPELB2lAf4EC1OVymD8ReBc2k,19168 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/output_0.pb,sha256=K6zh4voEFUjSB0GjsCoSztwSUoyePSdwHf6CFPdZNqs,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/model.onnx,sha256=88IiKCSK6OfBANmb5SQICTuVEP7ncS1gjnBxDrk9qlE,14610 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/output_0.pb,sha256=xEp7dJywtOQT08wU_4Rtohf1bTZ637uc40rySqmVM_8,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/model.onnx,sha256=5W-JQ5RLuQupAaY9I1Mg7EZAkRuRCM55t_qlkqMKUO8,251 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/output_0.pb,sha256=gfMdPffsSyLsb6JOH5UvUiImWBuFGgDPlB7c-X3ByOc,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/model.onnx,sha256=Fl6MEpTf-QKzRrsTwIT6_iJ-8n5-QyIIuMpj9qE7n4k,15784 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/output_0.pb,sha256=gfMdPffsSyLsb6JOH5UvUiImWBuFGgDPlB7c-X3ByOc,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/model.onnx,sha256=1VWYNYblQ5VCC7WIlpRnup-RjtjrfGk9NCPXKdt9YI0,254 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/output_0.pb,sha256=IEe1Wuq72pI821b7EIY4nG5JqrjUG3Tx_h6tN0OQPVM,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/model.onnx,sha256=6Zi3NaNQ6phXc78imjTWXDsCGHjtAbAWl8Y8cdYpA08,16969 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/output_0.pb,sha256=IEe1Wuq72pI821b7EIY4nG5JqrjUG3Tx_h6tN0OQPVM,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/model.onnx,sha256=LPVQMoOD-LAH807QzWEl32_op-9WCgolwSvniuAHp4k,487 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_3.pb,sha256=H8kLnArjipSp3pGoJbA1Zk5BkpywZyTZ_JAmS6xIFVw,308 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_4.pb,sha256=qMlPWsQPOfC-4L3I_k6NTZd9fph9H1UF0YmXEhTtZrI,2327 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_5.pb,sha256=JtO_M8zNGcIVOjwKMSmOqqOR_kKZM-sgZ_Vg68KtiJY,2905 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_0.pb,sha256=mvE-BcyHqIHAHls5qikL7BTrwdH-C4k11Tt0KgTPq1c,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_1.pb,sha256=qZbtKCoJxvDHCdgTF0-NXJMy74x0_6wuHA_hP6pxSA8,3482 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_2.pb,sha256=L7DfAsxRfTLPdmaszJtYaz2HC-7jzn3retOZCpY11Dc,4348 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/model.onnx,sha256=niijYBIfLgF_ngNCSDRs1WlElopIZ90b9ZBvyWCF5_s,17929 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_2.pb,sha256=07XM3RXkJbWrWCqw1FW8gevBVoLncW36isabUsRf4VU,1454 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_3.pb,sha256=H8kLnArjipSp3pGoJbA1Zk5BkpywZyTZ_JAmS6xIFVw,308 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_4.pb,sha256=qMlPWsQPOfC-4L3I_k6NTZd9fph9H1UF0YmXEhTtZrI,2327 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_5.pb,sha256=JtO_M8zNGcIVOjwKMSmOqqOR_kKZM-sgZ_Vg68KtiJY,2905 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_0.pb,sha256=mvE-BcyHqIHAHls5qikL7BTrwdH-C4k11Tt0KgTPq1c,974 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_1.pb,sha256=qZbtKCoJxvDHCdgTF0-NXJMy74x0_6wuHA_hP6pxSA8,3482 +onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_2.pb,sha256=L7DfAsxRfTLPdmaszJtYaz2HC-7jzn3retOZCpY11Dc,4348 +onnx/backend/test/data/node/test_attention_3d_expanded/model.onnx,sha256=8XgX6eAc889HvwN8KNoWGo7xF8eU-85WizgiT8EibgE,11732 +onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/output_0.pb,sha256=cpAIXuUUwGOa9RQsQH9XnPL3iwrzWdx3ufLBNPqTt8w,782 +onnx/backend/test/data/node/test_attention_3d_gqa/model.onnx,sha256=cM6-bb27PMDJktTP0op28bXAsYd1b5Xi2e4ubXODLAk,214 +onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/output_0.pb,sha256=hMU2RLqU30ASUfvlKaRDBcyYUqbetRgn2d1MZa_dQMY,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/model.onnx,sha256=_nSOB2eqrtT5dMJOEHLJH_Qnz8lK3n3Dq_ig1FABIZg,264 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_3.pb,sha256=i1yCXhuL1ahdW-3ZxqYy2z6uPG7m9h19Cy-rDkPOBqE,115 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/output_0.pb,sha256=Vv0g6mCijKXxRQsQbnnKVmTDdLYDygKAQuZF2eKu1cY,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/model.onnx,sha256=Tlf77jfCAQ2am23pRiwlkXVzQ8_WoH21zjdEciUw7H8,14223 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_3.pb,sha256=i1yCXhuL1ahdW-3ZxqYy2z6uPG7m9h19Cy-rDkPOBqE,115 +onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/output_0.pb,sha256=Vv0g6mCijKXxRQsQbnnKVmTDdLYDygKAQuZF2eKu1cY,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_causal/model.onnx,sha256=dehgN5mCloK0zt-m83iUMYOsKtCAr4DX4klLbZ_iOSU,239 +onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/output_0.pb,sha256=qLqnYQc8ZSs2qXqM4Emr2ZyPBrqpDs2VSx8ckURQ2M4,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/model.onnx,sha256=w514_KdpLxYQWsGSIJvawNYDhUYuJ7fsjzky2QqoMoU,16462 +onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/output_0.pb,sha256=qLqnYQc8ZSs2qXqM4Emr2ZyPBrqpDs2VSx8ckURQ2M4,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_expanded/model.onnx,sha256=QgzMc1ojevL8BolGcNqsZhHvSinSr6fVtrxaHB57Ymk,12411 +onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/output_0.pb,sha256=hMU2RLqU30ASUfvlKaRDBcyYUqbetRgn2d1MZa_dQMY,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled/model.onnx,sha256=8oF1op_FdAwBB4BNqyj5wNpjwLLEsNtbVHvM2ub2PT8,238 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/output_0.pb,sha256=1O7ScZW6-MARdOyNXQHq6XIiwHMfVaOvC5YuCSQykKU,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/model.onnx,sha256=YT8X7ENXK5Bnvipa3vKpcTeK2zi1zDuqCPBV47m2eT4,13585 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/output_0.pb,sha256=1O7ScZW6-MARdOyNXQHq6XIiwHMfVaOvC5YuCSQykKU,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap/model.onnx,sha256=XCuh_ujpupIQAgs8hAAO5jagTpeLrpHHTsjboVqjAlY,241 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/output_0.pb,sha256=NajwIneLYFx5kaLt30kS_SSk5frzqXqE1uwk120VhJM,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/model.onnx,sha256=fvQ2DEU4ge9RcqlVETDBmTkHfS7fBuZvHw15qB0Vmbk,14626 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/output_0.pb,sha256=NajwIneLYFx5kaLt30kS_SSk5frzqXqE1uwk120VhJM,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/model.onnx,sha256=4XZ_zhHt-nkYYNkC8YqDAz2YsCQqTPWlouOnRzdCttw,480 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_3.pb,sha256=_sPeS4Lvc1qY8MrqVqerNfDz_FIuMLeOWMOulRRPys4,308 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_4.pb,sha256=bKIWowWpcvjjproWUbDmSLDH5pVh0qhAQ6iANQz8-P4,2327 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_5.pb,sha256=8Yh9Qu30bbazYRwrweTDIbrSvMKMafAMVs2qcYHHTDU,2329 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_0.pb,sha256=w-d8LQ9BQUnUXokTPWbfoua2e7l6mxHwSVotj252nFY,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_1.pb,sha256=742etsHynmYp0AMxK6YT6XezC5bSkAbPeabSetwMPc0,3482 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_2.pb,sha256=WQ6tzHRt-kmsEdSUgcXMabMtOCCEm95vej8jN_LsUFc,3484 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/model.onnx,sha256=WB9vxBEh6t5f6yJl89XyTC7SqwxE6PxuOgrNkXbgNL0,16721 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_0.pb,sha256=HNPMZIgJRztoCTftPHnoV5QJtDDecJFkKf3WqFxifcE,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_1.pb,sha256=78kPcanObcZLa5kyNRkdZ28R1BiJaBLZsMDG6gNekSg,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_2.pb,sha256=kgmmmqjeysQo7Zkbj5mdGrj3SmfgtqqW_D3866RWx0Y,1166 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_3.pb,sha256=_sPeS4Lvc1qY8MrqVqerNfDz_FIuMLeOWMOulRRPys4,308 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_4.pb,sha256=bKIWowWpcvjjproWUbDmSLDH5pVh0qhAQ6iANQz8-P4,2327 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_5.pb,sha256=8Yh9Qu30bbazYRwrweTDIbrSvMKMafAMVs2qcYHHTDU,2329 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_0.pb,sha256=w-d8LQ9BQUnUXokTPWbfoua2e7l6mxHwSVotj252nFY,2318 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_1.pb,sha256=742etsHynmYp0AMxK6YT6XezC5bSkAbPeabSetwMPc0,3482 +onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_2.pb,sha256=WQ6tzHRt-kmsEdSUgcXMabMtOCCEm95vej8jN_LsUFc,3484 +onnx/backend/test/data/node/test_attention_3d_scaled/model.onnx,sha256=EFx58F88UIhlbUzJbkSSQKpFrkP7ij4KqNfK6RenqSo,234 +onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/output_0.pb,sha256=1r-hA6bbMZqtiGcezPK0DjP0O5EniB8qlUqByQmBvqU,782 +onnx/backend/test/data/node/test_attention_3d_scaled_expanded/model.onnx,sha256=UoHmf9KD1368ThHo-rdftaeFWRtQ4zdIqfqCJBhwRRM,12909 +onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/output_0.pb,sha256=1r-hA6bbMZqtiGcezPK0DjP0O5EniB8qlUqByQmBvqU,782 +onnx/backend/test/data/node/test_attention_3d_softcap/model.onnx,sha256=xdxlWp0YBvs-6QevSiDXyEMSlKFXqPp1VlUjEL_X6mA,237 +onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/output_0.pb,sha256=nrxi4EOmtEuVwrWX7T0OkHfUseZeJStt06LLKlYCkw8,782 +onnx/backend/test/data/node/test_attention_3d_softcap_expanded/model.onnx,sha256=sQ3OUCGmsi-lF8hLETH7X7EYaVDZlRNVT6WiInh3xVs,13906 +onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/output_0.pb,sha256=nrxi4EOmtEuVwrWX7T0OkHfUseZeJStt06LLKlYCkw8,782 +onnx/backend/test/data/node/test_attention_3d_transpose_verification/model.onnx,sha256=fn1NGj-yZBKvncr-Ia7SwlJzzcNeX1tzzh7nj6-o-Hg,233 +onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_0.pb,sha256=Y4cnBWu_lDjReHe0kvqE6v3Q_pbhNNHIQJfgu93swgI,109 +onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_1.pb,sha256=FXRsRBJkHD95agRjfmtXovqsatcBjVG2WsiBbZj-RAU,109 +onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_2.pb,sha256=AG6CYpz3nyf9Xuqe4jv6kJJLVqp4UP3WmpxKu75hheA,109 +onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/output_0.pb,sha256=-sJC2ZDLvahh73UHMy8-ubxO1dNM1BsHH34Ec9fF8yA,109 +onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/model.onnx,sha256=IOBBGE-nmQwlTHVdFFg7eAPpkY0M1LgqzLabay4ly_g,15624 +onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_0.pb,sha256=Y4cnBWu_lDjReHe0kvqE6v3Q_pbhNNHIQJfgu93swgI,109 +onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_1.pb,sha256=FXRsRBJkHD95agRjfmtXovqsatcBjVG2WsiBbZj-RAU,109 +onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_2.pb,sha256=AG6CYpz3nyf9Xuqe4jv6kJJLVqp4UP3WmpxKu75hheA,109 +onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/output_0.pb,sha256=-sJC2ZDLvahh73UHMy8-ubxO1dNM1BsHH34Ec9fF8yA,109 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/model.onnx,sha256=iZDa0eZK1W5VvbilYWdXot2M_AGE3RGLi6roVbCPm_g,476 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_0.pb,sha256=XBJl19nmN59B4DRwo-rcGXzD3eYpTDlbnvdq93Urs4w,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/model.onnx,sha256=6so_eBojoegrlp8Ax1P9jyevpUVEsgHHVCDRimb_sPI,16032 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_0.pb,sha256=XBJl19nmN59B4DRwo-rcGXzD3eYpTDlbnvdq93Urs4w,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/model.onnx,sha256=i_U2-hU7f_LeVowYlOpeJVDdV83nGpsD2OcQ53EWwI4,549 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_0.pb,sha256=XBJl19nmN59B4DRwo-rcGXzD3eYpTDlbnvdq93Urs4w,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_3.pb,sha256=F0Ju2f_XjffedTdcRw1Olt-bC3UX3evnQuU_N4aCtk8,1759 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/model.onnx,sha256=zQWZtvMT2_XBjlRp42VTIvg3t3YTeUE2DEoH-EfrKB4,584 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_0.pb,sha256=XBJl19nmN59B4DRwo-rcGXzD3eYpTDlbnvdq93Urs4w,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_3.pb,sha256=q_aBTstcmNBWKBMYfqTmP658iBEOSyZ6ONbJvNh0UjU,1759 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/model.onnx,sha256=F6xm8ZAQ6Y5KnpzcFCQPW8v-H6gjluMU9-DRIfR9QX4,18800 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_0.pb,sha256=XBJl19nmN59B4DRwo-rcGXzD3eYpTDlbnvdq93Urs4w,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_3.pb,sha256=q_aBTstcmNBWKBMYfqTmP658iBEOSyZ6ONbJvNh0UjU,1759 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/model.onnx,sha256=L3AY7jO5mCFdyciBP2ezDxMBG-x5jzCHyMAkikjVvSM,17922 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_0.pb,sha256=XBJl19nmN59B4DRwo-rcGXzD3eYpTDlbnvdq93Urs4w,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_3.pb,sha256=F0Ju2f_XjffedTdcRw1Olt-bC3UX3evnQuU_N4aCtk8,1759 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/model.onnx,sha256=gSkWx12DOMgiSkDxuj-_pT0LCNLcqXu-KFF6ViZhbEI,606 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_0.pb,sha256=RzeGHMCaLUjo7IAWIe6-2Ag8JJyoUjHHu_nE5ddterE,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_3.pb,sha256=HDDWc8DznqBQ9ZxF3jfczc296vGOoIseN3Q4Xe2NmKY,1759 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/model.onnx,sha256=mZcssgvJUqVgheHAYUq4WNtN4MtTKCtLkDP2qsyaAnI,20490 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_0.pb,sha256=RzeGHMCaLUjo7IAWIe6-2Ag8JJyoUjHHu_nE5ddterE,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_3.pb,sha256=HDDWc8DznqBQ9ZxF3jfczc296vGOoIseN3Q4Xe2NmKY,1759 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/model.onnx,sha256=KC_33ekvbkq3jFmsXKze6bIvRYDcej1gLbTbQWkv-SE,587 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_0.pb,sha256=XBJl19nmN59B4DRwo-rcGXzD3eYpTDlbnvdq93Urs4w,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_3.pb,sha256=ymXirZx7gpuKCIjStpNPVX-7jloahwHWJGo-g6dRWX4,1759 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/model.onnx,sha256=hhOq1TTg6dH3gc76qtwyyFGFUBN_Mer0R5to2iI_jig,19319 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_0.pb,sha256=-vWMMQuWBXQRvqM7cAGSo4UWzXkJuo2Ha28tYiEg0r8,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_1.pb,sha256=fOdU0KHpDc1GVvz7rQRb_unBWytdw1IA5ZJ2og7qVkE,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_2.pb,sha256=nUflvYUIkm3wKoa7zeJFMogWQXVUv3HHB3P0dsw2Y0Q,1166 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_0.pb,sha256=XBJl19nmN59B4DRwo-rcGXzD3eYpTDlbnvdq93Urs4w,782 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_1.pb,sha256=WMWtrP-1te4fUSkpXjmPQYbXKLRVdQxetgF1KEUtvKw,3482 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_2.pb,sha256=eozCM_ojzJRAyGtq-O1oFZfSZZpyOJfCm2Ke6LpmuSk,3484 +onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_3.pb,sha256=ymXirZx7gpuKCIjStpNPVX-7jloahwHWJGo-g6dRWX4,1759 +onnx/backend/test/data/node/test_attention_4d/model.onnx,sha256=tPdjRRNi0qgSeikHA-vVDza7uf26H5d2ncs2Rf37HY8,185 +onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d/test_data_set_0/output_0.pb,sha256=nnfa4eYn7vuljVgVwTT08PwFwgTkrmVU8E1zJvA9Svg,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask/model.onnx,sha256=0Npr17702PYfFSskLVzxMuDGqB9nDB7aMKGxWyaHILU,235 +onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/output_0.pb,sha256=gohOKN2UKFaHkwHg0anV1ZKdgAPRMTN3QxVGfotTFio,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/model.onnx,sha256=5PfzNOcGrfYf8ny9hvFnRbPpYWGTW6qpV2gc3PJBYAA,246 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_3.pb,sha256=uHkO1TsUA9mrJg2iv2c0rFlg1pfsuV9sX9PQblHg5bQ,216 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/output_0.pb,sha256=bukmkZyRd-m8hny049-dgvJdmvK1U35_sBtEr10uP2U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/model.onnx,sha256=39B4U47poknaOHzLGEaDC7yhO31_WR7bMyG6Db6IzjM,271 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_3.pb,sha256=uHkO1TsUA9mrJg2iv2c0rFlg1pfsuV9sX9PQblHg5bQ,216 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/output_0.pb,sha256=eB1w2kl1f2hL2NepH5JCNZ3C2u_0npmat4yv5tXHKww,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/model.onnx,sha256=RcF5BHiBBqitoN8fcGKKOOgTJPP0VcNDv8kcfDwHTv8,15851 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_3.pb,sha256=uHkO1TsUA9mrJg2iv2c0rFlg1pfsuV9sX9PQblHg5bQ,216 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/output_0.pb,sha256=eB1w2kl1f2hL2NepH5JCNZ3C2u_0npmat4yv5tXHKww,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/model.onnx,sha256=j0-ykjrz8wnPUalfqdutyoyFBdQjnniasf20JjRJ9Ec,11644 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_3.pb,sha256=uHkO1TsUA9mrJg2iv2c0rFlg1pfsuV9sX9PQblHg5bQ,216 +onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/output_0.pb,sha256=bukmkZyRd-m8hny049-dgvJdmvK1U35_sBtEr10uP2U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/model.onnx,sha256=8ATIF7SS_xxldAkfaJ39Eq9SjpKhhKLFhVmawF3Zvy4,246 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_3.pb,sha256=wAp9tLjYbv6Hh7q7Jy2zF-Qrvuan1W37d7hr9XY5Gxk,600 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/output_0.pb,sha256=9Mhsvd5-cKe2ar6-Kz_xXD47eBnqKiQ0-IK84nxZFrE,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/model.onnx,sha256=dkrn1AEKvVeTnB_K_KrSgKHuOcF69i8zV1EBXWOYVis,271 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_3.pb,sha256=wAp9tLjYbv6Hh7q7Jy2zF-Qrvuan1W37d7hr9XY5Gxk,600 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/output_0.pb,sha256=OO9SfMdBvwv4cJqMu1PwCkWOO-Tkq7ckOXvEhpcmNXU,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/model.onnx,sha256=EM9RKDH83iciV75RkJqfkt5ifdM6Zv7QgeZxNTbo5LU,15851 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_3.pb,sha256=wAp9tLjYbv6Hh7q7Jy2zF-Qrvuan1W37d7hr9XY5Gxk,600 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/output_0.pb,sha256=OO9SfMdBvwv4cJqMu1PwCkWOO-Tkq7ckOXvEhpcmNXU,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/model.onnx,sha256=Th-a4thnj0Jfb29iJa67W0BCLnVGg0JFUbzTxnnteIs,11644 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_3.pb,sha256=wAp9tLjYbv6Hh7q7Jy2zF-Qrvuan1W37d7hr9XY5Gxk,600 +onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/output_0.pb,sha256=9Mhsvd5-cKe2ar6-Kz_xXD47eBnqKiQ0-IK84nxZFrE,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/model.onnx,sha256=sgEco37rZ8GJZAWACOvGxg0zN_egQg7DDkkklmur230,240 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_3.pb,sha256=4yk1ig8wpSX9nVmy9t9lDUTnElbPTcBgA6UFqETsbro,43 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/output_0.pb,sha256=nnfa4eYn7vuljVgVwTT08PwFwgTkrmVU8E1zJvA9Svg,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/model.onnx,sha256=1P-Nq421_YUk7W46UYOddanu2dHcKATjOHCznup857k,251 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_3.pb,sha256=JKX1ZTyXBhqysNXH8ntS-mbo-27YqI_SZZPQjoqwOlE,168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/output_0.pb,sha256=nnfa4eYn7vuljVgVwTT08PwFwgTkrmVU8E1zJvA9Svg,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/model.onnx,sha256=1YudR3oIuXhM9FYy5blL-jvtjq0_JPvy2pyDmmoIb8E,12502 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_3.pb,sha256=JKX1ZTyXBhqysNXH8ntS-mbo-27YqI_SZZPQjoqwOlE,168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/output_0.pb,sha256=nnfa4eYn7vuljVgVwTT08PwFwgTkrmVU8E1zJvA9Svg,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/model.onnx,sha256=j_BIiIUClHQt7EqLCdonlCIOEpg43Mx9kTH5JvRBbjo,12063 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_3.pb,sha256=4yk1ig8wpSX9nVmy9t9lDUTnElbPTcBgA6UFqETsbro,43 +onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/output_0.pb,sha256=nnfa4eYn7vuljVgVwTT08PwFwgTkrmVU8E1zJvA9Svg,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/model.onnx,sha256=F7TGgSGAJiGyJvWyY6BWt4GY38m028YPACShefDQLHc,11213 +onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/output_0.pb,sha256=gohOKN2UKFaHkwHg0anV1ZKdgAPRMTN3QxVGfotTFio,784 +onnx/backend/test/data/node/test_attention_4d_causal/model.onnx,sha256=oitSKh91lNocuZNJNrc1e9LgE393ecleH-Posi5slRM,210 +onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/output_0.pb,sha256=8h1Ciu-eNqnEBci3tg-VnWlJChvSJVIqXJGBW3D-OZ4,784 +onnx/backend/test/data/node/test_attention_4d_causal_expanded/model.onnx,sha256=Am1vaizQb6FywgGW7IECRtiKWgqcAbCRKLKM5evNbuI,13386 +onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/output_0.pb,sha256=8h1Ciu-eNqnEBci3tg-VnWlJChvSJVIqXJGBW3D-OZ4,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/model.onnx,sha256=vbecuNsk9WbdpG0iK1Em7i7P0FU17aaB4T5xVEz03_k,315 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_3.pb,sha256=3Mm2ir77sf6KVkgkxOR1AZAvaUagtTrnP8NULgC4QEA,408 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_4.pb,sha256=J_vBWwqPXQ_6s0ssnNm7lqjMkLehkBOp6bdJ_Re-zxo,40 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/output_0.pb,sha256=ESCDlE3QB2CIcGeCQAK8omuydP8SdyHZNJlD1BWUNEc,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/model.onnx,sha256=QZCDLKj1v56jmG_nOpBX2Htd75kQvaoIfj6mPgNKvZg,17586 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_3.pb,sha256=3Mm2ir77sf6KVkgkxOR1AZAvaUagtTrnP8NULgC4QEA,408 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_4.pb,sha256=J_vBWwqPXQ_6s0ssnNm7lqjMkLehkBOp6bdJ_Re-zxo,40 +onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/output_0.pb,sha256=ESCDlE3QB2CIcGeCQAK8omuydP8SdyHZNJlD1BWUNEc,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/model.onnx,sha256=f7UJkCTV8LQDERawHIqpuZg0F8neajEP73zNL0J7jR4,202 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/output_0.pb,sha256=vmYBZLZXurewBVd26Ck9ZMADbRTVH6mLK8xs3_SM_ZE,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/model.onnx,sha256=YZxzZundrFm2CmSK7XMkQQEuw0e-qBNqyjy61Rw4JZU,252 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_3.pb,sha256=wvCfnJA1byd40Fz2GiQXfRn3WG4-dWv43rQPs0d5dJ8,115 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/output_0.pb,sha256=adAeTBNGtXeWa4ttXKuuodWKDTjHfM5COwvjiiNUQD4,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/model.onnx,sha256=nRgfmpe8mF1cMRIhabpSYvbBHbmNecTOTBRuRnsfhMs,13612 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_3.pb,sha256=wvCfnJA1byd40Fz2GiQXfRn3WG4-dWv43rQPs0d5dJ8,115 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/output_0.pb,sha256=adAeTBNGtXeWa4ttXKuuodWKDTjHfM5COwvjiiNUQD4,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/model.onnx,sha256=ecAYXsyIKpb_UBjKLw8qWtJY2izJlpJD5tCVoIfIdFU,227 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/output_0.pb,sha256=a_iQNDwirSmMFnum8fhQFW5Zea2N0Hu7oUyTWiqxy7M,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/model.onnx,sha256=3eG3ZXQkwvzB4hM4di4Pqcz8D4p-X5q5F3z48TN2sug,16432 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/output_0.pb,sha256=a_iQNDwirSmMFnum8fhQFW5Zea2N0Hu7oUyTWiqxy7M,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/model.onnx,sha256=nxE95MQLxOxNj7xDxgURZLu3I8wN7s_AVdhj-lERdVQ,12077 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/output_0.pb,sha256=vmYBZLZXurewBVd26Ck9ZMADbRTVH6mLK8xs3_SM_ZE,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/model.onnx,sha256=ymVuBrcjLmWGq9A4wXC0CeBftJ2bfJf1ll5G68rk3nQ,226 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/output_0.pb,sha256=efVVE5sCZ3DiPI_9_QiF-D1BH-1grujsrFHjH71HUTU,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/model.onnx,sha256=tVzEK95wLTkq4dT09s6GbGs0USfUOER41me-aS9QsLU,13048 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/output_0.pb,sha256=efVVE5sCZ3DiPI_9_QiF-D1BH-1grujsrFHjH71HUTU,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/model.onnx,sha256=_bv4fL5HzLNJUNMZl_lqMGRGU-lx5JOm5kLMwDb_pyc,229 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/output_0.pb,sha256=7zKnQ03C9TQjyE3Mo_nxwDtRUrQCSHaw5mwHfiVVBWM,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/model.onnx,sha256=aPnWOXoAFWQztCxS4pTGAgpJcrqYBAXQ7ZocPq6nyJQ,14203 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/output_0.pb,sha256=7zKnQ03C9TQjyE3Mo_nxwDtRUrQCSHaw5mwHfiVVBWM,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/model.onnx,sha256=jxa1XsXKCvhOKp-8-3pWao0jSdzBSa-09JpkuORAe6U,462 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_3.pb,sha256=H8kLnArjipSp3pGoJbA1Zk5BkpywZyTZ_JAmS6xIFVw,308 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_4.pb,sha256=qMlPWsQPOfC-4L3I_k6NTZd9fph9H1UF0YmXEhTtZrI,2327 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_5.pb,sha256=JtO_M8zNGcIVOjwKMSmOqqOR_kKZM-sgZ_Vg68KtiJY,2905 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_0.pb,sha256=PJNpNtQFmhPSx618cB3ZL0MlwiHaTVf8cUCMPP2Ic8U,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_1.pb,sha256=jrn_AzRTfQHguvIfEQN1qUxTA0RqJUdxvCgiGACUfxo,3482 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_2.pb,sha256=N0itTWWiMieosQYTqRXF7PPffUMjNlwZyy5Cridc1dM,4348 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/model.onnx,sha256=9rYt9JPjtoZf_-JcNJgQoy3eq-i1ImxUkv1FUovB0Z0,14929 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_3.pb,sha256=H8kLnArjipSp3pGoJbA1Zk5BkpywZyTZ_JAmS6xIFVw,308 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_4.pb,sha256=qMlPWsQPOfC-4L3I_k6NTZd9fph9H1UF0YmXEhTtZrI,2327 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_5.pb,sha256=JtO_M8zNGcIVOjwKMSmOqqOR_kKZM-sgZ_Vg68KtiJY,2905 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_0.pb,sha256=PJNpNtQFmhPSx618cB3ZL0MlwiHaTVf8cUCMPP2Ic8U,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_1.pb,sha256=jrn_AzRTfQHguvIfEQN1qUxTA0RqJUdxvCgiGACUfxo,3482 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_2.pb,sha256=N0itTWWiMieosQYTqRXF7PPffUMjNlwZyy5Cridc1dM,4348 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/model.onnx,sha256=Usqsm46sJyDlmV_P2JdiuZpX3UpUA5J9-ICIYKXPZts,477 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_3.pb,sha256=dqZiQuSBOWdH8R6P29DWx11f_aPOHo6xLCWJ0c_ad30,600 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_4.pb,sha256=Nc1pEuOMHhmlkFUaQACARY0ftJqQW4MzAGsXCf3HCug,2327 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_5.pb,sha256=1UrzuVE5alQcNVztafOrpnUMuKM_2K1pMMC3mr1hUYg,2905 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_0.pb,sha256=l7YfKF-7HUsOQXDgng4bFQctmdow64znulkrDJdAoNo,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_1.pb,sha256=WGwyF2I_pTUEWYNJo4DXBxxEi9YcXAlxaARtbHwfqNk,3482 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_2.pb,sha256=Na-BlpXVUy-pCxaszJTIUoPWhlZJ6s7tnzr9kmFyRSE,4348 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/model.onnx,sha256=EcVx3ipuCIhnh3YXQenxEGLDSO6riBzfhrrmaLKscis,15941 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_3.pb,sha256=dqZiQuSBOWdH8R6P29DWx11f_aPOHo6xLCWJ0c_ad30,600 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_4.pb,sha256=Nc1pEuOMHhmlkFUaQACARY0ftJqQW4MzAGsXCf3HCug,2327 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_5.pb,sha256=1UrzuVE5alQcNVztafOrpnUMuKM_2K1pMMC3mr1hUYg,2905 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_0.pb,sha256=l7YfKF-7HUsOQXDgng4bFQctmdow64znulkrDJdAoNo,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_1.pb,sha256=WGwyF2I_pTUEWYNJo4DXBxxEi9YcXAlxaARtbHwfqNk,3482 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_2.pb,sha256=Na-BlpXVUy-pCxaszJTIUoPWhlZJ6s7tnzr9kmFyRSE,4348 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/model.onnx,sha256=yzCRNRgpkQQWLyMI8Qtf8L7NdW1MhHVRxjA01V55gHs,477 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_3.pb,sha256=C_y5RbmM7MKhlVsAn46C4oiv_hb3ehmXMTfKJW843Aw,1752 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_4.pb,sha256=BFKofEcuN2TzPQ0zvoatn-eHYVdxdHfE7LqGwuwQEBY,2327 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_5.pb,sha256=9a3xXLA9xX7DZXiPHvG81N2omJznAYGcbaEnoPMRRQc,2905 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_0.pb,sha256=2p22rSK3r8i6QcK17uH-vpoGavMRBz5LY3ox3zKMqTM,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_1.pb,sha256=z-LejdlmKoXvu9LnxZ1o4vvnWlWuCn7LeLBjpMUu2No,3482 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_2.pb,sha256=NC5nYyeVXrd50k_DG_f51j0d23zaPAUK9pwTwRaAUQA,4348 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/model.onnx,sha256=9-bWN0vtdkb_L_oL_99YkTGhjGzY_viea3L5JQZV-3g,15941 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_2.pb,sha256=RTpDXZg3VNzq8WIMdk4yrSJcp6tnKuGWIkFIXck0uCw,1456 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_3.pb,sha256=C_y5RbmM7MKhlVsAn46C4oiv_hb3ehmXMTfKJW843Aw,1752 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_4.pb,sha256=BFKofEcuN2TzPQ0zvoatn-eHYVdxdHfE7LqGwuwQEBY,2327 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_5.pb,sha256=9a3xXLA9xX7DZXiPHvG81N2omJznAYGcbaEnoPMRRQc,2905 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_0.pb,sha256=2p22rSK3r8i6QcK17uH-vpoGavMRBz5LY3ox3zKMqTM,976 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_1.pb,sha256=z-LejdlmKoXvu9LnxZ1o4vvnWlWuCn7LeLBjpMUu2No,3482 +onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_2.pb,sha256=NC5nYyeVXrd50k_DG_f51j0d23zaPAUK9pwTwRaAUQA,4348 +onnx/backend/test/data/node/test_attention_4d_expanded/model.onnx,sha256=UqBqLvN0KMdVcqxZ3JoglgTHCcFs96zYtGEX-6oBO5A,9692 +onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/output_0.pb,sha256=nnfa4eYn7vuljVgVwTT08PwFwgTkrmVU8E1zJvA9Svg,784 +onnx/backend/test/data/node/test_attention_4d_fp16/model.onnx,sha256=_QlgnJ3zwn4J_v35uPjmZ3KSRm6ciPBmHXB2DwGjHkQ,190 +onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_0.pb,sha256=s8_cy7fY2zqbRBjgu-ciZFOAtiCYuuGiYMvF1tJkMj4,400 +onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_1.pb,sha256=aj-CY5wAL4r4vCHQZK4JgHM0H-0idzl1SgGEprg4giw,592 +onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_2.pb,sha256=UWItfyN1m__J7JzBPu3DZpoJEFk51iuYBwAWEUpJj0k,592 +onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/output_0.pb,sha256=hrmoX1tczC-cDQQCn4Iu_cQEyOKUqdAvfkFi8RYSp4Y,400 +onnx/backend/test/data/node/test_attention_4d_fp16_expanded/model.onnx,sha256=iOdaO58viuvCsmgGObSskL0NZ13Ll9BrsN-dCFIl2aA,10395 +onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_0.pb,sha256=s8_cy7fY2zqbRBjgu-ciZFOAtiCYuuGiYMvF1tJkMj4,400 +onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_1.pb,sha256=aj-CY5wAL4r4vCHQZK4JgHM0H-0idzl1SgGEprg4giw,592 +onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_2.pb,sha256=UWItfyN1m__J7JzBPu3DZpoJEFk51iuYBwAWEUpJj0k,592 +onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/output_0.pb,sha256=hrmoX1tczC-cDQQCn4Iu_cQEyOKUqdAvfkFi8RYSp4Y,400 +onnx/backend/test/data/node/test_attention_4d_gqa/model.onnx,sha256=gMBmjZIWcs7i_ptBl8ycP4HOnNwUJRGQ3g0vrNf9pwo,189 +onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/output_0.pb,sha256=sPtphIlG2BAnRYmJO2bPWOqWILpYY14NVgWyhP9-ri4,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/model.onnx,sha256=d1Q4u1nglHO5-T9BodyCysuzNLtxeiPiSJTtOpKOlyY,239 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_3.pb,sha256=i1yCXhuL1ahdW-3ZxqYy2z6uPG7m9h19Cy-rDkPOBqE,115 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/output_0.pb,sha256=fBkVVyM68BEw-tNwMT4r3er6-f0pvtzMJ36JoEqobM4,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/model.onnx,sha256=H2y1UqIb7jqzl04qXtM5GPMT1_tMKwdQekwEWy1BXJI,11777 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_3.pb,sha256=i1yCXhuL1ahdW-3ZxqYy2z6uPG7m9h19Cy-rDkPOBqE,115 +onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/output_0.pb,sha256=fBkVVyM68BEw-tNwMT4r3er6-f0pvtzMJ36JoEqobM4,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_causal/model.onnx,sha256=IoTh2kGwptzo9jmPGTnnx8ym6fvobKNkMf-9g-BWJmo,214 +onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/output_0.pb,sha256=9Yi1m1WkFyAvovjyiMTERXRXJUVLS7m-eTetnEHurJc,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/model.onnx,sha256=UuC8KvhwM1tQgylV-0lvEAZalIQQ39ccNy9uszYATVA,14102 +onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/output_0.pb,sha256=9Yi1m1WkFyAvovjyiMTERXRXJUVLS7m-eTetnEHurJc,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_expanded/model.onnx,sha256=TI9tf3RBYgbXq_zsfjZKl6XbVn0SUmQSPgKj0Z3auPk,10255 +onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/output_0.pb,sha256=sPtphIlG2BAnRYmJO2bPWOqWILpYY14NVgWyhP9-ri4,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled/model.onnx,sha256=s5eX-DqlQq9Sf4NmDxnan4cDODrInhzr3XKWcxL6zvs,213 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/output_0.pb,sha256=i77j108rRdCjGCCyGCGfTyoot9mRfv6lk-_BKLKXmis,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/model.onnx,sha256=mSEOsIp9USiITAU2H_kgIUalF3IwDcuF-r1XhRma7oA,11226 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/output_0.pb,sha256=i77j108rRdCjGCCyGCGfTyoot9mRfv6lk-_BKLKXmis,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap/model.onnx,sha256=uuKlq9qfUY-aEdbsg-sALCD12Fm8hvsR2vNPl-oqn48,216 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/output_0.pb,sha256=BPmo6V8V9pc5vd-2SHOQoZ_5kqxVGNgi_GUZw5OA7ts,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/model.onnx,sha256=vH8KGOBzp98iseq77JnxqJJNAmGTQkzeJYz6H9yWqb0,12238 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/output_0.pb,sha256=BPmo6V8V9pc5vd-2SHOQoZ_5kqxVGNgi_GUZw5OA7ts,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/model.onnx,sha256=4XlOQEj0Bru2VhO51QN990PF906MhoXwHw3LgRUA0bc,455 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_3.pb,sha256=_sPeS4Lvc1qY8MrqVqerNfDz_FIuMLeOWMOulRRPys4,308 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_4.pb,sha256=bKIWowWpcvjjproWUbDmSLDH5pVh0qhAQ6iANQz8-P4,2327 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_5.pb,sha256=8Yh9Qu30bbazYRwrweTDIbrSvMKMafAMVs2qcYHHTDU,2329 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_0.pb,sha256=yPhtcMLQy__2aEhDLZ3zryOQcCfBCMcPzhRt7D8PbFg,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_1.pb,sha256=L9fcZi9EGNq2UOCDM7P9VvV9c5WP8Wsqt5IDaa5jgjs,3482 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_2.pb,sha256=IiOar17KCx7DUalZ-ukFdF045wKyt8_qU4rNL-dJUBU,3484 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/model.onnx,sha256=LE7sCeJFSEaW_qm3PR3BZhoKlpWidJutcqtKhq05NgY,13926 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_0.pb,sha256=xj0owBIafWziCHFuhwX1WielzONMy7h1JW1spGnuTWA,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_1.pb,sha256=Mx6zGx-PSw64f33n2a9TtOF4RFMkn8LOTg3riA7DqK4,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_2.pb,sha256=CaNrDEYVJLtbXjEMeikkkt9x8Nsi2pclXqvMzHtec8k,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_3.pb,sha256=_sPeS4Lvc1qY8MrqVqerNfDz_FIuMLeOWMOulRRPys4,308 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_4.pb,sha256=bKIWowWpcvjjproWUbDmSLDH5pVh0qhAQ6iANQz8-P4,2327 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_5.pb,sha256=8Yh9Qu30bbazYRwrweTDIbrSvMKMafAMVs2qcYHHTDU,2329 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_0.pb,sha256=yPhtcMLQy__2aEhDLZ3zryOQcCfBCMcPzhRt7D8PbFg,2320 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_1.pb,sha256=L9fcZi9EGNq2UOCDM7P9VvV9c5WP8Wsqt5IDaa5jgjs,3482 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_2.pb,sha256=IiOar17KCx7DUalZ-ukFdF045wKyt8_qU4rNL-dJUBU,3484 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/model.onnx,sha256=RajuGFVw6G3j4yYv2-xAac8kBw8392O5iStxYjZbbzU,460 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_0.pb,sha256=-WPDYqmCunWJZzBmZtOHzJLm760aI4TxFELSkMMGZwQ,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_1.pb,sha256=cixaJYoKMGVJ8U-qLGEgzXV-pRXghmXPUR6yQezlcf8,592 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_2.pb,sha256=oA1HmzyJUGlUlDqJ5vxaXsmTAYPY6Wdj5uYn8NLoJGg,592 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_3.pb,sha256=3nCC242yQBPYdg6bOovLo1MEMmUYQujchxKjCDUFsu0,164 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_4.pb,sha256=wbZjnm67FzzpkF_TV0irUygz_O_TsDqoSag_0szfMXI,1175 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_5.pb,sha256=x7Yn82TOWdYjE9PMuC-YQB_nE9uEFhpN26vQr3OnurE,1177 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_0.pb,sha256=wQMYKt9fKsLHtY_hpXyqBFHrrofXlZdGst5V3jl6J7Y,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_1.pb,sha256=kXPqGgad_aCSf5P0kZfWw-fNCLkAk8UABO6u9K77_Lg,1754 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_2.pb,sha256=I3Ega22QXtPnN2xMiNa_BJ4Bd6iLPpdylCw-JTLBHrM,1756 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/model.onnx,sha256=fP0OzwIC3kiLoCGJO-G88ZVurUZaoOTJBoX2rYVknuk,14641 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_0.pb,sha256=-WPDYqmCunWJZzBmZtOHzJLm760aI4TxFELSkMMGZwQ,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_1.pb,sha256=cixaJYoKMGVJ8U-qLGEgzXV-pRXghmXPUR6yQezlcf8,592 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_2.pb,sha256=oA1HmzyJUGlUlDqJ5vxaXsmTAYPY6Wdj5uYn8NLoJGg,592 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_3.pb,sha256=3nCC242yQBPYdg6bOovLo1MEMmUYQujchxKjCDUFsu0,164 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_4.pb,sha256=wbZjnm67FzzpkF_TV0irUygz_O_TsDqoSag_0szfMXI,1175 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_5.pb,sha256=x7Yn82TOWdYjE9PMuC-YQB_nE9uEFhpN26vQr3OnurE,1177 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_0.pb,sha256=wQMYKt9fKsLHtY_hpXyqBFHrrofXlZdGst5V3jl6J7Y,1168 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_1.pb,sha256=kXPqGgad_aCSf5P0kZfWw-fNCLkAk8UABO6u9K77_Lg,1754 +onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_2.pb,sha256=I3Ega22QXtPnN2xMiNa_BJ4Bd6iLPpdylCw-JTLBHrM,1756 +onnx/backend/test/data/node/test_attention_4d_scaled/model.onnx,sha256=F_EiRfnrCgJB6Z6YlG1yt7RaDudyq0Gc5ekhCrGiuRg,209 +onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/output_0.pb,sha256=DjP7z7tJJvE8bqLB2ghocx3HIwOcrm0oJsGCxCrCND0,784 +onnx/backend/test/data/node/test_attention_4d_scaled_expanded/model.onnx,sha256=T5Ru93MC-TvCSxbeAI5AstwlaCJ5rWtx8pj8klH6gGw,10666 +onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/output_0.pb,sha256=DjP7z7tJJvE8bqLB2ghocx3HIwOcrm0oJsGCxCrCND0,784 +onnx/backend/test/data/node/test_attention_4d_softcap/model.onnx,sha256=eilYgByGNcJFe0KmWnEvAPNtNtoB-dYNUdic_1grsxI,212 +onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/output_0.pb,sha256=iAznyBhkNWvZWoDW5gZJb1-uarrb67WuNUP_1egMa0k,784 +onnx/backend/test/data/node/test_attention_4d_softcap_expanded/model.onnx,sha256=mUpsx28OKiBrM8HYQaP3n0SJXtJ1tbSERcAmBwnUznQ,11634 +onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/output_0.pb,sha256=iAznyBhkNWvZWoDW5gZJb1-uarrb67WuNUP_1egMa0k,784 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/model.onnx,sha256=JEtzBn5a1cUPlh4PeVlo3RO2EqRKg091yDbli1qinKY,264 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_0.pb,sha256=fUjbIdaquQAzzLirPIueHMXGtYBpPrNqvF4FqVcRjgM,144 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_1.pb,sha256=XqxUhi-uvjcyDZTBOCzgccyWRk71lPKxkpq7A0D7NCE,208 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_2.pb,sha256=2dCCKsos7xxcb9po9I9TG6Y2V8thITPb7WXbruwj5iY,208 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_3.pb,sha256=HYy714-NV_Rv3-FX550N33ncL0ROOUu2Nl5TdSCqrWM,115 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/output_0.pb,sha256=RukvlcN9Lp8TNHoHE-XMCbA1Nhnyxa9aynVurb73xAI,144 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/model.onnx,sha256=s4EbEKBg7of77kIIPwHnus4alEzvXstdIzylTgKv4v8,13576 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_0.pb,sha256=fUjbIdaquQAzzLirPIueHMXGtYBpPrNqvF4FqVcRjgM,144 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_1.pb,sha256=XqxUhi-uvjcyDZTBOCzgccyWRk71lPKxkpq7A0D7NCE,208 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_2.pb,sha256=2dCCKsos7xxcb9po9I9TG6Y2V8thITPb7WXbruwj5iY,208 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_3.pb,sha256=HYy714-NV_Rv3-FX550N33ncL0ROOUu2Nl5TdSCqrWM,115 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/output_0.pb,sha256=RukvlcN9Lp8TNHoHE-XMCbA1Nhnyxa9aynVurb73xAI,144 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/model.onnx,sha256=8_mT0lNs4jTRozgDKFhw_4UCfiYfB-ntGTdWUPpJLwE,271 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_0.pb,sha256=fUjbIdaquQAzzLirPIueHMXGtYBpPrNqvF4FqVcRjgM,144 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_1.pb,sha256=XqxUhi-uvjcyDZTBOCzgccyWRk71lPKxkpq7A0D7NCE,208 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_2.pb,sha256=XZDPjOjhQzEz1h0G5x1chlllloAPHUbqHk3PBg2Wv3U,208 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_3.pb,sha256=HYy714-NV_Rv3-FX550N33ncL0ROOUu2Nl5TdSCqrWM,115 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/output_0.pb,sha256=RukvlcN9Lp8TNHoHE-XMCbA1Nhnyxa9aynVurb73xAI,144 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/model.onnx,sha256=OOVzvfgjS6sCJ5pOKviqBSURPHjDxHOfkt9Owxjp5Qk,14640 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_0.pb,sha256=fUjbIdaquQAzzLirPIueHMXGtYBpPrNqvF4FqVcRjgM,144 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_1.pb,sha256=XqxUhi-uvjcyDZTBOCzgccyWRk71lPKxkpq7A0D7NCE,208 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_2.pb,sha256=XZDPjOjhQzEz1h0G5x1chlllloAPHUbqHk3PBg2Wv3U,208 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_3.pb,sha256=HYy714-NV_Rv3-FX550N33ncL0ROOUu2Nl5TdSCqrWM,115 +onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/output_0.pb,sha256=RukvlcN9Lp8TNHoHE-XMCbA1Nhnyxa9aynVurb73xAI,144 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/model.onnx,sha256=nwrxUeF58L4Y0LYbwjKwMOv-mwrW-rZcfcjL37MxVK4,451 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_0.pb,sha256=vyA2peF15AeTQe5zEpBfTUVWZnq5_7EhsFqykSqGw9k,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_1.pb,sha256=DDb1cvJktq3yvftYdemK30W827lQ2x0vxz0_a0UxNSI,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_2.pb,sha256=RoEGiFQPxcDdKl7uDPveI9cdrCYUZuFsCaBztc0v2l8,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/model.onnx,sha256=T7PP8q65C-i0IbbwESwbZU6z2jJqaGmHo6TS0mUguIQ,13354 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_0.pb,sha256=vyA2peF15AeTQe5zEpBfTUVWZnq5_7EhsFqykSqGw9k,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_1.pb,sha256=DDb1cvJktq3yvftYdemK30W827lQ2x0vxz0_a0UxNSI,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_2.pb,sha256=RoEGiFQPxcDdKl7uDPveI9cdrCYUZuFsCaBztc0v2l8,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/model.onnx,sha256=qmyhbCXRmNpSZUdsR1Wtzf2IHcs0-6WDwwTapDdZhI4,523 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_0.pb,sha256=vyA2peF15AeTQe5zEpBfTUVWZnq5_7EhsFqykSqGw9k,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_1.pb,sha256=DDb1cvJktq3yvftYdemK30W827lQ2x0vxz0_a0UxNSI,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_2.pb,sha256=RoEGiFQPxcDdKl7uDPveI9cdrCYUZuFsCaBztc0v2l8,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_3.pb,sha256=ygIKYj-2uZjzjKYAUCTlboLiDhHRn1OvU0fTJpqtpdY,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/model.onnx,sha256=8zc4FqyIurT5aAjOfo1w-2ESozsbYcGfj5v_UYlazmE,559 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_0.pb,sha256=vyA2peF15AeTQe5zEpBfTUVWZnq5_7EhsFqykSqGw9k,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_1.pb,sha256=DDb1cvJktq3yvftYdemK30W827lQ2x0vxz0_a0UxNSI,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_2.pb,sha256=RoEGiFQPxcDdKl7uDPveI9cdrCYUZuFsCaBztc0v2l8,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_3.pb,sha256=rqkUUwMUSQvP2oC6A_Ls6bRRz-JkcHotcf8srMGsAWY,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/model.onnx,sha256=KmRoVeXDV7Q4NqXHr4qg-oM1U0IBMdMhBaUxhA0iK5A,575 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_3.pb,sha256=KSEcO9LFmILEv5B4SqqSZgDVJddMYcz5WY2MeMGmgoE,600 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_4.pb,sha256=qMlPWsQPOfC-4L3I_k6NTZd9fph9H1UF0YmXEhTtZrI,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_5.pb,sha256=jFSPXzq5M-lO1OplbzwhXbNnt8sPxOPPx_ZbRQyjJuA,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_0.pb,sha256=eBkGyiOTJ0OsvdOO6l97OYrMoc7-tIvRB57_DutChVk,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_1.pb,sha256=jrn_AzRTfQHguvIfEQN1qUxTA0RqJUdxvCgiGACUfxo,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_2.pb,sha256=bk4f8F6ke8-FOiy88ct2nEOv9WKxsg_fTASLxoVFDXI,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_3.pb,sha256=fV4i4MJ6q1HEYFhYdLiI7RXNO1lp7vjhAt_VCrCO6tE,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/model.onnx,sha256=QUlBiGHTpKBcQvgzNc5M3BK0J_yr0fNNarKQNeAPlxA,600 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_3.pb,sha256=KSEcO9LFmILEv5B4SqqSZgDVJddMYcz5WY2MeMGmgoE,600 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_4.pb,sha256=qMlPWsQPOfC-4L3I_k6NTZd9fph9H1UF0YmXEhTtZrI,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_5.pb,sha256=jFSPXzq5M-lO1OplbzwhXbNnt8sPxOPPx_ZbRQyjJuA,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_0.pb,sha256=lnI6t0lsr3pbcTU1WM784JxT1WLWo6NVYMxKwldc7Ps,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_1.pb,sha256=jrn_AzRTfQHguvIfEQN1qUxTA0RqJUdxvCgiGACUfxo,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_2.pb,sha256=bk4f8F6ke8-FOiy88ct2nEOv9WKxsg_fTASLxoVFDXI,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_3.pb,sha256=SuVgl9xQhdql5_L4Z_tBHWT2Z7PIUP3Np1VkpXr7iO0,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/model.onnx,sha256=zUiWIGK1-Sh96Dmlu2WCiqL_MQ7WDivcbd-brXfnp14,22328 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_3.pb,sha256=KSEcO9LFmILEv5B4SqqSZgDVJddMYcz5WY2MeMGmgoE,600 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_4.pb,sha256=qMlPWsQPOfC-4L3I_k6NTZd9fph9H1UF0YmXEhTtZrI,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_5.pb,sha256=jFSPXzq5M-lO1OplbzwhXbNnt8sPxOPPx_ZbRQyjJuA,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_0.pb,sha256=lnI6t0lsr3pbcTU1WM784JxT1WLWo6NVYMxKwldc7Ps,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_1.pb,sha256=jrn_AzRTfQHguvIfEQN1qUxTA0RqJUdxvCgiGACUfxo,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_2.pb,sha256=bk4f8F6ke8-FOiy88ct2nEOv9WKxsg_fTASLxoVFDXI,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_3.pb,sha256=SuVgl9xQhdql5_L4Z_tBHWT2Z7PIUP3Np1VkpXr7iO0,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/model.onnx,sha256=qVo1Mjs5N0OQ4WL5LKwzj8IxqBTXYj_KYNqyrj2RLkE,16852 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_3.pb,sha256=KSEcO9LFmILEv5B4SqqSZgDVJddMYcz5WY2MeMGmgoE,600 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_4.pb,sha256=qMlPWsQPOfC-4L3I_k6NTZd9fph9H1UF0YmXEhTtZrI,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_5.pb,sha256=jFSPXzq5M-lO1OplbzwhXbNnt8sPxOPPx_ZbRQyjJuA,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_0.pb,sha256=eBkGyiOTJ0OsvdOO6l97OYrMoc7-tIvRB57_DutChVk,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_1.pb,sha256=jrn_AzRTfQHguvIfEQN1qUxTA0RqJUdxvCgiGACUfxo,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_2.pb,sha256=bk4f8F6ke8-FOiy88ct2nEOv9WKxsg_fTASLxoVFDXI,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_3.pb,sha256=fV4i4MJ6q1HEYFhYdLiI7RXNO1lp7vjhAt_VCrCO6tE,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/model.onnx,sha256=ks0xbwJK1H7RSvOe3TlhUFdDbzX1XJ4Qv7rQwQZgSJk,575 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_3.pb,sha256=sllnaSGxki8W7rBReeBAP1JAGcTMh331N1LfcUr8468,1752 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_4.pb,sha256=rlqyhZ9APgE8wjgw_D7AQDvDhJR9ENTLtVqihVkjYMA,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_5.pb,sha256=27hxXFI5_m9XfQ6vdeDkq5Z2ekGgVuO0ns47tzOIB8A,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_0.pb,sha256=EYws0_vRAU83QGVYjzRA98fmphj2N1dvpHkyv3zW5b8,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_1.pb,sha256=GUqdqRBB2AnFX-JsIHFe1Z-9GhVdylmyfvzoAlWoUa0,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_2.pb,sha256=MrGePWPGLpBTtPGlKxgPfoHiCzeBNz1yNVNsFbRQzwE,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_3.pb,sha256=bxFBIAhYi__I2Z01P-Mu8NLw4WkEkOsmndWxNhnuybU,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/model.onnx,sha256=Y1QknQOYOUrqctfcHrSy1E5R45cKWtz9SPsVkUkP-iI,600 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_3.pb,sha256=sllnaSGxki8W7rBReeBAP1JAGcTMh331N1LfcUr8468,1752 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_4.pb,sha256=rlqyhZ9APgE8wjgw_D7AQDvDhJR9ENTLtVqihVkjYMA,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_5.pb,sha256=27hxXFI5_m9XfQ6vdeDkq5Z2ekGgVuO0ns47tzOIB8A,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_0.pb,sha256=MfQ5A5b4X3izdPIE14QFfuFdgSzCoOTPekyjP8lZnIc,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_1.pb,sha256=GUqdqRBB2AnFX-JsIHFe1Z-9GhVdylmyfvzoAlWoUa0,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_2.pb,sha256=MrGePWPGLpBTtPGlKxgPfoHiCzeBNz1yNVNsFbRQzwE,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_3.pb,sha256=h0SXuf0uOT2omedn4MIPfOgWJdcTJPuQOypuYloMHeI,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/model.onnx,sha256=mOmmDVhf0n8jO0PRw3Qo7qOGEJp0m1jLW6r2sgQhDcQ,22328 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_3.pb,sha256=sllnaSGxki8W7rBReeBAP1JAGcTMh331N1LfcUr8468,1752 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_4.pb,sha256=rlqyhZ9APgE8wjgw_D7AQDvDhJR9ENTLtVqihVkjYMA,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_5.pb,sha256=27hxXFI5_m9XfQ6vdeDkq5Z2ekGgVuO0ns47tzOIB8A,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_0.pb,sha256=MfQ5A5b4X3izdPIE14QFfuFdgSzCoOTPekyjP8lZnIc,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_1.pb,sha256=GUqdqRBB2AnFX-JsIHFe1Z-9GhVdylmyfvzoAlWoUa0,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_2.pb,sha256=MrGePWPGLpBTtPGlKxgPfoHiCzeBNz1yNVNsFbRQzwE,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_3.pb,sha256=h0SXuf0uOT2omedn4MIPfOgWJdcTJPuQOypuYloMHeI,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/model.onnx,sha256=n6Y2hRLNlBfwaRVjSEqhswCrYBS7lRdSA00WSdr4z0A,16852 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_3.pb,sha256=sllnaSGxki8W7rBReeBAP1JAGcTMh331N1LfcUr8468,1752 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_4.pb,sha256=rlqyhZ9APgE8wjgw_D7AQDvDhJR9ENTLtVqihVkjYMA,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_5.pb,sha256=27hxXFI5_m9XfQ6vdeDkq5Z2ekGgVuO0ns47tzOIB8A,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_0.pb,sha256=EYws0_vRAU83QGVYjzRA98fmphj2N1dvpHkyv3zW5b8,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_1.pb,sha256=GUqdqRBB2AnFX-JsIHFe1Z-9GhVdylmyfvzoAlWoUa0,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_2.pb,sha256=MrGePWPGLpBTtPGlKxgPfoHiCzeBNz1yNVNsFbRQzwE,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_3.pb,sha256=bxFBIAhYi__I2Z01P-Mu8NLw4WkEkOsmndWxNhnuybU,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/model.onnx,sha256=-RRmngRR423SK8lJ1b0BvSDUlOMThR4bziWNDyFe-aw,15683 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_0.pb,sha256=vyA2peF15AeTQe5zEpBfTUVWZnq5_7EhsFqykSqGw9k,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_1.pb,sha256=DDb1cvJktq3yvftYdemK30W827lQ2x0vxz0_a0UxNSI,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_2.pb,sha256=RoEGiFQPxcDdKl7uDPveI9cdrCYUZuFsCaBztc0v2l8,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_3.pb,sha256=rqkUUwMUSQvP2oC6A_Ls6bRRz-JkcHotcf8srMGsAWY,1759 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/model.onnx,sha256=Q9JdEZNkV1BIZmzaR6zk0om4_6iMi_WFkUD9-uxR_EQ,14952 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_3.pb,sha256=P8bSisrvN7ufRVtjIBg80Qs70HrEtymNJlpc8fqBjgo,308 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_4.pb,sha256=tI7LQb2ABS6x7Xiq6u1pkQWw5FrJ45yQb8gYRG5jC1U,2327 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_5.pb,sha256=BMupSfAwOnSrrX9fLOjNHsWNn7Q6_frIbMhQACvxnxU,2329 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_0.pb,sha256=vyA2peF15AeTQe5zEpBfTUVWZnq5_7EhsFqykSqGw9k,784 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_1.pb,sha256=DDb1cvJktq3yvftYdemK30W827lQ2x0vxz0_a0UxNSI,3482 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_2.pb,sha256=RoEGiFQPxcDdKl7uDPveI9cdrCYUZuFsCaBztc0v2l8,3484 +onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_3.pb,sha256=ygIKYj-2uZjzjKYAUCTlboLiDhHRn1OvU0fTJpqtpdY,1759 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/model.onnx,sha256=1DSOHgwCUfDNkLeq2cwk5c4RsfQlisPbafT8mYXQ-m8,266 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/output_0.pb,sha256=nnfa4eYn7vuljVgVwTT08PwFwgTkrmVU8E1zJvA9Svg,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/output_1.pb,sha256=7fgYoHIUuhsRncCWFalNtB9edztCOebBuxnf8Ix8tpA,607 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/model.onnx,sha256=cEeA8jKQ9reLUQdHwega1JayWzo7Aj9-ZpZmXcm6Dg4,341 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/output_0.pb,sha256=gohOKN2UKFaHkwHg0anV1ZKdgAPRMTN3QxVGfotTFio,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/output_1.pb,sha256=Cf-42v4aw-_QjdXEc7tAEff9BIXOMnKhC0WUasTVKAI,607 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/model.onnx,sha256=1v7poD7HQ-0ufaVTJJfBUjeI6enO2wrH8ojSceuNjHQ,12788 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/output_0.pb,sha256=gohOKN2UKFaHkwHg0anV1ZKdgAPRMTN3QxVGfotTFio,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/output_1.pb,sha256=Cf-42v4aw-_QjdXEc7tAEff9BIXOMnKhC0WUasTVKAI,607 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/model.onnx,sha256=dllxCvyhUyghT3eHhBMaRovVIvt4HPfcyiddm3nQVJ8,11946 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/output_0.pb,sha256=nnfa4eYn7vuljVgVwTT08PwFwgTkrmVU8E1zJvA9Svg,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/output_1.pb,sha256=7fgYoHIUuhsRncCWFalNtB9edztCOebBuxnf8Ix8tpA,607 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/model.onnx,sha256=D12ElQRa0ppiG4EY34Hqan_HXE68xnxcm-fnkFZXasI,363 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/output_0.pb,sha256=0-xW6CgYJgUKFBzisWed7aAfHrFmWoSaJ3XVbI-M3Kg,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/output_1.pb,sha256=e8_ziHzRmOcSj7aqg85fNaDdtQLLgytAT4loSaGsGCk,607 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/model.onnx,sha256=4rs1oX1U6f2vfX7WLehUUI6x5l3wOELtMWVoMAZSGnA,14195 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/output_0.pb,sha256=0-xW6CgYJgUKFBzisWed7aAfHrFmWoSaJ3XVbI-M3Kg,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/output_1.pb,sha256=e8_ziHzRmOcSj7aqg85fNaDdtQLLgytAT4loSaGsGCk,607 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/model.onnx,sha256=xPx4DbPt62ObxNvLhx_7qeOxzRQvQ5beHm1IvHrHGCA,344 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/output_0.pb,sha256=gohOKN2UKFaHkwHg0anV1ZKdgAPRMTN3QxVGfotTFio,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/output_1.pb,sha256=exxTKY_8tTvKjuDN8GbLKmYMHpkfVwuqWgYYu7Z6K9w,607 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/model.onnx,sha256=tVica6y8Kp__5zrNEtHQitICYvLVNybrMdJY-7Cb6bM,13212 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_0.pb,sha256=I75aFm1e1P1YxvZ5fA1mNv6Hhw-gUgDl-8Ru2VPcl7U,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_1.pb,sha256=U-LDjXa7lmDfEv2EMYgwer1qtE0BRoo8AFhE-_OJT0w,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_2.pb,sha256=roZ59-lCiP-q4dFPm6S3W5bGrkMqxt8-_Gghs9Biw6A,1168 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_3.pb,sha256=KS6AWObeS6Wu0vtv33GrnIZILIrI6u1vDpf3gtHgd1w,115 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/output_0.pb,sha256=gohOKN2UKFaHkwHg0anV1ZKdgAPRMTN3QxVGfotTFio,784 +onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/output_1.pb,sha256=exxTKY_8tTvKjuDN8GbLKmYMHpkfVwuqWgYYu7Z6K9w,607 +onnx/backend/test/data/node/test_averagepool_1d_default/model.onnx,sha256=vEBPv7wPbfsX-LfrQh1fl2T07ThGbyMMAgTBbvvvUac,145 +onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/input_0.pb,sha256=Za3StahBL7BbhQGm5tBIbmHL40mPVKMeoJms01DCbkU,398 +onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/output_0.pb,sha256=TZiHbd4tAQX4YEoKfpv4FAfDU8Wfj18Luu5gvR5syQs,386 +onnx/backend/test/data/node/test_averagepool_2d_ceil/model.onnx,sha256=pvtg8VhMkeg3wTos3oOQ3fIGf6zkuUl6D3uuCaDjH74,189 +onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/output_0.pb,sha256=J_NsHn9iEsmJAHuv2HzlQWz7V96t50EsGijdfWrqmeA,31 +onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/model.onnx,sha256=ZHixmCRXtq6MFpfc3X2hQf3ArfafibbhU6jnr0SCVXM,260 +onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/test_data_set_0/input_0.pb,sha256=ZR_dFXIleWo7VVFxXGrYdT3wy99Vzp-fQa0PUmpg0gA,63 +onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/test_data_set_0/output_0.pb,sha256=fFMNhxFThDes-7PMNMPUx9DL9M0Cxlthd1PAKkGIX1Y,27 +onnx/backend/test/data/node/test_averagepool_2d_default/model.onnx,sha256=Vbp-C9lWziqXW9Wh_HAm-a81yTMc3Uw_Y50MgFuLRjs,156 +onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/output_0.pb,sha256=WqDv_FV3cMJET2YYrTwD1QNaFS1HWX3l_wgNWu5fv8Y,11548 +onnx/backend/test/data/node/test_averagepool_2d_dilations/model.onnx,sha256=Oicqzm6m-APqWGhsVPvv4XbX6XuEVcKaoSthFB2EhsM,214 +onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/output_0.pb,sha256=W0xv7zagmB-A0lWKOzPp6y4w5v8iBNre0k8VvAb23es,31 +onnx/backend/test/data/node/test_averagepool_2d_pads/model.onnx,sha256=fJ1XlJ68SOYDHpwUphcCH9QbkAwW6-aQXbbqHX1W97o,172 +onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/input_0.pb,sha256=HFGpOb8k-_eSox3wcj8SOjH7WcbqDYrAaqiceZ_ZzdI,9424 +onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/output_0.pb,sha256=zFviiXMYWWVgabusMEGvLMEybZSq7C296tqaNQL6kf8,10816 +onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/model.onnx,sha256=yD44WySKhCVIFqLNiVW-lYOdXOQM9iH1LM95quse7lk,216 +onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/input_0.pb,sha256=HFGpOb8k-_eSox3wcj8SOjH7WcbqDYrAaqiceZ_ZzdI,9424 +onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/output_0.pb,sha256=5U46RW5XBKUVs3UYsbuPPOqxyVl-Bs5cqdlmg3zBVjs,10816 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/model.onnx,sha256=59wDKFF-wxUsnl_UDeek49vfj8K-tNaElkANTvEBPzs,184 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/output_0.pb,sha256=Ecxo2QxKQku1MYTr16hK8pervsU5PyL_fGNkROknnP8,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/model.onnx,sha256=NeMwCi3hziR7XxB6i7Sc30aNTnqoqqGkiuOFb6EOL2I,228 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/output_0.pb,sha256=2xNtCtCrswd372GDRTeANsSwrjEvCEBD52M4I77kG8U,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/model.onnx,sha256=me2riNWkMxowZilJFeyNbqNSMYCSbuu7m5ZwvARHQMk,216 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/output_0.pb,sha256=PXPhQwNqHdL1LZx5KD3oGFGzjLnNpPSRRUEzLfDeflM,51 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/model.onnx,sha256=KPjq-H9j3gZ4QQr6Rpn7lWFFM_xjqRKDd4BM8UWbO_M,186 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/output_0.pb,sha256=6kurBL2grQAt9ZKHrnJkfWS3ZP-ToeFCUf4U4ZcVcJ8,31 +onnx/backend/test/data/node/test_averagepool_2d_same_lower/model.onnx,sha256=YUFNnpk00K7txDAPX6hQAbE6q7HBMCrKJ4O5kWxgvZM,186 +onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/output_0.pb,sha256=-5ZZi0sQTaBI0T6CQ1Sv1ifyPAcHKzpYLJfVbGyk_qw,12304 +onnx/backend/test/data/node/test_averagepool_2d_same_upper/model.onnx,sha256=6A9UX-C0eScyQuMGvYz_oslaCHdx2_5KnPm24dX7F70,186 +onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/output_0.pb,sha256=0dyD3w375fMoeUr4L5i396MTxAKFnGEc0E4FPhFOhwM,12304 +onnx/backend/test/data/node/test_averagepool_2d_strides/model.onnx,sha256=J8VyzOFgnKxauUY9zxG4wtxsTnzdzty7ZeHavW-RUgQ,174 +onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/output_0.pb,sha256=IR_Q7lYkCMSUqv7Rvjth91C6d2O0alfXQxjoPdDuMhA,1216 +onnx/backend/test/data/node/test_averagepool_3d_default/model.onnx,sha256=jFMaK0HN26Eegwcotin0paDlReWvPxS0CNiuHKaoXuY,166 +onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/input_0.pb,sha256=L_c9P56CmA7WzPjy1TlkWrKgYm0YkeXEYxiPZ6VV1wY,393235 +onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/output_0.pb,sha256=bWn81UGs4Eu7uQ-sAsgNLoy5M4lo5LZ8qLYoC87yC6g,357511 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/model.onnx,sha256=QXKkYGBZDQwUBESAa8Z6LqBk1g73WIzhD6kXGlkam1A,303 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/test_data_set_0/input_0.pb,sha256=G0ZmaRtAJ5ywCVv8RZdiQQtdSsDDMkBOq129UCl5duM,131091 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/test_data_set_0/output_0.pb,sha256=Yungt3DB4TIX35zBpAvr34-YKrcXpE9pQNNO6NtV02Y,2066 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/model.onnx,sha256=rLJWlB9elxuvao-_Ha83vKC-IebDolK-kmb2GGDx-88,302 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/test_data_set_0/input_0.pb,sha256=VKR6T99kXsypZCXWOcGPYobnNiPdA95uKzDtur6-Wps,131091 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/test_data_set_0/output_0.pb,sha256=h30I9AcAYxUV2k5fQjbh3KXNEB6pyvpzd2zxlMlFrl4,2934 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/model.onnx,sha256=jiBnOf1s_c9EAn2iAykX0UhfxR7On-4qwH248MO404g,303 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/test_data_set_0/input_0.pb,sha256=NxZlzYncM3n7oZ55CPGRMSrsZYfKvhZL0vtBW0siD8M,131091 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/test_data_set_0/output_0.pb,sha256=X8NWa80Dr242-z3E8xYObU6geX8KZyhPxfonC_PxJ1E,2066 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/model.onnx,sha256=aYkT2N0B4pNBEgoKdZkwJUpQNfTqkbbkT3Obpy5VYVs,302 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/test_data_set_0/input_0.pb,sha256=COVvyW4FhX4PqauStmT3UkrJpe8KUoQXpqHjD8N_MqE,131091 +onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/test_data_set_0/output_0.pb,sha256=TWOzxPmq9NnPLXECIijOPTu3YTx_oH5ueOSrCDSnou8,2934 +onnx/backend/test/data/node/test_averagepool_3d_dilations_small/model.onnx,sha256=rNw5xKOhMti7JyxpVrA_y9UDU6Dz4LmvWmN0fOx30DI,234 +onnx/backend/test/data/node/test_averagepool_3d_dilations_small/test_data_set_0/input_0.pb,sha256=eUBZRSXolhPmPqfzFXG-IJegZfzGOQpfdDoeK2OEkrA,274 +onnx/backend/test/data/node/test_averagepool_3d_dilations_small/test_data_set_0/output_0.pb,sha256=Rtr3ZjMwQn0VuZWLIFhhFlRtrdRznLumebIVumuWPDk,49 +onnx/backend/test/data/node/test_basic_conv_with_padding/model.onnx,sha256=yEv5uXpF5gtQ0KQ-GxnZvUt6L3QU0SvKtp1TXMTg87Y,201 +onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_0.pb,sha256=RnJVWHKql-4c51A3JiCTvFe-ry8o5bavOnIotOzZFK8,115 +onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/output_0.pb,sha256=_LQ6Gcbvv-Twct7wPuCO5Hk3vIzVJ6zAJjqsCUTiESs,115 +onnx/backend/test/data/node/test_basic_conv_without_padding/model.onnx,sha256=Zv6r5DWQMz2hSYHQl5iyU1PYOPm9L7GDETNgOHyIwFw,204 +onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_0.pb,sha256=RnJVWHKql-4c51A3JiCTvFe-ry8o5bavOnIotOzZFK8,115 +onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/output_0.pb,sha256=K4v6OtrT-N3QKnkBVUq6hzq-cwsWe0UFSldl-Ue2gBo,51 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/model.onnx,sha256=5xlWN29dZRLw_GMYuZ2nRhHWv4hJFVo8a5DebwjkWJM,308 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_1.pb,sha256=4Ki_u3n_9JzedrVVClMoOCDVY7aP6BJSo_YgoX_n3EM,31 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_2.pb,sha256=ubxlpp8Ok84plEXefjcKBNLmtjYWHyW8lTBySGpXiVY,546 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/output_0.pb,sha256=Irv1r-kaSImnwtIZkxyVkxsEt5PsqthjzKxqarimwTk,92 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/model.onnx,sha256=Eu9w1Bq2iQaoRWrKPS-ZbAbdZgerty4NzRZtzrp_cQ4,323 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_1.pb,sha256=4Ki_u3n_9JzedrVVClMoOCDVY7aP6BJSo_YgoX_n3EM,31 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_2.pb,sha256=X6j9HPA1XkWmfq_jLD2L8xChvOSYaeHC866XeRYcjYI,165 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/output_0.pb,sha256=peJJza0T-DL7-QEaZxSV3xP-Dw7ZUQF7DAoh54hXozo,47 +onnx/backend/test/data/node/test_batchnorm_epsilon/model.onnx,sha256=NXo3bdeikoeDCYmkO46QlVY4bBGEZfKsFlRE7Pw5RtI,250 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_0.pb,sha256=8uEeu7nwOZUkfBuA5bw-ePBY0x7IS3e44oNXGMyGbkQ,496 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_1.pb,sha256=OBGvvDW2vXlYrjwA7mwO12Os-DSXirqdY2jD0Oy6CpY,21 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_2.pb,sha256=3wE1u1KcTYpoMTF-wBk003DsXnUc9oEGTFycIU4jCXM,24 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_3.pb,sha256=T8_L--XgZOdbDGUSHIWGNqYTLTv1yFq2oH487fAI0tk,24 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_4.pb,sha256=Ti6CdJotPj-3-v8kHqk-YWnNLFRA5W3Ggebr1lG_QiI,23 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/output_0.pb,sha256=n6XFIIVyNJbcQt5Mj2SKHyj8_vjkASjh5KIlzVwFbi4,496 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/model.onnx,sha256=SAramxkbImr0vmaRPxJA-1RLrQaTx8rud89R0WuZ3JI,364 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_0.pb,sha256=8uEeu7nwOZUkfBuA5bw-ePBY0x7IS3e44oNXGMyGbkQ,496 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_1.pb,sha256=OBGvvDW2vXlYrjwA7mwO12Os-DSXirqdY2jD0Oy6CpY,21 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_2.pb,sha256=3wE1u1KcTYpoMTF-wBk003DsXnUc9oEGTFycIU4jCXM,24 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_3.pb,sha256=T8_L--XgZOdbDGUSHIWGNqYTLTv1yFq2oH487fAI0tk,24 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_4.pb,sha256=Ti6CdJotPj-3-v8kHqk-YWnNLFRA5W3Ggebr1lG_QiI,23 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_0.pb,sha256=WTc4mm4mdiyNSmlgxnwB17sNnDNlw_i_mHnXabAsE9o,496 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_1.pb,sha256=jHTM3xrd557eg6TzhgmP5mMHNrMCIlsBuK6OZqnnKkc,31 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_2.pb,sha256=N5551G0V8glw6AyG4jMpqsOL3dLoLlP8UUWNEoz_VZ4,30 +onnx/backend/test/data/node/test_batchnorm_example/model.onnx,sha256=ub690uwc1r-R7fxX6EtJDAMIF4aI4YfzhMCkkhGH7yQ,231 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_0.pb,sha256=SYKd5PF5vM-bKNrV8oTKPGHvYE0twyvHWdFt3T67zDY,496 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_1.pb,sha256=AI-3RnrtRdqYWsuL7R4_zbZ0Vb7zfnaDEBYsm0i2kvY,21 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_2.pb,sha256=2oNlXxvO0WnQ0oLXr0SuQwOm4ErOca8R9dkNLwewDK4,24 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_3.pb,sha256=d60mjqff9zbsLGnRD8GG9bbEk2qyV8UaYde7LaB_myc,24 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_4.pb,sha256=EyHoNru0GPIaJLApYVvbQ1CqR67ReuX4wdywoIWBV5o,23 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/output_0.pb,sha256=oeWjuEbXwDN3lB6trNUoMhzjqR-2WCk-Rt9KbKy_lJs,496 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/model.onnx,sha256=DAaPW_k2UOPYfvNEk00CEgz2yHtNbpttW9kpp5z49cE,345 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_0.pb,sha256=SYKd5PF5vM-bKNrV8oTKPGHvYE0twyvHWdFt3T67zDY,496 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_1.pb,sha256=AI-3RnrtRdqYWsuL7R4_zbZ0Vb7zfnaDEBYsm0i2kvY,21 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_2.pb,sha256=2oNlXxvO0WnQ0oLXr0SuQwOm4ErOca8R9dkNLwewDK4,24 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_3.pb,sha256=d60mjqff9zbsLGnRD8GG9bbEk2qyV8UaYde7LaB_myc,24 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_4.pb,sha256=EyHoNru0GPIaJLApYVvbQ1CqR67ReuX4wdywoIWBV5o,23 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_0.pb,sha256=e-lIEIZD_v28N7-cbLdGgQKaTqsjUA7tmsc3OGNwz8M,496 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_1.pb,sha256=B0lT9yeJL76Z8VJvMM29lFzBBqzZ7ifQi0nP8Rrih8Q,31 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_2.pb,sha256=Hb31AnNOCJ7SIMDkm-IuS8WJaRwxB1qvuSJedInfXUY,30 +onnx/backend/test/data/node/test_bernoulli/model.onnx,sha256=B-yF9t2tVZqOeUppCx0W5rM0pp9gJDXFifJbOKS9qAI,93 +onnx/backend/test/data/node/test_bernoulli/test_data_set_0/input_0.pb,sha256=hyJJsFqjdZ5XnAjaaBhB0YNRxb9AuGsGsBdSS1te2iw,89 +onnx/backend/test/data/node/test_bernoulli/test_data_set_0/output_0.pb,sha256=xs9aCuRMT-QHKEFQ0SiknUjFyecsDJLJJ1TQ9BQh2os,89 +onnx/backend/test/data/node/test_bernoulli_double/model.onnx,sha256=obwB18Qs4ft2KcbxayprosnJWEs3z5XK7x1oB6DEgcM,114 +onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/input_0.pb,sha256=cuPUsQEt8rLSUYiu2PhyXLudD1nqEYaXqoG180s6eiw,49 +onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/output_0.pb,sha256=xs9aCuRMT-QHKEFQ0SiknUjFyecsDJLJJ1TQ9BQh2os,89 +onnx/backend/test/data/node/test_bernoulli_double_expanded/model.onnx,sha256=xNXqlqV6A4DmVJK0DChsAXE4xRD2C0rRVl2nhG7pOZU,446 +onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/input_0.pb,sha256=cuPUsQEt8rLSUYiu2PhyXLudD1nqEYaXqoG180s6eiw,49 +onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/output_0.pb,sha256=xs9aCuRMT-QHKEFQ0SiknUjFyecsDJLJJ1TQ9BQh2os,89 +onnx/backend/test/data/node/test_bernoulli_expanded/model.onnx,sha256=RatIgsjUhuVs4hZxAIECjoQ7bshU6aJBjGRm1gYvSL8,409 +onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/input_0.pb,sha256=hyJJsFqjdZ5XnAjaaBhB0YNRxb9AuGsGsBdSS1te2iw,89 +onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/output_0.pb,sha256=xs9aCuRMT-QHKEFQ0SiknUjFyecsDJLJJ1TQ9BQh2os,89 +onnx/backend/test/data/node/test_bernoulli_seed/model.onnx,sha256=iu3MQDdxiHkDJDxbpoEL3AW2ECbll9VnwKlDFrlL__w,114 +onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/input_0.pb,sha256=cuPUsQEt8rLSUYiu2PhyXLudD1nqEYaXqoG180s6eiw,49 +onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/output_0.pb,sha256=wDTjyEkwQ92j1RiXjUtYJjS14OwkKkkTih0mdFRpGGc,49 +onnx/backend/test/data/node/test_bernoulli_seed_expanded/model.onnx,sha256=sdo5daQVcnJwC8wAOPvfYT9n13rGwCdC44AkhUvqGQw,452 +onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/input_0.pb,sha256=cuPUsQEt8rLSUYiu2PhyXLudD1nqEYaXqoG180s6eiw,49 +onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/output_0.pb,sha256=wDTjyEkwQ92j1RiXjUtYJjS14OwkKkkTih0mdFRpGGc,49 +onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/model.onnx,sha256=J0R6JUdkF3OTwQbarlreQcj2mVI4FdTOlld3_-zqbv4,128 +onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/test_data_set_0/input_0.pb,sha256=4pQ6jBxU8_tBNnaRVRgYgck68GhQp-YW_tL388GcCvE,35 +onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/test_data_set_0/output_0.pb,sha256=C6Bt8v8GCAN6OZGXD1VBehAFUF0dDAl9j0ADVP1so8s,35 +onnx/backend/test/data/node/test_bitcast_bool_to_uint8/model.onnx,sha256=LdB2TsDBBduLuGXtIZKRJdPoDgla6dKBikQKeNYu0cU,114 +onnx/backend/test/data/node/test_bitcast_bool_to_uint8/test_data_set_0/input_0.pb,sha256=dvmF3ksyMmZiPBGzyMT907WpkhONazxpTU21F4MaSmM,13 +onnx/backend/test/data/node/test_bitcast_bool_to_uint8/test_data_set_0/output_0.pb,sha256=GOJgXQK2k3VHJtoMzQ4lhLsyqnh4eksSgzzimDnpo54,13 +onnx/backend/test/data/node/test_bitcast_float32_to_int32/model.onnx,sha256=ebXYW3CM2qilPSSDfyCjSYEBrI-8K74Yt2S351YawT0,117 +onnx/backend/test/data/node/test_bitcast_float32_to_int32/test_data_set_0/input_0.pb,sha256=HuCr4MiuDtUlYQGwb-LbJhUMUunmX_Ex8bzhiqNJckM,21 +onnx/backend/test/data/node/test_bitcast_float32_to_int32/test_data_set_0/output_0.pb,sha256=BmebAWMXyN8tOVvIXcuVRaSqFmkQqVtvYX-Sgc718aY,21 +onnx/backend/test/data/node/test_bitcast_float64_to_int64/model.onnx,sha256=GdhPa-SB1Tc4Cay7VlRNNEvOH9Z44_wOl5dI6qSC-mw,117 +onnx/backend/test/data/node/test_bitcast_float64_to_int64/test_data_set_0/input_0.pb,sha256=6QcczrZ9cPGoezGXLWb05ytGJL4NSZxHh6RSHyqOu78,33 +onnx/backend/test/data/node/test_bitcast_float64_to_int64/test_data_set_0/output_0.pb,sha256=PaIlOIxYK8irBt0qSKz4pOPNFRQuGBjebejydjxObRU,33 +onnx/backend/test/data/node/test_bitcast_int32_to_float32/model.onnx,sha256=p2qOvzl6O2OKRxpiFTHXcN2r1ryJUkONLo7pc_Tl-l8,117 +onnx/backend/test/data/node/test_bitcast_int32_to_float32/test_data_set_0/input_0.pb,sha256=DgVb99kn7r5Y6EazZTd7TpdoYj5NZfJysKJ0zafYvM4,21 +onnx/backend/test/data/node/test_bitcast_int32_to_float32/test_data_set_0/output_0.pb,sha256=uYA0gdTnbARDMi-UGpRznFYk1NW-2Zu_qzRWFBi8cyA,21 +onnx/backend/test/data/node/test_bitcast_int64_to_float64/model.onnx,sha256=P0UQbNFS0Y4x0h-_FX7Y1BYoiFSq8jjfb9H1cDa-h3c,117 +onnx/backend/test/data/node/test_bitcast_int64_to_float64/test_data_set_0/input_0.pb,sha256=QpDyZ-as-bLWuTtxmocQQlSwv2LGNr_kna49TOrZDd4,33 +onnx/backend/test/data/node/test_bitcast_int64_to_float64/test_data_set_0/output_0.pb,sha256=Bqn2H1jV771iJuNpPpioi4G_jxo7vY6npF-troyXb4Q,33 +onnx/backend/test/data/node/test_bitcast_int8_to_uint8/model.onnx,sha256=QLnnD5IJ0x1Em5TkVLzs-TnvDz61JbaKhMxFyap_t8o,114 +onnx/backend/test/data/node/test_bitcast_int8_to_uint8/test_data_set_0/input_0.pb,sha256=H9vy56zTPQD2RUfA9QCZf94FyyT2n_RoBCPxM9banf0,13 +onnx/backend/test/data/node/test_bitcast_int8_to_uint8/test_data_set_0/output_0.pb,sha256=_7-7___aoawMcZptADzO-rFSb0guGsMVNjsSHeUsS54,13 +onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/model.onnx,sha256=gwvIz_5kVtib3rZ0LCm3WwOU_tZfZf_1cmYhThfIeS8,116 +onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/test_data_set_0/input_0.pb,sha256=7QWJaRTh1IvFK-dQvQ_pgT0XqQwl8ttbn32tGsdomDo,11 +onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/test_data_set_0/output_0.pb,sha256=QBL8xevJSJmLh7o8t_RsKFa7S4B2jSq22mXFSPz2Pmc,11 +onnx/backend/test/data/node/test_bitcast_uint16_to_int16/model.onnx,sha256=KjfY-VYE8AG4WLdEc6fpY_eBoI5NJ_T_WZG4aziNWSo,116 +onnx/backend/test/data/node/test_bitcast_uint16_to_int16/test_data_set_0/input_0.pb,sha256=jkH5UFVwcg1m8UMerrFotYedrPjYDrFjmqVZZaMI1FM,15 +onnx/backend/test/data/node/test_bitcast_uint16_to_int16/test_data_set_0/output_0.pb,sha256=-ui4ec6LPO1SLxm1zEHWoQHUZzShnb5Wn1EGsOGVGh4,15 +onnx/backend/test/data/node/test_bitcast_uint32_to_int32/model.onnx,sha256=j-j82B31ESYS_UdKtP0fW7_vTzP7tw_JfUPcvungisA,116 +onnx/backend/test/data/node/test_bitcast_uint32_to_int32/test_data_set_0/input_0.pb,sha256=P3t9alQuHeU6xGTYErQ6lhEXJL-NvLzs0Ec5MuW5wRA,21 +onnx/backend/test/data/node/test_bitcast_uint32_to_int32/test_data_set_0/output_0.pb,sha256=l5aBVTvooqjxecpzcHE7AphIMl14xBj6gSmM_yruHKY,21 +onnx/backend/test/data/node/test_bitshift_left_uint16/model.onnx,sha256=LnZd_SO9L1dOzaN11XKMPNWZCPRE96L0NT-xnJTOBtY,145 +onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_0.pb,sha256=jQ176jxBAIMO5ulz_2R2t_RMNCYxBhWBKtEQvp3VPnA,15 +onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_1.pb,sha256=d_wFROmBvDAar5EVjiFwX-5HWMz7-3X15eaoWQv8BAQ,15 +onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/output_0.pb,sha256=FIj-kC6QX69gcjY2ZLPbJAeYeTxYhDoTphdZzBHyxr4,15 +onnx/backend/test/data/node/test_bitshift_left_uint32/model.onnx,sha256=Xbshde1wAgne2pBGkwDnLbZJFsZB-nH8INUp_fyKsH8,145 +onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_0.pb,sha256=n0jmfIFAkvhmvSsxFmIhij1NKAC2rZ0GZjPUvl0OvpM,21 +onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_1.pb,sha256=LPGgfy0kWPfzwbePS63zlBnHRcjnKVmTNhl56DQT_LQ,21 +onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/output_0.pb,sha256=UHau1j361dwNuOuv9GVClDPrEvAsEMDnU7kZ9Ka9XEM,21 +onnx/backend/test/data/node/test_bitshift_left_uint64/model.onnx,sha256=uitk2ZXsCBnTzjWPhsF5PNoiwI5ECCfQvp9EGR19MOo,145 +onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_0.pb,sha256=gdItplXa-gah3kzYq0cb4Ny7SwnrQpNjCBu9BwvRWs4,33 +onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_1.pb,sha256=srzREYqcjuSETV_il_0QENxQV8EbW-IHk_e_wnZX_s0,33 +onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/output_0.pb,sha256=uv291G2Nz0ctLLM_ZjvaFsSQLkB6Ywj1QJ2am6jrAOI,33 +onnx/backend/test/data/node/test_bitshift_left_uint8/model.onnx,sha256=2hKErCnyvnmUegUBOX3i_-OWYfrGyErXp3n4NlviXww,144 +onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_0.pb,sha256=Npre_kHciTwjklfqHpxJJP6BJTCF638zHABwLLSJLVc,12 +onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_1.pb,sha256=OmXyE8_Mj-VdKRY0dsUACEnjcieoln-kaSNRW1ulqnU,12 +onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/output_0.pb,sha256=htgT0sbAbcKHka93qygml6m7QOyV_RNBGZ-7Bfh8VWg,12 +onnx/backend/test/data/node/test_bitshift_right_uint16/model.onnx,sha256=dMuztKV5VcxFmhxYQ_w9wEofyRNitDf6dXlT8OpOh4g,147 +onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_0.pb,sha256=jQ176jxBAIMO5ulz_2R2t_RMNCYxBhWBKtEQvp3VPnA,15 +onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_1.pb,sha256=d_wFROmBvDAar5EVjiFwX-5HWMz7-3X15eaoWQv8BAQ,15 +onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/output_0.pb,sha256=OWgso0Bd4H7b02Z0t-9C6BIe0JqxZPl4x5pLDCuH-6g,15 +onnx/backend/test/data/node/test_bitshift_right_uint32/model.onnx,sha256=ZSUngGFGhJm4frc_N6LC_nOTHfOmgcEpVBloBXbfhY0,147 +onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_0.pb,sha256=n0jmfIFAkvhmvSsxFmIhij1NKAC2rZ0GZjPUvl0OvpM,21 +onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_1.pb,sha256=LPGgfy0kWPfzwbePS63zlBnHRcjnKVmTNhl56DQT_LQ,21 +onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/output_0.pb,sha256=9HW8Yn_MW2Ply6yspxBbl2QGTJwZ6HTfx7F2ZWCB8ks,21 +onnx/backend/test/data/node/test_bitshift_right_uint64/model.onnx,sha256=3TJliEGizBkKgJoqU47jiojDGC7a1JJyt1OGJ9f_zjY,147 +onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_0.pb,sha256=gdItplXa-gah3kzYq0cb4Ny7SwnrQpNjCBu9BwvRWs4,33 +onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_1.pb,sha256=srzREYqcjuSETV_il_0QENxQV8EbW-IHk_e_wnZX_s0,33 +onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/output_0.pb,sha256=cIXEma3tYpCdRIYdSiF8UH4PveH4LSu3mBe9eKtaxRY,33 +onnx/backend/test/data/node/test_bitshift_right_uint8/model.onnx,sha256=FiyhL_aDh3eJggmM0yqczmC9_K4z4r-NVC3So1zoX_I,146 +onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_0.pb,sha256=Npre_kHciTwjklfqHpxJJP6BJTCF638zHABwLLSJLVc,12 +onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_1.pb,sha256=OmXyE8_Mj-VdKRY0dsUACEnjcieoln-kaSNRW1ulqnU,12 +onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/output_0.pb,sha256=xQwf8_nlX7DpOs61hkVxH1caC4G9PqWOvYdUgQCFFs4,12 +onnx/backend/test/data/node/test_bitwise_and_i16_3d/model.onnx,sha256=yc-YBEB-A5u1Ji2mSkoNgGF87Q901mX8Wzh_CxOZecQ,166 +onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_0.pb,sha256=51_g10nhl3pGMHzIZPb9uJiIkLoqLtARgYxBZRXFJ8A,133 +onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_1.pb,sha256=cHjBuAqlCncTYhGLbDmLR1oHQbjNdpHVt6Mo7Cg31To,133 +onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/output_0.pb,sha256=HnblxbS-jMUk0JpLSVezpf9X_qP2I_E57Vv_TXxNubY,142 +onnx/backend/test/data/node/test_bitwise_and_i32_2d/model.onnx,sha256=VI5E4eNL7PdENxiR7BWHTpJQH4J22TwDIyYo3i6x2f4,154 +onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_0.pb,sha256=vBRtRagPhbZGk_pp35bJnnqw8va3HLQEeA-gRpGr_cg,59 +onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_1.pb,sha256=GLkOWs-6gJxZOVVgeCGpbbxY4U3jqjvRYYSunDQHxjQ,59 +onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/output_0.pb,sha256=zSY0bjB6kO8gOdTaQqGVJstGswRtTnQ9hofYX2DVZII,68 +onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/model.onnx,sha256=0ilxxehkgXk3mDGpu7uXqdCoc65XmidwPzqMi0gwbAw,167 +onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_0.pb,sha256=yyF0q6vMUHrYoNxDxHkS1M1J57ABoWCxVPikiSbgt9I,494 +onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_1.pb,sha256=yhmmpWW5p4InqcZXi6vWNboAzILeHxIStUce2hV1TeQ,49 +onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/output_0.pb,sha256=YjQjN5VK40lEVH99dAAz4EeIEq9g8MBODn-ksUV8UUE,503 +onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/model.onnx,sha256=NAzIiuPcp2ykmd0Ylcqs6qC1itlr9FNG2Fct6GAxXAI,182 +onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_0.pb,sha256=M0-FUiXusNZj8HLlUaJlCacWI_VvmB7CXwEQm7W8-_o,376 +onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_1.pb,sha256=cmiv6qNYN8mNf9Mbmi3IZSAgZ1arXHV1abF_FizB1vk,133 +onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/output_0.pb,sha256=k58qWsuM9aJahBM4EBl-PRJW_vtQ2_MJe4DIdHgKzcE,385 +onnx/backend/test/data/node/test_bitwise_not_2d/model.onnx,sha256=Hi968CmDbvXJ6F-QnnsvEsuBm1PJG5mOddx40P3JTEA,127 +onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/input_0.pb,sha256=vBRtRagPhbZGk_pp35bJnnqw8va3HLQEeA-gRpGr_cg,59 +onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/output_0.pb,sha256=Igvz3l6da-yIIbb1dHK45BFXJl8FWckYz7UCN80_p84,69 +onnx/backend/test/data/node/test_bitwise_not_3d/model.onnx,sha256=li1vHDxnTXPyVVg0BX3sL0009QiN_vXxIjz0j-zbPnw,135 +onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/input_0.pb,sha256=-GvODn13fY7XtP0uHpumPLmhhvPiYGG-4gplBNAZrt0,133 +onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/output_0.pb,sha256=979pI-QykNeUo-B8su5J9nc-VBzqJoNMUOGhs1B88xw,143 +onnx/backend/test/data/node/test_bitwise_not_4d/model.onnx,sha256=InYj3ToYFWonqMUxkfgDCVZDYHtSr1QC72QebAd_4CI,143 +onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/input_0.pb,sha256=M0-FUiXusNZj8HLlUaJlCacWI_VvmB7CXwEQm7W8-_o,376 +onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/output_0.pb,sha256=cCdeum9xyuJG02YEHo7w2P15mUmeFWkAUufvJbL-wuA,386 +onnx/backend/test/data/node/test_bitwise_or_i16_4d/model.onnx,sha256=enje0I-pI3bLXqGYCBGKlQWK0PFdl59_PwDjwafql3o,174 +onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_0.pb,sha256=PnxxwiX86m3d_QkLdl3Asalt7yqxjGmgck55zPjA2tM,376 +onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_1.pb,sha256=dESyvCmUTodtbWS3T_t5OMVsH0XWXdlE-pNDsdco8AU,376 +onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/output_0.pb,sha256=QeGUOBMBMRUWqrTa7bHM36t2Emg8OQwtVE0wLVO3Cpg,384 +onnx/backend/test/data/node/test_bitwise_or_i32_2d/model.onnx,sha256=McwgQLlT_EdkiUFBxBM3MASoBLHnDGhilM4N0nONxOk,149 +onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_0.pb,sha256=vBRtRagPhbZGk_pp35bJnnqw8va3HLQEeA-gRpGr_cg,59 +onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_1.pb,sha256=GLkOWs-6gJxZOVVgeCGpbbxY4U3jqjvRYYSunDQHxjQ,59 +onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/output_0.pb,sha256=PWwPYI7MIgvc8DurWpiRPeZbG0vMzQ4m4jGGmC2OZT8,67 +onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/model.onnx,sha256=L_BirEZ6MunAtXPvm2htIlr8oVaFerC3x3TRibbuB1g,163 +onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_0.pb,sha256=yyF0q6vMUHrYoNxDxHkS1M1J57ABoWCxVPikiSbgt9I,494 +onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_1.pb,sha256=yhmmpWW5p4InqcZXi6vWNboAzILeHxIStUce2hV1TeQ,49 +onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/output_0.pb,sha256=gnw5KbwNGy3mtEYVA0VpILmEYsuxCZe1wGgEKHyNT5o,502 +onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/model.onnx,sha256=VF0_AxeWLUOiz_0T0ghcsMW6_ePD9xlS9XERYlKQoqc,178 +onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_0.pb,sha256=M0-FUiXusNZj8HLlUaJlCacWI_VvmB7CXwEQm7W8-_o,376 +onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_1.pb,sha256=cmiv6qNYN8mNf9Mbmi3IZSAgZ1arXHV1abF_FizB1vk,133 +onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/output_0.pb,sha256=Xb3ol4eZSuioqDtjcIDOyOCendI-ptK9UGFpi5tIWLc,384 +onnx/backend/test/data/node/test_bitwise_xor_i16_3d/model.onnx,sha256=NsWTaACGKoFPWQFATJhi26d7Ad7E1awRbgc3CnH7I8w,166 +onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_0.pb,sha256=51_g10nhl3pGMHzIZPb9uJiIkLoqLtARgYxBZRXFJ8A,133 +onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_1.pb,sha256=cHjBuAqlCncTYhGLbDmLR1oHQbjNdpHVt6Mo7Cg31To,133 +onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/output_0.pb,sha256=25Ra6ldrJ6PLqEEDgZYtL1vFlIf0_C9SO0UPBHeRks0,142 +onnx/backend/test/data/node/test_bitwise_xor_i32_2d/model.onnx,sha256=0QLOP7dIxQdVWZMwH3iA41FMg3nSJgH_KlpdF50dqS0,154 +onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_0.pb,sha256=vBRtRagPhbZGk_pp35bJnnqw8va3HLQEeA-gRpGr_cg,59 +onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_1.pb,sha256=GLkOWs-6gJxZOVVgeCGpbbxY4U3jqjvRYYSunDQHxjQ,59 +onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/output_0.pb,sha256=e61ZBx9CxyY306l5aTy6WcFQLoN6X93lXGQ6bjJl1NU,68 +onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/model.onnx,sha256=LG4PKAQcvKETW_3kJrSXGFi1WrP_osg47XdIotLXITc,167 +onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_0.pb,sha256=yyF0q6vMUHrYoNxDxHkS1M1J57ABoWCxVPikiSbgt9I,494 +onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_1.pb,sha256=yhmmpWW5p4InqcZXi6vWNboAzILeHxIStUce2hV1TeQ,49 +onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/output_0.pb,sha256=qBxhB5FE97cuhUy9PLy4vufyWq3WslKpVW9AszsMxoQ,503 +onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/model.onnx,sha256=HELtLeN0P__CPF4SuXLa8Qkam3xmJp-Wt4S0DpQmfrk,182 +onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_0.pb,sha256=M0-FUiXusNZj8HLlUaJlCacWI_VvmB7CXwEQm7W8-_o,376 +onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_1.pb,sha256=cmiv6qNYN8mNf9Mbmi3IZSAgZ1arXHV1abF_FizB1vk,133 +onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/output_0.pb,sha256=WbhBsgrQao6_fBtCLQYp6UGrGmVRcnMk1H7xyusFeG8,385 +onnx/backend/test/data/node/test_blackmanwindow/model.onnx,sha256=Nx4NbJvhAjOy2ul7cNMiqQFvHzyHF7xBvyni8rB0c8E,99 +onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/output_0.pb,sha256=keYWWdT09vLTG84wMpBvbBoaM7K2i0Vl8f9iEb4Dl7s,49 +onnx/backend/test/data/node/test_blackmanwindow_expanded/model.onnx,sha256=05pJhIQZB2um1j-TNW7okCAE3V_VDP6y3so0xkUc_Y4,4244 +onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/output_0.pb,sha256=keYWWdT09vLTG84wMpBvbBoaM7K2i0Vl8f9iEb4Dl7s,49 +onnx/backend/test/data/node/test_blackmanwindow_symmetric/model.onnx,sha256=X26VKulL-8l4oQJJbri3-rauH9EmYfdOt95QNjx5sIk,126 +onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/output_0.pb,sha256=x5syHaKUNx7HaFR3H9N86Kj1pkwypUSspCb_c8ctAu4,49 +onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/model.onnx,sha256=PcLK0s5KHCgn2quKjikZV8V1ouRwP7Y06MbWwXStF9w,4814 +onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/output_0.pb,sha256=x5syHaKUNx7HaFR3H9N86Kj1pkwypUSspCb_c8ctAu4,49 +onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/model.onnx,sha256=teyyWLTK_05I44tLUYxvjJrT9n-oaQoaEi9Sn63Ya4o,138 +onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb,sha256=AIPs7QV-_L_ajwgcbL5HbhfHzaL95n0zURjTpHjGLEw,39 +onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb,sha256=wf2Q00DDiqxt2Lr0YzsJRvG87F7tIV6U4boXU4W6TA4,64 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/model.onnx,sha256=Jr9X4X6nuH7oJG3_L_g92zOmBZsUIRcHeKyQ5ZaP7vA,136 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb,sha256=cVlLKPSOquKH7X4tyQi9xji0THjFPDOpa2SWqxqRyP0,111 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb,sha256=0jolK7AVdqKeYqxXZl_bMAlnbkHhPocU-fidVgDsG9g,64 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/model.onnx,sha256=GYn7WIl7YUNnn72urMo59fK-dK_DnOs1jzygSmqoyX0,138 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb,sha256=cVlLKPSOquKH7X4tyQi9xji0THjFPDOpa2SWqxqRyP0,111 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb,sha256=avHl4pPAFXiA9yh5X5ssGjYWC46cMT9BYOnx524Bhoo,40 +onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/model.onnx,sha256=Vt39jPW-PurK-pekBNy1q1A4u-9Ij5q2KCf9lm1d204,138 +onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb,sha256=QwU2TijAV4vte-9vZ58rioSAJ7A3pwt8z6w77GshMaM,39 +onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb,sha256=fyIT_roWTtVgHdHUAqdEi72FgiX7KKv6I5iwli5XkBQ,112 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/model.onnx,sha256=obNYEVoqepIYAGU-jwv3PbQsXrtu-EIautaoUV3dBP0,137 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb,sha256=QwU2TijAV4vte-9vZ58rioSAJ7A3pwt8z6w77GshMaM,39 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb,sha256=gZxNgWAAnnDEF1RB86ZES5fMMjbSkdXEgd3Qdkvky78,64 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/model.onnx,sha256=IzIZR5D_D3baad2txwX3h9iaSIPX20L9Nv9_WvW46DY,142 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_0.pb,sha256=TJ3rFELDoYMt8dzK7Dg7a36zw3ytNDV0Ir3ymF0K7Bw,45 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/test_data_set_0/output_0.pb,sha256=ZM591tJDP7VbZoyDjkT5qzOa8WqBNef0YSmsXzu7v7c,24 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/model.onnx,sha256=WhFLIzgt-yP76PQw1nNPqjeHWkg-ttZYLrHkYvuT9_g,144 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=el0tKrXOcSIaQATh7f4n92_QPujSBo7YLXM6H7rU1Ls,31 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx,sha256=Dgpe1z8BT_ouqk13u393V7YaeFNU_y3O_JWfAMytRW0,146 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=v54Gdie54p92llk_T9tP5mf7QqyO-fjBl--LyRHBhlQ,31 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/model.onnx,sha256=xx4Nvs4e4KvL8LO9S3gigi2gEndtMefhfqwT48ruTK0,142 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=QwjMu0e7PAYVPZPZDcVTWBWlBHuICyWchUG8ywVR9Ig,31 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx,sha256=xCgEVhLoLH3CSDZSD0WjVDcQ391M27YOEXuq6Yn-lMk,146 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=3t0txRN5NUMddVglirtxvJrlLt6I3qGSDeusw4dLoBY,31 +onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/model.onnx,sha256=Gl_a8vrOAg3kxhba2hoXYVMglPCDwjJ_0k8lEIhkCII,136 +onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/test_data_set_0/input_0.pb,sha256=FIu2l31uYG1b5mKFanajZG5--lB9lZ1uBBz8hFYPros,29 +onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/test_data_set_0/output_0.pb,sha256=Y1Q7ND7VYJGBWj9MMnvYCaBtPaOPfkvA3FxLl3Mn5ao,18 +onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/model.onnx,sha256=9h8tkm875wa3nnPkszRPvLsySWN9Dva58rZkyrrIXgU,136 +onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/test_data_set_0/input_0.pb,sha256=wkc26zwuBAqiiWlUmIUZ7Zjslh0giyMY_b76WauWXXg,65 +onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/test_data_set_0/output_0.pb,sha256=DxY8St6FrPsPCzw7HsdK6L5gpYc0XPyBj1aOyKWHyMc,29 +onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/model.onnx,sha256=EDEGd-XcRmyAdtaiNQBej-ODMzpFKSkJZ2zYKsozSaM,137 +onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/test_data_set_0/input_0.pb,sha256=FIu2l31uYG1b5mKFanajZG5--lB9lZ1uBBz8hFYPros,29 +onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/test_data_set_0/output_0.pb,sha256=I1tavFkBJyLRfSNhzZ4SUarGOH5M-LiTV9YfzwlSPRE,18 +onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/model.onnx,sha256=dBUVZxnogfMY1oPq3S-cGiOvaNVTEfNvde3ujr-Gl28,137 +onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/test_data_set_0/input_0.pb,sha256=wkc26zwuBAqiiWlUmIUZ7Zjslh0giyMY_b76WauWXXg,65 +onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/test_data_set_0/output_0.pb,sha256=Ltz95VVy3JtZRBft2tsbNTSXW5gL7r23jE6kOq9Vo8A,29 +onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/model.onnx,sha256=nmN2Ow07oeikevPuL-XIbF7N4RpZarwoYK_jSdMpCDc,140 +onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_0.pb,sha256=Fn4iF3_g5X5Pb_gmmmSZnx3Gw0D4606_gDVTvCH4ZTw,23 +onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/test_data_set_0/output_0.pb,sha256=J8y-SmAHLy8yQmoR6lKhi8kfSnc2_Dl7oGgUJqPPwDk,76 +onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/model.onnx,sha256=rwfkeSoAa4jy_Jghu3IhDCc2DW6FrNAbCWT28clNAB0,142 +onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_0.pb,sha256=Fn4iF3_g5X5Pb_gmmmSZnx3Gw0D4606_gDVTvCH4ZTw,23 +onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/test_data_set_0/output_0.pb,sha256=-2rlYC_3BcdtrYKNs78TU18N6hLOCQIQQLTv5ikBK7A,46 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx,sha256=QGPc2BydivQIjGLj54AgN5QsQ3KRvh9fq4jFHTB2278,144 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb,sha256=fFblKfbkmP1CSsR7UWDwlzppmudxzaleDLnBvyt6B_A,30 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb,sha256=YbYdkZNCBfKuOOacK1pLBGa3VvuDBR6Hm4QzXKLaIpg,76 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx,sha256=w5EdV5u4p47Y8L8eSQLdJYd8JY3fxQL9wiLi0Y6S48g,146 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb,sha256=fFblKfbkmP1CSsR7UWDwlzppmudxzaleDLnBvyt6B_A,30 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb,sha256=xtAr-E2kQWpJN0gRwJkFhUgJ_XDjp8seSgLpimDdJzM,46 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/model.onnx,sha256=p9GiSh1kWMG1WHL8g7zC9UqCErupWtZNspiM5dUIhSw,142 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb,sha256=16NyLeQFmBr0g7f0MrgtSJkWt7e9D93mD0uyDm3AF44,30 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb,sha256=BNfuYp6llZShUI5Cwt3Y33aut5eS-X9pDGLKEZXAeKo,76 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/model.onnx,sha256=sAURQlC4K5ie0BanEVvGRk6eUq-5vP1tgcQkM0WhMuY,144 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb,sha256=16NyLeQFmBr0g7f0MrgtSJkWt7e9D93mD0uyDm3AF44,30 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb,sha256=ODsP2h1PABtoARxGi3yd4ShqAqAmGaXvYa68xnxJn-s,46 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx,sha256=jTH9bYL3hEx9-OWIgLg3sTDpXcwTtyB5wA5Zn2hsg2w,144 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb,sha256=OJehhDts_Bv8ejLGqHPmottezo1gffWJKHpIq1aB6q0,30 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb,sha256=JaIRrD53l4QyKvS5SHaX-Az8qrk_BzXknMgc04vfl78,76 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx,sha256=dZBlzZm485Rr0hq-HpGJ_f2T9gUYoDoLtpVED4YgGkY,146 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb,sha256=OJehhDts_Bv8ejLGqHPmottezo1gffWJKHpIq1aB6q0,30 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb,sha256=Rdur6FopgdLEb3UZU8vNVSGOSn71KjIH8VTmrIkZg-Y,46 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/model.onnx,sha256=zFSLiXKB46WU-8AtC7XJ9HVaOOUOLrtg6QY5Nn_x0nA,140 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb,sha256=J3uHFmK9Lo8Xxvlb5W1lB6gqPpAix3Nr-_qVOLCoE1A,30 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb,sha256=oBC6oTO3nE0wfwToI80RtOytDGDK-cRAhTEhbX1tNm8,76 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/model.onnx,sha256=7QZ01LhnuqDuyYvML8bGKg36YtXGdk7JB6ebN8i2IBA,142 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb,sha256=J3uHFmK9Lo8Xxvlb5W1lB6gqPpAix3Nr-_qVOLCoE1A,30 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb,sha256=ANt2Z2GcDky38BnzL10ivI4QdQ8-_w06tL4W7uN2hzg,46 +onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/model.onnx,sha256=O-RbnlOxGw2R-Cp3Ms-4LQJvBIB-aH_OdgIS8fGbX30,138 +onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb,sha256=97_wb_U055nf-PRWYWjNSBULKJrPushEVJu0fgH77n8,40 +onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/model.onnx,sha256=q_eTc7JHnmUBM10blcz_HrSEMNH45KAfO9AU8zP_g2M,136 +onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb,sha256=k4N7P7s7pQt0Urk_8uGEQkqdrU_Gy3hb5dvyMaFPC08,112 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/model.onnx,sha256=8GbvpeZr23Of8UMOmCsqNJeEJlbnzuUwD9hEfM8uqvs,137 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb,sha256=avHl4pPAFXiA9yh5X5ssGjYWC46cMT9BYOnx524Bhoo,40 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/model.onnx,sha256=wHMdzctkp94DYMBF2dmQROLJFLviujLpbSj2p8Nf_io,140 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_0.pb,sha256=mgdqHG3AH4vLzvWfCEpAR1xTheJPh2eDfAtihK_Ng_M,75 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/test_data_set_0/output_0.pb,sha256=ZM591tJDP7VbZoyDjkT5qzOa8WqBNef0YSmsXzu7v7c,24 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/model.onnx,sha256=H74bKvzs7HmC2yD48LmAoQBtrjvXQPQ72fLt2C8lwXY,142 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=el0tKrXOcSIaQATh7f4n92_QPujSBo7YLXM6H7rU1Ls,31 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx,sha256=I-0mgHIk_fnpDywEKaUJVgoFeyr8MqsTG05LPtdhE2o,144 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=v54Gdie54p92llk_T9tP5mf7QqyO-fjBl--LyRHBhlQ,31 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/model.onnx,sha256=T96BDVJgulRisQ0K90IUO5k-IyUzsQNsHh2tgR6riy0,140 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=QwjMu0e7PAYVPZPZDcVTWBWlBHuICyWchUG8ywVR9Ig,31 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx,sha256=ec5fb74D35e9cLZui9-qizAJMxSwNJ-flI_X0vX_OZA,144 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=3t0txRN5NUMddVglirtxvJrlLt6I3qGSDeusw4dLoBY,31 +onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/model.onnx,sha256=5t3OzGKGSRnZhhClIC2Pz2L1u8PDlZaMpuzc5D3F1lg,134 +onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/test_data_set_0/input_0.pb,sha256=F7I6-031CpeYJ_soN5aqaHC2rk7u2P6HrkglKT0de64,43 +onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/test_data_set_0/output_0.pb,sha256=Y1Q7ND7VYJGBWj9MMnvYCaBtPaOPfkvA3FxLl3Mn5ao,18 +onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/model.onnx,sha256=4IcaS-fUrKwI0H8R6g_ESj0ScB5uqa-mB5CLN-mxZVk,134 +onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/test_data_set_0/input_0.pb,sha256=pjmnU_D629_nx7QHA8vmhQg_OTT-iSvh4RToLysVN6o,115 +onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/test_data_set_0/output_0.pb,sha256=DxY8St6FrPsPCzw7HsdK6L5gpYc0XPyBj1aOyKWHyMc,29 +onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/model.onnx,sha256=BaRva5DNT54rM1Ig9y5_hooKykns_53g4nng7kEGXEU,135 +onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/test_data_set_0/input_0.pb,sha256=F7I6-031CpeYJ_soN5aqaHC2rk7u2P6HrkglKT0de64,43 +onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/test_data_set_0/output_0.pb,sha256=I1tavFkBJyLRfSNhzZ4SUarGOH5M-LiTV9YfzwlSPRE,18 +onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/model.onnx,sha256=BOdoyZgKvfKVMunlcRPwskVz4FbH6VKwbS0vNwze9KA,135 +onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/test_data_set_0/input_0.pb,sha256=pjmnU_D629_nx7QHA8vmhQg_OTT-iSvh4RToLysVN6o,115 +onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/test_data_set_0/output_0.pb,sha256=Ltz95VVy3JtZRBft2tsbNTSXW5gL7r23jE6kOq9Vo8A,29 +onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/model.onnx,sha256=OMRjJ4yv30mbMZWQDllj_ESO-LT4ZUPOTBXJyVztxhY,134 +onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/test_data_set_0/output_0.pb,sha256=hgUnqvyRNB-ZdMqUeclabA_Sj96aoc3GbAOP8ogcDLw,44 +onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/model.onnx,sha256=RbNCL2sIkETVMKNvJAMllMtwIGb7cV0r4cEGN2G1dOo,136 +onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/test_data_set_0/output_0.pb,sha256=g1V5XrJ46L0YlIhHsT-ck-OSpGj_1EexaWapkoGhp-w,30 +onnx/backend/test/data/node/test_cast_INT2_to_INT8/model.onnx,sha256=14xJoyOk_ydBCo8GvpSpJjxcZ800PHyZD_bku7uAyhg,133 +onnx/backend/test/data/node/test_cast_INT2_to_INT8/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_cast_INT2_to_INT8/test_data_set_0/output_0.pb,sha256=BSVyxQ0rhfypiwLxLpqT4elzch-GgWZCW3qOjbhxZrc,23 +onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/model.onnx,sha256=fGR-N1qIw1dyTzBqAIQYrjdyvVMKQCAqfveBUwAE3dM,134 +onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/test_data_set_0/output_0.pb,sha256=JibBnmWTfUAcmb-MMtaLkyFx4EPl4MerBd6sSD6waJk,116 +onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/model.onnx,sha256=qNtaZoergDBsoL2hnQ9sbULbzlGe3jPR4dWOrkCAzDk,136 +onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/test_data_set_0/output_0.pb,sha256=udlsAZImje4ho2IBcFPUCvfOtKzQo3bV5XEjnMJzSBo,66 +onnx/backend/test/data/node/test_cast_INT4_to_INT8/model.onnx,sha256=daA_TVGNJyGX53_n6aK1dZ0VHIGfSI7dEM86ANb5LyU,133 +onnx/backend/test/data/node/test_cast_INT4_to_INT8/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_cast_INT4_to_INT8/test_data_set_0/output_0.pb,sha256=RO_Hj-GblIYNR9HO-r0bhOMRpClepy8HLbWnNlaa0Sc,41 +onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/model.onnx,sha256=GVxSwULTy3qQpb276o3PQ5PRgjWtodQkaR176O7igVU,135 +onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/test_data_set_0/output_0.pb,sha256=yl1BrsOU1P5F1Ewox3wFchocIMDuVfXT-M9lbJ_qeA8,44 +onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/model.onnx,sha256=nU1v0DIZ5o_hTRAAuG0V5LJwyC9YuQ8vCfmHDUHFujI,137 +onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/test_data_set_0/output_0.pb,sha256=Wsyj2YFp5YhC-Bm0hz6MNkn-svd_hBk1D5ONbvGWf-Q,30 +onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/model.onnx,sha256=_AKvl94FKXZESEPrHiAfSje8r3JbVXnvfqvCQBoOfDM,135 +onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/test_data_set_0/output_0.pb,sha256=sxKF5FyQzoOiOyNGuhaeXTcFQM_2Bv0LeqxiTJHV0uE,23 +onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/model.onnx,sha256=B78kEoqO-fNHWPWWPbVSuJBLSMvg2BeRi-euDHe8q4c,135 +onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/test_data_set_0/output_0.pb,sha256=6rHhmKi7KF1En2k1GG2e0O2DzT8kIfYOaUCwusJvXrU,116 +onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/model.onnx,sha256=gie27972JN-vhNXBraYoKQeYY1rzYmFGRWHF4xA2LN8,137 +onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/test_data_set_0/output_0.pb,sha256=-NTkd6AtdXCN0_bDXLguYMQxY_IBNSPP70QZp4Co_Aw,66 +onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/model.onnx,sha256=-EfTN2sT3Oszo78nNRwl1XYDvNSIFaqQmRTN6iZex5g,135 +onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/test_data_set_0/output_0.pb,sha256=hxLKo5hNxCLp0bOmAgA75KTqdyauEi43m8Aqtx8GpZQ,41 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/model.onnx,sha256=yqlgjuQfdqzN4w8b_XqQJWsiblDo_bQPdR-h3VwRCkU,186 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/test_data_set_0/input_0.pb,sha256=4HB3aMbzxLlj4hl8K6hWnARnCf6hQBM5zbr1JS50G6Y,31 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/test_data_set_0/output_0.pb,sha256=8IPEFWXSfQRflEfjvwbmYmocnYzPSbPjShJaksOr3nI,24 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/model.onnx,sha256=CpZwe6IkhKSL9yutPTeVuFvzqkPY8zIAGSBbrtZ6Lzg,145 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/test_data_set_0/input_0.pb,sha256=1LXP6dR7TTAB9dTVsC7ch3bR-I2vLO6UFMJafFe-qqA,23 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/test_data_set_0/output_0.pb,sha256=WW5med1aTkMo5mMk9KVZASZMccGYj5dfMIOtXsvc5E0,48 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/model.onnx,sha256=o7gHUx1c2AOWAGsVH8Lyz6iwXboCZepRszaym_jYR48,147 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/test_data_set_0/input_0.pb,sha256=1LXP6dR7TTAB9dTVsC7ch3bR-I2vLO6UFMJafFe-qqA,23 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/test_data_set_0/output_0.pb,sha256=WEUgSESRFn2K4cslldLG8utVkIONrgZNVKEJIkhn6FM,32 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/model.onnx,sha256=oD1ZQ5aXHkh0g7LqAip0fZxowDlUYfY6v8bptWj62a4,184 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/test_data_set_0/input_0.pb,sha256=dQy_9agAc3ZcM4B_cpOsyZFN5Z3zWkqAVBmPWzNqJE4,47 +onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/test_data_set_0/output_0.pb,sha256=8IPEFWXSfQRflEfjvwbmYmocnYzPSbPjShJaksOr3nI,24 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx,sha256=om7Mx0FKeftHjv6FmbpqqOGjYJ1g0XMqi9sM0xd04FM,174 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=3BY0HmWGs5FY8SdW_mGEth_m-rM3yXPZcwGKRexfrFE,31 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx,sha256=bl3PtpeRYlXWwCSmgVcSTPXoLt39bdz1Cj5BxVePm04,176 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=2GqFXiQqmY3yCHC71zbkoZMB6lFnIS46G69ddlq6jrg,31 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx,sha256=qxIULnN1oCbGX5viL9QWuTZDoyqRHcTcdH6qMPsKq10,172 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=q9mo--pPuxLjS7oox3X9VzrdfH0ZdZMNWWt29Ja3lSM,31 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx,sha256=7wMn4PYRgKwNHxCkLeSbBbqKHrIxIpPCbQgaM-kxY0A,176 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=Nwdwhgz2METpwxQ0z2XJDS6Sk5Z7b-wqL-Q8aYgOt_Q,31 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx,sha256=GnSdKLD4zvttrIDC7Nf3wtK7Xwg2VQhdhDpPO1h3ve4,172 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=3BY0HmWGs5FY8SdW_mGEth_m-rM3yXPZcwGKRexfrFE,31 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx,sha256=Wmh2U3hPE0Lm9C88QiAn-3Z-vvQ0dfwFJEMvCAT9y3s,174 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=2GqFXiQqmY3yCHC71zbkoZMB6lFnIS46G69ddlq6jrg,31 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx,sha256=K4UrmWYTsvJW44Wh5XG8mCpLQgixih5i9dJCOVXVdTM,170 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=q9mo--pPuxLjS7oox3X9VzrdfH0ZdZMNWWt29Ja3lSM,31 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx,sha256=iCMsl0fxCKY0Ami60HRT59doQol5tdcHjtCiYmQzMQg,174 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=Nwdwhgz2METpwxQ0z2XJDS6Sk5Z7b-wqL-Q8aYgOt_Q,31 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/model.onnx,sha256=3uKvdIN3BQCb2zCG42QwNROqeDyHACD0AjI443NCTQI,162 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb,sha256=AIPs7QV-_L_ajwgcbL5HbhfHzaL95n0zURjTpHjGLEw,39 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb,sha256=wf2Q00DDiqxt2Lr0YzsJRvG87F7tIV6U4boXU4W6TA4,64 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/model.onnx,sha256=RuISm_eBshNDzBgxCKBhk7BDnxOcfZNjRPb6Wqpxpk0,191 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=AIPs7QV-_L_ajwgcbL5HbhfHzaL95n0zURjTpHjGLEw,39 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=wf2Q00DDiqxt2Lr0YzsJRvG87F7tIV6U4boXU4W6TA4,64 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/model.onnx,sha256=ThPu1rfI1U_AmNwssa4v6A4DyaMtI11Ffrk42Cp2nkI,160 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb,sha256=cVlLKPSOquKH7X4tyQi9xji0THjFPDOpa2SWqxqRyP0,111 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb,sha256=0jolK7AVdqKeYqxXZl_bMAlnbkHhPocU-fidVgDsG9g,64 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/model.onnx,sha256=Uix3LXUcxAFHscim6jSABlJ8ehZdYc5ehHT8pW6hjUE,162 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb,sha256=cVlLKPSOquKH7X4tyQi9xji0THjFPDOpa2SWqxqRyP0,111 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb,sha256=avHl4pPAFXiA9yh5X5ssGjYWC46cMT9BYOnx524Bhoo,40 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/model.onnx,sha256=x94TMf2XKM93BDRSFubLenn8LlTSW_nBaEH_PDDapdk,191 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=cVlLKPSOquKH7X4tyQi9xji0THjFPDOpa2SWqxqRyP0,111 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=avHl4pPAFXiA9yh5X5ssGjYWC46cMT9BYOnx524Bhoo,40 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/model.onnx,sha256=Ufr-Iowvg-8cM9v6Aa1Qjajv3rCE4YTpwOYEkbXqKek,189 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=cVlLKPSOquKH7X4tyQi9xji0THjFPDOpa2SWqxqRyP0,111 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=0jolK7AVdqKeYqxXZl_bMAlnbkHhPocU-fidVgDsG9g,64 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/model.onnx,sha256=x_HCKT4P354bXqE0OqA7-1K-HJYn-QAIs8TqiabRibY,162 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb,sha256=QwU2TijAV4vte-9vZ58rioSAJ7A3pwt8z6w77GshMaM,39 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_1.pb,sha256=Gp9CxTYPDCBV8kcgnJdpQW8pvhN3TC6q8YgwtSY1yXo,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb,sha256=fyIT_roWTtVgHdHUAqdEi72FgiX7KKv6I5iwli5XkBQ,112 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/model.onnx,sha256=aTx0URjDLdQk8vzbmXeGj9yRK7oLWc_Im9nGBoaKeCE,191 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_0.pb,sha256=QwU2TijAV4vte-9vZ58rioSAJ7A3pwt8z6w77GshMaM,39 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_1.pb,sha256=Gp9CxTYPDCBV8kcgnJdpQW8pvhN3TC6q8YgwtSY1yXo,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/output_0.pb,sha256=fyIT_roWTtVgHdHUAqdEi72FgiX7KKv6I5iwli5XkBQ,112 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/model.onnx,sha256=FCQTt-TOVhAzSx4IjMQw8cyP4xM_tLiRwUrzFy2IQdI,161 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb,sha256=QwU2TijAV4vte-9vZ58rioSAJ7A3pwt8z6w77GshMaM,39 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb,sha256=gZxNgWAAnnDEF1RB86ZES5fMMjbSkdXEgd3Qdkvky78,64 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/model.onnx,sha256=vo9xoKyE_HPfljeqLFH84JwoegGG8j57PhaDzfimOp8,166 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_0.pb,sha256=TJ3rFELDoYMt8dzK7Dg7a36zw3ytNDV0Ir3ymF0K7Bw,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_1.pb,sha256=9aZfj7D6frw2PaWDo3kV_ht6dCcqrTYfz_6VyaF9dB0,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/output_0.pb,sha256=ZM591tJDP7VbZoyDjkT5qzOa8WqBNef0YSmsXzu7v7c,24 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/model.onnx,sha256=2v8IVZKEC7kG0eguIj9hq_9AGpZN6RtMcno63-x5Dxk,195 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/input_0.pb,sha256=TJ3rFELDoYMt8dzK7Dg7a36zw3ytNDV0Ir3ymF0K7Bw,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/input_1.pb,sha256=9aZfj7D6frw2PaWDo3kV_ht6dCcqrTYfz_6VyaF9dB0,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/output_0.pb,sha256=ZM591tJDP7VbZoyDjkT5qzOa8WqBNef0YSmsXzu7v7c,24 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/model.onnx,sha256=-vIYILdM-JCUicy7gnnCUCr5TXP8TOYne9RlQksvDi4,168 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb,sha256=ftVjFykB2Sr0Zu0dF5hksA7scFDt759u89_QvyyuV2g,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=el0tKrXOcSIaQATh7f4n92_QPujSBo7YLXM6H7rU1Ls,31 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx,sha256=c0zelkwGCV9QrgmtsgpB9HTk5zEJSGVY2uZlt55esAE,170 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb,sha256=vHGE9VdOfx0R82vPjxrYvlXTMRMNVXV9IB95o7o1xxI,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=v54Gdie54p92llk_T9tP5mf7QqyO-fjBl--LyRHBhlQ,31 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/model.onnx,sha256=zlsv9QODtDjZ3kmT3VZzPCsNfu3JJDKF_txD6Dk6ZSk,199 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb,sha256=vHGE9VdOfx0R82vPjxrYvlXTMRMNVXV9IB95o7o1xxI,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb,sha256=v54Gdie54p92llk_T9tP5mf7QqyO-fjBl--LyRHBhlQ,31 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/model.onnx,sha256=EFI4nvTjTQZnS4q_OXIqj_VYqkscNNXj65aWZIiHQJ0,197 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb,sha256=ftVjFykB2Sr0Zu0dF5hksA7scFDt759u89_QvyyuV2g,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb,sha256=el0tKrXOcSIaQATh7f4n92_QPujSBo7YLXM6H7rU1Ls,31 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/model.onnx,sha256=oDKFk0XYo9d2gfppdYgBwet7dzHXolg__I9vc894KSM,166 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_1.pb,sha256=xgi1vXVsh-3TL8IqhzOXxlYGSN5UnIcH3FmsVPTp9Wg,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=QwjMu0e7PAYVPZPZDcVTWBWlBHuICyWchUG8ywVR9Ig,31 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx,sha256=pgZ3GcoKE1OwHtzapZK7TiF8RHolqizOJXVg8IWQJqs,170 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb,sha256=tTWJZW2iT6UqZwzVNEIP1_jWhey4oHjIl6h4uilC80g,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=3t0txRN5NUMddVglirtxvJrlLt6I3qGSDeusw4dLoBY,31 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/model.onnx,sha256=NinT8eptgyuyJ2jXIZ9EFcL6Il78Gqxlv2vT3-ThgZk,199 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb,sha256=tTWJZW2iT6UqZwzVNEIP1_jWhey4oHjIl6h4uilC80g,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb,sha256=3t0txRN5NUMddVglirtxvJrlLt6I3qGSDeusw4dLoBY,31 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/model.onnx,sha256=bGqcs8V8YVuxw3nmhjBuTcYuQLhBYi-Zb-U_N-eiNtU,195 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb,sha256=xgi1vXVsh-3TL8IqhzOXxlYGSN5UnIcH3FmsVPTp9Wg,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb,sha256=QwjMu0e7PAYVPZPZDcVTWBWlBHuICyWchUG8ywVR9Ig,31 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/model.onnx,sha256=iJMIcVEfc17VIYW0w6Gc6tiNNA0_-e-CKBKgzQrBigU,190 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=QwU2TijAV4vte-9vZ58rioSAJ7A3pwt8z6w77GshMaM,39 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=gZxNgWAAnnDEF1RB86ZES5fMMjbSkdXEgd3Qdkvky78,64 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/model.onnx,sha256=_WQ_tsMFdzcU7XEzr7ASK_E3YLwEM8-pM7bXN9cbx-U,160 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/input_0.pb,sha256=FIu2l31uYG1b5mKFanajZG5--lB9lZ1uBBz8hFYPros,29 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/input_1.pb,sha256=OEpftbS5FJXdgAImDwh8m6jl5ZuvuQdtOWWZ6MoOrfE,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/output_0.pb,sha256=Y1Q7ND7VYJGBWj9MMnvYCaBtPaOPfkvA3FxLl3Mn5ao,18 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/model.onnx,sha256=wIxyyLt6BEfYe9Hcm9_9r6O5K_OUzu5MEWH_RdhEKMI,189 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/input_0.pb,sha256=FIu2l31uYG1b5mKFanajZG5--lB9lZ1uBBz8hFYPros,29 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/input_1.pb,sha256=OEpftbS5FJXdgAImDwh8m6jl5ZuvuQdtOWWZ6MoOrfE,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/output_0.pb,sha256=Y1Q7ND7VYJGBWj9MMnvYCaBtPaOPfkvA3FxLl3Mn5ao,18 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/model.onnx,sha256=igKRhcMAx_LPIYz0UF745snSePCoo85a5cgKtxo2eD4,160 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/input_0.pb,sha256=wkc26zwuBAqiiWlUmIUZ7Zjslh0giyMY_b76WauWXXg,65 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/input_1.pb,sha256=mTiiNiZ8WPIWymf_7WE2FugVGZVKo8DBf_BV1St4QRA,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/output_0.pb,sha256=DxY8St6FrPsPCzw7HsdK6L5gpYc0XPyBj1aOyKWHyMc,29 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/model.onnx,sha256=gpuTLTt_NgLzWowcu2YEXgeTYJp7WN05AyzF0xpv1bA,189 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/input_0.pb,sha256=wkc26zwuBAqiiWlUmIUZ7Zjslh0giyMY_b76WauWXXg,65 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/input_1.pb,sha256=mTiiNiZ8WPIWymf_7WE2FugVGZVKo8DBf_BV1St4QRA,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/output_0.pb,sha256=DxY8St6FrPsPCzw7HsdK6L5gpYc0XPyBj1aOyKWHyMc,29 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/model.onnx,sha256=pYRIg_xSJYy9LY9wWRsM8FHWgLYgPyX6GLaAGlUvRnw,161 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/input_0.pb,sha256=FIu2l31uYG1b5mKFanajZG5--lB9lZ1uBBz8hFYPros,29 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/input_1.pb,sha256=jvOS9jYgMXGSC2gUpi3sDl9AH9WEn_amOHf5J_6eWX8,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/output_0.pb,sha256=I1tavFkBJyLRfSNhzZ4SUarGOH5M-LiTV9YfzwlSPRE,18 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/model.onnx,sha256=dMLg7ogDZ14cNC1typ-kB-hc7sMjMo4M6GndjM18QPo,190 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/input_0.pb,sha256=FIu2l31uYG1b5mKFanajZG5--lB9lZ1uBBz8hFYPros,29 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/input_1.pb,sha256=jvOS9jYgMXGSC2gUpi3sDl9AH9WEn_amOHf5J_6eWX8,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/output_0.pb,sha256=I1tavFkBJyLRfSNhzZ4SUarGOH5M-LiTV9YfzwlSPRE,18 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/model.onnx,sha256=4BnC9vkuBsxxG69YpjC-2ukqa9dED_TMWNJaA08a-5c,161 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/input_0.pb,sha256=wkc26zwuBAqiiWlUmIUZ7Zjslh0giyMY_b76WauWXXg,65 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/input_1.pb,sha256=Tf9BukRLteFZCeke4LmXR9FHRyMonuWnrxsactTGzNU,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/output_0.pb,sha256=Ltz95VVy3JtZRBft2tsbNTSXW5gL7r23jE6kOq9Vo8A,29 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/model.onnx,sha256=_qBa29S6eUgH6m43l2bfz7pWNvvz6y1TDAPqnNqhohQ,190 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/input_0.pb,sha256=wkc26zwuBAqiiWlUmIUZ7Zjslh0giyMY_b76WauWXXg,65 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/input_1.pb,sha256=Tf9BukRLteFZCeke4LmXR9FHRyMonuWnrxsactTGzNU,10 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/output_0.pb,sha256=Ltz95VVy3JtZRBft2tsbNTSXW5gL7r23jE6kOq9Vo8A,29 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/model.onnx,sha256=sB-m6qOzI_AdLKgPMe2YQ0Z_j_onjVTQ5DkD6WCP5tA,164 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_0.pb,sha256=Fn4iF3_g5X5Pb_gmmmSZnx3Gw0D4606_gDVTvCH4ZTw,23 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/output_0.pb,sha256=J8y-SmAHLy8yQmoR6lKhi8kfSnc2_Dl7oGgUJqPPwDk,76 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/model.onnx,sha256=veHdpemedrs-m2EaMv1rli2lVkEQ9lnxJ6D-FAvDWWw,166 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_0.pb,sha256=Fn4iF3_g5X5Pb_gmmmSZnx3Gw0D4606_gDVTvCH4ZTw,23 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/output_0.pb,sha256=-2rlYC_3BcdtrYKNs78TU18N6hLOCQIQQLTv5ikBK7A,46 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/model.onnx,sha256=bY_bp9ETvIb37T6G5W2E5507HyXSw5W9RTkid5QJ72Y,195 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=Fn4iF3_g5X5Pb_gmmmSZnx3Gw0D4606_gDVTvCH4ZTw,23 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=-2rlYC_3BcdtrYKNs78TU18N6hLOCQIQQLTv5ikBK7A,46 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/model.onnx,sha256=Qvrx9XTchA9Ss52R7142kh490azXqr2IGc7YnWmhwiU,193 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=Fn4iF3_g5X5Pb_gmmmSZnx3Gw0D4606_gDVTvCH4ZTw,23 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=J8y-SmAHLy8yQmoR6lKhi8kfSnc2_Dl7oGgUJqPPwDk,76 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx,sha256=lF6wyxQLTUriUKpjSzujvJhwiY3wtqm2bCLqJPoW8bs,168 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb,sha256=fFblKfbkmP1CSsR7UWDwlzppmudxzaleDLnBvyt6B_A,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb,sha256=YbYdkZNCBfKuOOacK1pLBGa3VvuDBR6Hm4QzXKLaIpg,76 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx,sha256=EZsy4ShqrPWy33ZbnCNzrCRvdxpusRoIiBMejYgCZyk,170 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb,sha256=fFblKfbkmP1CSsR7UWDwlzppmudxzaleDLnBvyt6B_A,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb,sha256=xtAr-E2kQWpJN0gRwJkFhUgJ_XDjp8seSgLpimDdJzM,46 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/model.onnx,sha256=D8qKNsipn19Jo0HHZn4CrW0OE_LM49ukzPphJFbdUYc,199 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=fFblKfbkmP1CSsR7UWDwlzppmudxzaleDLnBvyt6B_A,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=xtAr-E2kQWpJN0gRwJkFhUgJ_XDjp8seSgLpimDdJzM,46 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/model.onnx,sha256=OZhNyTEHvd-cj0MsZRwaYdo8CTvaaBsr4-MkYyjJdvE,197 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=fFblKfbkmP1CSsR7UWDwlzppmudxzaleDLnBvyt6B_A,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=YbYdkZNCBfKuOOacK1pLBGa3VvuDBR6Hm4QzXKLaIpg,76 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/model.onnx,sha256=f8KkBOwM4xqLawDvXKQEkjki20AzdOxje2DAKY3gSis,166 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb,sha256=16NyLeQFmBr0g7f0MrgtSJkWt7e9D93mD0uyDm3AF44,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb,sha256=BNfuYp6llZShUI5Cwt3Y33aut5eS-X9pDGLKEZXAeKo,76 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/model.onnx,sha256=0q3YKu16KRo0tQftapxcbiRXXhG0Np245WAkbqE15Gw,168 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb,sha256=16NyLeQFmBr0g7f0MrgtSJkWt7e9D93mD0uyDm3AF44,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb,sha256=ODsP2h1PABtoARxGi3yd4ShqAqAmGaXvYa68xnxJn-s,46 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/model.onnx,sha256=9z3dLqRpybuivZLV5kWSn_7NKGW1eDuXvGPVNmEoT0Y,197 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=16NyLeQFmBr0g7f0MrgtSJkWt7e9D93mD0uyDm3AF44,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=ODsP2h1PABtoARxGi3yd4ShqAqAmGaXvYa68xnxJn-s,46 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/model.onnx,sha256=PIB7ndAsEeB8FEcZ0rDahs8xaDgdLxnMNenXya4nCVk,195 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=16NyLeQFmBr0g7f0MrgtSJkWt7e9D93mD0uyDm3AF44,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=BNfuYp6llZShUI5Cwt3Y33aut5eS-X9pDGLKEZXAeKo,76 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx,sha256=62Q2mf8xLMVn8BzTP9tggRP-icA1lNBZWt3HjrbXLXs,168 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb,sha256=OJehhDts_Bv8ejLGqHPmottezo1gffWJKHpIq1aB6q0,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb,sha256=JaIRrD53l4QyKvS5SHaX-Az8qrk_BzXknMgc04vfl78,76 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx,sha256=Lsex0aJ1UJ20yECFTyJ8djR8IQFQ8cn5jAGPWKm-p5U,170 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb,sha256=OJehhDts_Bv8ejLGqHPmottezo1gffWJKHpIq1aB6q0,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb,sha256=Rdur6FopgdLEb3UZU8vNVSGOSn71KjIH8VTmrIkZg-Y,46 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/model.onnx,sha256=_5JIhjfiXzrBBlWHxjEoPWvTfiPZBRVHsrvaGxK3Ec8,199 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=OJehhDts_Bv8ejLGqHPmottezo1gffWJKHpIq1aB6q0,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=Rdur6FopgdLEb3UZU8vNVSGOSn71KjIH8VTmrIkZg-Y,46 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/model.onnx,sha256=fZZVbOfX52OV_MU5lkE_TP-IMNDFo8xK9C33fTHd5uE,197 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=OJehhDts_Bv8ejLGqHPmottezo1gffWJKHpIq1aB6q0,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=JaIRrD53l4QyKvS5SHaX-Az8qrk_BzXknMgc04vfl78,76 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/model.onnx,sha256=uUQbbQex8Xa8nRYmc_LqtnU7z9XHdbdJoBQ9kcbZZ-0,164 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb,sha256=J3uHFmK9Lo8Xxvlb5W1lB6gqPpAix3Nr-_qVOLCoE1A,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb,sha256=oBC6oTO3nE0wfwToI80RtOytDGDK-cRAhTEhbX1tNm8,76 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/model.onnx,sha256=sPP9eImBnYWolfPPcphfEhpwCwNPIcgTdURRlQpX5k4,166 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb,sha256=J3uHFmK9Lo8Xxvlb5W1lB6gqPpAix3Nr-_qVOLCoE1A,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb,sha256=ANt2Z2GcDky38BnzL10ivI4QdQ8-_w06tL4W7uN2hzg,46 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/model.onnx,sha256=aan7_6RiRmYMvHzcEO317nqk9fKsZH2s6U1VXX4zerM,195 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=J3uHFmK9Lo8Xxvlb5W1lB6gqPpAix3Nr-_qVOLCoE1A,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=ANt2Z2GcDky38BnzL10ivI4QdQ8-_w06tL4W7uN2hzg,46 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/model.onnx,sha256=b7KrFxvB51rUvD06MIlpH2II_tQzUWhN48J9I4ZqlG4,193 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=J3uHFmK9Lo8Xxvlb5W1lB6gqPpAix3Nr-_qVOLCoE1A,30 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=oBC6oTO3nE0wfwToI80RtOytDGDK-cRAhTEhbX1tNm8,76 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/model.onnx,sha256=DYIHpWm-mWWcBoEkpbm6kVUCTH9SCrXnHDbzoJmpgkg,162 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_1.pb,sha256=aLvEJbuQGsla0oX3eG3TW38IyJtg0JIKFmFzcO5mNfw,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb,sha256=97_wb_U055nf-PRWYWjNSBULKJrPushEVJu0fgH77n8,40 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/model.onnx,sha256=VUriA31SBIC3UcniArLWzogig8S8w48xEMIpb9Et79c,191 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_1.pb,sha256=aLvEJbuQGsla0oX3eG3TW38IyJtg0JIKFmFzcO5mNfw,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/output_0.pb,sha256=97_wb_U055nf-PRWYWjNSBULKJrPushEVJu0fgH77n8,40 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/model.onnx,sha256=PTOLrgM618hctYYwYEOF-JBFsYMcWdIIsHZHm8tgBpU,160 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_1.pb,sha256=Gp9CxTYPDCBV8kcgnJdpQW8pvhN3TC6q8YgwtSY1yXo,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb,sha256=k4N7P7s7pQt0Urk_8uGEQkqdrU_Gy3hb5dvyMaFPC08,112 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/model.onnx,sha256=XkxSb7iaUsWaz8NGO9WejJsc5dly7HCepwXnpa28FcY,189 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_1.pb,sha256=Gp9CxTYPDCBV8kcgnJdpQW8pvhN3TC6q8YgwtSY1yXo,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/output_0.pb,sha256=k4N7P7s7pQt0Urk_8uGEQkqdrU_Gy3hb5dvyMaFPC08,112 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/model.onnx,sha256=d4AOJd8J03O58BMZmvibOshu_WezK2GnWAYM4mjINEM,161 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb,sha256=avHl4pPAFXiA9yh5X5ssGjYWC46cMT9BYOnx524Bhoo,40 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/model.onnx,sha256=1yumBMYGU5wEz-ySdAgx7NGs-xeX_fTajjgwO1yRh1M,190 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=avHl4pPAFXiA9yh5X5ssGjYWC46cMT9BYOnx524Bhoo,40 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/model.onnx,sha256=JN6VMaRS-E3r0XmZO6vhaTR3wuv2JXT24Q0ziIG5Wlw,164 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_0.pb,sha256=mgdqHG3AH4vLzvWfCEpAR1xTheJPh2eDfAtihK_Ng_M,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_1.pb,sha256=9aZfj7D6frw2PaWDo3kV_ht6dCcqrTYfz_6VyaF9dB0,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/output_0.pb,sha256=ZM591tJDP7VbZoyDjkT5qzOa8WqBNef0YSmsXzu7v7c,24 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/model.onnx,sha256=zfSYm-l_Atcjnft_YopB103Xxt5ufoj2B_FUvCMw6zA,193 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/input_0.pb,sha256=mgdqHG3AH4vLzvWfCEpAR1xTheJPh2eDfAtihK_Ng_M,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/input_1.pb,sha256=9aZfj7D6frw2PaWDo3kV_ht6dCcqrTYfz_6VyaF9dB0,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/output_0.pb,sha256=ZM591tJDP7VbZoyDjkT5qzOa8WqBNef0YSmsXzu7v7c,24 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/model.onnx,sha256=ZjTrAQDfrXO1Q8ORRl7175SjA1l-GbbFhuArFs1Sgl0,166 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb,sha256=ftVjFykB2Sr0Zu0dF5hksA7scFDt759u89_QvyyuV2g,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=el0tKrXOcSIaQATh7f4n92_QPujSBo7YLXM6H7rU1Ls,31 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx,sha256=Cg9WD_wCLWgSkTTnWEd_zz-CsPHpN7R_0kqY1uM3LNA,168 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb,sha256=vHGE9VdOfx0R82vPjxrYvlXTMRMNVXV9IB95o7o1xxI,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=v54Gdie54p92llk_T9tP5mf7QqyO-fjBl--LyRHBhlQ,31 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx,sha256=oScw8qoa5as2ywR7voTkHdOacaRDKZCrMsu8flK9OK4,197 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb,sha256=vHGE9VdOfx0R82vPjxrYvlXTMRMNVXV9IB95o7o1xxI,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb,sha256=v54Gdie54p92llk_T9tP5mf7QqyO-fjBl--LyRHBhlQ,31 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx,sha256=WppwtwPxL22k4EE3R3ixb6XDryFrQM1YG3KNyCANyZ0,195 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb,sha256=ftVjFykB2Sr0Zu0dF5hksA7scFDt759u89_QvyyuV2g,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb,sha256=el0tKrXOcSIaQATh7f4n92_QPujSBo7YLXM6H7rU1Ls,31 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/model.onnx,sha256=XwdwoApWB4elzu5EzZF5uIcRHK8233wEXC28jW5t6SQ,164 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb,sha256=xgi1vXVsh-3TL8IqhzOXxlYGSN5UnIcH3FmsVPTp9Wg,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=QwjMu0e7PAYVPZPZDcVTWBWlBHuICyWchUG8ywVR9Ig,31 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx,sha256=_HNo_hNxcNK2QP2y08cxt910J1vqx9aW6NGbqaNzfKo,168 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb,sha256=tTWJZW2iT6UqZwzVNEIP1_jWhey4oHjIl6h4uilC80g,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=3t0txRN5NUMddVglirtxvJrlLt6I3qGSDeusw4dLoBY,31 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx,sha256=L4SYQRfYCZHgvUD7unMUpRE_TTy-P4TcOG5HITpsYIk,197 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb,sha256=tTWJZW2iT6UqZwzVNEIP1_jWhey4oHjIl6h4uilC80g,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb,sha256=3t0txRN5NUMddVglirtxvJrlLt6I3qGSDeusw4dLoBY,31 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/model.onnx,sha256=gDaCSOr2JuEgBHs5rm7i0owORt59uTdpQhG24Bm-U5w,193 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb,sha256=xgi1vXVsh-3TL8IqhzOXxlYGSN5UnIcH3FmsVPTp9Wg,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb,sha256=QwjMu0e7PAYVPZPZDcVTWBWlBHuICyWchUG8ywVR9Ig,31 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/model.onnx,sha256=einPDOuBd404tOsRzfGcSp6mLirBrLTB2wo9F9-VmWU,158 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/input_0.pb,sha256=F7I6-031CpeYJ_soN5aqaHC2rk7u2P6HrkglKT0de64,43 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/input_1.pb,sha256=OEpftbS5FJXdgAImDwh8m6jl5ZuvuQdtOWWZ6MoOrfE,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/output_0.pb,sha256=Y1Q7ND7VYJGBWj9MMnvYCaBtPaOPfkvA3FxLl3Mn5ao,18 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/model.onnx,sha256=_0ZGfDpXOEbIttBnF7LP5jmlynVxcPL4n6GUTD8kCI4,187 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/input_0.pb,sha256=F7I6-031CpeYJ_soN5aqaHC2rk7u2P6HrkglKT0de64,43 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/input_1.pb,sha256=OEpftbS5FJXdgAImDwh8m6jl5ZuvuQdtOWWZ6MoOrfE,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/output_0.pb,sha256=Y1Q7ND7VYJGBWj9MMnvYCaBtPaOPfkvA3FxLl3Mn5ao,18 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/model.onnx,sha256=oNV4FWNxxl992PgJvl3adYr8kxVoOQe0TlJKJsb1chY,158 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/input_0.pb,sha256=pjmnU_D629_nx7QHA8vmhQg_OTT-iSvh4RToLysVN6o,115 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/input_1.pb,sha256=mTiiNiZ8WPIWymf_7WE2FugVGZVKo8DBf_BV1St4QRA,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/output_0.pb,sha256=DxY8St6FrPsPCzw7HsdK6L5gpYc0XPyBj1aOyKWHyMc,29 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/model.onnx,sha256=lnBsbOeTpZOY6d0f3jBHrzqDLC0WG2DHTzVjaktyy-Q,187 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/input_0.pb,sha256=pjmnU_D629_nx7QHA8vmhQg_OTT-iSvh4RToLysVN6o,115 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/input_1.pb,sha256=mTiiNiZ8WPIWymf_7WE2FugVGZVKo8DBf_BV1St4QRA,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/output_0.pb,sha256=DxY8St6FrPsPCzw7HsdK6L5gpYc0XPyBj1aOyKWHyMc,29 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/model.onnx,sha256=qRK3ygbZBnkmueG4jeB3nGeadRGkoqh-qcFu7aunOz0,159 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/input_0.pb,sha256=F7I6-031CpeYJ_soN5aqaHC2rk7u2P6HrkglKT0de64,43 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/input_1.pb,sha256=jvOS9jYgMXGSC2gUpi3sDl9AH9WEn_amOHf5J_6eWX8,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/output_0.pb,sha256=I1tavFkBJyLRfSNhzZ4SUarGOH5M-LiTV9YfzwlSPRE,18 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/model.onnx,sha256=sGX8oZm1A6dQqVbDm-vl9oYw3PjCQIGprO4gloxF29E,188 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/input_0.pb,sha256=F7I6-031CpeYJ_soN5aqaHC2rk7u2P6HrkglKT0de64,43 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/input_1.pb,sha256=jvOS9jYgMXGSC2gUpi3sDl9AH9WEn_amOHf5J_6eWX8,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/output_0.pb,sha256=I1tavFkBJyLRfSNhzZ4SUarGOH5M-LiTV9YfzwlSPRE,18 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/model.onnx,sha256=Xrzvf9RqclHwrGKqKuOQ3rbvGdy4maY5gE327wZY-Kc,159 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/input_0.pb,sha256=pjmnU_D629_nx7QHA8vmhQg_OTT-iSvh4RToLysVN6o,115 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/input_1.pb,sha256=Tf9BukRLteFZCeke4LmXR9FHRyMonuWnrxsactTGzNU,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/output_0.pb,sha256=Ltz95VVy3JtZRBft2tsbNTSXW5gL7r23jE6kOq9Vo8A,29 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/model.onnx,sha256=Dcw3LiMTmQff6hHexW_pzTjGOU1jx9h8F1WNZBquyIg,188 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/input_0.pb,sha256=pjmnU_D629_nx7QHA8vmhQg_OTT-iSvh4RToLysVN6o,115 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/input_1.pb,sha256=Tf9BukRLteFZCeke4LmXR9FHRyMonuWnrxsactTGzNU,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/output_0.pb,sha256=Ltz95VVy3JtZRBft2tsbNTSXW5gL7r23jE6kOq9Vo8A,29 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/model.onnx,sha256=RX7ncm39-JJ1-vD0QTs4y_hXE5Vl0ssSRL_N0Q2ssNQ,158 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/output_0.pb,sha256=hgUnqvyRNB-ZdMqUeclabA_Sj96aoc3GbAOP8ogcDLw,44 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/model.onnx,sha256=VrqqSZ8wbC5WxCcakpyHz8JNjZQd40XEkQIMkjMazi4,160 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/output_0.pb,sha256=g1V5XrJ46L0YlIhHsT-ck-OSpGj_1EexaWapkoGhp-w,30 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/model.onnx,sha256=3nRWhHnmlw5nK0SWcSOw8w5YJFNLUfnc_WC3Qg-cbgA,189 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=g1V5XrJ46L0YlIhHsT-ck-OSpGj_1EexaWapkoGhp-w,30 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/model.onnx,sha256=isoNmFonbqv8h_9_9zq0UCOBJCgUxiasQoamBuupOus,187 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=hgUnqvyRNB-ZdMqUeclabA_Sj96aoc3GbAOP8ogcDLw,44 +onnx/backend/test/data/node/test_castlike_INT2_to_INT8/model.onnx,sha256=Z_PxIoi5SLdpnaclrva0DMfoKPoGPj2zs3YkYbzRU2w,157 +onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/input_1.pb,sha256=AdBXiqreushjTzSAsQQPR7nAq4q6cyyCDL2ElDWkXAs,10 +onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/output_0.pb,sha256=BSVyxQ0rhfypiwLxLpqT4elzch-GgWZCW3qOjbhxZrc,23 +onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/model.onnx,sha256=ESUoOBwDULbzbKLSI3RYiqMtYuOkOBtpMC4dXghqAts,186 +onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/input_0.pb,sha256=hx-YTuL3ZBCcV5bAN-N5RQVetECwPR1FhqX7k22TnIc,17 +onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/input_1.pb,sha256=AdBXiqreushjTzSAsQQPR7nAq4q6cyyCDL2ElDWkXAs,10 +onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/output_0.pb,sha256=BSVyxQ0rhfypiwLxLpqT4elzch-GgWZCW3qOjbhxZrc,23 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/model.onnx,sha256=U67Ex3L8rvrjxbjBiypv09eCv-hi8nows_MMvNmxK2k,158 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/output_0.pb,sha256=JibBnmWTfUAcmb-MMtaLkyFx4EPl4MerBd6sSD6waJk,116 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/model.onnx,sha256=ftQJYlC-eqvEtOL1Tma5RjMhYTDbShJWmndIcvn_epE,160 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/output_0.pb,sha256=udlsAZImje4ho2IBcFPUCvfOtKzQo3bV5XEjnMJzSBo,66 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/model.onnx,sha256=JDDY2PL_5S9J2TINnig8mdcy5H1e_acEpFFDc9djJ-s,189 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=udlsAZImje4ho2IBcFPUCvfOtKzQo3bV5XEjnMJzSBo,66 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/model.onnx,sha256=TxnQ15xO8ndjkbVWzvA5KJv5GFC9uL-LBAch6J1C1vk,187 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=JibBnmWTfUAcmb-MMtaLkyFx4EPl4MerBd6sSD6waJk,116 +onnx/backend/test/data/node/test_castlike_INT4_to_INT8/model.onnx,sha256=tn2MnALzLW9P5CfnWRDhGDyg03rJ4r96k947hmfn5EI,157 +onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/input_1.pb,sha256=AdBXiqreushjTzSAsQQPR7nAq4q6cyyCDL2ElDWkXAs,10 +onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/output_0.pb,sha256=RO_Hj-GblIYNR9HO-r0bhOMRpClepy8HLbWnNlaa0Sc,41 +onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/model.onnx,sha256=0aPnGK8UsHXveGeRt-Afu5vCtl8cyemw2PHH3dDjLeQ,186 +onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/input_0.pb,sha256=gqbPVYZalcsr9Mrp9R8hHw8JgEqosV2lq5Uz3RHqgns,28 +onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/input_1.pb,sha256=AdBXiqreushjTzSAsQQPR7nAq4q6cyyCDL2ElDWkXAs,10 +onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/output_0.pb,sha256=RO_Hj-GblIYNR9HO-r0bhOMRpClepy8HLbWnNlaa0Sc,41 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/model.onnx,sha256=jnyYKf_S6TasHuQmRoX7pnepWj4-nd6Se0mPybQvMC0,159 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/output_0.pb,sha256=yl1BrsOU1P5F1Ewox3wFchocIMDuVfXT-M9lbJ_qeA8,44 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/model.onnx,sha256=TfrNYkxuXuRWomAkUr9mYZ-jLx6Ut2kWnL-IcCONZTM,161 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/output_0.pb,sha256=Wsyj2YFp5YhC-Bm0hz6MNkn-svd_hBk1D5ONbvGWf-Q,30 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/model.onnx,sha256=lnxWbpDVvH6eS7SeRM4V_Yp0ySgCUAQrxcDHCI8r47U,190 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=Wsyj2YFp5YhC-Bm0hz6MNkn-svd_hBk1D5ONbvGWf-Q,30 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/model.onnx,sha256=AhzdhiUZgmfiGyH_sEE0kg5YEwKGkWjIVng-RQ5mHfo,188 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=yl1BrsOU1P5F1Ewox3wFchocIMDuVfXT-M9lbJ_qeA8,44 +onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/model.onnx,sha256=PTc9_zwn21ul28MQo-vj0oIZYxOTes9Dlturf-P1Vs0,159 +onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/input_1.pb,sha256=Weqr-ItcBHjXmpnCP1UGRQXTzd20ZO7fyXeaQAOgeVc,10 +onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/output_0.pb,sha256=sxKF5FyQzoOiOyNGuhaeXTcFQM_2Bv0LeqxiTJHV0uE,23 +onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/model.onnx,sha256=Jxpqv1H1brKJNTyr2cBwl-Tljr59L_aSSD84g7XjxyM,188 +onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/input_0.pb,sha256=dqqiNY4wJ-hfVw2TaeL4i2QWYZdxiNgMvV8mfpbnPQ0,17 +onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/input_1.pb,sha256=Weqr-ItcBHjXmpnCP1UGRQXTzd20ZO7fyXeaQAOgeVc,10 +onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/output_0.pb,sha256=sxKF5FyQzoOiOyNGuhaeXTcFQM_2Bv0LeqxiTJHV0uE,23 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/model.onnx,sha256=xvSsTfil61rfG5W_HRlzS-rvEmT8_B5epociTb7g_qw,159 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/output_0.pb,sha256=6rHhmKi7KF1En2k1GG2e0O2DzT8kIfYOaUCwusJvXrU,116 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/model.onnx,sha256=9pqo8EbPPknEsmadA2x_HMRMRyLI6UIx_HUQkqW8cVA,161 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/output_0.pb,sha256=-NTkd6AtdXCN0_bDXLguYMQxY_IBNSPP70QZp4Co_Aw,66 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/model.onnx,sha256=w-fgf9KrbOdroC6PQ6FgggTiUvMJyGqXmd_zvopzTds,190 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=EAKGrxjauitdz9urJ8BDgEvEJGXjuWmALoFYTunAuNc,10 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=-NTkd6AtdXCN0_bDXLguYMQxY_IBNSPP70QZp4Co_Aw,66 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/model.onnx,sha256=1ZVq4GVPkBs-LNKTUvs5ma48kAs6JdRwTBlwLQxIEk8,188 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=CRJx7rUdQcHxGytc9DaMKYU-g5ex2eIJokJFWV1uVyI,10 +onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=6rHhmKi7KF1En2k1GG2e0O2DzT8kIfYOaUCwusJvXrU,116 +onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/model.onnx,sha256=OCtuBs0Mzh3f7jpTzM9tY3k510cRWPUxmNrO5CKRlT0,159 +onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/input_1.pb,sha256=Weqr-ItcBHjXmpnCP1UGRQXTzd20ZO7fyXeaQAOgeVc,10 +onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/output_0.pb,sha256=hxLKo5hNxCLp0bOmAgA75KTqdyauEi43m8Aqtx8GpZQ,41 +onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/model.onnx,sha256=IMSt_L2HleRqJotW7s2psxeBOrOJuBr98faIH6oVPCc,188 +onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/input_0.pb,sha256=UwItzY9Co3clAqRsXjpZBDmx6fV49JUOplL2K_ITpSI,28 +onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/input_1.pb,sha256=Weqr-ItcBHjXmpnCP1UGRQXTzd20ZO7fyXeaQAOgeVc,10 +onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/output_0.pb,sha256=hxLKo5hNxCLp0bOmAgA75KTqdyauEi43m8Aqtx8GpZQ,41 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx,sha256=waKym2nt8yCGX2TjO9LklXcjKzdb2a66j0Vd9pp9V9c,197 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb,sha256=ftVjFykB2Sr0Zu0dF5hksA7scFDt759u89_QvyyuV2g,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=3BY0HmWGs5FY8SdW_mGEth_m-rM3yXPZcwGKRexfrFE,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx,sha256=OycwivZTgGvkTacEOlbBLBnH27qBS-lp75V5fw34MbE,199 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb,sha256=vHGE9VdOfx0R82vPjxrYvlXTMRMNVXV9IB95o7o1xxI,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=2GqFXiQqmY3yCHC71zbkoZMB6lFnIS46G69ddlq6jrg,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/model.onnx,sha256=K4RpeKAT72u152s57DXzI1-tKVke-SF2MIQJtyOtAZQ,211 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb,sha256=vHGE9VdOfx0R82vPjxrYvlXTMRMNVXV9IB95o7o1xxI,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb,sha256=2GqFXiQqmY3yCHC71zbkoZMB6lFnIS46G69ddlq6jrg,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/model.onnx,sha256=t-UfKYKGPjk_ixAualI95irFHKfOpHM6DXjDyVu6MqA,209 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb,sha256=ftVjFykB2Sr0Zu0dF5hksA7scFDt759u89_QvyyuV2g,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb,sha256=3BY0HmWGs5FY8SdW_mGEth_m-rM3yXPZcwGKRexfrFE,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx,sha256=auex60BaZHJdBnTdvAAjhOaQ9WdP8AGFoljTXQNo2Ms,195 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_1.pb,sha256=xgi1vXVsh-3TL8IqhzOXxlYGSN5UnIcH3FmsVPTp9Wg,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=q9mo--pPuxLjS7oox3X9VzrdfH0ZdZMNWWt29Ja3lSM,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx,sha256=kFHr2dmsM0iu1R46DsBfvnGiHXnIWdphjx2bjxl5F_A,199 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb,sha256=tTWJZW2iT6UqZwzVNEIP1_jWhey4oHjIl6h4uilC80g,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=Nwdwhgz2METpwxQ0z2XJDS6Sk5Z7b-wqL-Q8aYgOt_Q,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/model.onnx,sha256=3WUdEsSO3JPQUJH76g17PZw5PtA0DJrkB_UXN19mF54,211 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb,sha256=tTWJZW2iT6UqZwzVNEIP1_jWhey4oHjIl6h4uilC80g,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb,sha256=Nwdwhgz2METpwxQ0z2XJDS6Sk5Z7b-wqL-Q8aYgOt_Q,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/model.onnx,sha256=BXXXaJplhnP5-H3QRTExXz2xbBsnY8eSqw0E1wXlNAk,207 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb,sha256=clH173yhuJ44Zm5FaJQ35UgxSSF8Ayo8WXQRrQXcj2E,45 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb,sha256=xgi1vXVsh-3TL8IqhzOXxlYGSN5UnIcH3FmsVPTp9Wg,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb,sha256=q9mo--pPuxLjS7oox3X9VzrdfH0ZdZMNWWt29Ja3lSM,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx,sha256=yPV3C5POQysO7eEhl9FAqu9BWILB51KDCh6fn6X5JhU,195 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb,sha256=ftVjFykB2Sr0Zu0dF5hksA7scFDt759u89_QvyyuV2g,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=3BY0HmWGs5FY8SdW_mGEth_m-rM3yXPZcwGKRexfrFE,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx,sha256=y-Sm9K7vtAzl4LhsS2_6sbALn2iUevOZ2E7wqZopVEA,197 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb,sha256=vHGE9VdOfx0R82vPjxrYvlXTMRMNVXV9IB95o7o1xxI,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=2GqFXiQqmY3yCHC71zbkoZMB6lFnIS46G69ddlq6jrg,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx,sha256=ETfS8ax-uzeVUgvXFcfL5Kgr-lXLrP5oFX2GIawv8ko,209 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb,sha256=vHGE9VdOfx0R82vPjxrYvlXTMRMNVXV9IB95o7o1xxI,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb,sha256=2GqFXiQqmY3yCHC71zbkoZMB6lFnIS46G69ddlq6jrg,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx,sha256=Gnw8Pid7Vens6JOWE5aqhKfxXQyQ9Q_3kz40XUFT3iU,207 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb,sha256=ftVjFykB2Sr0Zu0dF5hksA7scFDt759u89_QvyyuV2g,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb,sha256=3BY0HmWGs5FY8SdW_mGEth_m-rM3yXPZcwGKRexfrFE,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx,sha256=1bgbYogg6lpnROfxW7uo77rcgYIhpyI81XbNTtZ53Fg,193 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb,sha256=xgi1vXVsh-3TL8IqhzOXxlYGSN5UnIcH3FmsVPTp9Wg,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=q9mo--pPuxLjS7oox3X9VzrdfH0ZdZMNWWt29Ja3lSM,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx,sha256=BaYgzHpSyMim54ZdDDV6xYstjLOdl6r7hy04Q4idd0U,197 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb,sha256=tTWJZW2iT6UqZwzVNEIP1_jWhey4oHjIl6h4uilC80g,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=Nwdwhgz2METpwxQ0z2XJDS6Sk5Z7b-wqL-Q8aYgOt_Q,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx,sha256=BgFPd-BzDzJXwd5Ia1ACcfKkWfd6Qg_S9_gz0fuljis,209 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb,sha256=tTWJZW2iT6UqZwzVNEIP1_jWhey4oHjIl6h4uilC80g,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb,sha256=Nwdwhgz2METpwxQ0z2XJDS6Sk5Z7b-wqL-Q8aYgOt_Q,31 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/model.onnx,sha256=VGGx3HHpNgttrxtEHF41BMKsoTt3i9YCU2trnGhLAoQ,205 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb,sha256=f3fVTDtaNPUt0O5x0EUDRd3cIyAMl66cD1M1VKeMXII,75 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb,sha256=xgi1vXVsh-3TL8IqhzOXxlYGSN5UnIcH3FmsVPTp9Wg,10 +onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb,sha256=q9mo--pPuxLjS7oox3X9VzrdfH0ZdZMNWWt29Ja3lSM,31 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/model.onnx,sha256=R53R7FuB5BKkzMXuzOLvu_48-w461Lw6g23jcTlvVmg,258 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/input_0.pb,sha256=Z2DI_PnDMpYHhXNFERRqWTTJc8GfamFB0jbHuV1JG8Q,41 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/input_1.pb,sha256=2-u0A846XSQCuv1eGJwwiog11tZMC66HBMot10YhNN8,34 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/output_0.pb,sha256=11JoNBLdF-FO8nmQliFqTJpe7gugLaNhh-ZPN7xe6xs,42 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/output_1.pb,sha256=REwhi4Qf9mSbGrGOXwHLJFtlCu-eiYKLC-q1ZxeEcPQ,37 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/model.onnx,sha256=LX-zbZRsUq8UYRCeSvTeojxEgnNiZxeyu2evV5lqBfo,3450 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/input_0.pb,sha256=Z2DI_PnDMpYHhXNFERRqWTTJc8GfamFB0jbHuV1JG8Q,41 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/input_1.pb,sha256=2-u0A846XSQCuv1eGJwwiog11tZMC66HBMot10YhNN8,34 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/output_0.pb,sha256=11JoNBLdF-FO8nmQliFqTJpe7gugLaNhh-ZPN7xe6xs,42 +onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/output_1.pb,sha256=REwhi4Qf9mSbGrGOXwHLJFtlCu-eiYKLC-q1ZxeEcPQ,37 +onnx/backend/test/data/node/test_causal_conv_with_state_basic/model.onnx,sha256=HRCrn-4l-yWnmdJ5j3umTyjHNUHVRghFi6ujbizKFLo,247 +onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/output_0.pb,sha256=a8QIsq2zLUTsL2rNEhxAI6edomgmsFUg3aNwIV9xqAM,275 +onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/model.onnx,sha256=oBRAYu6a10mzHhMematWX35-am5XtXwEOKVqq7J8Ym4,3106 +onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/output_0.pb,sha256=a8QIsq2zLUTsL2rNEhxAI6edomgmsFUg3aNwIV9xqAM,275 +onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/model.onnx,sha256=h8KFyIOk1kMWbYdnW9x07dViNtu7RjEZ7QWeZyiA8aE,325 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_0.pb,sha256=P_zqg0T5KtrYTu046ykNnCYrwRzU80qFLywqcYPVaUA,49 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_1.pb,sha256=5Ud3OVCUK3MLC2WxV28m9_zHHT-8pK3Kh8wXAZ49Dic,82 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_2.pb,sha256=OOh1soEwMXcP2E-7VVvUyhIQQDb8g2piEHnWo5csQes,28 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_3.pb,sha256=i1UFPPMxnco1AfFiVmlDeMziB43VovWy0SHCUFBWQHg,118 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/output_0.pb,sha256=1Pnx0OGT4xakD1P7JNNrHBPGM-VZiUuKReKL9CT6MZc,50 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/output_1.pb,sha256=cOWr75yy4hw30QqOu9YFfsBx8658jscq55Z_SEaZYzk,121 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/model.onnx,sha256=CKixKzTUq21FnDXsFGHSyOGrLsWyz-ZG-nvHKpSfKx8,2228 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_0.pb,sha256=P_zqg0T5KtrYTu046ykNnCYrwRzU80qFLywqcYPVaUA,49 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_1.pb,sha256=5Ud3OVCUK3MLC2WxV28m9_zHHT-8pK3Kh8wXAZ49Dic,82 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_2.pb,sha256=OOh1soEwMXcP2E-7VVvUyhIQQDb8g2piEHnWo5csQes,28 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_3.pb,sha256=i1UFPPMxnco1AfFiVmlDeMziB43VovWy0SHCUFBWQHg,118 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/output_0.pb,sha256=1Pnx0OGT4xakD1P7JNNrHBPGM-VZiUuKReKL9CT6MZc,50 +onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/output_1.pb,sha256=cOWr75yy4hw30QqOu9YFfsBx8658jscq55Z_SEaZYzk,121 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16/model.onnx,sha256=odlvI0NcmdPWSKykzkX2suKaJE1FKBMe1DX-7fnaTZM,246 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/input_0.pb,sha256=f1K6iUK0NvpTKiNuoZXzpHjUbYazyZLgIPiOkbz9k3M,146 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/input_1.pb,sha256=g0Wt1gfGhIZZWYx26xYFMMuaMGYaaXeHwcukzwFnqqc,50 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/output_0.pb,sha256=o9OXQnh32ZGoFJ039uyOEbVLfvmV9CWbtpkGtuVY6Qc,147 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/output_1.pb,sha256=PJMa2IxwI__cvrK7y4CTumJ0Ee2cOTfIK3e9rKvbI70,73 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/model.onnx,sha256=aQwVNi1loRHRacjiQwGI5GoyfT8jiZio-RKXXYS-qn8,3075 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/input_0.pb,sha256=f1K6iUK0NvpTKiNuoZXzpHjUbYazyZLgIPiOkbz9k3M,146 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/input_1.pb,sha256=g0Wt1gfGhIZZWYx26xYFMMuaMGYaaXeHwcukzwFnqqc,50 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/output_0.pb,sha256=o9OXQnh32ZGoFJ039uyOEbVLfvmV9CWbtpkGtuVY6Qc,147 +onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/output_1.pb,sha256=PJMa2IxwI__cvrK7y4CTumJ0Ee2cOTfIK3e9rKvbI70,73 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/model.onnx,sha256=zwXRKrs50SN3NuUhepZxsOYaOyoFKpfGdkLQPILwzQs,257 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/input_1.pb,sha256=SrEKQABm-PU_D0VsDwWm1cB6bnZCyxyffBTCFJvssWg,34 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/output_0.pb,sha256=ks-jkCKg2za6frI2eeHl6QEvyif3H50NAhqE2iOdGeU,275 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/output_1.pb,sha256=TnabazseO2CRfYEwb8HEUHDTk6dU1FMrhJvmou0W32w,25 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/model.onnx,sha256=PQVS-lrQ-fwSCtXSyV4L1261oH0EKD3F9iGqGmpnG-E,3419 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/input_1.pb,sha256=SrEKQABm-PU_D0VsDwWm1cB6bnZCyxyffBTCFJvssWg,34 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/output_0.pb,sha256=ks-jkCKg2za6frI2eeHl6QEvyif3H50NAhqE2iOdGeU,275 +onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/output_1.pb,sha256=TnabazseO2CRfYEwb8HEUHDTk6dU1FMrhJvmou0W32w,25 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/model.onnx,sha256=tzQDWeNuN57AoXEZQZSRtZAvD9xL_rE8feuMzABAUPw,267 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/input_0.pb,sha256=EbYub3a0Yn5xaC9mK5AX4U2eX8WuQW-YsGVMTSgtx40,81 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/input_1.pb,sha256=O98-eVowWdO5NOGJbYtArTV-lPO7z9qU8_k9laBFJ6k,98 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/output_0.pb,sha256=N59I3NoLijglKSRtigsqPFfxPFpMTmQSmCsAfx0WaQs,82 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/output_1.pb,sha256=qnC8dUKDGC_BHAXc5zbRk5oyn3iKUg0IECZlKFFkFDU,154 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/model.onnx,sha256=BDeE-obW2AAJgDyCCuFf8SQpeWhcKHpzLSWPiQ5a31o,3731 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/input_0.pb,sha256=EbYub3a0Yn5xaC9mK5AX4U2eX8WuQW-YsGVMTSgtx40,81 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/input_1.pb,sha256=O98-eVowWdO5NOGJbYtArTV-lPO7z9qU8_k9laBFJ6k,98 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/output_0.pb,sha256=N59I3NoLijglKSRtigsqPFfxPFpMTmQSmCsAfx0WaQs,82 +onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/output_1.pb,sha256=qnC8dUKDGC_BHAXc5zbRk5oyn3iKUg0IECZlKFFkFDU,154 +onnx/backend/test/data/node/test_causal_conv_with_state_silu/model.onnx,sha256=YB0QHuydzIKsvTao45QBeQsGaG-8Xxcc_-Sg48nXYqI,269 +onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/output_0.pb,sha256=2fQW1WmFYcJqeUF1IMxghChAjPUzER3FgdUmns6T73Y,275 +onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/model.onnx,sha256=wODwcNyrxxjqlB-gQlyZpBa3ljaEeptOFST-v3HaO3A,3793 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/output_0.pb,sha256=2fQW1WmFYcJqeUF1IMxghChAjPUzER3FgdUmns6T73Y,275 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/model.onnx,sha256=ktskkIGkzeLhfZvYeVLbUKj4ktffgWCDb0brTWNlEvM,274 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/input_0.pb,sha256=f1K6iUK0NvpTKiNuoZXzpHjUbYazyZLgIPiOkbz9k3M,146 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/input_1.pb,sha256=g0Wt1gfGhIZZWYx26xYFMMuaMGYaaXeHwcukzwFnqqc,50 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/output_0.pb,sha256=7DfKurA-IsO_o-oVE9_2ly1nyvcGaDBFjwOl3ta9VXk,147 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/output_1.pb,sha256=PJMa2IxwI__cvrK7y4CTumJ0Ee2cOTfIK3e9rKvbI70,73 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/model.onnx,sha256=AJtNHp85u01JJ8fp4-RaXWQKBUC8LzK8GPCWsZoQ5LE,3991 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/input_0.pb,sha256=f1K6iUK0NvpTKiNuoZXzpHjUbYazyZLgIPiOkbz9k3M,146 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/input_1.pb,sha256=g0Wt1gfGhIZZWYx26xYFMMuaMGYaaXeHwcukzwFnqqc,50 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/output_0.pb,sha256=7DfKurA-IsO_o-oVE9_2ly1nyvcGaDBFjwOl3ta9VXk,147 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/output_1.pb,sha256=PJMa2IxwI__cvrK7y4CTumJ0Ee2cOTfIK3e9rKvbI70,73 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/model.onnx,sha256=qV-zpZPiNrL2A1InTyAj7Kn4avFnOu9J4bxrTK-2WKM,333 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_2.pb,sha256=qwuAXH9cWoJM0URKORKqaW3SP5LhnET6i3AGuQBOFT4,118 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/output_0.pb,sha256=6AR604genWM7q-KQt8aEfBgWdgSzqlNBuCbM6u2Cax0,275 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/model.onnx,sha256=A3kto9mm_x9eyyT_thQWNVOg94HzXFmKM98T4o64qlY,3229 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_2.pb,sha256=qwuAXH9cWoJM0URKORKqaW3SP5LhnET6i3AGuQBOFT4,118 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/output_0.pb,sha256=6AR604genWM7q-KQt8aEfBgWdgSzqlNBuCbM6u2Cax0,275 +onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/model.onnx,sha256=u18WCYnEZ-ekcy8TXGMMeS4K4WCK-0rL2lQoe14xwDY,277 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/output_0.pb,sha256=2fQW1WmFYcJqeUF1IMxghChAjPUzER3FgdUmns6T73Y,275 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/model.onnx,sha256=MRdDiR9tEhaUY1z3afpeR0AAKijCB6zkBzXP303WZPs,4069 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/output_0.pb,sha256=2fQW1WmFYcJqeUF1IMxghChAjPUzER3FgdUmns6T73Y,275 +onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/model.onnx,sha256=LauvZ2u2wO-XNeShXo-GEbqElxYGpwnNhmHY3YPz8Sk,277 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_2.pb,sha256=j8zMgDXns1lc-AMEFMTO1Ffe2yjiTPuKSojFq9ja8pc,28 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/output_0.pb,sha256=cCdBED_cqmcP0EvgxGTUM47JCxAw-fq8PQIEDHf1-lI,275 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/model.onnx,sha256=rdyNhiFE83O_uFx6oYwDqHCQblbHzjGhvomHcHKivRg,338 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_2.pb,sha256=j8zMgDXns1lc-AMEFMTO1Ffe2yjiTPuKSojFq9ja8pc,28 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_3.pb,sha256=bbjoUkRONXNCsoNUKfQYojWiNGPPjyKfZiDbgCzxerg,118 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/output_0.pb,sha256=dqrI_gCL42r1QiAFyDoPNmj0NF-MBpOGXaOddF_z33g,275 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/model.onnx,sha256=-1mAE74X8wy2cHSqe7qqIbnOI8X9tubTRegHGnODpmk,2490 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_2.pb,sha256=j8zMgDXns1lc-AMEFMTO1Ffe2yjiTPuKSojFq9ja8pc,28 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_3.pb,sha256=bbjoUkRONXNCsoNUKfQYojWiNGPPjyKfZiDbgCzxerg,118 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/output_0.pb,sha256=dqrI_gCL42r1QiAFyDoPNmj0NF-MBpOGXaOddF_z33g,275 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/model.onnx,sha256=9QewLo8gHeYp0GNubWS08crzs_i0Y8YRkXcLeLAkoKg,3259 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_2.pb,sha256=j8zMgDXns1lc-AMEFMTO1Ffe2yjiTPuKSojFq9ja8pc,28 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/output_0.pb,sha256=cCdBED_cqmcP0EvgxGTUM47JCxAw-fq8PQIEDHf1-lI,275 +onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/model.onnx,sha256=wDXzQspB2xZVnX7LfsyuB8u-ldFnlJ75fRQSF86Ub-I,305 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_2.pb,sha256=qwuAXH9cWoJM0URKORKqaW3SP5LhnET6i3AGuQBOFT4,118 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/output_0.pb,sha256=qwh8wygLl-wsqM0BsSQNJsPacg9iC8R2ex5haHLKVgU,275 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/model.onnx,sha256=8L0elP0sd8qH7rwNUGvFCuXIkvJ162GJxkEUsC4JgL8,2282 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_0.pb,sha256=UMOi3b354h2msbBpvJM4iITe5xEs3G1t-tOJMajIr-M,274 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_1.pb,sha256=K6owuYdV7XJt5xwqut7GKA5HE576ALl_xVMnPGhyWe8,82 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_2.pb,sha256=qwuAXH9cWoJM0URKORKqaW3SP5LhnET6i3AGuQBOFT4,118 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/output_0.pb,sha256=qwh8wygLl-wsqM0BsSQNJsPacg9iC8R2ex5haHLKVgU,275 +onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/output_1.pb,sha256=8BSL_0ejKtN2GFPg7GvzwiZZ2hJ586aBCcNAXjKPbiM,121 +onnx/backend/test/data/node/test_ceil/model.onnx,sha256=zYQ7FyzP6UWksThCpmDNZVL7ACGAVk45wCUk7MSpMPw,99 +onnx/backend/test/data/node/test_ceil/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_ceil/test_data_set_0/output_0.pb,sha256=zFFujcTZbJ_iUdvnj1WgKihPqud_iXTK61jQn2s3fkU,254 +onnx/backend/test/data/node/test_ceil_example/model.onnx,sha256=8MRvY_buZ3kwGWbrH3N9AtIKqYnHsubJWQBe-Uk8wDg,91 +onnx/backend/test/data/node/test_ceil_example/test_data_set_0/input_0.pb,sha256=oA0la8_u-_HaZWXeP39QnRf3LzBFm_z-OT5ubTiMa_U,17 +onnx/backend/test/data/node/test_ceil_example/test_data_set_0/output_0.pb,sha256=B7VTcXhgHNoWwox6O0nLSYo-xZkobaTvtkPnXWM8T8w,17 +onnx/backend/test/data/node/test_celu/model.onnx,sha256=cAr7drqDNV5RDqzClNfkslVJ4K89Qlj0ywgg_uwHiiw,124 +onnx/backend/test/data/node/test_celu/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_celu/test_data_set_0/output_0.pb,sha256=6P8qt55BKmIbeRKrDDUb_9L_ZZgD2nf7uJFA69OD8Os,123 +onnx/backend/test/data/node/test_celu_expanded/model.onnx,sha256=HfTUwa-nDKvHFYB7ANwkEKpTexAJAuNrhXUSPIPIX8Y,485 +onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/output_0.pb,sha256=6P8qt55BKmIbeRKrDDUb_9L_ZZgD2nf7uJFA69OD8Os,123 +onnx/backend/test/data/node/test_center_crop_pad_crop/model.onnx,sha256=_UO9zWEcYILyGcbCnjQg7KHg2LFJw7PxdNFcUlmO68g,153 +onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_0.pb,sha256=gf54Qr4guDZleIe2sau8YNEx-dDwW55nJJ5RqhWYCHk,2414 +onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_1.pb,sha256=azvnzc647fD3maqvDtZTEwrGWfugxBxPHJAPz7424Qk,37 +onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/output_0.pb,sha256=SNJXACP7f4r8OFKE3X8vI4Bfu4kXNPTkemOqeuQifTc,854 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/model.onnx,sha256=2yQn_WyWM7819hVHdgPRMNyxAI_6pTMS5dH_ahRzZrA,161 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_1.pb,sha256=XE-LFxtx5KK6KyhPjIx-Hp-i_db8kg7viI8PN8SDXnc,37 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/output_0.pb,sha256=NwJcXJ-I3-LwyTwk8F6WaLvoITXD4jynu8BnWdMfxdY,1214 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/model.onnx,sha256=3SXsErt7mt9BpECaXiK4kW66R7xeU072PARgYd_fQmc,2658 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_1.pb,sha256=XE-LFxtx5KK6KyhPjIx-Hp-i_db8kg7viI8PN8SDXnc,37 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/output_0.pb,sha256=NwJcXJ-I3-LwyTwk8F6WaLvoITXD4jynu8BnWdMfxdY,1214 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/model.onnx,sha256=NxTo_Ni7c8YpJj640cd9qoXA_GdxapFiCCSeLbH_7Xw,177 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_0.pb,sha256=5bJVCfNa9wvtQv3XL4MKOfrM0RylCo4e3iKMenFQojw,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/output_0.pb,sha256=golyE5sd9CtwPUzy7oEWi2ovFIug8BohD5b2N7o2_Xg,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/model.onnx,sha256=WyXAtrdbAMR_xZYhE9W_iHz8P2V3DbLLhVeY2lFeSlI,3485 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_0.pb,sha256=5bJVCfNa9wvtQv3XL4MKOfrM0RylCo4e3iKMenFQojw,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/output_0.pb,sha256=golyE5sd9CtwPUzy7oEWi2ovFIug8BohD5b2N7o2_Xg,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/model.onnx,sha256=ViKPMOcZcmDs3W72cKydVNfdXiz7BzXrzuTJD2BWa-M,177 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/output_0.pb,sha256=ywUWnOKgTUDpebF1B3HI5cEuEAvmvdsA13IZEnfncZY,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/model.onnx,sha256=Na51-QkGvR8-oGz-1V5aWseNqcPL6KwnfSRCrGe91gg,3485 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/output_0.pb,sha256=ywUWnOKgTUDpebF1B3HI5cEuEAvmvdsA13IZEnfncZY,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/model.onnx,sha256=i3QMXxhLCRMRCXHiDBj9X5IwPjkexZK_mCyKeXgBO00,2410 +onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_0.pb,sha256=gf54Qr4guDZleIe2sau8YNEx-dDwW55nJJ5RqhWYCHk,2414 +onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_1.pb,sha256=azvnzc647fD3maqvDtZTEwrGWfugxBxPHJAPz7424Qk,37 +onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/output_0.pb,sha256=SNJXACP7f4r8OFKE3X8vI4Bfu4kXNPTkemOqeuQifTc,854 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/model.onnx,sha256=SG0akIxqpCM29L2aTKW_NVPJr9KxJWBGJuENM2EH4o8,204 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/output_0.pb,sha256=ywUWnOKgTUDpebF1B3HI5cEuEAvmvdsA13IZEnfncZY,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/model.onnx,sha256=bH3jKyXyTbQO1v4cdRYuri9vJ78cWi8tR9co_Ihg-ho,3864 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/output_0.pb,sha256=ywUWnOKgTUDpebF1B3HI5cEuEAvmvdsA13IZEnfncZY,1094 +onnx/backend/test/data/node/test_center_crop_pad_pad/model.onnx,sha256=ZsLLWWeEugG7qfPtUUsbt7iBfXtdL1Qoq3zFJ-gyM-A,151 +onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_0.pb,sha256=Brb9NNYy61mIqV0k6WJ2uoox7QOgy-TI61uJhMg0QZw,854 +onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_1.pb,sha256=MicQ1KFx-S6_RlEPgAe1cyjiu2xloE-vov752d7v394,37 +onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/output_0.pb,sha256=TqD45G9p_DkrIF5wtvJXaOW0ls_XSgER9EsfKT66no4,2414 +onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/model.onnx,sha256=rIrnvjLpY-MpX1WgOkSabprL4n8fLeTTlPfJc9ZCCHc,2379 +onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_0.pb,sha256=Brb9NNYy61mIqV0k6WJ2uoox7QOgy-TI61uJhMg0QZw,854 +onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_1.pb,sha256=MicQ1KFx-S6_RlEPgAe1cyjiu2xloE-vov752d7v394,37 +onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/output_0.pb,sha256=TqD45G9p_DkrIF5wtvJXaOW0ls_XSgER9EsfKT66no4,2414 +onnx/backend/test/data/node/test_clip/model.onnx,sha256=LeRDoahciHypJ9D7ArLrfQwYmGTzb2Mco1syI1Dpp4w,139 +onnx/backend/test/data/node/test_clip/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_clip/test_data_set_0/input_1.pb,sha256=BRepSTg3YLUzFaeEDm7kjV41FnB7WdzkW7ynoPYkPGs,13 +onnx/backend/test/data/node/test_clip/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip/test_data_set_0/output_0.pb,sha256=0Mj3n7O3-ghXihrxNll_6tjrgxFo27H4atMMfljBuEg,254 +onnx/backend/test/data/node/test_clip_default_inbounds/model.onnx,sha256=K4rP6tKhvLWvZ25uFXfcgzpjmeBe4fodMVdEp6TWncw,104 +onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_default_inbounds_expanded/model.onnx,sha256=dtxZlZ7xu_1pfCXBFLU8V_bS-YBZeWCxB9mmT1rXhMU,115 +onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_default_int8_inbounds/model.onnx,sha256=gUowpb23puqbhCvxUPiduQpf5-uoFRVsf_28cLYT99E,109 +onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/input_0.pb,sha256=vG4b7OylZbXs1oNvJh6N2DD10wdfMSnVxkKOz7zbvwA,12 +onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/output_0.pb,sha256=p1SpO2Oa2tZ9dMA6FVWw3xl2fU-OVpuE21zP9E4rquQ,12 +onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/model.onnx,sha256=GFvqxihYvSo_9PG2IQbf-cvnA6E56Hkv_VzP1lYBuYM,120 +onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/input_0.pb,sha256=vG4b7OylZbXs1oNvJh6N2DD10wdfMSnVxkKOz7zbvwA,12 +onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/output_0.pb,sha256=p1SpO2Oa2tZ9dMA6FVWw3xl2fU-OVpuE21zP9E4rquQ,12 +onnx/backend/test/data/node/test_clip_default_int8_max/model.onnx,sha256=EtzpiOh8w6lp9tqy_kO-yRryxqohJAFuZskjyH-ctgQ,138 +onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_0.pb,sha256=rzR9S2WkPtQ_eTqlg48tVCWUU-HSMIndc3aNczLLc8I,73 +onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_1.pb,sha256=CEHeigf36q5XZtDez_5a1gT5ZJRMYNVEBF9z_OHEBEU,10 +onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/output_0.pb,sha256=tO69iQwwhb-FI6NNsgjnmVvfGzuTybog0CfmVRQ3lfY,73 +onnx/backend/test/data/node/test_clip_default_int8_max_expanded/model.onnx,sha256=h1njraDyzwOWbA8QLswnmldaGPRfHrV2lzjSi-3FFyw,311 +onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_0.pb,sha256=rzR9S2WkPtQ_eTqlg48tVCWUU-HSMIndc3aNczLLc8I,73 +onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_1.pb,sha256=CEHeigf36q5XZtDez_5a1gT5ZJRMYNVEBF9z_OHEBEU,10 +onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/output_0.pb,sha256=tO69iQwwhb-FI6NNsgjnmVvfGzuTybog0CfmVRQ3lfY,73 +onnx/backend/test/data/node/test_clip_default_int8_min/model.onnx,sha256=StI7Sylxxi_7VU7dPaKQ3MFSOkXIOuFMgIbcmZ7SVYE,136 +onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_0.pb,sha256=jlYHFzRpo9mRew7WTiCIRuEiMgtorH1Bs1r4lKBBdz8,73 +onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_1.pb,sha256=6kLq4kB4db3nFcoSmyNZk_unkHDDP5rztDpt8kwhzD4,10 +onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/output_0.pb,sha256=cxOphxSnH_muVv845xL_eqeIP1yVmxRCqmu92YISig4,73 +onnx/backend/test/data/node/test_clip_default_int8_min_expanded/model.onnx,sha256=CTaB_ZhST7UKYki3k9KcHg_d7Ov6pv2sZIo_A239SBo,309 +onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_0.pb,sha256=jlYHFzRpo9mRew7WTiCIRuEiMgtorH1Bs1r4lKBBdz8,73 +onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_1.pb,sha256=6kLq4kB4db3nFcoSmyNZk_unkHDDP5rztDpt8kwhzD4,10 +onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/output_0.pb,sha256=cxOphxSnH_muVv845xL_eqeIP1yVmxRCqmu92YISig4,73 +onnx/backend/test/data/node/test_clip_default_max/model.onnx,sha256=FL6R-HHUIBFafkhbS6htUeEGGIEAZ-1TdQJKD3gPGMI,133 +onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_0.pb,sha256=bLIkw3E_ZyNzOrq7tsNCLynmVOluwxDhZiJUPP_menI,254 +onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_1.pb,sha256=-8abKXDhQDgDtXksv1K3VkLu2XJbj3RVgko0p7nK-8o,13 +onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/output_0.pb,sha256=I04WldqbkTeeL0KpKpuo4Aw_r1J6E5FHlnYOTQjMQxU,254 +onnx/backend/test/data/node/test_clip_default_max_expanded/model.onnx,sha256=swEbjGDk9FNUHy4gDxWQSCJ5BNna0Co1PGXv9lyKzrY,296 +onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_0.pb,sha256=bLIkw3E_ZyNzOrq7tsNCLynmVOluwxDhZiJUPP_menI,254 +onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_1.pb,sha256=-8abKXDhQDgDtXksv1K3VkLu2XJbj3RVgko0p7nK-8o,13 +onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/output_0.pb,sha256=I04WldqbkTeeL0KpKpuo4Aw_r1J6E5FHlnYOTQjMQxU,254 +onnx/backend/test/data/node/test_clip_default_min/model.onnx,sha256=HXEnek_-WWBF-8Qh73uGU59Os6hZDH2x71kE2X35ZnA,131 +onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_1.pb,sha256=YN1rp1oEc2SLKQVP1qKZlBVrrUYAUCXA0Ids1IC8cVo,13 +onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/output_0.pb,sha256=SqNj4MYf1_XozMtqbVv31LmL5bj5_lZV-tOJ9tLs8Ik,254 +onnx/backend/test/data/node/test_clip_default_min_expanded/model.onnx,sha256=dqAs6KUlnP5pfOaHxVCo5kEycyWSywvoqVANWd4waEo,294 +onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_1.pb,sha256=YN1rp1oEc2SLKQVP1qKZlBVrrUYAUCXA0Ids1IC8cVo,13 +onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/output_0.pb,sha256=SqNj4MYf1_XozMtqbVv31LmL5bj5_lZV-tOJ9tLs8Ik,254 +onnx/backend/test/data/node/test_clip_example/model.onnx,sha256=jmMzre4t9LogRagPrYJD0Qk_VHljfUufDPpUJWTFj04,131 +onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_0.pb,sha256=9k-PJmwQ91koTiiJe8X4rULQA1y9P3aSpPPuUdAwT9E,21 +onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_1.pb,sha256=BRepSTg3YLUzFaeEDm7kjV41FnB7WdzkW7ynoPYkPGs,13 +onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip_example/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_example_expanded/model.onnx,sha256=eM62MADuYthk8xV0LVHcf8-wSqROjU_IgJXQlg9RGyU,578 +onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_0.pb,sha256=9k-PJmwQ91koTiiJe8X4rULQA1y9P3aSpPPuUdAwT9E,21 +onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_1.pb,sha256=BRepSTg3YLUzFaeEDm7kjV41FnB7WdzkW7ynoPYkPGs,13 +onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_expanded/model.onnx,sha256=bTXSndV3iagfSKE9Aw3psPNzl6a0l7_M_iLpujEm7n4,530 +onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_1.pb,sha256=BRepSTg3YLUzFaeEDm7kjV41FnB7WdzkW7ynoPYkPGs,13 +onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/output_0.pb,sha256=0Mj3n7O3-ghXihrxNll_6tjrgxFo27H4atMMfljBuEg,254 +onnx/backend/test/data/node/test_clip_inbounds/model.onnx,sha256=idZxS7uYmOrM7b4yKftomS-sd83XIBs8zBIZAEEWXf8,132 +onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_inbounds_expanded/model.onnx,sha256=OvcxAGIGUWSIMmNoGIUt6XJRdTRgGIvhveBRAaoM3sc,587 +onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_min_greater_than_max/model.onnx,sha256=M-JdaXe9x0Wo90DnONQGZtIiuE3uFDGc6DUq52Fuw5s,144 +onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_0.pb,sha256=JidSOIM35FeGoS9-hQTnbOJpCgSYpB8cdUGL7obby1s,21 +onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_1.pb,sha256=66G6FDOBbBk02d6eH1KObRg5NllDFh-Vr-WFCYeTQnk,13 +onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/output_0.pb,sha256=QlVZnOfM2uQ8ofEDw3HtvJK2d8eDdXfuxUupV7GKez4,21 +onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/model.onnx,sha256=KpCMKvkFtwNwtmc3Z2b_z3RaheeMr8tTuONgmf2lrgU,685 +onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_0.pb,sha256=JidSOIM35FeGoS9-hQTnbOJpCgSYpB8cdUGL7obby1s,21 +onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_1.pb,sha256=66G6FDOBbBk02d6eH1KObRg5NllDFh-Vr-WFCYeTQnk,13 +onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/output_0.pb,sha256=QlVZnOfM2uQ8ofEDw3HtvJK2d8eDdXfuxUupV7GKez4,21 +onnx/backend/test/data/node/test_clip_outbounds/model.onnx,sha256=DKK18noAKi9Btc-47_kGK2uuLsHlfmuRs-bXv1P6wh4,133 +onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_0.pb,sha256=V0F1iOI7iAm2K90hqNNItzlFwxXH3rKXm9a5wXB-qYQ,21 +onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/output_0.pb,sha256=vvqmqBIu_2d9LT3R85W2RtMis_GI5BLVrhWdaGNRMB0,21 +onnx/backend/test/data/node/test_clip_outbounds_expanded/model.onnx,sha256=lGBTvlb3SGg-7LQFxUUhPvDYorM4NudbNqk3khkv8HI,596 +onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_0.pb,sha256=V0F1iOI7iAm2K90hqNNItzlFwxXH3rKXm9a5wXB-qYQ,21 +onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/output_0.pb,sha256=vvqmqBIu_2d9LT3R85W2RtMis_GI5BLVrhWdaGNRMB0,21 +onnx/backend/test/data/node/test_clip_splitbounds/model.onnx,sha256=57xFzbLRYD7xPA_1rSX225JFx7FpBqe-TxAh0yRGutA,135 +onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_0.pb,sha256=leQohPrMDQG6Z0CCWG_wiYb4jpwYZA2BG_LvQcmbl9o,21 +onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/output_0.pb,sha256=15BzcxfrfHAuKkv7YEqCqM0o_yR1xECA5GJqzFGwo0Y,21 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/model.onnx,sha256=EfcHHaSmBKZEG32NdMfGA8XQmcxTQrCEHz1Xznl9zC0,613 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_0.pb,sha256=leQohPrMDQG6Z0CCWG_wiYb4jpwYZA2BG_LvQcmbl9o,21 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/output_0.pb,sha256=15BzcxfrfHAuKkv7YEqCqM0o_yR1xECA5GJqzFGwo0Y,21 +onnx/backend/test/data/node/test_col2im/model.onnx,sha256=IOf8vTDwhQGOtllNTnICmKiz07hm1rxWD-Nc7NNADfk,206 +onnx/backend/test/data/node/test_col2im/test_data_set_0/input_0.pb,sha256=5A3VwvCazC3A3QMIcJp8G1vvMKrc67-pH8D3QiYJxrw,117 +onnx/backend/test/data/node/test_col2im/test_data_set_0/input_1.pb,sha256=sC33YEdMBoSDhAdtQ124hhrmtKVAxoV-pDz8e6zRvRk,35 +onnx/backend/test/data/node/test_col2im/test_data_set_0/input_2.pb,sha256=dDzuXwdlcFBeNNxzJK0GQtcMTbb_H6Y32BCWnvDooDU,35 +onnx/backend/test/data/node/test_col2im/test_data_set_0/output_0.pb,sha256=xEQ2Kj9FDYM_Uu6NEhi2oPAvBijU8rklQamYJqr4AYs,120 +onnx/backend/test/data/node/test_col2im_5d/model.onnx,sha256=k-5N3_FUpbwT1QXtMqOufg0uQsJxnV4rqswqe8D-NXg,213 +onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_0.pb,sha256=10NWZ13V9CcUU08fb3zJSdT9Wn1ykGAMSmEV63jwgSc,498 +onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_1.pb,sha256=mSuKXNsMN1uBSUQ6osPvFSCLieHyPCHcY348CC0BAZ8,43 +onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_2.pb,sha256=KWWYXJvC1NdLgGh8u0n8JUmPG2N9Ykdsp9YVT_8huiE,43 +onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/output_0.pb,sha256=iEagmo2f_5o9u1f8VbWM0axVO6jVi8PqZ0Kwqew7g8M,503 +onnx/backend/test/data/node/test_col2im_dilations/model.onnx,sha256=V12TeDt8MRMS_EvbIKGg8G1SwMdC75kU_h5nk862Nww,236 +onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_0.pb,sha256=d9wmnv3b9dr2kDj10v5X5wkY0lIAaxqSoVm_FGKz2TY,97 +onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_1.pb,sha256=4GVa_GmgAg6wnfkkTNNgGTYtMDQuUT19vWfeDA_9GVw,35 +onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_2.pb,sha256=bLrs_xcBqV1BYkqqtdhN8gk07hFw_rfW0NpC3S8enAw,35 +onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/output_0.pb,sha256=jZt6LpawiR5-xTQ4emYrD7LTWpTpe3GbIbSV5oKlPo0,165 +onnx/backend/test/data/node/test_col2im_pads/model.onnx,sha256=FszV1KU3PR-9pZE7t4lltctCRUPjhT5FFIUdhGh41mo,230 +onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_0.pb,sha256=FJT7adhospTzI4VyMN70Qk2Ijori7V0uLua2eLO3wGI,318 +onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_1.pb,sha256=sC33YEdMBoSDhAdtQ124hhrmtKVAxoV-pDz8e6zRvRk,35 +onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_2.pb,sha256=dDzuXwdlcFBeNNxzJK0GQtcMTbb_H6Y32BCWnvDooDU,35 +onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/output_0.pb,sha256=Wi5m8n4bgmc9Fvl68grDeS8VTj3pkvBlVCr9wp9QjT4,120 +onnx/backend/test/data/node/test_col2im_strides/model.onnx,sha256=wdgnYE0Qeoy3xRKLMUpR4NOymjxDg9SNtvTbvEkAK3M,232 +onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_0.pb,sha256=bATQTJp-m3z-CD8kdkzPCHqEkGQCZWzeYH1luHYPsLs,162 +onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_1.pb,sha256=sC33YEdMBoSDhAdtQ124hhrmtKVAxoV-pDz8e6zRvRk,35 +onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_2.pb,sha256=zrcpb5IFLjcr6h-Ze3T0j8tMq-I7sAJZD1TULUur5Ew,35 +onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/output_0.pb,sha256=3SveaOMPddbY4IP1dOqylTuVoz7a_KyOLxB45bgvhIo,120 +onnx/backend/test/data/node/test_compress_0/model.onnx,sha256=nodKtdil0L0jbH4L5wO-v7yOu-BP0BkZlQEJDVbvvf8,169 +onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_0.pb,sha256=46laMzhSwTujxNC5wdf57VFKvfNtw0oXjGKcn85m99c,39 +onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_1.pb,sha256=jw39JH8-z2Ji3LtSHV2AWRWenNBHag9p9CIi0kH0WHs,20 +onnx/backend/test/data/node/test_compress_0/test_data_set_0/output_0.pb,sha256=REWTt5gfMJMzFJqlXfEgkPunKMIa4ztIMdbazCALGAY,32 +onnx/backend/test/data/node/test_compress_1/model.onnx,sha256=QhUJpXVhlcZ5jAmQFQY0LAvCYLZKqCpUxk7bLn-_WCM,169 +onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_0.pb,sha256=46laMzhSwTujxNC5wdf57VFKvfNtw0oXjGKcn85m99c,39 +onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_1.pb,sha256=cU3M65jPa3QTEGyHULlR-gk02IKzUg28hWixar4xdQ4,19 +onnx/backend/test/data/node/test_compress_1/test_data_set_0/output_0.pb,sha256=P-YBRUIo2dEPuIakb5wO4LXMR_mhYPCtGflcP-3B-qk,28 +onnx/backend/test/data/node/test_compress_default_axis/model.onnx,sha256=Tia1aeKj5DAQqe23y8WKMYY9LzJHn_rWX4hYA189-N4,163 +onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_0.pb,sha256=46laMzhSwTujxNC5wdf57VFKvfNtw0oXjGKcn85m99c,39 +onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_1.pb,sha256=As8vdbdiBHE5yy7e9p1d0ztqpDC8js6Dnzj3Sz7uWMU,22 +onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/output_0.pb,sha256=5m4bYUDPwIjGY_qUyTFXAxuUzstD-Vi3TTFlwkdjp7w,22 +onnx/backend/test/data/node/test_compress_negative_axis/model.onnx,sha256=qSUsJJPWf-fDfmbGlU3sG-j968n09FJ95FgTeFUhx3U,190 +onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_0.pb,sha256=46laMzhSwTujxNC5wdf57VFKvfNtw0oXjGKcn85m99c,39 +onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_1.pb,sha256=cU3M65jPa3QTEGyHULlR-gk02IKzUg28hWixar4xdQ4,19 +onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/output_0.pb,sha256=P-YBRUIo2dEPuIakb5wO4LXMR_mhYPCtGflcP-3B-qk,28 +onnx/backend/test/data/node/test_concat_1d_axis_0/model.onnx,sha256=UD4hvQQPsO5mdTW7kHiWrpisTxd-QLk_Jdn854AlV0I,161 +onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_0.pb,sha256=M_zmlmaj7q-xos1LgfEPC1kNNKTsWO4Fvr1h-Ep1zaM,22 +onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_1.pb,sha256=ALDN6Sc9t1SBGFf3S6VjvzHPLi6FM7bqSzORcQ78E3I,22 +onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/output_0.pb,sha256=vSCHzMFSvur8t7ADW1BDQbERwPltOiCd-JuPcQ6-XcQ,30 +onnx/backend/test/data/node/test_concat_1d_axis_negative_1/model.onnx,sha256=YoSMpWext44eCDoh2QV4N8J2chRPhYI2t4bjYD2n1L8,179 +onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_0.pb,sha256=M_zmlmaj7q-xos1LgfEPC1kNNKTsWO4Fvr1h-Ep1zaM,22 +onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_1.pb,sha256=ALDN6Sc9t1SBGFf3S6VjvzHPLi6FM7bqSzORcQ78E3I,22 +onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/output_0.pb,sha256=vSCHzMFSvur8t7ADW1BDQbERwPltOiCd-JuPcQ6-XcQ,30 +onnx/backend/test/data/node/test_concat_2d_axis_0/model.onnx,sha256=e2A3L9ryrB2kVlNKX4dcF1wAIQuk6eLWJgJ35yvurSM,173 +onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_0.pb,sha256=FF2sDSeoQuwLOa3kNb3bHbtcVNAifeP-yk4AM9YE9A4,32 +onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_1.pb,sha256=x9-oIRV3uL9uNyxiTOG7Q5zHYeT9DketTiY7dySqaKc,32 +onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/output_0.pb,sha256=Ta3eaIezq0mRJM1A9OsJDF7hyiipBPfqZHsahXM5SNo,48 +onnx/backend/test/data/node/test_concat_2d_axis_1/model.onnx,sha256=rFTQnBxGEZCLdelAGH1xXRLwPrJ4bgeZUFcNAtGEctM,173 +onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_0.pb,sha256=FF2sDSeoQuwLOa3kNb3bHbtcVNAifeP-yk4AM9YE9A4,32 +onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_1.pb,sha256=x9-oIRV3uL9uNyxiTOG7Q5zHYeT9DketTiY7dySqaKc,32 +onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/output_0.pb,sha256=9BvkeNloIrO5LNPMggPhy2lcCqOOU5HHPdQPj7sEfvw,48 +onnx/backend/test/data/node/test_concat_2d_axis_negative_1/model.onnx,sha256=zzVnaH5YLO-T0lWGv-Bexq56fxLAtm9JkkFyQ-0HU4U,191 +onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_0.pb,sha256=FF2sDSeoQuwLOa3kNb3bHbtcVNAifeP-yk4AM9YE9A4,32 +onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_1.pb,sha256=x9-oIRV3uL9uNyxiTOG7Q5zHYeT9DketTiY7dySqaKc,32 +onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/output_0.pb,sha256=9BvkeNloIrO5LNPMggPhy2lcCqOOU5HHPdQPj7sEfvw,48 +onnx/backend/test/data/node/test_concat_2d_axis_negative_2/model.onnx,sha256=nR004XJROokQER1gioPgrJx4lNbMRKr53nGnBj8L9EA,191 +onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_0.pb,sha256=FF2sDSeoQuwLOa3kNb3bHbtcVNAifeP-yk4AM9YE9A4,32 +onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_1.pb,sha256=x9-oIRV3uL9uNyxiTOG7Q5zHYeT9DketTiY7dySqaKc,32 +onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/output_0.pb,sha256=Ta3eaIezq0mRJM1A9OsJDF7hyiipBPfqZHsahXM5SNo,48 +onnx/backend/test/data/node/test_concat_3d_axis_0/model.onnx,sha256=LN-VZp2V3JT2FAMnwWn97NDFexgJj7xpOwyztM1GPBA,185 +onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/output_0.pb,sha256=dUvwM04_dv9m8UaqWmWl0QjkurUJSN_oRSXorZ97h2Q,82 +onnx/backend/test/data/node/test_concat_3d_axis_1/model.onnx,sha256=QLwkJrU-3hhnPEFv5-9DAukR_kvj1CGb0CtqmImkYRc,185 +onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/output_0.pb,sha256=2aOEqB0HzGWyPK-b-x4GY4_rB9VAb3Xk195r28cSNMQ,82 +onnx/backend/test/data/node/test_concat_3d_axis_2/model.onnx,sha256=WBBOjo3hw1d_0I7ErVWfYps6q03HwpcoUSGKewUFlhg,185 +onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/output_0.pb,sha256=83yvsYA4HAppNb6e1qyXLKZZOFJwpFvQkNmBQ6VXvgg,82 +onnx/backend/test/data/node/test_concat_3d_axis_negative_1/model.onnx,sha256=aywEPDxFVmIGoIi8rFzzhSfsIK5gZ8vk9CLymObB-LY,203 +onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/output_0.pb,sha256=83yvsYA4HAppNb6e1qyXLKZZOFJwpFvQkNmBQ6VXvgg,82 +onnx/backend/test/data/node/test_concat_3d_axis_negative_2/model.onnx,sha256=DzSa3Qr5LYMmo9J8lcvgq86FUEg5Wj9t5zJ31-96l4s,203 +onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/output_0.pb,sha256=2aOEqB0HzGWyPK-b-x4GY4_rB9VAb3Xk195r28cSNMQ,82 +onnx/backend/test/data/node/test_concat_3d_axis_negative_3/model.onnx,sha256=kN_yeyuEFOOXREufwa55NK5mRhj64blkAd1Zcixp3B0,203 +onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/output_0.pb,sha256=dUvwM04_dv9m8UaqWmWl0QjkurUJSN_oRSXorZ97h2Q,82 +onnx/backend/test/data/node/test_constant/model.onnx,sha256=Lewn6CuCjszXGNJcBE3WulRrA2_0OynuzC6YTnh9d5E,224 +onnx/backend/test/data/node/test_constant/test_data_set_0/output_0.pb,sha256=ZtZq7biLE0YlYjO3sb2Ior_w2EOqzpNpNMCGHbGmiVQ,116 +onnx/backend/test/data/node/test_constant_pad/model.onnx,sha256=RRkbaCUB12V7hr3i7oTfOBgjj5_eYZTXOiUEEW1Bric,186 +onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_0.pb,sha256=hFcc65NzF2jKbEvO_e8J60kUbf0yiM7kqrgc4fH_zcw,256 +onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_1.pb,sha256=ATAqLmSfBqkY7YZcsD06zkF3azvPnL7hkoPMm3R__Tc,76 +onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_2.pb,sha256=-iWKiqLhApsL8FEiLSrlvrdAGtuBlTxHvG7p-_FNqzk,15 +onnx/backend/test/data/node/test_constant_pad/test_data_set_0/output_0.pb,sha256=0e78ZdrtxNO0GEW3dObwOBqTpBycxQUoInBNVhnLm7w,1024 +onnx/backend/test/data/node/test_constant_pad_axes/model.onnx,sha256=dI7Uf_Miiihp2dGCjWUWX2XEtwmfAUHWK0benG462n4,217 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_0.pb,sha256=hFcc65NzF2jKbEvO_e8J60kUbf0yiM7kqrgc4fH_zcw,256 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_1.pb,sha256=tY8h_wDfpSXDPKmu9zOpH_G0C_JlFYFRLs84BZy2vw4,44 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_2.pb,sha256=-iWKiqLhApsL8FEiLSrlvrdAGtuBlTxHvG7p-_FNqzk,15 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_3.pb,sha256=pX9n5VloYbf2naQVDVOgUQjBFu_mcvPOWkP1mH0Fwp8,28 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/output_0.pb,sha256=32CHhoVQ_jOuUuNIFNIYKynezo6BafmF2Eyrkr2uNjE,592 +onnx/backend/test/data/node/test_constant_pad_negative_axes/model.onnx,sha256=uPI9US3xWgqt3xR7S7bqBy0Ccf2AHmSyMHjH_seBny0,226 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_0.pb,sha256=hFcc65NzF2jKbEvO_e8J60kUbf0yiM7kqrgc4fH_zcw,256 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_1.pb,sha256=tY8h_wDfpSXDPKmu9zOpH_G0C_JlFYFRLs84BZy2vw4,44 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_2.pb,sha256=-iWKiqLhApsL8FEiLSrlvrdAGtuBlTxHvG7p-_FNqzk,15 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_3.pb,sha256=jOLO9c9UDkiTUsrm1piTLJODPkSHC2uDBWr6sbTixtY,28 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/output_0.pb,sha256=32CHhoVQ_jOuUuNIFNIYKynezo6BafmF2Eyrkr2uNjE,592 +onnx/backend/test/data/node/test_constantofshape_float_ones/model.onnx,sha256=C6UwBNPkyOjRKYUx0eqGdgY1HJVx95GmgH9yKJsfiJk,156 +onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/input_0.pb,sha256=SF8xOIzH7O17I29ISO9iIIogd75Kt4opGiw4UN5z9Ig,33 +onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/output_0.pb,sha256=fM51l16xt2ADixD3tubDFSZJhvp44ltpkzuAZo1D9tg,109 +onnx/backend/test/data/node/test_constantofshape_int_shape_zero/model.onnx,sha256=wHsNHt7_4wcfuIzfJVFHP-BQMRyWFH4D2p0_uCcHO2E,148 +onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/input_0.pb,sha256=49_f6waZPNPplh_reb2omwHhFxvAn7iTR__LuEBk59Y,17 +onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/output_0.pb,sha256=0v9IGvSgdFHNbGSEn5hgWuc58i5GJAQPlXlTW3A7nQQ,9 +onnx/backend/test/data/node/test_constantofshape_int_zeros/model.onnx,sha256=HbXzZ0SApd1G4OSjj5R-K3CnIlJPWzVkYqBy49E0ZJI,147 +onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/input_0.pb,sha256=_VQY3wcZhcCAEZwbELNR-ceaJwmhW-uKL6DcRBVX2Ks,25 +onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/output_0.pb,sha256=lKYhgMCsEKm6_R6aX9y86EzA3ZggFUKai7DekgAn9rY,252 +onnx/backend/test/data/node/test_conv_with_autopad_same/model.onnx,sha256=9Js0ZuiYc4yho-OJ33if5Llvy7Nwy1a2BsSpkVW-1j0,226 +onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_0.pb,sha256=RnJVWHKql-4c51A3JiCTvFe-ry8o5bavOnIotOzZFK8,115 +onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/output_0.pb,sha256=fBuFid7X2GAEdW-WKUKklPs4CDHcf2SMq98fX9QICIQ,51 +onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/model.onnx,sha256=iRUUZA6IKo79JqiFVnsVemnRyXTGLKIxLF2k2GLjzsk,236 +onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_0.pb,sha256=EKni8PMyz3jKiEUekWtHFQJ_0vQqMDykmd7ijlyvmUk,156 +onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/output_0.pb,sha256=zWxG_I4hksIoNyVDyHd3focjwFyOzpjzxRY0lKt8hLc,47 +onnx/backend/test/data/node/test_conv_with_strides_no_padding/model.onnx,sha256=mFAavKfs5nYAd-yjlCI-rNs44bthxbpsS6yNalk6kVw,224 +onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_0.pb,sha256=EKni8PMyz3jKiEUekWtHFQJ_0vQqMDykmd7ijlyvmUk,156 +onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/output_0.pb,sha256=jpWXQcHC97bNhULIDaC1cTAxCzLIRdQDp6Uujd7Vt2M,39 +onnx/backend/test/data/node/test_conv_with_strides_padding/model.onnx,sha256=spytZkgEjKQkfWM96A6oO-mJFVfV74BjE4snhHY_WUM,221 +onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_0.pb,sha256=EKni8PMyz3jKiEUekWtHFQJ_0vQqMDykmd7ijlyvmUk,156 +onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/output_0.pb,sha256=KJnfa4Bs2wm6SwFgzBZZWQuQ3rrG5KOYY9bZH4G2toQ,63 +onnx/backend/test/data/node/test_convinteger_with_padding/model.onnx,sha256=vGi7EkiMRRbCINdliNpmWg2o7DC_9CBUDR8SyXTvAkk,268 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_0.pb,sha256=Blk9OpAbYayI22rinL6HBBpGT7VxJcAbgYpPMNlfDLs,24 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_1.pb,sha256=Ke5KLrXr8cu_gO8LL96SPkiEEloBs0SXZ6It9TUOwMA,23 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_2.pb,sha256=ZeQpztgb7wGWXMWNAGDKbvP-wyc-Toe88voMPU1aWKI,19 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_3.pb,sha256=wlwRtEJHFOuW6BggyTmNAOYFr0OweEo9ysgr6F7aOdI,23 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/output_0.pb,sha256=kf0FAamxR0-lp5QPfIrRXMIuBSIvkuJSs73xWOHISRc,144 +onnx/backend/test/data/node/test_convinteger_without_padding/model.onnx,sha256=3f-BSu8df7zOqub8da6dejeGah2S4HCeiwgKcb_4W6s,208 +onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_0.pb,sha256=Blk9OpAbYayI22rinL6HBBpGT7VxJcAbgYpPMNlfDLs,24 +onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_1.pb,sha256=6DoOKAFFqEvwzMlQqPnfz-Y99DBZgq3zfgSBJrrG-1c,19 +onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_2.pb,sha256=ZeQpztgb7wGWXMWNAGDKbvP-wyc-Toe88voMPU1aWKI,19 +onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/output_0.pb,sha256=yXCRQ-429TJ61mZfgaxJtnt0Zp5_EEQzBLY_Dmf0on4,31 +onnx/backend/test/data/node/test_convtranspose/model.onnx,sha256=xSD9z5KN478wJdZzsqwMO11NN2qYqljDbRmToB1QXB4,158 +onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose/test_data_set_0/output_0.pb,sha256=HneG-T3MmfaylD4KMxnOwosFJxoRtZraGOg0lU_Hsc8,216 +onnx/backend/test/data/node/test_convtranspose_1d/model.onnx,sha256=nVX3od7tu6l2d5dq3CG0aR-Bl4Z2Y-xWEe4PoGdOGqE,148 +onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_0.pb,sha256=DugdB8mDd8zLjys9Gz6guoROF5WniAbCMOYxTsRL2yY,25 +onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_1.pb,sha256=vqReEteH3D9QNgAwAcubV7ohKew3T-tgB6LOqwzNZYQ,37 +onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/output_0.pb,sha256=m82EQ2cpDznkgM3kvHq8Zg7BXP7GHlUqqHAeLFknzNA,53 +onnx/backend/test/data/node/test_convtranspose_3d/model.onnx,sha256=PSGNabwin_uLUbXUfGw9yOYydzBw5OiJbWxfppYQwxY,173 +onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_0.pb,sha256=yzJg-6Mo6S_Ii0J_O6ARrRuJRKm2GYYzSfoKJBTl1Tw,258 +onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_1.pb,sha256=bJ7b_MaU60hfPdSePVI_fuAX-u2abWHoX3JjQuEshOw,234 +onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/output_0.pb,sha256=Ko5haeAPyeETXCurwHh_K-3n6hM4JTBkT8074b05hGc,1698 +onnx/backend/test/data/node/test_convtranspose_autopad_same/model.onnx,sha256=lwNPZ3xHok5oMx66K1NVOOVR-eXYXyWpnFCK0bn__n0,216 +onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/output_0.pb,sha256=mz9atUy2Vn7Nr6d5zIB8psRUkJh1hDQTt__CSBYXiA4,304 +onnx/backend/test/data/node/test_convtranspose_dilations/model.onnx,sha256=9JWWVoF8rJ7SqiI57pkJGEpLBbsMK7AsTH1ksePYa3I,188 +onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_0.pb,sha256=bzWXnz5LvVN9kq3fKc3EYBxkwZ6KmN1FMR5y-0duD9E,51 +onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_1.pb,sha256=4MwrDO_hTzR2PV0ke-Q-ESpzROSmpcoPTLu20GNZ2oc,31 +onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/output_0.pb,sha256=SU_6_ceIvxcyEkY5cIaxfpxFOO7o08pElgWQJXtUQao,115 +onnx/backend/test/data/node/test_convtranspose_group_2/model.onnx,sha256=EPKzIYcHKpLDl62bO8OjVGe_S1FyBV6FSFrOJt91-SQ,180 +onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/input_0.pb,sha256=G30jsUS6rVfTA8k5fM2JiuG3W3A0gKV9OcoosNjfPKw,87 +onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/input_1.pb,sha256=G7pG7jolUNswciH4QXyNZbGbg8Yda7ljgWCuockH1gk,87 +onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/output_0.pb,sha256=6TiKaHRlFEqf0uWQs2bZYKT2dO3DgGtYYa6P9HyqqQI,216 +onnx/backend/test/data/node/test_convtranspose_group_2_image_3/model.onnx,sha256=kElh0pmG8n8vN7HjVJPN555nUjxUZx4bPwHBzy9NAes,188 +onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/input_0.pb,sha256=JS9S2CoGz1YnT5OfGjHiP9KCR1LyRv4CQwqdr98lRkQ,232 +onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/input_1.pb,sha256=G7pG7jolUNswciH4QXyNZbGbg8Yda7ljgWCuockH1gk,87 +onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/output_0.pb,sha256=aA10G9PGpNQ9Vbwhwc_46V_KJ3akz1o4F0QOHJ0M3k4,616 +onnx/backend/test/data/node/test_convtranspose_kernel_shape/model.onnx,sha256=nNTOqYUoW1sTcFX7H2CcMMVwnAChVyCHOAshuRUkAnI,266 +onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/output_0.pb,sha256=cNpj1cm-VSGhzBRQ9cssIsBnwZsZIiYwXeSfSRj7hM4,656 +onnx/backend/test/data/node/test_convtranspose_output_shape/model.onnx,sha256=eC8XZAw7z8aaLTbPU7hVB8QXGjnpxdMZGLgmUYxHbbY,212 +onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/output_0.pb,sha256=cNpj1cm-VSGhzBRQ9cssIsBnwZsZIiYwXeSfSRj7hM4,656 +onnx/backend/test/data/node/test_convtranspose_pad/model.onnx,sha256=LEUEXq7JYqS3CShkC2SEX0NSUlmsQXzTUEJQt5Z6JbE,205 +onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/output_0.pb,sha256=cNpj1cm-VSGhzBRQ9cssIsBnwZsZIiYwXeSfSRj7hM4,656 +onnx/backend/test/data/node/test_convtranspose_pads/model.onnx,sha256=mRQMemYg0icq-SUR3MlWqmFczEd8w0ZAp5ImLDWDUQ8,200 +onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/output_0.pb,sha256=shm1OKRrwwW7T6skwkeDpmN7KA1v3qUgB75cH9Dl8qc,184 +onnx/backend/test/data/node/test_cos/model.onnx,sha256=asUay0c5pk9ArPvAvK64l8uLg26Y64bgJazPA9Abht4,97 +onnx/backend/test/data/node/test_cos/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_cos/test_data_set_0/output_0.pb,sha256=xwExE7n32GQjc8I4MyAWZBOXoLeSnXllZfK9b67amvY,254 +onnx/backend/test/data/node/test_cos_example/model.onnx,sha256=t9SWrlzkams1t_gvyomcpOCT6QY-QrViwTT-LE-4NF0,89 +onnx/backend/test/data/node/test_cos_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_cos_example/test_data_set_0/output_0.pb,sha256=F4c54AgTxALn0fDkECFlprJnqpteSyq28Lwua7w37OY,21 +onnx/backend/test/data/node/test_cosh/model.onnx,sha256=CK6oJ_7ET9C43z9SLtOvd1opBzd9Q5Yl13SRwfTpUpI,99 +onnx/backend/test/data/node/test_cosh/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_cosh/test_data_set_0/output_0.pb,sha256=XnUVCOBvze089QqE65mHTGO0qrKRGEJIBPgzrQOJHYs,254 +onnx/backend/test/data/node/test_cosh_example/model.onnx,sha256=-JCUd6KhlYxKlwjSCNk2ad0IR-Rllzo7HYqGJdE0OZ0,91 +onnx/backend/test/data/node/test_cosh_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_cosh_example/test_data_set_0/output_0.pb,sha256=5zBfI_66Bj-xHkKeQjU7ExsAzYQ3svYlk2gScUs37_s,21 +onnx/backend/test/data/node/test_cumprod_1d/model.onnx,sha256=OGisBcMG8vy7uzeM3aqLf_SvuYXMog2WGKqJqbOpeQg,114 +onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/output_0.pb,sha256=BOHH0xTKcMzeXr5tjeS09DH1KX2nM14jB8eGsgAGeyM,49 +onnx/backend/test/data/node/test_cumprod_1d_exclusive/model.onnx,sha256=cL803RPrW1cKFUs2zQ-vLQ5Owkg1LKZEUdVGYyJtMCs,142 +onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/output_0.pb,sha256=xpYtK_EPgiOVsV4MkCO5md7VAdMDYnMDtW-A4nHkmHA,49 +onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/model.onnx,sha256=CfBun34YHrv4-oD73tQP6re_zjeQzd5-KbCvfpt8Xo8,148 +onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/input_0.pb,sha256=TOBmtdtOaih-9-vU0f9fuIW7XJw7vE5p7kp-4yOPa9M,29 +onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/output_0.pb,sha256=phygkt8QuiG8z5wBtwR_tJ79iWf8uO7aYXWctOxzkxI,29 +onnx/backend/test/data/node/test_cumprod_1d_reverse/model.onnx,sha256=hPC6_D00XoxPYYhSSuNHh3_nVTTLJimIRTVG96_z4Qs,138 +onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/output_0.pb,sha256=ki3Sl27HZWSiTaQ6U5yqVUyLWgXBccxZ8CeV6Nq7hgY,49 +onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/model.onnx,sha256=GdRb8zOarqPdDokoOclNcm0cYhcwt83a171Aitx8L0o,167 +onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/output_0.pb,sha256=PfLngIUGM8WuMkwUEcL8n3AfeAeIMTsk2fWYoiSr3iI,49 +onnx/backend/test/data/node/test_cumprod_2d_axis_0/model.onnx,sha256=BMfdAQ_spBjNhsY35XGB3Q6TTPKUvErJ_bjZzVNJKDc,129 +onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/output_0.pb,sha256=Ui1fk8wWemLr0CzlUueBfz62YaIqe0azD84f7UL1NU8,59 +onnx/backend/test/data/node/test_cumprod_2d_axis_1/model.onnx,sha256=1eVQOWytdViflVOQ_SbjMai3ty50GBk_h0UBzoCNYAM,129 +onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/input_1.pb,sha256=NMmvV9Gd72jAqm4CVKvPfg5tsoTU35TpnJO8I3QgmOM,14 +onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/output_0.pb,sha256=QWRLQfBrnF1rgCOZl8OZQRRRUqVNS0sVMHLT6YxlUzw,59 +onnx/backend/test/data/node/test_cumprod_2d_int32/model.onnx,sha256=arNTXBPi529lCBO3XjfuwaMtIUBNdkRpzgqVFN9vfdE,128 +onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/input_0.pb,sha256=A4YkdLfEkkZrHbzsU3n_Mbw5LZtXJxCCt-iw-kFxbsE,35 +onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/output_0.pb,sha256=t-osOSWq9Uq18_XYBnOF33s7xCtNhaU7iaerAW5tXCM,35 +onnx/backend/test/data/node/test_cumprod_2d_negative_axis/model.onnx,sha256=oowaqSOvehIN8MdSScrzzj-KsmDNgy-8ij0g0M9gWns,136 +onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/input_1.pb,sha256=VFp0AgVnZO0DGSm4jbAffIBQgezMSIif_MjDWojRRFQ,14 +onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/output_0.pb,sha256=QWRLQfBrnF1rgCOZl8OZQRRRUqVNS0sVMHLT6YxlUzw,59 +onnx/backend/test/data/node/test_cumsum_1d/model.onnx,sha256=a0-USQspl-Y7FCLaopAcOcXl8YJMSHZdoJVuiabnwxc,112 +onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/output_0.pb,sha256=8u6a-CH_s8CSSeDu2Xkey9IkVrCxfGeK1zruGN-GBZ0,49 +onnx/backend/test/data/node/test_cumsum_1d_exclusive/model.onnx,sha256=8roorRSX_UmgltqXKhlqq700efdCxQvgbtUQp_pXdBk,140 +onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/output_0.pb,sha256=KxZYZON3hTdtJo13FySOB4-9VcLllUPVPRiYl6J5jKc,49 +onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/model.onnx,sha256=BL07IsN1fS7fPeeGnu4I-MDfmypfap3ijZXKyeMUFIU,146 +onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/input_0.pb,sha256=TOBmtdtOaih-9-vU0f9fuIW7XJw7vE5p7kp-4yOPa9M,29 +onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/output_0.pb,sha256=5QDiCRgvEnxi40EKZwlFEZvjs37VI1NBTq5e4xUw8bc,29 +onnx/backend/test/data/node/test_cumsum_1d_reverse/model.onnx,sha256=GJVic393uVQwWZIITwyUiXJEdeE31PCfaREaa0V47rs,136 +onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/output_0.pb,sha256=Qx9JC5x68xbCSGlmcVAfxcPWBfRq4XWTKX9vcU4v7lM,49 +onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/model.onnx,sha256=Hx4GBa3gVcU6OeG4waFSxEAa7r_VvPZDa4C4HLv6Bno,165 +onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/output_0.pb,sha256=WQ4WtDbRG6kYBvqYrMr2Tqz1nyUugHKzXw6_kIKreGU,49 +onnx/backend/test/data/node/test_cumsum_2d_axis_0/model.onnx,sha256=RKckuBZhpqglL2dviFPjshMDeazp7lc4RovX29mqtpw,127 +onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/output_0.pb,sha256=uIQ9aM_YHV83ShrV9fZREjUB_1AzsmlyFmksuyGpvQo,59 +onnx/backend/test/data/node/test_cumsum_2d_axis_1/model.onnx,sha256=kLauNIYFM7TmL27su7h41eon9EoCo_hIDgFo2prXd3Y,127 +onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_1.pb,sha256=NMmvV9Gd72jAqm4CVKvPfg5tsoTU35TpnJO8I3QgmOM,14 +onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/output_0.pb,sha256=fjOhNqyyw_q9RM3Q_tHH-zo5LyuiIIPlnwg_ikn-G1o,59 +onnx/backend/test/data/node/test_cumsum_2d_int32/model.onnx,sha256=qFahSS_s6S3RdHtUEhaMo6z6VYZo3NLaGcBbzGJ0RI0,126 +onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/input_0.pb,sha256=A4YkdLfEkkZrHbzsU3n_Mbw5LZtXJxCCt-iw-kFxbsE,35 +onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/output_0.pb,sha256=QmL74JO2YULHPWeVJvQbvbcJi_IibxrloOqJ9hMBchw,35 +onnx/backend/test/data/node/test_cumsum_2d_negative_axis/model.onnx,sha256=PzI6naK8X5kO2jZohlXfYB8Y8Iu7veFMLxVIGThBJ0Q,134 +onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_1.pb,sha256=VFp0AgVnZO0DGSm4jbAffIBQgezMSIif_MjDWojRRFQ,14 +onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/output_0.pb,sha256=fjOhNqyyw_q9RM3Q_tHH-zo5LyuiIIPlnwg_ikn-G1o,59 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/model.onnx,sha256=3F-qQcZszJzimJiYf8gkL4r51GdgpCeLN6xy3JWtxLM,310 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_1.pb,sha256=4Ki_u3n_9JzedrVVClMoOCDVY7aP6BJSo_YgoX_n3EM,31 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_2.pb,sha256=EhURFxsdfyOamsaS1dDwOw3rNpUzQFR_rV_PiCUXGgQ,149 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_3.pb,sha256=bWxbblK-zibXhuqJnlYY76Q-CMwp2JIBxYU-OSpIJlg,13 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_4.pb,sha256=aAzeB402zdR1RgnF4bwrRmCAJqeefsffEwh6adi3hFE,82 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/output_0.pb,sha256=QDXvxD5as96MNzcX4VyrYjfyUVh70ERSgZWsbhUYAXc,31 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/model.onnx,sha256=EmlFUnt4bD2TTF_cfcaO2f0qglqjwEbv15j6D_A4eqU,286 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_0.pb,sha256=mz70lzdE3dV9eCVSeVw1IPD0yxzuvQww2K-IygMsQ8U,87 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_1.pb,sha256=owMofin1vCKYHIHkslh4bPVinD0BZTgNyltN7xiGjjY,47 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_2.pb,sha256=GZrP3XBGQvMlDDHBU10iOG6UcGOI8RsMTWFJPM1XXhc,277 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/output_0.pb,sha256=1GKwquiq34PG-gdNzkcEMTVkLLXkM1fDY3jlkYLS1do,31 +onnx/backend/test/data/node/test_depthtospace_crd_mode_example/model.onnx,sha256=NKPEJg_MCvJ1JpqkMeaVOv8i6mDopHCUnypY29SNBJc,175 +onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/input_0.pb,sha256=RgEVxMZP6lyZL5iCrvplZ59lKVjVOqOK6HbeXaJvtBg,208 +onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/output_0.pb,sha256=jcnCB1p-6U2LnnzjM5JZTSv-wLkadP8R8T7xDtBZf2M,208 +onnx/backend/test/data/node/test_depthtospace_example/model.onnx,sha256=aMvte-8S8rfH8edeajpPdRSDpxRnhjv9Pvf_KOwbFdk,166 +onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/input_0.pb,sha256=RgEVxMZP6lyZL5iCrvplZ59lKVjVOqOK6HbeXaJvtBg,208 +onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/output_0.pb,sha256=XZsnoNSiBEpeUw5duLl02ij6y-CLa75VFwa6fK9CW-U,208 +onnx/backend/test/data/node/test_dequantizelinear/model.onnx,sha256=OELm-sG0jiUQpfv9RKgy1blnx-zthqW1mB6cf4f-eeI,174 +onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_0.pb,sha256=EmysV2w6e9A4gkikFxjf-h5DEDE-xLzeoN7oYeCQE04,13 +onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_2.pb,sha256=lFnABk3b12PAd-w6LAhH1aQBJ4jE7GVjHeT6rBlLPHQ,19 +onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/output_0.pb,sha256=PY_Zk5COHTEuddMpyFjKHFk5E6u4xQQEXMiAU2kHfd8,25 +onnx/backend/test/data/node/test_dequantizelinear_axis/model.onnx,sha256=YEb-_H2pYjwso7HpTfMrbEH5QGkM8fq5eCw2nsOm2ws,211 +onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_0.pb,sha256=F1clPA2jDiRJvIkJOrVW4-uWrMCe3ci36ERppwWeFr0,33 +onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_1.pb,sha256=8153V3qlOWYhYmsbcUqVSI4UZKUMFAC9iONtVWruuDI,27 +onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_2.pb,sha256=AX9gtY0YGg4meweG0-gBYu8fbZQMaFj-4ePD0AVE23U,23 +onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/output_0.pb,sha256=clTyPPD3CizDRWpK3EKw1PsOobgue1JHzKmFMlVf8XA,87 +onnx/backend/test/data/node/test_dequantizelinear_blocked/model.onnx,sha256=COtkRKxKGGm6bJgi69tB6UzK8nR-4FD3GwB_8cwAhUg,270 +onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_0.pb,sha256=ZxzPl8EUGTeLzCv52dlK4HFE-3oOw00s84dsg2InQYk,39 +onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_1.pb,sha256=NYzPvsHJckD9ggSfHu3zCfSuydIK4yWlJ4G9yaO0Tzs,69 +onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_2.pb,sha256=mo5zdy6QWdX0GdSEWMTVpD4XzPbTC51Z-AklKdIcfmw,38 +onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/output_0.pb,sha256=aBoBdmpRQFaYR0_h7OkQmHQmgr4-A7HoNa28QLdbvW0,111 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/model.onnx,sha256=I6ZhT2ftuXmLDbogwEC2XzdOnxjtrauhFJzd0SLsrE8,156 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_0.pb,sha256=ouNewVo-woBhiPhPqys2tzIXPZTj1jRxBMX8D4ENTOY,15 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/output_0.pb,sha256=HoScRA1An9eM-pF3W0B6jeMjkwVrEBJSFFqrSI8JPgY,29 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/model.onnx,sha256=OWiwgphMu7VyqiHszzpJ1i5z5fOUW5IdkxbYBQRs28g,164 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/input_0.pb,sha256=ouNewVo-woBhiPhPqys2tzIXPZTj1jRxBMX8D4ENTOY,15 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/input_1.pb,sha256=60dxb5sNyankjSpTaguNhgOa3MiKy1KQMQNSDbmOr6Q,15 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/output_0.pb,sha256=Vri-LRqOSx9Zy_Sh00jBhW36uqkowDRmKj75DDCxvp0,19 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/model.onnx,sha256=sCDsWLqwv1qjo7uMiq8mabAGw4hy3lElxAhJcWjYirI,205 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_0.pb,sha256=ouNewVo-woBhiPhPqys2tzIXPZTj1jRxBMX8D4ENTOY,15 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_2.pb,sha256=3qDZIcWHdcD6sR2bi0d9zxwFMbgB-8xVA8QC78gP0h4,19 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/output_0.pb,sha256=HoScRA1An9eM-pF3W0B6jeMjkwVrEBJSFFqrSI8JPgY,29 +onnx/backend/test/data/node/test_dequantizelinear_e5m2/model.onnx,sha256=jHAOK0sBCwJiPaWjqbu_I8yCfVRu5ZJG3jiNDpfV_KM,154 +onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_0.pb,sha256=yw3eIa6_XeFddym2QAP7S_IfKNNy-bUYwPABatQogxU,15 +onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/output_0.pb,sha256=rowj1Mm8ky6Puzl1Gvwlb8okeNXIqZKLe_Y3L6K-xyY,29 +onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/model.onnx,sha256=RXsra9z4iOSXQ2dFAp9QE6JpbiDVmaSzhhCYTkhYHRU,202 +onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_0.pb,sha256=hfKWK6hYjYTEXIMj5jhc4S-MGpD0emGDLHBqoRcMrNo,12 +onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_2.pb,sha256=9ObzrEPlg918P132HUu0BGqlBJSlkjiSs8NsDblEYmE,21 +onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/output_0.pb,sha256=DcpbqTOhv9IcnDveQ4fa0idfGkkTg6RZnq9ECLf2dbE,29 +onnx/backend/test/data/node/test_dequantizelinear_int16/model.onnx,sha256=PFpI3JA_l0N3Oj82njKf_leLOVNzS2wLL3AjqOGNOJ8,180 +onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_0.pb,sha256=5kwTISfoYEY-gS6vbfkx0YG9bb_QT9eLgZ2nWJgUSks,17 +onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_2.pb,sha256=aA9bTmWOD6-LSfDuU18yhKzxxLN8k7baAz0o2RU2Tjk,20 +onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/output_0.pb,sha256=4CMGzWoZPL0Pe6ra48nb6IyJcJ5pPIn8egmX-CisQr0,25 +onnx/backend/test/data/node/test_dequantizelinear_int2/model.onnx,sha256=2ZrjIwWj82rFu9uXlntuAZUuTUQX6d694f3iZetDJCE,196 +onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_0.pb,sha256=s6zQDJDctYkv_-YGuEfoQW8F1QO4NT2zYXWWXDv_fBw,11 +onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_2.pb,sha256=y89M2oPyIF10VT-HeYSz3gCZma1rpQ2OdBJ38TV8Nmc,21 +onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/output_0.pb,sha256=RhhnxRPOygJ93RBV-DrJXB_5hHhv3UDchFU0qtj8zQk,25 +onnx/backend/test/data/node/test_dequantizelinear_int4/model.onnx,sha256=NQnsKhOk-7SbFF_0q5mtiIRQhwowqeUBOzO1w5LtFlA,196 +onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_0.pb,sha256=EDNr4ycFlbxGUjRuQUWI2h8YZMW3K5-MZAmYCNBGKPY,13 +onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_2.pb,sha256=GxHG9IjbNdY0hTEZRYeNssvlZnFbX4ouLHJww6ODDzg,21 +onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/output_0.pb,sha256=AB-QMRL0DZclEXLlbWVi-ti0NMUhxGgqeAKzRFgL-rM,29 +onnx/backend/test/data/node/test_dequantizelinear_uint16/model.onnx,sha256=DyVvlkdq4gi6tIyBc7uJgta0vb_3CAc6oJYYApfLFjo,181 +onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_0.pb,sha256=lXtHv2NCkXFokLmUC4XcHZ0KObiQXiRreUIK-COCeLU,17 +onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_2.pb,sha256=YQZmuOZhu1-ia2hm8uiNP_tZt4UzyU2zqiQqwD1rXTQ,20 +onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/output_0.pb,sha256=1DaudDf_dFSb6ER64wWqnX0fuF09V-qLVWFygx4LlMM,25 +onnx/backend/test/data/node/test_dequantizelinear_uint2/model.onnx,sha256=DsLNW6ZJKF3IJsCshxAJIBcwXDUthsDXg-zQvXfgrjY,197 +onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_0.pb,sha256=-h7VoNIxeWWrI-nyrCuTj-WgtgaZvmO8sCVnP-YdDMQ,11 +onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_2.pb,sha256=dPutS9DMTMElqU5Ax5xHv7v0gGS9xQwZ8mDdEKpFtWI,21 +onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/output_0.pb,sha256=y0Xp2iBMu9Ui8xkjZuyJq3oLoqPsCI0eiw10XKkUrCU,25 +onnx/backend/test/data/node/test_dequantizelinear_uint4/model.onnx,sha256=11fQvif3JcWFVKMJU5xShR0PZlhi4J9wna_ocjpdpqQ,197 +onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_0.pb,sha256=DujJO55o1k-7hYjfqgLjHUHvFWS9ME3xYq410pSWAPk,13 +onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_2.pb,sha256=Uy6DIdWiaShjYZoqvhZytFOW-nrnkq_jDxhSya5GM1Q,21 +onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/output_0.pb,sha256=xQMWX_7whFxNBSm64slp3ncuglAEdprKtaQD0zkjTqI,29 +onnx/backend/test/data/node/test_det_2d/model.onnx,sha256=QvnRggorO_u7XPIpq9MtOSbIvjek7ASSQ4Hqh9YYgFw,84 +onnx/backend/test/data/node/test_det_2d/test_data_set_0/input_0.pb,sha256=0phUVbSY99aYNDvbb4I7ZwTF4_oqB7I9Teh_3LZTlfk,27 +onnx/backend/test/data/node/test_det_2d/test_data_set_0/output_0.pb,sha256=b25eApoGtGI7BEKuAIjKZCC5IY5G7F_xvMlh9QxE7Og,11 +onnx/backend/test/data/node/test_det_nd/model.onnx,sha256=iH2c0VvJ1gZTq0vTtJ51ILr_oHPSw6mGGqhIrdPo7eU,92 +onnx/backend/test/data/node/test_det_nd/test_data_set_0/input_0.pb,sha256=8YluWZgsAsrlB4CYnJbRuf7gscfo9QKQNTqVdfYttvE,61 +onnx/backend/test/data/node/test_det_nd/test_data_set_0/output_0.pb,sha256=4i7Hs35s1K_MXnQ7ljAM-dfHG1YeQVsSls_jDMSmxWM,21 +onnx/backend/test/data/node/test_dft/model.onnx,sha256=OC6v3RTWTdS5XFaZLtKboBg60uglHMkzqrGkcynDPQI,129 +onnx/backend/test/data/node/test_dft/test_data_set_0/input_0.pb,sha256=BIHO98lzVkUyYknuhq6si9MRulBqSgXJNCwPwn7ZzUA,416 +onnx/backend/test/data/node/test_dft/test_data_set_0/input_1.pb,sha256=9FhB30n-ceweWvV552dURW3S3pEzQl90sx9pYsJ2W_A,18 +onnx/backend/test/data/node/test_dft/test_data_set_0/output_0.pb,sha256=qMRu6BAT3ZyFlXAyGLhHtfWEhKkvUzjqVD6ET3t4W-0,816 +onnx/backend/test/data/node/test_dft_axis/model.onnx,sha256=CSEAyMihmvsyCVdRYs9_bCr_sBrREnWkj6coDhVhKKE,134 +onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_0.pb,sha256=BIHO98lzVkUyYknuhq6si9MRulBqSgXJNCwPwn7ZzUA,416 +onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_1.pb,sha256=_08JRy_4qCwnWW9gzVVqB_WYpllZrQZTWfv4xG3HQ3k,18 +onnx/backend/test/data/node/test_dft_axis/test_data_set_0/output_0.pb,sha256=XhuF_YTUsH2U8zQ_t-RXnfgnjAppTYyOPYc2VsbxeWQ,816 +onnx/backend/test/data/node/test_dft_axis_opset19/model.onnx,sha256=E-3UD4-UxE1w1WHlKsCkc8T__PsmV07nOQrd3Gkhi1M,131 +onnx/backend/test/data/node/test_dft_axis_opset19/test_data_set_0/input_0.pb,sha256=BIHO98lzVkUyYknuhq6si9MRulBqSgXJNCwPwn7ZzUA,416 +onnx/backend/test/data/node/test_dft_axis_opset19/test_data_set_0/output_0.pb,sha256=XhuF_YTUsH2U8zQ_t-RXnfgnjAppTYyOPYc2VsbxeWQ,816 +onnx/backend/test/data/node/test_dft_inverse/model.onnx,sha256=hwvNFltz3x9Zkrk4j-Y-vjVp1WPTHFH364LBTtqFa8s,154 +onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_0.pb,sha256=7PtwIwLGEO0OFI_rXNZqOmtnlBQExbdZcxeeOFm4aug,816 +onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_1.pb,sha256=9FhB30n-ceweWvV552dURW3S3pEzQl90sx9pYsJ2W_A,18 +onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/output_0.pb,sha256=vUxIxBJGmthipsKMYXs6TVhYrPjedeN_Ze9bc0_mnBs,816 +onnx/backend/test/data/node/test_dft_inverse_opset19/model.onnx,sha256=H4smfc3KYTCDYTcvLjTJTAHl_YExtNaAyXYmR1ip5cw,150 +onnx/backend/test/data/node/test_dft_inverse_opset19/test_data_set_0/input_0.pb,sha256=7PtwIwLGEO0OFI_rXNZqOmtnlBQExbdZcxeeOFm4aug,816 +onnx/backend/test/data/node/test_dft_inverse_opset19/test_data_set_0/output_0.pb,sha256=vUxIxBJGmthipsKMYXs6TVhYrPjedeN_Ze9bc0_mnBs,816 +onnx/backend/test/data/node/test_dft_irfft/model.onnx,sha256=IFqLcmZzCDJ95aA0sUX9I03xa5nI8TN7A-njRnsiKJQ,169 +onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/input_0.pb,sha256=DV2qlJucuq_dVAjp-LpPFbLiGvDK7UHWRGhDXTeDHaI,496 +onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/input_1.pb,sha256=9FhB30n-ceweWvV552dURW3S3pEzQl90sx9pYsJ2W_A,18 +onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/output_0.pb,sha256=dNP_piNES_VJv-ta3eKr9Nl3SKUMtfG81yCWFWHECJ8,416 +onnx/backend/test/data/node/test_dft_irfft_opset19/model.onnx,sha256=n73YZAzzOQcjhZk1ZUvP0y73vhidBH3H--1luh4Wauc,166 +onnx/backend/test/data/node/test_dft_irfft_opset19/test_data_set_0/input_0.pb,sha256=DV2qlJucuq_dVAjp-LpPFbLiGvDK7UHWRGhDXTeDHaI,496 +onnx/backend/test/data/node/test_dft_irfft_opset19/test_data_set_0/output_0.pb,sha256=dNP_piNES_VJv-ta3eKr9Nl3SKUMtfG81yCWFWHECJ8,416 +onnx/backend/test/data/node/test_dft_opset19/model.onnx,sha256=8Ifb5vDjFlWzj_I7Om2zdm5hnfFfb5HlZz6c2vm0uRc,126 +onnx/backend/test/data/node/test_dft_opset19/test_data_set_0/input_0.pb,sha256=BIHO98lzVkUyYknuhq6si9MRulBqSgXJNCwPwn7ZzUA,416 +onnx/backend/test/data/node/test_dft_opset19/test_data_set_0/output_0.pb,sha256=qMRu6BAT3ZyFlXAyGLhHtfWEhKkvUzjqVD6ET3t4W-0,816 +onnx/backend/test/data/node/test_dft_rfft/model.onnx,sha256=Qw63FyltnUN3FO7SK3pcmlvsdGZNvbuiAEWMjD8Vvu0,151 +onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/input_0.pb,sha256=BIHO98lzVkUyYknuhq6si9MRulBqSgXJNCwPwn7ZzUA,416 +onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/input_1.pb,sha256=9FhB30n-ceweWvV552dURW3S3pEzQl90sx9pYsJ2W_A,18 +onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/output_0.pb,sha256=0PcLB5mpkvKVR_HyS2J0ljfkO70O7uagYmggVMxy5lc,496 +onnx/backend/test/data/node/test_dft_rfft_opset19/model.onnx,sha256=Ga7Rm95sfGMYnilpGsXvWG10fZmGkzy_tOwAQkG6pJk,148 +onnx/backend/test/data/node/test_dft_rfft_opset19/test_data_set_0/input_0.pb,sha256=BIHO98lzVkUyYknuhq6si9MRulBqSgXJNCwPwn7ZzUA,416 +onnx/backend/test/data/node/test_dft_rfft_opset19/test_data_set_0/output_0.pb,sha256=0PcLB5mpkvKVR_HyS2J0ljfkO70O7uagYmggVMxy5lc,496 +onnx/backend/test/data/node/test_div/model.onnx,sha256=BC7Wj-nywr5jTxV_jbCcDkgEkPD_yoQ7KQRk5zTinKs,125 +onnx/backend/test/data/node/test_div/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_div/test_data_set_0/input_1.pb,sha256=EdnSdDX16HmReb_YAemagUKjdzJfVyWKaqThtG0XUdo,254 +onnx/backend/test/data/node/test_div/test_data_set_0/output_0.pb,sha256=oDeGZ2kWqr-qxEt70OvpI9yKHxxk-U0_Fd5toUxgNO0,254 +onnx/backend/test/data/node/test_div_bcast/model.onnx,sha256=m0B1sh2gk5LB6GaJ3ncV0reTkUkWdxBk3TafRd8MPW8,123 +onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_1.pb,sha256=MqH-1RsmHArvXfx7K35Qp2E8yr83igIRnQTj67suDHA,29 +onnx/backend/test/data/node/test_div_bcast/test_data_set_0/output_0.pb,sha256=2yycZqpnMyKEloUowJhkwXjK-IE9yPRd1T7TWPBxvvk,254 +onnx/backend/test/data/node/test_div_example/model.onnx,sha256=-V4U6W3JAnNtGcoXj-90cNrefeLcd1WzODbJxSLNCLo,109 +onnx/backend/test/data/node/test_div_example/test_data_set_0/input_0.pb,sha256=5m2PEEsKXQbJNrLR6JC_nvLRZCEVZ89U3jSEZ7Zcn2g,17 +onnx/backend/test/data/node/test_div_example/test_data_set_0/input_1.pb,sha256=UpYzYhBYwWnWsKo320h6NtTBuKOsfvvObUYElou6U1Y,17 +onnx/backend/test/data/node/test_div_example/test_data_set_0/output_0.pb,sha256=F-A7vcHWnvj2qwZVhcZLvB4sACk6jmYJEidt7RNhvcE,17 +onnx/backend/test/data/node/test_div_int16/model.onnx,sha256=J6D0n-BNdYzjvynAahXWCNPFY1PlO4fytMANLZiIEus,131 +onnx/backend/test/data/node/test_div_int16/test_data_set_0/input_0.pb,sha256=o-NT_C7786CzrLp_9P4Xl-Ku1kZ5_D7nQ4zaf7KTauc,133 +onnx/backend/test/data/node/test_div_int16/test_data_set_0/input_1.pb,sha256=xzTCArxxZo7BEhbKbG9UfjtNPyQJzF_K5uZenBnE7aM,133 +onnx/backend/test/data/node/test_div_int16/test_data_set_0/output_0.pb,sha256=Dcf2qPfZFWEUyligRHcIZ-O_A-tvPFak_XxGHNmVhE0,133 +onnx/backend/test/data/node/test_div_int32_trunc/model.onnx,sha256=vYrhcAz7zlWAff74aOka_MDphAc7mPFl0Yg7P4UCFJw,113 +onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/input_0.pb,sha256=36J0G0INzMX_0kErvTxgJ3Ty5ttP3cwCPxg44vPhpWk,25 +onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/input_1.pb,sha256=ybpb652XgDLXjy7xxn5do1lRrhOeZJM4GQeXc1-6uSM,25 +onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/output_0.pb,sha256=bo4vIdHSzrSIOoGtB9RteLWghoAvS-x1h0YwnyOcSBA,25 +onnx/backend/test/data/node/test_div_int8/model.onnx,sha256=O7dvdIwEu9CfoCZ_XDImjOGWCGYvrOxh_sbAuiJjaog,130 +onnx/backend/test/data/node/test_div_int8/test_data_set_0/input_0.pb,sha256=eATUBT1I3TRfB7Ppx2dqesLzDrBYMo2rXR_zM_9a_3k,73 +onnx/backend/test/data/node/test_div_int8/test_data_set_0/input_1.pb,sha256=a8-z7WTX_yIWBmBOlkSTg_q-5A-rTaft4uj6aQhjRjc,73 +onnx/backend/test/data/node/test_div_int8/test_data_set_0/output_0.pb,sha256=PXNBCNJ0WdqytNd6D88PCEbeietpSqRMEzLOyCaLk64,73 +onnx/backend/test/data/node/test_div_uint16/model.onnx,sha256=YWDMfu0wjXVTDtVVef6OEQZ7rhUo1ToNzmW06BQ2vqY,132 +onnx/backend/test/data/node/test_div_uint16/test_data_set_0/input_0.pb,sha256=pXfvBmdY-kfJTard0V37AvQ5cSlgNL_GMq34JXUwzts,133 +onnx/backend/test/data/node/test_div_uint16/test_data_set_0/input_1.pb,sha256=tHqUgjSSwqF54xh1Wv-EwrYf9jUAPv0uOFIuVggUVGQ,133 +onnx/backend/test/data/node/test_div_uint16/test_data_set_0/output_0.pb,sha256=QBAktv7a7QzQNbiafLiYego6r1KEPJFoG4dhyx2xJpQ,133 +onnx/backend/test/data/node/test_div_uint32/model.onnx,sha256=CiOiPzH4OJkQ2uRKQKlFqxCyWPRe1vNxz-SGsyM9ESY,132 +onnx/backend/test/data/node/test_div_uint32/test_data_set_0/input_0.pb,sha256=PquawxSQVEc3WC-erNA8Ci9lF26vCG7Gnty2n70iC18,254 +onnx/backend/test/data/node/test_div_uint32/test_data_set_0/input_1.pb,sha256=J-fHQ5FKvLQ6VkvdtEtK9Buxqbm0z2sqzlKjCJJF-_g,254 +onnx/backend/test/data/node/test_div_uint32/test_data_set_0/output_0.pb,sha256=o7uwCXkiu9hVLwDlokzdN8DWQhMW8TP3XZFazj1JeV8,254 +onnx/backend/test/data/node/test_div_uint64/model.onnx,sha256=Tv1ryjZl2wy9vI0aPf0Rg2uIGdD9a0CX4_WWCNKe5E8,132 +onnx/backend/test/data/node/test_div_uint64/test_data_set_0/input_0.pb,sha256=n6BuZwpwEdbW_VlxQXvX8dVh_0p3iL5pIu0-4wAubbg,494 +onnx/backend/test/data/node/test_div_uint64/test_data_set_0/input_1.pb,sha256=3UCp2ZxCKi0nEYOvYt_PgsgStCbAoOJsCRC3D3T3k2c,494 +onnx/backend/test/data/node/test_div_uint64/test_data_set_0/output_0.pb,sha256=Dupd4mI0aEMAntUnz41i3e1u3Ds_kfKLDvzxERJrOLs,494 +onnx/backend/test/data/node/test_div_uint8/model.onnx,sha256=73xGoanAmgvFoxnmeY70cMDJMj_tiw_G2UXfL1xHP3Q,131 +onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_0.pb,sha256=VLARt-BemSdNsRk2yRbRacC9CHX30n1cw-y9mb8mu74,73 +onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_1.pb,sha256=f330OGFcaxOfvubZ0n0Gt-xnPdJSg6E5FDDzfF74zbY,73 +onnx/backend/test/data/node/test_div_uint8/test_data_set_0/output_0.pb,sha256=vGi8WPzbjzogLQYh6rOWG0mpvUggTSv1ihagWYhgluA,73 +onnx/backend/test/data/node/test_dropout_default/model.onnx,sha256=e5VlAM4clog9LqXTb-sX5CRNkw0j-Q7Xlt8zhcFqobg,126 +onnx/backend/test/data/node/test_dropout_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_default/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dropout_default_mask/model.onnx,sha256=cfc6CZ0VjkyfWjAFaSPgC_plz_PMEYXOSRWFgQfMK7s,160 +onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_1.pb,sha256=4sWzAHgaDiZSCGEr949BKLl9dNfAyqyQpzL1ccqJJ2M,73 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/model.onnx,sha256=JUoCF4i6SO4y7YgrHQ1ediU4NR-YheMONXb7zg5181k,182 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_1.pb,sha256=9FZuwRdGL9lHbnD4w8PpG6fdJjuBpsU9Ei8UsUTXsgA,11 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_1.pb,sha256=4sWzAHgaDiZSCGEr949BKLl9dNfAyqyQpzL1ccqJJ2M,73 +onnx/backend/test/data/node/test_dropout_default_old/model.onnx,sha256=ukHf_-XR4gMOPC5xA7oRg6a5E0bdXsrkl7H6oScsLBE,101 +onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_dropout_default_ratio/model.onnx,sha256=x0nRpQV87wGgR1Tb-tTT5Z0mFG_w0NqSiKnY_SrJ5w4,148 +onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_1.pb,sha256=9FZuwRdGL9lHbnD4w8PpG6fdJjuBpsU9Ei8UsUTXsgA,11 +onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dropout_random_old/model.onnx,sha256=indJUl0_xdJkjHL8itDQnja4iDBaut3bkRryOv65Ajs,133 +onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dynamicquantizelinear/model.onnx,sha256=I5Nk7KgdM4PiZcv5toOWiQZNASMP7H1-BVip_TM4zVM,184 +onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/input_0.pb,sha256=GzpMBt69V1vDS1x0m43plOXtiv0KATlGTtFlf6wKT58,33 +onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_0.pb,sha256=ry3_qJJ8NX3XhMicOdeNEia49jnRgxG2mYxsRuCNIqA,15 +onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_1.pb,sha256=_qXCs5BSE3SUvlSSmCKQs09zGQDHtxBxiiZA6tT1pds,17 +onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_2.pb,sha256=AlfPMoClolzBruTVYhCw3YMjy4RinXVFQpOJ4568epw,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/model.onnx,sha256=y0RptQ5zEM33enw0M1lqkW8WMzTf1M1OU5CXFRV_shc,3145 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/input_0.pb,sha256=GzpMBt69V1vDS1x0m43plOXtiv0KATlGTtFlf6wKT58,33 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_0.pb,sha256=ry3_qJJ8NX3XhMicOdeNEia49jnRgxG2mYxsRuCNIqA,15 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_1.pb,sha256=_qXCs5BSE3SUvlSSmCKQs09zGQDHtxBxiiZA6tT1pds,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_2.pb,sha256=AlfPMoClolzBruTVYhCw3YMjy4RinXVFQpOJ4568epw,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/model.onnx,sha256=sQDOYQy4OZq0Hh-EeM0hb5nEsMZaNAGnOzeDniTnIJY,197 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/input_0.pb,sha256=5Sw2guhx2Fx5oLhz2en7hvFuDC4Ch7l4rDCamVC0X94,33 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_0.pb,sha256=o7JvKwH0WX9r2TNocBXFjxns3RpyEmLMEPxlzT225VM,15 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_1.pb,sha256=pVez9xxtD7ltZc4oLTF3NrV30IFL9ogVC7eseamvAco,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_2.pb,sha256=Ew0CDXUBMf1O1PCpkeQ-lLgahqVnxe0ydyS5jeyNuCk,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/model.onnx,sha256=TehN-V9Yqegtvra-N4OTEq_TJ5LfgjOpihSxyogHuI8,3600 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/input_0.pb,sha256=5Sw2guhx2Fx5oLhz2en7hvFuDC4Ch7l4rDCamVC0X94,33 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_0.pb,sha256=o7JvKwH0WX9r2TNocBXFjxns3RpyEmLMEPxlzT225VM,15 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_1.pb,sha256=pVez9xxtD7ltZc4oLTF3NrV30IFL9ogVC7eseamvAco,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_2.pb,sha256=Ew0CDXUBMf1O1PCpkeQ-lLgahqVnxe0ydyS5jeyNuCk,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/model.onnx,sha256=my7WaurE-jr43TsIE5cuj87Sy7n28aDqgboGieSu0Rg,205 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/input_0.pb,sha256=8wCIWAmNy9W1cv2n1Cqyir5HR5RnEIoXCiO3nqkK_kU,59 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_0.pb,sha256=iwSG6hTgbf_TtcdovQLDsNtTlht754rvSfq5hg2SP-g,23 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_1.pb,sha256=pVez9xxtD7ltZc4oLTF3NrV30IFL9ogVC7eseamvAco,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_2.pb,sha256=L2h2DxO9c7IdJJkT8HsuYfIREZMgRoyy1cA8eeD-F6g,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/model.onnx,sha256=TVtsc5K3LrPgDkW648mwTQ7Oq73tVvfGy7INcf3gg0k,3608 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/input_0.pb,sha256=8wCIWAmNy9W1cv2n1Cqyir5HR5RnEIoXCiO3nqkK_kU,59 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_0.pb,sha256=iwSG6hTgbf_TtcdovQLDsNtTlht754rvSfq5hg2SP-g,23 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_1.pb,sha256=pVez9xxtD7ltZc4oLTF3NrV30IFL9ogVC7eseamvAco,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_2.pb,sha256=L2h2DxO9c7IdJJkT8HsuYfIREZMgRoyy1cA8eeD-F6g,19 +onnx/backend/test/data/node/test_edge_pad/model.onnx,sha256=Cg3ezdLG_ng905u08WKWRtFW0rcUTIrd36yPWlEn3Lc,154 +onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_0.pb,sha256=cOtF8vlVdG7QMT-RPMc2QVp7RFd7GBwL0kJdZpJtZMc,256 +onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_1.pb,sha256=8s4uRhNf19t1kZ-BWDxuitcnY9MeHgkG6w6i1Sghnz0,76 +onnx/backend/test/data/node/test_edge_pad/test_data_set_0/output_0.pb,sha256=Qv3dfFBzQiAv5a2UJMcD3Imge8rs9Lhddyi-ZA2vxXw,520 +onnx/backend/test/data/node/test_einsum_batch_diagonal/model.onnx,sha256=4zTeWtGLnr0OVE8J7llox-D3bgsWZlqPWZAYOTzVPSU,143 +onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/input_0.pb,sha256=sHXqijBwpgvbMjoAuwT6ee_BgNE5XxZNjbh9ezoAJ5A,614 +onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/output_0.pb,sha256=bW-C_Ix72YDKjjTC486yi59ehsLSuK6zTphLx60y15w,131 +onnx/backend/test/data/node/test_einsum_batch_matmul/model.onnx,sha256=JLgXzilgY10tl-yILQhGZI2n83SmH9sjBZYamf6_FOE,177 +onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_0.pb,sha256=XA6uNuRQNZT9t697igygft7fS_BrWdyvbkDTJ1ycv9o,254 +onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_1.pb,sha256=Rb-T5LOsdM55duFCcf7_kuymX-A1Fh1JItpbSdYdohQ,494 +onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/output_0.pb,sha256=btxQVcOiJhZxHjzD9JlDtX7mMumNmOmQNf4XQwP_AnA,334 +onnx/backend/test/data/node/test_einsum_inner_prod/model.onnx,sha256=m0BWV7SrmniOu6XKl0_czSFiH5asoxj7aJtes0U6YPM,134 +onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_0.pb,sha256=6ALN9kajvwedycdrXcEwbCbOklCh2-IRC2ow--sBu6w,49 +onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_1.pb,sha256=3zewJx5xB7-0SZf2259wx2ILafmvfob_BJq1cOs2fdM,49 +onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/output_0.pb,sha256=MUB8WvKbPcte5zUbCNfBkkxdgJyMr-1_W3OnGT4dL9s,15 +onnx/backend/test/data/node/test_einsum_scalar/model.onnx,sha256=Ylwzqg0OE1WOlB9ISmsEDRm2BBJAsrps51ujH0DpoxQ,105 +onnx/backend/test/data/node/test_einsum_scalar/test_data_set_0/input_0.pb,sha256=D_Svxo1ezEL0fv2lAQCDI7WkbEf0NxMPEbizgryRx_g,15 +onnx/backend/test/data/node/test_einsum_scalar/test_data_set_0/output_0.pb,sha256=BfGZGopOdgOi-vMCCzagyM8lE8AnI2HBaY14BzvMF9Y,15 +onnx/backend/test/data/node/test_einsum_sum/model.onnx,sha256=QWE5X5J5jTX5g5X9_cNfJ_Wx54sighP2-RzVLmvIA9s,117 +onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/input_0.pb,sha256=kaRz7Spymj6w1xeS_WNmXkA4FBwzOeDwZxGKrDqtMUM,107 +onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/output_0.pb,sha256=mmH-SDsmj8Pcm24YqzLTL4nZ6CPuL6qZdB7UBTKmDTM,33 +onnx/backend/test/data/node/test_einsum_transpose/model.onnx,sha256=HmVAMMWlGNC3EwszWdTE3kVxq1mZYxlpAbLe5VJkpFM,128 +onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/input_0.pb,sha256=kaRz7Spymj6w1xeS_WNmXkA4FBwzOeDwZxGKrDqtMUM,107 +onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/output_0.pb,sha256=D8CgoMhtm2b7opWaiN6AUgqbOtpSxhagaUexmJr0-pE,107 +onnx/backend/test/data/node/test_elu/model.onnx,sha256=YuWg94S78F8YpP5ClGy7bDGcepz5DGRJW2H3pIsh07M,114 +onnx/backend/test/data/node/test_elu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_elu/test_data_set_0/output_0.pb,sha256=1qikqd90KnVBAo1LXaZuZ_plZqqyNCGPaXg7nndxHaQ,254 +onnx/backend/test/data/node/test_elu_default/model.onnx,sha256=1Cra_oVtGDR---X0rFgqdpBos4XLD3HWhuj0kxqsVcc,105 +onnx/backend/test/data/node/test_elu_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_elu_default/test_data_set_0/output_0.pb,sha256=R10e2MFkJdT7LXU0o6fWwpUeMNIrnT9xSP45r1r6KIU,254 +onnx/backend/test/data/node/test_elu_default_expanded_ver18/model.onnx,sha256=cLYK-eJjTul0ne919XzExJWx4eqzVZOo1v1F5QMblas,1317 +onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/output_0.pb,sha256=R10e2MFkJdT7LXU0o6fWwpUeMNIrnT9xSP45r1r6KIU,254 +onnx/backend/test/data/node/test_elu_example/model.onnx,sha256=cJh64nZo2lmCOFk2ezKZbIpfj7BjfSIfdZB5uOn-bu8,106 +onnx/backend/test/data/node/test_elu_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_elu_example/test_data_set_0/output_0.pb,sha256=BagtTGVCh4Fl4wKScganoM7CS_gWaMK6AlPDEDAksnw,21 +onnx/backend/test/data/node/test_elu_example_expanded_ver18/model.onnx,sha256=KR8nIfX48GdYT6AZkavN6z305oe7Hw7gcK04dShq2g0,1301 +onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=BagtTGVCh4Fl4wKScganoM7CS_gWaMK6AlPDEDAksnw,21 +onnx/backend/test/data/node/test_elu_expanded_ver18/model.onnx,sha256=2JjMB9lsE_l7VxXofbpqL9pqcTcKwubvEzDzODSxt78,1147 +onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/output_0.pb,sha256=1qikqd90KnVBAo1LXaZuZ_plZqqyNCGPaXg7nndxHaQ,254 +onnx/backend/test/data/node/test_equal/model.onnx,sha256=lwmcVb5UafztmJnMu-R95GH3ckvfjLXyLtiN8MxniVc,129 +onnx/backend/test/data/node/test_equal/test_data_set_0/input_0.pb,sha256=MKLPWH4JsioIIdvp1FcMaVkAvmJInLU3evdsDMTfU_k,254 +onnx/backend/test/data/node/test_equal/test_data_set_0/input_1.pb,sha256=4NP29YAJAKfKqC62zG5fj4kjHkgVtZNubPKm6-TtGiM,254 +onnx/backend/test/data/node/test_equal/test_data_set_0/output_0.pb,sha256=ttqpyVFrpeKQuRmyvcAQBtR70YTBB24AYZ3ObZ-r4hQ,73 +onnx/backend/test/data/node/test_equal_bcast/model.onnx,sha256=bFxea4JWRlSryQN79E6QcVCanmIKm_3FvCiUpvY2Zac,127 +onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_0.pb,sha256=MKLPWH4JsioIIdvp1FcMaVkAvmJInLU3evdsDMTfU_k,254 +onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_1.pb,sha256=PSjreW5uEBtMh7ZA7HYMm-dNGY8_FOGUWvaQf6vqo1I,29 +onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/output_0.pb,sha256=FDjiiT-UI1Vmyv7YZPwrXo1-PrlbunLjj4OJ41_aAjs,73 +onnx/backend/test/data/node/test_equal_int16/model.onnx,sha256=xBeBkPIdqm6h2uTrkKuflrRIhnJKIu27XcZYONb_ohA,135 +onnx/backend/test/data/node/test_equal_int16/test_data_set_0/input_0.pb,sha256=4m_QA1NUDty4mB8Ng47eHFujUG1ddc7Rtv5qEZwD1Tw,133 +onnx/backend/test/data/node/test_equal_int16/test_data_set_0/input_1.pb,sha256=OB3mPTjjV00KkqdhG-pV4lEgjfs9ChxNem6Se5-lj4w,133 +onnx/backend/test/data/node/test_equal_int16/test_data_set_0/output_0.pb,sha256=ZOpK7KA-RO1iSlJTBfBdC3P6uTVOsiVzsim3o3zNN_E,73 +onnx/backend/test/data/node/test_equal_int8/model.onnx,sha256=_nBFZmZ58GRkwfOsfWOo6VN_uRSAen_gZhzLi27WNoQ,134 +onnx/backend/test/data/node/test_equal_int8/test_data_set_0/input_0.pb,sha256=5F7K46T_PQ7b92TbJtV2GgupZ9zucLpOCnwmkSmUnRg,73 +onnx/backend/test/data/node/test_equal_int8/test_data_set_0/input_1.pb,sha256=f4GnY373ln2pYtAb4_VHfwbPNLK5Q32vziigx-UqlXY,73 +onnx/backend/test/data/node/test_equal_int8/test_data_set_0/output_0.pb,sha256=W2vBd5tDT33wV4M6TGdySIoJkKFHj7dfEB1wujsZTEU,73 +onnx/backend/test/data/node/test_equal_string/model.onnx,sha256=0FKXgIuUUzbp_zfW68dk4nfjNABehY7u60xHCnjROZc,112 +onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_0.pb,sha256=JL7-CwtjtjFEHwmsDSxw-GA7U5qY0iV3bQVs_6zFmTw,25 +onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_1.pb,sha256=MuifKJHibr3zcpvSLMjcRVz4751u9shjGf9us1VbCI4,25 +onnx/backend/test/data/node/test_equal_string/test_data_set_0/output_0.pb,sha256=vuGdPlSHGdS-OGbB7phc5TqRuC3BQcpJCN7BrvD7pMA,11 +onnx/backend/test/data/node/test_equal_string_broadcast/model.onnx,sha256=_48qehgyKwmUXNKC97eMVRBYwZg5KSt-o_jE3K1KW2A,122 +onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_0.pb,sha256=JL7-CwtjtjFEHwmsDSxw-GA7U5qY0iV3bQVs_6zFmTw,25 +onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_1.pb,sha256=isHWUq2j_Iwbwc2dyAmnF813WI3zs4sENKnIvov_e50,16 +onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/output_0.pb,sha256=vuGdPlSHGdS-OGbB7phc5TqRuC3BQcpJCN7BrvD7pMA,11 +onnx/backend/test/data/node/test_equal_uint16/model.onnx,sha256=ab1KJA_IxFzSxDI9EGLnrcK6rj2nVpG1tYF-1nYyJNI,136 +onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/input_0.pb,sha256=Z8XKkVlB3GZlM-rOR7o7J0Tz1FBTJk-4q6p9lQzT4m4,133 +onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/input_1.pb,sha256=pJ8Bp5eLLQBM0rI9BGkmX_4_nLu9d2VBRQ-rVXXzqCY,133 +onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/output_0.pb,sha256=Cj55DEGGwhnGtM68-Ha4Ap6GLxRp-I0Fb3YXMuwl-0U,73 +onnx/backend/test/data/node/test_equal_uint32/model.onnx,sha256=l7G_LhH32TsmeSLb2W5j6zeQfeJmXks4_pe4TVz1Gvw,136 +onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/input_0.pb,sha256=D0JYWd_ZrvIAvE4r1pPzdOXpwzQVpKYhokUKUa6gRGU,254 +onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/input_1.pb,sha256=ZIaVDbRokYroC0nnM8S1_AzhW5esgMj9EFgFdiIer9Q,254 +onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/output_0.pb,sha256=uuvy4SBld4_7XcoxlELGTiME3HhKAHX6gd7eJqrjVyk,73 +onnx/backend/test/data/node/test_equal_uint64/model.onnx,sha256=2fwkR277GERmTq_h4RQROG5vxlx-1dR4Wy2tzB_J2UA,136 +onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/input_0.pb,sha256=CD_WyZi4lAYk0qAg-z1tjmzD2Q1uA4oZJan-D3y7Gnk,494 +onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/input_1.pb,sha256=TlyupIqUTNNgvP-nfm2KjUCrtptWOnXDF7Tcln315iY,494 +onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/output_0.pb,sha256=_6kMVPidJ5AODF6xpT-A7WhHIm-WDLj4KoM3E0N0F5w,73 +onnx/backend/test/data/node/test_equal_uint8/model.onnx,sha256=O_1DhJfli0VNOBWzzpsqEYaRUAlER458UWkl-XOKAYk,135 +onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/input_0.pb,sha256=OtZmydXMzIfhfiXHFc5c2ZuPImAkezOnRWnK5t8lPQM,73 +onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/input_1.pb,sha256=CIZ-pKNPQzrHKtM8Sp3Gf97XG7qGYd8h9wUit4PPVRw,73 +onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/output_0.pb,sha256=te4SieOi7b3DJSqM8yjRnOyIKVDrw_QsELSSAqqDWe8,73 +onnx/backend/test/data/node/test_erf/model.onnx,sha256=gZmISY2s3vLkp-p3hGrtYQ7g7x1ZyxPp7qBCk_BtuLo,105 +onnx/backend/test/data/node/test_erf/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_erf/test_data_set_0/output_0.pb,sha256=9sqo5UrZ7X_DtEbtytD-4yhCG-fxZN8AtpfVZnDq7IM,12304 +onnx/backend/test/data/node/test_exp/model.onnx,sha256=g1MTYxYg4MkE_ehqbgO_MDDr5izLU4lyhd2-C_dRejo,97 +onnx/backend/test/data/node/test_exp/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_exp/test_data_set_0/output_0.pb,sha256=jP7r-z7yLediEhV36ovwLP0z0r1PtySuyJ7u9FQI_jo,254 +onnx/backend/test/data/node/test_exp_example/model.onnx,sha256=I6CSuYgNQyGhCW3VGbAoB0xv_oKXZSCeFahI_t_zAuk,89 +onnx/backend/test/data/node/test_exp_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_exp_example/test_data_set_0/output_0.pb,sha256=8Z6Sn41Qmu-5DSO90Vhz6iYIY8302yNCBwlDvnxlW9c,21 +onnx/backend/test/data/node/test_expand_dim_changed/model.onnx,sha256=c4_vEqKUcEBPs4Vd9l-OA6h5GN5_rTBFnc6zkcOFe_s,168 +onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_0.pb,sha256=AoPnKt-H_dcTIDGK9TessImdkEH3HfmiW-77-3ZZIqY,26 +onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_1.pb,sha256=nz_Os8au3_CRXPk6uOHXGma3TwkLsQ0R0ZWJdZl2wYU,41 +onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/output_0.pb,sha256=Xeuh-wyUv3E_ihC7s1rogDDZI7IiZZX2Rvq8DW5LwiA,165 +onnx/backend/test/data/node/test_expand_dim_unchanged/model.onnx,sha256=_P8uTx5R3WMbSbUV8du2SdE6XirZGS41H0jzpGc8Syo,166 +onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_0.pb,sha256=AoPnKt-H_dcTIDGK9TessImdkEH3HfmiW-77-3ZZIqY,26 +onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_1.pb,sha256=DvZj0CscD2fjY1rTp_dvS7OobwuGgeXFLEfUroZjXRk,33 +onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/output_0.pb,sha256=W0FAvWPJ1K2wCIJxDV-G4Ejv6MMLgP8xZGwN_KKOEXI,66 +onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/model.onnx,sha256=XrG3LCChELZxXJW_9XW0Lzo_G7Xef_jOMjPjQU9w91k,148 +onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/input_0.pb,sha256=Tx9m2RIZI9vFt7CE3QTvOTK4cLjEh5MACeSTP1egDeA,91 +onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/output_0.pb,sha256=gXtL9SCTNQYHwx7EeNmFhxq1VmtV-WtGGJq-Jk7W4n8,91 +onnx/backend/test/data/node/test_eyelike_with_dtype/model.onnx,sha256=2RVp3NTDlOGQPBNwLfFpSAGBegDjw3ViDCe40z4CtEw,122 +onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/input_0.pb,sha256=l4NjktRUQoCUFQXwkl4ZkuFX0uN_a4U3otSqPmmAL_E,59 +onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/output_0.pb,sha256=0QxDxZ7AFNB3zkhhpmKoveOZZG-yj8CEbcbprLAxmL0,107 +onnx/backend/test/data/node/test_eyelike_without_dtype/model.onnx,sha256=P_0HGWO02Rs5BCn162xyXsT2EBfCpGUjxbMvovVIFEo,111 +onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/input_0.pb,sha256=1UjqCqHuod0Uy98DDsmwuxJylfDmD1WC6n1cuIaueAg,75 +onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/output_0.pb,sha256=41IuN8qkdjiw-rvD37Xoci-okMoFlzst_lOEmxMN22k,75 +onnx/backend/test/data/node/test_flatten_axis0/model.onnx,sha256=RD6BGAWKODXsex-Z7YSeO9fy0czCZfyH1shPbOwEt5E,124 +onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/output_0.pb,sha256=rK76rD-Gd7pN7MFiCa4gnGDsCIaupauMseig-khoG4A,492 +onnx/backend/test/data/node/test_flatten_axis1/model.onnx,sha256=qADkiPP4KCbz8mlh9DvGzu3H35MtC6XQWMWyPjZ3Y0w,124 +onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/output_0.pb,sha256=gp4cg8vDGCIxsjAVH_C6zXUfFdU8e5Zt2rFrNtLE4qM,492 +onnx/backend/test/data/node/test_flatten_axis2/model.onnx,sha256=3lUSdHPBvbmom9GjRrvx45gkTjunWtcLTsjjdRKgy-M,124 +onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/output_0.pb,sha256=WxLYJ0ShJO5yi1cemMDvetHIRHssm7QET5WHVyhCz4w,492 +onnx/backend/test/data/node/test_flatten_axis3/model.onnx,sha256=RHPVx6PR5nxqGbstd6dNm1s093J7jz91ibnxZihFEpQ,124 +onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/output_0.pb,sha256=yPyzGHWmluHXMDP7BvL5BElzL7KCgMtwEH3tLKTwJoE,492 +onnx/backend/test/data/node/test_flatten_default_axis/model.onnx,sha256=JgWOKlzdnkq76T9H9swIYDwWWNWNRZef0PoqH6G2GiM,118 +onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/input_0.pb,sha256=hLRdvgAmmF6-VWT36JhFYz7XSQ8QBpZyobohXpWIaSE,496 +onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/output_0.pb,sha256=6rx1onyZ2U_4kN9SI-xNMUkluod27NrzqMkvO1TH9-Q,492 +onnx/backend/test/data/node/test_flatten_negative_axis1/model.onnx,sha256=csvHMyuNNr4QtfMN-0H1Vf5hbtJt9y10ehgyg3srJk4,142 +onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/output_0.pb,sha256=yPyzGHWmluHXMDP7BvL5BElzL7KCgMtwEH3tLKTwJoE,492 +onnx/backend/test/data/node/test_flatten_negative_axis2/model.onnx,sha256=AxpcDlgTR7QgJxesKEMSKpd36HQUmAo4BRxqwYTp9ck,142 +onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/output_0.pb,sha256=WxLYJ0ShJO5yi1cemMDvetHIRHssm7QET5WHVyhCz4w,492 +onnx/backend/test/data/node/test_flatten_negative_axis3/model.onnx,sha256=MtUmApY4pcwfVN8c7RedTw0dzv_5tpp1COnUqUTsbX0,142 +onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/output_0.pb,sha256=gp4cg8vDGCIxsjAVH_C6zXUfFdU8e5Zt2rFrNtLE4qM,492 +onnx/backend/test/data/node/test_flatten_negative_axis4/model.onnx,sha256=EGShH8a81rf8iz6r-_8qK6OSiPp0Cgx1VsnK-BeLUEE,142 +onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/output_0.pb,sha256=rK76rD-Gd7pN7MFiCa4gnGDsCIaupauMseig-khoG4A,492 +onnx/backend/test/data/node/test_flexattention/model.onnx,sha256=Frvo3o2EAubJV8aDH9qz_kkG3sThSGXv0nBOPrmDnco,228 +onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_0.pb,sha256=aecQ7dHjWNZED8WTLXEIs919Y83KitYmJyV0-WFFw2Q,4112 +onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_1.pb,sha256=uK9mmoJcMNxcp4vA0ylB_E_6ZX3pXKQMoYnXj2usY6c,3088 +onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_2.pb,sha256=HTUGGgcWgtmYYBRAznFHqq0v29rdBsUrvjGkRchqyd8,3088 +onnx/backend/test/data/node/test_flexattention/test_data_set_0/output_0.pb,sha256=wrrFM5FsKyOn3F3vnr-8VG7M8py5nHCI2gpb6U8HrSs,4112 +onnx/backend/test/data/node/test_flexattention_causal_mask/model.onnx,sha256=cryoSBZF-buWraMtxvtpTC8Kob2SkxsLFI4R5YUEqw8,855 +onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_0.pb,sha256=WGoCOefK03UhVu9PW7p7lkC9zdzSplWtIlzHuKjoQhw,272 +onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_1.pb,sha256=gh8Gp1PJa6bIE7y8UaHLg_YBoF-4yL-taCR-35_wcvg,272 +onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_2.pb,sha256=B0wX7D_L9iz8xvwlpfe-d6XwaW_Tf97s7BvZUVGZVIw,272 +onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/output_0.pb,sha256=-dAw9gc8u_OIpsfmzuNJMUoJyg2yoe6Q48j1Rb4yqNA,272 +onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/model.onnx,sha256=KWnDjwmHjKNuoYQyefoS1V5gybvOr8knchAXPotBf98,10822 +onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_0.pb,sha256=WGoCOefK03UhVu9PW7p7lkC9zdzSplWtIlzHuKjoQhw,272 +onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_1.pb,sha256=gh8Gp1PJa6bIE7y8UaHLg_YBoF-4yL-taCR-35_wcvg,272 +onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_2.pb,sha256=B0wX7D_L9iz8xvwlpfe-d6XwaW_Tf97s7BvZUVGZVIw,272 +onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/output_0.pb,sha256=-dAw9gc8u_OIpsfmzuNJMUoJyg2yoe6Q48j1Rb4yqNA,272 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes/model.onnx,sha256=d0rG6artsTqB7_iGnbO6ylUscTyNGq9Nd76tnVcGmNg,244 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_0.pb,sha256=aecQ7dHjWNZED8WTLXEIs919Y83KitYmJyV0-WFFw2Q,4112 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_1.pb,sha256=uK9mmoJcMNxcp4vA0ylB_E_6ZX3pXKQMoYnXj2usY6c,3088 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_2.pb,sha256=YU44GMK5qCd0En54tQ32ifviUihNJQrzy72UmPQtq2I,6160 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/output_0.pb,sha256=-NEuJHbRwCwMONFokz1J0cEcUY0mzx3nIzUQGvnb2H4,8208 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/model.onnx,sha256=0ovBnQFvW9AihEhXgha8M0DDBUJCC9Q7iqB3X9WrwB0,7963 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_0.pb,sha256=aecQ7dHjWNZED8WTLXEIs919Y83KitYmJyV0-WFFw2Q,4112 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_1.pb,sha256=uK9mmoJcMNxcp4vA0ylB_E_6ZX3pXKQMoYnXj2usY6c,3088 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_2.pb,sha256=YU44GMK5qCd0En54tQ32ifviUihNJQrzy72UmPQtq2I,6160 +onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/output_0.pb,sha256=-NEuJHbRwCwMONFokz1J0cEcUY0mzx3nIzUQGvnb2H4,8208 +onnx/backend/test/data/node/test_flexattention_double/model.onnx,sha256=wAGOayRldz79cgnmPSf-QulvwgRWqE8lH_zw88JufYo,235 +onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_0.pb,sha256=5VPBHfzTEABp7s-22dDLRklUOfFLjwqCdlLKT5nrshE,8208 +onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_1.pb,sha256=MbgX6kh3U_gTRwWjhTBDT-MK0S78yXB72RRpZOOkj_M,6160 +onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_2.pb,sha256=hxpIL65Br-LsrfvWgaJwlUBwCxgeNhJ7J0WJ9BWSwl0,6160 +onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/output_0.pb,sha256=_5GALalvcSee8As1vyVZQ8tkFcNtG4mkPkZKGbZTcrM,8208 +onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/model.onnx,sha256=A3kcdzJ9e0hel-N3jibL_NQDJDMUpVtxMt5TUwgRezU,7170 +onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_0.pb,sha256=5VPBHfzTEABp7s-22dDLRklUOfFLjwqCdlLKT5nrshE,8208 +onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_1.pb,sha256=MbgX6kh3U_gTRwWjhTBDT-MK0S78yXB72RRpZOOkj_M,6160 +onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_2.pb,sha256=hxpIL65Br-LsrfvWgaJwlUBwCxgeNhJ7J0WJ9BWSwl0,6160 +onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/output_0.pb,sha256=_5GALalvcSee8As1vyVZQ8tkFcNtG4mkPkZKGbZTcrM,8208 +onnx/backend/test/data/node/test_flexattention_expanded_ver26/model.onnx,sha256=tqGldNnRFqNnNgAk6jQamejjw8kYoIDZcADlRhMuK0k,6554 +onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_0.pb,sha256=aecQ7dHjWNZED8WTLXEIs919Y83KitYmJyV0-WFFw2Q,4112 +onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_1.pb,sha256=uK9mmoJcMNxcp4vA0ylB_E_6ZX3pXKQMoYnXj2usY6c,3088 +onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_2.pb,sha256=HTUGGgcWgtmYYBRAznFHqq0v29rdBsUrvjGkRchqyd8,3088 +onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/output_0.pb,sha256=wrrFM5FsKyOn3F3vnr-8VG7M8py5nHCI2gpb6U8HrSs,4112 +onnx/backend/test/data/node/test_flexattention_fp16/model.onnx,sha256=L1vY_OwRYjxjCZtZciwLCN6wxhsw5nOvCyFFSfcIuN8,233 +onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_0.pb,sha256=BBdLmJbZtR2pvHhcMwz1Vp1itIVnOJHncYbZy-5mWoc,2064 +onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_1.pb,sha256=sSoxQ2MgjYpEQ4LH1exQQD58T2owdIibP0dMKu_w6QQ,1552 +onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_2.pb,sha256=UpV4doItjGRsZRtUFo_ZZNssT6Er1zurYMUC6gnuIrI,1552 +onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/output_0.pb,sha256=wsxT0VuK_hOrq3NYsXC0_MJii2B4SK1ZQTcUTCo5URc,2064 +onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/model.onnx,sha256=LxMoOZFZJZD43EchljTozb7QUl84hGD6N-XIXEBbjfI,7281 +onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_0.pb,sha256=BBdLmJbZtR2pvHhcMwz1Vp1itIVnOJHncYbZy-5mWoc,2064 +onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_1.pb,sha256=sSoxQ2MgjYpEQ4LH1exQQD58T2owdIibP0dMKu_w6QQ,1552 +onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_2.pb,sha256=UpV4doItjGRsZRtUFo_ZZNssT6Er1zurYMUC6gnuIrI,1552 +onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/output_0.pb,sha256=wsxT0VuK_hOrq3NYsXC0_MJii2B4SK1ZQTcUTCo5URc,2064 +onnx/backend/test/data/node/test_flexattention_gqa/model.onnx,sha256=_cSY7TU7CXX8cNnpfP92_qjyrQu384spmZ2iAtVc2sE,232 +onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_0.pb,sha256=vtHiGmSbU6aaS4x91qlenLG-4QrNryLYusIztdI5T0I,4112 +onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_1.pb,sha256=ZA41bHDXW5O2zDIivm7Kez-WJJ3RYtH0mg9-2AjDwi0,1552 +onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_2.pb,sha256=oHNgvzWhP_fnQQ2_-k6Lle7_wQD6zlgbqFfA_LYV6hc,1552 +onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/output_0.pb,sha256=-uB91DvZwPzekbfublN5nECG6aa0NK9UBzaFD43C9eA,4112 +onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/model.onnx,sha256=HBe-mrn_iSdlh2a3i_yhbgzAI8RUC_czTgjDs9I0JUM,6906 +onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_0.pb,sha256=vtHiGmSbU6aaS4x91qlenLG-4QrNryLYusIztdI5T0I,4112 +onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_1.pb,sha256=ZA41bHDXW5O2zDIivm7Kez-WJJ3RYtH0mg9-2AjDwi0,1552 +onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_2.pb,sha256=oHNgvzWhP_fnQQ2_-k6Lle7_wQD6zlgbqFfA_LYV6hc,1552 +onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/output_0.pb,sha256=-uB91DvZwPzekbfublN5nECG6aa0NK9UBzaFD43C9eA,4112 +onnx/backend/test/data/node/test_flexattention_prob_mod/model.onnx,sha256=bpckml3VYjHG0qWXDdw-BdhpEy8Zm5OFOwryKeZYTRQ,400 +onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_0.pb,sha256=UGnu4_xaWole6sFq5BcQNNd-ciwajFoubq4CB5jZmDI,111 +onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_1.pb,sha256=Nzu1nkYkTf6DaaqUyBRbteQGI5sysD7xScp2vYRQZsI,111 +onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_2.pb,sha256=6hlcceG7WYZtC5URCGBBMGTJxYW5EX8grTuZN5Qavpo,111 +onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/output_0.pb,sha256=GomRSDjKac0TFmV_y_TIfCY3yebwSU3reyWsY4Esn-o,111 +onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/model.onnx,sha256=I_AkS7yRyEjhZ0cO50oeSGdC6f33mdWECm2Uvxo7laU,7536 +onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_0.pb,sha256=UGnu4_xaWole6sFq5BcQNNd-ciwajFoubq4CB5jZmDI,111 +onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_1.pb,sha256=Nzu1nkYkTf6DaaqUyBRbteQGI5sysD7xScp2vYRQZsI,111 +onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_2.pb,sha256=6hlcceG7WYZtC5URCGBBMGTJxYW5EX8grTuZN5Qavpo,111 +onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/output_0.pb,sha256=GomRSDjKac0TFmV_y_TIfCY3yebwSU3reyWsY4Esn-o,111 +onnx/backend/test/data/node/test_flexattention_relative_positional/model.onnx,sha256=UuF1cYxbqfRvb_CNlb7gWIFv-7VcCDCSPDsONtdEow8,879 +onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_0.pb,sha256=WGoCOefK03UhVu9PW7p7lkC9zdzSplWtIlzHuKjoQhw,272 +onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_1.pb,sha256=gh8Gp1PJa6bIE7y8UaHLg_YBoF-4yL-taCR-35_wcvg,272 +onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_2.pb,sha256=B0wX7D_L9iz8xvwlpfe-d6XwaW_Tf97s7BvZUVGZVIw,272 +onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/output_0.pb,sha256=BI6ggIKHbE0IuTAlImsHfYUwEO9Tvta064VZWxQ8OLU,272 +onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/model.onnx,sha256=UJPZA8_IIetHO2RqG22aZefJBOLlONSy_D-0qKvMbP4,11772 +onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_0.pb,sha256=WGoCOefK03UhVu9PW7p7lkC9zdzSplWtIlzHuKjoQhw,272 +onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_1.pb,sha256=gh8Gp1PJa6bIE7y8UaHLg_YBoF-4yL-taCR-35_wcvg,272 +onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_2.pb,sha256=B0wX7D_L9iz8xvwlpfe-d6XwaW_Tf97s7BvZUVGZVIw,272 +onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/output_0.pb,sha256=BI6ggIKHbE0IuTAlImsHfYUwEO9Tvta064VZWxQ8OLU,272 +onnx/backend/test/data/node/test_flexattention_scaled/model.onnx,sha256=aqgC5lHDuK6P1nx2fHJ6xJxuSQJP56ztRclT-sDkrLE,252 +onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_0.pb,sha256=aecQ7dHjWNZED8WTLXEIs919Y83KitYmJyV0-WFFw2Q,4112 +onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_1.pb,sha256=uK9mmoJcMNxcp4vA0ylB_E_6ZX3pXKQMoYnXj2usY6c,3088 +onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_2.pb,sha256=HTUGGgcWgtmYYBRAznFHqq0v29rdBsUrvjGkRchqyd8,3088 +onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/output_0.pb,sha256=h6u8Dut_3xRPGuSvaRSd6m4saVHUnbZhn6COUOWJ0wc,4112 +onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/model.onnx,sha256=8ZRXZLz-EBlZZ8ewH9_yee8G2rSRQaT4XIGOGBgIpnA,6061 +onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_0.pb,sha256=aecQ7dHjWNZED8WTLXEIs919Y83KitYmJyV0-WFFw2Q,4112 +onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_1.pb,sha256=uK9mmoJcMNxcp4vA0ylB_E_6ZX3pXKQMoYnXj2usY6c,3088 +onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_2.pb,sha256=HTUGGgcWgtmYYBRAznFHqq0v29rdBsUrvjGkRchqyd8,3088 +onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/output_0.pb,sha256=h6u8Dut_3xRPGuSvaRSd6m4saVHUnbZhn6COUOWJ0wc,4112 +onnx/backend/test/data/node/test_flexattention_score_mod/model.onnx,sha256=E8WX78jVxLER1BWHj3uokSDBKWKq4uOkVy5s87Ocsvs,404 +onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_0.pb,sha256=UGnu4_xaWole6sFq5BcQNNd-ciwajFoubq4CB5jZmDI,111 +onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_1.pb,sha256=Nzu1nkYkTf6DaaqUyBRbteQGI5sysD7xScp2vYRQZsI,111 +onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_2.pb,sha256=6hlcceG7WYZtC5URCGBBMGTJxYW5EX8grTuZN5Qavpo,111 +onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/output_0.pb,sha256=cwxyPZnWtt6qcSviJ2AiGEqjZoEZRqf4k_ap1F_qxvY,111 +onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/model.onnx,sha256=rYLRJbRjzVur5vgJ9LG68z06Wqzk8t2nmAXvby21BUY,7625 +onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_0.pb,sha256=UGnu4_xaWole6sFq5BcQNNd-ciwajFoubq4CB5jZmDI,111 +onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_1.pb,sha256=Nzu1nkYkTf6DaaqUyBRbteQGI5sysD7xScp2vYRQZsI,111 +onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_2.pb,sha256=6hlcceG7WYZtC5URCGBBMGTJxYW5EX8grTuZN5Qavpo,111 +onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/output_0.pb,sha256=cwxyPZnWtt6qcSviJ2AiGEqjZoEZRqf4k_ap1F_qxvY,111 +onnx/backend/test/data/node/test_flexattention_soft_cap/model.onnx,sha256=3iQBPjb0dc_pL8_gSwSGTNErDx_iWEfG9KZiMhgXLew,461 +onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_0.pb,sha256=WGoCOefK03UhVu9PW7p7lkC9zdzSplWtIlzHuKjoQhw,272 +onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_1.pb,sha256=gh8Gp1PJa6bIE7y8UaHLg_YBoF-4yL-taCR-35_wcvg,272 +onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_2.pb,sha256=B0wX7D_L9iz8xvwlpfe-d6XwaW_Tf97s7BvZUVGZVIw,272 +onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/output_0.pb,sha256=4EYbF78OlhA6PEcBLPKuQ3hyQNUfjl9IGYTPyYTUoiM,272 +onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/model.onnx,sha256=SyxTd5HpCRkoVDYa36qOnGSS9FG1hBLXjLXz5QUngco,7945 +onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_0.pb,sha256=WGoCOefK03UhVu9PW7p7lkC9zdzSplWtIlzHuKjoQhw,272 +onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_1.pb,sha256=gh8Gp1PJa6bIE7y8UaHLg_YBoF-4yL-taCR-35_wcvg,272 +onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_2.pb,sha256=B0wX7D_L9iz8xvwlpfe-d6XwaW_Tf97s7BvZUVGZVIw,272 +onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/output_0.pb,sha256=4EYbF78OlhA6PEcBLPKuQ3hyQNUfjl9IGYTPyYTUoiM,272 +onnx/backend/test/data/node/test_floor/model.onnx,sha256=ys4pd-oBAvmFqHS_YNndTptJf8jJUJ25303yszFXYz0,101 +onnx/backend/test/data/node/test_floor/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_floor/test_data_set_0/output_0.pb,sha256=SLn5L75ClP1fBiBE6ZDE4VZzTrXCiWcTMy7QXKa-Ikw,254 +onnx/backend/test/data/node/test_floor_example/model.onnx,sha256=VdIVjxbhQSgQ3qGk0N-ADc6pxiVzMX5yIrBQgg2bFy8,93 +onnx/backend/test/data/node/test_floor_example/test_data_set_0/input_0.pb,sha256=ILNT9pLgfeiHDm9wzsrp3xhT2j2j7e4JJZnFxDDExm4,21 +onnx/backend/test/data/node/test_floor_example/test_data_set_0/output_0.pb,sha256=R2jpEs28Fpb5O1rged2oKCrC6rKz2V4AZANFkIZWhvo,21 +onnx/backend/test/data/node/test_gather_0/model.onnx,sha256=BVuBNnaBUTjWY0CQmPobcWUlvKhO90GmSJ0_Q-K6qos,165 +onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_0.pb,sha256=v9ro1rIfI6GdfDAOlfzMtvUqIdKvWlTBkhnXf794Nm8,499 +onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_1.pb,sha256=0Ccyp4GZ5Le6DSa9l6Ll54TxclZLEJcFSzyZNmAGtOM,39 +onnx/backend/test/data/node/test_gather_0/test_data_set_0/output_0.pb,sha256=09KeAIrn_T0fae6_KPa4XtXP6OS1dQUtxXObxyVKA3o,304 +onnx/backend/test/data/node/test_gather_1/model.onnx,sha256=-einNP84SiRXQdfqLWV_ptKuGZOfDZhxRR6PkxoA2Sg,165 +onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_0.pb,sha256=v9ro1rIfI6GdfDAOlfzMtvUqIdKvWlTBkhnXf794Nm8,499 +onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_1.pb,sha256=0Ccyp4GZ5Le6DSa9l6Ll54TxclZLEJcFSzyZNmAGtOM,39 +onnx/backend/test/data/node/test_gather_1/test_data_set_0/output_0.pb,sha256=ieyU1qyiHYO1t5Ab7_nxdVGd_OaMgc3YbKzYuqajEPg,376 +onnx/backend/test/data/node/test_gather_2d_indices/model.onnx,sha256=DPra5GUI_sv0fTGRUntpMSCozKIDCyJJgGnsrORMvcM,166 +onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_0.pb,sha256=SOaFrsa79PCS2ugXp1X-Zq0oKZzsDF1ZhhCp-IilMbI,50 +onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_1.pb,sha256=bXdhgzbcEgKzjvDLVobDKoZnWAbC9zGJZFC0lj7Y_o8,33 +onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/output_0.pb,sha256=w7ycEGtr1LhcasCY6CV0lbteDV95mdJMiOSF6kAeL68,37 +onnx/backend/test/data/node/test_gather_elements_0/model.onnx,sha256=-UKGxaVDmtpIiOxLp3hdBW50jufIf6WzYL2x9CXsna0,170 +onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_0.pb,sha256=wRC2L4HlxZ6ZgrkzAQSaPSyf6PJwdYTMGNVxHYmTBOE,30 +onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_1.pb,sha256=wSm3mqUOOxYumS8IIOegQAGpVj-DJa5dmRvLafVm1go,49 +onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/output_0.pb,sha256=F1BDlx55q8vtfYsgvENwpn1xht12Z7Dsw5tL1fkhntI,27 +onnx/backend/test/data/node/test_gather_elements_1/model.onnx,sha256=qhtzp0PVLrQhxI8DObE-nI7P7zDA8JgKTo8pliOpxW8,170 +onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_0.pb,sha256=Wm59aOyyoZOZv5YocFWSzXPg25a-rdTtaDgEYaWC5kc,50 +onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_1.pb,sha256=5pgWxgEKVysUsnq2IsW-NVvjJquNbcZKBWa1yFTP0VQ,65 +onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/output_0.pb,sha256=h_nydv1J1lfEmGnseH4P5IDLSjCcUDxV0wK-aQfoPKY,35 +onnx/backend/test/data/node/test_gather_elements_negative_indices/model.onnx,sha256=eFwUhoyzlAwCXYUqo2uMg9At6nY630sSPZYiO6xYER0,185 +onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_0.pb,sha256=Wm59aOyyoZOZv5YocFWSzXPg25a-rdTtaDgEYaWC5kc,50 +onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_1.pb,sha256=0VU9o2--B-qtP4gN3jZZoUPLGH2P_3RcU3JEkOZ9xEo,65 +onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/output_0.pb,sha256=fibWdZ4Mvy73m47uPMZAAKLshVsu3yP3zerYkK7Tqbw,35 +onnx/backend/test/data/node/test_gather_negative_indices/model.onnx,sha256=LsHLhrGMuLkwmRgyZ2IQDIFSPV3498o2_GBtp54cnQk,156 +onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_0.pb,sha256=GXKNcQ-uaECnpF8lviHCWJqTZop-OiUYjf15GjWXEdM,52 +onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_1.pb,sha256=5A7wfS6LnXClLPQu_ACgve0ttcPbYZSfwUcXrHRn7f8,39 +onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/output_0.pb,sha256=A5dULKLVuSszRV-Lr4tSbcCXE8SmBGXGEt2PBEUnrC0,21 +onnx/backend/test/data/node/test_gathernd_example_float32/model.onnx,sha256=qXeqzRaQl1k20yQxj66_8OMPrjB8hhbVLTAIP6Mhwrw,180 +onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_0.pb,sha256=5cz0WLnzXzK7tNORYLLJt7M4cEl5voO6weP87g10uzY,48 +onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_1.pb,sha256=jbBMayVnL94pY1Yt8CqgATmUpNvs4tIWsExStJnd_mU,51 +onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/output_0.pb,sha256=mji8xWMFyFYSHhjyJ7DCrYk0VKFyB-A-UXkQ4i_FRsY,34 +onnx/backend/test/data/node/test_gathernd_example_int32/model.onnx,sha256=BNQJZvLmpsNQWy9awDjRUyKJUFvbW6KFlHgtnp31l4c,162 +onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_0.pb,sha256=9zPZQrD5dWr-AFtjXJKRMv3rliBFCWE67e5HYlFgI8Q,30 +onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_1.pb,sha256=IgYXoL1hPZ5AWWRDlAg52hQcugR9rQ315g3gS5h2SKU,49 +onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/output_0.pb,sha256=wBiSs17OlKdFQgS0dKfm8s3KikSCYY3DCqHVJLqTax0,22 +onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/model.onnx,sha256=6VH-THSJwzI7Z3ZzLqkZIu8raqAyYJ5cYsBtZOTrDSM,200 +onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_0.pb,sha256=_Ufgo65torZP3BJXMuNV_I5bjGxlFeNnmYbzBQDtGgk,48 +onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_1.pb,sha256=PYURLeB1BEiLLcnnTviJ8DKU5TaUbxAMmuEs-y9aEPc,33 +onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/output_0.pb,sha256=SevtZOQwcp9sevBCWvvSXtPStmtLO1deGNkftiCcUK4,32 +onnx/backend/test/data/node/test_gelu_default_1/model.onnx,sha256=mwFqEZ51y0LvHRM5IsCHKreJZ9KXEyX5zpk4_QX32nA,93 +onnx/backend/test/data/node/test_gelu_default_1/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_gelu_default_1/test_data_set_0/output_0.pb,sha256=kXNHzc3-GKYrxpaghZr6veSiP4xRqqFxF7O3-ZhP4BE,21 +onnx/backend/test/data/node/test_gelu_default_1_expanded/model.onnx,sha256=8BP72Oh43uhKm9rtAdckT1VxWGqEeUXkY1_6E2EHLL8,1429 +onnx/backend/test/data/node/test_gelu_default_1_expanded/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_gelu_default_1_expanded/test_data_set_0/output_0.pb,sha256=kXNHzc3-GKYrxpaghZr6veSiP4xRqqFxF7O3-ZhP4BE,21 +onnx/backend/test/data/node/test_gelu_default_2/model.onnx,sha256=QKh66wLVRddslXbWjz9w5qMZaiNSjSuha7xpkQSyiIs,109 +onnx/backend/test/data/node/test_gelu_default_2/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_gelu_default_2/test_data_set_0/output_0.pb,sha256=owVvd1NkqZpTeKmmb6YvaEmWsXET0MfPCc2Q2_9lnl0,254 +onnx/backend/test/data/node/test_gelu_default_2_expanded/model.onnx,sha256=WF1LGm5Sk7UrVsSVxArXm_T8CAoFIB_pwbNhMLDoIxA,1445 +onnx/backend/test/data/node/test_gelu_default_2_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_gelu_default_2_expanded/test_data_set_0/output_0.pb,sha256=owVvd1NkqZpTeKmmb6YvaEmWsXET0MfPCc2Q2_9lnl0,254 +onnx/backend/test/data/node/test_gelu_tanh_1/model.onnx,sha256=VLP4GruStaso802a_IGfYbdxZ7qR5TacEx330pS5xcc,114 +onnx/backend/test/data/node/test_gelu_tanh_1/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_gelu_tanh_1/test_data_set_0/output_0.pb,sha256=zOPUFL9N2bIgMy9AISAxC9H_2OkMgH08bIVd-BLSf4E,21 +onnx/backend/test/data/node/test_gelu_tanh_1_expanded/model.onnx,sha256=QL1UVQadFUDytZKnFhkSKJcLhYwDOKmk3LtuYLtPrVE,2239 +onnx/backend/test/data/node/test_gelu_tanh_1_expanded/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_gelu_tanh_1_expanded/test_data_set_0/output_0.pb,sha256=zOPUFL9N2bIgMy9AISAxC9H_2OkMgH08bIVd-BLSf4E,21 +onnx/backend/test/data/node/test_gelu_tanh_2/model.onnx,sha256=xRiWp7RIE4Jo9IoWKwCUPU5sWho5uxSsVPtNciPFWWo,130 +onnx/backend/test/data/node/test_gelu_tanh_2/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_gelu_tanh_2/test_data_set_0/output_0.pb,sha256=1GhhdFZGWjKhO_psy8GSBCNzuVmt-HAj12NPz06Ids4,254 +onnx/backend/test/data/node/test_gelu_tanh_2_expanded/model.onnx,sha256=65XfLWnYZKKO3UPutOkQXXY9sotXRG-Im9CJinKBmEM,2255 +onnx/backend/test/data/node/test_gelu_tanh_2_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_gelu_tanh_2_expanded/test_data_set_0/output_0.pb,sha256=1GhhdFZGWjKhO_psy8GSBCNzuVmt-HAj12NPz06Ids4,254 +onnx/backend/test/data/node/test_gemm_all_attributes/model.onnx,sha256=HTR5DpeE8XQRryF_KzHEKihBvN_IRKm7yHy0WKvGjBI,218 +onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_0.pb,sha256=RXR_ByfkxKZMoWCAHpiivbcuBwFAKhfBUVkyCln3T0o,59 +onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_1.pb,sha256=aVoY8BMzhNSlp1xP2b-jQ6REpi2Dtc1qnEAPQSMYGKY,91 +onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_2.pb,sha256=8gbLQicg2cZTYZpzj5BI-b4-9XtcCgaLXiQM1a6sZo0,31 +onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/output_0.pb,sha256=M8ow4VnzrBXwrvTAwznwIas4zwLusLNUS7u7MWkQsYY,71 +onnx/backend/test/data/node/test_gemm_alpha/model.onnx,sha256=SzQN_zHM5FNWh8GdU0P7nGh5JurL_z5yCQ1xbB8EfmM,163 +onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_0.pb,sha256=MILDtCDczrrmVCYbqkuMR6oYZmKaoVlWgARdLbzo9B4,71 +onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_1.pb,sha256=1xWZAGPREKiwEVDAShgn4ytsgBqHdZiahRzc34kWXIo,91 +onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_2.pb,sha256=_0XG54N6Zz5zb0Nxb201xMsoJvRtQ47nblJ4VfMvvXA,27 +onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/output_0.pb,sha256=0QrvhY8NjgaHuyrMkfNjHiN8EGUrrI2ik9s8pmKXLVM,59 +onnx/backend/test/data/node/test_gemm_beta/model.onnx,sha256=lbbrtTgcdg49mL9b9JhVQLbSNXp7HnHHN4P0XoFkuto,161 +onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_0.pb,sha256=r5WMCnSToJqMbEYSeANqSG5Nbsp3PtGfofCSBKWZxEw,67 +onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_1.pb,sha256=JeOCNEjJirYi_V4m0bfCyIwat86xDBD3ZA9OL6u1lPM,123 +onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_2.pb,sha256=IB3Jspke-7-5qQWMVzj62hbsVQ_lbvNUYjXvtFGl5IM,27 +onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/output_0.pb,sha256=JVxD5TKmPSVG8a_4F5GxWsxGnVh_R0L9rDe2k3xCqYg,43 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/model.onnx,sha256=EncOjVzLufDY4k7CdiKPnwWV3QqoASAgUDlw9q_f0z0,160 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_0.pb,sha256=XvAUu3zVMoHoUthPBoozrxWJMZk4TyEmquNiplVhb5g,83 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_1.pb,sha256=L69sZ8XUqDcre4xBAI4kPV0TarQpqwHvAdTg5f7WW9Y,107 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_2.pb,sha256=muCFB3W2JEK0ta9OShyFBcQwmhqbNzDHbY3sUDkVkew,59 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/output_0.pb,sha256=iQ3LpdiK7rS38o00o7UMFfXGstIaDyxsk2fileNMB1Q,59 +onnx/backend/test/data/node/test_gemm_default_no_bias/model.onnx,sha256=kLKHvgantAA1L4aWXYOBFpK_y_6ZYUd8sDM0HuauoYk,131 +onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_0.pb,sha256=cTbU9_Eif-2LEv4q5aKaThA_zQhShNPDIiZjXSRhMxs,91 +onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_1.pb,sha256=9trDrSVCbecGUg-TpqlqdscizRriba9XmLEIAPekmDU,131 +onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/output_0.pb,sha256=KC0JMcrMnA0iDy2_QfcyfQQs8KWTbYA9kLb9aSbETMw,35 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/model.onnx,sha256=kyvYbbUiBOl43sEzFkP1NX2h-4EHAR5BuTkNyiPUIKs,151 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_0.pb,sha256=VtTpPce13D-fdCP-802VIbl4EIVLgrtF7mtl517CpIE,35 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_1.pb,sha256=SZG6iS5JbxzyssmlpNhOPGFP_iOd8yfd9sbSGvm4LIA,59 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_2.pb,sha256=zRb1hwJ_IqbwUHQg5cFKeoV_wK7hFWJCLGv5_3lfDoU,11 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/output_0.pb,sha256=EINJmRzyMakSMOcv5FRxJpwJuzuYxYFp_vFX3lPPz1M,43 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/model.onnx,sha256=mUQWPy0JVeYPaVvAvb0jdSDFOKLpwda0OxRe6GBE3Ic,168 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_0.pb,sha256=KtFIVi8IliPuo9E23jP3YKzU-jsTyv306GzQu64WNRM,95 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_1.pb,sha256=QZrZwYak1ep3E164r-vGwhW0neLicmkAgQwUYgKQpG0,95 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_2.pb,sha256=qqc1BKD0WlwHFwNCosttdZqyvg0EznvDfX4sN4oLiGY,13 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/output_0.pb,sha256=uhIwMJjEzSp8y0mRbvsD9SClUujmS9ze-3vbtZmpAK8,47 +onnx/backend/test/data/node/test_gemm_default_vector_bias/model.onnx,sha256=d3yUgH0ldHi5SmINnvKCBg81rqZf64z97wzDRixnEtU,160 +onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_0.pb,sha256=r5WMCnSToJqMbEYSeANqSG5Nbsp3PtGfofCSBKWZxEw,67 +onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_1.pb,sha256=JeOCNEjJirYi_V4m0bfCyIwat86xDBD3ZA9OL6u1lPM,123 +onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_2.pb,sha256=IB3Jspke-7-5qQWMVzj62hbsVQ_lbvNUYjXvtFGl5IM,27 +onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/output_0.pb,sha256=-bT3X5G1IREouSTeHUyj7eZeA6zlCC5U25jNljD222A,43 +onnx/backend/test/data/node/test_gemm_default_zero_bias/model.onnx,sha256=fKG8IMPCAtOZnskNM_HhHhGPX54KM7mbRafsJxcKmAY,158 +onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_0.pb,sha256=MILDtCDczrrmVCYbqkuMR6oYZmKaoVlWgARdLbzo9B4,71 +onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_1.pb,sha256=1xWZAGPREKiwEVDAShgn4ytsgBqHdZiahRzc34kWXIo,91 +onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_2.pb,sha256=_0XG54N6Zz5zb0Nxb201xMsoJvRtQ47nblJ4VfMvvXA,27 +onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/output_0.pb,sha256=-fJCSSDCHHgenicNtmUhcWgfyxt9tadr5CZPutY1ol4,59 +onnx/backend/test/data/node/test_gemm_transposeA/model.onnx,sha256=VRg_UfqynzEdxEmglw_sL9ebMTbIvMUjxH2OmGPCIYY,166 +onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_0.pb,sha256=8v_ybDUH0fDPp5sZoIMfWJvtnweReOYdHp7Iu7qGYCk,83 +onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_1.pb,sha256=L69sZ8XUqDcre4xBAI4kPV0TarQpqwHvAdTg5f7WW9Y,107 +onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_2.pb,sha256=_0XG54N6Zz5zb0Nxb201xMsoJvRtQ47nblJ4VfMvvXA,27 +onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/output_0.pb,sha256=k-IwJyiSI1g8vypylfNjds4-VnWY6uME1fx6BH2lYZU,59 +onnx/backend/test/data/node/test_gemm_transposeB/model.onnx,sha256=qF4Yla3z628tEgTZQuvk_LRwoGr5nh7FJGJZxu3S4hQ,166 +onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_0.pb,sha256=XvAUu3zVMoHoUthPBoozrxWJMZk4TyEmquNiplVhb5g,83 +onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_1.pb,sha256=VKG3Ykxfro1pdhKVtzUNYRYQjysnnn3_P7ZkAKfVQm8,107 +onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_2.pb,sha256=_0XG54N6Zz5zb0Nxb201xMsoJvRtQ47nblJ4VfMvvXA,27 +onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/output_0.pb,sha256=RPKyOLcHHw4m-bpJDc5OB_oLunmPJGdD9FYP-keAVHU,59 +onnx/backend/test/data/node/test_globalaveragepool/model.onnx,sha256=T3XoMZ6NuXeg1iIpTEua2l7gF8oksIR7xVWjkqvW5QM,133 +onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/input_0.pb,sha256=qmHY5ZOgfUeKlGr6gKjS6R4nQl61rIb7E8ZrdQSs3HQ,316 +onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/output_0.pb,sha256=xNA3TgQwfvnKKtJLHlP8BGoYSyY42pXVndHvtMzKNSw,27 +onnx/backend/test/data/node/test_globalaveragepool_precomputed/model.onnx,sha256=8WGRZvh2D4v_7ZXrlNC_7mTTe4da0nyHcVHWsuctqEM,145 +onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/input_0.pb,sha256=VEPr9C-MPAPrWNFhCqj3re8AshFCwfNIPN9i9k2EvMo,51 +onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/output_0.pb,sha256=otE0U2fczeenDUSTqh59jqDAfCNOJMoQjqE0pLtL-KQ,19 +onnx/backend/test/data/node/test_globalmaxpool/model.onnx,sha256=fRcsqaHtJ-bMuqKTuYE10xW9GAeDQSCjHRHTleLhr3I,125 +onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/input_0.pb,sha256=qmHY5ZOgfUeKlGr6gKjS6R4nQl61rIb7E8ZrdQSs3HQ,316 +onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/output_0.pb,sha256=56GJcF-qYJQhHJoqwvMOiOlFGpGfi3tVUUGyrRdycLs,27 +onnx/backend/test/data/node/test_globalmaxpool_precomputed/model.onnx,sha256=IwTHWGrXkP1-ryO2WmeHZo5MZ7k32dmOH8hiTsfZ85E,137 +onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/input_0.pb,sha256=VEPr9C-MPAPrWNFhCqj3re8AshFCwfNIPN9i9k2EvMo,51 +onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/output_0.pb,sha256=BIUCmZ29Gugpj6pl82Cf1tuj26kP34Mbp33VqWuFmnI,19 +onnx/backend/test/data/node/test_greater/model.onnx,sha256=ewXoLOj7YNobggSofGk__hmXs7RamQ2IosA_fQ3Eaos,145 +onnx/backend/test/data/node/test_greater/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_greater/test_data_set_0/output_0.pb,sha256=uDTgBvvrdZBv60SwtKEuuMrGFn3ip783yOujJbu2_wc,79 +onnx/backend/test/data/node/test_greater_bcast/model.onnx,sha256=JL5xVnCCPgeF5ILL-bLmKpmrfSU-CfJXL1FBhe4GW7E,143 +onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/output_0.pb,sha256=ZferDXWUCmTQTquCgvAxWYEnjQ_b1B-dOjznTOngcdQ,79 +onnx/backend/test/data/node/test_greater_equal/model.onnx,sha256=pWC2qrXxm0Vbjj2m8omzBcdrjBVlVCxRRpqg3rY8Lx0,171 +onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_greater_equal/test_data_set_0/output_0.pb,sha256=mzT9JswDPorPoAK92dgoB5a05d4MI3Tx5985GQu3Ntw,85 +onnx/backend/test/data/node/test_greater_equal_bcast/model.onnx,sha256=E1Hy02R8SQc_F_PlX-ArhzZQJwPyTmPnw2z_mxDP-kE,169 +onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/output_0.pb,sha256=oDBk3zKJWIs6Tb8nJcKwh-Fuv0CHlJ8PtGAuV9byRuw,85 +onnx/backend/test/data/node/test_greater_equal_bcast_expanded/model.onnx,sha256=fATWTpPG4PUHGDL0tDnliPidXPuXmVd2GPSryeXnkmQ,447 +onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/output_0.pb,sha256=oDBk3zKJWIs6Tb8nJcKwh-Fuv0CHlJ8PtGAuV9byRuw,85 +onnx/backend/test/data/node/test_greater_equal_expanded/model.onnx,sha256=5stox5Y1fFCl4dX3MuRH40TfIeiJHg4_zUwRAt0FyBQ,425 +onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/output_0.pb,sha256=mzT9JswDPorPoAK92dgoB5a05d4MI3Tx5985GQu3Ntw,85 +onnx/backend/test/data/node/test_greater_equal_int16/model.onnx,sha256=6xHw8SFRI7JhmMfOMeyQznvljB1e9v0b0N1UR1J0opo,177 +onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/input_0.pb,sha256=Ekql9F2JGxauMyWYy99gddONneZ2JokRhXRqh_ztXu4,133 +onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/input_1.pb,sha256=dUS9xcKbE8wAvizR5u89BuWnwC5Zhz2AIMRDLX_pstE,133 +onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/output_0.pb,sha256=OgJIZo5PtDdyd8Mdgdve9giLTXIUdPZrYYnhbHshyE4,85 +onnx/backend/test/data/node/test_greater_equal_int16_expanded/model.onnx,sha256=PqYn-2Eip7rzPN5PgtVAe_NGu8B_t5i2rjNG9Upu-gw,455 +onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/input_0.pb,sha256=Ekql9F2JGxauMyWYy99gddONneZ2JokRhXRqh_ztXu4,133 +onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/input_1.pb,sha256=dUS9xcKbE8wAvizR5u89BuWnwC5Zhz2AIMRDLX_pstE,133 +onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/output_0.pb,sha256=OgJIZo5PtDdyd8Mdgdve9giLTXIUdPZrYYnhbHshyE4,85 +onnx/backend/test/data/node/test_greater_equal_int8/model.onnx,sha256=O7fz2r2pKZPGLpnUR8Awj_tKsKto_z0yrWRhBdyLNx8,176 +onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/input_0.pb,sha256=SUfAIaLamboMcY2-6yJ-_6YzOqUCXuVs-Af-4P9PAGE,73 +onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/input_1.pb,sha256=KrQQ7amyE7zfznGiNWekeRtnQSqyTLrM9tZSsbdVkpY,73 +onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/output_0.pb,sha256=4PJawtQyPedNeViMIRl__UzypMfCi-UWBGVra9wR9TM,85 +onnx/backend/test/data/node/test_greater_equal_int8_expanded/model.onnx,sha256=dMVh1V66-jGHbAFwSXoBBcdxu06czFozUu-DmxjkXSA,450 +onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/input_0.pb,sha256=SUfAIaLamboMcY2-6yJ-_6YzOqUCXuVs-Af-4P9PAGE,73 +onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/input_1.pb,sha256=KrQQ7amyE7zfznGiNWekeRtnQSqyTLrM9tZSsbdVkpY,73 +onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/output_0.pb,sha256=4PJawtQyPedNeViMIRl__UzypMfCi-UWBGVra9wR9TM,85 +onnx/backend/test/data/node/test_greater_equal_uint16/model.onnx,sha256=d44nLgXSXA6rHank3hQ6qlRRZq6CmSagvsxBFOqabks,178 +onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/input_0.pb,sha256=Z8XKkVlB3GZlM-rOR7o7J0Tz1FBTJk-4q6p9lQzT4m4,133 +onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/input_1.pb,sha256=pJ8Bp5eLLQBM0rI9BGkmX_4_nLu9d2VBRQ-rVXXzqCY,133 +onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/output_0.pb,sha256=vB-jaEN_YxujTheoLWHwVQz9XBKVBl3k1h9kfUtSkTQ,85 +onnx/backend/test/data/node/test_greater_equal_uint16_expanded/model.onnx,sha256=ISfq_pg6HMPkkwvnwgQC2hwXM5ikiuBmKxg8s0TAC_0,460 +onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/input_0.pb,sha256=Z8XKkVlB3GZlM-rOR7o7J0Tz1FBTJk-4q6p9lQzT4m4,133 +onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/input_1.pb,sha256=pJ8Bp5eLLQBM0rI9BGkmX_4_nLu9d2VBRQ-rVXXzqCY,133 +onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/output_0.pb,sha256=vB-jaEN_YxujTheoLWHwVQz9XBKVBl3k1h9kfUtSkTQ,85 +onnx/backend/test/data/node/test_greater_equal_uint32/model.onnx,sha256=svFqxUmhhTGi3FoX7HkGEHYprC7AE6FbP062IKB1qrc,178 +onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/input_0.pb,sha256=D0JYWd_ZrvIAvE4r1pPzdOXpwzQVpKYhokUKUa6gRGU,254 +onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/input_1.pb,sha256=ZIaVDbRokYroC0nnM8S1_AzhW5esgMj9EFgFdiIer9Q,254 +onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/output_0.pb,sha256=9Z-LUuG0DvxMDr8kLJq20_3NXOzFmRBp8UTZOCGaYqQ,85 +onnx/backend/test/data/node/test_greater_equal_uint32_expanded/model.onnx,sha256=t8ag7cqIXLygMZmWSypg1_NfbiV08-P6-Ke4abXuwBA,460 +onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/input_0.pb,sha256=D0JYWd_ZrvIAvE4r1pPzdOXpwzQVpKYhokUKUa6gRGU,254 +onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/input_1.pb,sha256=ZIaVDbRokYroC0nnM8S1_AzhW5esgMj9EFgFdiIer9Q,254 +onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/output_0.pb,sha256=9Z-LUuG0DvxMDr8kLJq20_3NXOzFmRBp8UTZOCGaYqQ,85 +onnx/backend/test/data/node/test_greater_equal_uint64/model.onnx,sha256=sbajZ-G01pJhU-L7lWfKLmhdo0660rQt8cDOA5jpjYM,178 +onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/input_0.pb,sha256=CD_WyZi4lAYk0qAg-z1tjmzD2Q1uA4oZJan-D3y7Gnk,494 +onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/input_1.pb,sha256=TlyupIqUTNNgvP-nfm2KjUCrtptWOnXDF7Tcln315iY,494 +onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/output_0.pb,sha256=nlklM08DuCc0f3Gw-Qj59e9h3r_6ljq3Ka4I0G7HVBo,85 +onnx/backend/test/data/node/test_greater_equal_uint64_expanded/model.onnx,sha256=ijIEJPm9XoWv9lwnZ0a2GK2CEqTN0jxwmu1WamnC-6Y,460 +onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/input_0.pb,sha256=CD_WyZi4lAYk0qAg-z1tjmzD2Q1uA4oZJan-D3y7Gnk,494 +onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/input_1.pb,sha256=TlyupIqUTNNgvP-nfm2KjUCrtptWOnXDF7Tcln315iY,494 +onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/output_0.pb,sha256=nlklM08DuCc0f3Gw-Qj59e9h3r_6ljq3Ka4I0G7HVBo,85 +onnx/backend/test/data/node/test_greater_equal_uint8/model.onnx,sha256=ZoB6z9tBaTK0O93x6IDQG7cDFKbOzUxubqG9DQh8iD0,177 +onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/input_0.pb,sha256=OtZmydXMzIfhfiXHFc5c2ZuPImAkezOnRWnK5t8lPQM,73 +onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/input_1.pb,sha256=CIZ-pKNPQzrHKtM8Sp3Gf97XG7qGYd8h9wUit4PPVRw,73 +onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/output_0.pb,sha256=D-ZPR56O0ch2pAfxbiFBLLGLGhEG8byazXlZZ2cSXrM,85 +onnx/backend/test/data/node/test_greater_equal_uint8_expanded/model.onnx,sha256=tK4jCPdTTiwbmD6g18pJC62zOZKZU4_M4Ce0ZbRrN4k,455 +onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/input_0.pb,sha256=OtZmydXMzIfhfiXHFc5c2ZuPImAkezOnRWnK5t8lPQM,73 +onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/input_1.pb,sha256=CIZ-pKNPQzrHKtM8Sp3Gf97XG7qGYd8h9wUit4PPVRw,73 +onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/output_0.pb,sha256=D-ZPR56O0ch2pAfxbiFBLLGLGhEG8byazXlZZ2cSXrM,85 +onnx/backend/test/data/node/test_greater_int16/model.onnx,sha256=vuO1DZFEPNuhsPZA6FGPTGk_ML7NgYj_lfCulsyjxQ0,151 +onnx/backend/test/data/node/test_greater_int16/test_data_set_0/input_0.pb,sha256=Ekql9F2JGxauMyWYy99gddONneZ2JokRhXRqh_ztXu4,133 +onnx/backend/test/data/node/test_greater_int16/test_data_set_0/input_1.pb,sha256=dUS9xcKbE8wAvizR5u89BuWnwC5Zhz2AIMRDLX_pstE,133 +onnx/backend/test/data/node/test_greater_int16/test_data_set_0/output_0.pb,sha256=J9OWFLLoenB7OiwpUMc97BDS5P7ohtBov0ZjUrC26jM,79 +onnx/backend/test/data/node/test_greater_int8/model.onnx,sha256=r-tfyIvA4mbKlt7xyN1G1YutQ_tUAkJiNq1CjJSGIz4,150 +onnx/backend/test/data/node/test_greater_int8/test_data_set_0/input_0.pb,sha256=SUfAIaLamboMcY2-6yJ-_6YzOqUCXuVs-Af-4P9PAGE,73 +onnx/backend/test/data/node/test_greater_int8/test_data_set_0/input_1.pb,sha256=KrQQ7amyE7zfznGiNWekeRtnQSqyTLrM9tZSsbdVkpY,73 +onnx/backend/test/data/node/test_greater_int8/test_data_set_0/output_0.pb,sha256=EyCAFmuHx-ix9qrgKj1MvvTT7YP7JlLAgvHFvn1-1cA,79 +onnx/backend/test/data/node/test_greater_uint16/model.onnx,sha256=dDCHV9t5HTYjoBq93yUFWvUh3NuXIlYmZ00ItlGiREs,153 +onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/input_0.pb,sha256=Z8XKkVlB3GZlM-rOR7o7J0Tz1FBTJk-4q6p9lQzT4m4,133 +onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/input_1.pb,sha256=pJ8Bp5eLLQBM0rI9BGkmX_4_nLu9d2VBRQ-rVXXzqCY,133 +onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/output_0.pb,sha256=kuF4BBgB5jcwGlhf8w_owWOuMmtDC4DsxVn5Eihh_Qg,79 +onnx/backend/test/data/node/test_greater_uint32/model.onnx,sha256=Zt-WBIOPsdpZUnTvYGtSrDVEM3RZ2s2-fyjLC5Ju1aQ,153 +onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/input_0.pb,sha256=D0JYWd_ZrvIAvE4r1pPzdOXpwzQVpKYhokUKUa6gRGU,254 +onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/input_1.pb,sha256=ZIaVDbRokYroC0nnM8S1_AzhW5esgMj9EFgFdiIer9Q,254 +onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/output_0.pb,sha256=KIy4CoRC-wmdvuigEopguHl35c3VeKkDmc3Jnvnxm_U,79 +onnx/backend/test/data/node/test_greater_uint64/model.onnx,sha256=cfsk_vqwTDlg-s-Pc96LVh6eGtVxOBF8MYXy3BCuhp4,153 +onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/input_0.pb,sha256=CD_WyZi4lAYk0qAg-z1tjmzD2Q1uA4oZJan-D3y7Gnk,494 +onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/input_1.pb,sha256=TlyupIqUTNNgvP-nfm2KjUCrtptWOnXDF7Tcln315iY,494 +onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/output_0.pb,sha256=PkWLBgMKlZEI2JBFn4ANzOGbp75Si1aWBDTNqK8VJWk,79 +onnx/backend/test/data/node/test_greater_uint8/model.onnx,sha256=TzSUReZlL4TvsyQelocKk_bvjdTN7hZzpVd093Ausxk,151 +onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/input_0.pb,sha256=OtZmydXMzIfhfiXHFc5c2ZuPImAkezOnRWnK5t8lPQM,73 +onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/input_1.pb,sha256=CIZ-pKNPQzrHKtM8Sp3Gf97XG7qGYd8h9wUit4PPVRw,73 +onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/output_0.pb,sha256=V2CvSUvIHjfQqGeg7aRhvo4BW06k-w6ZH8Rto52XKzM,79 +onnx/backend/test/data/node/test_gridsample/model.onnx,sha256=eDTK1KimoDfprmX8Ei2pR47-X7divF58m5SAdwEpeDU,225 +onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_0.pb,sha256=Er_KMA_bpGQqp91W7npSqfc4KcISgiYpOOth1aVtUoI,79 +onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_1.pb,sha256=VIc-rbiGUK4N9CBPdEUTgumay_Uf6CQo8S8rSodbCdo,307 +onnx/backend/test/data/node/test_gridsample/test_data_set_0/output_0.pb,sha256=35yxRZMYSQ1swNbyzFBFwVsmmeUdZR7iduxEuQ3I0NM,160 +onnx/backend/test/data/node/test_gridsample_aligncorners_true/model.onnx,sha256=MDrVYHnvG2WpTQ8TfdoBMxGpCX_jFz0qlggk4_io16Y,217 +onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_1.pb,sha256=-sgoYS71T1zyadZBJamze1_tDkLWp1RdqtziONB_zus,82 +onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/output_0.pb,sha256=LKkY9CQbQvs4La-iuW0PzhH7gUCo-vr7friq3vXiyRw,47 +onnx/backend/test/data/node/test_gridsample_bicubic/model.onnx,sha256=W5-GhUZ2Uz1FSp8tNSdlXFSvAxk8_MgHXgSPyH2MrNE,184 +onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_1.pb,sha256=-sgoYS71T1zyadZBJamze1_tDkLWp1RdqtziONB_zus,82 +onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/output_0.pb,sha256=iWyxqWQU2N7P8sBWOhtYGlbaZOizT5bWdJyERH9Vmd4,47 +onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/model.onnx,sha256=mgqC7VVOYfS2TDJLqFMajVh2k4YtYf4y7ijJgsxQxEg,235 +onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/input_1.pb,sha256=S-pBmDHOidx8aoIg0YScdo5k3XAxEqy94qiZuwzIg5E,82 +onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/output_0.pb,sha256=CH1eGEUSYtT6gnhdwtywpw00oxGO061P3KX40yu1pNE,47 +onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/model.onnx,sha256=0iBECpLbCTR6i_r_GvKWDkj9DQ03Yd_pixUuk-Jxo8A,235 +onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/input_1.pb,sha256=S-pBmDHOidx8aoIg0YScdo5k3XAxEqy94qiZuwzIg5E,82 +onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/output_0.pb,sha256=FA2Hwp_kMsEDsazjxJCrhvf9B1b6sG4cCYriEcmOLPw,47 +onnx/backend/test/data/node/test_gridsample_bilinear/model.onnx,sha256=LnkZQodyae4uA9qMSBmxG7AU3W1CXQ2uGLFYeTxb31E,186 +onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_1.pb,sha256=-sgoYS71T1zyadZBJamze1_tDkLWp1RdqtziONB_zus,82 +onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/output_0.pb,sha256=JT3KtQjkMJaSS4Apt00mMjXzrXSol3CsMvGX-0_2-w8,47 +onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/model.onnx,sha256=hmN6gx0MbzCYfJZ9siHIvSJmTFJFUUZK9Q5pIEo50oM,237 +onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/input_1.pb,sha256=S-pBmDHOidx8aoIg0YScdo5k3XAxEqy94qiZuwzIg5E,82 +onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/output_0.pb,sha256=Hia4lHz9zXuIbUxTcFdXcKVmSfITXZX2Nv3iWTsYPc8,47 +onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/model.onnx,sha256=Oz1sk893IVtFmif1Y2sATdhDqU1lYbRjkXAXZNRczMw,237 +onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/input_1.pb,sha256=S-pBmDHOidx8aoIg0YScdo5k3XAxEqy94qiZuwzIg5E,82 +onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/output_0.pb,sha256=2lnf2H2pxf833H5TR83M3Ie7RrrEwAq95jOFyr1n6I4,47 +onnx/backend/test/data/node/test_gridsample_border_padding/model.onnx,sha256=JSKyNe7MwSGlLbnvwDdAfxHERc_dDbhXuF2eXYCY6bI,200 +onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_1.pb,sha256=uIKQ9S1EJfGQDnIqDNFDZbPRcI4P9J11zZOQAFxwJGA,82 +onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/output_0.pb,sha256=9rfdAbkyFmuRjDoU9VsoDOaem0ChoKqoz4aBl_pcsGk,47 +onnx/backend/test/data/node/test_gridsample_nearest/model.onnx,sha256=qSWq3aXUc_pZxnmfeFmEDpSl_teLY8ERb7UpQZWfCG0,186 +onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_1.pb,sha256=-sgoYS71T1zyadZBJamze1_tDkLWp1RdqtziONB_zus,82 +onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/output_0.pb,sha256=RM6pagyCCllTI5PrwIPKwCNW9RocxzB7ktzcax9cNiM,47 +onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/model.onnx,sha256=T17aDQ_Gd9zQ9Q0VAqwB4eQcyCSpqI5K27rg37RHv30,237 +onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/input_1.pb,sha256=S-pBmDHOidx8aoIg0YScdo5k3XAxEqy94qiZuwzIg5E,82 +onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/output_0.pb,sha256=pprCS5vT63wV2Kn1n1Vm8G_lSlOxeKhGCoWiNFmhJWg,47 +onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/model.onnx,sha256=d9VZO8RdP-ko_Gh1xsgyz4jK6cg2IyHrVnqL2J8w6kY,237 +onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/input_1.pb,sha256=S-pBmDHOidx8aoIg0YScdo5k3XAxEqy94qiZuwzIg5E,82 +onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/output_0.pb,sha256=AzIm5H-C20yEZs3qQNunUmyAwLF5U2ziZlH17iYr7EM,47 +onnx/backend/test/data/node/test_gridsample_reflection_padding/model.onnx,sha256=4-BUHAvmxrLZNzfHoRk1IUhAGcXGekecG5PpDmS6By0,208 +onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_1.pb,sha256=uIKQ9S1EJfGQDnIqDNFDZbPRcI4P9J11zZOQAFxwJGA,82 +onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/output_0.pb,sha256=8Ovh-MCNiNQzDI6mWj3wv0noANRS_mwlPRnZPtEz7Pk,47 +onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/model.onnx,sha256=u4eUhOXGZ0Lkp_f2RdpGQQ0Xub-REFWtHR4UpmigGhE,247 +onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/input_0.pb,sha256=w3udC33Xk5943mn4uUmJjjfWWlSTh4VpmQ6jcfBb39c,65 +onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/input_1.pb,sha256=j0XIrTf0kge2JI0qWKCw8Pgklg_WapelI24JtKplbYI,213 +onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/output_0.pb,sha256=4RZ1gXSksQEIzTr2XANATu1u1zucNYe-SP9YA84ksg4,81 +onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/model.onnx,sha256=7vyfmfJUgHaSPaQ_HVW-owc9kkq0C00FoApwc3tlvqI,247 +onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/input_0.pb,sha256=w3udC33Xk5943mn4uUmJjjfWWlSTh4VpmQ6jcfBb39c,65 +onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/input_1.pb,sha256=j0XIrTf0kge2JI0qWKCw8Pgklg_WapelI24JtKplbYI,213 +onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/output_0.pb,sha256=HxSumNRz-peyT_0-4Ic5h34T9DFf6vqx5KobtnJCVvQ,81 +onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/model.onnx,sha256=pjRzIrW4Fv6IqfGnKEBFEfErJKgdrleOP3AS0khk8_s,247 +onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/input_0.pb,sha256=w3udC33Xk5943mn4uUmJjjfWWlSTh4VpmQ6jcfBb39c,65 +onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/input_1.pb,sha256=j0XIrTf0kge2JI0qWKCw8Pgklg_WapelI24JtKplbYI,213 +onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/output_0.pb,sha256=qpKayAfI6ebDn-hG3_zWQEN-ktIeocC7cnuXbe6dBi8,81 +onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/model.onnx,sha256=WVx-GmdwjP5Q3qq6OvFT33GAycj7TpW_mkMLXQIERnc,247 +onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/input_0.pb,sha256=w3udC33Xk5943mn4uUmJjjfWWlSTh4VpmQ6jcfBb39c,65 +onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/input_1.pb,sha256=j0XIrTf0kge2JI0qWKCw8Pgklg_WapelI24JtKplbYI,213 +onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/output_0.pb,sha256=91xEyuO_lD8wWYy5PndQ9qwj-Cu4dTvoPM7eJzu9Ww0,81 +onnx/backend/test/data/node/test_gridsample_zeros_padding/model.onnx,sha256=3a9HWYk_lC0Fpnz_bbfnTonf_0JHpepQUmncGu3N4Tk,198 +onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_1.pb,sha256=uIKQ9S1EJfGQDnIqDNFDZbPRcI4P9J11zZOQAFxwJGA,82 +onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/output_0.pb,sha256=jRhFqa9skdV2ePTbDrQAFklZOaUhfsUJp4FA8TgrUq8,47 +onnx/backend/test/data/node/test_group_normalization_epsilon/model.onnx,sha256=IWmWvvQALlCFUQsKw2vuzBZVCNLgorkLrWCJEPcJG1k,237 +onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_0.pb,sha256=692CieKQgoIgcJDXYv6vb3tpyZcEpU2pA8gk_cgjurc,208 +onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_1.pb,sha256=V8-sP2yOFVu15tceGemZwbw8kYpaxnUBnMrD1VV5uPs,29 +onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_2.pb,sha256=67rO8d_pa-UblpMvR2LTgAvqsWOcSl3Y90e1kFz0LhQ,28 +onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/output_0.pb,sha256=JjaAD2JmnNphn2cTa3r6PnSW2T8YEzXcgzuS2UfJlfw,208 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/model.onnx,sha256=XTSHGpSU1AfC_DjsnV3SNqGnu-_e64LZr7i_BGE0GRg,7018 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_0.pb,sha256=692CieKQgoIgcJDXYv6vb3tpyZcEpU2pA8gk_cgjurc,208 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_1.pb,sha256=V8-sP2yOFVu15tceGemZwbw8kYpaxnUBnMrD1VV5uPs,29 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_2.pb,sha256=67rO8d_pa-UblpMvR2LTgAvqsWOcSl3Y90e1kFz0LhQ,28 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/output_0.pb,sha256=JjaAD2JmnNphn2cTa3r6PnSW2T8YEzXcgzuS2UfJlfw,208 +onnx/backend/test/data/node/test_group_normalization_example/model.onnx,sha256=ru04WRQ8XYo0fGdeEs1sDftlHVr9yto9Gtf3nQKPIQI,218 +onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_0.pb,sha256=692CieKQgoIgcJDXYv6vb3tpyZcEpU2pA8gk_cgjurc,208 +onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_1.pb,sha256=V8-sP2yOFVu15tceGemZwbw8kYpaxnUBnMrD1VV5uPs,29 +onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_2.pb,sha256=67rO8d_pa-UblpMvR2LTgAvqsWOcSl3Y90e1kFz0LhQ,28 +onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/output_0.pb,sha256=BVpVQ2TcrdSkl3KPb8GNgtKDPozLxYe0be9x7C0MDHE,208 +onnx/backend/test/data/node/test_group_normalization_example_expanded/model.onnx,sha256=09n99FpzxcHOp6Io2Vb46zem0PtnRxmMr7v0qMnPSPQ,7018 +onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_0.pb,sha256=692CieKQgoIgcJDXYv6vb3tpyZcEpU2pA8gk_cgjurc,208 +onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_1.pb,sha256=V8-sP2yOFVu15tceGemZwbw8kYpaxnUBnMrD1VV5uPs,29 +onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_2.pb,sha256=67rO8d_pa-UblpMvR2LTgAvqsWOcSl3Y90e1kFz0LhQ,28 +onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/output_0.pb,sha256=BVpVQ2TcrdSkl3KPb8GNgtKDPozLxYe0be9x7C0MDHE,208 +onnx/backend/test/data/node/test_gru_batchwise/model.onnx,sha256=f3gAlPEtZahkM9sqESBeJRVaxDGEmkT9cUO5u5ak7jQ,235 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_0.pb,sha256=X4Jx731skujCbqYlfE79v4ovLqbqAar9VfhQTegviw8,37 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_1.pb,sha256=1XWIhQUoTeNdQ7bZCX8yrBOX7Q92l7BeORAPrRY1avU,158 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_2.pb,sha256=oTE_0fIu0UOnnYZ7CNygBadHRlesmV1ETn3TvYDEya4,446 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_0.pb,sha256=9JVi2_8o_taU1q2mC9RFUb8_KHoyJ-J4xI0rXrK5LYs,87 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_1.pb,sha256=CnxT40oj7emJcthZanYarqegr_Zsvg3qkro1M3x3dUU,87 +onnx/backend/test/data/node/test_gru_defaults/model.onnx,sha256=6mA0aqWS4XHtzbQ2F4BkdrsG0L5oKCgjEhcKlU8SJe8,189 +onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_0.pb,sha256=CfdyEi1TF1qNXdr7S9ZjPY0_c7pWtxM7ou3bNl3fNIo,37 +onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_1.pb,sha256=Z_bpWjBL52Ni7_VmBBnx9GHq8oGZzSILXNiGdNDDxiQ,133 +onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_2.pb,sha256=blVg0U6-PdjmVF5azf2rAQafYFnzJtcTojgoF5OKCak,314 +onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/output_0.pb,sha256=xhW9IjUNOKkLWOQu1imw5N_rLbHxi-vqJStJf-FksVM,75 +onnx/backend/test/data/node/test_gru_seq_length/model.onnx,sha256=-VMn3ix9-tVKGfann3m3PU_Ytu6jWstadYynfafrkKE,215 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_0.pb,sha256=fFR4OIXWBj5wmFEuZbfl7GOhhRaSJv9tEZM8VbjQ72Q,85 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_1.pb,sha256=tdQyLDrgooqElZX1X_yvVWQ3l77QTVxNMuJ9Mc3my5A,194 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_2.pb,sha256=bGMNqQFklQXONtCc1NZ73_jH8eb-uYXHaNyqNefJOzg,314 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_3.pb,sha256=pj0sMaV4OPwfxoqssa4Ub4IA_xoFv1hFo--pPjxftQ4,131 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/output_0.pb,sha256=ANqsfpHbnQLw0XMH1goz9oheZN79GTowkv3yVIr6l8A,75 +onnx/backend/test/data/node/test_gru_with_initial_bias/model.onnx,sha256=vUTV65RG1Bj10pU_QQPpnQOa3q9SRIRAgjHxtAhCMIc,222 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_0.pb,sha256=eujm2YGHVRU93EAGK-aPA-aFEublku2wP288wJjVc4M,49 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_1.pb,sha256=EfCDZYPnRWB7IsE8QGLIxMMz1xsQspu2INrBzW0mBtw,121 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_2.pb,sha256=NuX-1ShTCBOI4m3H5fPAevf2oD_13zSsGNnhuLqlfwg,121 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_3.pb,sha256=SVjGa5u2ro0p1fUr5PEg1iOb7l12XHqFk9ZhQdMB2uQ,83 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/output_0.pb,sha256=HqlZXwUiQd76iSbd2zcKuJXxDM4Xe2av5ojJ5ndZ4Vk,51 +onnx/backend/test/data/node/test_hammingwindow/model.onnx,sha256=XmWXPruOkAjvFooZAUhkRImHklBQyIc-oNDAnk6Kp_s,97 +onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/output_0.pb,sha256=JJqU6DQrUQh2Z9OHkuJEvgE4h7aRTqrFf8eghKQnJic,49 +onnx/backend/test/data/node/test_hammingwindow_expanded/model.onnx,sha256=q-Ts9UxK0oBEFLslo8fT_xaD5tAIfY0LUc9DqeVTYk8,4131 +onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/output_0.pb,sha256=JJqU6DQrUQh2Z9OHkuJEvgE4h7aRTqrFf8eghKQnJic,49 +onnx/backend/test/data/node/test_hammingwindow_symmetric/model.onnx,sha256=8JOAx7sAb5z3xfSuOwq8AD30ghEjTR1iH06VS9uqAsM,124 +onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/output_0.pb,sha256=LpkXJQOJz2FojSTdvVyf5qSxF5_CTzGKGGukVhBADCA,49 +onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/model.onnx,sha256=n6fC4unzUlQFNiC0fiAPQRhIuTRkdwb-xIbr2ucCxks,4701 +onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/output_0.pb,sha256=LpkXJQOJz2FojSTdvVyf5qSxF5_CTzGKGGukVhBADCA,49 +onnx/backend/test/data/node/test_hannwindow/model.onnx,sha256=fpu3WfmAnvLPZokShbCTr9zhweBMiIs4BSWCJ6kM14E,91 +onnx/backend/test/data/node/test_hannwindow/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hannwindow/test_data_set_0/output_0.pb,sha256=La1AIuktrbq9_sQyopHiDF2gpWDg1uYHb0JNcHJi2Fc,49 +onnx/backend/test/data/node/test_hannwindow_expanded/model.onnx,sha256=ghAYZSC8XHRMj1HAkopEVhR1VEM8XJ_JCD0RcUFmJ_o,3792 +onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/output_0.pb,sha256=La1AIuktrbq9_sQyopHiDF2gpWDg1uYHb0JNcHJi2Fc,49 +onnx/backend/test/data/node/test_hannwindow_symmetric/model.onnx,sha256=ieBsEc3yA82fJuZLOPWaGQXzY1oC639oG1dzpxVjR8g,118 +onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/output_0.pb,sha256=IkkSxie6_OjqiB-FqYkza4IME5tWVZnRE8CmEWg7kRA,49 +onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/model.onnx,sha256=Xpsrjinpeu2i0nz2_8Jm6nIHzLhVwNLxc1w5QM8kr3Q,4362 +onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/output_0.pb,sha256=IkkSxie6_OjqiB-FqYkza4IME5tWVZnRE8CmEWg7kRA,49 +onnx/backend/test/data/node/test_hardmax_axis_0/model.onnx,sha256=moiCGKB0Oc3qJtx6dMYz2IfuBDJShvTEZHTGzMR7tBM,125 +onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/output_0.pb,sha256=-jupCDBJs-WrmX2w6Gbwg76FW-XG0RzAhHYZeclMMHM,254 +onnx/backend/test/data/node/test_hardmax_axis_1/model.onnx,sha256=lLcJFwZG9SxP1SR1ip1xRH_GWjwwUgZSGcDmK_DiOKg,125 +onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/output_0.pb,sha256=ShJTro9DVDSj1gN_QIhaNfi3aDsXbW0xlw5He2wbAF0,254 +onnx/backend/test/data/node/test_hardmax_axis_2/model.onnx,sha256=Aq5v4HywyLNApU7lL1ge1Izhbwamc7jnq2GVxB27hkA,125 +onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/output_0.pb,sha256=p6ts1e5G3uPByR7frd8okvp0wsK8j91dRLPkDbq5Yf4,254 +onnx/backend/test/data/node/test_hardmax_default_axis/model.onnx,sha256=K3iL4jVTDBNWZxWOSU7B9U-AP6EStZbEW4EfvDR8YKI,118 +onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/output_0.pb,sha256=p6ts1e5G3uPByR7frd8okvp0wsK8j91dRLPkDbq5Yf4,254 +onnx/backend/test/data/node/test_hardmax_example/model.onnx,sha256=tAlOkY2DZGE9MiBisTVqXU-wggSqTxs7DOiy6piZ-wQ,105 +onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/input_0.pb,sha256=OzGq9WBWdosYSRvhnaiLhc7KylgWFWhYq8uaEybAeNs,75 +onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/output_0.pb,sha256=M4Nd1Dixr1GZVG8M8nttCzW57XEJpxlL3pT_jKit-as,75 +onnx/backend/test/data/node/test_hardmax_negative_axis/model.onnx,sha256=GEMroWxNGa7Kdjf5rFkOztNV5167ywdGdc2gIlLGXmI,141 +onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/output_0.pb,sha256=p6ts1e5G3uPByR7frd8okvp0wsK8j91dRLPkDbq5Yf4,254 +onnx/backend/test/data/node/test_hardmax_one_hot/model.onnx,sha256=_QtPLoPEGl0HTFjIH6AWIiqzLwUzHdOc2SjWXHiK2bI,105 +onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/input_0.pb,sha256=DLuz3VAkGId5FXX8jyoCfePLABiQklqpVIJJXzXOvsc,27 +onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/output_0.pb,sha256=P6WwvTGfwLDhJb72onY1iPvk3b0s1_tn5fMLATQ1JtU,27 +onnx/backend/test/data/node/test_hardsigmoid/model.onnx,sha256=Vhgf1vfG2wVlLVe7QyHV73S_hdT1HHXb2nZOwWd5hDU,146 +onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/output_0.pb,sha256=TqEPthNFWy5d78pFlUAqA8L0OV5_7USxH89x_hDCGSY,254 +onnx/backend/test/data/node/test_hardsigmoid_default/model.onnx,sha256=qFBH45PIsJ007E_JCFv8N2s33xlaQikO61FziS-tCm8,121 +onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/output_0.pb,sha256=9uWdF9Of6-C1Xl4uBs_ViDKh_BS2f-kxq05kKF6CL8E,254 +onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/model.onnx,sha256=abINq0Rs2GihOQ0A0ZGP-wrzpbfi1vQw8-zXbMtUCKs,1832 +onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/output_0.pb,sha256=9uWdF9Of6-C1Xl4uBs_ViDKh_BS2f-kxq05kKF6CL8E,254 +onnx/backend/test/data/node/test_hardsigmoid_example/model.onnx,sha256=FkWbCgCTM-vRNnSEI63BfnxN-nhcTP-wgN5id58PmR0,138 +onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/output_0.pb,sha256=PHqA-MDOmKyDONKLmnSan5kJG8kPdXMzAzKuVLYvEGI,21 +onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/model.onnx,sha256=C5ZbLmEUIJ2Cx3uX_V9D5hOk28lCRZCoNp_pstKJr4A,1816 +onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=PHqA-MDOmKyDONKLmnSan5kJG8kPdXMzAzKuVLYvEGI,21 +onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/model.onnx,sha256=S9Qspqr4OliFKvUDw3SzZdX-rsMZhcEzOoYvaq8XiLU,1643 +onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/output_0.pb,sha256=TqEPthNFWy5d78pFlUAqA8L0OV5_7USxH89x_hDCGSY,254 +onnx/backend/test/data/node/test_hardswish/model.onnx,sha256=vPxdesCjrKa7Y_4HiIIljz7zyMT4pez5LnT-DqX4z1M,109 +onnx/backend/test/data/node/test_hardswish/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardswish/test_data_set_0/output_0.pb,sha256=GmF26kbYvCTZt0rhtvIs_790x5A_8j5LG4zpVHM8BaI,254 +onnx/backend/test/data/node/test_hardswish_expanded/model.onnx,sha256=yrdEyb0LUHe897PxwzWc91NHkkjEK-yVijOQcRr2xQs,266 +onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/output_0.pb,sha256=GmF26kbYvCTZt0rhtvIs_790x5A_8j5LG4zpVHM8BaI,254 +onnx/backend/test/data/node/test_identity/model.onnx,sha256=SI9xNHyiFgbNWTYfwm87vSMsqIDAWsxEglLc0TAimEU,115 +onnx/backend/test/data/node/test_identity/test_data_set_0/input_0.pb,sha256=jVVsnPYTtqJkezoas6FKgAvUJVH-Z4OI0Eocd13lMSg,31 +onnx/backend/test/data/node/test_identity/test_data_set_0/output_0.pb,sha256=gGR3wxRX145Jj-O43a8Qh6gPsPhFfPlEHErpPYQTP4Q,31 +onnx/backend/test/data/node/test_identity_opt/model.onnx,sha256=O_lLBDX5CpDSi7O2MOl6WIg4QEQHw36dxVPbu3ejBoA,133 +onnx/backend/test/data/node/test_identity_opt/test_data_set_0/input_0.pb,sha256=YddZEUyYhxMxNF8EBJChB6-dIseFq_7iAqB4GMdZr5s,42 +onnx/backend/test/data/node/test_identity_opt/test_data_set_0/output_0.pb,sha256=eh6A9N--g1PUhUrMyCSJUT3XmOiwx8LdKFOQ96LXotM,43 +onnx/backend/test/data/node/test_identity_sequence/model.onnx,sha256=CBu8Pw8jt_KpksSLARWtj1tn_IyUi99eyIkBzvj0muU,96 +onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/input_0.pb,sha256=OtWKEZPsdistnxRCHxBveuTAodHN1mzb88-jDLRqGWM,65 +onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/output_0.pb,sha256=Nzoz0AbflpzSX5mlHltvaOoEuIt3h7yohG3-3hUdgXs,65 +onnx/backend/test/data/node/test_if/model.onnx,sha256=Kpbswl4zKb87TSAXvwkKrXZ-pz5_FiaP8_q9CBT4q_g,321 +onnx/backend/test/data/node/test_if/test_data_set_0/input_0.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_if/test_data_set_0/output_0.pb,sha256=6Z-sAab-Ll2mHzCTuxkbUjBy_RmQb_4im7xdYzJzlbA,31 +onnx/backend/test/data/node/test_if_opt/model.onnx,sha256=bHltYx2DCg9ppabsHWPOdZ6ovPN8-fRYxKS9kcHBsOU,419 +onnx/backend/test/data/node/test_if_opt/test_data_set_0/input_0.pb,sha256=9kbmn5T_KJnQNPG1ixMvyTnx_50JkgYRl4SGlqjdY00,11 +onnx/backend/test/data/node/test_if_opt/test_data_set_0/output_0.pb,sha256=CD_cSpf7zENvc3TWqcIg_NGBAiNDKNKlQTYwwfMpe04,44 +onnx/backend/test/data/node/test_if_seq/model.onnx,sha256=OzaqxTiIf5D_51--3X-8qhjyGSpDus2SnZ5ez_ImuRc,389 +onnx/backend/test/data/node/test_if_seq/test_data_set_0/input_0.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_if_seq/test_data_set_0/output_0.pb,sha256=nrKwZGW_LIu6T51XGN9q76qgQlPcdYwJp1dZ-icyV8w,35 +onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/model.onnx,sha256=WliphL_oL1UgrTQ1-onJLzDK2VWpGKC1PZv9UYUvpms,165 +onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/test_data_set_0/input_0.pb,sha256=3WphR9u0eYaYc-XgtQK4UjGM2EWmQuMDht0k3NM8pno,3140 +onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/test_data_set_0/output_0.pb,sha256=r6Ad2pCIMQzYmpKqj7lhmrshM4Y3dcEU9S8Zq198uu4,3091 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/model.onnx,sha256=V2srJk-PqZKcghl-dalGTNsCSdQBJT1r_YW370_f5KY,168 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/test_data_set_0/input_0.pb,sha256=FXB7diR3xR4AncihlszYqFi00Nke15j9k_KS2KVWeAI,1901 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/test_data_set_0/output_0.pb,sha256=r6Ad2pCIMQzYmpKqj7lhmrshM4Y3dcEU9S8Zq198uu4,3091 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/model.onnx,sha256=KZTC2Ru7YUTy5NjFmXUTQq-ePrTUJaFBfiVKIeIBFF4,166 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/test_data_set_0/input_0.pb,sha256=jKWRdIilLcY9ra7Mef0dyEutF3bREESbKpY4cmvtSJQ,1072 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/test_data_set_0/output_0.pb,sha256=KTYAFI9diH71TAb3rsZda44mlhUJIwZ_ycbZHHAfLcU,3091 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/model.onnx,sha256=m0y8LkT1za8NIMxf3O1bfv_C3gmNuiwYdusshrHVmXQ,178 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/test_data_set_0/input_0.pb,sha256=jKWRdIilLcY9ra7Mef0dyEutF3bREESbKpY4cmvtSJQ,1072 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/test_data_set_0/output_0.pb,sha256=4H1hbiSnnwUsVmyPLBXa_zr9-g-C-YzTKm65FTR1Oss,1043 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/model.onnx,sha256=QJiqi-SilkGw8BNNNjyYYutAlpKXb0mMJxng8Rk-w-c,166 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/test_data_set_0/input_0.pb,sha256=jKWRdIilLcY9ra7Mef0dyEutF3bREESbKpY4cmvtSJQ,1072 +onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/test_data_set_0/output_0.pb,sha256=vad7ak4qNxXFLEep24zF3V7qbgUwsBhchfYXRgiwaF8,3091 +onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/model.onnx,sha256=Lk8tvz3NDlmWsFgNjpMXCEWobGs325Dvc_iBMp8F9jM,165 +onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/test_data_set_0/input_0.pb,sha256=hc97gZD_jsHH5MsJv_kg1yDuFuv2D7AOBy_cc7wxQVw,326 +onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/test_data_set_0/output_0.pb,sha256=r6Ad2pCIMQzYmpKqj7lhmrshM4Y3dcEU9S8Zq198uu4,3091 +onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/model.onnx,sha256=uHFPiiOb_TqZHQv_8SbuyOpv9D_OWgzPUxKWVnzdLoc,165 +onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/test_data_set_0/input_0.pb,sha256=rpeeyR0Xyhfm7zJsp8FaufpFQOs1bPv63WHw6GKVHms,3099 +onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/test_data_set_0/output_0.pb,sha256=r6Ad2pCIMQzYmpKqj7lhmrshM4Y3dcEU9S8Zq198uu4,3091 +onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/model.onnx,sha256=KYvXOq_PJ6sJ3oFpxmOwxh0e3A-TE10scd2HEGo8Ea8,166 +onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/test_data_set_0/input_0.pb,sha256=lSd_mOxQHA0RvJH_4r8Wf6_idVKu3KGiHDa8qxfqev4,3226 +onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/test_data_set_0/output_0.pb,sha256=r6Ad2pCIMQzYmpKqj7lhmrshM4Y3dcEU9S8Zq198uu4,3091 +onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/model.onnx,sha256=RmXX3Rk82ET7z66fYUlNmsO2TGz0oe49CBUHb3RI7k4,166 +onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/test_data_set_0/input_0.pb,sha256=MdIansNcRXVyK-xR3xH1YeH1H6PGC5J0a13FFNcTffk,566 +onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/test_data_set_0/output_0.pb,sha256=0pMvVMzifzYFw9TGLLCNQwbz1y3sy1s2IO0eV4SsYpA,3091 +onnx/backend/test/data/node/test_instancenorm_epsilon/model.onnx,sha256=5VWEyyePFdsN_NB1bgmaQfvaA8Uaz77SkAF-Z9P871Y,206 +onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_0.pb,sha256=SYKd5PF5vM-bKNrV8oTKPGHvYE0twyvHWdFt3T67zDY,496 +onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_1.pb,sha256=AI-3RnrtRdqYWsuL7R4_zbZ0Vb7zfnaDEBYsm0i2kvY,21 +onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_2.pb,sha256=2oNlXxvO0WnQ0oLXr0SuQwOm4ErOca8R9dkNLwewDK4,24 +onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/output_0.pb,sha256=kViHfy66VxtlADF2mSyn7ORx1duw-RQk1rfI2xGzAf0,496 +onnx/backend/test/data/node/test_instancenorm_example/model.onnx,sha256=vAkJ6_tTVRL-EMnn9-2Kz1Gk5ri22y8UAh0VRJ9nliw,187 +onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_0.pb,sha256=VUIPX62VbmFbVNHPK2_fBC1r_H9D8f-WYOR64GExRxg,39 +onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_1.pb,sha256=LAyTcjTe_XhxYy49mFzDu7kzZbw1weK3MkBpQcDLY7Y,17 +onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_2.pb,sha256=Qr3ZK8mEuzcmIiC7CqVjLO10zP1ZUJSVhf57xgIViJc,20 +onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/output_0.pb,sha256=UXtFI_9wnq2LC-OKKrnRlR7OkEDwtzSz6huAdy3yogI,39 +onnx/backend/test/data/node/test_isinf/model.onnx,sha256=Ex9vI0MtCeoLMMqgxcI6tE_Dwy1_8sl2TSUh-QcK3p4,85 +onnx/backend/test/data/node/test_isinf/test_data_set_0/input_0.pb,sha256=DUSqI3C3X65jGkuhMXunUVTh3fc8Y2RfKVcIgqF2PSI,33 +onnx/backend/test/data/node/test_isinf/test_data_set_0/output_0.pb,sha256=IU0OrIPsDhiQy6zcHECAVjDvfVr6qR_yXQEvoNCEOAQ,15 +onnx/backend/test/data/node/test_isinf_float16/model.onnx,sha256=21EyffqOPA0mw4_IyeP4qxaA_v6dDHcP74Mz0Lsl3tY,93 +onnx/backend/test/data/node/test_isinf_float16/test_data_set_0/input_0.pb,sha256=GzL9GHU-GuROgkjEhBQpi7v5zDspP_CGz6TBesGOmAQ,21 +onnx/backend/test/data/node/test_isinf_float16/test_data_set_0/output_0.pb,sha256=IU0OrIPsDhiQy6zcHECAVjDvfVr6qR_yXQEvoNCEOAQ,15 +onnx/backend/test/data/node/test_isinf_negative/model.onnx,sha256=F48N3xhREkkIfjYZ0l52JgEXFFhpb2BwkS1sF1uIN6A,118 +onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/input_0.pb,sha256=TZCOthXvSS1htnpkqRg4pC6K8OoGrAnxG_8lBZ2_jKk,33 +onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/output_0.pb,sha256=EkxCQSMrh0vkL8zRXyX5wQasiMwKXB41vEbwM-mJ9Sk,15 +onnx/backend/test/data/node/test_isinf_positive/model.onnx,sha256=jSWVzWtPahdbEnkGYKT0NMWkv10gbP6_X9rrT8k3QYI,118 +onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/input_0.pb,sha256=EszjPltq6ca9PXAPoXK2UayVbMS6fQ4AMMUExeYrUZc,33 +onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/output_0.pb,sha256=k8MIxh7aAeuvyLaQHb3xCbJ1zjetTSbQ9jrGyvmdMAA,15 +onnx/backend/test/data/node/test_isnan/model.onnx,sha256=xGcIz2X4lzM8eWIH8SUBVuDzeZcvNvMrU6NDaMvrqo8,85 +onnx/backend/test/data/node/test_isnan/test_data_set_0/input_0.pb,sha256=DUSqI3C3X65jGkuhMXunUVTh3fc8Y2RfKVcIgqF2PSI,33 +onnx/backend/test/data/node/test_isnan/test_data_set_0/output_0.pb,sha256=6w7AlYmICAOPY5SerH7LcWt1NXFIk6l61AOzgFibC3w,15 +onnx/backend/test/data/node/test_isnan_float16/model.onnx,sha256=OHNj0HW8VurC7SGHHtkgZknPOIO0ci4L_p7L9CIBkxU,93 +onnx/backend/test/data/node/test_isnan_float16/test_data_set_0/input_0.pb,sha256=GzL9GHU-GuROgkjEhBQpi7v5zDspP_CGz6TBesGOmAQ,21 +onnx/backend/test/data/node/test_isnan_float16/test_data_set_0/output_0.pb,sha256=6w7AlYmICAOPY5SerH7LcWt1NXFIk6l61AOzgFibC3w,15 +onnx/backend/test/data/node/test_l1normalization_axis_0/model.onnx,sha256=ha_Bnx68amoC25KYZA6OenN657AVfvVCvS4Y1U4f2c4,135 +onnx/backend/test/data/node/test_l1normalization_axis_0/test_data_set_0/input_0.pb,sha256=5m2PEEsKXQbJNrLR6JC_nvLRZCEVZ89U3jSEZ7Zcn2g,17 +onnx/backend/test/data/node/test_l1normalization_axis_0/test_data_set_0/output_0.pb,sha256=rjwKOvvalT3s3-TlovPDXZ2iZCUiSMv3blZS0-aNF0U,17 +onnx/backend/test/data/node/test_l1normalization_axis_1/model.onnx,sha256=OTXxbG0i96Q8PrC9KnzfBx0rlS9bXrp1NjW2gmkk0zk,143 +onnx/backend/test/data/node/test_l1normalization_axis_1/test_data_set_0/input_0.pb,sha256=HZ6hwnX_AEX-8ChmthadrAbOeXpaob1B3rgDefNUzfM,27 +onnx/backend/test/data/node/test_l1normalization_axis_1/test_data_set_0/output_0.pb,sha256=5kf4brbacyhKz7o7zDA5KEOqN74KOThejh9GXTGGtok,27 +onnx/backend/test/data/node/test_l1normalization_axis_last/model.onnx,sha256=RKRFlrgF2fcV5BabIfWugzi4XN5SOpmvbW809JEpxLY,164 +onnx/backend/test/data/node/test_l1normalization_axis_last/test_data_set_0/input_0.pb,sha256=jwDJXEjdzn_x1inv86-W1U1E7SIOArlMB_6yFFNpTOc,61 +onnx/backend/test/data/node/test_l1normalization_axis_last/test_data_set_0/output_0.pb,sha256=PNJvZmeUZUERVF9f8H0S3ybw0y-2TZOg_Pp_mEMUDXs,61 +onnx/backend/test/data/node/test_l2normalization_axis_0/model.onnx,sha256=4rNXpN65cwbP1M03hQS9EYD3P9Zuk9PRzGEhxTPE2R0,151 +onnx/backend/test/data/node/test_l2normalization_axis_0/test_data_set_0/input_0.pb,sha256=jwDJXEjdzn_x1inv86-W1U1E7SIOArlMB_6yFFNpTOc,61 +onnx/backend/test/data/node/test_l2normalization_axis_0/test_data_set_0/output_0.pb,sha256=VfWYekR1P0-d4o-x4GLmUdd2RXHqqeO1emy52_qYJt4,61 +onnx/backend/test/data/node/test_l2normalization_axis_1/model.onnx,sha256=Bl19OR15tgi8GufnC19QWsvBXCYd03ZRYWF2D9klNMU,143 +onnx/backend/test/data/node/test_l2normalization_axis_1/test_data_set_0/input_0.pb,sha256=HZ6hwnX_AEX-8ChmthadrAbOeXpaob1B3rgDefNUzfM,27 +onnx/backend/test/data/node/test_l2normalization_axis_1/test_data_set_0/output_0.pb,sha256=gPbU1g4EBDmMKQv_nwppWlZCVB9JKHs9wY_q3mpYkoM,27 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/model.onnx,sha256=Qu0CT3bG2vP6ou0oyq0FeISUX1PBaBGR3O6yFpUv_P4,261 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_1.pb,sha256=c5v62j2q513u7QaD0Kck1K-O-g3Q6LiJWVgNaVZ3umg,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_2.pb,sha256=LXv8aWQikWfT9D0FYEGMsl-g-FZoYCh4YhCuC_3uprM,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_0.pb,sha256=iVt1SwGe_eyWjGblJNeTU6rlSc-4YC-xkTWTBTmHODI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/model.onnx,sha256=DUxhEduHYmkto1q2Uv_ED0HtSnJ0Hl7aU-3PIS9Veqw,6048 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb,sha256=c5v62j2q513u7QaD0Kck1K-O-g3Q6LiJWVgNaVZ3umg,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_2.pb,sha256=LXv8aWQikWfT9D0FYEGMsl-g-FZoYCh4YhCuC_3uprM,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb,sha256=iVt1SwGe_eyWjGblJNeTU6rlSc-4YC-xkTWTBTmHODI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/model.onnx,sha256=tMjoGfaPiZVV21CHq_LjcOc68zQW8yZ35H-1gxQYvkI,6300 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_1.pb,sha256=c5v62j2q513u7QaD0Kck1K-O-g3Q6LiJWVgNaVZ3umg,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_2.pb,sha256=LXv8aWQikWfT9D0FYEGMsl-g-FZoYCh4YhCuC_3uprM,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_0.pb,sha256=iVt1SwGe_eyWjGblJNeTU6rlSc-4YC-xkTWTBTmHODI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/model.onnx,sha256=sfa3c68-O_GcmBe4JJTF-vU1Y7ITngIUR1G5uPwynfk,253 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_1.pb,sha256=EZKA7ForrN2YairSPGNOCkCyOm1H2fD6otmjaVO4YdQ,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_2.pb,sha256=RbUzETROopB8rHchzsZs6Msdde_nz6eGAAvGd5telR4,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_0.pb,sha256=_7YDN6UEtee83kkh5wsnjvgdzJLyTGqAqlcF1Mig-8s,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/model.onnx,sha256=yiizqo2aVKXpdnyNQtQN9Aaox20FkEpMwkgewv1Qnfk,6040 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb,sha256=EZKA7ForrN2YairSPGNOCkCyOm1H2fD6otmjaVO4YdQ,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_2.pb,sha256=RbUzETROopB8rHchzsZs6Msdde_nz6eGAAvGd5telR4,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb,sha256=_7YDN6UEtee83kkh5wsnjvgdzJLyTGqAqlcF1Mig-8s,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/model.onnx,sha256=-ZUiNrDjVRz4py1EbR--rS26VWfdv9y6fKtQvlYWNHA,6292 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_1.pb,sha256=EZKA7ForrN2YairSPGNOCkCyOm1H2fD6otmjaVO4YdQ,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_2.pb,sha256=RbUzETROopB8rHchzsZs6Msdde_nz6eGAAvGd5telR4,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_0.pb,sha256=_7YDN6UEtee83kkh5wsnjvgdzJLyTGqAqlcF1Mig-8s,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/model.onnx,sha256=pZlPnXiGuXY7ZUkh8lgWBpkktPV_OzY6efzG3KfQpoo,272 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb,sha256=Z9KJWMim8_HHQqx310sN-MwR8HbbppmvpY0Gd7oGIIY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_2.pb,sha256=E-0WQ1hbMoH0mpC3NBjz-AzskpOkxKDYBugpDFckqXY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb,sha256=VnTGQAZfGqzqbsQv6BCWCuKG17-1be_ARnOAG2KQni8,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/model.onnx,sha256=D-htrwW-dU676NZDIItiLrkYjhMTUNmHSFcMiJEs7IQ,6633 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb,sha256=Z9KJWMim8_HHQqx310sN-MwR8HbbppmvpY0Gd7oGIIY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_2.pb,sha256=E-0WQ1hbMoH0mpC3NBjz-AzskpOkxKDYBugpDFckqXY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb,sha256=VnTGQAZfGqzqbsQv6BCWCuKG17-1be_ARnOAG2KQni8,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/model.onnx,sha256=POGSoiJko5Xu7inl9n9LtBqkhkIMpdjOgKZ5Drwrano,6915 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb,sha256=Z9KJWMim8_HHQqx310sN-MwR8HbbppmvpY0Gd7oGIIY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb,sha256=E-0WQ1hbMoH0mpC3NBjz-AzskpOkxKDYBugpDFckqXY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=VnTGQAZfGqzqbsQv6BCWCuKG17-1be_ARnOAG2KQni8,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/model.onnx,sha256=lFCifpXsH80wLKo1i6kqVLL9bL6nZVC6d4EoRp6FCyw,280 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb,sha256=xCO5Odqhx6GmjsUlwlrHLnjfm63TjRJb3rzZndZCYyQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_2.pb,sha256=Pd-TMGMv2FcDr-jRpePp8LPEJICDh8AD1HX04T6MrLI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb,sha256=1QvjVDP3oBuUy26wURfUK_9v8pj-Jr8iXjjvMpm0Lp4,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/model.onnx,sha256=MrIobPhwcsTjlPntx0-XmOZSh2jahDomXYmftvYNOeI,6641 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb,sha256=xCO5Odqhx6GmjsUlwlrHLnjfm63TjRJb3rzZndZCYyQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_2.pb,sha256=Pd-TMGMv2FcDr-jRpePp8LPEJICDh8AD1HX04T6MrLI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb,sha256=1QvjVDP3oBuUy26wURfUK_9v8pj-Jr8iXjjvMpm0Lp4,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/model.onnx,sha256=FT55lf5rew2LfzX4yYFsYutgHfAPJMl2TmTz3kcIg4A,6923 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb,sha256=xCO5Odqhx6GmjsUlwlrHLnjfm63TjRJb3rzZndZCYyQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb,sha256=Pd-TMGMv2FcDr-jRpePp8LPEJICDh8AD1HX04T6MrLI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb,sha256=1QvjVDP3oBuUy26wURfUK_9v8pj-Jr8iXjjvMpm0Lp4,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/model.onnx,sha256=nWu0d8mPuo_q-6EbxNldBgOwAHLI6r82ofpwMOeY3VE,312 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb,sha256=7opcXxjA9jj8tE0kwn6o2zODfFoW-_nJ5TGxMKGx3Fs,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_2.pb,sha256=5PyU6fVFO0EEZAhy7iw-cH3feNNieB9cflROAd5uNrE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb,sha256=v4LJo9woQRls5a_jNs6Rjayjn62ji3ZGj_FOZjvOR6w,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/model.onnx,sha256=0ngaHnVQCQtDLmTPUnsltXdMbsef1Zao-_xztRUrJqg,6600 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb,sha256=7opcXxjA9jj8tE0kwn6o2zODfFoW-_nJ5TGxMKGx3Fs,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_2.pb,sha256=5PyU6fVFO0EEZAhy7iw-cH3feNNieB9cflROAd5uNrE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb,sha256=v4LJo9woQRls5a_jNs6Rjayjn62ji3ZGj_FOZjvOR6w,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/model.onnx,sha256=dlYp8YolSE9qPr-UD8df4ajih6-FKKW4S7wvGSpwwGE,6876 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=7opcXxjA9jj8tE0kwn6o2zODfFoW-_nJ5TGxMKGx3Fs,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=5PyU6fVFO0EEZAhy7iw-cH3feNNieB9cflROAd5uNrE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=v4LJo9woQRls5a_jNs6Rjayjn62ji3ZGj_FOZjvOR6w,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/model.onnx,sha256=L1n3cJ5FYR20w-NL_S3NqlfSja8XnlEEZGDUXF5_Lp4,304 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb,sha256=ZPe50IuXkbPIN0CuON0wV-i4zLn3HPRsxO5bwFT9bkw,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_2.pb,sha256=ZKaykW9NECftmK4UFhp4YwKdZ066BMxKP2xmGzUHx28,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb,sha256=d2aHuLpzy26hKZfRcdjI52hGJm4-Rnvt4OA7yaHmC70,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/model.onnx,sha256=aPdwPxyqI8o_B1EVa074QMWy1LFSRTbDx0hGkB_VWNI,6592 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb,sha256=ZPe50IuXkbPIN0CuON0wV-i4zLn3HPRsxO5bwFT9bkw,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_2.pb,sha256=ZKaykW9NECftmK4UFhp4YwKdZ066BMxKP2xmGzUHx28,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb,sha256=d2aHuLpzy26hKZfRcdjI52hGJm4-Rnvt4OA7yaHmC70,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/model.onnx,sha256=Tf3OQ_KUgR3XL4Q8Uno1nuzP5lghFAUzrUSCNbvqLyk,6868 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=ZPe50IuXkbPIN0CuON0wV-i4zLn3HPRsxO5bwFT9bkw,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=ZKaykW9NECftmK4UFhp4YwKdZ066BMxKP2xmGzUHx28,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=d2aHuLpzy26hKZfRcdjI52hGJm4-Rnvt4OA7yaHmC70,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/model.onnx,sha256=CpeyhCB4UgjtGlVuw-BMJErTR4D3zFHDIZGjjcDBlzE,296 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb,sha256=va8YRICxaQUTR-F6lUfwmRzaiwoaXpFUgZQvNMMtd2Y,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_2.pb,sha256=k3SelyY2T9UlihBpgMkCl7r0uQ1BnbqvAaqnmxhD3BU,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb,sha256=9UZHfb3EbKd1lt9AAGTPK2rFA9w_3PYU1FfL5IMX3aM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/model.onnx,sha256=TcFs6aY6Oar3gTdtyKmzSxynu1bE4j3XLQ746ZeeLQU,6584 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb,sha256=va8YRICxaQUTR-F6lUfwmRzaiwoaXpFUgZQvNMMtd2Y,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_2.pb,sha256=k3SelyY2T9UlihBpgMkCl7r0uQ1BnbqvAaqnmxhD3BU,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb,sha256=9UZHfb3EbKd1lt9AAGTPK2rFA9w_3PYU1FfL5IMX3aM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/model.onnx,sha256=ZwEvYPFp-eSF4B-jfEdEX3aDSTNZdjjo9L4BlwwVVyw,6860 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=va8YRICxaQUTR-F6lUfwmRzaiwoaXpFUgZQvNMMtd2Y,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=k3SelyY2T9UlihBpgMkCl7r0uQ1BnbqvAaqnmxhD3BU,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=9UZHfb3EbKd1lt9AAGTPK2rFA9w_3PYU1FfL5IMX3aM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/model.onnx,sha256=Mgyj5v0-FOddHlPK2b49zSnTzPhLyEM5FiHI5R637uQ,315 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb,sha256=4PBrvKy3rxl13drhLIE5bL7rYJLK7SoYRzFAKTTxLy0,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_2.pb,sha256=QoSWvX-d04Zqaupf99gDg5LEvvIx4A1qA6BgR8pJKMg,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb,sha256=lXpnAlkFz26dL_kmQMXJJBuuk88Vtr6FMhlY7fLtBEY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx,sha256=XURUaN2LvupLmJtwiMxdDYqC93dBWn4aiBVkkFlsYW0,7171 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb,sha256=4PBrvKy3rxl13drhLIE5bL7rYJLK7SoYRzFAKTTxLy0,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_2.pb,sha256=QoSWvX-d04Zqaupf99gDg5LEvvIx4A1qA6BgR8pJKMg,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb,sha256=lXpnAlkFz26dL_kmQMXJJBuuk88Vtr6FMhlY7fLtBEY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/model.onnx,sha256=Czi1LTqxIkTQ2PXFHqbp6R5Z1Y4XXM70c6r_hgc8k7o,7478 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=4PBrvKy3rxl13drhLIE5bL7rYJLK7SoYRzFAKTTxLy0,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=QoSWvX-d04Zqaupf99gDg5LEvvIx4A1qA6BgR8pJKMg,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=lXpnAlkFz26dL_kmQMXJJBuuk88Vtr6FMhlY7fLtBEY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/model.onnx,sha256=tfYuT0x48pO3zOdPvb2af-sgrWXGAtDgigBlY_f2A8E,323 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb,sha256=RsFIHUaVXXkVUuqNiwwNCyD0G-fnbmxu-VtjpWDCr-g,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_2.pb,sha256=sHcZJ9BtHritZi7auxmp2MQdRfb6VioBIMj37gdsuUQ,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb,sha256=OvSGu63DhH8Q6FOw4vCzNGh3CbvdnCI3IWrxEogZ7OM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx,sha256=1aszJdGvZzf6nhA_2iFchJivNtGVEIY3hLsuqQQ-U0U,7179 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb,sha256=RsFIHUaVXXkVUuqNiwwNCyD0G-fnbmxu-VtjpWDCr-g,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_2.pb,sha256=sHcZJ9BtHritZi7auxmp2MQdRfb6VioBIMj37gdsuUQ,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb,sha256=OvSGu63DhH8Q6FOw4vCzNGh3CbvdnCI3IWrxEogZ7OM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/model.onnx,sha256=mXqVqfsfyDeK9O9mvz6w8dBQsW4pScdPJF_aXhD0-EY,7486 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=RsFIHUaVXXkVUuqNiwwNCyD0G-fnbmxu-VtjpWDCr-g,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=sHcZJ9BtHritZi7auxmp2MQdRfb6VioBIMj37gdsuUQ,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=OvSGu63DhH8Q6FOw4vCzNGh3CbvdnCI3IWrxEogZ7OM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/model.onnx,sha256=EsaeIyu7HXxvvWKBbE4MtVCAVtZSc8dLn-xEL_r1WEQ,331 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb,sha256=-_y6ugkVRAuX6VtIyUN56Ja8hsdgc-uYpjQhH9o3wgM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_2.pb,sha256=pL40Oaw2IK9LzoPOZDaP75bc2lI0nDGGPsLMtsEA7CE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb,sha256=_jNYy4sNYdyeP5vTYQs63WW9_PpdR1ObiJalbo7T1rc,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx,sha256=D6LP8qum68kfFVrPWqQpubdeeIJbDzrBY-kkaNgzfRQ,7187 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb,sha256=-_y6ugkVRAuX6VtIyUN56Ja8hsdgc-uYpjQhH9o3wgM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_2.pb,sha256=pL40Oaw2IK9LzoPOZDaP75bc2lI0nDGGPsLMtsEA7CE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb,sha256=_jNYy4sNYdyeP5vTYQs63WW9_PpdR1ObiJalbo7T1rc,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/model.onnx,sha256=-UB36cfKrf0whCnJPy35TDp_2DBfxSt_8Bt_dWcwDGM,7494 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=-_y6ugkVRAuX6VtIyUN56Ja8hsdgc-uYpjQhH9o3wgM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=pL40Oaw2IK9LzoPOZDaP75bc2lI0nDGGPsLMtsEA7CE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=_jNYy4sNYdyeP5vTYQs63WW9_PpdR1ObiJalbo7T1rc,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/model.onnx,sha256=6FTymSB7VUYcPZKAp3b5kYQ87SaZnfg-FQZohEflz3c,309 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_1.pb,sha256=SQ1M8CaJ0qLmcLTvIkOMlgNO0L8HwaXc_m0K26vIbnI,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_2.pb,sha256=__QE7EAq717I04_JG7I_51Z5sC2scQ1_WLMFDvKlhl4,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_0.pb,sha256=oMQtjXP8GiZgJtDBJ1pNz2JI7FdH7M-rQiiT4b63_rY,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/model.onnx,sha256=yzgNEYHW9v9br3Uvujgff1JNa3T_oqsWiRP1T09zcP0,6096 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb,sha256=SQ1M8CaJ0qLmcLTvIkOMlgNO0L8HwaXc_m0K26vIbnI,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_2.pb,sha256=__QE7EAq717I04_JG7I_51Z5sC2scQ1_WLMFDvKlhl4,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb,sha256=oMQtjXP8GiZgJtDBJ1pNz2JI7FdH7M-rQiiT4b63_rY,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/model.onnx,sha256=gCIb_iUdusfUvRyCuxAqngine6lFStpfNZ69Ob9IM5E,6348 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_1.pb,sha256=SQ1M8CaJ0qLmcLTvIkOMlgNO0L8HwaXc_m0K26vIbnI,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_2.pb,sha256=__QE7EAq717I04_JG7I_51Z5sC2scQ1_WLMFDvKlhl4,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_0.pb,sha256=oMQtjXP8GiZgJtDBJ1pNz2JI7FdH7M-rQiiT4b63_rY,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/model.onnx,sha256=hnQKrdk74MuMs4Tg3gWL2wnn6FImP1OfquiXvAdW62g,301 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_1.pb,sha256=7zaL3tDlpElVdcFGJowAUcp6j2Nq_xL1ZjeEUWn73QQ,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_2.pb,sha256=lLuiBlurFP19GIwIpD-S93B2EPY2gV630HErOlKNK-Q,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_0.pb,sha256=SEut2uddWoC5hL8h16RBz-7H9XquUwDwmbYco_WFWEw,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/model.onnx,sha256=jNy7YkdY02dnpplGtFAzO06i_D9fVavlHJo5YFx_hlc,6088 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb,sha256=7zaL3tDlpElVdcFGJowAUcp6j2Nq_xL1ZjeEUWn73QQ,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_2.pb,sha256=lLuiBlurFP19GIwIpD-S93B2EPY2gV630HErOlKNK-Q,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb,sha256=SEut2uddWoC5hL8h16RBz-7H9XquUwDwmbYco_WFWEw,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/model.onnx,sha256=P9ZmRA9zsujJH7q1P2GU2ZhZy7XO_vyTJZ2YBLP6SnI,6340 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_1.pb,sha256=7zaL3tDlpElVdcFGJowAUcp6j2Nq_xL1ZjeEUWn73QQ,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_2.pb,sha256=lLuiBlurFP19GIwIpD-S93B2EPY2gV630HErOlKNK-Q,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_0.pb,sha256=SEut2uddWoC5hL8h16RBz-7H9XquUwDwmbYco_WFWEw,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/model.onnx,sha256=sFRKeanTQ5lDP1B82P-m3otZ3wZLy3bFjx2UASnY-yY,293 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_1.pb,sha256=qe-XVfBNefBCFc7BqwFVPauls8p6xc7Kg_zN9Z7Z37E,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_2.pb,sha256=FJdFCcsdB1KsWHVHfzL8qSH4MOsZeA-MpqXybaSUyj4,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_0.pb,sha256=bZ21DorsMQaEkatMnhbenFA8rDNstpgIdOKwN8CvD30,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/model.onnx,sha256=mVKO0Uefb9JPe411LiAS2tT1MD0uA-b595TyKUVxLEE,6080 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb,sha256=qe-XVfBNefBCFc7BqwFVPauls8p6xc7Kg_zN9Z7Z37E,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_2.pb,sha256=FJdFCcsdB1KsWHVHfzL8qSH4MOsZeA-MpqXybaSUyj4,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb,sha256=bZ21DorsMQaEkatMnhbenFA8rDNstpgIdOKwN8CvD30,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/model.onnx,sha256=K6H8uEh5a0FOxFCaQJPHsxnyj8Js9OL3g7Wcu9onojc,6332 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_1.pb,sha256=qe-XVfBNefBCFc7BqwFVPauls8p6xc7Kg_zN9Z7Z37E,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_2.pb,sha256=FJdFCcsdB1KsWHVHfzL8qSH4MOsZeA-MpqXybaSUyj4,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_0.pb,sha256=bZ21DorsMQaEkatMnhbenFA8rDNstpgIdOKwN8CvD30,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/model.onnx,sha256=f3vB99GHKLnzZ6VMiUiLAYGhsUS_p9rv5q7xLL9arig,285 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_1.pb,sha256=dhPFEwCCeDrZzyZzzTc4B8YdEbZB8eOdvjTBRWTna0o,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_2.pb,sha256=I3r-GMpY-sWqu4lHyIlkD5s7nRziiDkrGNkhZxJ6PpQ,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_0.pb,sha256=ZZgPs-pyo4XnW-gGUahZhyyefO-v_IsCwu4fdYG-jGU,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/model.onnx,sha256=wHnllra7f3F0Yn7bx76ltd0uF4Jo38Bxh9cHiobLFR0,6072 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb,sha256=dhPFEwCCeDrZzyZzzTc4B8YdEbZB8eOdvjTBRWTna0o,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_2.pb,sha256=I3r-GMpY-sWqu4lHyIlkD5s7nRziiDkrGNkhZxJ6PpQ,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb,sha256=ZZgPs-pyo4XnW-gGUahZhyyefO-v_IsCwu4fdYG-jGU,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/model.onnx,sha256=tc5gpKsV8OptgZw0XhllKuJ_e5D23kH9Zba_-PA8hTc,6324 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_1.pb,sha256=dhPFEwCCeDrZzyZzzTc4B8YdEbZB8eOdvjTBRWTna0o,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_2.pb,sha256=I3r-GMpY-sWqu4lHyIlkD5s7nRziiDkrGNkhZxJ6PpQ,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_0.pb,sha256=ZZgPs-pyo4XnW-gGUahZhyyefO-v_IsCwu4fdYG-jGU,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/model.onnx,sha256=73UhfFj6hqI5f7kRWoruEDcfbuEaSx1xviw5cYFsRR4,304 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb,sha256=6GZ_k7Bg5S-sVwagkPPRjF351HRT5efq3L0RXbbFfPo,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_2.pb,sha256=XJX83EpHjA-svtp5ZUT-cGHo6rmxPJPuge7JtGCcIL4,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb,sha256=ZuFfotGGllfUiOngMYM4jmdmjdC-Jrrz9jj9tpFRkzQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/model.onnx,sha256=7PhXg1U9I2yFSYJKePbnKTjGHublQ2h8zflWqeuMuDU,6665 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb,sha256=6GZ_k7Bg5S-sVwagkPPRjF351HRT5efq3L0RXbbFfPo,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_2.pb,sha256=XJX83EpHjA-svtp5ZUT-cGHo6rmxPJPuge7JtGCcIL4,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb,sha256=ZuFfotGGllfUiOngMYM4jmdmjdC-Jrrz9jj9tpFRkzQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/model.onnx,sha256=fl0G-dS-cClTWvnynmx9TjXyx5KKrO4jhlL00yvyoxE,6947 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb,sha256=6GZ_k7Bg5S-sVwagkPPRjF351HRT5efq3L0RXbbFfPo,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb,sha256=XJX83EpHjA-svtp5ZUT-cGHo6rmxPJPuge7JtGCcIL4,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=ZuFfotGGllfUiOngMYM4jmdmjdC-Jrrz9jj9tpFRkzQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/model.onnx,sha256=A2htY41elXdKJX_T2mPfTFyS0GqQWit50Be8HTzM7a4,312 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb,sha256=lldUvoN8cEAHdj14iPu_W2NaWno-DAHLBIhPF_p4Pd8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_2.pb,sha256=IdlwA87uvKYeYSPClPtWIUU9EwPQigWZfgLGhsI5E-8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb,sha256=asFNXrgO-KAfHYrriGkiIwAWBnnnEv6efe4rmSzGxIQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/model.onnx,sha256=pF9o1Z9It45xK3tp6cYAld9W76DFjgGbAevaW6WotEY,6673 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb,sha256=lldUvoN8cEAHdj14iPu_W2NaWno-DAHLBIhPF_p4Pd8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_2.pb,sha256=IdlwA87uvKYeYSPClPtWIUU9EwPQigWZfgLGhsI5E-8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb,sha256=asFNXrgO-KAfHYrriGkiIwAWBnnnEv6efe4rmSzGxIQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/model.onnx,sha256=8Y-ybd42hcymPB_-xOT7GF0u6VtKzQypdE97bEGFX_Y,6955 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb,sha256=lldUvoN8cEAHdj14iPu_W2NaWno-DAHLBIhPF_p4Pd8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb,sha256=IdlwA87uvKYeYSPClPtWIUU9EwPQigWZfgLGhsI5E-8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb,sha256=asFNXrgO-KAfHYrriGkiIwAWBnnnEv6efe4rmSzGxIQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/model.onnx,sha256=VNCqFZoNsJFTB0ngEmUrJH1xWBQz_NgmSPvTEir5W0w,320 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb,sha256=Gq90Mctuyji8qFBteJmVpb2Hrpyq8LdiSb3PnC7udRs,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_2.pb,sha256=HF2D2CKuGbjo2s8uM5wNXzz7x55YyplI1OBvIXzUr2g,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb,sha256=l5U23ab2-R8Md6IYMyC72oD0P2uU52TH0JhH_VPDIA0,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/model.onnx,sha256=Kby-ajsIb_vu3rEUCBYufMh2qVybDA7iRnakIPqUqhc,6681 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb,sha256=Gq90Mctuyji8qFBteJmVpb2Hrpyq8LdiSb3PnC7udRs,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_2.pb,sha256=HF2D2CKuGbjo2s8uM5wNXzz7x55YyplI1OBvIXzUr2g,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb,sha256=l5U23ab2-R8Md6IYMyC72oD0P2uU52TH0JhH_VPDIA0,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/model.onnx,sha256=nRuSFMXeVKgz0etyhiyLfadJW1Azl8Y7xaGnwBjg9No,6963 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_1.pb,sha256=Gq90Mctuyji8qFBteJmVpb2Hrpyq8LdiSb3PnC7udRs,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_2.pb,sha256=HF2D2CKuGbjo2s8uM5wNXzz7x55YyplI1OBvIXzUr2g,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_0.pb,sha256=l5U23ab2-R8Md6IYMyC72oD0P2uU52TH0JhH_VPDIA0,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/model.onnx,sha256=70k7y1Dw1jZs9VJuQpe1maGoy9T8ZBGvVFF7ufVF5NU,328 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb,sha256=pjzWsxYof-fpDuo60I8TJ_IoOXGfsn9uGNzmD-dqse8,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_2.pb,sha256=F4lODpYxgJ7bw__BS9HzQiEIvcezx2NAUr-bdpeWLME,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb,sha256=CNZnGSYfMqynnB9RBPfSfz0Z107X_uZQ5YyxsQHrZPo,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/model.onnx,sha256=4kuJXvNy2sKGNjaWL-_137AAKHEwKq985u-YXKNKGKo,6689 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb,sha256=pjzWsxYof-fpDuo60I8TJ_IoOXGfsn9uGNzmD-dqse8,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_2.pb,sha256=F4lODpYxgJ7bw__BS9HzQiEIvcezx2NAUr-bdpeWLME,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb,sha256=CNZnGSYfMqynnB9RBPfSfz0Z107X_uZQ5YyxsQHrZPo,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/model.onnx,sha256=NW8yWja0CKsEwYw_M9mHJ0nj-Jc5dVEXcO5foPKFQcU,6971 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_1.pb,sha256=pjzWsxYof-fpDuo60I8TJ_IoOXGfsn9uGNzmD-dqse8,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_2.pb,sha256=F4lODpYxgJ7bw__BS9HzQiEIvcezx2NAUr-bdpeWLME,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_0.pb,sha256=CNZnGSYfMqynnB9RBPfSfz0Z107X_uZQ5YyxsQHrZPo,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_default_axis/model.onnx,sha256=b_2kEk9Ayq6XBTG-oSOrfJFe_FKs_ZyYmWkU9OxDOSU,276 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_2.pb,sha256=XsRGoQhLOWNEyIeZqVVjYnHk4mZKF8lajaF9UI8GZts,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_0.pb,sha256=RfWw3_rb9bhFMIefbpqMRHBeSAkrDZx9kMlblgbFlT8,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/model.onnx,sha256=TDt2_Jc5tCXHj2l5O7QY9-ItZFhp2rUg2XN88nXzgBc,6273 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_2.pb,sha256=XsRGoQhLOWNEyIeZqVVjYnHk4mZKF8lajaF9UI8GZts,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_0.pb,sha256=RfWw3_rb9bhFMIefbpqMRHBeSAkrDZx9kMlblgbFlT8,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/model.onnx,sha256=HO6zcuo5N3mdS6EXK2OYuFoECMlKUYJhfOxhZw232DE,6537 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_2.pb,sha256=XsRGoQhLOWNEyIeZqVVjYnHk4mZKF8lajaF9UI8GZts,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=RfWw3_rb9bhFMIefbpqMRHBeSAkrDZx9kMlblgbFlT8,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_leakyrelu/model.onnx,sha256=_22Ni5RQMG7uIlr6XEeVpMPtd6m-wghY5OPw7MX_Z0o,126 +onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/output_0.pb,sha256=HL5T46BD6dJDcU8eZMF5Lm5I4maShdEDBguWdgLux3c,254 +onnx/backend/test/data/node/test_leakyrelu_default/model.onnx,sha256=I1tKwPadbD9YaefW-ZBgElwp3GNleBeR8pzzGqi0PA0,117 +onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/output_0.pb,sha256=n198khm90YbTozNWp1IATonknkccZtYunsb6PRQA_hU,254 +onnx/backend/test/data/node/test_leakyrelu_default_expanded/model.onnx,sha256=pc1KytIHlwlrT6uSt0Aar9M3KrHiUadTpnjEmhAKaf4,996 +onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/output_0.pb,sha256=n198khm90YbTozNWp1IATonknkccZtYunsb6PRQA_hU,254 +onnx/backend/test/data/node/test_leakyrelu_example/model.onnx,sha256=4uswPgT5c4NX9AAy8k97e9wHTixFkyH3MI35Ea63G3o,118 +onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/output_0.pb,sha256=MY0cN1MP7gOByzkKkJceoWxHG-kwUcs4D8IgLgDgXdo,21 +onnx/backend/test/data/node/test_leakyrelu_example_expanded/model.onnx,sha256=HqNSxSkEqZ4H6f2T-afxoG18D1pwpNVVzgBZgQLHBlo,980 +onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/output_0.pb,sha256=MY0cN1MP7gOByzkKkJceoWxHG-kwUcs4D8IgLgDgXdo,21 +onnx/backend/test/data/node/test_leakyrelu_expanded/model.onnx,sha256=m3NuI8g_U_7Czdc9tX1bnLwAaSoohmMDg3cgl6gdock,887 +onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/output_0.pb,sha256=HL5T46BD6dJDcU8eZMF5Lm5I4maShdEDBguWdgLux3c,254 +onnx/backend/test/data/node/test_less/model.onnx,sha256=VarII_RAwHj31PsI-Pxtwxnn9uJ3impXIoeHdX8xupU,133 +onnx/backend/test/data/node/test_less/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_less/test_data_set_0/output_0.pb,sha256=oLRYA8-ghpFNYXX8_SU6S82c8LMGyLC3hcXpYcRAegA,76 +onnx/backend/test/data/node/test_less_bcast/model.onnx,sha256=iTJmFimcwmkhrembVS2cERHKyTfUr2y2cFiOo3AAbMI,131 +onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_less_bcast/test_data_set_0/output_0.pb,sha256=ISvgvc7TKhgnUzs1arbsFxBlMJnFlb3SSY3MxVCm2NU,76 +onnx/backend/test/data/node/test_less_equal/model.onnx,sha256=G7cUKwHYYg_vsrRmj_m_BQXHzgjG_OYxEGAdhDxDid4,159 +onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_less_equal/test_data_set_0/output_0.pb,sha256=6KQRJD-Zzbqgjq8LLBi1XYJ2HcB9SkzS4oPm8hDTT3U,82 +onnx/backend/test/data/node/test_less_equal_bcast/model.onnx,sha256=R73v6AOmEUmMTYS4DEzM6rgp89TErgdIpAzq3GcDdfU,157 +onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/output_0.pb,sha256=6OSOoce2x4z76WkKaCJFJbNncAEOkLSY8hY7Mp7kfNk,82 +onnx/backend/test/data/node/test_less_equal_bcast_expanded/model.onnx,sha256=4ArSKpbhsIhQh51IyTmlp2jxRjtlRmWYhxJEZWDmhSs,411 +onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/output_0.pb,sha256=6OSOoce2x4z76WkKaCJFJbNncAEOkLSY8hY7Mp7kfNk,82 +onnx/backend/test/data/node/test_less_equal_expanded/model.onnx,sha256=jCJ-6W4caO1SFch4j0QbuPwSEd4GVRJHcwhwBGxeWKU,388 +onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/output_0.pb,sha256=6KQRJD-Zzbqgjq8LLBi1XYJ2HcB9SkzS4oPm8hDTT3U,82 +onnx/backend/test/data/node/test_less_equal_int16/model.onnx,sha256=CQIySlFi-Ksbk3IUYEZdzsUJJkFuVTfW_eh8Yq0FTVI,165 +onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/input_0.pb,sha256=Ekql9F2JGxauMyWYy99gddONneZ2JokRhXRqh_ztXu4,133 +onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/input_1.pb,sha256=dUS9xcKbE8wAvizR5u89BuWnwC5Zhz2AIMRDLX_pstE,133 +onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/output_0.pb,sha256=id8Q85Ngie76yYcYZusYfu9XW_6TRRhnSIohWHYr1As,82 +onnx/backend/test/data/node/test_less_equal_int16_expanded/model.onnx,sha256=ReF0A8wxjNO4bU0U_K2GkcGGGMox9Q63_ETQoxVr5Kw,419 +onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/input_0.pb,sha256=Ekql9F2JGxauMyWYy99gddONneZ2JokRhXRqh_ztXu4,133 +onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/input_1.pb,sha256=dUS9xcKbE8wAvizR5u89BuWnwC5Zhz2AIMRDLX_pstE,133 +onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/output_0.pb,sha256=id8Q85Ngie76yYcYZusYfu9XW_6TRRhnSIohWHYr1As,82 +onnx/backend/test/data/node/test_less_equal_int8/model.onnx,sha256=bjS-k4P925Nl4XwRcdzw38jS5jQWlIJCXsCnd4othrw,164 +onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/input_0.pb,sha256=SUfAIaLamboMcY2-6yJ-_6YzOqUCXuVs-Af-4P9PAGE,73 +onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/input_1.pb,sha256=KrQQ7amyE7zfznGiNWekeRtnQSqyTLrM9tZSsbdVkpY,73 +onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/output_0.pb,sha256=x8H9W8q0_6xrJbJdpD4g48ZRzyWAU5y3Bwd8noavA6A,82 +onnx/backend/test/data/node/test_less_equal_int8_expanded/model.onnx,sha256=fceq1ERvTxZptqeZVKDdLya9qITg5lknwuxjVVOnV1c,414 +onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/input_0.pb,sha256=SUfAIaLamboMcY2-6yJ-_6YzOqUCXuVs-Af-4P9PAGE,73 +onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/input_1.pb,sha256=KrQQ7amyE7zfznGiNWekeRtnQSqyTLrM9tZSsbdVkpY,73 +onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/output_0.pb,sha256=x8H9W8q0_6xrJbJdpD4g48ZRzyWAU5y3Bwd8noavA6A,82 +onnx/backend/test/data/node/test_less_equal_uint16/model.onnx,sha256=Y8W4RBBS2HouDacwCeZQOwR-jqJuPu1ZiFjBNl3lgKs,166 +onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/input_0.pb,sha256=Z8XKkVlB3GZlM-rOR7o7J0Tz1FBTJk-4q6p9lQzT4m4,133 +onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/input_1.pb,sha256=pJ8Bp5eLLQBM0rI9BGkmX_4_nLu9d2VBRQ-rVXXzqCY,133 +onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/output_0.pb,sha256=mdtdBrbqMdcoD9KKOovr9MBx-7rbhVTQHRk_KUqQJL0,82 +onnx/backend/test/data/node/test_less_equal_uint16_expanded/model.onnx,sha256=QJcFFbdSP-bXpuZciYK_K07LaqeeKWQlmkUpDV-hkS8,424 +onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/input_0.pb,sha256=Z8XKkVlB3GZlM-rOR7o7J0Tz1FBTJk-4q6p9lQzT4m4,133 +onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/input_1.pb,sha256=pJ8Bp5eLLQBM0rI9BGkmX_4_nLu9d2VBRQ-rVXXzqCY,133 +onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/output_0.pb,sha256=mdtdBrbqMdcoD9KKOovr9MBx-7rbhVTQHRk_KUqQJL0,82 +onnx/backend/test/data/node/test_less_equal_uint32/model.onnx,sha256=gIEA5zb45GWVCKIm7-5oMTl_nVFu3MN-wW6rFZYEEc8,166 +onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/input_0.pb,sha256=D0JYWd_ZrvIAvE4r1pPzdOXpwzQVpKYhokUKUa6gRGU,254 +onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/input_1.pb,sha256=ZIaVDbRokYroC0nnM8S1_AzhW5esgMj9EFgFdiIer9Q,254 +onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/output_0.pb,sha256=Y3_ooFVLvFrkKWe5SD1uhdysIifk-CbL8k03EmfqKos,82 +onnx/backend/test/data/node/test_less_equal_uint32_expanded/model.onnx,sha256=VV0pasEzuL4w0JmsUDQekb3BnhZaFZKgeXLPSSFnxpk,424 +onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/input_0.pb,sha256=D0JYWd_ZrvIAvE4r1pPzdOXpwzQVpKYhokUKUa6gRGU,254 +onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/input_1.pb,sha256=ZIaVDbRokYroC0nnM8S1_AzhW5esgMj9EFgFdiIer9Q,254 +onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/output_0.pb,sha256=Y3_ooFVLvFrkKWe5SD1uhdysIifk-CbL8k03EmfqKos,82 +onnx/backend/test/data/node/test_less_equal_uint64/model.onnx,sha256=5wiKLt2Lm6TttABu2MUZaYC4gubzm-_R0LaOLw6QXxw,166 +onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/input_0.pb,sha256=CD_WyZi4lAYk0qAg-z1tjmzD2Q1uA4oZJan-D3y7Gnk,494 +onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/input_1.pb,sha256=TlyupIqUTNNgvP-nfm2KjUCrtptWOnXDF7Tcln315iY,494 +onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/output_0.pb,sha256=AGY36eK_Ak6X5uwiTEv3L0Z-ns7TbAqwIaAYDaMZ_WU,82 +onnx/backend/test/data/node/test_less_equal_uint64_expanded/model.onnx,sha256=ujPv7vqt3dEgb_gFJKxYqtuHGXkFn1DXPIkBmxUQZPE,424 +onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/input_0.pb,sha256=CD_WyZi4lAYk0qAg-z1tjmzD2Q1uA4oZJan-D3y7Gnk,494 +onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/input_1.pb,sha256=TlyupIqUTNNgvP-nfm2KjUCrtptWOnXDF7Tcln315iY,494 +onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/output_0.pb,sha256=AGY36eK_Ak6X5uwiTEv3L0Z-ns7TbAqwIaAYDaMZ_WU,82 +onnx/backend/test/data/node/test_less_equal_uint8/model.onnx,sha256=T4Byt28D5is0osbxCu5Gutb6cO_-5x-lZLGjc_JzBHc,165 +onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/input_0.pb,sha256=OtZmydXMzIfhfiXHFc5c2ZuPImAkezOnRWnK5t8lPQM,73 +onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/input_1.pb,sha256=CIZ-pKNPQzrHKtM8Sp3Gf97XG7qGYd8h9wUit4PPVRw,73 +onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/output_0.pb,sha256=57aoRILzA9gyBgHPN_1AuPb78CMkJJDDBPFq9ym_cCs,82 +onnx/backend/test/data/node/test_less_equal_uint8_expanded/model.onnx,sha256=ovM1_fuBzfXnDeT6-x2YXmnDQvk8iFrVGQh2euSR5KI,419 +onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/input_0.pb,sha256=OtZmydXMzIfhfiXHFc5c2ZuPImAkezOnRWnK5t8lPQM,73 +onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/input_1.pb,sha256=CIZ-pKNPQzrHKtM8Sp3Gf97XG7qGYd8h9wUit4PPVRw,73 +onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/output_0.pb,sha256=57aoRILzA9gyBgHPN_1AuPb78CMkJJDDBPFq9ym_cCs,82 +onnx/backend/test/data/node/test_less_int16/model.onnx,sha256=EZKrc4qZ7BJsXKEO5ZwiMNgrd6pbftCgEQC3r6_jkqQ,139 +onnx/backend/test/data/node/test_less_int16/test_data_set_0/input_0.pb,sha256=Ekql9F2JGxauMyWYy99gddONneZ2JokRhXRqh_ztXu4,133 +onnx/backend/test/data/node/test_less_int16/test_data_set_0/input_1.pb,sha256=dUS9xcKbE8wAvizR5u89BuWnwC5Zhz2AIMRDLX_pstE,133 +onnx/backend/test/data/node/test_less_int16/test_data_set_0/output_0.pb,sha256=jkXNtO9TKoQIfaQ_Mg3sx5Dv_7R7k6M2PsZ1AnNJSu0,76 +onnx/backend/test/data/node/test_less_int8/model.onnx,sha256=2UaS-pgC5Oy9PTjKUihHl19yRtuvKASgY8WYiII-M0Q,138 +onnx/backend/test/data/node/test_less_int8/test_data_set_0/input_0.pb,sha256=SUfAIaLamboMcY2-6yJ-_6YzOqUCXuVs-Af-4P9PAGE,73 +onnx/backend/test/data/node/test_less_int8/test_data_set_0/input_1.pb,sha256=KrQQ7amyE7zfznGiNWekeRtnQSqyTLrM9tZSsbdVkpY,73 +onnx/backend/test/data/node/test_less_int8/test_data_set_0/output_0.pb,sha256=zOOR0xPeQdk3XAx5Q8ZLVFSLGHpcj32QwH20xqHYzGA,76 +onnx/backend/test/data/node/test_less_uint16/model.onnx,sha256=Lc7nrd7ObRgPP5mZdNG2yl8dVaac3hYnRf5I1wRD18s,140 +onnx/backend/test/data/node/test_less_uint16/test_data_set_0/input_0.pb,sha256=Z8XKkVlB3GZlM-rOR7o7J0Tz1FBTJk-4q6p9lQzT4m4,133 +onnx/backend/test/data/node/test_less_uint16/test_data_set_0/input_1.pb,sha256=pJ8Bp5eLLQBM0rI9BGkmX_4_nLu9d2VBRQ-rVXXzqCY,133 +onnx/backend/test/data/node/test_less_uint16/test_data_set_0/output_0.pb,sha256=RDAisVpEJObMKsxbxuS3khKnxNbKWtHEqu_rhhKfY9s,76 +onnx/backend/test/data/node/test_less_uint32/model.onnx,sha256=5Z5Kk6Iza6UWzWvr_x3LeCficovpXEDDHAJbUck13kw,140 +onnx/backend/test/data/node/test_less_uint32/test_data_set_0/input_0.pb,sha256=D0JYWd_ZrvIAvE4r1pPzdOXpwzQVpKYhokUKUa6gRGU,254 +onnx/backend/test/data/node/test_less_uint32/test_data_set_0/input_1.pb,sha256=ZIaVDbRokYroC0nnM8S1_AzhW5esgMj9EFgFdiIer9Q,254 +onnx/backend/test/data/node/test_less_uint32/test_data_set_0/output_0.pb,sha256=S7A3UcOYcIwmTB2rhpLyLkMrOSiGxNT0eQDB7wNw_ZY,76 +onnx/backend/test/data/node/test_less_uint64/model.onnx,sha256=nGSjLvade9U_RcxLiFSG9I39r5tITQphjBidFvulnPY,140 +onnx/backend/test/data/node/test_less_uint64/test_data_set_0/input_0.pb,sha256=CD_WyZi4lAYk0qAg-z1tjmzD2Q1uA4oZJan-D3y7Gnk,494 +onnx/backend/test/data/node/test_less_uint64/test_data_set_0/input_1.pb,sha256=TlyupIqUTNNgvP-nfm2KjUCrtptWOnXDF7Tcln315iY,494 +onnx/backend/test/data/node/test_less_uint64/test_data_set_0/output_0.pb,sha256=4ja_HYROSSaptwJiJykcb-77JV63OpAdK5VSt2HxSwg,76 +onnx/backend/test/data/node/test_less_uint8/model.onnx,sha256=lpYKrOloWKief4NzvUC9TYmdr3KdGHoiLSwlUEKmmig,139 +onnx/backend/test/data/node/test_less_uint8/test_data_set_0/input_0.pb,sha256=OtZmydXMzIfhfiXHFc5c2ZuPImAkezOnRWnK5t8lPQM,73 +onnx/backend/test/data/node/test_less_uint8/test_data_set_0/input_1.pb,sha256=CIZ-pKNPQzrHKtM8Sp3Gf97XG7qGYd8h9wUit4PPVRw,73 +onnx/backend/test/data/node/test_less_uint8/test_data_set_0/output_0.pb,sha256=UaBky3iFb5nOBhuff4rLX2EVdnbABQf6_6iLMQpISUM,76 +onnx/backend/test/data/node/test_linear_attention_decode_step/model.onnx,sha256=WHMSUyGBCoWaCo2S1c2f8toIAWDoGNXepjAotE4hfh8,438 +onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_0.pb,sha256=s_Cut8lBkFYPi555Sj-4eU0o3jVqzWWdUC4ZqHE9WDE,274 +onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_1.pb,sha256=wfvHIJwCvxzB9zVx9a991sJPP17_WGX3LovKPgrRfBM,272 +onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_2.pb,sha256=s5qJI-hgIMr8XTrlhJiZev7d7382JcCnwwSaoUi--I4,274 +onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_3.pb,sha256=lajT70FCE9c-h5sYj0o6Ft46SpukzA2ZffLoDtCUWqk,2073 +onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_4.pb,sha256=G_jk7bL_J_hFY_xx7cxHvvjY2WfHAXE4VNMN2MiBW3w,274 +onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_5.pb,sha256=-Rq2_B9MiJraH-ATQxUSqxGyK9xjl4B74ppboCqOx3A,48 +onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/output_0.pb,sha256=nnmBOS8eFmhU2iCERSYPWSwKBryHQam350sy6KFM_UE,275 +onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/output_1.pb,sha256=Tt1pbh8oB-lD-VPWBE8inMul02jKoxTEzXw0BxzLYik,2076 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/model.onnx,sha256=cGIOdvmApYWtE2_duHUOFtsv1PjsSf46IFzZobCVS7I,12824 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_0.pb,sha256=s_Cut8lBkFYPi555Sj-4eU0o3jVqzWWdUC4ZqHE9WDE,274 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_1.pb,sha256=wfvHIJwCvxzB9zVx9a991sJPP17_WGX3LovKPgrRfBM,272 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_2.pb,sha256=s5qJI-hgIMr8XTrlhJiZev7d7382JcCnwwSaoUi--I4,274 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_3.pb,sha256=lajT70FCE9c-h5sYj0o6Ft46SpukzA2ZffLoDtCUWqk,2073 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_4.pb,sha256=G_jk7bL_J_hFY_xx7cxHvvjY2WfHAXE4VNMN2MiBW3w,274 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_5.pb,sha256=-Rq2_B9MiJraH-ATQxUSqxGyK9xjl4B74ppboCqOx3A,48 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/output_0.pb,sha256=nnmBOS8eFmhU2iCERSYPWSwKBryHQam350sy6KFM_UE,275 +onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/output_1.pb,sha256=Tt1pbh8oB-lD-VPWBE8inMul02jKoxTEzXw0BxzLYik,2076 +onnx/backend/test/data/node/test_linear_attention_delta/model.onnx,sha256=mQKJiZqSF7Q7REz3iGJ8lrl4xHBZabPWadvDtydvaP8,376 +onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_3.pb,sha256=E2Yy0MN933kzhnAD3FAfYfG54pkTRS_akKP7wf9cMsw,145 +onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/output_0.pb,sha256=XCLpRgbCIB59Ed6xv1H_Eo0szKO8bvmjrBG5pzHttfA,1043 +onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/output_1.pb,sha256=_ec5DSja18Y6umLNReAOUbMN-4MeX9DeLDAlW8lXTo0,2076 +onnx/backend/test/data/node/test_linear_attention_delta_expanded/model.onnx,sha256=MuuoorQlA_dcrF8XqcIktua2_9kK13YqKwjMYbf6Zxk,11036 +onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_3.pb,sha256=E2Yy0MN933kzhnAD3FAfYfG54pkTRS_akKP7wf9cMsw,145 +onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/output_0.pb,sha256=XCLpRgbCIB59Ed6xv1H_Eo0szKO8bvmjrBG5pzHttfA,1043 +onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/output_1.pb,sha256=_ec5DSja18Y6umLNReAOUbMN-4MeX9DeLDAlW8lXTo0,2076 +onnx/backend/test/data/node/test_linear_attention_explicit_scale/model.onnx,sha256=SY1EGDHSb3rCVzxOrls1xaZpnZSat-7RcruloJSX3hE,411 +onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_3.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_4.pb,sha256=zUyUjLk937LkJEKxxGcFvld6b5W7jiXdd7YmWptB52g,145 +onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/output_0.pb,sha256=xRTGeDXrhomP5pP5SZzJqJzyhwb_3X-3kBX0VM1T5tA,1043 +onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/output_1.pb,sha256=bVMOabF-LZDcIRnUEdNSEsIuC_YkOtsTXidTZdD0n0s,2076 +onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/model.onnx,sha256=4K2IAEMpL_Iyx0Tx6aD21KA7XpM17GP_TFmfR00iqPU,13126 +onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_3.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_4.pb,sha256=zUyUjLk937LkJEKxxGcFvld6b5W7jiXdd7YmWptB52g,145 +onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/output_0.pb,sha256=xRTGeDXrhomP5pP5SZzJqJzyhwb_3X-3kBX0VM1T5tA,1043 +onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/output_1.pb,sha256=bVMOabF-LZDcIRnUEdNSEsIuC_YkOtsTXidTZdD0n0s,2076 +onnx/backend/test/data/node/test_linear_attention_fp16/model.onnx,sha256=cAb6Eq4-VmmlFK4rWWpLvXYg399sTNWEfqkFi6yTrdw,383 +onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_0.pb,sha256=jbM0Z0jFSuA3EZpMr1T3dMHepCAq29nPlywGjcsN1t8,1042 +onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_1.pb,sha256=35qsZWqvOTkXV2Jfia4fVY85lABdAIY2tvyF5LNwYtA,528 +onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_2.pb,sha256=MF58TfDPZcTzBd4QPX2TAwbIS2WSkv9Bz9Fb7d1lIPg,530 +onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_3.pb,sha256=GBE57ZbOmbQqcNKRBi_wzHiQmVGQD7iQTQIlG-kkpBw,530 +onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_4.pb,sha256=RKZ3P1UaCXMuvm4qenTauAMzX3ovj7-0p9rIp-ukqDk,80 +onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/output_0.pb,sha256=bO-6bQOcCymm_2D6RdSE_0_Z1nvMmT08VLCQiH3TtvQ,1043 +onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/output_1.pb,sha256=yBXll1gDatR_-2iXSe_WAiG8WGW64RTeFtLhmVAcsWE,1052 +onnx/backend/test/data/node/test_linear_attention_fp16_expanded/model.onnx,sha256=TPG6OarTS3P1qkRK8tCeYnImkxiGB8c7novD--6qqlk,13970 +onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_0.pb,sha256=jbM0Z0jFSuA3EZpMr1T3dMHepCAq29nPlywGjcsN1t8,1042 +onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_1.pb,sha256=35qsZWqvOTkXV2Jfia4fVY85lABdAIY2tvyF5LNwYtA,528 +onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_2.pb,sha256=MF58TfDPZcTzBd4QPX2TAwbIS2WSkv9Bz9Fb7d1lIPg,530 +onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_3.pb,sha256=GBE57ZbOmbQqcNKRBi_wzHiQmVGQD7iQTQIlG-kkpBw,530 +onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_4.pb,sha256=RKZ3P1UaCXMuvm4qenTauAMzX3ovj7-0p9rIp-ukqDk,80 +onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/output_0.pb,sha256=bO-6bQOcCymm_2D6RdSE_0_Z1nvMmT08VLCQiH3TtvQ,1043 +onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/output_1.pb,sha256=yBXll1gDatR_-2iXSe_WAiG8WGW64RTeFtLhmVAcsWE,1052 +onnx/backend/test/data/node/test_linear_attention_gated/model.onnx,sha256=_Cd7WAB_cne8GcZ8nsHMCM0cT1EBza2orqZGF1lZ_-E,376 +onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_1.pb,sha256=s91li6kYxzvQj117tTxgVm_M2Oi9z_Tv3Xshlba_K6E,1040 +onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_3.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/output_0.pb,sha256=qKNa8fKHJhs0J87WYNe0VFDq68BaVuYIJWwnexyssUA,1043 +onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/output_1.pb,sha256=SziikkmyRHgbD-Rh2BU7z4FUbAGgYXs61kKEJv4GKDk,2076 +onnx/backend/test/data/node/test_linear_attention_gated_delta/model.onnx,sha256=G7jB2uY7JIADadfCXfTfaQQ-9lR3mGQ_GJcE2xXr7-k,390 +onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_3.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_4.pb,sha256=zUyUjLk937LkJEKxxGcFvld6b5W7jiXdd7YmWptB52g,145 +onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/output_0.pb,sha256=0pGr1gZEDXHDvYt5JtxCVXmE6jxotvM1MiTkQAZW4w8,1043 +onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/output_1.pb,sha256=bVMOabF-LZDcIRnUEdNSEsIuC_YkOtsTXidTZdD0n0s,2076 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/model.onnx,sha256=-uyrlVDhKgactH9vL7F8TYxsQgEXJ9lXaYBTn5eZf8w,402 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_3.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_4.pb,sha256=muWsjMC2ZpGOIhucWZBJY46K1GHyVctc-LIRiyxIv6I,48 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/output_0.pb,sha256=9ofBBr3xzFOpubyjzYLU08HRYAEvK8TeVkjV3obgglU,1043 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/output_1.pb,sha256=okbJhwaMm-66vccGOzmzewgHsJQIUy3znBqF1apGuGI,2076 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/model.onnx,sha256=GS4Bwcrokl-O7o-T04dTd1faQxxoOVtwn87tGEUPdpA,15068 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_3.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_4.pb,sha256=muWsjMC2ZpGOIhucWZBJY46K1GHyVctc-LIRiyxIv6I,48 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/output_0.pb,sha256=9ofBBr3xzFOpubyjzYLU08HRYAEvK8TeVkjV3obgglU,1043 +onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/output_1.pb,sha256=okbJhwaMm-66vccGOzmzewgHsJQIUy3znBqF1apGuGI,2076 +onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/model.onnx,sha256=1yxzYbqqXablIHpcqv7aaBOzCnzmnuNVoiDAxPRdaiw,13262 +onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_3.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_4.pb,sha256=zUyUjLk937LkJEKxxGcFvld6b5W7jiXdd7YmWptB52g,145 +onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/output_0.pb,sha256=0pGr1gZEDXHDvYt5JtxCVXmE6jxotvM1MiTkQAZW4w8,1043 +onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/output_1.pb,sha256=bVMOabF-LZDcIRnUEdNSEsIuC_YkOtsTXidTZdD0n0s,2076 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/model.onnx,sha256=x7Q2_k5-bXtSMImJ6oy5FvwDoGPRQJdCRR9C6xWOa5Q,394 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_0.pb,sha256=3T5lWOmPg-hQKigzioKb3lTCL8TpLxlLXvPQCLEu7zw,2066 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_1.pb,sha256=xc-U-z9mU7qa3nwVJuwCOrrcU--C6-5ZbKbpHGjx9NM,1040 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_2.pb,sha256=e12kgKN0zdBRqPXncS5_6QN5AQlA6mvG8Cj-LJK0upU,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_3.pb,sha256=kaTdiMVv2E0mfApRIScR0FmyX4rNie1tYm2cS4Po10A,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_4.pb,sha256=p6T9M62Fbk2qsM54eM-oQRobcGEkLlXT7-GtV64dFqM,145 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/output_0.pb,sha256=yGzRcI4PJTh1MiHxZyTibqgPyPpjRxKLzEj6DWm7pi4,2067 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/output_1.pb,sha256=5xju0484rOCBOAVNfgbfGGQPrAN-834j14tgZCaNUqg,2076 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/model.onnx,sha256=ewMc2jwLofBFF_jdNInPGvdmFHmwUg-dbACGWYfux0w,15862 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_0.pb,sha256=3T5lWOmPg-hQKigzioKb3lTCL8TpLxlLXvPQCLEu7zw,2066 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_1.pb,sha256=xc-U-z9mU7qa3nwVJuwCOrrcU--C6-5ZbKbpHGjx9NM,1040 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_2.pb,sha256=e12kgKN0zdBRqPXncS5_6QN5AQlA6mvG8Cj-LJK0upU,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_3.pb,sha256=kaTdiMVv2E0mfApRIScR0FmyX4rNie1tYm2cS4Po10A,1042 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_4.pb,sha256=p6T9M62Fbk2qsM54eM-oQRobcGEkLlXT7-GtV64dFqM,145 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/output_0.pb,sha256=yGzRcI4PJTh1MiHxZyTibqgPyPpjRxKLzEj6DWm7pi4,2067 +onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/output_1.pb,sha256=5xju0484rOCBOAVNfgbfGGQPrAN-834j14tgZCaNUqg,2076 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/model.onnx,sha256=RFL_2bEXmJtw_gKPo01OIsxSx72vt_pp_WP6SLWM8Cw,394 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_0.pb,sha256=3T5lWOmPg-hQKigzioKb3lTCL8TpLxlLXvPQCLEu7zw,2066 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_1.pb,sha256=Re5bYQ_kO5Z4d1D_bnnxwzw9NFmZCaPQuRTBAItp7bM,272 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_2.pb,sha256=DcJKci5nP5WVX76sc8UAkjhFCMwsf4N0zhn6W031Fbs,274 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_3.pb,sha256=Ohy-ijN7H03e2d8tsOcYr2ogg58nJzHNgAlYVTnpF3s,274 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_4.pb,sha256=GfIo30DcHjpYmBRM2zempoKk5yWaq-Hpqd5kuWEboPs,48 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/output_0.pb,sha256=XcS0bD1EnFU8I1JjieH9jfISUkM_Yrd-QVGOq8HzQ9w,2067 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/output_1.pb,sha256=kXY67FWN0KtbOgO5B0y6oDFlNZ1gKXDZK83mNKeLULw,540 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/model.onnx,sha256=UnAZ_2gLyebiiEE1wP2c3bspiwtaendncxeIPhdVM0s,15862 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_0.pb,sha256=3T5lWOmPg-hQKigzioKb3lTCL8TpLxlLXvPQCLEu7zw,2066 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_1.pb,sha256=Re5bYQ_kO5Z4d1D_bnnxwzw9NFmZCaPQuRTBAItp7bM,272 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_2.pb,sha256=DcJKci5nP5WVX76sc8UAkjhFCMwsf4N0zhn6W031Fbs,274 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_3.pb,sha256=Ohy-ijN7H03e2d8tsOcYr2ogg58nJzHNgAlYVTnpF3s,274 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_4.pb,sha256=GfIo30DcHjpYmBRM2zempoKk5yWaq-Hpqd5kuWEboPs,48 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/output_0.pb,sha256=XcS0bD1EnFU8I1JjieH9jfISUkM_Yrd-QVGOq8HzQ9w,2067 +onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/output_1.pb,sha256=kXY67FWN0KtbOgO5B0y6oDFlNZ1gKXDZK83mNKeLULw,540 +onnx/backend/test/data/node/test_linear_attention_gated_expanded/model.onnx,sha256=6PAkuMBkBDrwom3Z9EcAH5HQTErKEBIFnHIT4z0fs4Q,10208 +onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_1.pb,sha256=s91li6kYxzvQj117tTxgVm_M2Oi9z_Tv3Xshlba_K6E,1040 +onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_3.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/output_0.pb,sha256=qKNa8fKHJhs0J87WYNe0VFDq68BaVuYIJWwnexyssUA,1043 +onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/output_1.pb,sha256=SziikkmyRHgbD-Rh2BU7z4FUbAGgYXs61kKEJv4GKDk,2076 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/model.onnx,sha256=gLsnwG8gmxL59FMnYEvPvKurm3aQohRzxd8NvtCjhsA,391 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_1.pb,sha256=s91li6kYxzvQj117tTxgVm_M2Oi9z_Tv3Xshlba_K6E,1040 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_3.pb,sha256=y4U_99GlESda8qLYY-1ocF5iZ7S7A16oL_Uj3cspxao,146 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/output_0.pb,sha256=nNADhg0qJR1M1j58hrdT8cyXIxtqlHVE0UOaAY4QHVs,1043 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/output_1.pb,sha256=ERzG_VOeKyfme1Rw7oQfdJri_vNe_4M0GJM9meNgemE,2076 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/model.onnx,sha256=PfTk1E1eNIpY5XCqMn-UtqeH6CDLq17l8UtXJq-QmWU,12059 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_1.pb,sha256=s91li6kYxzvQj117tTxgVm_M2Oi9z_Tv3Xshlba_K6E,1040 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_3.pb,sha256=y4U_99GlESda8qLYY-1ocF5iZ7S7A16oL_Uj3cspxao,146 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/output_0.pb,sha256=nNADhg0qJR1M1j58hrdT8cyXIxtqlHVE0UOaAY4QHVs,1043 +onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/output_1.pb,sha256=ERzG_VOeKyfme1Rw7oQfdJri_vNe_4M0GJM9meNgemE,2076 +onnx/backend/test/data/node/test_linear_attention_linear/model.onnx,sha256=MKD-xAqj-TzCqq4y4cVv6_MC5TgOQx7FkkAhJ8TlY9Q,339 +onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_1.pb,sha256=s91li6kYxzvQj117tTxgVm_M2Oi9z_Tv3Xshlba_K6E,1040 +onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/output_0.pb,sha256=RlktNhkjRx27ugwYG1uE8FV4TiMl9QLBmzathZuDVRE,1043 +onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/output_1.pb,sha256=beMJtNkigywY2ACAsBC83YCru2Q3qB6vZ7cOCiJJvio,2076 +onnx/backend/test/data/node/test_linear_attention_linear_expanded/model.onnx,sha256=Wga0GZGEWqoMZolnCEeo4jb_JvHUbU3sCVop8WzMuoc,8993 +onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_1.pb,sha256=s91li6kYxzvQj117tTxgVm_M2Oi9z_Tv3Xshlba_K6E,1040 +onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/output_0.pb,sha256=RlktNhkjRx27ugwYG1uE8FV4TiMl9QLBmzathZuDVRE,1043 +onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/output_1.pb,sha256=beMJtNkigywY2ACAsBC83YCru2Q3qB6vZ7cOCiJJvio,2076 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/model.onnx,sha256=moV2FMjtfyQLd9JGrAQ4h_AQDJ3Iuyj-PlPadw5Ck94,350 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_0.pb,sha256=s_Cut8lBkFYPi555Sj-4eU0o3jVqzWWdUC4ZqHE9WDE,274 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_1.pb,sha256=9GXNFvTTLnBEptt17LdeWiSd-fFtrf8qvQXmh9M50n4,272 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_2.pb,sha256=s5qJI-hgIMr8XTrlhJiZev7d7382JcCnwwSaoUi--I4,274 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/output_0.pb,sha256=rsxtKCfMaHYIJ7VkLSGQAEq8LCPMvVE2jVFYF4R7Efk,275 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/output_1.pb,sha256=8HcWhbSQlmlB_asnBjC0o2PnIldZLBDlImFvDF9Mmrs,2076 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/model.onnx,sha256=WMkpnDmJE_VE4MlVfDtnis_k4GX61Jdvvl6BN5XVDZY,10170 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_0.pb,sha256=s_Cut8lBkFYPi555Sj-4eU0o3jVqzWWdUC4ZqHE9WDE,274 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_1.pb,sha256=9GXNFvTTLnBEptt17LdeWiSd-fFtrf8qvQXmh9M50n4,272 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_2.pb,sha256=s5qJI-hgIMr8XTrlhJiZev7d7382JcCnwwSaoUi--I4,274 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/output_0.pb,sha256=rsxtKCfMaHYIJ7VkLSGQAEq8LCPMvVE2jVFYF4R7Efk,275 +onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/output_1.pb,sha256=8HcWhbSQlmlB_asnBjC0o2PnIldZLBDlImFvDF9Mmrs,2076 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/model.onnx,sha256=zJbg92dmEnFs3izOVoeI8Zcdo2_JB3FgNXVf1q93FEc,449 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_3.pb,sha256=LsJaIpqd3P_ie0M0rcITHTjIBKaLDNtHK7weCP9ARb8,2073 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_4.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_5.pb,sha256=zUyUjLk937LkJEKxxGcFvld6b5W7jiXdd7YmWptB52g,145 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/output_0.pb,sha256=0pGr1gZEDXHDvYt5JtxCVXmE6jxotvM1MiTkQAZW4w8,1043 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/output_1.pb,sha256=bVMOabF-LZDcIRnUEdNSEsIuC_YkOtsTXidTZdD0n0s,2076 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/model.onnx,sha256=bEgU0wrPOVLIkrsBjwxFKkCJ9_-ikpprRyTlhkUeOB0,14415 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_3.pb,sha256=LsJaIpqd3P_ie0M0rcITHTjIBKaLDNtHK7weCP9ARb8,2073 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_4.pb,sha256=vUOmgT_sFgzvuaRmM-1sqmmENPakxWKgC6e4ABsstJQ,1042 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_5.pb,sha256=zUyUjLk937LkJEKxxGcFvld6b5W7jiXdd7YmWptB52g,145 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/output_0.pb,sha256=0pGr1gZEDXHDvYt5JtxCVXmE6jxotvM1MiTkQAZW4w8,1043 +onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/output_1.pb,sha256=bVMOabF-LZDcIRnUEdNSEsIuC_YkOtsTXidTZdD0n0s,2076 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/model.onnx,sha256=cocKceXz8I2mGmuwsJxOaNrcffnBlgpCoCDKH8Senrk,444 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_3.pb,sha256=zTMrVRzlErJdrvm-yJbrjRHHnDM4y7Ue2lOMtqPnVl8,2073 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_4.pb,sha256=uH4Kr9aItd61p0W3VhwmbHRCPKHV6Nmc-qUHvFZaZuE,1042 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_5.pb,sha256=LLJLryYe27KNKf9l-RVuJpQyf5vfxALQH6t3k5dMauA,145 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/output_0.pb,sha256=JUPKLs6J4BZgGMfHkU12RAj2xZnQTWhpIx925WM7DDg,1043 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/output_1.pb,sha256=_gMK1rjfYioJlzezxLoM8QeoBvOl-2Q6Rj_CCW_NxIk,2076 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/model.onnx,sha256=Ml3c_qJh4hpBRJlnpMZb981a-ZF7OJEfaZbgDEuUDHw,13688 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_0.pb,sha256=S8z2KnYG4p8ATWw4fJdsmqGFwW12c-iYQDxMpQldcFg,1042 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_1.pb,sha256=8Shv-PiTHsQkeCvPizhw-x9UKFwaLCAvDA8n7BS9Z2Q,1040 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_2.pb,sha256=WVeahuPIyRnyROB43ZGaG66YVSmVBnQBVGE8xxcwH4c,1042 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_3.pb,sha256=zTMrVRzlErJdrvm-yJbrjRHHnDM4y7Ue2lOMtqPnVl8,2073 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_4.pb,sha256=uH4Kr9aItd61p0W3VhwmbHRCPKHV6Nmc-qUHvFZaZuE,1042 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_5.pb,sha256=LLJLryYe27KNKf9l-RVuJpQyf5vfxALQH6t3k5dMauA,145 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/output_0.pb,sha256=JUPKLs6J4BZgGMfHkU12RAj2xZnQTWhpIx925WM7DDg,1043 +onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/output_1.pb,sha256=_gMK1rjfYioJlzezxLoM8QeoBvOl-2Q6Rj_CCW_NxIk,2076 +onnx/backend/test/data/node/test_log/model.onnx,sha256=cjzxxnA2vdNVbEX5HvAKpSmjYnWrEJoMDppGn_nVs6U,97 +onnx/backend/test/data/node/test_log/test_data_set_0/input_0.pb,sha256=h8CKUWP5FlTAgSDNi1yNwj568pm_N5ceqp_-U0ll_Vk,254 +onnx/backend/test/data/node/test_log/test_data_set_0/output_0.pb,sha256=pETp9F1Xftoyb5uzN-CDODSiMM1O3kKb6bqDTq8nloo,254 +onnx/backend/test/data/node/test_log_example/model.onnx,sha256=XVquiQ33XPpN2dX6vINv5rNtk-sTtg9bXICaZ2bPjwM,89 +onnx/backend/test/data/node/test_log_example/test_data_set_0/input_0.pb,sha256=0YatubYDmMpLjT3RWtFeMNO0bgyvikdU41tE6Or7TXw,17 +onnx/backend/test/data/node/test_log_example/test_data_set_0/output_0.pb,sha256=uhyyuENMdNx-nQ9styrIbgpA_f86OaR-2N7rPvmRBMk,17 +onnx/backend/test/data/node/test_logsoftmax_axis_0/model.onnx,sha256=VJwFm_Yn_uQ5JJ8u_eWlbgtiWZrtUi6NAPAsOJ8-AGE,131 +onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/output_0.pb,sha256=rxRI3f_tjrg9jlkJETIIY0Ezuf2mdi8sJVui7jN45os,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/model.onnx,sha256=YfCbAB070y4n4iY1Jd1GKDYl9dLoNDmQUPi6hfk3H6Q,1058 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/output_0.pb,sha256=rxRI3f_tjrg9jlkJETIIY0Ezuf2mdi8sJVui7jN45os,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/model.onnx,sha256=0xlpmgQ7u3QkgZrwjSAQKfoM_I0RCzyThOhRPHvS85A,1110 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb,sha256=rxRI3f_tjrg9jlkJETIIY0Ezuf2mdi8sJVui7jN45os,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1/model.onnx,sha256=ecVwQeM2qxClBhjEWUbOb2ag80E0M72V3PKfPoB107c,131 +onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/output_0.pb,sha256=y-ROhxTKXw_3lML2t7eeO6eumoUcDiK7HUCWDrM0zjQ,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/model.onnx,sha256=g5Dj4agZBHB5oYZpG5fDhDSzlP6r5eAnq7lclEn7XH4,1058 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/output_0.pb,sha256=y-ROhxTKXw_3lML2t7eeO6eumoUcDiK7HUCWDrM0zjQ,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/model.onnx,sha256=DFEInUgsiO7XfgcAXECqwsmPRs5vxeg1jMAy3drbkS8,1110 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=y-ROhxTKXw_3lML2t7eeO6eumoUcDiK7HUCWDrM0zjQ,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2/model.onnx,sha256=nshnXZ3VAXw3BDp8QNoyBWN8szqKSIfh2w6v5fuFMeY,131 +onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/model.onnx,sha256=MiHL1XMsKoyIm9MPa-EeZTOBmmIShCvteQR0igOGgug,1058 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/model.onnx,sha256=cWJhXBgARwv2HFpK0boBVxxbAB-uJqiRJEEYn6z9ZSs,1110 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis/model.onnx,sha256=W_xTO0KtwNOY1vT1hr9XmelZo54m6yXz4lPD4aNYnbQ,124 +onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/model.onnx,sha256=KlfdRLL8jlBhSlKlS-GX9L8nQ_gVqqH9Rm7zMQaDNZE,1161 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/model.onnx,sha256=wC2W2D5LPxEUCiGU9aAutzkUbr_SK4TJwRP35vfq6tQ,1210 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_example_1/model.onnx,sha256=0AlAWkvbmN5EuyqEmOQTqSwtUfKwopJz1z5RgxXbS9w,113 +onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/output_0.pb,sha256=0E88Sg_EHhUCNlKNOtJhRSD4YLju2X8tGUYcZ-68M98,23 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/model.onnx,sha256=BzlBt5Ku0H1N8HqQOwSqH8TgegEiWJ0uOTiXPpp5gmw,1111 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/output_0.pb,sha256=0E88Sg_EHhUCNlKNOtJhRSD4YLju2X8tGUYcZ-68M98,23 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/model.onnx,sha256=Fm1B-d4hmXuY6aIMje5xrjHpaj4QxJgz1_Vk0ZBG9to,1157 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=0E88Sg_EHhUCNlKNOtJhRSD4YLju2X8tGUYcZ-68M98,23 +onnx/backend/test/data/node/test_logsoftmax_large_number/model.onnx,sha256=gJWUGFTLCqc41krZNiUU9j2zySmHPqJK2ZJbgP5o0ng,116 +onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/output_0.pb,sha256=Sr55i9PgvLCs-n1Ew4mlUpnkhsgmu3BaizigOb_SFwk,43 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/model.onnx,sha256=byHDQ5CYCFgvkuFSiTxaETwHkpsasZMFBUfq1-AWUjE,1153 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/output_0.pb,sha256=Sr55i9PgvLCs-n1Ew4mlUpnkhsgmu3BaizigOb_SFwk,43 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/model.onnx,sha256=fXI6GvlhebnyoFrv0QPQ98kJQksjCFpjlYleYdUlnCU,1202 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/output_0.pb,sha256=Sr55i9PgvLCs-n1Ew4mlUpnkhsgmu3BaizigOb_SFwk,43 +onnx/backend/test/data/node/test_logsoftmax_negative_axis/model.onnx,sha256=eycSf6ZZu87Dr64zGxydYF7uwDJNon6U0YOxlJVZ5Ms,147 +onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/model.onnx,sha256=4URNtnb9AximMCbvDlR6JOkAot2n-0bqXA9aImyKIys,1175 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/model.onnx,sha256=ISmFRynfhw5CyXIuuuQKQRhZ7SIOGGuVD34vSDUCquM,1225 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_loop11/model.onnx,sha256=NUlbusd6NPWkUocdEIyVtNhyLkrj8dNo-Jt4G1Cmv9c,726 +onnx/backend/test/data/node/test_loop11/test_data_set_0/input_0.pb,sha256=21JE-MBIhsvfmum8LEJZRp-Ye4W2jOC8yOKzQDWQeSg,24 +onnx/backend/test/data/node/test_loop11/test_data_set_0/input_1.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_loop11/test_data_set_0/input_2.pb,sha256=odGLrEmd0nK29vu1cr7vt82v8nFq43Ps-bhrbn3_7rc,13 +onnx/backend/test/data/node/test_loop11/test_data_set_0/output_0.pb,sha256=4ToJMgBIR2YxjkszwBk7SawzzOTz3WUAz8cgo_aEH0E,17 +onnx/backend/test/data/node/test_loop11/test_data_set_0/output_1.pb,sha256=4FgI1CLKyj4rzxQPcdL6YDctQ1tijp2ao1XFgbLEtX8,38 +onnx/backend/test/data/node/test_loop13_seq/model.onnx,sha256=X2_q1DMYFPlgKOXWtNil8nGpg77BOc5BTqwTOKNPeGY,735 +onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_0.pb,sha256=21JE-MBIhsvfmum8LEJZRp-Ye4W2jOC8yOKzQDWQeSg,24 +onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_1.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_2.pb,sha256=06j9wXmbVFTVecpbq-DEWVtWWQSzCcllrwnC--Jf54g,13 +onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/output_0.pb,sha256=zTPY0hjFSeAJ8JDXtLJ9RqaiGe3bkvi-kIZnICmmnrw,111 +onnx/backend/test/data/node/test_loop16_seq_none/model.onnx,sha256=qI0mQQyRbK_o6Xkf0p_SX-TsdIMCfm8SIktEfIJwNgE,1149 +onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_0.pb,sha256=21JE-MBIhsvfmum8LEJZRp-Ye4W2jOC8yOKzQDWQeSg,24 +onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_1.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_2.pb,sha256=eJaYeF3jiE9xLuq2AoSHII-61tNtlFUkew3iRtmr60A,25 +onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/output_0.pb,sha256=9SLymmgUBDSk1J-jBePC9CBoLiabCczNkHDaJMMZzwM,121 +onnx/backend/test/data/node/test_lpnormalization_default/model.onnx,sha256=kcTnL9_oNqCsm-SZlaLWZQAOGOB1nTT57uwiJkQoXhg,129 +onnx/backend/test/data/node/test_lpnormalization_default/test_data_set_0/input_0.pb,sha256=jwDJXEjdzn_x1inv86-W1U1E7SIOArlMB_6yFFNpTOc,61 +onnx/backend/test/data/node/test_lpnormalization_default/test_data_set_0/output_0.pb,sha256=oKkPecbAZQ2OX2RRY5j6MpsBhH4Ows_WOgtpI-jYcTc,61 +onnx/backend/test/data/node/test_lppool_1d_default/model.onnx,sha256=o5evHGI6DjPArJAaghrWYbwJXJp9OF7FVCFtmWH32w4,162 +onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/input_0.pb,sha256=Za3StahBL7BbhQGm5tBIbmHL40mPVKMeoJms01DCbkU,398 +onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/output_0.pb,sha256=1L_yUusP737vt8eijCtjg8QqDOfanSurZN1keYpGDKE,386 +onnx/backend/test/data/node/test_lppool_2d_default/model.onnx,sha256=HmcskAlvnkGWyTwzhukJb7RybsOrEDdlnSEe-AqhYkk,156 +onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/output_0.pb,sha256=LzE2Oxxd63O1kjiFWsQdwmXklchw2YzdMnuFJJEhLaU,11548 +onnx/backend/test/data/node/test_lppool_2d_dilations/model.onnx,sha256=TDzxBelKNx0TalOuRDML8VQwL6zjBtm_ge8JdOaabcI,196 +onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/output_0.pb,sha256=4a9-Q0pFJed5AhCQ2R01nG38O2j5TevoKwad9oslwnY,31 +onnx/backend/test/data/node/test_lppool_2d_pads/model.onnx,sha256=iGQMkD-R-4slvlFt48gmRxeddvVAHFMpzUaEjuaoShg,172 +onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/input_0.pb,sha256=HFGpOb8k-_eSox3wcj8SOjH7WcbqDYrAaqiceZ_ZzdI,9424 +onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/output_0.pb,sha256=XRKbQ5hsySARPEvuYmfwSrxRs1Bap72RAuFEaH75wHc,10816 +onnx/backend/test/data/node/test_lppool_2d_same_lower/model.onnx,sha256=UgUv3Hy2L4SG0GeYP5awBD276FNd3BvPna2ddRcPt-I,186 +onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/output_0.pb,sha256=1wdwKGIn2REGI2TrNnL-84BfUdm-w6_-7Exh8B8BcP0,12304 +onnx/backend/test/data/node/test_lppool_2d_same_upper/model.onnx,sha256=wWpqPyCVqpLH8_sVCXjbxc1R44GxlYmAdb79rVyKzbY,186 +onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/output_0.pb,sha256=ch43_PicQ9_lD0EALSHTlLpeOVzSaoo6wQA5f6zgorA,12304 +onnx/backend/test/data/node/test_lppool_2d_strides/model.onnx,sha256=gKJNOVaZJUQTHwnEsWFVazBYSAIR-A65CYU84rJcM74,174 +onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/output_0.pb,sha256=2JKvzLOR2xhGU56W9IV4q4OZXDVBf66sS8duyojBUvs,1216 +onnx/backend/test/data/node/test_lppool_3d_default/model.onnx,sha256=PR6zY_YW6tXQ8BajglOdFJ8oN-e4LMq2_5PqrE3ghDI,166 +onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/input_0.pb,sha256=L_c9P56CmA7WzPjy1TlkWrKgYm0YkeXEYxiPZ6VV1wY,393235 +onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/output_0.pb,sha256=JhikdYWL_PstWkGsahKVxijLNC8wwgjgp7SKabiRCy8,357511 +onnx/backend/test/data/node/test_lrn/model.onnx,sha256=2RmKdi_xdJKG2nQ6Sydr0RhKp9hx2sYugj0rrLJiwHg,168 +onnx/backend/test/data/node/test_lrn/test_data_set_0/input_0.pb,sha256=WTjaurAfJF9L9t73S5CfE2SmsNIVXuYgfYNgVEkypVQ,2516 +onnx/backend/test/data/node/test_lrn/test_data_set_0/output_0.pb,sha256=xdnB1rOmadLvzwf321Xc8uXA01Lyr_k6mac3gS-LQAg,2516 +onnx/backend/test/data/node/test_lrn_default/model.onnx,sha256=pLo59lyQp0avFhRmH_TiiS2qWXApwiREShuiL_3uuVE,126 +onnx/backend/test/data/node/test_lrn_default/test_data_set_0/input_0.pb,sha256=WTjaurAfJF9L9t73S5CfE2SmsNIVXuYgfYNgVEkypVQ,2516 +onnx/backend/test/data/node/test_lrn_default/test_data_set_0/output_0.pb,sha256=cxUk8-yvr-GWQUwRs5k296MxN76GuC3f9Ry4MYC-nhg,2516 +onnx/backend/test/data/node/test_lstm_batchwise/model.onnx,sha256=kV9HjQu1iAL0qbmpy7cgZNl5B1cR_MQj9JFAdoDDmps,237 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_0.pb,sha256=X4Jx731skujCbqYlfE79v4ovLqbqAar9VfhQTegviw8,37 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_1.pb,sha256=OtNadmJqOUdzMif6TE-Lr_MvFZLW5uPxpNN307RTPqI,238 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_2.pb,sha256=4TgQIT8ZsnJmaBYxUhHn-MwfrldN0Nl5ubXhWUqr11A,798 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_0.pb,sha256=OTkQCUErjFkNHjBcm6xzsKYQ0Ihg5HMl5uSOi7oN-Rw,99 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_1.pb,sha256=5GQt1_4Z8Z1ArFiNEbzFUZxEAMVDr9AsjRXeAg1tiME,99 +onnx/backend/test/data/node/test_lstm_defaults/model.onnx,sha256=9EmTBJ1_P-OOpcyNvtumKKURPIEhy0j5PMbcrVrViI8,191 +onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_0.pb,sha256=CfdyEi1TF1qNXdr7S9ZjPY0_c7pWtxM7ou3bNl3fNIo,37 +onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_1.pb,sha256=TdJ94c4zwrACHQohXoMpgqyrwu4mcgsXbjFRuNlhp1k,109 +onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_2.pb,sha256=J0_sd5TU-GsTX-rbQovkFPVlVl7vgYypkPSUwo5ssZM,158 +onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/output_0.pb,sha256=lFvUjpPnQcNn5X_C-qFjM4CvBRwylGP0bgCPpFV9u20,51 +onnx/backend/test/data/node/test_lstm_with_initial_bias/model.onnx,sha256=_YBBdWuJqjZhJAX5DHFzH7jvNyUbR8nbJhI8VQTQoco,224 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_0.pb,sha256=eujm2YGHVRU93EAGK-aPA-aFEublku2wP288wJjVc4M,49 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_1.pb,sha256=4nJnesA4ulDJrcu7HmldoPAKiHBRrrYEixxYzM93W8Y,206 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_2.pb,sha256=B_-IsKA8_GE6IY8PnBmwX9m6t6_3vdFJM9Z2dHMOHC4,270 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_3.pb,sha256=FWf6rrp6unNAWgeBMcpNQbQGnOLdeqkuEb3JpC0hKGI,140 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/output_0.pb,sha256=bnEbfd3S79ZtqIA_BeGIOrBw9dxm1KGb_czY6mtL6iU,63 +onnx/backend/test/data/node/test_lstm_with_peepholes/model.onnx,sha256=1Kg6yENZ5yUfiK4R5SCbT2fuzR3zVE0kT8Mz9Cziyi8,377 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_0.pb,sha256=2OeoosrOatiTi0V9BOYjvhD88vWXbcfkKA6c20gxRr0,45 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_1.pb,sha256=YkSD-HUoRWHWy5VblSruzpovxbXfIx3hpt_ixzQtv1Q,206 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_2.pb,sha256=J0_sd5TU-GsTX-rbQovkFPVlVl7vgYypkPSUwo5ssZM,158 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_3.pb,sha256=UTQhV68H3RnHN8YKybJuSU0jokxWMdiPQJ8MvnNYS6U,107 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_4.pb,sha256=MkJoqFV7-u_t8_o6Y2rIguYZimj9D8eeb341jV847QI,29 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_5.pb,sha256=-V_w7_cGyZ0GDnxvC1kRRN6fgpl0cpKetpIig_LQwC0,45 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_6.pb,sha256=ZyP6k0P4yDzfvH4T-npTdIMB-DmtFmKrZbXjRhpq1MM,45 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_7.pb,sha256=o1t21DuNUncpuswkkA69WCsPzw0sPPeGbw4AO6heHEQ,47 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/output_0.pb,sha256=QcMlaZa8V3bViVMaUZ4VCqhpktnx3QHRL8mp2b1kUkw,39 +onnx/backend/test/data/node/test_matmul_1d_1d/model.onnx,sha256=Legp8EOGmD84qlXJgALmE8Q6AUzY500lr90xDCniU6Y,109 +onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/input_0.pb,sha256=Xg0c45xW3uYzZ5X18v_Iw_uco5lvjPTcGQXUDuV8SZE,21 +onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/input_1.pb,sha256=JjH5e9JQlrT5N20fJJJPm5AEwQ9KXD_x5pSWJydlrY0,21 +onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/output_0.pb,sha256=VqVIm0jX9y4mzCKqA2yCkIF5IcjjuOo_F0NOX7eNcYs,11 +onnx/backend/test/data/node/test_matmul_1d_3d/model.onnx,sha256=6hOvuzWxcekf2I5XDHud0YvP1qqVgQfU5LgPC-Qgedw,125 +onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/input_0.pb,sha256=7CCwdB0mc3EZefv9TQU20FOt2OXPN1Ij-98xICBxCpY,25 +onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/input_1.pb,sha256=bhIthVr5e0fdmAuXMaPGD2OfDkXkbLp1ToaVdrE9gXo,45 +onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/output_0.pb,sha256=KZRk9yzF8pfDtcTQ0aXXomff41kpoXC8X04luRVLxxg,19 +onnx/backend/test/data/node/test_matmul_2d/model.onnx,sha256=lG86Scz9r2JYa7roQ4Bl_kGn5qm4AGsUrzIZmZtJu3Y,122 +onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_0.pb,sha256=XJ-hOynTG0EF6hYsDK7MlRgESZsBa98mi49HC0BMH3k,59 +onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_1.pb,sha256=fZUNbWrynfo6yrjJ_N6nbVU8ERJAE7EG62YivA6_PdQ,59 +onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/output_0.pb,sha256=x5KLo-j-hQdpdMlVIAUywqJGlxGetUszj7x8Jjkijkg,47 +onnx/backend/test/data/node/test_matmul_3d/model.onnx,sha256=DSaZ3zVKvneKN1wcjZAH2WW5yjn7StDbbPU_zOA1lC0,134 +onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_0.pb,sha256=X2JZRe6Q-1UZLzTUnGefHdp5psiyGGbOZUoOU2PJJFY,109 +onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_1.pb,sha256=uNcHeZg62FvPXXLbAOIfP2JA-S0GbYLdWCPiOFju_B0,109 +onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/output_0.pb,sha256=Q2pR-WqVLQPaV8_iSRR_Yl4z_ddIBOA_7qJ72M9CFW4,85 +onnx/backend/test/data/node/test_matmul_4d/model.onnx,sha256=zvG_PFUSeYw4uirzowT8rtfUHmwcngKIpEpcxTaymq8,146 +onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_0.pb,sha256=BOQ_EXZfe_quR07HGszrPSBrS2-k42x1hH8FiMBFPAs,111 +onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_1.pb,sha256=6jox02jdTNxPHGwscLuIGr_GWZZhcG9iyOvRGH3Wlwg,111 +onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/output_0.pb,sha256=koxqNtVvc6ykaa0u9WWTchqTWy-WxdyQJYMV4-LdDUI,87 +onnx/backend/test/data/node/test_matmul_4d_1d/model.onnx,sha256=Fz32oI-Peyc-ntw--fSTZFPv_8Wk3avFm2JpTV3OOh4,133 +onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/input_0.pb,sha256=arQGOaiY_PpEhuzj_uPFSpKoAAZ3u8Xp5wWwXwnpoGM,111 +onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/input_1.pb,sha256=m8KT4lnCzC1iCRLtBpQBF7D1KpG2YOHo6K8r8E8YBQg,21 +onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/output_0.pb,sha256=t3dN0vLX8EWc53Og5snTugKI4iq7dAoompVWH7cTKG0,45 +onnx/backend/test/data/node/test_matmul_bcast/model.onnx,sha256=ODHdYdDpsJ2DDIifSzh2CKGvgsFilpD0pWHdysKhwF0,149 +onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/input_0.pb,sha256=d9t19GMkR8pFoqQkxgWEoduFaE0cJgTy_m8pHvRllWc,160 +onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/input_1.pb,sha256=ysXvgnnGpf5qRuG81GAFKY0zJBY5iU0D98NFyxGoaCA,79 +onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/output_0.pb,sha256=YdzQ7A3WlyjugDUKbmvRADH46jml-Lmut5AxaZN8Ew8,160 +onnx/backend/test/data/node/test_matmulinteger/model.onnx,sha256=80liWhDJ10RJr-RA7pL_LffuyFV9P-fu4u1J4QO6yCI,218 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_0.pb,sha256=CW_qu6MGZeHIi4xtdzFAE3EunQBARAnSpXpphiq4n3E,23 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_1.pb,sha256=Zi7ccul40b_4WbGzddk6zQxNcul5WpeybbqROgjR_fE,17 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_2.pb,sha256=n9w_0UFZSEO_KZ8ixK8FVb_f0hz4De5Q3qVfuoU90WE,21 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_3.pb,sha256=2QOpPgCU1uUvr5u3dTi6vhiiHB_Rp5lh2LZGrHlup38,21 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/output_0.pb,sha256=q285XbBU3WGQ67jFVoD_LqN-Zc_Fs5chpbtCmJh8mm4,43 +onnx/backend/test/data/node/test_max_example/model.onnx,sha256=uZcZ8DpvjVFEZwu03Aa3A7twKGWU6ZduHpPZOIYiN3g,170 +onnx/backend/test/data/node/test_max_example/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_max_example/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_max_example/test_data_set_0/input_2.pb,sha256=AIB1cbcFh3kj1j43N81kkDuwnI8-0qQyvmV-b-FJ_UI,26 +onnx/backend/test/data/node/test_max_example/test_data_set_0/output_0.pb,sha256=sJp2P7F8KKH4NdxwIWBG9p6S_EpBkKyZjvqeEH9hs1k,26 +onnx/backend/test/data/node/test_max_float16/model.onnx,sha256=PrWzBjjbzgVYz_zPCtTL1HpfXqW2njVwePab2C6gn8M,139 +onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_0.pb,sha256=XkpNeOliXBMqFxuPluFGL90YeFBKPQgFn1VCcdN0JTc,20 +onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_1.pb,sha256=PGuS9cFumaH9L8uba6S7fx1HAjkPixoPdhEnLzKsJR0,20 +onnx/backend/test/data/node/test_max_float16/test_data_set_0/output_0.pb,sha256=WubrX5BBksfMhnwR41XLC7FM_0k0Ilv6nLUrrDRyGFc,20 +onnx/backend/test/data/node/test_max_float32/model.onnx,sha256=tOJ-16c5LKcjYgoFmD7SSZ-3zsw5jR_1PcakIUGgEYk,139 +onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_max_float32/test_data_set_0/output_0.pb,sha256=E_wXnHEmLizJ3s9zseH5tQKuAokfDXYQ7so-RUpR2SI,26 +onnx/backend/test/data/node/test_max_float64/model.onnx,sha256=adsd71YIOGdvQR0grieRN8r5IWqah5goY0iXR9K9brs,139 +onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_0.pb,sha256=aYo1cyxhD5UJSoRB6MYQY5rIIODrGNSUJtchZ3acHIo,38 +onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_1.pb,sha256=ZVu4MYPV1wvct-Tk1Ju5kemkLyKfY1O7yyOxDXn3HBU,38 +onnx/backend/test/data/node/test_max_float64/test_data_set_0/output_0.pb,sha256=4oiQWJRtVlEw2oLoRfFsiwZOfTb3ABrE3kuqiC106sw,38 +onnx/backend/test/data/node/test_max_int16/model.onnx,sha256=aUD1AZjE3QcudcAaK6RHNWJW1Ge0YxEpkyJa8t1iTI0,137 +onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_0.pb,sha256=FJtiLllRWIS-a9GZyj5gx3m04341cxeH0urJ1Z68vfc,20 +onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_1.pb,sha256=PsSyF9rrkKuUygjrqNhdMCyZQCKu6RXs5lgH-MYow1Q,20 +onnx/backend/test/data/node/test_max_int16/test_data_set_0/output_0.pb,sha256=OGejQtNKbP-XeLonJgWAEuoOxN0YVuXhppnh8Wyd2Rc,20 +onnx/backend/test/data/node/test_max_int32/model.onnx,sha256=2fg800_ywUTwN8eNexg2EsRsLEHDaMCiJDxQWeV1_24,137 +onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_0.pb,sha256=oMt8bgYATqCj4PhzKh_oNtszKREjsNTuk5YwoMxWvHk,26 +onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_1.pb,sha256=dv4_C3z4H-aIoWXzNNmORQ6jQ1A2eaaR0CJVwTkSs38,26 +onnx/backend/test/data/node/test_max_int32/test_data_set_0/output_0.pb,sha256=kRy9ZYyhzDGeGwhqNnHQhpZ7-0MXIpwXqo8gSY_BF0Q,26 +onnx/backend/test/data/node/test_max_int64/model.onnx,sha256=9fkGP9GdQqsU3B7HM4sBXodpxVwO4x_MRv2pZ0jqmuo,137 +onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_0.pb,sha256=KjwVyx6CIaL3FdqxbpcjXEFaaGaO_Ru1yHutAcTm64Y,38 +onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_1.pb,sha256=fvapJViThkYxR2fL98GASrAg9vLpzpzDQsyrcHE0g8s,38 +onnx/backend/test/data/node/test_max_int64/test_data_set_0/output_0.pb,sha256=VycEHo6uFBG7JFssCyGxuXiyiRHCPeHzAukqVU3jMMk,38 +onnx/backend/test/data/node/test_max_int8/model.onnx,sha256=swSBQ_LLuz_5QhQTeYRZJaAPhoxSfnyQEnm56BGoY5Y,136 +onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_0.pb,sha256=wcyuFxX3kcHkurfMWEZ7SIbnKsYcn2OL5ybQBrJoGOI,17 +onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_1.pb,sha256=jMvP1oUjUx-YfHhzRx9y6TktJZrXCoGCA_1TqSRUVIA,17 +onnx/backend/test/data/node/test_max_int8/test_data_set_0/output_0.pb,sha256=MN1XN7VS9eX5ZE3BGlpy8uL0gGug-JVx67jOYzPoX8s,17 +onnx/backend/test/data/node/test_max_one_input/model.onnx,sha256=KE6w2WFpaTpjbAlELW2vIRYjuUSWK5usM_kZW10ORtk,111 +onnx/backend/test/data/node/test_max_one_input/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_max_one_input/test_data_set_0/output_0.pb,sha256=2zyDGx5VM6wREENPQvmSlNd-hsuWcMKvHDS30GC4txo,26 +onnx/backend/test/data/node/test_max_two_inputs/model.onnx,sha256=b0f8X9_6y9g7RdIRdWk7INpwxcEHb0jWe9njs5PNtk8,142 +onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/output_0.pb,sha256=E_wXnHEmLizJ3s9zseH5tQKuAokfDXYQ7so-RUpR2SI,26 +onnx/backend/test/data/node/test_max_uint16/model.onnx,sha256=gh5elrUdqR6TAE-9GLd73ezLANIdM5iVT6A49uy-cR4,138 +onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_0.pb,sha256=X-cnRcEYXi6OPoDAGivylhC6W0b97RiSbZYosOrTjyk,20 +onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_1.pb,sha256=LNaHLa0pYg31eVGgKD2j2_K0qV9p_04E7rwNwE58WIM,20 +onnx/backend/test/data/node/test_max_uint16/test_data_set_0/output_0.pb,sha256=MwEWUB-O9UEcFkKe1qFJ31bNOlYhbzMNYHkKuZeoKz4,20 +onnx/backend/test/data/node/test_max_uint32/model.onnx,sha256=5ss8IzMCUZIYRXZUvXDC2ytzjEYjYeWrChcyCtgAsY4,138 +onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_0.pb,sha256=GUldKT7G3azwH1ALqcSPzCRwnvYQaQYORo_nwdufOvA,26 +onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_1.pb,sha256=HxXkqFhIrH8fFY0dh2U29hfzGO_kE_47ahyZ9QH3oBU,26 +onnx/backend/test/data/node/test_max_uint32/test_data_set_0/output_0.pb,sha256=wJRLHAF8aMq0b6QMJ4nioLkGeZ7QN9h8U-YMkRo9AU4,26 +onnx/backend/test/data/node/test_max_uint64/model.onnx,sha256=twFkVgUAjihfUBCujVhIWcHk58B9SLDOTeIa963Y8fI,138 +onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_0.pb,sha256=URHhAcMIJ52W8ExjVsDmTYPLDu0cRKN9sXcoOPF6nds,38 +onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_1.pb,sha256=Kc229gfiuo2eKmyts9JJNXFrnA0U1sKhgM6uyban3W4,38 +onnx/backend/test/data/node/test_max_uint64/test_data_set_0/output_0.pb,sha256=6r1bXvn_3-S04qjHSshAQ-EGpXeZ01H-4Ii3WlAivm8,38 +onnx/backend/test/data/node/test_max_uint8/model.onnx,sha256=9xvgReV9iBBgU617ADLrYDh8X5aPZey_TcTGqPhtRXM,137 +onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_0.pb,sha256=d8-V_cmlfWKcdUnF5wYjohZ3PM7DtOeQaLO_BWcOZ44,17 +onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_1.pb,sha256=u_Ig9DtP5w3-ADv0CKHHwWzzexXoKKuQXHENbJNK8Jw,17 +onnx/backend/test/data/node/test_max_uint8/test_data_set_0/output_0.pb,sha256=4ijjUbkUJeRJUYuCQBu54lcJJsZEVH34jiQCzHBzZ0E,17 +onnx/backend/test/data/node/test_maxpool_1d_default/model.onnx,sha256=KnTmW4ovYWYkfutY473iVSOaCOLEjGSzUe19HqgfIpY,137 +onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/input_0.pb,sha256=Za3StahBL7BbhQGm5tBIbmHL40mPVKMeoJms01DCbkU,398 +onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/output_0.pb,sha256=ztthcPetAeoKY7HTdeVucMBBtGPI0tjx42jpBggsano,386 +onnx/backend/test/data/node/test_maxpool_2d_ceil/model.onnx,sha256=XICBkpBxH6jc1L-3T9SRlodBKwftmyN8P0KSvXpxMEg,181 +onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/output_0.pb,sha256=BhWwtQ7jPUcvpLyfxmX6TehlXYva35_ohmw3Zjd4Hj8,31 +onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/model.onnx,sha256=Lva38FELvuBTCeH9t-pwpgR7uOObocqe_utPKdKionE,207 +onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/test_data_set_0/input_0.pb,sha256=jVVsnPYTtqJkezoas6FKgAvUJVH-Z4OI0Eocd13lMSg,31 +onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/test_data_set_0/output_0.pb,sha256=UfXp_oNmvaQtHL218Gt4BcyJqwrkzYsfHOpJ50BoRlg,19 +onnx/backend/test/data/node/test_maxpool_2d_default/model.onnx,sha256=H73Rnsv1fl_-be4XHyGmnGftbv-n6K7uWnkHY5WTWto,147 +onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/output_0.pb,sha256=JsM1y5aj-I4KCDSIoohJxNtHERuuFh1BDJk7FagRyUg,11548 +onnx/backend/test/data/node/test_maxpool_2d_dilations/model.onnx,sha256=nKw06ek-QhD2cbXrum6F5ZrJ53ulbEFJdcuCMkbcbJw,188 +onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/output_0.pb,sha256=BhWwtQ7jPUcvpLyfxmX6TehlXYva35_ohmw3Zjd4Hj8,31 +onnx/backend/test/data/node/test_maxpool_2d_pads/model.onnx,sha256=wBRztW_q1OCbK08YXGu5IkvkcqA1VpXFeA4GcaQjE5k,164 +onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/input_0.pb,sha256=HFGpOb8k-_eSox3wcj8SOjH7WcbqDYrAaqiceZ_ZzdI,9424 +onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/output_0.pb,sha256=xqjyYXTRUlDv6gfMp9O3f_nmQTqOzwl31kYWzyocyA8,10816 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/model.onnx,sha256=yHhgcOoshd_qBpsKcg1fkKxBB4pRpbUGYwTi9XtO1lY,176 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/output_0.pb,sha256=BHyTkA2yfKPVso9bJ4yBq_7GlaexvNXyNEixQHDZfKk,115 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/model.onnx,sha256=RmU7UF5leqUosmtyOYzETXsprk3TG2q1QY4t8tJGrpo,208 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/output_0.pb,sha256=NwkDSgVwZffOfc-RYMiB-T4Bi9cG3Hu6ckE1QL5KUOQ,51 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/model.onnx,sha256=ibG4hhmKVIB_CIytzM5fk_63fUDdCnefMCg8wZcH-Dc,178 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/output_0.pb,sha256=uvNdXstYljuvnE014-jjf3-QdQ47ixmPovGW56jxeOM,31 +onnx/backend/test/data/node/test_maxpool_2d_same_lower/model.onnx,sha256=xlsK60RMFWO4G3-JqAfqZMvanZ5b3KUYr0-YohLvBUs,178 +onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/output_0.pb,sha256=uY9algpaX_ocBYHvZlcdg9ZIduWkiisEWHy-6ZF_cD8,12304 +onnx/backend/test/data/node/test_maxpool_2d_same_upper/model.onnx,sha256=p-i9voEE6wkTYlRJgY0SUB56_tGutcQRkYcb8sssebc,178 +onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/output_0.pb,sha256=3VZC2meFU8-OLnTuJM31Fm_TltaQS6RZEXBWSy-lo70,12304 +onnx/backend/test/data/node/test_maxpool_2d_strides/model.onnx,sha256=TMm9-VzEbOVQ4Ewt7ssoyo_8qKJNavIqNgEXkRAcwvA,166 +onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/output_0.pb,sha256=ydD0_CK6cx87T-WWLIm5fN5Y5FVnMjR3dqVLlDAkrkY,1216 +onnx/backend/test/data/node/test_maxpool_2d_uint8/model.onnx,sha256=YvKwQ9DqMRj1BfU16LmES00Tg3-suJ_7JidbDA79P9I,165 +onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/input_0.pb,sha256=3rECJgx1OCrUoFpmAiMYxDU35mjjrL9I1QJb0vTgL_U,40 +onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/output_0.pb,sha256=gEtwsq33uBnzsUvNyx84xTRk7AyduVLPFIMUBbzryas,40 +onnx/backend/test/data/node/test_maxpool_3d_default/model.onnx,sha256=rz7hgDN72M9YcnRsp5ebbpPveaspSk-6jIxSv1k2hMo,158 +onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/input_0.pb,sha256=L_c9P56CmA7WzPjy1TlkWrKgYm0YkeXEYxiPZ6VV1wY,393235 +onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/output_0.pb,sha256=_bML65YsBeYvjV6NIF53p3bWICy0g7hiTWhjfhv5K94,357511 +onnx/backend/test/data/node/test_maxpool_3d_dilations/model.onnx,sha256=spb0X2DfG_3aTWNbyxqTe6KtcFjQD6Hjcc1QMb1IwwU,202 +onnx/backend/test/data/node/test_maxpool_3d_dilations/test_data_set_0/input_0.pb,sha256=eUBZRSXolhPmPqfzFXG-IJegZfzGOQpfdDoeK2OEkrA,274 +onnx/backend/test/data/node/test_maxpool_3d_dilations/test_data_set_0/output_0.pb,sha256=SMcrnt8KLpOf6P5d7j5qhvmbm6dCgLH-q7qso_mKpGM,49 +onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/model.onnx,sha256=gO0PqnZou9PpzWRVJT9w-3ULyI5yDHJ-spGI9huL1ik,215 +onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/test_data_set_0/input_0.pb,sha256=eUBZRSXolhPmPqfzFXG-IJegZfzGOQpfdDoeK2OEkrA,274 +onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/test_data_set_0/output_0.pb,sha256=SMcrnt8KLpOf6P5d7j5qhvmbm6dCgLH-q7qso_mKpGM,49 +onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/model.onnx,sha256=XlRkM6SMuXxadPu7XIotGhMp5jhxuIilHj05hLNymVw,239 +onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/test_data_set_0/input_0.pb,sha256=VKR6T99kXsypZCXWOcGPYobnNiPdA95uKzDtur6-Wps,131091 +onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/test_data_set_0/output_0.pb,sha256=J_8LdXcDVVGkKWIOaG-4eOAtR-vehlDDoVOQS9zG5n0,2934 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/model.onnx,sha256=_bBQtWtxpTOu7KBJeA6s82FvHUJDbInauGOOKWhTQfc,220 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_0.pb,sha256=BHyTkA2yfKPVso9bJ4yBq_7GlaexvNXyNEixQHDZfKk,115 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_1.pb,sha256=Dc74UT0aIeGqzqxQHRA5XIEuMc4LMA78gwdBT3gYEUc,216 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/model.onnx,sha256=I7Czj4XAgllEOnVIGyjTqm6HFlZYVvLBdTX_iB1G2yM,244 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_0.pb,sha256=uvNdXstYljuvnE014-jjf3-QdQ47ixmPovGW56jxeOM,31 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_1.pb,sha256=ux7kfRW2OZDqGYUGfIbVRLuPOCkiwlShBxVO0syCvqA,47 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/model.onnx,sha256=soadVCwWMa8uVsy9kWi1ChBgbAF5wIKKaInydhcB5jU,262 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_0.pb,sha256=v2Jafk_IShwMwa2Gew0QBJuJenG-XnnlkQktS0E-suM,32 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_1.pb,sha256=_Ho_y8dI0kAzxqDHfrdxQahOFIrlabEN2V3_9FrvihY,48 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_2.pb,sha256=DjgMaIl2oDbkGYsMWUYGn1-JTp6N9w_xP-ayKrmNEbk,52 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/output_0.pb,sha256=R33r1KeeZjicEOJg6Ib1Suhskf1qCU1s68adr1fqBhA,115 +onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/model.onnx,sha256=D_VSU-toLJB0Bf5PzQ-3NkhkeeQ0EEW-GIzyVesZfV8,223 +onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_0.pb,sha256=6AsUaxumi7ZjpBxazO9ZJIE1HyGmav5abfKCoArXX_A,32 +onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_1.pb,sha256=_Ho_y8dI0kAzxqDHfrdxQahOFIrlabEN2V3_9FrvihY,48 +onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/output_0.pb,sha256=AsBxPx9tutDDcg5YVJB63RC9URcoMzdGfCiIj4aX-oE,79 +onnx/backend/test/data/node/test_mean_example/model.onnx,sha256=L0nI3wSlMT3WoBWPnGRvOCjwszB5AOmVQ9sfNALXXqs,172 +onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_1.pb,sha256=CT8EqMoWnZgfvIbZCTZCcy5yi-scc6HUEY-s5dz8uC4,26 +onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_2.pb,sha256=_PLxlJ7xl9XIGa6nbKkonHq25eO5mYsALw5JQS7zyx8,26 +onnx/backend/test/data/node/test_mean_example/test_data_set_0/output_0.pb,sha256=KG7ceFD_UsUNZYzkjIM8TFMO7G0-cmnzZLgXel7i9vk,26 +onnx/backend/test/data/node/test_mean_one_input/model.onnx,sha256=1XwAN1QuSDBuIxW8R6ln8m0SYjj6YA86i5X_5wuWO1k,113 +onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/output_0.pb,sha256=ZKhVafwrQna2mYQVSKmI2eivwdOVRllNuFJ0a3S4awM,26 +onnx/backend/test/data/node/test_mean_two_inputs/model.onnx,sha256=g00GzthG6o0H_aStXffMWED1rUw5J2kFr8pW9AqsoRk,144 +onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_1.pb,sha256=CT8EqMoWnZgfvIbZCTZCcy5yi-scc6HUEY-s5dz8uC4,26 +onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/output_0.pb,sha256=nqC_wFwz02oBVUimtu5pY2Nga3AVKriaEL7M6uMdyC4,26 +onnx/backend/test/data/node/test_melweightmatrix/model.onnx,sha256=b9l8xULlNZVrhxOduh7oVLNuVrdfPgNSyOL9Lh2rbGs,300 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_0.pb,sha256=NEPQIRs3FEL6UGqz8HzVTd0uBDI52jfUHtmsPDo6xh8,22 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_1.pb,sha256=I3E3ucT0v3A3C96bJeRt6VJerY7Vvo_1jYX-wFC1Xio,20 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_2.pb,sha256=riXIveX4Y4MT3-Xz3tvYXF5jNkOeUjLJDYNYzLhmQMA,21 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_3.pb,sha256=e8IILeTioZtXTnxsVBJEM_k9Uee58y2clJvgOuz_zmk,26 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_4.pb,sha256=RXrXHnMYPUVp0r__a6otNlGy9yyeq6P4B5YXO_47Ors,26 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/output_0.pb,sha256=sBNBK-d3RGC0wetdS2QB7w63nuLz04fTVQBV0AumZuo,305 +onnx/backend/test/data/node/test_min_example/model.onnx,sha256=Jl71j3_A-QdMP_yyVfKSP8ZONEAFXuO_sqCAGWkoKbk,170 +onnx/backend/test/data/node/test_min_example/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_min_example/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_min_example/test_data_set_0/input_2.pb,sha256=QpbKt69Jv0zAdktqC0_-h0v6bwKo1Uj7aPUx26Wv0zU,26 +onnx/backend/test/data/node/test_min_example/test_data_set_0/output_0.pb,sha256=NiybG918Px_YARZTv8xLcKeVMg4_DawQIjEP6N-3ax8,26 +onnx/backend/test/data/node/test_min_float16/model.onnx,sha256=7ZSX7Ps22Dx_ZYoC52rHlfMazBGQAIXt1odd1IyfKX4,139 +onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_0.pb,sha256=XkpNeOliXBMqFxuPluFGL90YeFBKPQgFn1VCcdN0JTc,20 +onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_1.pb,sha256=PGuS9cFumaH9L8uba6S7fx1HAjkPixoPdhEnLzKsJR0,20 +onnx/backend/test/data/node/test_min_float16/test_data_set_0/output_0.pb,sha256=RK5AMEDDe5TRXOuJSAaQBPF3jJPVwvGUmDrQl2mFR5E,20 +onnx/backend/test/data/node/test_min_float32/model.onnx,sha256=24f8iC-6SRbQWm-irEf-Pvve6NWJ45BCNk9OfzS-kxs,139 +onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_min_float32/test_data_set_0/output_0.pb,sha256=l4xYUpOgO-wd16dHDwhvlQnq3U_PRCoHyWTjTgDgWfk,26 +onnx/backend/test/data/node/test_min_float64/model.onnx,sha256=RY2IJ7_4rbMt2CTikHnyafV2QZeC3xeEPhMl7Hqn4Pk,139 +onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_0.pb,sha256=aYo1cyxhD5UJSoRB6MYQY5rIIODrGNSUJtchZ3acHIo,38 +onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_1.pb,sha256=ZVu4MYPV1wvct-Tk1Ju5kemkLyKfY1O7yyOxDXn3HBU,38 +onnx/backend/test/data/node/test_min_float64/test_data_set_0/output_0.pb,sha256=GEKafc3aNO_TQNdJae9RihD3K85Onv7GJAH9KyvLX1c,38 +onnx/backend/test/data/node/test_min_int16/model.onnx,sha256=NRHzzE2zXmhpkuMX8U8EqYxKCmV2X5lpKpr8-lbp8eo,137 +onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_0.pb,sha256=FJtiLllRWIS-a9GZyj5gx3m04341cxeH0urJ1Z68vfc,20 +onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_1.pb,sha256=PsSyF9rrkKuUygjrqNhdMCyZQCKu6RXs5lgH-MYow1Q,20 +onnx/backend/test/data/node/test_min_int16/test_data_set_0/output_0.pb,sha256=hASsoRQp3LTFS1EuynL9QOnLfVLX5MzZWo3ZyB7uMfw,20 +onnx/backend/test/data/node/test_min_int32/model.onnx,sha256=z-JDavbfz2-uoCSQQejk_o8NWsQDQblAjaL2QWVy5r0,137 +onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_0.pb,sha256=oMt8bgYATqCj4PhzKh_oNtszKREjsNTuk5YwoMxWvHk,26 +onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_1.pb,sha256=dv4_C3z4H-aIoWXzNNmORQ6jQ1A2eaaR0CJVwTkSs38,26 +onnx/backend/test/data/node/test_min_int32/test_data_set_0/output_0.pb,sha256=QOgWmBfpG2ZTFzEZ6O0QZQWkTyvU4ka4qkFLJUqBOCg,26 +onnx/backend/test/data/node/test_min_int64/model.onnx,sha256=XhaI6ewm7TosjMjsg3RNo_g79YobPtaFhbAVuc8Nll0,137 +onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_0.pb,sha256=KjwVyx6CIaL3FdqxbpcjXEFaaGaO_Ru1yHutAcTm64Y,38 +onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_1.pb,sha256=fvapJViThkYxR2fL98GASrAg9vLpzpzDQsyrcHE0g8s,38 +onnx/backend/test/data/node/test_min_int64/test_data_set_0/output_0.pb,sha256=qf27EVakskgj0Bv0aNtW4WJQrgME131LP74nHqx6MgM,38 +onnx/backend/test/data/node/test_min_int8/model.onnx,sha256=y3gjGQ2UzLg9LEU1Nr1Hkcee-zv6Q-JRgg5VcSKr-F4,136 +onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_0.pb,sha256=wcyuFxX3kcHkurfMWEZ7SIbnKsYcn2OL5ybQBrJoGOI,17 +onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_1.pb,sha256=jMvP1oUjUx-YfHhzRx9y6TktJZrXCoGCA_1TqSRUVIA,17 +onnx/backend/test/data/node/test_min_int8/test_data_set_0/output_0.pb,sha256=mVByJIahRHozMhvyDghT17o7iB2vYsDonWzby7nB04A,17 +onnx/backend/test/data/node/test_min_one_input/model.onnx,sha256=s8sXPKEgzYrTnfd6dJWh0rYujFVjIad7AalqDtrLqhc,111 +onnx/backend/test/data/node/test_min_one_input/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_min_one_input/test_data_set_0/output_0.pb,sha256=2zyDGx5VM6wREENPQvmSlNd-hsuWcMKvHDS30GC4txo,26 +onnx/backend/test/data/node/test_min_two_inputs/model.onnx,sha256=LX78oggqjZfNUGhN1iipvJTOINLQp7LIp6YWjRAbC60,142 +onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/output_0.pb,sha256=l4xYUpOgO-wd16dHDwhvlQnq3U_PRCoHyWTjTgDgWfk,26 +onnx/backend/test/data/node/test_min_uint16/model.onnx,sha256=hDS6KkmbuOOKDdODax1bcXI9CCZD8cqfctQ4ok719bw,138 +onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_0.pb,sha256=X-cnRcEYXi6OPoDAGivylhC6W0b97RiSbZYosOrTjyk,20 +onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_1.pb,sha256=LNaHLa0pYg31eVGgKD2j2_K0qV9p_04E7rwNwE58WIM,20 +onnx/backend/test/data/node/test_min_uint16/test_data_set_0/output_0.pb,sha256=AASj0clqDfoUl5BuA9hzYSB90G5ESdetIgx2CjmGQcE,20 +onnx/backend/test/data/node/test_min_uint32/model.onnx,sha256=-Tpxeb4-r6EAeAhoKZdxYBXO_errt6m1nTLPm8VQtmk,138 +onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_0.pb,sha256=GUldKT7G3azwH1ALqcSPzCRwnvYQaQYORo_nwdufOvA,26 +onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_1.pb,sha256=HxXkqFhIrH8fFY0dh2U29hfzGO_kE_47ahyZ9QH3oBU,26 +onnx/backend/test/data/node/test_min_uint32/test_data_set_0/output_0.pb,sha256=7xTVNXY6HjeciLcJV6zdkMW0unSZrIrZn7nibEMoZV4,26 +onnx/backend/test/data/node/test_min_uint64/model.onnx,sha256=spJUPN6TOkif8NhqEN4XnSWOqEhSJ6fyUYdXNsMqnlY,138 +onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_0.pb,sha256=URHhAcMIJ52W8ExjVsDmTYPLDu0cRKN9sXcoOPF6nds,38 +onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_1.pb,sha256=Kc229gfiuo2eKmyts9JJNXFrnA0U1sKhgM6uyban3W4,38 +onnx/backend/test/data/node/test_min_uint64/test_data_set_0/output_0.pb,sha256=FE2KqNIEFUjpIl7oaUVxtvE_4BB019djTS7PGK4Im8Q,38 +onnx/backend/test/data/node/test_min_uint8/model.onnx,sha256=g8P4RJbhTlZYfM-uXsCrCLTzUHsvejgu4LYRx7AZaEg,137 +onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_0.pb,sha256=d8-V_cmlfWKcdUnF5wYjohZ3PM7DtOeQaLO_BWcOZ44,17 +onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_1.pb,sha256=u_Ig9DtP5w3-ADv0CKHHwWzzexXoKKuQXHENbJNK8Jw,17 +onnx/backend/test/data/node/test_min_uint8/test_data_set_0/output_0.pb,sha256=A08AZUxIdlvdVsUZwY2HJY7t-weOBX3f6n7noU2Uoh4,17 +onnx/backend/test/data/node/test_mish/model.onnx,sha256=zUQxAKekvGTBpOUfvX4w00yQt9Vaow9pVmOCPheB038,85 +onnx/backend/test/data/node/test_mish/test_data_set_0/input_0.pb,sha256=RV1aKvQqmlX789Wd5GM1iOelHOcq7mpK2AOc67HTnds,40012 +onnx/backend/test/data/node/test_mish/test_data_set_0/output_0.pb,sha256=R0fUL48TlUkZEKUOxuIziaLHj8Hu9_joVAA82El9Zh8,40012 +onnx/backend/test/data/node/test_mish_expanded/model.onnx,sha256=n20xZJ0ccxIixAuveAKNrXPXfqy5VOmsO91HQOi70gw,309 +onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/input_0.pb,sha256=RV1aKvQqmlX789Wd5GM1iOelHOcq7mpK2AOc67HTnds,40012 +onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/output_0.pb,sha256=R0fUL48TlUkZEKUOxuIziaLHj8Hu9_joVAA82El9Zh8,40012 +onnx/backend/test/data/node/test_mod_broadcast/model.onnx,sha256=UZosTR7ILJwdb-R8mjUh0dV6Yto8ml7Hs9Y9Qsc_VoY,127 +onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_0.pb,sha256=3qcX3Wo1hXBUsLziRjzEWPSLBxAIkA6VkDFfdA1ODMU,133 +onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_1.pb,sha256=lhpCdi7Z7eKMpbL-r8ctfPGvcP5tqKpCYNwyvTL_R30,13 +onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/output_0.pb,sha256=XH7PNJTdEM2rYc6l2D7GV682V_c2XKf8T5IMzZ1_esw,133 +onnx/backend/test/data/node/test_mod_int64_fmod/model.onnx,sha256=Sh2X6OdVI6ekT4fRR4TRVhNxnSh_qOfb2D1XfiEzjLM,125 +onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_0.pb,sha256=nOKhA4S_k4oLRRJtc_sBIsbaabKM4Kp44EPsTtGDZhc,57 +onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_1.pb,sha256=flHpVhHA6WGEfMmq0TjdhZcLKpScvTBl45zZ8KCgQHU,57 +onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/output_0.pb,sha256=wyOpSZFx-PejmYFgPDzyIxKN4uk7JQ9whEwb-YUuZts,57 +onnx/backend/test/data/node/test_mod_mixed_sign_float16/model.onnx,sha256=gto1zqyjHBJAoruIoES9llZMP-VflH0elbJ6k0Sgcg0,133 +onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_0.pb,sha256=MVkaogxKWSWLKCwAWIYIK6ka31cTnE5k7AGtluEGF98,21 +onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_1.pb,sha256=v0Ok1u195wYs7KWZpMK_-kRpCU-kJEdKLi2dkVWPFWo,21 +onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/output_0.pb,sha256=XoZwwT9Mq8IIe68Fvh9txJxngP333hN7nptDt1NxAS8,21 +onnx/backend/test/data/node/test_mod_mixed_sign_float32/model.onnx,sha256=fyl1SXwq0Ep0mmmnPCGwg585zjCQ9bT6D-6OHz4Fglc,133 +onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_0.pb,sha256=QIyPABIKtekKty_eC1fS4BQXb9SAfOc95d3C-hWuOaI,33 +onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_1.pb,sha256=TlfuxHXSKKO59_3ot-9_8TkSOEghBMa1JttpvwE_9HY,33 +onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/output_0.pb,sha256=fThMIPzW6l8EFZIP-cjpRxJ_5SA5LPFmB2iBDgr3aqs,33 +onnx/backend/test/data/node/test_mod_mixed_sign_float64/model.onnx,sha256=ukr-kauED-l7VCdewRDZxkC7WrkJPUbtnobG1U6jrHs,133 +onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_0.pb,sha256=jsA_RIDwWdbwaf1pa-Eg2TOKQVSW-InXqUAGRGoIgtI,57 +onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_1.pb,sha256=ZkwMjo9QFC5z4WWHXnidDvETp_Vg7HxYH8IW4QH56-M,57 +onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/output_0.pb,sha256=LAlPMxtTz5ncBIakv4KmstJhSW3IVxQuauGbzWqk2GM,57 +onnx/backend/test/data/node/test_mod_mixed_sign_int16/model.onnx,sha256=MGsxSYQNbI0OQCZFNRF3E0pv_T0KeHIVaEMF6U4bOUQ,118 +onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_0.pb,sha256=UEIoI4Qd-kq43WszIVwerQdDc-kCz1SdUQlJdigMHec,21 +onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_1.pb,sha256=AjsGow0MFJSwTd9jddqniDZA4pk1CiWh-vgZt-Egfn4,21 +onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/output_0.pb,sha256=jv4-0meAPqn4mynSfgFV1NNOq3UKKsgeM1to4cDxn_4,21 +onnx/backend/test/data/node/test_mod_mixed_sign_int32/model.onnx,sha256=PgK31M04H60Q5fcHtpoaQKj-5wiRoDBkb3eVLRr04xM,118 +onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_0.pb,sha256=giEjjHtUYRpU_BEU217_pCgE_OEA3y9ZleuAgN-typU,33 +onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_1.pb,sha256=22wYw0JM7tNQ401SFLtgGcQ-ne90tvpWWTReoytj7Bo,33 +onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/output_0.pb,sha256=_a4Yjx7uvnZPG-TkIb341yGjdeliR--d3Fu5Trgxpho,33 +onnx/backend/test/data/node/test_mod_mixed_sign_int64/model.onnx,sha256=nTw6OR_BMSC0Y_JjnrTnr5BXwUOMJ9tA9B9R1VljY2Y,118 +onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_0.pb,sha256=nOKhA4S_k4oLRRJtc_sBIsbaabKM4Kp44EPsTtGDZhc,57 +onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_1.pb,sha256=flHpVhHA6WGEfMmq0TjdhZcLKpScvTBl45zZ8KCgQHU,57 +onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/output_0.pb,sha256=jnR4bDtZ93G6nMkj2CAaTaWk0UxaTaA5AonWF1KjDKY,57 +onnx/backend/test/data/node/test_mod_mixed_sign_int8/model.onnx,sha256=CC0VBcKcNW2g4-82riqZy2byWRYIeaE4Xs_SIfdtBSQ,117 +onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_0.pb,sha256=e4SdPaUz7v7WV4GqACVkvDDWv3VVRGyh6zY736g7Avg,15 +onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_1.pb,sha256=QWRmvzgxJcXKMTv1vhMCT_n4SZgHtga6NLK0sm17tH4,15 +onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/output_0.pb,sha256=3dXZkOSPNjX9Qe0FFIjUZ9sYNqJBrpeBuDRK9z1gwYo,15 +onnx/backend/test/data/node/test_mod_uint16/model.onnx,sha256=alKlDqYYFEBTlxoP_KUnA0ujiOdmDAPCUpPlN4hBM2E,108 +onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_0.pb,sha256=tCsmCRMblNFjQrp58dHq-WdUlovdrwQtDw18AEeCa6M,15 +onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_1.pb,sha256=2LAcmWXmGxfnOGwxfznTysJ_tjFk5VK8q_Rr7uAaWL4,15 +onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/output_0.pb,sha256=MKxPEomEIEe4a3G8KHviE6UTv5yi-EfSi_IFkqHypkI,15 +onnx/backend/test/data/node/test_mod_uint32/model.onnx,sha256=MukL3eMwWSctzgKqJFqFkmQdbAVYtzx94H5sVfPcs9M,108 +onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_0.pb,sha256=RMNhUhYgBTdqxllQCSq5-7jdbrhadyk-Y67u6inphCc,21 +onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_1.pb,sha256=CTViFOfkAPQBZePJI7qcH3xxx-o60oHKZ_Ke-zJVidc,21 +onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/output_0.pb,sha256=6ZpnoFc5CJba_bTAYvYaZLlfHn2oYWn5z16ykLEjYCQ,21 +onnx/backend/test/data/node/test_mod_uint64/model.onnx,sha256=RkACaHHi03wcrloxfUcHz1XxirhsdUkmpyGYR0D09Qw,108 +onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_0.pb,sha256=ntDx28CL_G8v9dPpttRHXJ8h6FsFGA0GNQipBt-ouwk,33 +onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_1.pb,sha256=4NWx2-tUm-ZC_B5WjZqZzVwE9MdhMRRt38ohiDV6WjI,33 +onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/output_0.pb,sha256=1V8VuyVx0lcS2Df0tt-JrILo_d95XKV4ksyO2OV7ZM8,33 +onnx/backend/test/data/node/test_mod_uint8/model.onnx,sha256=5qmvMgMmlxRslaSdJSYy4VqUhnPZAHEC4h6l6vB8Pjk,107 +onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_0.pb,sha256=hDHI1DHkbLpXzkvBdwdVqa0ReVZMhcpGiIlhep4W9YU,12 +onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_1.pb,sha256=slzwobrbN-njwaehacvZjMt6LUfm49Bl_dHEOCuB5ZI,12 +onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/output_0.pb,sha256=QiipYfVIuwPVRtPVyMv5lZN-q2JuQys4ocuT4c3dCZ0,12 +onnx/backend/test/data/node/test_momentum/model.onnx,sha256=-5oApOVFhBs0bz9FDBG8ldvVBgrAhU-avnjryfajF6I,333 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_2.pb,sha256=q6Wsydvsci5ZJNiqDej1Kq17QzS3xOPWEruuLIgoorQ,17 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_3.pb,sha256=NQkKr3rClZp31gGf1Oyh_ECrr2_5AMVYn_fNdDazT8U,17 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_4.pb,sha256=6upGRVU5-O-5zKXoDu6cRsc2F036k6N02w_CNPHBGqA,17 +onnx/backend/test/data/node/test_momentum/test_data_set_0/output_0.pb,sha256=1cxy6HxWJTlaTZSXXWCoR56T9BWkUpKG7saLuYwgXyc,21 +onnx/backend/test/data/node/test_momentum/test_data_set_0/output_1.pb,sha256=Ci12duo6EDJXkQplTj0GZH3T5xTG-BDRHfUN7eIaR0M,21 +onnx/backend/test/data/node/test_momentum_multiple/model.onnx,sha256=5h0MIOkr-byri8c8cozhvIeSHzz5mfmTnFt7uOclUvk,478 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_2.pb,sha256=zSCQaDJuSfjV89lOKl_e8FAvaYdDg6UrH2n4eykC9bI,14 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_3.pb,sha256=A-40FgJNucPNFb_WksbMy0Z-E_EIV7RF0DP90kqbbC4,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_4.pb,sha256=CxeZGajewrwPha-MBoCdOi3nXJYzF9DgbGhOIwIqx3A,14 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_5.pb,sha256=stCGvEbBW8itgJbkRX1pnKZir080kytSIuTmZAkh41Y,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_6.pb,sha256=1-flVrzPmKolD0GSh-ld1wYZxSEIUx0TUpi_0ywedqA,14 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_7.pb,sha256=elUimbVps7sroUEVgzsr7m7OElV1YF29zVkzYA0YS-s,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_0.pb,sha256=4sSVWd8Z9X1CPKfShQixSU6j1XAuHKwTbI1HDWDK05c,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_1.pb,sha256=VIx5aXfPMBO-XRc7JlxZvj1LRnOeikNDOmR-uqHntzs,22 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_2.pb,sha256=QpvgrRN5sklswqZAtEjKXsjjnjKNTvmEd8eJz4v8VQc,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_3.pb,sha256=y6bsm396HxD86Z8Gx4SrXpBeBLu1t4YviYpxT9Zp3Bg,22 +onnx/backend/test/data/node/test_mul/model.onnx,sha256=ZuS6sRZvUEzjJgVPrTahZSjon8MxxwR7LmtefNnB24M,125 +onnx/backend/test/data/node/test_mul/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_mul/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_mul/test_data_set_0/output_0.pb,sha256=GvmV3GKzE3tMQaUbtsliIf7YaUyHtSitkjeF-u4Qptw,254 +onnx/backend/test/data/node/test_mul_bcast/model.onnx,sha256=FmrNZbakJHVt0sk6JDgHNkK08Xla6MrTE3U_qv0LntY,123 +onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/output_0.pb,sha256=xVi0Xf_iQ-yNWQKzRUGY86LcvRmnwTV2W9U7iPvAXyc,254 +onnx/backend/test/data/node/test_mul_example/model.onnx,sha256=BbkaFyBUf7-QS7ZH0F3kuoLpjnMhMWXxMFYZ8nTaUU4,109 +onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_1.pb,sha256=CRO596M4hKvMtegi6TFu8eNUs-prhD7vkphHojkzBj4,21 +onnx/backend/test/data/node/test_mul_example/test_data_set_0/output_0.pb,sha256=tVxYlgVT1AqY2a1VMrqOyiLZAn9wRBDCh7Fdffib0uA,21 +onnx/backend/test/data/node/test_mul_int16/model.onnx,sha256=PqHbxGzuihf_UMOwEUfu0Jw_kEcx-JTuLnW8hPjre6k,131 +onnx/backend/test/data/node/test_mul_int16/test_data_set_0/input_0.pb,sha256=JeiIkski7g9cKMez_YBTiAcDSpc34bkSK9QDqbi1zv0,133 +onnx/backend/test/data/node/test_mul_int16/test_data_set_0/input_1.pb,sha256=KWYFQm3jw5YrrVXWyb6bvggM01Helnwp-rTLgI7bDFs,133 +onnx/backend/test/data/node/test_mul_int16/test_data_set_0/output_0.pb,sha256=w2EPAQHcXshyq4cN8AywWcRmmpbkLZzmP0_y7V6rK_g,133 +onnx/backend/test/data/node/test_mul_int8/model.onnx,sha256=1CRzxtBYID4kQJUjHruYUey9BtYMSTTBQMIe_l9NP1M,130 +onnx/backend/test/data/node/test_mul_int8/test_data_set_0/input_0.pb,sha256=kMsXnufaSnyU5twOjRP9y5GKqw4PC1sRsvQUGhMePPA,73 +onnx/backend/test/data/node/test_mul_int8/test_data_set_0/input_1.pb,sha256=6terZEnbk1_8u8NrAj-2C5h-HbvBuiEBEQWqwHxOZ34,73 +onnx/backend/test/data/node/test_mul_int8/test_data_set_0/output_0.pb,sha256=6Jp9ewT5oSk9B0h6LV7mq2_C7eLTzTXVyiRLpneoAfs,73 +onnx/backend/test/data/node/test_mul_uint16/model.onnx,sha256=X4DsuwpEz62nsbO1_Gp7OPrZGAM2bJj7pgoTtrUjwUo,132 +onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/input_0.pb,sha256=w5nG7b_2tFoCLrZyRIb3-Gdr9Ir__Tk_7ST9xmnG4Oc,133 +onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/input_1.pb,sha256=0mE60agyf-1RT8mYWHBbczZFk37ocqblyojv7yRya9Y,133 +onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/output_0.pb,sha256=c_hAQcmH25GgaWruWYU1dtc4qMY7H-swzjE-3cIrw14,133 +onnx/backend/test/data/node/test_mul_uint32/model.onnx,sha256=gyQh07Z4tj7EOog9hxy8rFn1xFSr5sIpQh0j78Zib1w,132 +onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/input_0.pb,sha256=SfgW_3rkp-qkj2_t2W94igtT3dM67I7zLXHS3Jbwgvg,254 +onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/input_1.pb,sha256=kZOFgvafBzg-6jnU8JywbCuOSOZEUXtsI2GCfFELPLM,254 +onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/output_0.pb,sha256=rc1qd1PMwDBFmkCJ5yYo3AU8rohybN7cHILejGR-v2A,254 +onnx/backend/test/data/node/test_mul_uint64/model.onnx,sha256=jTBGu7BfCkimUFaOBXee1bm-l9tEUmFt14mq0WzdfHM,132 +onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/input_0.pb,sha256=AmvHVBkgGsfNAxPXUyS8yJ1N88djMgy1x17QLTRvV3M,494 +onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/input_1.pb,sha256=3CNIdruGcVrO7nTksqqjcVE1Ik5a9NfP-52Jlfhi2iU,494 +onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/output_0.pb,sha256=JOsBdTRoWTznHNUuXHc0H1zsSx9YFTWmVZ6n-xXG8Gs,494 +onnx/backend/test/data/node/test_mul_uint8/model.onnx,sha256=D6fmj7leZM-7NYYKX7rKyNcmRryGvdyndMqlNnBrIhM,131 +onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_0.pb,sha256=0KGVBGXs8wLgBXPgH9IHTfOtv8p-PuULlbD-yseqOdM,73 +onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_1.pb,sha256=pW7w2zo-jhNEEp7O8mhEm6yaPiV3ERAUfQPoytv2BSk,73 +onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/output_0.pb,sha256=T71ETQ3fQFAWThTdc3o5nlziAjY7vtEp5OAc7UipAr8,73 +onnx/backend/test/data/node/test_mvn/model.onnx,sha256=epvYrtzDMGUCQaTNZrsSaaJv6sj4Z93jWBiIdkZuTtI,127 +onnx/backend/test/data/node/test_mvn/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_mvn/test_data_set_0/output_0.pb,sha256=E83O-chiuVDaVh2K4dg2eJ0Xg40h2shNgDjy6prT-mQ,123 +onnx/backend/test/data/node/test_mvn_expanded/model.onnx,sha256=EZuZmf6XgC8sidl6q5Uf8Gvse-2rTXU8dX8ZeGGRpiQ,1714 +onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/output_0.pb,sha256=E83O-chiuVDaVh2K4dg2eJ0Xg40h2shNgDjy6prT-mQ,123 +onnx/backend/test/data/node/test_mvn_expanded_ver18/model.onnx,sha256=GUDLfw0FyhbNGi6k2wyaZMfyk1GuZYJD5fwIZjhUDrY,1901 +onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/output_0.pb,sha256=E83O-chiuVDaVh2K4dg2eJ0Xg40h2shNgDjy6prT-mQ,123 +onnx/backend/test/data/node/test_neg/model.onnx,sha256=RG6cCaIqfUQ34xlba_AMQOwsIBnpTHgEE4_2K3bWURs,97 +onnx/backend/test/data/node/test_neg/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_neg/test_data_set_0/output_0.pb,sha256=Ts5Na8UG6-tCk6szO_WjtcUAMMIPYVYm3I09yt3IuAs,254 +onnx/backend/test/data/node/test_neg_example/model.onnx,sha256=1xGuNAOWCh8G6u2QwbF8-n6qtNrao0AvKJ70iKtMX0s,89 +onnx/backend/test/data/node/test_neg_example/test_data_set_0/input_0.pb,sha256=hIDv23oySvd30UHcdMkH6btwYls47z-2HWS1hMB2wdg,17 +onnx/backend/test/data/node/test_neg_example/test_data_set_0/output_0.pb,sha256=4EW4AVpPlfhx4g9wwktECbBn42vmT0mhx-eztsZhymE,17 +onnx/backend/test/data/node/test_nesterov_momentum/model.onnx,sha256=0PJxU7A_pXiJUQYJqlEwQhgUz-7Y4D-K11Y6wItheKI,342 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_2.pb,sha256=q6Wsydvsci5ZJNiqDej1Kq17QzS3xOPWEruuLIgoorQ,17 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_3.pb,sha256=NQkKr3rClZp31gGf1Oyh_ECrr2_5AMVYn_fNdDazT8U,17 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_4.pb,sha256=6upGRVU5-O-5zKXoDu6cRsc2F036k6N02w_CNPHBGqA,17 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_0.pb,sha256=78D4vxBLlg3_1l7fVOJsUgiud1GhCpYye_F23yOxGfQ,21 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_1.pb,sha256=u3TIKVQhJ12mswy7LJAMitidrIrQwfmHZc95LItmh38,21 +onnx/backend/test/data/node/test_nllloss_NC/model.onnx,sha256=kBwFCJEQYhl37W2n9ChRpkZRk8BpkdgONexur05Gm-0,181 +onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_0.pb,sha256=old7l3-e0xBCJ0lTuYT6UfvHSpi0zYXGQc1FsncLpIg,75 +onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_1.pb,sha256=4CX0ut_YErV-LAF0q3XBesrAedTFBSOEEoLncdkhSCo,38 +onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/output_0.pb,sha256=FzPp1aOpi6ruhclBnofi7t6rPu1JBh__2nUlEKB8jRg,24 +onnx/backend/test/data/node/test_nllloss_NC_expanded/model.onnx,sha256=6bUwdWJ3hmX7PGFlGxLcIWz22E2Fezt7XNNO9k58oTA,1487 +onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_0.pb,sha256=old7l3-e0xBCJ0lTuYT6UfvHSpi0zYXGQc1FsncLpIg,75 +onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_1.pb,sha256=4CX0ut_YErV-LAF0q3XBesrAedTFBSOEEoLncdkhSCo,38 +onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/output_0.pb,sha256=FzPp1aOpi6ruhclBnofi7t6rPu1JBh__2nUlEKB8jRg,24 +onnx/backend/test/data/node/test_nllloss_NCd1/model.onnx,sha256=ELLAy9kQRxRAC2vMJK7HTQu-EWlwYOndrHtLrxzmF9c,187 +onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_1.pb,sha256=TxDsHYS2QuW7G4Ta0rbBDixXELufO1KTJTJKsj5PDh8,64 +onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/output_0.pb,sha256=Wy80hsUPrWr21jyHz00NtQPKFLFbm9jkiMOVGrkzYOM,14 +onnx/backend/test/data/node/test_nllloss_NCd1_expanded/model.onnx,sha256=Zzz4ic39bsD4hdC9n2yS-aAV_x329seggdHFnXrWhWA,1702 +onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_1.pb,sha256=TxDsHYS2QuW7G4Ta0rbBDixXELufO1KTJTJKsj5PDh8,64 +onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/output_0.pb,sha256=Wy80hsUPrWr21jyHz00NtQPKFLFbm9jkiMOVGrkzYOM,14 +onnx/backend/test/data/node/test_nllloss_NCd1_ii/model.onnx,sha256=-KHTAbDB049780Yv3XauBaw8XG_xEr9shGeF01OhtDw,211 +onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_1.pb,sha256=Ur_oz-w-7AwpWPcD7rOje_KVu5kEOh8mhVS8xvWexXA,64 +onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/output_0.pb,sha256=mvZzSWz0AU3Qvv7pm7RZtTx91YugRDgGdDqN4IjfhRE,14 +onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/model.onnx,sha256=uBamt9RhHReVJOEwhki5kzfxC9LhvIa8XkSgyXb6Avs,4799 +onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_1.pb,sha256=Ur_oz-w-7AwpWPcD7rOje_KVu5kEOh8mhVS8xvWexXA,64 +onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/output_0.pb,sha256=mvZzSWz0AU3Qvv7pm7RZtTx91YugRDgGdDqN4IjfhRE,14 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/model.onnx,sha256=vujYW21XeRXOeqNl6eNTi6KuK9b9kI2icZQkPtlhkyw,271 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb,sha256=EV-DL1xuw3Ssoc13Ru3vNTP97mPKvc4FanaWAaurb30,378 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb,sha256=jCgGbI3X6Kh1LiIy-D1u1T83sddtcdLsgSGGSfnxv34,161 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb,sha256=2pdGNpbiJ_sObKTCzmn5NvpYSnz7nmZf6k9pSWyaiyk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb,sha256=xVxmU46seyPHXo5LO5_H1OTgdz4paTCSI5_vP1GO3rY,14 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/model.onnx,sha256=YCAgd01QYB8wyF9_FAY6AHIcv7fDpCZZwVVx6P6YhNE,6057 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb,sha256=EV-DL1xuw3Ssoc13Ru3vNTP97mPKvc4FanaWAaurb30,378 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb,sha256=jCgGbI3X6Kh1LiIy-D1u1T83sddtcdLsgSGGSfnxv34,161 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb,sha256=2pdGNpbiJ_sObKTCzmn5NvpYSnz7nmZf6k9pSWyaiyk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb,sha256=xVxmU46seyPHXo5LO5_H1OTgdz4paTCSI5_vP1GO3rY,14 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/model.onnx,sha256=_rCqMZ5mPlZmmbZ05RocaqJOEXUDdQa3dlzyXceplvQ,224 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_1.pb,sha256=TxDsHYS2QuW7G4Ta0rbBDixXELufO1KTJTJKsj5PDh8,64 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_2.pb,sha256=7DDbvKGGDdq188bMvD_LwMlrhgJmPpCuh6-TbVZJglk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/output_0.pb,sha256=VMqJ-Ig4hx6FdES7_UNH17eu-1_iOnoQZdk5N9VOgKk,14 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/model.onnx,sha256=nDZmSPgFkyPEoRzWz1lXax_TtO_txxU0kfDypb_A8fU,2696 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_1.pb,sha256=TxDsHYS2QuW7G4Ta0rbBDixXELufO1KTJTJKsj5PDh8,64 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_2.pb,sha256=7DDbvKGGDdq188bMvD_LwMlrhgJmPpCuh6-TbVZJglk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/output_0.pb,sha256=VMqJ-Ig4hx6FdES7_UNH17eu-1_iOnoQZdk5N9VOgKk,14 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/model.onnx,sha256=0-XHdhbtQNXQ9bWf5mxvDHmGh2sGYDKuyN0NxCr4Q5M,248 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_1.pb,sha256=Ur_oz-w-7AwpWPcD7rOje_KVu5kEOh8mhVS8xvWexXA,64 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_2.pb,sha256=7DDbvKGGDdq188bMvD_LwMlrhgJmPpCuh6-TbVZJglk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/output_0.pb,sha256=8_UkUhjk3o7HpAwm_8qujCN_005PKGId3cvF1VYaCTQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/model.onnx,sha256=EdRk32IYCB2BKQwqZjySNg80Hb9nwmb_dwQMP0XTIgc,5288 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_1.pb,sha256=Ur_oz-w-7AwpWPcD7rOje_KVu5kEOh8mhVS8xvWexXA,64 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_2.pb,sha256=7DDbvKGGDdq188bMvD_LwMlrhgJmPpCuh6-TbVZJglk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/output_0.pb,sha256=8_UkUhjk3o7HpAwm_8qujCN_005PKGId3cvF1VYaCTQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2/model.onnx,sha256=ZlbGRkU_5rEdBUfyuwI59bE5Wug5Yvua5wYbQKbx1aU,209 +onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/output_0.pb,sha256=i2iYMamczG-7HCsEJauZO4tMxXxOii0ei0TGmGaTimM,449 +onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/model.onnx,sha256=Hw_ioK5BgqBuSLqY098UK-2knJzBIReBQk2OHgUg1ks,1579 +onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/output_0.pb,sha256=i2iYMamczG-7HCsEJauZO4tMxXxOii0ei0TGmGaTimM,449 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/model.onnx,sha256=swVOoIGXXnjcGMgVal4ISZfCBNTDjGkKNzgXojUZKyk,246 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/output_0.pb,sha256=hSGnu1TNFV4r9LcNJTndtBoNX_1GblNESfOk-W2HrLQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/model.onnx,sha256=3vcAQie_6eN3TE3o-IRr-1VOe36kuCqJcjYpFtbpS2M,6244 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/output_0.pb,sha256=hSGnu1TNFV4r9LcNJTndtBoNX_1GblNESfOk-W2HrLQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/model.onnx,sha256=_RxTZ9M9vovb9HQvoq88boUloLZ3exfJL-7n0ev3AhQ,212 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/output_0.pb,sha256=qSq6WlgazeDCIm1mTyLxUKhzYL5DcoLCqbHb-BXtdAM,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/model.onnx,sha256=DhvKni0SxgbbkKMGy9QL7f37m5tLMSjUaOxR4a0l41M,2033 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/output_0.pb,sha256=qSq6WlgazeDCIm1mTyLxUKhzYL5DcoLCqbHb-BXtdAM,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/model.onnx,sha256=2mAt_7kXO2PmNKqXnux_PkexKWvuH7F_7aC2C84m-v4,210 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/output_0.pb,sha256=x1AM6O_evyx9hb1eICxW4zTGdItDWz9rf-65meUkzCM,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/model.onnx,sha256=LR7KefdiFEJkxcwJjDUPOhzX9l1cv06DBq9rOIJ_By4,2013 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/output_0.pb,sha256=x1AM6O_evyx9hb1eICxW4zTGdItDWz9rf-65meUkzCM,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/model.onnx,sha256=V3sH_TWRr8R08QAy4AyzZj0Kh3KshPwvew4heUjcDxM,251 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/output_0.pb,sha256=JSqPDGiOsobP6xup-vxOXxOSOJTnn6J3C0Z4VCboW54,449 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/model.onnx,sha256=ND7QJfUswdernn6Hu4A_2Ud4fPnpZ3ATCOxxu-CqOpk,2211 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/output_0.pb,sha256=JSqPDGiOsobP6xup-vxOXxOSOJTnn6J3C0Z4VCboW54,449 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/model.onnx,sha256=2_rZRTeQmXKbRVhg7TcvLckn-r83D7_lCVuc0Un8VJ0,254 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/output_0.pb,sha256=Y2jLiaibOR3bdOa9HsLCodhKnjvPmkYX4oUXLJlpg7Q,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/model.onnx,sha256=U81BDGBGy8UScBwNb8WUIKILrtWGNq8wWAW2tiyZDj8,3324 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/output_0.pb,sha256=Y2jLiaibOR3bdOa9HsLCodhKnjvPmkYX4oUXLJlpg7Q,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/model.onnx,sha256=QlnoU4-kgYF3Zb_9bvH6_wyVbKnn39jlrBczwklhv64,252 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/output_0.pb,sha256=ttk6qgLV4PrBOJwBA0MNagYSn2xbblmFgdT5G4Y6DSo,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/model.onnx,sha256=dZnvlzb9pfgEP1SlhDu5hJTKFhlQCaPz-s44lUxrp-M,2730 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/output_0.pb,sha256=ttk6qgLV4PrBOJwBA0MNagYSn2xbblmFgdT5G4Y6DSo,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/model.onnx,sha256=uiwNNu8L-mQRHVsZ7ajMzURZU5wjduh5sA0Sr4gGgpw,276 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_1.pb,sha256=t37hGGOZpY76Z076TWnyUXHJ9RhjExXsTMzsFDongOE,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/output_0.pb,sha256=G1tuk8Dm8zZmN2j-1zlY1fE7Dhiqg62AePzHDxzw9Vk,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/model.onnx,sha256=rBhdTX5eJnALBOxr7RX1ULwNz-BkLX9oJ5xea9npFak,5854 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_1.pb,sha256=t37hGGOZpY76Z076TWnyUXHJ9RhjExXsTMzsFDongOE,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/output_0.pb,sha256=G1tuk8Dm8zZmN2j-1zlY1fE7Dhiqg62AePzHDxzw9Vk,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/model.onnx,sha256=q4D8YiO7iGnxAPtf7dmcmjFUdaaPx9qZxEfzTCjHe_w,280 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb,sha256=z23LiYXVLuyr6YhOh59dhvGqVqx8aoJP7eOh4qE51QM,10822 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb,sha256=cKLm3K_3JxpfYsG4am6zDDJskYvJQbVzjuENYNBUkpw,4341 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb,sha256=S_h5iqr0rOuKrKp6BbeSJ3fJ-2kKAljKD94lVeL46Wc,2179 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx,sha256=LuHimlWQeQF-B4R6Y-NXdB1NWohOT6GhajM1qCIonHE,5510 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb,sha256=z23LiYXVLuyr6YhOh59dhvGqVqx8aoJP7eOh4qE51QM,10822 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb,sha256=cKLm3K_3JxpfYsG4am6zDDJskYvJQbVzjuENYNBUkpw,4341 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb,sha256=S_h5iqr0rOuKrKp6BbeSJ3fJ-2kKAljKD94lVeL46Wc,2179 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/model.onnx,sha256=McUjCOna1Ugwg_5mNyVJH7ivA-w3rX7AYhlorvRIUAE,252 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb,sha256=old7l3-e0xBCJ0lTuYT6UfvHSpi0zYXGQc1FsncLpIg,75 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb,sha256=RXI-xC4uNH5h_9bRIqFZxVMyWsu6CV5b0pbQecU4Bgs,38 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb,sha256=Jm5nsejoZUXJLQiQBzP-LlZ0LpN6o5WgziqWVVxouXg,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb,sha256=nZ7GyTo8pI1otqZg8N04qEXGK8KMRoAVsVCuNp6KZKs,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx,sha256=7YAr9Vk46vPc8jn4uFK5Mm3AbL-2h37sLN0wG6V_xwQ,5445 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb,sha256=old7l3-e0xBCJ0lTuYT6UfvHSpi0zYXGQc1FsncLpIg,75 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb,sha256=RXI-xC4uNH5h_9bRIqFZxVMyWsu6CV5b0pbQecU4Bgs,38 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb,sha256=Jm5nsejoZUXJLQiQBzP-LlZ0LpN6o5WgziqWVVxouXg,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb,sha256=nZ7GyTo8pI1otqZg8N04qEXGK8KMRoAVsVCuNp6KZKs,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/model.onnx,sha256=i-hdWOyqqCK8aeDbOV18JrLFUnC5n6fv5Uk6d5AVfU8,269 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb,sha256=P-KwI3TkPu9I4UH_2t-0e1iCCIJe7S3kGZNXzc_N2GU,129627 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb,sha256=2oaVEIGngV21FQn4FgoG7qbtTYELaSA8w1z1HdyQSIc,51866 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb,sha256=ELwcD97zClJjm-0q0aWGNMO2lFpemh7tQC1XoEkDCCo,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb,sha256=PSbLzivPmtfKKKqqHg4CfuFqAdZRxWJCEJN4QLYvFbQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/model.onnx,sha256=6CjTXJW23fGAYIK6S1s8LOA6lgjUkdQfPLVyArRWPiM,3092 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb,sha256=P-KwI3TkPu9I4UH_2t-0e1iCCIJe7S3kGZNXzc_N2GU,129627 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb,sha256=2oaVEIGngV21FQn4FgoG7qbtTYELaSA8w1z1HdyQSIc,51866 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb,sha256=ELwcD97zClJjm-0q0aWGNMO2lFpemh7tQC1XoEkDCCo,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb,sha256=PSbLzivPmtfKKKqqHg4CfuFqAdZRxWJCEJN4QLYvFbQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/model.onnx,sha256=cyDHFIwEmtKzCu8u7dl5luBjZnUA6MaaJei6BXDBJqQ,266 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb,sha256=P-KwI3TkPu9I4UH_2t-0e1iCCIJe7S3kGZNXzc_N2GU,129627 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb,sha256=2oaVEIGngV21FQn4FgoG7qbtTYELaSA8w1z1HdyQSIc,51866 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb,sha256=y3Zghr4cDyuqm8pbBCrybjPAkSLe_eJ7sR0zCMdCpyM,25944 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx,sha256=rbZ8cTICihap4CTkkvflVVpDs0bVMG9Uhtu1XQldZ10,1974 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb,sha256=P-KwI3TkPu9I4UH_2t-0e1iCCIJe7S3kGZNXzc_N2GU,129627 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb,sha256=2oaVEIGngV21FQn4FgoG7qbtTYELaSA8w1z1HdyQSIc,51866 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb,sha256=y3Zghr4cDyuqm8pbBCrybjPAkSLe_eJ7sR0zCMdCpyM,25944 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/model.onnx,sha256=b5A4lcIFtquT_uLGjS0-Yh_HxEPuxsj-sfdxboSMfhE,410 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_0.pb,sha256=aQPSV_4Z6zQcZDVGmekHfnVc5BHUPfOMSfgoCOUCiX8,113 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/output_0.pb,sha256=VkYmKplg2aAE_7p6EVba0_QxYiTcUtLIAud4BVNFCVc,98 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/model.onnx,sha256=ChIjMwo0mYkmvrx5mruIWwH6vffhTspoARXoUnTObqM,380 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_0.pb,sha256=vYpz_7-JGMz48Rd76XAJEU5ZJP9EbbVdbojxgbVQG3Q,113 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/output_0.pb,sha256=VkYmKplg2aAE_7p6EVba0_QxYiTcUtLIAud4BVNFCVc,98 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/model.onnx,sha256=pRqjxjc6bOsMwBV7BFZH11P88ZSmYkxEvjfviO3c0ss,376 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_0.pb,sha256=CmhJacibwTo53qN1x9N-gVK36bwbgCdCDi8wFskbaAk,178 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_1.pb,sha256=HvcpOmM7nTwjD3KeqZ-FkgFW0xAT9ltbwiA0Db3UmjI,58 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/output_0.pb,sha256=9YHRVPgbYrY2cQnDRar4KnLaeonSVWSdU89tbBN7vso,50 +onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/model.onnx,sha256=uanG0_aAlQa9h2u8pYWAFqKiUdTmV-YZ1oG0-1qBzi0,383 +onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_0.pb,sha256=FiEh5UacMuCSklKsO6SWa7uxy58XhbRCj663YxGR1nI,49 +onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_1.pb,sha256=5UP5hC7TwN5l9OGiE9fvR6WKL_6sajSkJDNbwsW7oqk,26 +onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_3.pb,sha256=mm3pJgGgGyX0g-GJk7BLyiayNRVeJPD11o6ZlMpC17I,25 +onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/output_0.pb,sha256=68lrGGTPnfxcg1_tL89FKuv1mAb3c7CI6mxQD2hwVwc,74 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/model.onnx,sha256=ruPA6FNX-f2C8YKjU9f-fGPtWs8E14vAbin4aStZ7do,378 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_0.pb,sha256=QcocbmgMfN9gR0hQmlBCkMN1MOqyzDtOyL0wDo3HH-s,113 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_2.pb,sha256=2P30Cd3fFGFSGa7DF8F9KCKvZGxbK5uNUhmU-k69NzE,42 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/output_0.pb,sha256=6I0l4kmldzPrF5onX4EWG6aE2qEYmjhx2g0NhS6sr0A,74 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/model.onnx,sha256=G9qIpCAAKZfUE4vQaN5VqiYlR75wqD2z8cu3k21RkFo,371 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_0.pb,sha256=b1Nue7dL-O5ckB2PtWiRUbFhbD4I6NhHOAK0KaFIvko,33 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_1.pb,sha256=taq4F_r3_H_0TP2WdMSsl7q-8GBinBXy0GgNfbcJT6Q,22 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/output_0.pb,sha256=9YHRVPgbYrY2cQnDRar4KnLaeonSVWSdU89tbBN7vso,50 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/model.onnx,sha256=c4__cnmz8GcfTRmVUcaeSWMKiEgWmYkmN_SOYqSMzAE,376 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_0.pb,sha256=QcocbmgMfN9gR0hQmlBCkMN1MOqyzDtOyL0wDo3HH-s,113 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/output_0.pb,sha256=VkYmKplg2aAE_7p6EVba0_QxYiTcUtLIAud4BVNFCVc,98 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/model.onnx,sha256=I4ZPZIQDwB_6DWvtoH7Jw7StjGTDmldjhkloHZnt_0Y,387 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_0.pb,sha256=QcocbmgMfN9gR0hQmlBCkMN1MOqyzDtOyL0wDo3HH-s,113 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_4.pb,sha256=S_ZLHHF52hnQCGoYFUDGzoXON6ejUj1_45vFLB8oRzE,27 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/output_0.pb,sha256=6I0l4kmldzPrF5onX4EWG6aE2qEYmjhx2g0NhS6sr0A,74 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/model.onnx,sha256=lFJHZUPBRCbUKh6iUMzOzuRTuujALHctWk8hNDzPz_o,372 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_0.pb,sha256=3HF94qHNxjTM8WjQWgm2G3v0yWzH-uZMwkjNvixauog,210 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_1.pb,sha256=H91iA7UY1O-Q6Bk7qNRv1g6Udhd4PQetKtp4KemkCCg,66 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_2.pb,sha256=2P30Cd3fFGFSGa7DF8F9KCKvZGxbK5uNUhmU-k69NzE,42 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/output_0.pb,sha256=8rjpUP7x4wsIEYYTzCWpUhTfdii3TzZu3wVcBJFwdKY,122 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/model.onnx,sha256=7EWVtK6PCCwzWUvXtGlJY6RbqU-BQNJnaxGppt3y9AA,372 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_0.pb,sha256=QcocbmgMfN9gR0hQmlBCkMN1MOqyzDtOyL0wDo3HH-s,113 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_1.pb,sha256=txKTRX67rNUdqyDQKt-fzGR7NdzmdWON2-47x_otWBM,66 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_2.pb,sha256=2P30Cd3fFGFSGa7DF8F9KCKvZGxbK5uNUhmU-k69NzE,42 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/output_0.pb,sha256=0Xd_ql2omtRQrJWmryeLNA9btZZH6gbiR8HXP0EDDRA,122 +onnx/backend/test/data/node/test_nonzero_example/model.onnx,sha256=NX71cOVVAavMtXWDgcW3432l9-4BxiHnarj-LJq5fkA,131 +onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/input_0.pb,sha256=ghkps-yp5CRRR8fRbC7fiqWG19bL00TcORlce2Dr8og,23 +onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/output_0.pb,sha256=qoM-JaFSLmJRjNoDvsqY2dR0f6q64MPDvlJtjVR6grg,64 +onnx/backend/test/data/node/test_not_2d/model.onnx,sha256=ZmCCGeOUtVvFmdxC1oaRu2PkbBvnhHQ3Gai3PyrsoKo,96 +onnx/backend/test/data/node/test_not_2d/test_data_set_0/input_0.pb,sha256=LjNp_gf5HfToURj-fOV-TL_10b7cTqoOj8RfPTNPYLQ,23 +onnx/backend/test/data/node/test_not_2d/test_data_set_0/output_0.pb,sha256=JEuquI41JHa3vt29a199NzMyPBW9WvAOkSSADkpkpiU,25 +onnx/backend/test/data/node/test_not_3d/model.onnx,sha256=--Dj2nqyBlRaVxLrtH5BZ-anek--8I4MBmVx6xD6QAo,104 +onnx/backend/test/data/node/test_not_3d/test_data_set_0/input_0.pb,sha256=TWHpMMyqdtQO1GlrLNWX631jO6986ZyG-R4tcfX_k9M,73 +onnx/backend/test/data/node/test_not_3d/test_data_set_0/output_0.pb,sha256=-oL9DNgUrH4pCs7vwUYL5uq1Las7wPU-F4ZJSVNExrY,75 +onnx/backend/test/data/node/test_not_4d/model.onnx,sha256=_GXaFJpy_nuIiMqj2PyWLjPP7FfBx6eaxaujJNpnGmM,112 +onnx/backend/test/data/node/test_not_4d/test_data_set_0/input_0.pb,sha256=iZjPxHloGhOKJNSczLBvGtYZN5Sen7TAs77gLl8-eJA,376 +onnx/backend/test/data/node/test_not_4d/test_data_set_0/output_0.pb,sha256=8PTjOyrS2vPHwwmPn8DXr1_MbVZjMzStaPuHfzenUTI,378 +onnx/backend/test/data/node/test_onehot_negative_indices/model.onnx,sha256=fjlyNhjpN3EFThxhnvvRr7R_IrOBnSZ1v47WdW2X3c0,188 +onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_0.pb,sha256=F1-tByU4VnMyQFdReEjjeChbk03-iM4AH8zk9QNM1QQ,39 +onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_1.pb,sha256=SniLudwpo_9h-MMMuoLXqe1Ulz9W9uSM28WqXjYKBB4,15 +onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_2.pb,sha256=N_K-xBM0o6Y0qLA8Ml_8Q69xVU7fEZBZDFDFtXN5gYo,22 +onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/output_0.pb,sha256=5HdC9_F-HsrRLzGONydCDeMC2U1U7qJAOglTi8kUsWE,131 +onnx/backend/test/data/node/test_onehot_with_axis/model.onnx,sha256=7Tn4gjOHr5C80bna6RBkHEvFdSKx5ucs4Mw29ScjCKI,189 +onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_0.pb,sha256=qPjxHytD_tom84Yx4twm4SstHXXF6aMSkw1A0I1NzHs,33 +onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_1.pb,sha256=SniLudwpo_9h-MMMuoLXqe1Ulz9W9uSM28WqXjYKBB4,15 +onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_2.pb,sha256=N_K-xBM0o6Y0qLA8Ml_8Q69xVU7fEZBZDFDFtXN5gYo,22 +onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/output_0.pb,sha256=bu2Cxu0sCAAENGCwmOdA4QRBlbkqJBMAxunzVkOUbIs,174 +onnx/backend/test/data/node/test_onehot_with_negative_axis/model.onnx,sha256=f8RCLQLUojpYObQA3yVz6ZEGA350Ak1TdU48FyZSrd0,207 +onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_0.pb,sha256=qPjxHytD_tom84Yx4twm4SstHXXF6aMSkw1A0I1NzHs,33 +onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_1.pb,sha256=SniLudwpo_9h-MMMuoLXqe1Ulz9W9uSM28WqXjYKBB4,15 +onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_2.pb,sha256=N_K-xBM0o6Y0qLA8Ml_8Q69xVU7fEZBZDFDFtXN5gYo,22 +onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/output_0.pb,sha256=bu2Cxu0sCAAENGCwmOdA4QRBlbkqJBMAxunzVkOUbIs,174 +onnx/backend/test/data/node/test_onehot_without_axis/model.onnx,sha256=U0MILFaATSHjw9zDIMB4sRTqS_roPxfMWY6J84vV80o,171 +onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_0.pb,sha256=ta7hFCjVAb1WUU9sgiAov4CmflwgDNr3ak4YwDYUcxs,39 +onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_1.pb,sha256=4Ww8eBVFbMYzzKNzz3vLhRTT7_zLFojaP213mTFSVvU,15 +onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_2.pb,sha256=N73BjNA73IsU2QnQRSOqdYwn0AZlbwJonbgfKwmjLnU,22 +onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/output_0.pb,sha256=O8e-sVvv0ez-QO3vJ6e5qiVmVID9fwqfA1bgs3uHKyA,156 +onnx/backend/test/data/node/test_optional_get_element_optional_sequence/model.onnx,sha256=cKBCcL2XcDo1Y-HE02G7OEjeuqc_7V9tbNCP_4s00T8,174 +onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/input_0.pb,sha256=vpd8FwYbVh9wyMZ9xsWKs5AxADA98-eucJKMK8T-tU0,46 +onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/output_0.pb,sha256=PTgucfFItJi7etGLkHgc63wqJeAs5Fm_jZEdQGFHH_k,34 +onnx/backend/test/data/node/test_optional_get_element_optional_tensor/model.onnx,sha256=Kc4P3uTKFr35Ezt5zmkEDu8KFHxj3ipovRpfB7E8OR4,170 +onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/input_0.pb,sha256=A-AbnXPvbH-QEhigtVShIBP4Fxgyw6jbvckX2cSUAlM,42 +onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/output_0.pb,sha256=vSCHzMFSvur8t7ADW1BDQbERwPltOiCd-JuPcQ6-XcQ,30 +onnx/backend/test/data/node/test_optional_get_element_sequence/model.onnx,sha256=r2cz0m_Z6oUSQ3MpWM2huW1MfIB9tNN3qfUunUpkYm8,161 +onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/input_0.pb,sha256=mw1O20tvt7b6NaD0nRT-YqH7HmJARdY9dK4rnHwQ8_E,42 +onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/output_0.pb,sha256=PTgucfFItJi7etGLkHgc63wqJeAs5Fm_jZEdQGFHH_k,34 +onnx/backend/test/data/node/test_optional_get_element_tensor/model.onnx,sha256=smEO352xSf3_ms-9u2kyG5NKsJV_SBji5n1wP666qAk,157 +onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/input_0.pb,sha256=uUsn8ZJZNXJMkBUOaeS4pl1SPQtNedl6dZNV_MGJE90,38 +onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/output_0.pb,sha256=vSCHzMFSvur8t7ADW1BDQbERwPltOiCd-JuPcQ6-XcQ,30 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/model.onnx,sha256=gCOrPv1m7gcQjjBim0-S8q0RFs1erBi31VkyHuT3Yl8,136 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/model.onnx,sha256=wUjCLI9sTzqKZV8slgHm50AdjHBPULNsO-UywuHZZl0,134 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/model.onnx,sha256=fcThUtkxSofwsh9bpW_1o_zI2QwbYX7e1RN4mx2GzqM,129 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/model.onnx,sha256=B8L4KqEAU6oYpjOcXpByxFtlNK7AznjTdImTR7vAbQo,127 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/model.onnx,sha256=lhf09ImdqqoFt2WX5kuR9OH1ihyT85AOhSjgZX_dQzo,167 +onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/input_0.pb,sha256=wv94C5xbz5m4GuMdyxohS6Lqilkq4fNCzFygsTgGIPs,18 +onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_optional_input/model.onnx,sha256=oZsbFysfy2fzzLDLaRl5pp6yAKt_JBLQwYKKbCb_O5M,165 +onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/input_0.pb,sha256=A-AbnXPvbH-QEhigtVShIBP4Fxgyw6jbvckX2cSUAlM,42 +onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/output_0.pb,sha256=hpn8eiTjKgyiZryvhHYl3b_SKNz3D9ZMneyziZ0AkvA,13 +onnx/backend/test/data/node/test_optional_has_element_tensor_input/model.onnx,sha256=uU1Svb-zZhq-bhKKY5XCI1gDnmfKllnJOvDEK7JrfmA,163 +onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/input_0.pb,sha256=A-AbnXPvbH-QEhigtVShIBP4Fxgyw6jbvckX2cSUAlM,42 +onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/output_0.pb,sha256=hpn8eiTjKgyiZryvhHYl3b_SKNz3D9ZMneyziZ0AkvA,13 +onnx/backend/test/data/node/test_or2d/model.onnx,sha256=YxZyfgzueJXXO82yAk2d0oFy_YCthbGNgd1ZHuDZ7WU,115 +onnx/backend/test/data/node/test_or2d/test_data_set_0/input_0.pb,sha256=LjNp_gf5HfToURj-fOV-TL_10b7cTqoOj8RfPTNPYLQ,23 +onnx/backend/test/data/node/test_or2d/test_data_set_0/input_1.pb,sha256=goZmxegiEZPjRTXScUiQU9fpxPndF4EqAZy8oeToa8k,23 +onnx/backend/test/data/node/test_or2d/test_data_set_0/output_0.pb,sha256=5Xl0XiY-aaQiF0RTwPftqw-gxf2WK-W0mXlMNdMDSyc,24 +onnx/backend/test/data/node/test_or3d/model.onnx,sha256=14UsGEpmYYb9juxWEBxdx89196ZQU8cWRIawcP-mbWs,127 +onnx/backend/test/data/node/test_or3d/test_data_set_0/input_0.pb,sha256=Dr4k5dppNqEaWmFsMUXw_Pbp7QoEpqkXv4Bodqt7zMQ,73 +onnx/backend/test/data/node/test_or3d/test_data_set_0/input_1.pb,sha256=v5SpTzEGQijgxpt3GQdqFdpD-LCqlDgrPace75EL5pQ,73 +onnx/backend/test/data/node/test_or3d/test_data_set_0/output_0.pb,sha256=mw8NzywgY2NAFHAr4f4QQLIffghFyfSifzaeN457XRI,74 +onnx/backend/test/data/node/test_or4d/model.onnx,sha256=bKfqW6lqdxp4zZ8X7G6MD1eyfUCI2TS9qECPjystd3s,139 +onnx/backend/test/data/node/test_or4d/test_data_set_0/input_0.pb,sha256=sMKxU5gNQx6mv89ZOkmV0QCdEu9f8EhE-MZuoWNbcek,376 +onnx/backend/test/data/node/test_or4d/test_data_set_0/input_1.pb,sha256=9JaUvXVRf_NYTRwYWtPYsbSoKJDwOXPZuRBgFY7pYPc,376 +onnx/backend/test/data/node/test_or4d/test_data_set_0/output_0.pb,sha256=NWaSdDXxpWJ2G5_V1j1D4xBCLVAfA5AibswMzTatBs4,377 +onnx/backend/test/data/node/test_or_bcast3v1d/model.onnx,sha256=cXjsmeVsR0T2G5yMsihChNeQN_zpdqJ6i6IbPlJi5RA,127 +onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_0.pb,sha256=wF52hvLEXCfryTN0FvgWPKXSx3PPlpiaC_aAZ5IXCMc,73 +onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_1.pb,sha256=0cP0kHJ95VbmGsyJW3rlozPO38YQocSctc5buLas0ZI,14 +onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/output_0.pb,sha256=j0nTh8QRsYHOGVMoWh_46oB-6On3aBJH4SI24vIohRI,74 +onnx/backend/test/data/node/test_or_bcast3v2d/model.onnx,sha256=G9GQtIbSTfAFO3EFW38ioWu9y_2NkgU1Iav8Ci5HCrs,131 +onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_0.pb,sha256=2Hi5gZzCyk3SWtB8dhtS5tIMipISnPJGI1SIjx08Fe0,73 +onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_1.pb,sha256=J1neLsOqZHTvGdagBF8_3O6sQk1byuUIMABR0wJxASA,31 +onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/output_0.pb,sha256=Glafui2pjURlqmm1rfvld49F1orTOyvv3DaBtU3j1gI,74 +onnx/backend/test/data/node/test_or_bcast4v2d/model.onnx,sha256=TZJalmR1gazv8940_76Fk0UXbxLJLqVAKlZnbMATqKI,139 +onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_0.pb,sha256=TG9PpNJBW-rhSdwYDpmwCMotWc8SOe2e2cLAoXaNQ8o,376 +onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_1.pb,sha256=D4JIlfVUzijC8rk152pkPsDWa33YJRlmutjMvkT-1FI,41 +onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/output_0.pb,sha256=3VcBGGnUIc16zDtVFdh1ecfxPo5Amdeloer8Gs6iGWc,377 +onnx/backend/test/data/node/test_or_bcast4v3d/model.onnx,sha256=fgL1jyS62RVe7hVUtiNc0VXR-Qi_Hd-D6QAhvFN54ns,143 +onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_0.pb,sha256=1gaunFCw_HO0ZAf_sAp9bfcwVRJW_aTJIwkv-2WYWMw,376 +onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_1.pb,sha256=26gLYNI9eQESqKzWzx1zrE8YDDCNIvfAE_0m_FoeT3E,133 +onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/output_0.pb,sha256=L4Mruier4Yg6xS5HZXDfBii0EK9xF13r_INAS00D8fU,377 +onnx/backend/test/data/node/test_or_bcast4v4d/model.onnx,sha256=0jt8W5Qyv_1nUR5K7fMmga8rLmjsjePDZvS7ZKtdnkc,147 +onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_0.pb,sha256=f63fGhPch5eTkAvMXCrJTC0FOIdhKnaSfJ8Ox9hnol0,39 +onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_1.pb,sha256=iCGDAU6H1-WHvqKKRCD44UWeluKsnFCWMpevbsJ5ASU,105 +onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/output_0.pb,sha256=FDGBOwzj2VIUJgfnXU22QetJ_GOkZCqrZ27em-O04Lk,377 +onnx/backend/test/data/node/test_pow/model.onnx,sha256=oSi3o33WPiiwEEtIqeL8xWz5h2VGhoieq2vfZxsTdkM,125 +onnx/backend/test/data/node/test_pow/test_data_set_0/input_0.pb,sha256=AY_VMGnKJBQrw98tz_qYFRZu6obuXC-dGQyJjKrKjKo,254 +onnx/backend/test/data/node/test_pow/test_data_set_0/input_1.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_pow/test_data_set_0/output_0.pb,sha256=y-34eZm7CPL6irwI7C6amp564eVmFsIb9OvVtgp0cjg,254 +onnx/backend/test/data/node/test_pow_bcast_array/model.onnx,sha256=aWkVJssCZgZJkRcz1r9097G5eEy7N-yy2FhQszIXYeQ,121 +onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_0.pb,sha256=4pQ6jBxU8_tBNnaRVRgYgck68GhQp-YW_tL388GcCvE,35 +onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_1.pb,sha256=KW9J7uTWmyfHYqYwYwZyv64IeAl6_iDrPha7DI-bhcU,21 +onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/output_0.pb,sha256=oINJYm3arnswSBGkl8GBHl_T8_2yIhrVB53JwpiKAvE,35 +onnx/backend/test/data/node/test_pow_bcast_scalar/model.onnx,sha256=UuP9qM1PUFNvkdMvtnuBcHQ2-HIMkO6eRJ6v5JzOkBc,110 +onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_1.pb,sha256=ydsAlIsWhTc_J1CFdrtsGmByX5clFiagrVStpbLbEm4,11 +onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/output_0.pb,sha256=KJlLjivIdBlVq1m1jgyIwPU5tSpNIjw-blrFrPmtr3Q,21 +onnx/backend/test/data/node/test_pow_example/model.onnx,sha256=W--GGh80r5ebmjKz0wJSx74FtnlQW26I5-rqJ3Pe_sk,109 +onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_1.pb,sha256=CRO596M4hKvMtegi6TFu8eNUs-prhD7vkphHojkzBj4,21 +onnx/backend/test/data/node/test_pow_example/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_float32_int32/model.onnx,sha256=dxLTq6DJ-ekrMCQY4IxPqzB5oIDKNcEJDFKWNTk4iO8,121 +onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_1.pb,sha256=r8BFGDyB4p4Qqn72TCCqllX4VYjNBD2WqlCAVxUuF10,21 +onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_float32_int64/model.onnx,sha256=bva03rFSbrJ18uJMKS5oBQTMI8XdxebRhodAICC0M7c,121 +onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_1.pb,sha256=-Mz9howslt6OFLvLPy_8aC6Z7H6lpX4ULsCU9rbuITQ,33 +onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_float32_uint32/model.onnx,sha256=8Pbwtz_fJDSXpX-bstlXsg6MCAanm_cXB4VcH2dYDVQ,122 +onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_1.pb,sha256=58O5vvDhR1HzOWUoqyt2e86myJ4FYDger-v8DT6IeR0,21 +onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_float32_uint64/model.onnx,sha256=oX2b_ITd8r-Hl9OeBki0iVT5oNggIYhN_0AAHIUTiRA,122 +onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_1.pb,sha256=yY4W3jqfz1Qc7B9EKL41WxTKzhmiwQlgkd_3eJoJtQA,33 +onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_int32_float32/model.onnx,sha256=lEyY8p-kFy2-Um7rIKeF2W6wSppZvfBrYuUdWS-KNEI,121 +onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_0.pb,sha256=nXGXrHzTelDfYXqyN-ePUSAnKkGHHf4Em7tfQoCy8gI,21 +onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_1.pb,sha256=CRO596M4hKvMtegi6TFu8eNUs-prhD7vkphHojkzBj4,21 +onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/output_0.pb,sha256=5HGZJaBp_kTdE1qP63n0RHw17mLW6osJWWIKcdTAPRE,21 +onnx/backend/test/data/node/test_pow_types_int32_int32/model.onnx,sha256=b94RDUFctnJPBTWKCC3gXLaM152e7zkloWeyZpqGsnU,119 +onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_0.pb,sha256=nXGXrHzTelDfYXqyN-ePUSAnKkGHHf4Em7tfQoCy8gI,21 +onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_1.pb,sha256=r8BFGDyB4p4Qqn72TCCqllX4VYjNBD2WqlCAVxUuF10,21 +onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/output_0.pb,sha256=5HGZJaBp_kTdE1qP63n0RHw17mLW6osJWWIKcdTAPRE,21 +onnx/backend/test/data/node/test_pow_types_int64_float32/model.onnx,sha256=h4Bky73HUDVZ3HfCJr8Bd-mmkMeQq-Lmktqp5NxZL-s,121 +onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_0.pb,sha256=_cGeaGhZxcfOOmaCCsiTo_hNZRp2Zxo91TaoYiWtOAM,33 +onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_1.pb,sha256=CRO596M4hKvMtegi6TFu8eNUs-prhD7vkphHojkzBj4,21 +onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/output_0.pb,sha256=zDXqkOFSIfyWuTMnQxcIRhTC-wGpB5rhBrjWeAOZdLw,33 +onnx/backend/test/data/node/test_pow_types_int64_int64/model.onnx,sha256=aobGdTeCPRQjcsm-0MQ55aszgjd3WW1DU5Po3uzsoKw,119 +onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_0.pb,sha256=_cGeaGhZxcfOOmaCCsiTo_hNZRp2Zxo91TaoYiWtOAM,33 +onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_1.pb,sha256=-Mz9howslt6OFLvLPy_8aC6Z7H6lpX4ULsCU9rbuITQ,33 +onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/output_0.pb,sha256=zDXqkOFSIfyWuTMnQxcIRhTC-wGpB5rhBrjWeAOZdLw,33 +onnx/backend/test/data/node/test_prelu_broadcast/model.onnx,sha256=VOu6i8tiLpeQK6YWXdF7oJCXK-4WT3E0bDszBxRc4l4,139 +onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_1.pb,sha256=zCWXggDw6QArEHtYuiVS23cWS2G7lNjtq_XeeHy65sc,33 +onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/output_0.pb,sha256=KmwLJ-2oKWwwgugpBrNYG2ynhsgvc_0m_vdW_NCbEFI,254 +onnx/backend/test/data/node/test_prelu_broadcast_expanded/model.onnx,sha256=3VpORuXsca8Ufl65oJO1bkyRLQZ-KJS3La0KlcSTQbU,676 +onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_1.pb,sha256=zCWXggDw6QArEHtYuiVS23cWS2G7lNjtq_XeeHy65sc,33 +onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/output_0.pb,sha256=KmwLJ-2oKWwwgugpBrNYG2ynhsgvc_0m_vdW_NCbEFI,254 +onnx/backend/test/data/node/test_prelu_example/model.onnx,sha256=fTqBhgsJarObGlLYNycwzJD2NIggfMg4_pjC0LrZ_c8,145 +onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_1.pb,sha256=t8-Rs14nU1gM46Bqcj7DCLL8KQt3PwZNrP-n6Yxs050,258 +onnx/backend/test/data/node/test_prelu_example/test_data_set_0/output_0.pb,sha256=hkpum_lGz_jBnbvAIljQ9y5IzwU1AbXJRLXvIuVCK5I,254 +onnx/backend/test/data/node/test_prelu_example_expanded/model.onnx,sha256=Pu-_pG45_wdvyBPfSRxzgpHH-Ou7-y5XY7K7ls2Fh_4,665 +onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_1.pb,sha256=t8-Rs14nU1gM46Bqcj7DCLL8KQt3PwZNrP-n6Yxs050,258 +onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/output_0.pb,sha256=hkpum_lGz_jBnbvAIljQ9y5IzwU1AbXJRLXvIuVCK5I,254 +onnx/backend/test/data/node/test_qlinearconv/model.onnx,sha256=bqDrNQcDv3Qw4DbA2a6-uTWtkLlPxWm1Sk9EJa0uOKk,360 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_0.pb,sha256=nixNRkyGN_KgVkWV5xeFSwW2P9g5MGBOe-fgB5gW744,64 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_1.pb,sha256=a9DMFXaeuYAOi_FHwlb4SDFEqpxh_gwHrH06td0hjQ0,17 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_2.pb,sha256=afKUomTgzPpltKVwfiOFEPSOezG6ntRvqW9enoddjJA,19 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_3.pb,sha256=YDlA6BZ9CIGFwKl9IfXE7vxH2gKpIftKThESMEtEHgI,16 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_4.pb,sha256=kdHz8BDgovMXRdFV-OaK5z36bbaWGT3-ZI0h6qw2uh0,19 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_5.pb,sha256=CQhc7l4YdSLie9L3sGF-eLE3KZIxewlTFTmvOmZRym0,21 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_6.pb,sha256=T4bbtORqnLDgoXiJlaOQ2C-Rbwqp2nQ_t4VN6Rbc84Y,17 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_7.pb,sha256=qrW9JA42dIlWU4LSxNQEZVx6ktF-KAhGf4gYgy-4bX4,19 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/output_0.pb,sha256=fXjZHJuLHRtyTJIj46iMB6A-32OAXHixEdz5OWZ7t0E,64 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/model.onnx,sha256=YMtaZlgncQFarWKRaFS5GHxrmep7nShkNyCJSftAth8,372 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_0.pb,sha256=EW4KzwC4IDcjv5uG14lyLOx9ieD3E6OQZtnO4MAhlb4,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_1.pb,sha256=nnYTBKWGRnIW1s-p2ROJAwiL-Q_M_TS4m-kBAjuFaGQ,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_2.pb,sha256=NJ1z8xFynGtHNA3xluGHxNKI2mU5GMzAIylBdZbSfBQ,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_3.pb,sha256=3Su8-6njxvvsNh2-C2VxCrZM3hlJwOe61sBe77Uxbx4,23 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_4.pb,sha256=DhgPgyPecHsoTXjdgqQ9dUHJ0gm2K3tgCqnHKrtsRdE,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_5.pb,sha256=sszTS9AFBbYJkRJC3oCoh6AGx-2IVOprE3COEL-ItUg,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_6.pb,sha256=0LyvWUhWqNYVSVkJKOqXWcG3Sjz_wdXBmxGG9aCTtjI,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_7.pb,sha256=MgU6P2x2sZyaqZX7fIx-qw7Rq97TpHkcRbW0NmZMQdU,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/output_0.pb,sha256=AdJqHiAKsIiyzKI6hnZ3i0bPSbwpdeMTkBJBIlO3KpQ,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/model.onnx,sha256=d57daBhbC2v11IXbHl2jYMBPq6m4se7lcvuurqxok20,372 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_0.pb,sha256=EW4KzwC4IDcjv5uG14lyLOx9ieD3E6OQZtnO4MAhlb4,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_1.pb,sha256=aVsxHksGQU9JCf5giP1I5HpY1f659W0A0y09s5oXTVQ,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_2.pb,sha256=NJ1z8xFynGtHNA3xluGHxNKI2mU5GMzAIylBdZbSfBQ,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_3.pb,sha256=3Su8-6njxvvsNh2-C2VxCrZM3hlJwOe61sBe77Uxbx4,23 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_4.pb,sha256=-XzmSr1oi7OP_jzKt5I8dd4ZiHXLfgttDVHG9h02Asc,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_5.pb,sha256=sszTS9AFBbYJkRJC3oCoh6AGx-2IVOprE3COEL-ItUg,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_6.pb,sha256=f9fGFxkJMhbFB3Jha4dcX2nTB0pIclfxri5tXYpZZwc,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_7.pb,sha256=MgU6P2x2sZyaqZX7fIx-qw7Rq97TpHkcRbW0NmZMQdU,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/output_0.pb,sha256=AdJqHiAKsIiyzKI6hnZ3i0bPSbwpdeMTkBJBIlO3KpQ,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/model.onnx,sha256=eSmBLskSpRr71KchtmlSd-inYHC_UMky6kGwKFo9_Q8,373 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_0.pb,sha256=ko9ZfhAcGp41Zcl0RgwHA7UB-6Iqkc0hqXnViR7c-2M,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_1.pb,sha256=nnYTBKWGRnIW1s-p2ROJAwiL-Q_M_TS4m-kBAjuFaGQ,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_2.pb,sha256=pPLPbQiq1ONgy164_MHBnJM4nH5E_tZbcoFV5sPOYUY,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_3.pb,sha256=oIvG3PVjz2QeQCzNzI9o9errRsMMNpLyCqVPNflcHAY,23 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_4.pb,sha256=DhgPgyPecHsoTXjdgqQ9dUHJ0gm2K3tgCqnHKrtsRdE,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_5.pb,sha256=CbDV3Ys31D0hYZkLMhnYjqA2TCsFoiAB6Osr8BXOleg,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_6.pb,sha256=0LyvWUhWqNYVSVkJKOqXWcG3Sjz_wdXBmxGG9aCTtjI,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_7.pb,sha256=ATdkTkCLK9NqW-0ctLP0ByOjC9HDFf6P3w_fAVQhiQc,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/output_0.pb,sha256=Fbb3q876qubUQlK88YFKv7lCDKrp0pAA5yddHKodoqc,17 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/model.onnx,sha256=-emyASzk9mYzpvEklornS-KJAwVgO-ZumIFM81iWm1s,373 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_0.pb,sha256=ko9ZfhAcGp41Zcl0RgwHA7UB-6Iqkc0hqXnViR7c-2M,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_1.pb,sha256=aVsxHksGQU9JCf5giP1I5HpY1f659W0A0y09s5oXTVQ,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_2.pb,sha256=pPLPbQiq1ONgy164_MHBnJM4nH5E_tZbcoFV5sPOYUY,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_3.pb,sha256=oIvG3PVjz2QeQCzNzI9o9errRsMMNpLyCqVPNflcHAY,23 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_4.pb,sha256=-XzmSr1oi7OP_jzKt5I8dd4ZiHXLfgttDVHG9h02Asc,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_5.pb,sha256=CbDV3Ys31D0hYZkLMhnYjqA2TCsFoiAB6Osr8BXOleg,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_6.pb,sha256=f9fGFxkJMhbFB3Jha4dcX2nTB0pIclfxri5tXYpZZwc,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_7.pb,sha256=ATdkTkCLK9NqW-0ctLP0ByOjC9HDFf6P3w_fAVQhiQc,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/output_0.pb,sha256=Fbb3q876qubUQlK88YFKv7lCDKrp0pAA5yddHKodoqc,17 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/model.onnx,sha256=4CGBeH4fTxLxAlyrZ5QB4K8oEE6ELvaXTcCqOEx8u8Y,384 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_0.pb,sha256=oKrfJZoWsHvS6q36ryQqtu4sdYzHFxTYSYA1qPIXfTI,29 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_1.pb,sha256=nnYTBKWGRnIW1s-p2ROJAwiL-Q_M_TS4m-kBAjuFaGQ,17 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_2.pb,sha256=NJ1z8xFynGtHNA3xluGHxNKI2mU5GMzAIylBdZbSfBQ,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_3.pb,sha256=7-xca2r8N2Vyt3Qpje0wnsi65Uj65ieur9wJdQxMKj8,37 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_4.pb,sha256=DhgPgyPecHsoTXjdgqQ9dUHJ0gm2K3tgCqnHKrtsRdE,17 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_5.pb,sha256=X3jdM38tfezX3Z13EbQ5utaQCL2WXxq20jkn0xl9OaU,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_6.pb,sha256=0LyvWUhWqNYVSVkJKOqXWcG3Sjz_wdXBmxGG9aCTtjI,17 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_7.pb,sha256=MgU6P2x2sZyaqZX7fIx-qw7Rq97TpHkcRbW0NmZMQdU,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/output_0.pb,sha256=_C8dr4uWlLaa9_LvZL_450sWmuipkHLbQmEJEvIdzqw,25 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/model.onnx,sha256=8Jjd7cBRcCKVzU_JBD3bWNH3v5KthcxMa2NX6NZoe24,384 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_0.pb,sha256=oKrfJZoWsHvS6q36ryQqtu4sdYzHFxTYSYA1qPIXfTI,29 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_1.pb,sha256=aVsxHksGQU9JCf5giP1I5HpY1f659W0A0y09s5oXTVQ,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_2.pb,sha256=NJ1z8xFynGtHNA3xluGHxNKI2mU5GMzAIylBdZbSfBQ,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_3.pb,sha256=7-xca2r8N2Vyt3Qpje0wnsi65Uj65ieur9wJdQxMKj8,37 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_4.pb,sha256=-XzmSr1oi7OP_jzKt5I8dd4ZiHXLfgttDVHG9h02Asc,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_5.pb,sha256=X3jdM38tfezX3Z13EbQ5utaQCL2WXxq20jkn0xl9OaU,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_6.pb,sha256=f9fGFxkJMhbFB3Jha4dcX2nTB0pIclfxri5tXYpZZwc,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_7.pb,sha256=MgU6P2x2sZyaqZX7fIx-qw7Rq97TpHkcRbW0NmZMQdU,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/output_0.pb,sha256=_C8dr4uWlLaa9_LvZL_450sWmuipkHLbQmEJEvIdzqw,25 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/model.onnx,sha256=3_zCQ_9VtBCOouPlz7Q5JQEpi8NTeJjysD-LoS49RM0,385 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_0.pb,sha256=g5g_gcA0GltOE1_lFzaVSua7MBYe98NlUfplZayMJtM,29 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_1.pb,sha256=nnYTBKWGRnIW1s-p2ROJAwiL-Q_M_TS4m-kBAjuFaGQ,17 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_2.pb,sha256=pPLPbQiq1ONgy164_MHBnJM4nH5E_tZbcoFV5sPOYUY,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_3.pb,sha256=aRoCSENX6yjHjLkmm5vXFbBpo9EbeGo9RxE94GPJHXQ,37 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_4.pb,sha256=DhgPgyPecHsoTXjdgqQ9dUHJ0gm2K3tgCqnHKrtsRdE,17 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_5.pb,sha256=CbDV3Ys31D0hYZkLMhnYjqA2TCsFoiAB6Osr8BXOleg,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_6.pb,sha256=0LyvWUhWqNYVSVkJKOqXWcG3Sjz_wdXBmxGG9aCTtjI,17 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_7.pb,sha256=ATdkTkCLK9NqW-0ctLP0ByOjC9HDFf6P3w_fAVQhiQc,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/output_0.pb,sha256=rvU4UCTaVhbhfnNv1gl2oCkUQblLDZkbA4uRlSy0Le0,25 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/model.onnx,sha256=1wzomcDWQcy2GltYKKKgVEOn8wHH7T_sJJDJNo2vRXI,385 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_0.pb,sha256=g5g_gcA0GltOE1_lFzaVSua7MBYe98NlUfplZayMJtM,29 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_1.pb,sha256=aVsxHksGQU9JCf5giP1I5HpY1f659W0A0y09s5oXTVQ,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_2.pb,sha256=pPLPbQiq1ONgy164_MHBnJM4nH5E_tZbcoFV5sPOYUY,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_3.pb,sha256=aRoCSENX6yjHjLkmm5vXFbBpo9EbeGo9RxE94GPJHXQ,37 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_4.pb,sha256=-XzmSr1oi7OP_jzKt5I8dd4ZiHXLfgttDVHG9h02Asc,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_5.pb,sha256=CbDV3Ys31D0hYZkLMhnYjqA2TCsFoiAB6Osr8BXOleg,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_6.pb,sha256=f9fGFxkJMhbFB3Jha4dcX2nTB0pIclfxri5tXYpZZwc,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_7.pb,sha256=ATdkTkCLK9NqW-0ctLP0ByOjC9HDFf6P3w_fAVQhiQc,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/output_0.pb,sha256=rvU4UCTaVhbhfnNv1gl2oCkUQblLDZkbA4uRlSy0Le0,25 +onnx/backend/test/data/node/test_quantizelinear/model.onnx,sha256=LD2rgZxW97Bm9Ow-bsvUmsujEA_pbvdijTe8qNAJvZw,170 +onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_0.pb,sha256=-WdUWtE3Gq6XQCRO6yOoTUcsaUMo-gEvqWT8B_Q2ax8,33 +onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_1.pb,sha256=Zv7CydImWalnvbaS5VHQ6zTXvOUCohUym_ClUIDiLJ4,17 +onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_2.pb,sha256=wPEVchEft31jMR00LL9m2McOaC1WYliDhjLWm34U2yA,19 +onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/output_0.pb,sha256=tKPhseg-u9oNXCOVqz3GYbmoR7oSaEtKC0Y5KC4txus,15 +onnx/backend/test/data/node/test_quantizelinear_axis/model.onnx,sha256=_cr96Jcv57SJuZbyU5iVyZblXHhsBOkXe81EV9qbu0k,207 +onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_0.pb,sha256=lOMq5eKWvXmYUXZijznYZGS8ZP7QGcLUOQgOwOc00zE,87 +onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_1.pb,sha256=32ZIocYXlTh3bTOfM1h_XZs3_EDpTAXIivA6ljFghzA,27 +onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_2.pb,sha256=Nm2IkguOQZ3UhRkLUIs3YMzqEG3ssgm0UKDB1bvBKKk,23 +onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/output_0.pb,sha256=qUJeQDCKjzRejnEfE6gC17CDuVDqA6q5MM1F555aFVA,33 +onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/model.onnx,sha256=0qseNvAwh-kUaK3JdZB1fgexg_Tka_7vpTiZoNPA7Yc,245 +onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_0.pb,sha256=y7Rhu8G-uM9JmVW66VI-VnYQbiuRE5sGV_Z6AQuyxkA,59 +onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_1.pb,sha256=v8inhQKQhz6dS_q_JBaaUuy2xp49SRE1THZSwm-QDkA,41 +onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_2.pb,sha256=1un1WVjefFvWOQnshf2LbMhpAQ2QxiXMunRcoT7vMow,28 +onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/output_0.pb,sha256=rElUPp_29s5O54rRjWy1dP0WYzZ6KxmJK0yJuHxE5k8,23 +onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/model.onnx,sha256=oCx2FCduvmAp2xUZoMd5pMlvZG9vi_itIQNIikAKhv0,219 +onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/input_0.pb,sha256=arGehoBobNUspLhRtF3Ex9xKCa0F0y98oL6fRrQvA_s,59 +onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/input_1.pb,sha256=v8inhQKQhz6dS_q_JBaaUuy2xp49SRE1THZSwm-QDkA,41 +onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/output_0.pb,sha256=bycN13RnEpWSK9Kk8K3evE6KopdVTsEVeKRxRfyZ6n8,41 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/model.onnx,sha256=OTXZw9VnmBhFsi6t4qZn9vKFNplg78cUtGY7U4mn1sY,181 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_0.pb,sha256=RpINE2Cg2dhwMgzJm3ZxSLDmJ1q0XwI6WmIHcL_j6Yc,29 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_1.pb,sha256=Zv7CydImWalnvbaS5VHQ6zTXvOUCohUym_ClUIDiLJ4,17 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_2.pb,sha256=_7Vdv5427rLlWyXQDc1ya_9WSxSO8L4LZu_OHnm_FT8,21 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/output_0.pb,sha256=nNu5UvmZ8mpsh_54mZqigNgGwEN8yszynDbulB-hJ5c,14 +onnx/backend/test/data/node/test_quantizelinear_e5m2/model.onnx,sha256=tKv_gX7nsJKYpzmpKylDZyU1IgU9HNN9bH5EV8oJ0pY,179 +onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_0.pb,sha256=RpINE2Cg2dhwMgzJm3ZxSLDmJ1q0XwI6WmIHcL_j6Yc,29 +onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_1.pb,sha256=Zv7CydImWalnvbaS5VHQ6zTXvOUCohUym_ClUIDiLJ4,17 +onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_2.pb,sha256=trfI5bwzv3rDl1dqKlEM_RmOGYCac0PrHNjqYeGXxa0,21 +onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/output_0.pb,sha256=Bk-NH1ZeWwTusSN6X2cuqkFjbYJ1vDxhtJZ592E76fw,14 +onnx/backend/test/data/node/test_quantizelinear_float4e2m1/model.onnx,sha256=8pYBRUdC63W5Y6KrSbET9l3ww6faUwHuXrRk15qK9tA,210 +onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_0.pb,sha256=_x5fzgyqRG8ygg45vesuTo_KQ61ZIUo2owASMRGAjjU,59 +onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_1.pb,sha256=2Pe2lcrRWP5oT1EosWg6ZOv0VcNUIPd__rMnNp0couk,27 +onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_2.pb,sha256=e3e08q3GvFTx2_PeLwT8GUnNOP1Vvo5IZTglmBMBHyQ,22 +onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/output_0.pb,sha256=GeyENRHI8m0NZmId1EofUsxhVOrjufwelJ1wBgAtBSw,20 +onnx/backend/test/data/node/test_quantizelinear_int16/model.onnx,sha256=A817ZCavLj7ZWZXawn_aGIfH0g_ebEM-cZu2zh4HfGw,176 +onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_0.pb,sha256=VmE8fR23t887aluLk_qjxKg-S07NoLxCSje5xyEL5NI,73 +onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_1.pb,sha256=Zv7CydImWalnvbaS5VHQ6zTXvOUCohUym_ClUIDiLJ4,17 +onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_2.pb,sha256=IW96bAqV6F71uF1t7ICNMPFMR_nVLfIPA7W1KdkU4B4,20 +onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/output_0.pb,sha256=fO4cGgMJoTMHPXyb7Zk8-8od4K7pei-IdioLjClPpmM,41 +onnx/backend/test/data/node/test_quantizelinear_int2/model.onnx,sha256=t4MjuAgt7tQcNY_rqZhbHEPvVL-lPP6TE40qJ0u5_xM,204 +onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_0.pb,sha256=BsaAybZAws7W11xs89WVRhdhLw3j_s-it729oJ1mFyY,59 +onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_1.pb,sha256=2Pe2lcrRWP5oT1EosWg6ZOv0VcNUIPd__rMnNp0couk,27 +onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_2.pb,sha256=RDsG4xY1Y_ePorUE-x0E9Nv3LSOyyFTNmlSYFvfuCqg,21 +onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/output_0.pb,sha256=X25E-N6tNRfa6UfpXqrXQcWOWd4nA0mVJU2izrc_i3E,15 +onnx/backend/test/data/node/test_quantizelinear_int4/model.onnx,sha256=DNCLHxnNu-4ULiZV4RJICZB2fmxyeDucBR0hnAcHosA,204 +onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_0.pb,sha256=Lg7BLkDJVhKNTmTszgJp0eK_i1afP0XARGAXTfNFdeQ,59 +onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_1.pb,sha256=2Pe2lcrRWP5oT1EosWg6ZOv0VcNUIPd__rMnNp0couk,27 +onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_2.pb,sha256=1d3dNu_2t0cVW-a0345YfmGWH3i1K_8DOgi_jg-eIdA,22 +onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/output_0.pb,sha256=Y8UW6_XGB7CQP9OELbYRI2JNDII0bechX_9Pbg-fNvs,18 +onnx/backend/test/data/node/test_quantizelinear_uint16/model.onnx,sha256=2p8T9Kq-P5Ja3O1Wh7Rsiwuu0zjM4xp_YoRr_4xb1l8,177 +onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_0.pb,sha256=HBChWZzpiiAckJ1Lx-CShRBJIZz9e-vcIp8no74kWhI,57 +onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_1.pb,sha256=Zv7CydImWalnvbaS5VHQ6zTXvOUCohUym_ClUIDiLJ4,17 +onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_2.pb,sha256=jzinJ02Qb3DPCHtpjg5UfGdMvuKAiNXwqDBpDUaDXVY,20 +onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/output_0.pb,sha256=MbBTwcF-NDF361Rl6ouA8W4Nbyjc9TMYrLFJnhRAAGk,33 +onnx/backend/test/data/node/test_quantizelinear_uint2/model.onnx,sha256=8YVH7nuPG141-plJykF82sv3JbVQ-CZwrNI5UB3cVY8,205 +onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_0.pb,sha256=RrQ7HBZCM4-he7fnsQX8Z9CHSpGiugt6l3zcwMViWNg,59 +onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_1.pb,sha256=2Pe2lcrRWP5oT1EosWg6ZOv0VcNUIPd__rMnNp0couk,27 +onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_2.pb,sha256=4CNOo9ZEs5iUMs9bLTSPfQq8FTnDLwVhdRDTj9Qu4EQ,21 +onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/output_0.pb,sha256=xSQpbSPgugWWMu84f2AcJOKXnkSkHHS1VHXmY0kOxCc,16 +onnx/backend/test/data/node/test_quantizelinear_uint4/model.onnx,sha256=-tfE0Tf3E1TtcRJDAo0SXkJPavUghEn8Q_LaP6YK_GI,205 +onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_0.pb,sha256=Lg7BLkDJVhKNTmTszgJp0eK_i1afP0XARGAXTfNFdeQ,59 +onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_1.pb,sha256=2Pe2lcrRWP5oT1EosWg6ZOv0VcNUIPd__rMnNp0couk,27 +onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_2.pb,sha256=iIP2U9MJwQa9ghUcuN8tpW91KGfsrp1Q8akf22lwe2M,22 +onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/output_0.pb,sha256=8q530wXE297IpPg4EiJTOU3f4gDmaAuZgtD9-UT2vyM,18 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/model.onnx,sha256=N3el7B4niCkkoeyhcuD-PMVgxxxgtzukqf9LRye45b8,177 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_0.pb,sha256=m8GGyyb9SWwi3z8Vjx4z79g9sohlJfrCTllyrcpMsSk,13 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_1.pb,sha256=W684bLsuenaXXvoHDIk_Ql88BUgr6g9xe2j6WEeO49k,13 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_2.pb,sha256=iNR1T2bxKf_1tX8N7nsimHzY3ZfvlBpD_uQj_sozyXc,13 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/output_0.pb,sha256=4li14Srls6ooiIRh0jWWGIb5wc8l4oyK3fNl-cvaJCI,18 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/model.onnx,sha256=BcagxEVfRYUUJyn_GorWo9cDALD5C3ZSTQSpq4q6fLU,3091 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_0.pb,sha256=m8GGyyb9SWwi3z8Vjx4z79g9sohlJfrCTllyrcpMsSk,13 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_1.pb,sha256=W684bLsuenaXXvoHDIk_Ql88BUgr6g9xe2j6WEeO49k,13 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_2.pb,sha256=iNR1T2bxKf_1tX8N7nsimHzY3ZfvlBpD_uQj_sozyXc,13 +onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/output_0.pb,sha256=4li14Srls6ooiIRh0jWWGIb5wc8l4oyK3fNl-cvaJCI,18 +onnx/backend/test/data/node/test_range_float16_type_positive_delta/model.onnx,sha256=MTRZMuhH3rDMcDAsb9CcFBxZGrI4QeJWveu5VoxdceY,176 +onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_0.pb,sha256=CrrgOSderfHU5L9hUC-BawKYwLo4Uk5D6qJnx4BJ3kE,13 +onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_1.pb,sha256=8NtkHBZqRyAvc4A9-7U9qk4VqTBaXnzdlmf8V8wSvT4,13 +onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_2.pb,sha256=JNIVh_b36TWKHQPFO5rpii0koAsxoE5Sg1V6O9WQTCE,13 +onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/output_0.pb,sha256=oPmcBKuet38rmUzdqps9-v-wp5aSmsgknirXtkRBCSo,18 +onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/model.onnx,sha256=ix3qisxTkd9cmDLTad1gqALA1RcF4xRchDna5do_X-M,3054 +onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_0.pb,sha256=CrrgOSderfHU5L9hUC-BawKYwLo4Uk5D6qJnx4BJ3kE,13 +onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_1.pb,sha256=8NtkHBZqRyAvc4A9-7U9qk4VqTBaXnzdlmf8V8wSvT4,13 +onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_2.pb,sha256=JNIVh_b36TWKHQPFO5rpii0koAsxoE5Sg1V6O9WQTCE,13 +onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/output_0.pb,sha256=oPmcBKuet38rmUzdqps9-v-wp5aSmsgknirXtkRBCSo,18 +onnx/backend/test/data/node/test_range_float_type_positive_delta/model.onnx,sha256=gSih8O-SK_LLtE0mvLSzxtocsc9NKGJTRpFKVo11dTU,174 +onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_0.pb,sha256=PnwKkhwnmd5quiS20ZgN5aEPgWHukh4Z1L_5tQBqFMg,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_1.pb,sha256=OT2i3PvMIECBJbEVaUsUV8vy3vq8W619CaqivcgRoFg,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_2.pb,sha256=_Azn8KSvchMQKs1IHINUFQPQxYbtW9YaipLS2VsJGOE,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/output_0.pb,sha256=CWcrRK3j1PGFEpIxuIl7JKnveAGbOMams_iDdcqFhJA,22 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/model.onnx,sha256=xKXsGuzDVU8quupNBb-C0c6lZmIwbaemLW3r7-wGZfs,2647 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_0.pb,sha256=PnwKkhwnmd5quiS20ZgN5aEPgWHukh4Z1L_5tQBqFMg,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_1.pb,sha256=OT2i3PvMIECBJbEVaUsUV8vy3vq8W619CaqivcgRoFg,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_2.pb,sha256=_Azn8KSvchMQKs1IHINUFQPQxYbtW9YaipLS2VsJGOE,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/output_0.pb,sha256=CWcrRK3j1PGFEpIxuIl7JKnveAGbOMams_iDdcqFhJA,22 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/model.onnx,sha256=fDPjkxEMWWAd7GukUr1RK8R4kv-YcKz_2gZEAE8A0is,174 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_0.pb,sha256=IcldFo4nLQkGvXdxZT-tL5zhETapZc_ycbchk-cBlP8,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_1.pb,sha256=uNYgLVHrZEoHuuPTegF9h62BtRk4kWwhnCcH08WlTO4,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_2.pb,sha256=85Fwi4unXUNic9TUurAeph_M0WclGePlXKxTJkarxr8,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/output_0.pb,sha256=Km4G9yM-_Q369BPQXgij7_N3dWiC05nccMJvbVkCwOY,22 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/model.onnx,sha256=EyMrn231WZ-UbOkQBcxJH1d4I8ZFm4PQ3cWewlYmbyI,2647 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_0.pb,sha256=IcldFo4nLQkGvXdxZT-tL5zhETapZc_ycbchk-cBlP8,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_1.pb,sha256=uNYgLVHrZEoHuuPTegF9h62BtRk4kWwhnCcH08WlTO4,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_2.pb,sha256=85Fwi4unXUNic9TUurAeph_M0WclGePlXKxTJkarxr8,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/output_0.pb,sha256=Km4G9yM-_Q369BPQXgij7_N3dWiC05nccMJvbVkCwOY,22 +onnx/backend/test/data/node/test_reciprocal/model.onnx,sha256=9cYhyYrtsZnNsprI4Lv2Mo4iKGoD2D-2tKAXYkZ21fc,111 +onnx/backend/test/data/node/test_reciprocal/test_data_set_0/input_0.pb,sha256=GgRN6i1Z1pXIrsvfZWkp52hvnZToD0J1d6uAsH-ysOw,254 +onnx/backend/test/data/node/test_reciprocal/test_data_set_0/output_0.pb,sha256=Iw7Mqud4Obp2fRS-HaenQ1G7QoOphufczelvmamQGJY,254 +onnx/backend/test/data/node/test_reciprocal_example/model.onnx,sha256=zqyZFVq34gf2pggBHznhwsBXrlELzUaUou3suG758Ew,103 +onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/input_0.pb,sha256=hIDv23oySvd30UHcdMkH6btwYls47z-2HWS1hMB2wdg,17 +onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/output_0.pb,sha256=ep0bNR1nZSAgCmdKAEIQP7ZNm5_nVb12ngt6I-yLdzo,17 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/model.onnx,sha256=ohzqkukts8S1Ekf20SpX5OQEMvQWTUZ5Z3-2iSfLh90,200 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=-tM_bqHqK-65eWP1RbkvxizF8zO7aiimwgb1H-034CM,23 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/model.onnx,sha256=m9pfIeDZJhsvhnbVr_Ved8iVf317Uy4mufo_RahCKts,415 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=-tM_bqHqK-65eWP1RbkvxizF8zO7aiimwgb1H-034CM,23 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/model.onnx,sha256=Z4DTNgCI8ewEd2WZCu1gIgzJ8TOGXYj40T8fpAB-E2E,199 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=3IYq1wIPmuGmuhhsnqmPmvnaA3qpKCI5e2wRanUn-EI,23 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/model.onnx,sha256=K3Ohljq6u_VfluOVMTMsUeuDM4e0_HS_eFfa8jiQT4Q,412 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=3IYq1wIPmuGmuhhsnqmPmvnaA3qpKCI5e2wRanUn-EI,23 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/model.onnx,sha256=RPmBjeHx3iQ_RPcKvTxKCE6bveoJrtMXs_32KKOUVTE,190 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=JC-ByfOkizIkgJ3nwdBl673paZR_4rtYThjJ7UCL2Bs,41 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/model.onnx,sha256=0u7PqTBTBHnxoDw4NMvrW8-b1v926ssngI5rrN4nuvE,393 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=JC-ByfOkizIkgJ3nwdBl673paZR_4rtYThjJ7UCL2Bs,41 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/model.onnx,sha256=2MJdQR4vCOCKHEKWhYRnZvxFfS_EoYcBmzZV9YTc--8,189 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=boLxo_tKTY-Elb4ILMYTWLBXdqS8I2dDPXrh7wlJYdE,41 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/model.onnx,sha256=pVEM3xrFr7j2KRYOVKKPxdDDbD8RsNjNIXytFyU42vk,390 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=boLxo_tKTY-Elb4ILMYTWLBXdqS8I2dDPXrh7wlJYdE,41 +onnx/backend/test/data/node/test_reduce_l1_empty_set/model.onnx,sha256=X3t5PMvEjg1SyM5zxLLCchMnO2mlypzYA41BlLGXg78,180 +onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/output_0.pb,sha256=dkauAAxfP09SxG8x1uXFNv8Ndb1oDMAKAb8GRYfbrG0,51 +onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/model.onnx,sha256=gAHod72kux6JTNewViCYkVY3tvBObVUiq9xY6IQ_Bmk,355 +onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/output_0.pb,sha256=dkauAAxfP09SxG8x1uXFNv8Ndb1oDMAKAb8GRYfbrG0,51 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/model.onnx,sha256=8tPPR4vedPEERxpY1rTpUT76lMyxWjvum1LptsNgYKQ,188 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/output_0.pb,sha256=dJeaCpTSWSt6LwkQwBqvad3ot7QYb173M1rkBSqLXzY,43 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/model.onnx,sha256=hAJklF5zztuPHdXM-7fAJRWDhROqkS8QXt9WLiNKz88,379 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/output_0.pb,sha256=dJeaCpTSWSt6LwkQwBqvad3ot7QYb173M1rkBSqLXzY,43 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/model.onnx,sha256=vMPnjNZPytsdjAWg_-FIT_LynV0Fz_mPTVr6w4OmFjQ,187 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/output_0.pb,sha256=GLZKMWiKlhBmVVM0kbK38-GloFGIoR7eFzqiQlIojqA,43 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/model.onnx,sha256=Y-MNQU0XUqg--bFzgr8lSqlWk8_HU91HJFLMol5eMLg,376 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/output_0.pb,sha256=GLZKMWiKlhBmVVM0kbK38-GloFGIoR7eFzqiQlIojqA,43 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/model.onnx,sha256=v0bGIRG0HAaaWr8yKBWnfW36snQJuKgB-bgjx_Wz9no,202 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/output_0.pb,sha256=dJeaCpTSWSt6LwkQwBqvad3ot7QYb173M1rkBSqLXzY,43 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/model.onnx,sha256=c7twynaT7mnEZ7dp2WE66uvIQ_0CFiit__R4e0sp1qE,421 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb,sha256=dJeaCpTSWSt6LwkQwBqvad3ot7QYb173M1rkBSqLXzY,43 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/model.onnx,sha256=c2tLsQtNx4nsU6LOI_6kkmG6HkA8gHBO8EGmBcvnXIY,201 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/output_0.pb,sha256=GLZKMWiKlhBmVVM0kbK38-GloFGIoR7eFzqiQlIojqA,43 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/model.onnx,sha256=r3HhGmzZ8xHbI3oxE6yR5-f8OP5MymiAcX8ibln8og0,418 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb,sha256=GLZKMWiKlhBmVVM0kbK38-GloFGIoR7eFzqiQlIojqA,43 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/model.onnx,sha256=x3If-zJSSwsskknM8IMaAc-Q1HlsDhAVXNsVuGXxxmk,200 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=1nRvbw4k8gX2Lm2fHXH02jiiHY6FJ_bDDg0ZGJ14r08,23 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/model.onnx,sha256=z21mT0IWPfP05uY9jKIsNrk0fXFyiuAO9sbwrozP7Zs,980 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=1nRvbw4k8gX2Lm2fHXH02jiiHY6FJ_bDDg0ZGJ14r08,23 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/model.onnx,sha256=4bAdBwk_5DWKjJezOCbPeyRYwzguBTYveoYAWqep2nA,199 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=PIATHW_5LGj0-_ZFZ4z8TpxbqFnMZNPE0ugw_WZjiuM,23 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/model.onnx,sha256=QwU1PpNHnr5BOext_l923HnGKATXKIP912_4I8xTSKY,971 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=PIATHW_5LGj0-_ZFZ4z8TpxbqFnMZNPE0ugw_WZjiuM,23 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/model.onnx,sha256=VXrFAN0MVP4cc2Bo7NZ3334EsiiV3YTy_zJbWRCn0FM,190 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=c1D0KDheSLTWalNQZaabVbJ79Rr_RID0w21TeOewaBM,41 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/model.onnx,sha256=95wyVNCIIVda83EHuT9MzugyVBAuzsoUV96ldUTV6Lc,922 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=c1D0KDheSLTWalNQZaabVbJ79Rr_RID0w21TeOewaBM,41 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/model.onnx,sha256=CvpFw-JYy4MzUPdpdx4RsFNsFQE8z2_ZswiBS_C1HaA,189 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=JOKjva3pUba9oCjoOdZ5D5cn8DmqUxB4ukD3fJeSbSk,41 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/model.onnx,sha256=0VceBhUaxWpkLoYqgKL_BSocAkKpMOgSLSTTJ8D8EPw,913 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=JOKjva3pUba9oCjoOdZ5D5cn8DmqUxB4ukD3fJeSbSk,41 +onnx/backend/test/data/node/test_reduce_l2_empty_set/model.onnx,sha256=bx1dkq_nAG4aOg4tdmvBohm0JY7SyNE2YKM1bWWIhuw,180 +onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/output_0.pb,sha256=dkauAAxfP09SxG8x1uXFNv8Ndb1oDMAKAb8GRYfbrG0,51 +onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/model.onnx,sha256=1232-LDlkT-UezAnNjy_sFp4152CM38-_w1YyAdNaSc,800 +onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/output_0.pb,sha256=dkauAAxfP09SxG8x1uXFNv8Ndb1oDMAKAb8GRYfbrG0,51 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/model.onnx,sha256=z66shsNj20DpEmucNL9xyFGHMMCNhxIFGt5H0gOBNYk,188 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/output_0.pb,sha256=jEsoUMRhG4OeYC5KTm_HKvd8ZN1iEJzVUEOlNq3zsow,43 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/model.onnx,sha256=2pCpmkdEK4UP4vCFAH9ZqNQ_AcuQQh3U55erRf3an78,872 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/output_0.pb,sha256=jEsoUMRhG4OeYC5KTm_HKvd8ZN1iEJzVUEOlNq3zsow,43 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/model.onnx,sha256=mUGEy6kiSHSdFR1SPWYA8uUyKQkNwYKS2lO6wy0WgqY,187 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/output_0.pb,sha256=rPsbYUQn6_Cmp7zcRSMK4aDCf4R0jlttuYSLZj9JV6Y,43 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/model.onnx,sha256=TGrx_WM7dI6oG5TAVQtCEF9rdZOVOnkMF6fNcznJeS8,863 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/output_0.pb,sha256=rPsbYUQn6_Cmp7zcRSMK4aDCf4R0jlttuYSLZj9JV6Y,43 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/model.onnx,sha256=pjqo4Qrdy1yBnQntfi1AWBb0mKHhj08HFyvBAk8d4m4,202 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/output_0.pb,sha256=jEsoUMRhG4OeYC5KTm_HKvd8ZN1iEJzVUEOlNq3zsow,43 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/model.onnx,sha256=3PRWwT0UjKbvarah7WVWsgQZtUGTWnabapJCmuD7uQA,998 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb,sha256=jEsoUMRhG4OeYC5KTm_HKvd8ZN1iEJzVUEOlNq3zsow,43 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/model.onnx,sha256=_SnWGbphTilYxGrCD0L2vsViRqONP1Wc3UiXvYCvg4Y,201 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/output_0.pb,sha256=rPsbYUQn6_Cmp7zcRSMK4aDCf4R0jlttuYSLZj9JV6Y,43 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/model.onnx,sha256=wz7rpb4IIJX6aVjGw1-hd3ovba5kjc9otZMQK2canFw,989 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb,sha256=rPsbYUQn6_Cmp7zcRSMK4aDCf4R0jlttuYSLZj9JV6Y,43 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/model.onnx,sha256=08cgOZBs0l3W00v9s8wZpTPV3rOcIH-j5QRrsP05ZN4,180 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_0.pb,sha256=hiOZW6YmCAGEqJ0ELt4OVjMm3ncS3BqXQ9ngd-FPcN8,257 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_1.pb,sha256=3uvlJ_2xYPsfOzK-E0Fz2WR-a1Yvmf3r1G6DZPUQ8v0,28 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/output_0.pb,sha256=TtThcW8lQGZNcOpVgIggfFRZhLJ-dEq7i2HJ7P--ZQU,35 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/model.onnx,sha256=oYDwyo_m2NRq8Ti6G_QcybD_nhQG7LAZAoav-5tw6rc,373 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_0.pb,sha256=hiOZW6YmCAGEqJ0ELt4OVjMm3ncS3BqXQ9ngd-FPcN8,257 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_1.pb,sha256=3uvlJ_2xYPsfOzK-E0Fz2WR-a1Yvmf3r1G6DZPUQ8v0,28 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/output_0.pb,sha256=TtThcW8lQGZNcOpVgIggfFRZhLJ-dEq7i2HJ7P--ZQU,35 +onnx/backend/test/data/node/test_reduce_log_sum_default/model.onnx,sha256=qbcysYmQ32u_zU_D4iArr69SAiwEAtZcY2jQBLOF150,170 +onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/output_0.pb,sha256=VX5i5qOEuFQmlsL04_Mi021aVGoCe4VbAhD1x_xXErc,23 +onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/model.onnx,sha256=dVAPixBUxi_zDIwx1piMSyMa-CZBhDxwtNjJBEnH9JM,378 +onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/output_0.pb,sha256=VX5i5qOEuFQmlsL04_Mi021aVGoCe4VbAhD1x_xXErc,23 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/model.onnx,sha256=cJkZ61Jw2xic321dMt_B96LpK8tAT8dQE7Z3Ugm_9wk,181 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_1.pb,sha256=b9vD-lAvbO5WdOMBewE0sjS9vcl6_4iAPW_FFXA_LLc,28 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/output_0.pb,sha256=q6wBAMfbpLLolGYAiBt9QC9EEED4D5XYzGF1tSQQgLg,27 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/model.onnx,sha256=tPAji5H6DeXIqW7ydSfKhC14RjtZY-GC9dY69StD9IA,376 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_1.pb,sha256=b9vD-lAvbO5WdOMBewE0sjS9vcl6_4iAPW_FFXA_LLc,28 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/output_0.pb,sha256=q6wBAMfbpLLolGYAiBt9QC9EEED4D5XYzGF1tSQQgLg,27 +onnx/backend/test/data/node/test_reduce_log_sum_empty_set/model.onnx,sha256=jXiLk-jqzZ2E7d9Wvtm76r8ATvuVzqtsk-1R8kgCnNE,189 +onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/output_0.pb,sha256=NpmcJW0FZ2Uts6tVgBdKtSslkmnlqV43198R71w-KJ0,51 +onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/model.onnx,sha256=WXxWpnw2iIWtDH6N2UXid7gp_Y80-ttRocDu6AF09SY,384 +onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/output_0.pb,sha256=NpmcJW0FZ2Uts6tVgBdKtSslkmnlqV43198R71w-KJ0,51 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/model.onnx,sha256=-LSKr_3WMkVC8ft7_prQsvhatLidnsA4tO3X4QPo1nQ,216 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=8-s0mM_b-21xuh9gCxveN-F_DCnGgiCmS24Mz2sJGRM,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/model.onnx,sha256=AwUG3cT48eSrQSKDDYq5d_JTOk_S9zO66HjgCrW_kgM,1121 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=8-s0mM_b-21xuh9gCxveN-F_DCnGgiCmS24Mz2sJGRM,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/model.onnx,sha256=9-89fYqu5IADjGEbbqzQIF2QdUCOQ5RJQsQk-Y7TeYg,215 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=Q17PU4QR2ke-Ms3Jbvm8YwIVODqct6D8iOBWx1lXHUk,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/model.onnx,sha256=QBUpIfOWw9ftxfFAe_pifB9ErdfHtN3AdCnzs5svFew,1112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=Q17PU4QR2ke-Ms3Jbvm8YwIVODqct6D8iOBWx1lXHUk,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/model.onnx,sha256=evJeQt8UxeVRdg5hhuhA372TwI4KC85TooGPm2pmGMk,206 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=jLIBDVFsMai84zPcahQDicWPNPPjc3IHy3sJUKKjlHI,65 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/model.onnx,sha256=lBLv0PcYjhqYgpDbc80XoItEaqaaRO5EYd5VsPUqf0I,1062 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=jLIBDVFsMai84zPcahQDicWPNPPjc3IHy3sJUKKjlHI,65 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/model.onnx,sha256=7S4gYBITpFk_DyMhCkrv0PXNBWhZi3lUnFQbEas3ZdI,205 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=p5nS_8ARmFPPIalx4PaRRQDUgIeQFN7ErnCeB3m38ZA,65 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/model.onnx,sha256=wIicYO04GpNJTQcJV9tz1z8u3BKYXR-1w6MQtPGimDI,1053 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=p5nS_8ARmFPPIalx4PaRRQDUgIeQFN7ErnCeB3m38ZA,65 +onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/model.onnx,sha256=dGL0JVccvsmUNguPuRytf2OcDK23X1cr96nIsZXClVM,196 +onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/output_0.pb,sha256=NpmcJW0FZ2Uts6tVgBdKtSslkmnlqV43198R71w-KJ0,51 +onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/model.onnx,sha256=Ws54ImPvrD1SwOoxYYz2pULr_e_GQS4MN3iMGnXsuTY,940 +onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/output_0.pb,sha256=NpmcJW0FZ2Uts6tVgBdKtSslkmnlqV43198R71w-KJ0,51 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/model.onnx,sha256=TrGMChcDC10sgL-egbi-a_I1oqVT-m5t3rd26n79apA,203 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/output_0.pb,sha256=DJQqS-8gXhP8nKgBqwU9pn53ssTbxinuUpr6DbULG9o,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/model.onnx,sha256=4OC1FOS_rMjPPefw4vrtTQzLPKb7F6PEoMN9BiVRiUU,1003 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=DJQqS-8gXhP8nKgBqwU9pn53ssTbxinuUpr6DbULG9o,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/model.onnx,sha256=YlDp2phOYKOpNx4anOtWubW2l6ZX5fDQgpAW0Rxu8wo,202 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/output_0.pb,sha256=qXaDuXS4jBTpMtd2RCpbn4sdw7A6y7YX68LFQjmSkag,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/model.onnx,sha256=JPVPcu-q0SFY3raq6dXHSy3h5Uj6zVEfLoWozsYuKzE,994 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=qXaDuXS4jBTpMtd2RCpbn4sdw7A6y7YX68LFQjmSkag,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/model.onnx,sha256=mTDZeOW7N99CyYBbe_MquaYlz_4PdDJndCJRmQ1-dbI,217 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=DJQqS-8gXhP8nKgBqwU9pn53ssTbxinuUpr6DbULG9o,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/model.onnx,sha256=nlwmJbFWbhgHm-SjWPIeFzGXxp2MHoV2RcRZOJsvvrA,1130 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=DJQqS-8gXhP8nKgBqwU9pn53ssTbxinuUpr6DbULG9o,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/model.onnx,sha256=ua6HYd_IG6l-E3FdKTNSFGu5HkiFwxLP1GknDq1w6Bw,216 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=qXaDuXS4jBTpMtd2RCpbn4sdw7A6y7YX68LFQjmSkag,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/model.onnx,sha256=8xCMoIILEy6lDYYTaZoDzmSxbk87cqwFrbVPe_q0gZ4,1121 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=qXaDuXS4jBTpMtd2RCpbn4sdw7A6y7YX68LFQjmSkag,67 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/model.onnx,sha256=2r5RqRgA1ZB4SAlPBS-zvLiOi2_ZtK5JxeEymrQEbTk,176 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/output_0.pb,sha256=6Yx7ZZqxOko4EPFziIZlhqwlJqLZz77lIAR6lkQ5Vpg,79 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/model.onnx,sha256=m-EuNGKslqf3cY07lUVxdFQi1q_s96aaz5SFFxeYBJg,396 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/output_0.pb,sha256=6Yx7ZZqxOko4EPFziIZlhqwlJqLZz77lIAR6lkQ5Vpg,79 +onnx/backend/test/data/node/test_reduce_max_bool_inputs/model.onnx,sha256=oxWpcTS9-gG5EkW2xfDZjjsa3kAUUVPuayj8_NDE_Ts,176 +onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/input_0.pb,sha256=ouIG7Bj8ok8jytOSP6d7w90Kt_o1CcnM6U9SabN2X6w,22 +onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/output_0.pb,sha256=yHrgLqFsr7-DB7lKf0H5urDhCkMMFmmQZ9yRGfH3cWg,21 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/model.onnx,sha256=vE5drf-iydiwgV7A9GR7LcNtlAcOb4i389revGuEYjs,175 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/output_0.pb,sha256=Bb3KrZse37as3WFj056V_ClYfrCyJjnt2DnhrGk94j8,23 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/model.onnx,sha256=vanvh0gwKcMdDQIPsT3BArVb2Mg-XoqL4fY4Ng_mQO8,175 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=ozqWkbR-YL-E8NoR8OqPUH6OkLXjb-vzUIeOxUHkbBA,23 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/model.onnx,sha256=NFoSyvIEuAsNSntvGbAShr9g9qjoGvWjrTTmeAeMliA,192 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=HZffK_Pkm02avtHvOv7mhM-E3LY-MijOAq1-YgGuDV0,41 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/model.onnx,sha256=c7rXRCGW7S7y1GaEovkkfCKSBDVJhmM8DqamGq8liGc,191 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=EC7d1JJPDs9E3Pcqp3FMyYRM_Ydclfwe8J7KTg0Ae7Y,41 +onnx/backend/test/data/node/test_reduce_max_empty_set/model.onnx,sha256=duWl_N2qWr8GzBI_YNxmlTBnsbU4pTJ_zx_IAkdTLMk,182 +onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/output_0.pb,sha256=NpmcJW0FZ2Uts6tVgBdKtSslkmnlqV43198R71w-KJ0,51 +onnx/backend/test/data/node/test_reduce_max_keepdims_example/model.onnx,sha256=feVjIwASiT48qIHHEiGzGXmS_FLc2LgHWI-uVXYIQAo,189 +onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/output_0.pb,sha256=Y7JjZDTAji1tTbKuUwgzc6DaSNOnMOpmFJsTekO2MzQ,43 +onnx/backend/test/data/node/test_reduce_max_keepdims_random/model.onnx,sha256=cLMY5hW2k6QjxYHquRfmDO9a0hopP47I3ODrk27xKK4,188 +onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/output_0.pb,sha256=U3UiOpILvTohrJ7lDcmCm2IiF8wccl8q9MTyLtVBJ28,43 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/model.onnx,sha256=NEq1WRSDW6dkrjrbU6LQBu2ingjwlNZ0XWd2H7k2x0k,203 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=Y7JjZDTAji1tTbKuUwgzc6DaSNOnMOpmFJsTekO2MzQ,43 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/model.onnx,sha256=YZMSj660Mh4kI73f3IDKmfokYk2EnhwdqEzmdaC5W8M,202 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=U3UiOpILvTohrJ7lDcmCm2IiF8wccl8q9MTyLtVBJ28,43 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/model.onnx,sha256=0rdbzI9NKpScLSUZYf6psg5BpGqAWCWX7R3DbJB3rUw,204 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=7ibSI6LwyCIMwafplWVc4TDIpFpsp_gp9a7jPZQvSiM,23 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/model.onnx,sha256=QuLvz4AXd5SwGI_LYyRq9MjzuwW9bBYuDRTzxZIKEHc,203 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=F1Wj0GTUnCJNo9yidS3ralMUw5yeg62NF2QM4q6lkhI,23 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/model.onnx,sha256=hm6mmXP-WpLZSSQpFWvhoTv4TF1C7sz1wDeR9_r2imM,194 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=hnISZrOPRTiH5iggcwleJTg6bX6m-U_oEnF8oQuZqxs,41 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/model.onnx,sha256=_unWlCItn4pGX1rQ65kNpvv7LVnhftErr4MhWdBHcPI,193 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=kpivv-z4wkCcK-I8shs26UmpmKG6Ytshz2EvgjiwKEw,41 +onnx/backend/test/data/node/test_reduce_mean_keepdims_example/model.onnx,sha256=SLeuMLRrJpaL1whWfjMX2H4vdQcSjVE1j8p_Is2YZxQ,191 +onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/output_0.pb,sha256=TtXp182U6LiKAlxhCCqkrszUxdjEEvqx9eOk9Znqgk8,43 +onnx/backend/test/data/node/test_reduce_mean_keepdims_random/model.onnx,sha256=2qgVPNkQEUXIIv6XAyHoYtY_NmgTHxu2HNgWD1YVWZc,190 +onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/output_0.pb,sha256=wcLIggmeEyvBw7Fc2_7q0gHHnCiJKgrN1bqGxV-R6vw,43 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/model.onnx,sha256=Z-hc_RMz3VufOXQULmwK5pnC9MhotEybQrNOG12VSbc,205 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=TtXp182U6LiKAlxhCCqkrszUxdjEEvqx9eOk9Znqgk8,43 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/model.onnx,sha256=m2HDJeknLP2M0F3usH0iOb44KJcVyPBXlrQlBei-YDc,204 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=wcLIggmeEyvBw7Fc2_7q0gHHnCiJKgrN1bqGxV-R6vw,43 +onnx/backend/test/data/node/test_reduce_min_bool_inputs/model.onnx,sha256=QLEBYG3Cmf7D_JNYX-b8MWZs4O3dQ-GJ9MmdT93Ts-Q,176 +onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/input_0.pb,sha256=ouIG7Bj8ok8jytOSP6d7w90Kt_o1CcnM6U9SabN2X6w,22 +onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/output_0.pb,sha256=lPV-pYsggeQAp36hh6TrLqcK9RKBzUmS1igMp-KJMBc,21 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/model.onnx,sha256=M_DtcG5iqcqzc98s0DSgqY-N0qRPMqQuw7Wh_FqkfpQ,176 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=G2XC5D9PzsK5GpL4ZHlTK5OxYFrf70ozEzcBkItwsaA,23 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/model.onnx,sha256=QLKKrC-5Eujvt-EvyH9WFQTM4_6af5rtmEdX5dghe_c,175 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=fCFjoh4xFCI0bizOVGFspYggfTiFgAas8k1Mb9R46vI,23 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/model.onnx,sha256=uhZrDdQHcU_BN8oFyZTihiTSuKbIxGTJQDXLQND9Dig,192 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=Xu7cTpxA2M0y065t3hqWb0R-MmowoXfqGwu0JwdVU4I,41 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/model.onnx,sha256=ay7d2CF3QEKEdFoAk1aJ0zVq5qr_h6XmzZ-Uy7s_fxM,191 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=Wh_Dx6lJN0QUmIuWRDP29XGjpEw9R9Tlz2gzQT_XzUU,41 +onnx/backend/test/data/node/test_reduce_min_empty_set/model.onnx,sha256=feU3zn_3mTzQQuJnhMKqRSS3qJqLnA7eF_GQ-rDoxpI,182 +onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/output_0.pb,sha256=eIU1KG5xXZPe-cHrsnr3fs53PwScOiUMJf0BvHmw830,51 +onnx/backend/test/data/node/test_reduce_min_keepdims_example/model.onnx,sha256=PXL2jvwWdNRFdDTRuPzPtjLvQGO6CA_abXa-oPMtI2s,189 +onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/output_0.pb,sha256=NU4b8D9taBjUcD7UZpFmlgF6rWEuaX175z8RcR5RV1Y,43 +onnx/backend/test/data/node/test_reduce_min_keepdims_random/model.onnx,sha256=vFPC039OYaXjgPtoRF3dq5n7GKwaRJPI1Ql38xqE2Hc,188 +onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/output_0.pb,sha256=mMPCR1Esnn6Ww5w3SHz28klgLCsH3gnvJVLefjQmJMk,43 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/model.onnx,sha256=6Wcrg0issxxFNsBz_rGXOvKbXUyGU-n72hJJN61-2CI,203 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=NU4b8D9taBjUcD7UZpFmlgF6rWEuaX175z8RcR5RV1Y,43 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/model.onnx,sha256=mAzQANQL7yGJEy7ea19UF7emkKR-DE01KeuoqCHsdQg,202 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=mMPCR1Esnn6Ww5w3SHz28klgLCsH3gnvJVLefjQmJMk,43 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/model.onnx,sha256=3QaNyMuspKVWgPGbu8UyFpN5KDA0HDFWjv1MfjOx2EU,178 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=L8bDbzhMnsmauRTvBHYtKfDGUrj8Mdx-crYz4NARWz4,23 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/model.onnx,sha256=NyD7Og13fGa5kHZILIXFTyBJOSeeDfXAj3_8fYbvGlc,177 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=TOI_r_i3le4r-O5Z1HZerCe0ZmjJ8KOtsHw2nY_Utas,23 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/model.onnx,sha256=Nech7zzE0avGRtbwgjk4rgQmC-ETA8Vlw190ScCnqc8,194 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=mNWtHVOjuoK-vYvbrudn6UlFXq2_GLE6SHlutihvD5k,41 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/model.onnx,sha256=3oeBxWFvIGk1KI4AtIqnKGfDCR1BsxwXeL5Oab3mFKE,193 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=fvB-o3vzCwkRPNYZVs6InuQtFic0cQ__H0AXKP50rmo,41 +onnx/backend/test/data/node/test_reduce_prod_empty_set/model.onnx,sha256=KTMntXHTNW7Y_rsnn7UJEI45K5CxVr-lw-XlrNgBJgQ,184 +onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/output_0.pb,sha256=QSjeQjt3JdGgRAGg5-RM203ryR97LsLN1OasGjZsU78,51 +onnx/backend/test/data/node/test_reduce_prod_keepdims_example/model.onnx,sha256=4kJTiebaZg-DH2l-PwkadFWRrS_qRv6g6wlGHd6xmo8,191 +onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/output_0.pb,sha256=7ok4vwYSfLvbWG8irRUQBo3WGLl3s_rgJXemrrJRqyw,43 +onnx/backend/test/data/node/test_reduce_prod_keepdims_random/model.onnx,sha256=FG6mPY0kRbr-bPsuhnL8YEQ7CqhltGMk34CeyL3Melo,190 +onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/output_0.pb,sha256=1ila67umCRwEUTp6trOZSoLm3kfR0zVDxb20FWYyRa0,43 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/model.onnx,sha256=H6lGw_WyHA59zv-lv2lHVTaCGqHgaR_o8-fIzuoyM3Q,205 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=7ok4vwYSfLvbWG8irRUQBo3WGLl3s_rgJXemrrJRqyw,43 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/model.onnx,sha256=v57sz16zLEhnsl-RVPyy7VG2D-oE7tSZprK6CUQCgdM,204 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=1ila67umCRwEUTp6trOZSoLm3kfR0zVDxb20FWYyRa0,43 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/model.onnx,sha256=mZmJR-3SFDQ--6G0CwQ6IGgLrtTA5b-y71gMuYmBQkI,202 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=-tM_bqHqK-65eWP1RbkvxizF8zO7aiimwgb1H-034CM,23 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/model.onnx,sha256=pJt_pNmAgxZaTmbxZ5b3hdtClp2QkSL01LaW9dh_2bA,201 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=gP6xq40fhaM6-e7UNw1HN64G9nmjUBWgSvnzS5itHHU,23 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/model.onnx,sha256=fidSdw3yQJhcR7P810Ln9DAy913jRkLjVFAu9Btcs2E,192 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=rUr7bDeYdFfv8ODlJx3VxZCObcOQawo6PvpwwxxVyVk,41 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/model.onnx,sha256=jfI2GTWwCBA7kYoQX3ltR7riRcXzCgAlFeoPExOcq6k,191 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=Epgb6VirPLNuYKYEeE3PT2w4qkKao1u3CNpZaiHnocY,41 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/model.onnx,sha256=_-ujHgKK5uozTxHo11qOUTPgoeMscZJVtrAxe66jguY,223 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/output_0.pb,sha256=cQ0Q_SVFF2KsKqm4m_tH1qSv6sSiPriE2i1T8Ktnc_4,67 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/model.onnx,sha256=Le5t6Bv1fb7z-_UeTOsYkbt3SrjnaPb6jhP9dSki1Bg,231 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/output_0.pb,sha256=hxZ8kmFTn4aU_veDr-LP4a6v4IilChYy9YIOoEVHfv8,67 +onnx/backend/test/data/node/test_reduce_sum_empty_set/model.onnx,sha256=2vpXb6j53VqjPrjUtjUDP4FYGDt3-c0gton55tzIuxk,182 +onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/output_0.pb,sha256=dkauAAxfP09SxG8x1uXFNv8Ndb1oDMAKAb8GRYfbrG0,51 +onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/model.onnx,sha256=EcEPNTx8l1R49kTe7K2pbyxppf_HkGNpIqAqzBfB4_4,204 +onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/output_0.pb,sha256=HZVVt0c5MbTlwO5vbPsnvEiPwTFHjMFsTMMFj4fYKZ4,19 +onnx/backend/test/data/node/test_reduce_sum_keepdims_example/model.onnx,sha256=_atfvm_z1owilbBcO4adKbxvsFAcYALNlKXooizYsdo,189 +onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/output_0.pb,sha256=-0ot9rCkyWkDhV7chj_oxYHNFryuggjVddq8z4qWjuY,43 +onnx/backend/test/data/node/test_reduce_sum_keepdims_random/model.onnx,sha256=gqfy3V7eSTxiQ6UTgXo0olNcckZHUIVCMwcA66HzVAE,188 +onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/output_0.pb,sha256=88XdkhxYXPjaDDn84q-yBWICKN6ikXDbVH5RuCm3EKE,43 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/model.onnx,sha256=vJkjTGTKvBUSYRnYDHfgxFcRK6bpa3pnZ5zv72-JPGg,203 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=-0ot9rCkyWkDhV7chj_oxYHNFryuggjVddq8z4qWjuY,43 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/model.onnx,sha256=HyFXPYxsB-0CtQYzPBH44oQdMVYK37ow6d3VElPTsdM,202 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=88XdkhxYXPjaDDn84q-yBWICKN6ikXDbVH5RuCm3EKE,43 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/model.onnx,sha256=G2bxijVRgZn1JZJt3QGbNnDsx6oepsfIYamaUD3ZnxU,215 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=HZLley9Hbzlh5in3jlFTDghtNaheN7e3B8SBgGb3c-Q,23 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/model.onnx,sha256=6rkMWrJotZlaUmH9NEpxSgGtrk99D_uEiUZ1LB1TNts,465 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=HZLley9Hbzlh5in3jlFTDghtNaheN7e3B8SBgGb3c-Q,23 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/model.onnx,sha256=T5_7RGmpImy2WrH7D4FS1DbeK1RDqcoBhe5lXso9eFU,214 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=NbVoWb_YuZBVOJxwwGasGxSa91PqRFyopG8pwnsRrZo,23 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/model.onnx,sha256=MkQDfdfoGw8xDS1qJZqBb-Agod3VhY2wScGaYGbaX0o,462 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=NbVoWb_YuZBVOJxwwGasGxSa91PqRFyopG8pwnsRrZo,23 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/model.onnx,sha256=WkoP-bgJbWSEOUCAEdtp5W3QII3v8-Lu3JZPPJCQyW8,205 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=4STmxX1bz3tAUzg68411nc4sQSNZgAaUuYt_onSMO-c,41 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/model.onnx,sha256=UnNQ13w0ZW1ku7rlFzTWtvpMmMxEVbF6UpGaU-SRD4s,443 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=4STmxX1bz3tAUzg68411nc4sQSNZgAaUuYt_onSMO-c,41 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/model.onnx,sha256=bI3zRIns4YaHcHYe99iaPR-9Tyeo-1V-KRYYIFFtP8s,204 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=Kt1q2dw9kUxmKY4qFgAWAqeJZUagnKjwuytTKfpNlts,41 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/model.onnx,sha256=nj8bPxQSpM-y-leZOasQehUbPC9enk-MXy94IUbEYaM,440 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=Kt1q2dw9kUxmKY4qFgAWAqeJZUagnKjwuytTKfpNlts,41 +onnx/backend/test/data/node/test_reduce_sum_square_empty_set/model.onnx,sha256=-g26jAEVh7DMfc5VHp_sP4V3nVHbkgoZvU1J6lCJtMU,195 +onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/output_0.pb,sha256=dkauAAxfP09SxG8x1uXFNv8Ndb1oDMAKAb8GRYfbrG0,51 +onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/model.onnx,sha256=RyS8gp9eepfHRGxXbHfpS9tQiJ8v8An8n2nKr4dF9Jw,405 +onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/input_0.pb,sha256=diEJAtHd_b95FEPFWBBoLLmxB42c3-1U15UBg9rdUuw,16 +onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/output_0.pb,sha256=dkauAAxfP09SxG8x1uXFNv8Ndb1oDMAKAb8GRYfbrG0,51 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/model.onnx,sha256=7HagD67ewDY4s8-74ByYvNF_IKR7parPtsg4XxhQ0sI,202 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/output_0.pb,sha256=Cq_UDeh4h6nFLBgZBAWRe4VLZgIhclppB9m_jRlZrEo,43 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/model.onnx,sha256=xQdUfqgkBlLJ2ck6K-s9ItKJk5mWDOhUIGiokzwdIow,426 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=Cq_UDeh4h6nFLBgZBAWRe4VLZgIhclppB9m_jRlZrEo,43 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/model.onnx,sha256=GkzGXsE3RHJ7M4rnwI--bjcW4sXRzpu6wx44mNDsKKM,201 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/output_0.pb,sha256=T-ud1oynbPrU6k8obUDvYqxQoCsq0N-S_8SJKxthuBk,43 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/model.onnx,sha256=HFfXYjQqQXyC3eN-nThVFJ23iQFYmNUMJ_DRj0NfN2o,423 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=T-ud1oynbPrU6k8obUDvYqxQoCsq0N-S_8SJKxthuBk,43 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/model.onnx,sha256=Yxeca3t4PmMBNd8A6SAYpLBOatqlLb1_xMJvfpvd9Fw,216 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=Cq_UDeh4h6nFLBgZBAWRe4VLZgIhclppB9m_jRlZrEo,43 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/model.onnx,sha256=0316fKjS2l_InfJnXUH8qbeuZM_krj-V-HTMzIi5CEE,468 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=Cq_UDeh4h6nFLBgZBAWRe4VLZgIhclppB9m_jRlZrEo,43 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/model.onnx,sha256=26kPF5Om3gzxIpg2VJ8IfFcKVvUtj36jY15NHrl0PkU,215 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=T-ud1oynbPrU6k8obUDvYqxQoCsq0N-S_8SJKxthuBk,43 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/model.onnx,sha256=Hl28sflW_EJbxeJmdYxF6lxMCY5roz5tmAhEQ9FTPjs,465 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=T-ud1oynbPrU6k8obUDvYqxQoCsq0N-S_8SJKxthuBk,43 +onnx/backend/test/data/node/test_reflect_pad/model.onnx,sha256=UeFkUxi21EZZnO_0hP1EMyCBnVwQ7PAqIKl9_8Fjo94,160 +onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_0.pb,sha256=TuEz1ptAgJa6Qzh6nQx_rsYU5BVmA4qgVWNRPM7AEkU,256 +onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_1.pb,sha256=8s4uRhNf19t1kZ-BWDxuitcnY9MeHgkG6w6i1Sghnz0,76 +onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/output_0.pb,sha256=vRjclkAiKB0nuRzVWk4GeIKCHBxR-QZilgYP5DlBVr4,520 +onnx/backend/test/data/node/test_regex_full_match_basic/model.onnx,sha256=yCly5Cs07OW-682KHYYoWZPnJPhKn7NIcYhrkzsmLTc,148 +onnx/backend/test/data/node/test_regex_full_match_basic/test_data_set_0/input_0.pb,sha256=1fO9Vj8-f9A9v_fbA6lHnui0wxRWivm9u4Ofx4bWFMk,56 +onnx/backend/test/data/node/test_regex_full_match_basic/test_data_set_0/output_0.pb,sha256=_lhc3O_b74C03Oht1i8tnibUls64f1ROvyVBDQPO2Os,12 +onnx/backend/test/data/node/test_regex_full_match_email_domain/model.onnx,sha256=LjnPd5qIqTHB87k-0a13GFl_SE-QmAO9WRZNBzVOk0s,187 +onnx/backend/test/data/node/test_regex_full_match_email_domain/test_data_set_0/input_0.pb,sha256=u1NPTw32IImtF95uzUqq4GHK3RoDkr3FoVJm6UMsgCY,80 +onnx/backend/test/data/node/test_regex_full_match_email_domain/test_data_set_0/output_0.pb,sha256=xE17dM4PaT3OoJNUzMKqTicCcEsaku7OGMrpt-6A6XI,15 +onnx/backend/test/data/node/test_regex_full_match_empty/model.onnx,sha256=F0VGRCfhQRpZs-9_aYRqldQdSXWaNuQHd0GhPuXKQzg,180 +onnx/backend/test/data/node/test_regex_full_match_empty/test_data_set_0/input_0.pb,sha256=_oHGYv3MwEVLQZORNyWn0P7JLcItELdIsVNG3t_B7qM,9 +onnx/backend/test/data/node/test_regex_full_match_empty/test_data_set_0/output_0.pb,sha256=1k5BGRIQy5gADr5-ANfqJ5wHmJ-X3M2lEVtj_GZhiQU,11 +onnx/backend/test/data/node/test_relu/model.onnx,sha256=hzHJyDRTlaWNI-jSCxr_WqNHCOSCwGYwlc2URQeJoss,99 +onnx/backend/test/data/node/test_relu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_relu/test_data_set_0/output_0.pb,sha256=SqNj4MYf1_XozMtqbVv31LmL5bj5_lZV-tOJ9tLs8Ik,254 +onnx/backend/test/data/node/test_relu_expanded_ver18/model.onnx,sha256=KMFio-_6x2DXs7Bs_EyGD11Jy3eR-BfL3LPM9TW8Rpo,335 +onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/output_0.pb,sha256=SqNj4MYf1_XozMtqbVv31LmL5bj5_lZV-tOJ9tLs8Ik,254 +onnx/backend/test/data/node/test_reshape_allowzero_reordered/model.onnx,sha256=dT_jn-AjR3oDp4PUIa5AhLWGgBa-AHZmMn21ZGl78uw,192 +onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_0.pb,sha256=39jbCpQe08mPS4dsbK-BTXXytqtNJ2iXlQ87ZOq2p_E,16 +onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_1.pb,sha256=R5lCYdXFlSEYA9XjPU_Fjhx54__PbgfONnz-Qdy3NGo,37 +onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/output_0.pb,sha256=5DBO19lQ938nrN3x2OoaFb2OR5PxUJ0gS8dSub3omIE,20 +onnx/backend/test/data/node/test_reshape_extended_dims/model.onnx,sha256=bmqLwDRhon01bx5ug1tYnSIVVNG03BA5uW7VVkRj1us,172 +onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_1.pb,sha256=WagSbqYw6WuUYvL67CYqSzbZnVaoUz9MELD3BuUy8b4,45 +onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/output_0.pb,sha256=IDzjEzlEsBbvtMbnKI40MRU6IcXAR1W-gqBHFiXjLJM,118 +onnx/backend/test/data/node/test_reshape_negative_dim/model.onnx,sha256=kfvEtJ5Rx-jc2OsZMZV4n59C1Wb9m17RNU_6w5Y6M6k,167 +onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_1.pb,sha256=_45XuV5dYHVVu7Rx1FGNnvotQy31w4eANzXAA3bGEdE,37 +onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/output_0.pb,sha256=h1F8s8Hz2FQZbHF9HSMXEHzVHS1_RFukvMhdN4ouMns,116 +onnx/backend/test/data/node/test_reshape_negative_extended_dims/model.onnx,sha256=2A9QF2BrlCc_9r-ZHL2yWwuI2hQ_gUpyfU2XM8IJ8RI,181 +onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_1.pb,sha256=iuyo7JbFDNgl5IVKR0CPdvTCJjQfguS1qvi1qBtMvgY,45 +onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/output_0.pb,sha256=ZEJUohoXCbDgCdfxDVGfmH90AUhuNfiuq8pHSx7qi1M,118 +onnx/backend/test/data/node/test_reshape_one_dim/model.onnx,sha256=gkfulEm4Wpm6TOfJQQHWjjnKgjcaahBAzHl5hLSCBbs,154 +onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_1.pb,sha256=FnE_Y1xn7VcaF4iHxUcnwkMCqpumPFvsjsIvG7gZE8Y,21 +onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/output_0.pb,sha256=OW1VHWrW-p-vlPhvSXpGxaAnh794jpWNM46uGjVODRY,112 +onnx/backend/test/data/node/test_reshape_reduced_dims/model.onnx,sha256=pIj2y1gsLfHTBCzLzdWp--EjWxFe56OzMgpbeETXhfs,163 +onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_1.pb,sha256=ouJ6_oGL8_HBKEg7fUJpxVLNhpa96Ql0goSY7PqqYz8,29 +onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/output_0.pb,sha256=X0SC5DZwUl-yurzky8NKAXMQ94Z8WqR5ctunKFK1gIk,114 +onnx/backend/test/data/node/test_reshape_reordered_all_dims/model.onnx,sha256=BDO3ExBuvDYU-UM96rzJNrwkD4B_VlcEtaGpEzTMrk8,173 +onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_1.pb,sha256=WuXoFZwaDusBjM6stvBuiE2-ueq2hqpxw1IBgbDzXtw,37 +onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/output_0.pb,sha256=F3qOrvE7h1CQDCR8WwQFjdGHVYugNnpU2wa104F5rBw,116 +onnx/backend/test/data/node/test_reshape_reordered_last_dims/model.onnx,sha256=mafsUZOb1eLJQVoGCjMWaS2FsgDKOK0MBkpFec_V_o8,174 +onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_1.pb,sha256=g3yoG_7MeWVeyjtusuY4oWwwveQIuhkh27RQzhIr1HU,37 +onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/output_0.pb,sha256=J5J0ckD6rfn_-S4k1g8mo4qexsZdcE9w7kh_MMB-91k,116 +onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/model.onnx,sha256=iV9q_vBxoB0HBtYY32HKgGFmG4v0sDoslQHDBMFu9YE,180 +onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_1.pb,sha256=fGG-r1bYO3tPdrYbBsKgm8rNOTpMVc43zP5kzaWsOc4,45 +onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/output_0.pb,sha256=WpdkH70wR430ATRzOjP79tz4aqDju2-ZGEjmriNmZtw,118 +onnx/backend/test/data/node/test_reshape_zero_dim/model.onnx,sha256=aURvW469oYSgRAVbHtfAksoNQanPdBobRdMkzQQZzKE,167 +onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_1.pb,sha256=3LQjg-0h7af-IHdpcviFQ7n-7bI2IX04SBTcYt7KGYw,45 +onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/output_0.pb,sha256=OMGl3G0rnNPISyblKGPC3m3crj7IOfBg606ZZ16iUhU,118 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic/model.onnx,sha256=NvGAYLAArD0c10T1O5h7aaRuo0Q1N0ahZydZETAIdCg,186 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_1.pb,sha256=xPbOKT20LLRRzkK1NtGYUZK7K7jMcf7SR8v48R7Uaqo,30 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/output_0.pb,sha256=ZGnKaDrIFCTD_3Yb67GNTX-IVokI9Yr0bh9sWg6us-A,51 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/model.onnx,sha256=_ptXRcW2a1pg6gZDFiIp2ltFvXCRIbrr6ANMwicXsU0,258 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb,sha256=xPbOKT20LLRRzkK1NtGYUZK7K7jMcf7SR8v48R7Uaqo,30 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb,sha256=loFVIECPdfM4Elw8zNFWIE6JQTefZRc362LdOfJBgPA,51 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/model.onnx,sha256=H6KLpWckHrepT_R1YhD5UzEKXFtCOvzpQBFzkO10PRs,252 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_1.pb,sha256=xPbOKT20LLRRzkK1NtGYUZK7K7jMcf7SR8v48R7Uaqo,30 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/output_0.pb,sha256=2cgJqsQF1PGm1LLvvc9Dc5u6_YD8DHxfSgkKNV0gQtk,51 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/model.onnx,sha256=ofXD7K2I90DevflmIHO8Ht0p7SutmVeCu1GFfXfRXFM,214 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/output_0.pb,sha256=3RkVD_dvwVMDIMuTFJpRMSnAJZldXEW7WZL2Xy0xj2c,31 +onnx/backend/test/data/node/test_resize_downsample_scales_linear/model.onnx,sha256=fTKB9Mr2RLtnUE-RzyOAC2ijKeCvKvh6CrBlOIHq_SQ,188 +onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/output_0.pb,sha256=uwev2yGwG2Wa5GUD8WPsgHctU1XZJ2Q1Rf3owfZ_XHg,23 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/model.onnx,sha256=tk8tGvNP6KtfR7UMFW9f3432SLvmf9pajyuugP3BiTY,254 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/output_0.pb,sha256=dqsdDkmbIHzYaAA5V1gXM9ft7EKPO8Y-qCfxD8SjjBU,23 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/model.onnx,sha256=3Nj5SptzieyuU03tjT2Ner6GmjhEOVmWxP3lbT51Tn0,216 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/output_0.pb,sha256=1_-7ZdcqfP_WMa26f4W3pwWFk__1wz_OV-GK-HZe9Hk,31 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/model.onnx,sha256=YcAcJ63zezuxLrBF3Vgsl1TeHMU2Ogd3nLiU7g4v1Mw,268 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb,sha256=Rdy6Z1wI0QCS9oqH-9p6yUHvF-avjYhyozZYTQRcSyY,31 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb,sha256=Pv1EkH_ZwWOQBY6LxFlPlTh5YDAg7UkXgQyPbkfGCTE,30 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb,sha256=7weLx1gkYyPrWb_hlbICvh1nnkQTdCCn1usS_9sgXoc,23 +onnx/backend/test/data/node/test_resize_downsample_scales_nearest/model.onnx,sha256=1U9urxLLRINgNwIM00veMP9fErOY5QRG5HW6gp9-kyk,190 +onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/output_0.pb,sha256=Yjo_9cj_fib7n4VQV4PsQKY-y5v4-quR63M-EkCrzT0,23 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/model.onnx,sha256=6a46eIOdy_Qs4SxCR7ykEV9VTZVM4Og3pqd2DCtDjEM,185 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_1.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/output_0.pb,sha256=PiAS9GWaz3sX0Gf6Ln5Psc_9dku3ayUWL5hHq9vlzg0,51 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/model.onnx,sha256=4C6ccjEJ_YoSijXTgxAnK0FhhksGC2Iv4_DED-R_3pw,213 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_1.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/output_0.pb,sha256=FQ3KdwTmOlBZYLC7nxQY_fHxEEzwuIxommP9ItoqBUg,51 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/model.onnx,sha256=rGpyoONA3briRF0UkgzM87GAVUswPHrGZ_D9U0K1IFs,215 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_1.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/output_0.pb,sha256=4k2fzRJDvP4TITb-F963MxhGFoSpmv4Gcm1lMFsOqfM,51 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/model.onnx,sha256=VAAd9-jPn5WuhFovIXkyU76g8UAn2Wg0r06aNIiyjxI,263 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_1.pb,sha256=37sn5EOXGUhf2Y-K3TqAz2Ass_BYayom8mdmnc2h1GU,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/output_0.pb,sha256=iKqRlP_EQPX8v6QT7KLRSmrzOZZLemzCdmj8tuVgPXo,27 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/model.onnx,sha256=StlILIeH-jdXqhApX2vrq_z1APeoJPCOA-35PsZ8gA8,189 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_1.pb,sha256=EWQ2LRMYiDUHb77tpBRK0ytYOpI4T28MtPEOhezLW9E,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/output_0.pb,sha256=aBoGDHQgxT27m_eQuySjStIVzhxkJMLWH0A55bFbQ5g,27 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/model.onnx,sha256=eK6kffmxQ8WVtiuCHLZ089AYyS125sPEDrPscMxc6zY,258 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb,sha256=Ee8uWnujoqYe5BozCljVH-jTkbA4JDUotF8GxhXEZcw,29 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb,sha256=Yjo_9cj_fib7n4VQV4PsQKY-y5v4-quR63M-EkCrzT0,23 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/model.onnx,sha256=d8DDUXajzkKcuKIznrnN9NRhDlHs2VPMiTFH582mm6I,260 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb,sha256=Ee8uWnujoqYe5BozCljVH-jTkbA4JDUotF8GxhXEZcw,29 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb,sha256=nAc-MyWd9nHy3TljFTqiL0XzUFYlioeLyRGpZB2Jvcg,39 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/model.onnx,sha256=GYP_OafWY0-Ip2jTDzX1hkV7fq-xWhAQrsQSZL-xL0s,261 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_1.pb,sha256=Vlc-8jfAGlJ5VM2ARpVf-ERXb_PFAwUTkwn0ERVFzYQ,43 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_2.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/output_0.pb,sha256=WpJZbrC4oUGdfU2pRJ6Z34aitFfYz_OpfxWpEoEouiw,51 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/model.onnx,sha256=_2wYb0fspjXsFxSYql6wFFoiYH5J6ERjjUySWuCyDgI,285 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_1.pb,sha256=L1L2x0-QpyRLeyyjk73mjV7FdzUEAdNemEV0WbcZZWk,27 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_2.pb,sha256=vAIzVU8L_NauQljYoNRgwEqyRXBRLAdxNa_3HqjbY1E,29 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/output_0.pb,sha256=WpJZbrC4oUGdfU2pRJ6Z34aitFfYz_OpfxWpEoEouiw,51 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/model.onnx,sha256=syz90aTDAXM38gNXnKbP5XprnVCIpl4IdhAT-knvE5o,285 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_1.pb,sha256=tAApf3H0iSwfk8uTYnN5NBF8goYF8jHTlgp3mRG7wGo,27 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_2.pb,sha256=vAIzVU8L_NauQljYoNRgwEqyRXBRLAdxNa_3HqjbY1E,29 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/output_0.pb,sha256=WpJZbrC4oUGdfU2pRJ6Z34aitFfYz_OpfxWpEoEouiw,51 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/model.onnx,sha256=IjQ6MnGO-Fo9cvOLMGUcKfUZxryQN6EHmRZC18RyZZI,313 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_1.pb,sha256=jl82DpC9SOeZy-jQNk9BvM6nVoa-AgSa4ZtTT7709dc,43 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_2.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/output_0.pb,sha256=-7Q9n5yoaXsRRZsDvOtF_c7_YynJmUkeIQgW4rp-zKg,51 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic/model.onnx,sha256=QCvkupq4I7UtNd64GHm4u1q4sFe2Zdh_ma1EMZ3I9N8,184 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/output_0.pb,sha256=PkSU-XfoDiJLcyLNeQLkN2A9yyc9hXq4v8nm3UcPKq4,272 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/model.onnx,sha256=6mHAIPWMNAum--EwaHvxkkk8c6Dw5IECA-hnxGk7a2w,256 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb,sha256=0Ir5vu-hpsCeNPtx-nUkliiu-Vgm06Vga2TF5lryblA,272 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/model.onnx,sha256=HCQFmu-zRswTfKUSrVJgMqqbqXFvpU6tboIabJfKzF0,250 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/output_0.pb,sha256=AQz_0D5lp8mVlVoHV99xYl1kRmT-i3ZSaIM-2oAmHrs,272 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/model.onnx,sha256=KR4j7ABjJ_jI_hsrjX8JtttiB8Dwbc8A2b4jEfuR1Jc,244 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/output_0.pb,sha256=QmRUXe9rBd0mYIQPWDFpFGFADYvQFVySIweV2tFBvNE,272 +onnx/backend/test/data/node/test_resize_upsample_scales_linear/model.onnx,sha256=mEZo_9rq5fLFehb5FBaV3bKnFUBovWAzdhzhbqdqEqk,186 +onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/output_0.pb,sha256=fAWEWdC3o33m0DECLq7pDzMgk2P9M_AUYpA6oJmR6cE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/model.onnx,sha256=Ai1_ehB6rOGR1GQse3CvLwJEB9YCv7kiLWebSYLJYnk,252 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/output_0.pb,sha256=7Bpwq1ECSX1fKctUVbWV7mStOAMzyI6P5euZ310sOxQ,79 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/model.onnx,sha256=WlGAguzzIkWkkAo6ZfAdQKnSHXL50WIxJ1Zhr0oVw2I,266 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb,sha256=YuaMw9nlwphEIBDxyW46Wap5f3nI5zPV7UYjoA72gmQ,30 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb,sha256=e7ETAXX5wHi0EZN5mUMvRnkOxNAyUgy6trbeSN7uPvQ,95 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest/model.onnx,sha256=UQqEcTdiIlMdbcPIRMa1I5yM-Qa4RUC7AJelajIyXlE,188 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_1.pb,sha256=3a1OyYYNdnWsgKm8R9EJ4Ja-reMSXI0q04mtA4aFGfo,30 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/output_0.pb,sha256=sqObjzJsZ_nVStepjZKmx3dOTVd9cGqBu3Uw2w6tYFg,111 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/model.onnx,sha256=UQRCvBkSGiUgcqs8e3NwS0QUfkpF98phMycKdiYKCOc,212 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_1.pb,sha256=eYyQwyy4YgQ7gyB7cQ3EFSsVJypSRA2sAIsgdo6QPqc,22 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/output_0.pb,sha256=sqObjzJsZ_nVStepjZKmx3dOTVd9cGqBu3Uw2w6tYFg,111 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/model.onnx,sha256=N28Zs0qhbIprNOqoC7UKiuHeSpsTIZb8DnTfNHD1sLk,212 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_1.pb,sha256=mmDREgvzTwtEpDJvveHfvSZRixUEC3EI5pPND3xyE7s,22 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/output_0.pb,sha256=sqObjzJsZ_nVStepjZKmx3dOTVd9cGqBu3Uw2w6tYFg,111 +onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/model.onnx,sha256=RIKO4GXHzXsw2M5N1YgKGrWkMVqZwvMbs1er6OpPCDs,183 +onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_1.pb,sha256=nZ1sl7gz-g_V2hXQY5LuvuGaUGoBw8yTWrHeSJMcosg,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/output_0.pb,sha256=EAIMP98RAbzoToZHuzVJfftxaZYNj-guraY2RAfAc9Y,376 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/model.onnx,sha256=6-rxY2SQvDXSdskmMVaMM18HbJfpurkKmvbnI_6n9lI,187 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_1.pb,sha256=1vs5j9PloFBBBanpvHk9w3ue44PVRJ1eYMbKK18UxOs,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/output_0.pb,sha256=j2BVQHsxg5m9FtJaMV_08Y721i4ReIh15UcV_iWXsgA,240 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/model.onnx,sha256=mf61AtWMlncmh64F_VcEHZgN5R65F3gcLtugKrNVWxY,211 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_1.pb,sha256=bEY07sadyrUqd56CgpL2kpJOof8lkigI8NAOAw40NyQ,29 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/output_0.pb,sha256=j2BVQHsxg5m9FtJaMV_08Y721i4ReIh15UcV_iWXsgA,240 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/model.onnx,sha256=sXWUKH1vVFpC8ZJXdWE1Sunu6Ts3hkVax_wWRNeeujA,211 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_1.pb,sha256=lOngZJhTLdAR-LZ3kvPtpq3ScjST_SQb8On7xErMt5w,29 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/output_0.pb,sha256=j2BVQHsxg5m9FtJaMV_08Y721i4ReIh15UcV_iWXsgA,240 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/model.onnx,sha256=4KFn62-_PaftnFvGvGKF0dj2EDdTyyHL1W_Ttaajtz0,277 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_1.pb,sha256=TQJhADxzQwfIkkc2pen1_wFd2i4A0mEwyy0xjW-97n0,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/output_0.pb,sha256=3eAyujmk4k2eAAy3do3PVMqPf1luKx6ThRenNqxaA3I,272 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/model.onnx,sha256=4NEEGSuIpI2t0R7pzQcaQFlJezciMfzLBPn9e0Rwsdk,285 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_1.pb,sha256=TQJhADxzQwfIkkc2pen1_wFd2i4A0mEwyy0xjW-97n0,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/output_0.pb,sha256=sFAaFbl0e1cItIPWKmEoGnPpo2FsJFYi1U_Wq4Ugh2I,272 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/model.onnx,sha256=byktTn7y1B4nYPj-z1Ss3m53zdhy_4C3Ig7NALZ2Uk4,256 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb,sha256=bEY07sadyrUqd56CgpL2kpJOof8lkigI8NAOAw40NyQ,29 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb,sha256=Yjie6PGBxcjk8EVu0RS3US4PHyHKkcQoIyg_vrB5bXw,212 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/model.onnx,sha256=ZUbcC8eUrMz_rQHtw3YqJY-H4Qb95Zb64zCNJopgsgQ,258 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb,sha256=bEY07sadyrUqd56CgpL2kpJOof8lkigI8NAOAw40NyQ,29 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb,sha256=8clDIxBXkyuHVQ323HmQekDO90VrPFq47TfOm87Njkk,272 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/model.onnx,sha256=N20l0fhsa8cnQ9SdtwuvD1nO5NknKOe_GsNjBvhia3M,304 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_1.pb,sha256=TQJhADxzQwfIkkc2pen1_wFd2i4A0mEwyy0xjW-97n0,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/output_0.pb,sha256=3eAyujmk4k2eAAy3do3PVMqPf1luKx6ThRenNqxaA3I,272 +onnx/backend/test/data/node/test_reversesequence_batch/model.onnx,sha256=a3VXmvzlI1t3mIA2hPjhmYHL8fri4xP1_u1ZI2uG1Q0,201 +onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_0.pb,sha256=SkEHD0rsxMgSTW_tjWL00vAdiYAszJiX1Ksx5YSBdK0,75 +onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_1.pb,sha256=Wt9-cJ901jGUNQSJpk5jrUaamSkE48Z9G1veqRrgm8U,53 +onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/output_0.pb,sha256=X6YMiU-O_e2z3CYNrjkrVro88Zp9gYpoMd3iIeQPQ3E,75 +onnx/backend/test/data/node/test_reversesequence_time/model.onnx,sha256=wBxZXx0gVDsbH_UOz8PVsQseF_R3ghgk9fCDrov0lNM,200 +onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_0.pb,sha256=QhzuL3tyAa1nIihKr6jZUzHkfu4GTyPlq0GErxTiLgI,75 +onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_1.pb,sha256=Cq6df1JM6R0nUUd50ZJO7lz1h-jhb2YzMjuCxeVVIpI,53 +onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/output_0.pb,sha256=E74my-HnbjLGI__m_D9lTIR8sU4qlEEDW7AagYb5d8E,75 +onnx/backend/test/data/node/test_rms_normalization_2d_axis0/model.onnx,sha256=0fPQ1RcMkMNaE0xpBdBYq6w4ZjA9V5hw2v_ht7OZ3x8,163 +onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/input_1.pb,sha256=c5v62j2q513u7QaD0Kck1K-O-g3Q6LiJWVgNaVZ3umg,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/output_0.pb,sha256=U67cLmjDjfAM08ngd3T9z49bOV81XL75V_8BOR1HHk0,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/model.onnx,sha256=EJbahs71iJU6lOejR79YwNfkfIo7kp6rzOqW0fHIHJE,2869 +onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb,sha256=c5v62j2q513u7QaD0Kck1K-O-g3Q6LiJWVgNaVZ3umg,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb,sha256=U67cLmjDjfAM08ngd3T9z49bOV81XL75V_8BOR1HHk0,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis1/model.onnx,sha256=-1bGPWKjx4VIC5OB_aAUMHGSsiU_m9L8cfN5D8GLOuQ,159 +onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/input_1.pb,sha256=VQyK_PZb_WkSzAvjxFjoKQMs-QsSibW6jENVmyi19TM,25 +onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/output_0.pb,sha256=8cUSC5SdB8sfr_MHHS9fK1I8s6tlDTi0wm4CvR_Rr2M,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/model.onnx,sha256=0BE2HJfQH303bDmOCdsanxDjJgMi0Csvy1V4Ivn4B3I,2865 +onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb,sha256=VQyK_PZb_WkSzAvjxFjoKQMs-QsSibW6jENVmyi19TM,25 +onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb,sha256=8cUSC5SdB8sfr_MHHS9fK1I8s6tlDTi0wm4CvR_Rr2M,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/model.onnx,sha256=iTc2HehZpixYHPybYaDzX6KsaUwjzlqUyhTC4OuT1sw,178 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb,sha256=FjlIZ-qBiFKaEHCZCIKuOM9BO3PpPXi5OvB9FM1Ytg4,25 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb,sha256=o7rIBqgKo8LKf2JFHrbYbmvUs-F7XKR1FI4SYLgFprY,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/model.onnx,sha256=plOQbu8czIXi8808_1GCuXEj2xnufXwhv8Me1Jpy2BU,3282 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb,sha256=FjlIZ-qBiFKaEHCZCIKuOM9BO3PpPXi5OvB9FM1Ytg4,25 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb,sha256=o7rIBqgKo8LKf2JFHrbYbmvUs-F7XKR1FI4SYLgFprY,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/model.onnx,sha256=5XXKc4ahbuwx7cSgTF7qg_NYMxp22qGHFhC1vSlDNUE,182 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb,sha256=c-a4tsGiOvibXvtd4KLdzEZD6ZiF4aKubb8gghGiws4,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb,sha256=XX3IntpxQb7a-te18u-pK7KWfYWpvgkZnlu_car2ybU,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/model.onnx,sha256=MeK5bKRQSYptnW5C5E_1vpPUxn79_zQy7DzpRVFRfu8,3286 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb,sha256=c-a4tsGiOvibXvtd4KLdzEZD6ZiF4aKubb8gghGiws4,59 +onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb,sha256=XX3IntpxQb7a-te18u-pK7KWfYWpvgkZnlu_car2ybU,59 +onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/model.onnx,sha256=FSNkKyqL87OfwzgFpe3RDWY0D9IEMFmyog5klUqtGKI,202 +onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb,sha256=7opcXxjA9jj8tE0kwn6o2zODfFoW-_nJ5TGxMKGx3Fs,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb,sha256=RUFk7S31yRaCmg-YHDrMqPsG5bbxp45M4pEc1BbJkR0,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/model.onnx,sha256=u-BRyw178Dzpi1nBNrHgPDZ7DEcV4dxn6wr_9FMbDhI,3145 +onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb,sha256=7opcXxjA9jj8tE0kwn6o2zODfFoW-_nJ5TGxMKGx3Fs,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb,sha256=RUFk7S31yRaCmg-YHDrMqPsG5bbxp45M4pEc1BbJkR0,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/model.onnx,sha256=7nlEH-4OWtgFUKPFTmimzjXZDfohSlopph-zZlKWj48,198 +onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb,sha256=DeMX0rQ61yYg3Bsagteh01sI5U1axYPOGBci4g0bDsI,71 +onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb,sha256=MzMV6Z7nuTZsoAnVRtM2c213yPIzRCz2j6iLjHFrG2c,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/model.onnx,sha256=MebZ3fncr3-FIIZalMMumQuvnB7yt-wOAobHcvOZ-gM,3141 +onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb,sha256=DeMX0rQ61yYg3Bsagteh01sI5U1axYPOGBci4g0bDsI,71 +onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb,sha256=MzMV6Z7nuTZsoAnVRtM2c213yPIzRCz2j6iLjHFrG2c,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/model.onnx,sha256=Gf7lJB0JVQiFlBcapmF2YseS0xcaJA1RD7e3kT_ADQw,194 +onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb,sha256=ejwNovjeJ7h0TC3_W9ob0OL37KMWMYP8TU4jmABl3s8,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/model.onnx,sha256=--pelKPK3bH1UL3ZSQgj5yChubVxJ0lT7q-3Op6z9dg,3137 +onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb,sha256=ejwNovjeJ7h0TC3_W9ob0OL37KMWMYP8TU4jmABl3s8,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/model.onnx,sha256=AJR_6L8Zvt_uoRNg9AG4XXP8hLErJ1lBQQnMwkHvHrk,213 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb,sha256=RXt3ihUjYi-oqRiGbyc5XBOzmA3XIi4WvLN6rv1p-X4,29 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb,sha256=1CMSjNVwXpKvynf4zM558R-sos_LWukH68v_i8x4R6E,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx,sha256=_ADOKTXbkYoDRmZF5Wez6HeQgDV8myOfuuy__8_qqvQ,3564 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb,sha256=RXt3ihUjYi-oqRiGbyc5XBOzmA3XIi4WvLN6rv1p-X4,29 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb,sha256=1CMSjNVwXpKvynf4zM558R-sos_LWukH68v_i8x4R6E,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/model.onnx,sha256=QnYRHBVgbRQts4L9Hifr_uBUvkInloxtjwWSKYcK8Z8,217 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb,sha256=nzwigKlF4pxJl4DYZzSAHMy1wF_5BnKpO42oabvmYHg,71 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb,sha256=zNwfw4KdTLF-BAiHU48P_I1LmcBgKbjaN2qU3iT6tzE,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx,sha256=PhOesokVZ19Oc8GsajQyiydts4E20N9_OffZLfYXHO4,3568 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb,sha256=nzwigKlF4pxJl4DYZzSAHMy1wF_5BnKpO42oabvmYHg,71 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb,sha256=zNwfw4KdTLF-BAiHU48P_I1LmcBgKbjaN2qU3iT6tzE,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/model.onnx,sha256=pANIKk8VyGMTLiRgg_S6bZzpI6UVdObrs7GqOR6sPho,221 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb,sha256=jUtn8yQjzCkJH9U5ZbY894c-VbPvqTPMNNuMLIyDsu0,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb,sha256=4hClkUbTavUELvKZj_XUR1wHd9x0mPvLGaOAwlsITAw,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx,sha256=9tc7xFwBj9lFTrNRliyxiXCTNi4LruhRI3sgKJojHwo,3572 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb,sha256=jUtn8yQjzCkJH9U5ZbY894c-VbPvqTPMNNuMLIyDsu0,133 +onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb,sha256=4hClkUbTavUELvKZj_XUR1wHd9x0mPvLGaOAwlsITAw,133 +onnx/backend/test/data/node/test_rms_normalization_4d_axis0/model.onnx,sha256=6spoY5b0NLbBzOOLJPPVk8z9O8haNoAd09-LYpGOnq0,187 +onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/input_1.pb,sha256=SQ1M8CaJ0qLmcLTvIkOMlgNO0L8HwaXc_m0K26vIbnI,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/output_0.pb,sha256=ip8idzAKhkH48dC_JeeIaTzHUaSEt-YVf01PWDuGvu0,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/model.onnx,sha256=8e_Hqiu4TuE1LZYXkTjcInm0rZpEtr9hA51PE47QM4E,2893 +onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb,sha256=SQ1M8CaJ0qLmcLTvIkOMlgNO0L8HwaXc_m0K26vIbnI,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb,sha256=ip8idzAKhkH48dC_JeeIaTzHUaSEt-YVf01PWDuGvu0,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis1/model.onnx,sha256=1oQiXmYvfRnaORaRP9Q3f5PfnKzUvA4s0l0KvbZwwTQ,183 +onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/input_1.pb,sha256=aclMmoaumTmvKSFoQB1Rb30FJuJv8BOKNR0CCTTq-o8,254 +onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/output_0.pb,sha256=kgW1s3bZ_MVSGFGSISmvyJOKAHxdi6lGZCdidP9LH4k,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/model.onnx,sha256=vXqPsR8KI6GR3rdPuhu0vqMnnUdU8v_ya5M_1N1bymI,2889 +onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb,sha256=aclMmoaumTmvKSFoQB1Rb30FJuJv8BOKNR0CCTTq-o8,254 +onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb,sha256=kgW1s3bZ_MVSGFGSISmvyJOKAHxdi6lGZCdidP9LH4k,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis2/model.onnx,sha256=oue_W-Blg66MuBBB8a58iGbdX3exDciPA0244TrSJq4,179 +onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/input_1.pb,sha256=rZT472MxV8bYOxQjqKKNmTygsf90xop03eu843mkV0Q,91 +onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/output_0.pb,sha256=gwB6zwzrgWzlRu-fy0nBsMYSrQdTmfGlrJcT-vyFsC8,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/model.onnx,sha256=lKopswuXkDxatsPNxuu11jEeieMrlTRXB2edGfZ6JaE,2885 +onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb,sha256=rZT472MxV8bYOxQjqKKNmTygsf90xop03eu843mkV0Q,91 +onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb,sha256=gwB6zwzrgWzlRu-fy0nBsMYSrQdTmfGlrJcT-vyFsC8,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis3/model.onnx,sha256=4wF8aIu3cNJJcx06iTf3nEIdFa83PEh8HauPFUSHmck,175 +onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/input_1.pb,sha256=2b9fiNNbSoONUUH5CNPJ9cQb3nLBv71eQbOvmyVGzEc,29 +onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/output_0.pb,sha256=zZzzoZI3cpA38JDW6J6l3B8fM-0PIoW7TDHyOiyNOdM,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/model.onnx,sha256=y2Lut08uZedXXQj3gnWyJi87yvSrtcyzikELPlZPKnk,2881 +onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb,sha256=2b9fiNNbSoONUUH5CNPJ9cQb3nLBv71eQbOvmyVGzEc,29 +onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb,sha256=zZzzoZI3cpA38JDW6J6l3B8fM-0PIoW7TDHyOiyNOdM,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/model.onnx,sha256=qRw2oy8Q77vQf8RDvB3iq6OmoI6m6a4aZwq_bLJOTdg,194 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb,sha256=8_NN3BrsiQhr--tEyhsLTfztPB3eVZ7c9UKXrKbUhME,29 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb,sha256=9K-EJYCpwDGHrRvJxjEtUG1aUFNCCA-hnKZPgGVxWPA,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/model.onnx,sha256=PVqFVJXPfq5okQTQe8HYzEg4dIuY6u3wGawWp3ol-_Q,3298 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb,sha256=8_NN3BrsiQhr--tEyhsLTfztPB3eVZ7c9UKXrKbUhME,29 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb,sha256=9K-EJYCpwDGHrRvJxjEtUG1aUFNCCA-hnKZPgGVxWPA,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/model.onnx,sha256=3blDDx7xf9AzaH42zdJ1YFNaSlt7oYVS-0SW8dQGMok,198 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb,sha256=-cTrFx6DWKx3o8qOSexYwqtpfDqnC3La3exq9Uw_7Kw,91 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb,sha256=MxJILxkkqXAZEqT_84g0uBj0im9XOdomkhl_PXo4EKM,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/model.onnx,sha256=X_6JWbxRQqW-NfChelumMxyIwIGEpCqIcsx9xDpzx7Q,3302 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb,sha256=-cTrFx6DWKx3o8qOSexYwqtpfDqnC3La3exq9Uw_7Kw,91 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb,sha256=MxJILxkkqXAZEqT_84g0uBj0im9XOdomkhl_PXo4EKM,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/model.onnx,sha256=E-RlafFvlJ3n_iXRBzZMPv-SLOaI6GVbfpCurJw7ToM,202 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb,sha256=jQ_e5Nf51jDiZ5MmybX_I4YGCcD-CUZ4Gua3XmR2e2s,254 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb,sha256=Py5VrwHWVd_Av0wAzgn649BLVHFWSGaFaN29A_-vTZM,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/model.onnx,sha256=SRCb91ZoXVM-LLl_9SOO6H8fl1tYMptm9YDR3Ng_Qcc,3306 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb,sha256=jQ_e5Nf51jDiZ5MmybX_I4YGCcD-CUZ4Gua3XmR2e2s,254 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb,sha256=Py5VrwHWVd_Av0wAzgn649BLVHFWSGaFaN29A_-vTZM,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/model.onnx,sha256=rzRrJyQAu0VFZBUMC8-5xfBhapuDrFtfKLuhQq4oC-U,206 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb,sha256=tIsIS3JayZAuGX4lBJ-79JMJaOpSeRNg-CrvauHaEGc,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb,sha256=l0d01lmUkbL0Vy-qd236C-mQVa1XWh9OTUlYyu43Opo,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/model.onnx,sha256=nLQ4t_OL5SfLBqFdZODijRWXLXqcHOcM5tMmfDtGp_0,3310 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb,sha256=tIsIS3JayZAuGX4lBJ-79JMJaOpSeRNg-CrvauHaEGc,496 +onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb,sha256=l0d01lmUkbL0Vy-qd236C-mQVa1XWh9OTUlYyu43Opo,496 +onnx/backend/test/data/node/test_rms_normalization_default_axis/model.onnx,sha256=5WiJlGTIV6onSbT2AoOKnq9hr2S07JyMHjUi_g6HO9I,166 +onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/output_0.pb,sha256=vK1feCBhXHaB0bY8mNhxpVY9TY7Z12gsVS-Vu5DcKg4,496 +onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/model.onnx,sha256=NCWvBozOxSCVXJmdlC40LZLpbUTTYM1E0u4pbXkxGsc,3094 +onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/output_0.pb,sha256=vK1feCBhXHaB0bY8mNhxpVY9TY7Z12gsVS-Vu5DcKg4,496 +onnx/backend/test/data/node/test_rnn_seq_length/model.onnx,sha256=oy0jH_ftEEbYnRFDv-bOn7LOe9AAzILQ2QeCI25y1d0,215 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_0.pb,sha256=fFR4OIXWBj5wmFEuZbfl7GOhhRaSJv9tEZM8VbjQ72Q,85 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_1.pb,sha256=ET6TMaay9jqrVqbna-Wnsfz97AB1cb3OoixzzqcB9SE,73 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_2.pb,sha256=8OukqSSCHVpI2UW8Qhn4j9Y8PmzUUWI2y2Qi7j-l6EM,113 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_3.pb,sha256=YPIH8tZG0ntqRQMb2MWtwnrFHQBCYUBq9n-MBS8rYck,51 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/output_0.pb,sha256=J__yfJ1bCTGPdlxsojDRQtQOq4aNWQq_os7EVw4DTag,75 +onnx/backend/test/data/node/test_roialign_aligned_false/model.onnx,sha256=e-4h5tXFjmQHlBIaflJ2ud1Ob6tYbXDl623FOHoDR6c,352 +onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_0.pb,sha256=MAl6mj4EdjRRLLTTrMR3QypOOeqBR_zfDSrKfI5ZOIA,416 +onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_1.pb,sha256=0dELrNhfMRb954VgWZmrlXZ9foqomY7BBxzVO39h3F8,62 +onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_2.pb,sha256=KBLspuA99QkABElyuFbkwAASK19MfsWnSyuLyOuuhlM,45 +onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/output_0.pb,sha256=pBkN2eAHpzdKOrULgdFPb1vBUZYLEkshdoLCpFRszj0,316 +onnx/backend/test/data/node/test_roialign_aligned_true/model.onnx,sha256=DZSL1vDoPGfAI5gPT64uxC3HvZEdC7oCiPnnBEKSVCo,344 +onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_0.pb,sha256=MAl6mj4EdjRRLLTTrMR3QypOOeqBR_zfDSrKfI5ZOIA,416 +onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_1.pb,sha256=0dELrNhfMRb954VgWZmrlXZ9foqomY7BBxzVO39h3F8,62 +onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_2.pb,sha256=KBLspuA99QkABElyuFbkwAASK19MfsWnSyuLyOuuhlM,45 +onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/output_0.pb,sha256=fJDZDLjphgnhrq0aWFk-lPD_rGXn8507MnHb4SivShk,316 +onnx/backend/test/data/node/test_roialign_mode_max/model.onnx,sha256=HPzPV42k0l_KLEYHUeP_e5y9HKhd_PwA4oUHDP3JHyo,363 +onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_0.pb,sha256=MAl6mj4EdjRRLLTTrMR3QypOOeqBR_zfDSrKfI5ZOIA,416 +onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_1.pb,sha256=0dELrNhfMRb954VgWZmrlXZ9foqomY7BBxzVO39h3F8,62 +onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_2.pb,sha256=KBLspuA99QkABElyuFbkwAASK19MfsWnSyuLyOuuhlM,45 +onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/output_0.pb,sha256=TlRBT6bTd12HEPhEY2vPxZQBJiTCRcgxHzeyBj42FE4,316 +onnx/backend/test/data/node/test_rotary_embedding/model.onnx,sha256=ezlX96XXeKYK-lpzmVo5d0A175f-aYXpsdyC77XtCEo,275 +onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_1.pb,sha256=jCvlQGNHlUX2eBsRb4vaOwzMyHYDK6EL2A5oNt4rJyk,820 +onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_2.pb,sha256=pKjPj9XOllQpqjSdR_3IyP1trQuDhEhly397lY3D9Os,820 +onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/output_0.pb,sha256=9XljyMgTSAWYIUvFsKxr-LH2FG1-n1yPNU0BejsrwBk,789 +onnx/backend/test/data/node/test_rotary_embedding_3d_input/model.onnx,sha256=3igw7NDkHipHUCyy1Rk6zxkcOgd3rhv_lRufzFM1opc,294 +onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_0.pb,sha256=WUXO1Tqc3T8GEl3kaz-TKLTpsTrKRtHAbkNhePvIJ4I,786 +onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_1.pb,sha256=jCvlQGNHlUX2eBsRb4vaOwzMyHYDK6EL2A5oNt4rJyk,820 +onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_2.pb,sha256=pKjPj9XOllQpqjSdR_3IyP1trQuDhEhly397lY3D9Os,820 +onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/output_0.pb,sha256=7Kz4F7KcOt6Wj5AMMioZTZngbghVq_dQmp9YG6LbxHQ,787 +onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/model.onnx,sha256=cqrQ6XEMIyNNeEXMOjKSMxSBogHmrd7AhK6yN-PqUIo,7049 +onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_0.pb,sha256=WUXO1Tqc3T8GEl3kaz-TKLTpsTrKRtHAbkNhePvIJ4I,786 +onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_1.pb,sha256=jCvlQGNHlUX2eBsRb4vaOwzMyHYDK6EL2A5oNt4rJyk,820 +onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_2.pb,sha256=pKjPj9XOllQpqjSdR_3IyP1trQuDhEhly397lY3D9Os,820 +onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/output_0.pb,sha256=7Kz4F7KcOt6Wj5AMMioZTZngbghVq_dQmp9YG6LbxHQ,787 +onnx/backend/test/data/node/test_rotary_embedding_expanded/model.onnx,sha256=HVYoGCvr7kMZMErFZMV7w_Jt9houb3gm8ClSWPTA8kk,5952 +onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_1.pb,sha256=jCvlQGNHlUX2eBsRb4vaOwzMyHYDK6EL2A5oNt4rJyk,820 +onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_2.pb,sha256=pKjPj9XOllQpqjSdR_3IyP1trQuDhEhly397lY3D9Os,820 +onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/output_0.pb,sha256=9XljyMgTSAWYIUvFsKxr-LH2FG1-n1yPNU0BejsrwBk,789 +onnx/backend/test/data/node/test_rotary_embedding_interleaved/model.onnx,sha256=DmucU3jCQTYiEmj-67HEj6xR9MCNbUJlFbrQq6KXAtY,307 +onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_1.pb,sha256=jCvlQGNHlUX2eBsRb4vaOwzMyHYDK6EL2A5oNt4rJyk,820 +onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_2.pb,sha256=pKjPj9XOllQpqjSdR_3IyP1trQuDhEhly397lY3D9Os,820 +onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/output_0.pb,sha256=kQ4McORVo8WBuzWNzq1-kwJ53MWMH7tSM1De06PqWQk,789 +onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/model.onnx,sha256=wcMakV33_VXApots8CF7BV2TmAqvi0k7VdbGNib1e-8,9026 +onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_1.pb,sha256=jCvlQGNHlUX2eBsRb4vaOwzMyHYDK6EL2A5oNt4rJyk,820 +onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_2.pb,sha256=pKjPj9XOllQpqjSdR_3IyP1trQuDhEhly397lY3D9Os,820 +onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/output_0.pb,sha256=kQ4McORVo8WBuzWNzq1-kwJ53MWMH7tSM1De06PqWQk,789 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/model.onnx,sha256=LHOgFE33GrJxKLYBSrx8jTLB7JTRIBE3-rCUEzyOxAU,253 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_1.pb,sha256=ddhyl1MqYJRR9Br0ChVr5YmVDHujOi8_Ut6-3bCmzng,117 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_2.pb,sha256=aFO1ZHeACvBIZG9VWaLcJFsZ2CqSA6oafsgn6sPZo3o,117 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/output_0.pb,sha256=L7g9o2t3u7CZ6pfT99TgXPX-X23qPYKpGrbQBIXAL3I,789 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/model.onnx,sha256=97Z-19uF9YLZI20f--_WI9FFmXkiO2Et03dqLXp-NDA,7104 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_1.pb,sha256=ddhyl1MqYJRR9Br0ChVr5YmVDHujOi8_Ut6-3bCmzng,117 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_2.pb,sha256=aFO1ZHeACvBIZG9VWaLcJFsZ2CqSA6oafsgn6sPZo3o,117 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/output_0.pb,sha256=L7g9o2t3u7CZ6pfT99TgXPX-X23qPYKpGrbQBIXAL3I,789 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/model.onnx,sha256=6JKvsgHCgtmtTWer01Tb-hl_qXliA0DPlQ60lYhGEw4,285 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_1.pb,sha256=ddhyl1MqYJRR9Br0ChVr5YmVDHujOi8_Ut6-3bCmzng,117 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_2.pb,sha256=aFO1ZHeACvBIZG9VWaLcJFsZ2CqSA6oafsgn6sPZo3o,117 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/output_0.pb,sha256=sJmE9QQAChJDjn2gNKQ0ec86H6ly5Q_7Ysoog8fchnk,789 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/model.onnx,sha256=tnFerbcWB8-36-JI4A4kcVxRNH1ON2b4EcEE2sJE0UY,10581 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_1.pb,sha256=ddhyl1MqYJRR9Br0ChVr5YmVDHujOi8_Ut6-3bCmzng,117 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_2.pb,sha256=aFO1ZHeACvBIZG9VWaLcJFsZ2CqSA6oafsgn6sPZo3o,117 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/output_0.pb,sha256=sJmE9QQAChJDjn2gNKQ0ec86H6ly5Q_7Ysoog8fchnk,789 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/model.onnx,sha256=47WyDa9pl3vqnj5gDk19rIIpKsHRnyAHXS00vwvDAUA,293 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_1.pb,sha256=L3oDajX19aXTXcYrKLcHQMLk_iPl6rCV_agMkIpb2Jg,69 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_2.pb,sha256=6GAzkmytMur4osNU5u1R9ilhbUsJingPnUDgbWCpeJM,69 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/output_0.pb,sha256=p5C10cZLrQgEuhALUnyD-nH87MBFHxtOK9nksWWSWfg,789 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/model.onnx,sha256=ZJyJUEHEsU7D7Skk5RLMhIPcVsjoo7aUZ2YV5-b66rw,7858 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_1.pb,sha256=L3oDajX19aXTXcYrKLcHQMLk_iPl6rCV_agMkIpb2Jg,69 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_2.pb,sha256=6GAzkmytMur4osNU5u1R9ilhbUsJingPnUDgbWCpeJM,69 +onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/output_0.pb,sha256=p5C10cZLrQgEuhALUnyD-nH87MBFHxtOK9nksWWSWfg,789 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/model.onnx,sha256=O26kKv6_anntghBhMXVqQM8h2p6vckpONEWr_B6vXGg,352 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_1.pb,sha256=Nos14g-wothI4IRBDiO-NAWWqsNgb5z3xnIVv0v2Bwg,420 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_2.pb,sha256=Kqpd7ixPBxNK_Ered4DAIjD8mwzkP4YTGc_AuGUmi44,420 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/output_0.pb,sha256=0S9u74bmBlhEbvA08MVQfWWPEXTZDMBaq4ZxT1hkwzQ,789 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/model.onnx,sha256=huyRiqnKyNuhJ2agSxOp3xONuj4y3inacAKIO1n9eDU,10558 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_1.pb,sha256=Nos14g-wothI4IRBDiO-NAWWqsNgb5z3xnIVv0v2Bwg,420 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_2.pb,sha256=Kqpd7ixPBxNK_Ered4DAIjD8mwzkP4YTGc_AuGUmi44,420 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/output_0.pb,sha256=0S9u74bmBlhEbvA08MVQfWWPEXTZDMBaq4ZxT1hkwzQ,789 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/model.onnx,sha256=XtMFHyY0ChTN4XJRzpcgMKGPZBPLLjpPMjsFFmpI2w8,320 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_1.pb,sha256=Nos14g-wothI4IRBDiO-NAWWqsNgb5z3xnIVv0v2Bwg,420 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_2.pb,sha256=Kqpd7ixPBxNK_Ered4DAIjD8mwzkP4YTGc_AuGUmi44,420 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/output_0.pb,sha256=3tEoqtiU2rvDcGyvM0HqU1uJ1G18drLSt5dA-LUIJ0g,789 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/model.onnx,sha256=jT_jHWjffiKwnZ293n0FI0wicaUofAUffR3iiUjLnSg,7090 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_0.pb,sha256=l__Su2nC_g7Xn1Pp2UZ1De05YaAKSmFf5Y7Trpbbxx8,788 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_1.pb,sha256=Nos14g-wothI4IRBDiO-NAWWqsNgb5z3xnIVv0v2Bwg,420 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_2.pb,sha256=Kqpd7ixPBxNK_Ered4DAIjD8mwzkP4YTGc_AuGUmi44,420 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_3.pb,sha256=29ohwekGkgeqW-EnNx8y96bbsRejsLMxh3_IJd47xpY,70 +onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/output_0.pb,sha256=3tEoqtiU2rvDcGyvM0HqU1uJ1G18drLSt5dA-LUIJ0g,789 +onnx/backend/test/data/node/test_round/model.onnx,sha256=5N4RBMiRIT30-9Zg3zy3BGIlsvADpV6B9kXVApOMsvc,85 +onnx/backend/test/data/node/test_round/test_data_set_0/input_0.pb,sha256=cHlnrY3Uk-RbEkYhAli-6AAm8OTVLrXCadT3V-VzqNw,69 +onnx/backend/test/data/node/test_round/test_data_set_0/output_0.pb,sha256=ZsG9a3LCPTA8lsuKatNZHi17ZVfdZb_L-nBR-4mezCI,69 +onnx/backend/test/data/node/test_scan9_multi_state/model.onnx,sha256=ICz8IsR52oNBrQSLJ524u7dpSjOK5WPlDAEylFLYCn0,533 +onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_0.pb,sha256=z7H-FRWGDiHZsJVYxnIpH3Iiq2AUAMw1Qm16YdHQ5Ig,27 +onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_1.pb,sha256=8CuI5HwslPPgpVsDhjK2OpgroGrXXfPOo_vn-0aZ8Uc,28 +onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_2.pb,sha256=t5reF7GY_oHbl7Vv4kVs1SoxvwpCDuisZdvKyL_FV-s,35 +onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_0.pb,sha256=OCjmuUEAVxsFzPUAyZECwYxyIfH8zp1wp8hSIBNrQsM,21 +onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_1.pb,sha256=oEIOKxX3Dn9hpH1FxDYgG8KPfBSSLP8M9o6_GYIOZ5k,22 +onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_2.pb,sha256=HL309oJqNALe24vCksVqGrZ85esldvFHCW6BJejssMw,35 +onnx/backend/test/data/node/test_scan9_scalar/model.onnx,sha256=8BDaPs_kCKN3-4p8BlEtt9TogBejLKdlGNIbjqv7dCM,327 +onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/input_0.pb,sha256=E4HE4L2iG2s-bn5lFQgl139C_4iQF71RiZC4Ow-OMRA,17 +onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/input_1.pb,sha256=pL1459G3qyp0W_xxYh7lltxaB5rsf2tKPna5qyui5Rs,29 +onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/output_0.pb,sha256=kErzM5uLV_2N8I1oGILS97UWk3XtJuU5nvEQN7zg98M,11 +onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/output_1.pb,sha256=70FI6oIpFxmhGfw82Hf8y2Hgqi20amHdG5dFZRhXotE,29 +onnx/backend/test/data/node/test_scan9_sum/model.onnx,sha256=Ve46oUSSwpRflBSGNS1Z-v-QGmWXgzHrBI28MRwcH10,356 +onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_0.pb,sha256=BnhbN_OTtCNX4M6io3UpaIpvxLzrzErNVilo4coaHGM,23 +onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_1.pb,sha256=t5reF7GY_oHbl7Vv4kVs1SoxvwpCDuisZdvKyL_FV-s,35 +onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_0.pb,sha256=1sTPVuO9wgsKDIg1gHRzhl3ErtQ1AkzI8laUM5YnrsI,17 +onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_1.pb,sha256=HL309oJqNALe24vCksVqGrZ85esldvFHCW6BJejssMw,35 +onnx/backend/test/data/node/test_scan_sum/model.onnx,sha256=w18Rca-5_7wQKF8J1GDeCht69vqzuP5jhtemapX05Ww,373 +onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_0.pb,sha256=hft6PG5mqQ8I6v75s5v-STuBVSUl7jLRHCIYXQvvY0g,25 +onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_1.pb,sha256=AYFDqPhKTq-30FDGtMNfVnNc7S63t8gevJZ5mCzDIuw,37 +onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_0.pb,sha256=ATpWiBkuoiOqvU3Ad2myqm3WbAGmyrxfQD-VAfugDM4,19 +onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_1.pb,sha256=LHi4F8MFmjXkX1oYEtIO2SOeEooNoaw2uD1woEvXUi4,37 +onnx/backend/test/data/node/test_scatter_elements_with_axis/model.onnx,sha256=WK7CTrPZTogMaBWL4loizfcx-n60FSOvqF_MFwgOZ0o,216 +onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_1.pb,sha256=yxAkaBm3PWG9VJ8QL9zIHyP9dhDU0NmwftHGiVWTbmQ,33 +onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/output_0.pb,sha256=JcgSylIhYN2e8u823w30DFfY3PA8sLsLxUDtn6dGNxw,31 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/model.onnx,sha256=zH2xipnpOkq7FoVC7cDl8imEpz-5zW72QybRS9EgoMw,250 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_1.pb,sha256=LtXsziTJhM9eu2tV2pF68OB993sF-YaVhWI0izz49TE,33 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/output_0.pb,sha256=DjROkWNEJO-bgVoEdccRipm7A57FFhCf5hpJbikVJYk,31 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/model.onnx,sha256=NmexRxrBS5OI5SNRqpyS67zwEpZpnczkzobgHpRFke8,228 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_1.pb,sha256=q0Fin1pAQYBdnSVWMB4WrxdLIAqsz7cEIXK1wpL7HU4,33 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/output_0.pb,sha256=8VeVc3XRkIkfpRbJcVpn2e1uRLVVYuqOH4P1iLBaecE,31 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/model.onnx,sha256=4LrnmkHzDZ3YI0LeVoU5GVjge3pUxV5gAjfXeghreb4,246 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_1.pb,sha256=LtXsziTJhM9eu2tV2pF68OB993sF-YaVhWI0izz49TE,33 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/output_0.pb,sha256=WBm964VPNdWt89-yahLjj-RvVplFLut4ZXE0dfnAUuM,31 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/model.onnx,sha256=0vsDUI5GdeNGWs9SnbEn8Z5XYbneMDWgNTMATmhNkts,246 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_1.pb,sha256=LtXsziTJhM9eu2tV2pF68OB993sF-YaVhWI0izz49TE,33 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/output_0.pb,sha256=WADdYmrlyUDxTlC66OZ4XSg_-wQyGi9T4zlov7eXuVA,31 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/model.onnx,sha256=I0i4QBsyO2bPXdzSTpLfdntmp0vAIeZPu7T5E8DXWOM,246 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_1.pb,sha256=LtXsziTJhM9eu2tV2pF68OB993sF-YaVhWI0izz49TE,33 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/output_0.pb,sha256=yU_ifSJZxBBfhOITBKHIK0mYJxRQqKU01Mawx3o-PsE,31 +onnx/backend/test/data/node/test_scatter_elements_without_axis/model.onnx,sha256=5HX0on3L5s_YHj50f0VGynXETPH7KT5qPkvhRgMB34Q,206 +onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_0.pb,sha256=DiaJ-ROL20bBztx5Xg3H7swSLlKyglCXlmncvXA-HPM,50 +onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_1.pb,sha256=WXUWKy1f1Dr3A5TpL6asvPHu54JotHi6BQUtGRE7JOU,65 +onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_2.pb,sha256=FB191eliy4ig-YiffzExk2oVes_SQmX9mHmi6f9Hfh0,41 +onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/output_0.pb,sha256=LNLuWCnaX_nnESo8S2kfkcdAP2b_Prx7HAGSQu1nZGo,47 +onnx/backend/test/data/node/test_scatter_with_axis/model.onnx,sha256=mCeJdeuAWeQ2cIfU14Z4Ak4vnlKz1CmVH4cLSsFn1Jc,199 +onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_1.pb,sha256=yxAkaBm3PWG9VJ8QL9zIHyP9dhDU0NmwftHGiVWTbmQ,33 +onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/output_0.pb,sha256=JcgSylIhYN2e8u823w30DFfY3PA8sLsLxUDtn6dGNxw,31 +onnx/backend/test/data/node/test_scatter_without_axis/model.onnx,sha256=3PIZOZHIxXEr-zqvEWLoqwtdYL-u86zgSDXLv_w1CX4,189 +onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_0.pb,sha256=DiaJ-ROL20bBztx5Xg3H7swSLlKyglCXlmncvXA-HPM,50 +onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_1.pb,sha256=WXUWKy1f1Dr3A5TpL6asvPHu54JotHi6BQUtGRE7JOU,65 +onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_2.pb,sha256=FB191eliy4ig-YiffzExk2oVes_SQmX9mHmi6f9Hfh0,41 +onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/output_0.pb,sha256=LNLuWCnaX_nnESo8S2kfkcdAP2b_Prx7HAGSQu1nZGo,47 +onnx/backend/test/data/node/test_scatternd/model.onnx,sha256=bivVceLLPAvDCX2F-7S7g_5V1KP_jTWUKBb1I2EHJVk,192 +onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_1.pb,sha256=qUcsgYavSojoDVEkWYR3mzbddMcAMBPdRT4-G56dq1A,33 +onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd/test_data_set_0/output_0.pb,sha256=A6LOHrpDiF3e-qhcVGjGViue1VwB_INvC3ybI-jpnVU,270 +onnx/backend/test/data/node/test_scatternd_add/model.onnx,sha256=pYn7qepwWYvAL_DUNkJ_frU8pMhPl_hWs1xJXhPpCbQ,217 +onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_1.pb,sha256=yUrlT5iCIq0_2sUQNf_ql7v3LIeB4ZdHnA_kjiY6qE4,33 +onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/output_0.pb,sha256=Pg4VIAYXcs47zRkEaqMYymr8C5m7po7X2ru2phvlYow,270 +onnx/backend/test/data/node/test_scatternd_max/model.onnx,sha256=SFfA1SCU5HdrgvqZhqwbCFhbtT0S4-jAidV-Q6GHYrc,217 +onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_1.pb,sha256=yUrlT5iCIq0_2sUQNf_ql7v3LIeB4ZdHnA_kjiY6qE4,33 +onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/output_0.pb,sha256=H01S0BHgoas9UovgsbP5Z6NrAjVkCQuZQQFdRv2GsZ4,270 +onnx/backend/test/data/node/test_scatternd_min/model.onnx,sha256=YhCygCjRYWyVCBFo5iaYsG-pGLn2HK0wgTIP4bnLT_M,217 +onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_1.pb,sha256=yUrlT5iCIq0_2sUQNf_ql7v3LIeB4ZdHnA_kjiY6qE4,33 +onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/output_0.pb,sha256=bxnp_Su4TiWAgetLLCEZyk0yunmaFzrwlozwz9H8iaw,270 +onnx/backend/test/data/node/test_scatternd_multiply/model.onnx,sha256=4_A5H04c4XRoD50uMfujmSqh_Gq2fmfB3NRx4s7Y8Uc,222 +onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_1.pb,sha256=yUrlT5iCIq0_2sUQNf_ql7v3LIeB4ZdHnA_kjiY6qE4,33 +onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/output_0.pb,sha256=M6TZol_avnQUDu8YK3eANT0kknICIs65yucp2T0rXfU,270 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/model.onnx,sha256=4DjLogkrqhacIeo9bDuxaXEiMj2DiDf63gIqEnmOAVI,231 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb,sha256=qupP19AFkVGsd5p_IG3o67eqQmCi4VOmIPPH2HatK8E,374 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb,sha256=B1l-vlt8ntQR6mMtlxFwTx5L-JRc48LxU5URv95CBwg,156 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb,sha256=S4-FwQAxtH_avU6Egu10Eg7k2WkcisObX8kZuTMU1HE,29 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb,sha256=T1FHwvvDgmOgW7Wcdac4m7Ox5leiRh7vEpBMM_acaaQ,11 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/model.onnx,sha256=ePNl_XFo8EbbDr1TohiYMiSTY27lWaRUA4_IJwaNPGg,1672 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb,sha256=qupP19AFkVGsd5p_IG3o67eqQmCi4VOmIPPH2HatK8E,374 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb,sha256=B1l-vlt8ntQR6mMtlxFwTx5L-JRc48LxU5URv95CBwg,156 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb,sha256=S4-FwQAxtH_avU6Egu10Eg7k2WkcisObX8kZuTMU1HE,29 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb,sha256=T1FHwvvDgmOgW7Wcdac4m7Ox5leiRh7vEpBMM_acaaQ,11 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/model.onnx,sha256=qPccBQaYpxSGbNs26guvmm0OVSGVuLseoBdqhQkDupk,282 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_0.pb,sha256=qupP19AFkVGsd5p_IG3o67eqQmCi4VOmIPPH2HatK8E,374 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_1.pb,sha256=B1l-vlt8ntQR6mMtlxFwTx5L-JRc48LxU5URv95CBwg,156 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_2.pb,sha256=S4-FwQAxtH_avU6Egu10Eg7k2WkcisObX8kZuTMU1HE,29 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_0.pb,sha256=T1FHwvvDgmOgW7Wcdac4m7Ox5leiRh7vEpBMM_acaaQ,11 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_1.pb,sha256=OVOOloRk_LlopMXvzfRiT17U7xyjZZqdiZtrcdp54gg,381 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/model.onnx,sha256=AwsPBxuS30rFBhQkQTpFjzIICdDK5WR2BKxRlnHweUo,1959 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=qupP19AFkVGsd5p_IG3o67eqQmCi4VOmIPPH2HatK8E,374 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=B1l-vlt8ntQR6mMtlxFwTx5L-JRc48LxU5URv95CBwg,156 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_2.pb,sha256=S4-FwQAxtH_avU6Egu10Eg7k2WkcisObX8kZuTMU1HE,29 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=T1FHwvvDgmOgW7Wcdac4m7Ox5leiRh7vEpBMM_acaaQ,11 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=OVOOloRk_LlopMXvzfRiT17U7xyjZZqdiZtrcdp54gg,381 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/model.onnx,sha256=MkIxoow4nc3DSQ6QRUyXxgMXTGo4pnaGmVlsr_jFTPc,250 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb,sha256=Oj0wAqZWCkppXwBrkc88a6tsGSuIPPixSSKyu-0iAFI,10818 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb,sha256=4RPKO8gfYFkdhvfs-BUDko5KhATj_U0MJsqius0TDBI,4336 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb,sha256=la3r1KC4cnxtWqQmIjhvr5g6d51CtvveNgyfB9dH7ow,2176 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx,sha256=b9f_7RDCB-p-c4xXii_LzXjE9b9BFG11eI1th4gN2rQ,1789 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb,sha256=Oj0wAqZWCkppXwBrkc88a6tsGSuIPPixSSKyu-0iAFI,10818 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb,sha256=4RPKO8gfYFkdhvfs-BUDko5KhATj_U0MJsqius0TDBI,4336 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb,sha256=la3r1KC4cnxtWqQmIjhvr5g6d51CtvveNgyfB9dH7ow,2176 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/model.onnx,sha256=3dTRTlrZTBHv1JlBIrcvxSxLP4TUTkV5y_NM_2_6_Dw,309 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_0.pb,sha256=Oj0wAqZWCkppXwBrkc88a6tsGSuIPPixSSKyu-0iAFI,10818 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_1.pb,sha256=4RPKO8gfYFkdhvfs-BUDko5KhATj_U0MJsqius0TDBI,4336 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_0.pb,sha256=la3r1KC4cnxtWqQmIjhvr5g6d51CtvveNgyfB9dH7ow,2176 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_1.pb,sha256=WwTHHroM-9FFzxR9_T4rNpxcDfim9TWe7gZSOyW9dmo,10825 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/model.onnx,sha256=77p7YOdBc-XatsOyn3QWF8kD4Zdj1aW0GOMNJkbl5Ag,2091 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=Oj0wAqZWCkppXwBrkc88a6tsGSuIPPixSSKyu-0iAFI,10818 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=4RPKO8gfYFkdhvfs-BUDko5KhATj_U0MJsqius0TDBI,4336 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=la3r1KC4cnxtWqQmIjhvr5g6d51CtvveNgyfB9dH7ow,2176 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=WwTHHroM-9FFzxR9_T4rNpxcDfim9TWe7gZSOyW9dmo,10825 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/model.onnx,sha256=6CST92qbIJai61Z17kv2qWUliCv-4jNORS8i5bswDl0,212 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb,sha256=ECSYPd0TVGdd40h-c438gJx2ydi3K7_5RBP4JFP4my4,33 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb,sha256=lv65FooWlI3jBxoDOoZFOvy7S8opPsYwNL5tiia8U3U,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb,sha256=3aYW5UER_i5SRrjYt-SDD8VMa-GvcwrTG9Y9Qc-5CYk,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx,sha256=j8rQDC-MWlFg87VAcZfCrhS-lslAMKA7iW7AzyDfaGE,1639 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb,sha256=ECSYPd0TVGdd40h-c438gJx2ydi3K7_5RBP4JFP4my4,33 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb,sha256=lv65FooWlI3jBxoDOoZFOvy7S8opPsYwNL5tiia8U3U,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb,sha256=3aYW5UER_i5SRrjYt-SDD8VMa-GvcwrTG9Y9Qc-5CYk,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/model.onnx,sha256=y8kNNJ56nd8PSzLYECLjEk8XwCDpSWdysau225CSpNI,259 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_1.pb,sha256=ECSYPd0TVGdd40h-c438gJx2ydi3K7_5RBP4JFP4my4,33 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_2.pb,sha256=lv65FooWlI3jBxoDOoZFOvy7S8opPsYwNL5tiia8U3U,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_0.pb,sha256=3aYW5UER_i5SRrjYt-SDD8VMa-GvcwrTG9Y9Qc-5CYk,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/model.onnx,sha256=FtGQ7KjUknKScU3L1SUUAIS4gpaqr30ixmBUQ6-REc0,1921 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=ECSYPd0TVGdd40h-c438gJx2ydi3K7_5RBP4JFP4my4,33 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_2.pb,sha256=lv65FooWlI3jBxoDOoZFOvy7S8opPsYwNL5tiia8U3U,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=3aYW5UER_i5SRrjYt-SDD8VMa-GvcwrTG9Y9Qc-5CYk,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/model.onnx,sha256=15CKZ6DFK9pgqZwiJaYE8xGF3rBGiYCjA46GWKXt9UE,229 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb,sha256=7c-ar0sMCQdJWPdtJ0UpaFamw1FPHpEbrzYZq0LmkLM,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb,sha256=8TWjevDFjBey-IIoPfPMfeoeTsioE4dSFepfqkKERe4,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/model.onnx,sha256=a5I16sJlQjIhADbyISsEp2VJu6iNrYzHTWlcQM5f6As,1614 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb,sha256=7c-ar0sMCQdJWPdtJ0UpaFamw1FPHpEbrzYZq0LmkLM,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb,sha256=8TWjevDFjBey-IIoPfPMfeoeTsioE4dSFepfqkKERe4,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/model.onnx,sha256=YY5-0tZwDx90tQD82OBpjTbmRqdG_OKVunHsjH6mhfM,296 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_2.pb,sha256=7c-ar0sMCQdJWPdtJ0UpaFamw1FPHpEbrzYZq0LmkLM,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_0.pb,sha256=8TWjevDFjBey-IIoPfPMfeoeTsioE4dSFepfqkKERe4,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_1.pb,sha256=XSkwM4eCCjrPXkQeTjFxrP1R3X8PGrHLj1UaChCsHFk,129630 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/model.onnx,sha256=09dt3pvbvWp5yUKOS65ubmHCevNtJ21KbCjeUPF8rvo,1913 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb,sha256=7c-ar0sMCQdJWPdtJ0UpaFamw1FPHpEbrzYZq0LmkLM,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb,sha256=8TWjevDFjBey-IIoPfPMfeoeTsioE4dSFepfqkKERe4,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb,sha256=XSkwM4eCCjrPXkQeTjFxrP1R3X8PGrHLj1UaChCsHFk,129630 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/model.onnx,sha256=ULvWGcrcdSA1N_SUhkV1a6n2qI3MTPLeqWhZdqgwUz4,236 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb,sha256=QG6n-tNdHkQgVv67CaAhmakmLGNLAPn0d_3F0ZQcLhs,25941 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx,sha256=x91VgaxENlIQOA2y-v5mUc2FFt5VjHG8Gu4KDmrUAyQ,1663 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb,sha256=QG6n-tNdHkQgVv67CaAhmakmLGNLAPn0d_3F0ZQcLhs,25941 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/model.onnx,sha256=kuUxbSd2Kk-OVlzmBwsJPV2hJYpFtd0IJXqvKo4bffw,303 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_0.pb,sha256=QG6n-tNdHkQgVv67CaAhmakmLGNLAPn0d_3F0ZQcLhs,25941 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_1.pb,sha256=XSkwM4eCCjrPXkQeTjFxrP1R3X8PGrHLj1UaChCsHFk,129630 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/model.onnx,sha256=2tcnV4ot7YtPLDc2hrj134D1hYL78w3GK6ST4G-DkiE,1965 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_0.pb,sha256=QG6n-tNdHkQgVv67CaAhmakmLGNLAPn0d_3F0ZQcLhs,25941 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_1.pb,sha256=XSkwM4eCCjrPXkQeTjFxrP1R3X8PGrHLj1UaChCsHFk,129630 +onnx/backend/test/data/node/test_sce_mean/model.onnx,sha256=3-aUSOHOXSSfPlQt8uevWOY0JebH_Kfy4U23ceBqJMY,148 +onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean/test_data_set_0/output_0.pb,sha256=ukRi1Wf8MHKfHhzBXTTjokAYLg59piNsWW1WCJoZKbQ,11 +onnx/backend/test/data/node/test_sce_mean_3d/model.onnx,sha256=b5f8KkCsoJ4L67xiLvpfytT09dUUaLEcgfZ5ROroihw,160 +onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_1.pb,sha256=kNoEKy3hlfUjU19ueKYQpkIk-4x7sch0y0l7QJwS_fE,59 +onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/output_0.pb,sha256=miNyQyEMweya7bpEMp1TzAzXJzFp6xF-tqsM_YwAgYs,11 +onnx/backend/test/data/node/test_sce_mean_3d_expanded/model.onnx,sha256=q-u73xENPehluTdlJWM5_LrRkAcNfHTrB9OHxLcaTIw,1305 +onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_1.pb,sha256=kNoEKy3hlfUjU19ueKYQpkIk-4x7sch0y0l7QJwS_fE,59 +onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/output_0.pb,sha256=miNyQyEMweya7bpEMp1TzAzXJzFp6xF-tqsM_YwAgYs,11 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/model.onnx,sha256=N0mTSdtEJf0VC6pr_80Z-iH6lZKHqyoFLABQN1kInU4,211 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_1.pb,sha256=kNoEKy3hlfUjU19ueKYQpkIk-4x7sch0y0l7QJwS_fE,59 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_0.pb,sha256=miNyQyEMweya7bpEMp1TzAzXJzFp6xF-tqsM_YwAgYs,11 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/model.onnx,sha256=Pw8adJBkNBaFPyqtq5nf0C6e75H7tSROEtcmDhevIzo,1572 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=kNoEKy3hlfUjU19ueKYQpkIk-4x7sch0y0l7QJwS_fE,59 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=miNyQyEMweya7bpEMp1TzAzXJzFp6xF-tqsM_YwAgYs,11 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_expanded/model.onnx,sha256=TfH-LhShXm0l-eXwnqag3gi4pGL_VJtIyTjtRDrji5Q,1252 +onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/output_0.pb,sha256=ukRi1Wf8MHKfHhzBXTTjokAYLg59piNsWW1WCJoZKbQ,11 +onnx/backend/test/data/node/test_sce_mean_log_prob/model.onnx,sha256=rVrCzG3FrS3dBFUDfVMIr4uj_G-SWjxDAxT9mA1mMqc,196 +onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_0.pb,sha256=ukRi1Wf8MHKfHhzBXTTjokAYLg59piNsWW1WCJoZKbQ,11 +onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/model.onnx,sha256=xN4nEG5gFvD7tP7DFSD2UsbqWMpEmdld0fnUWWQjCmQ,1512 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_0.pb,sha256=ukRi1Wf8MHKfHhzBXTTjokAYLg59piNsWW1WCJoZKbQ,11 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii/model.onnx,sha256=SBpEoe9urLW0rKeW0Ac3BzNiwtc9v4bMTW1nHNnHRuw,183 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_1.pb,sha256=RyZME3YrdXmqynJj4q0osF7rcCSLXSIG2ufdzx0CWNo,33 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/output_0.pb,sha256=-p2yYFxEuzJ3QVJAAEY02AlKOWgqfAh-pYOeft2_X-s,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/model.onnx,sha256=hiUDHPE0pIkYNzMom_XlZLWqOZEGlpnDlhmVoXTHkoE,194 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_1.pb,sha256=I4cSUTJG17QP5oA6xVZKsUhMOd-3Ykysb6WzcbuY1m4,59 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/output_0.pb,sha256=PFOkOYcvliqNXtaW0RiMuvEKPotIC1lrIuQlASKuwqA,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/model.onnx,sha256=NPfg8j3S2-3d77D-bWCAA3P_paurP1cRDZHhkRyN8oE,1522 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_1.pb,sha256=I4cSUTJG17QP5oA6xVZKsUhMOd-3Ykysb6WzcbuY1m4,59 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/output_0.pb,sha256=PFOkOYcvliqNXtaW0RiMuvEKPotIC1lrIuQlASKuwqA,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/model.onnx,sha256=HP6L2jRokXh1_vYgTh-CA4Pqpu4mw5sys0ZaBECvzic,245 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_1.pb,sha256=I4cSUTJG17QP5oA6xVZKsUhMOd-3Ykysb6WzcbuY1m4,59 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_0.pb,sha256=PFOkOYcvliqNXtaW0RiMuvEKPotIC1lrIuQlASKuwqA,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/model.onnx,sha256=jEDXQgGxGjSzMNfNn48mwHMUbpfHPNAxWhW2-iA0P7w,1802 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=I4cSUTJG17QP5oA6xVZKsUhMOd-3Ykysb6WzcbuY1m4,59 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=PFOkOYcvliqNXtaW0RiMuvEKPotIC1lrIuQlASKuwqA,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/model.onnx,sha256=A8FoRpgKtUOk4tOBHau3h4ZipX4Hu0RxF8-keeJwghw,202 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/output_0.pb,sha256=T1V0dSN1m0drt7O148bSLjanf8_Y6jYvzLcOyWMeUcc,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/model.onnx,sha256=X9nRxKLRogAJfBTFCU2G6-HzYKhMp3ep4M7EwDmbVNE,1530 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/output_0.pb,sha256=T1V0dSN1m0drt7O148bSLjanf8_Y6jYvzLcOyWMeUcc,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/model.onnx,sha256=sYLdAh9Wrfmia2nhAuMOFPnatKFH9bxxgrInChYqFvQ,257 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_0.pb,sha256=T1V0dSN1m0drt7O148bSLjanf8_Y6jYvzLcOyWMeUcc,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_1.pb,sha256=w-EurMdSNKZnr-TaXWH4MRaTpJ4Oj-02F1ZbQw4Gch0,863 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/model.onnx,sha256=RCwsAOHhRl-O5bFL_b4w-Ua5wUTSr8hufvHwXzTZTaA,1814 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=T1V0dSN1m0drt7O148bSLjanf8_Y6jYvzLcOyWMeUcc,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=w-EurMdSNKZnr-TaXWH4MRaTpJ4Oj-02F1ZbQw4Gch0,863 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/model.onnx,sha256=q9QvMFTS8OztLXMlaXeKvt7LRrVmnlPDm5020UaXHkk,1469 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_1.pb,sha256=RyZME3YrdXmqynJj4q0osF7rcCSLXSIG2ufdzx0CWNo,33 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/output_0.pb,sha256=-p2yYFxEuzJ3QVJAAEY02AlKOWgqfAh-pYOeft2_X-s,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/model.onnx,sha256=j7HGJhVhHWH5CFK5UID5XF2ctIy43BXBlsqx6KmPFwU,230 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_1.pb,sha256=RyZME3YrdXmqynJj4q0osF7rcCSLXSIG2ufdzx0CWNo,33 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_0.pb,sha256=-p2yYFxEuzJ3QVJAAEY02AlKOWgqfAh-pYOeft2_X-s,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/model.onnx,sha256=VzorXg051TojMytCig-YX2oEh35Gmuz_mQ4M5S4WuAA,1742 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=RyZME3YrdXmqynJj4q0osF7rcCSLXSIG2ufdzx0CWNo,33 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=-p2yYFxEuzJ3QVJAAEY02AlKOWgqfAh-pYOeft2_X-s,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_weight/model.onnx,sha256=FDtFwSxTJi2o6AxnBuYfJ50s5T4D7mCELpj0DsZLVbQ,176 +onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/output_0.pb,sha256=lP_xZt4-fH-c-MMHxDWyE0nPc82po0Cj8pMGFj1zxNM,11 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/model.onnx,sha256=8YacVoGPm3GpfQQDrJMUjOem0zDK5U7sgwUptKajO7w,1378 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/output_0.pb,sha256=lP_xZt4-fH-c-MMHxDWyE0nPc82po0Cj8pMGFj1zxNM,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii/model.onnx,sha256=ubPeobCw3w8cF0I1Qnr2L_N6wGyzQ-0Wg3F7v_mcUcs,200 +onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_1.pb,sha256=YJUO7ePUACgNVajGJigiRsGzGaqL0hHgIAz6jyu88zk,33 +onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/output_0.pb,sha256=0JMPnsJnw0rYj2LJGjJHGXrFcuwORQsPfEJdn7048yI,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/model.onnx,sha256=NsPI86Dp0m9do2WsjEkCA9R1JcYaMDi1UcDhrJfn5xc,211 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_1.pb,sha256=trcZ3XMzOOuOFUO4W2aWJTmt7OFdWqdw8PCSQR0mprM,59 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/output_0.pb,sha256=qsY4ogfxxosqu-qK9YR3AW7Hq7r51jui_D3hT_1Vvxo,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/model.onnx,sha256=2FoQTNK043NuohFyUgPwpRNlhzDbhO_aLT6cBQ4lAcs,1497 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_1.pb,sha256=trcZ3XMzOOuOFUO4W2aWJTmt7OFdWqdw8PCSQR0mprM,59 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/output_0.pb,sha256=qsY4ogfxxosqu-qK9YR3AW7Hq7r51jui_D3hT_1Vvxo,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/model.onnx,sha256=bn4-smvay63gs1M_duVEpUKF1r0LYcHjChuS97GXypA,262 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_1.pb,sha256=trcZ3XMzOOuOFUO4W2aWJTmt7OFdWqdw8PCSQR0mprM,59 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_0.pb,sha256=qsY4ogfxxosqu-qK9YR3AW7Hq7r51jui_D3hT_1Vvxo,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/model.onnx,sha256=r4Sxfan1qnUwWoy2WqbrGK0euPoX1xB5G4jyHLnY4Qs,1774 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=trcZ3XMzOOuOFUO4W2aWJTmt7OFdWqdw8PCSQR0mprM,59 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=qsY4ogfxxosqu-qK9YR3AW7Hq7r51jui_D3hT_1Vvxo,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/model.onnx,sha256=1AYaMPMGNskTnRJg7Y0lDPeEYqOEtomdbz3rfcBZNmQ,219 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/output_0.pb,sha256=84SOfKbFoEmqcmwtI0T00WQkBlWevdpnax2C7UfyKIs,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/model.onnx,sha256=C2QnHfrdT3fox922LPCYt56dqOh7wv0hzlesUZKm810,1505 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/output_0.pb,sha256=84SOfKbFoEmqcmwtI0T00WQkBlWevdpnax2C7UfyKIs,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/model.onnx,sha256=7jOM2AOOk_vbCzoIpmYtfEEra5Sk_CesOa_8wQDLxdY,274 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_0.pb,sha256=84SOfKbFoEmqcmwtI0T00WQkBlWevdpnax2C7UfyKIs,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_1.pb,sha256=w-EurMdSNKZnr-TaXWH4MRaTpJ4Oj-02F1ZbQw4Gch0,863 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/model.onnx,sha256=5D5IXJS0E3jfGyP4bKSC3Xxxx-Py8x_L7bLfsgozeZQ,1786 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=84SOfKbFoEmqcmwtI0T00WQkBlWevdpnax2C7UfyKIs,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=w-EurMdSNKZnr-TaXWH4MRaTpJ4Oj-02F1ZbQw4Gch0,863 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/model.onnx,sha256=j46HBvdOCXuiQR_0FH7hr-kTwUuYykrPqZCq_hYcUps,1444 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_1.pb,sha256=YJUO7ePUACgNVajGJigiRsGzGaqL0hHgIAz6jyu88zk,33 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/output_0.pb,sha256=0JMPnsJnw0rYj2LJGjJHGXrFcuwORQsPfEJdn7048yI,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/model.onnx,sha256=IdUuxD1i3D9ZVQBa2r-E7cBsRGa5pslBpvLxNAvIRuE,247 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_1.pb,sha256=YJUO7ePUACgNVajGJigiRsGzGaqL0hHgIAz6jyu88zk,33 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_0.pb,sha256=0JMPnsJnw0rYj2LJGjJHGXrFcuwORQsPfEJdn7048yI,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/model.onnx,sha256=MZDb9GUNI8EDzj_6fsm21bEEe-hzeTJybNPUsYuaEQs,1714 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=YJUO7ePUACgNVajGJigiRsGzGaqL0hHgIAz6jyu88zk,33 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=0JMPnsJnw0rYj2LJGjJHGXrFcuwORQsPfEJdn7048yI,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/model.onnx,sha256=bi4ZJXOlblQde7zQJ2IXr19-7Tuzh7ABGIF1y9UBkxw,223 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_0.pb,sha256=lP_xZt4-fH-c-MMHxDWyE0nPc82po0Cj8pMGFj1zxNM,11 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/model.onnx,sha256=DZKdS7gtR9_bhuodjbc-XDv8AIXyxzKcjxcd4mojvVg,1644 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb,sha256=lP_xZt4-fH-c-MMHxDWyE0nPc82po0Cj8pMGFj1zxNM,11 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_none/model.onnx,sha256=H2lkLn0o5LXqCGKwv1US_QPA4ziHj_dWCD_VRr-x0So,153 +onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none/test_data_set_0/output_0.pb,sha256=x2eu67Bj72ih7ElYhvsY3EgwooqYYka6FOBY-4e-f5c,21 +onnx/backend/test/data/node/test_sce_none_expanded/model.onnx,sha256=jvMjhz-FPf3Y5Ljjl_wmeuy3w4SCJqd3eqboiqLZj3s,1256 +onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/output_0.pb,sha256=x2eu67Bj72ih7ElYhvsY3EgwooqYYka6FOBY-4e-f5c,21 +onnx/backend/test/data/node/test_sce_none_log_prob/model.onnx,sha256=Y9YRxncQJ320tXRz50KQeX4soUQ_g7qUQqNvr2dmmac,200 +onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_0.pb,sha256=x2eu67Bj72ih7ElYhvsY3EgwooqYYka6FOBY-4e-f5c,21 +onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/model.onnx,sha256=nDowvW1SSVlbo-44PvNAi27cBtPN-QkGjBweoaXEgSU,1516 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_0.pb,sha256=x2eu67Bj72ih7ElYhvsY3EgwooqYYka6FOBY-4e-f5c,21 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_none_weights/model.onnx,sha256=vUIbLrpezyXgtQIFBb85vvUQZc-I5OWnzy3fwqygqK4,181 +onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/output_0.pb,sha256=y-XkkLpEvSyr9CE4PdlzMmWIvBjaeZB0A0NCBrJ19ig,21 +onnx/backend/test/data/node/test_sce_none_weights_expanded/model.onnx,sha256=Gj0emH3XxL0lpeXKFM_5A_TyLlojnAxleEZd-IFi_ZI,1397 +onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/output_0.pb,sha256=y-XkkLpEvSyr9CE4PdlzMmWIvBjaeZB0A0NCBrJ19ig,21 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/model.onnx,sha256=s7n7tjyaNx2mI62GzKgQa73qF8mTVqTIfbSBEikGNgg,228 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_0.pb,sha256=y-XkkLpEvSyr9CE4PdlzMmWIvBjaeZB0A0NCBrJ19ig,21 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/model.onnx,sha256=3VIOOJuLcgdPaAwOLtfYcd2q9TR6JxU-pvVYvIWqAhE,1664 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_0.pb,sha256=y-XkkLpEvSyr9CE4PdlzMmWIvBjaeZB0A0NCBrJ19ig,21 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_sum/model.onnx,sha256=eKWzrBbwBTgYlHY-2HmzgUTx8HpbkbYXYDKzaPGjFsE,146 +onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_sum/test_data_set_0/output_0.pb,sha256=G7TfEJjhMn00Lpl6iXNHr_RQDPDaYWFElmZsgbqn13c,11 +onnx/backend/test/data/node/test_sce_sum_expanded/model.onnx,sha256=deboOkn3M8rduO0dixjQGrjXaKtjr8ayU4P9l73GD58,1236 +onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/output_0.pb,sha256=G7TfEJjhMn00Lpl6iXNHr_RQDPDaYWFElmZsgbqn13c,11 +onnx/backend/test/data/node/test_sce_sum_log_prob/model.onnx,sha256=2tYIhEZKQCXLk0k_GwDtKRP-nd259yfV-ZZTbPVtUtI,194 +onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_0.pb,sha256=G7TfEJjhMn00Lpl6iXNHr_RQDPDaYWFElmZsgbqn13c,11 +onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/model.onnx,sha256=usBI99QeRs6byBL7GjCGujjTkngrZVtWdSG2ou-dg6k,1494 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_0.pb,sha256=G7TfEJjhMn00Lpl6iXNHr_RQDPDaYWFElmZsgbqn13c,11 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_selu/model.onnx,sha256=eZYueUFFi1u6W_d4wSiXI782WtBpiU4g7IQ8uyEYNHs,133 +onnx/backend/test/data/node/test_selu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_selu/test_data_set_0/output_0.pb,sha256=3t_C-XZiQzxkvHFf3gx504Kj9Q0MV9112pt5kMmd8oQ,254 +onnx/backend/test/data/node/test_selu_default/model.onnx,sha256=2iyJxqWQkENGQKwM1rvywtBJPV-cfigEcQbE5kTKyFY,107 +onnx/backend/test/data/node/test_selu_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_selu_default/test_data_set_0/output_0.pb,sha256=_aFrBuR3jDgYVvV-OBwrJAzuyFsY0oAPRG4CXasl6nY,254 +onnx/backend/test/data/node/test_selu_default_expanded_ver18/model.onnx,sha256=h3cIE5-IoDq6fDDAAZ1YHGkozoprP8-0EXX6oKVQ0VA,1680 +onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/output_0.pb,sha256=_aFrBuR3jDgYVvV-OBwrJAzuyFsY0oAPRG4CXasl6nY,254 +onnx/backend/test/data/node/test_selu_example/model.onnx,sha256=KXGLzWUmKIs71KGYibTFUp7p26Lw9JFLIY7b91PYHvw,125 +onnx/backend/test/data/node/test_selu_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_selu_example/test_data_set_0/output_0.pb,sha256=GV9rQBElEpmyFwZK5vUCoErkUB9RzczSO8s8wBrlC2U,21 +onnx/backend/test/data/node/test_selu_example_expanded_ver18/model.onnx,sha256=6APAkckMLmBXple_3UQwMVYpf02213InCALqYB3YvY8,1664 +onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=GV9rQBElEpmyFwZK5vUCoErkUB9RzczSO8s8wBrlC2U,21 +onnx/backend/test/data/node/test_selu_expanded_ver18/model.onnx,sha256=qjTTbqvlMjwWwE44MeUPBOHQp88UpqbST66W_nhW_zI,1464 +onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/output_0.pb,sha256=3t_C-XZiQzxkvHFf3gx504Kj9Q0MV9112pt5kMmd8oQ,254 +onnx/backend/test/data/node/test_sequence_insert_at_back/model.onnx,sha256=dclz71fwabxjiwz7ZZPpZ3ERqjKUCfxs9MmwS5o-S0I,181 +onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_0.pb,sha256=WDgw3x97Oup88446uaFPYpisr9Lmw6gkCgC6dO8RTB8,108 +onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_1.pb,sha256=HM2wXt_MR9LhixZe95BE_6V4E0I8aGCth0LMDB_HfFM,38 +onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/output_0.pb,sha256=ztM0AhuLe0puEOS9gTDqXrLfm79yY-n3E2NT6ZVMu1s,147 +onnx/backend/test/data/node/test_sequence_insert_at_front/model.onnx,sha256=jHJltVXI4xcX2wLCEOTU8zTdCgFE-73rmpzFqAb5U4c,216 +onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_0.pb,sha256=WDgw3x97Oup88446uaFPYpisr9Lmw6gkCgC6dO8RTB8,108 +onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_1.pb,sha256=Hw_0b-P2L4hJ3YPDPqlTs0s4rH9VdGOA2GO_hkQ3xaM,38 +onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_2.pb,sha256=hRxu_mZX41ntrJWWbxx8f7P6EnyayB8ka0iNrMaxFj0,24 +onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/output_0.pb,sha256=T17FYTW-QhMbvm3f8yY1hDND0c4r6qEtLdIGlcQblEs,147 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/model.onnx,sha256=OfGcJofqQCkVFhPal0FCQgWSlvjbr1shOVMI2nxKq8M,272 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_0.pb,sha256=nCXX4WEnc0Zu3v-2E9cMzpL-HDU_mXtYYAVy4nBG_to,150 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_1.pb,sha256=4LWEZM0lo_jM1KcnB2dq0CYg0TvFm7G3_eRttrDsycU,50 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/output_0.pb,sha256=MYwdCW3clBFkSs7zcMQR211ZOPnLwIkOVyLHhSUwlFA,150 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/model.onnx,sha256=dyU0kfVT2Fx83iA2ADqcXZnzZ3M3g6AB5St0Dy5vMeM,2583 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb,sha256=nCXX4WEnc0Zu3v-2E9cMzpL-HDU_mXtYYAVy4nBG_to,150 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb,sha256=4LWEZM0lo_jM1KcnB2dq0CYg0TvFm7G3_eRttrDsycU,50 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb,sha256=MYwdCW3clBFkSs7zcMQR211ZOPnLwIkOVyLHhSUwlFA,150 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences/model.onnx,sha256=Mc9kMXbr184Szpv9fAbC6BMTnCTJdG83fws0BRhWEGU,268 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_0.pb,sha256=cGwNd7wWWJ-FuNDIPlO8IvEIyjmzK0D-xYjIam7MXhU,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_1.pb,sha256=bf6wd6KFJk459ileC4koSFigL5H6HdmP33e-4lH815M,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/output_0.pb,sha256=PkOXYpt42DXPXr5LGcda5uLFKC3W4SXgWNrvjupnYxM,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/model.onnx,sha256=WQtKBAc9qxRR1Z7p20KsXH3JvS9396ukdYuqfo6woWU,2502 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_0.pb,sha256=cGwNd7wWWJ-FuNDIPlO8IvEIyjmzK0D-xYjIam7MXhU,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_1.pb,sha256=bf6wd6KFJk459ileC4koSFigL5H6HdmP33e-4lH815M,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/output_0.pb,sha256=PkOXYpt42DXPXr5LGcda5uLFKC3W4SXgWNrvjupnYxM,74 +onnx/backend/test/data/node/test_sequence_map_extract_shapes/model.onnx,sha256=Jsl6R2LLrjHqFbg1N_uoGT7dW9HtxevfhzLm2lZVDl4,248 +onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/input_0.pb,sha256=mPhMK4W7csMlfDABLzSUi_9hj5Yyoaybjwu7Megeiyw,17452 +onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/output_0.pb,sha256=PXiF7who7_NSvRSbm7qpuMjQlD5XXC40cVlJBFVo4NI,106 +onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/model.onnx,sha256=xCqJXbZ7WsC9KoFpy3BvQMIR1v5b_n9DYuRhRPQUdK4,2232 +onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/input_0.pb,sha256=mPhMK4W7csMlfDABLzSUi_9hj5Yyoaybjwu7Megeiyw,17452 +onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/output_0.pb,sha256=PXiF7who7_NSvRSbm7qpuMjQlD5XXC40cVlJBFVo4NI,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/model.onnx,sha256=OEeIP33hLWof6fEFh_haP8yrxUYh7w1TePk86XFJrFs,220 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/input_0.pb,sha256=6tnw5WE3C0cv0L08TL4bxvHXwwdVH6diP_77Wwk_6a8,149 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/output_0.pb,sha256=1EIyt4XmclkaRfxbArKm4RLQAJ1XgXG3_0vGgEm0lOY,149 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/model.onnx,sha256=21q_NLTDki4fmu_UvzCQbYGplZXFVeEp8LktrHp4mN8,350 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_0.pb,sha256=p9PoQWTo5bC27UoTmyKqVW7FNgPzuy19YhT8PfT0k8M,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_1.pb,sha256=ZyvRjOUi5VBwdltGImSNNn_iVdnJ4lCr8fJNRgGenw0,18 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_0.pb,sha256=hMkE_GYM8mWkRJa_E5S3GXal67uKMxKuOiAHw9POsJk,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_1.pb,sha256=h2zwPyLH6s4cI9yRu_DJMHHm1wnDg5SXWFDAWEaI3zg,54 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/model.onnx,sha256=nP2doMsKhjazXp5WYeLS8IWMGgF3Qh9jFsf4QnjSgc4,3664 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb,sha256=p9PoQWTo5bC27UoTmyKqVW7FNgPzuy19YhT8PfT0k8M,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb,sha256=ZyvRjOUi5VBwdltGImSNNn_iVdnJ4lCr8fJNRgGenw0,18 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb,sha256=hMkE_GYM8mWkRJa_E5S3GXal67uKMxKuOiAHw9POsJk,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_1.pb,sha256=h2zwPyLH6s4cI9yRu_DJMHHm1wnDg5SXWFDAWEaI3zg,54 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/model.onnx,sha256=hiA16-f3aO5Nt6NmliOYBS7IOU3u8PUXz9Gcx8sjPg8,2307 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/input_0.pb,sha256=6tnw5WE3C0cv0L08TL4bxvHXwwdVH6diP_77Wwk_6a8,149 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/output_0.pb,sha256=1EIyt4XmclkaRfxbArKm4RLQAJ1XgXG3_0vGgEm0lOY,149 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/model.onnx,sha256=gBknA8YcoQ3V89G83B5Jh7ypAYRVOPZ2yiI_NXj4NYw,346 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_0.pb,sha256=p9PoQWTo5bC27UoTmyKqVW7FNgPzuy19YhT8PfT0k8M,106 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_1.pb,sha256=edLeh_wZP5_dANUseUALIqMRTOZ7y1QyX7w9_rZFYdU,82 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_0.pb,sha256=hMkE_GYM8mWkRJa_E5S3GXal67uKMxKuOiAHw9POsJk,106 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_1.pb,sha256=QNVN7ibNoj0ZZ8qF6QDsbXXk5ReGVQrR58d7XUF7Lzs,82 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/model.onnx,sha256=7Q_GyTpRAMwU6C1nN_emXFXtUQ7mPJpZvzmVsc44ob0,3524 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_0.pb,sha256=p9PoQWTo5bC27UoTmyKqVW7FNgPzuy19YhT8PfT0k8M,106 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_1.pb,sha256=edLeh_wZP5_dANUseUALIqMRTOZ7y1QyX7w9_rZFYdU,82 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_0.pb,sha256=hMkE_GYM8mWkRJa_E5S3GXal67uKMxKuOiAHw9POsJk,106 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_1.pb,sha256=QNVN7ibNoj0ZZ8qF6QDsbXXk5ReGVQrR58d7XUF7Lzs,82 +onnx/backend/test/data/node/test_shape/model.onnx,sha256=Z76E0xOiNsIEFmzZrtBNlkd014tkeG0-OFAgTtGU4MY,93 +onnx/backend/test/data/node/test_shape/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape/test_data_set_0/output_0.pb,sha256=EECFSLSrOZp2gtSXfesFT_CNAvoEOqauyDoYlnKEOTE,33 +onnx/backend/test/data/node/test_shape_clip_end/model.onnx,sha256=_91Ak28BlwcE4QzOdO_t0uNKvDFGQDb9CpelPWWc4Mc,114 +onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/output_0.pb,sha256=EECFSLSrOZp2gtSXfesFT_CNAvoEOqauyDoYlnKEOTE,33 +onnx/backend/test/data/node/test_shape_clip_start/model.onnx,sha256=6h0uIXXHV1pa0kPS0wMXNTwbmxYkFLy1NCJCznwApzE,127 +onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/output_0.pb,sha256=EECFSLSrOZp2gtSXfesFT_CNAvoEOqauyDoYlnKEOTE,33 +onnx/backend/test/data/node/test_shape_end_1/model.onnx,sha256=jKwePO5zpJ0MYniLtP-u5RAS4UWoumgurGN6ugl3WOc,111 +onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/output_0.pb,sha256=ujKSnDUgGwN2lii1DHBi3GFScTBofqmZ4RzFbFOIc9E,17 +onnx/backend/test/data/node/test_shape_end_negative_1/model.onnx,sha256=ArAB-6Mz6s0dYQgm-TYuf60FlNflidjny1oA4VEFqMo,129 +onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/output_0.pb,sha256=o_sMz2Vgclt0Ror2cqSXaN2p7cm4La1LMKCB8O_0aT0,25 +onnx/backend/test/data/node/test_shape_example/model.onnx,sha256=euiyIxv_59yevL_ZDJcU4EYp-t6iNbHnTOoOe7YalU0,97 +onnx/backend/test/data/node/test_shape_example/test_data_set_0/input_0.pb,sha256=4pQ6jBxU8_tBNnaRVRgYgck68GhQp-YW_tL388GcCvE,35 +onnx/backend/test/data/node/test_shape_example/test_data_set_0/output_0.pb,sha256=6ikEm3TGVfmw6AYUxs9Hj6Sz_9fYkqmojZP1Jzf94l4,25 +onnx/backend/test/data/node/test_shape_start_1/model.onnx,sha256=XE3uQVhmvKryODgPl4liABiaUJtk-IxcTa1Dnkpdykg,115 +onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/output_0.pb,sha256=6CbIjNHfclOJfoITJrtphF0oSHCpNlMWJf5rgpAe7Hc,25 +onnx/backend/test/data/node/test_shape_start_1_end_2/model.onnx,sha256=uHJpcpF4p_uoXBSZ2ZgcYQ-Y4Qb84AellvVjplSpSfQ,133 +onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/output_0.pb,sha256=EIeRS9lwJGLIo_UX9RbLDKw-bg_pno5AbyLkr0eDwbk,17 +onnx/backend/test/data/node/test_shape_start_1_end_negative_1/model.onnx,sha256=Nig5ZtaAJ_5AsDuALSL613L8XFDeQaOpybM76e8Z8Vw,151 +onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/output_0.pb,sha256=EIeRS9lwJGLIo_UX9RbLDKw-bg_pno5AbyLkr0eDwbk,17 +onnx/backend/test/data/node/test_shape_start_greater_than_end/model.onnx,sha256=GRBZRwHULHCSvVkAEWb7Is--2v6DtqAjgBlNySRSXVg,142 +onnx/backend/test/data/node/test_shape_start_greater_than_end/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_greater_than_end/test_data_set_0/output_0.pb,sha256=Str5mheI9dvkCudTAtZ8GBWbWNB4vm0nvU2lHQX7zyA,9 +onnx/backend/test/data/node/test_shape_start_negative_1/model.onnx,sha256=V8hQBDTnMorT8Csxc7n8aKMnQJpX5y_uKA1v6uoMBzU,133 +onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/output_0.pb,sha256=E5EQLnbSPOMjgkdKPi9jK7WKlPyQIdVIdbNaQTDYhrs,17 +onnx/backend/test/data/node/test_shrink_hard/model.onnx,sha256=hRk01cid7ePJWw54gaQvV4SuhFswtdeY0sMW4cCV7Mk,109 +onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/output_0.pb,sha256=KreC4NTAYK5M6dHrWIiG52RveZDpxh9mGTsf43xT4sk,29 +onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/model.onnx,sha256=g9Xalz8K-ARbwHMGzGKnXHdUHfdtfl1Xg_av5lSu7aY,1761 +onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/output_0.pb,sha256=KreC4NTAYK5M6dHrWIiG52RveZDpxh9mGTsf43xT4sk,29 +onnx/backend/test/data/node/test_shrink_soft/model.onnx,sha256=fd95F4NzSxY8j8N0YEuX3RFbmVvQk78Qzm2JpNX7VhE,125 +onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/output_0.pb,sha256=AbQplXJ5FVu2LaNzGC0t3G9EZhZUCsd-_fnyXRD9T2I,29 +onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/model.onnx,sha256=b-762wBGgDraNAQenMZF5yYpIi9UG639NYP1A8Cueaw,1761 +onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/output_0.pb,sha256=AbQplXJ5FVu2LaNzGC0t3G9EZhZUCsd-_fnyXRD9T2I,29 +onnx/backend/test/data/node/test_sigmoid/model.onnx,sha256=yepFvj3QD9Q4Zac5RYx0wffH_TJfr4KUAJ9DrpwGKN0,105 +onnx/backend/test/data/node/test_sigmoid/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sigmoid/test_data_set_0/output_0.pb,sha256=0M1TGc-0294NBpXmRH6IueVH60XOGwbeqLHuWtwlYaQ,254 +onnx/backend/test/data/node/test_sigmoid_example/model.onnx,sha256=qOwSJGf4ve6g7bQYHFcESH7TCyR-8MnWManHLNU6yCQ,97 +onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/output_0.pb,sha256=n9DyuVyiD6_UcKq3n3I64IT13QLjk3QfNoHdQTVflTE,21 +onnx/backend/test/data/node/test_sign/model.onnx,sha256=5l4xY8OBCnG5LepNxNKpVslAvTsQ7luIHrYwBJBeERw,83 +onnx/backend/test/data/node/test_sign/test_data_set_0/input_0.pb,sha256=rjz39Xc3D8_98MARLx2sEOivP3ylvsTlSYV1gS-Bkjo,53 +onnx/backend/test/data/node/test_sign/test_data_set_0/output_0.pb,sha256=GYc7eDjQSxVY5ZNV9JTqvwtl76bQQ-5Lj7KU0VWq2xU,53 +onnx/backend/test/data/node/test_simple_rnn_batchwise/model.onnx,sha256=r0ewWWNJXvIUhr4qkmTkULxip6Z1ndkJVTNoy-Xx930,242 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_0.pb,sha256=X4Jx731skujCbqYlfE79v4ovLqbqAar9VfhQTegviw8,37 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_1.pb,sha256=-qFlupAAYG72bVDrKQjQwSrFWi7iN5QBw4xnAFPcW84,45 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_2.pb,sha256=dGa_abJyaziCNP5gMI36AA1qPkXY_LbN8ysUOVmvHyk,77 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_0.pb,sha256=Ez-xZ1K8qEGZMxzQU_vbW69DKAZQtG3EiqIHGbBQt4M,63 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_1.pb,sha256=nXDD6IaK4uJCe6-oxjWmBH0vVBgbRwZ-0yFCq_-3OB0,63 +onnx/backend/test/data/node/test_simple_rnn_defaults/model.onnx,sha256=JF_-d_l-aujbyiAJHUUFctbmZUl7xCMkGoDi_Zbh-7c,196 +onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_0.pb,sha256=CfdyEi1TF1qNXdr7S9ZjPY0_c7pWtxM7ou3bNl3fNIo,37 +onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_1.pb,sha256=L2zxMm6uL4QSLsCnRiqUzv-9fp0-VkDW34RiKxcyg3g,45 +onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_2.pb,sha256=kU8zrxPzF60vfcmkNonlRPNh3BWlyVnLbMwQ5CkKp8A,77 +onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/output_0.pb,sha256=OU_yJMBnE3tT08kLB6QX9tCug2oOoUznNbKkxphDC2k,63 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/model.onnx,sha256=Qw1YIl7uZgz1LfABk5yd6lf19Y0y5ppSbWwvDpciIxo,229 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_0.pb,sha256=eujm2YGHVRU93EAGK-aPA-aFEublku2wP288wJjVc4M,49 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_1.pb,sha256=XvvuxoSRCrX0paTv67nqpKoXd_aJPHnXNXHAk58EJLo,73 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_2.pb,sha256=eHvrnjVBev9Xxrb4pqD28kF3B0UDphj4glVsRcqMlGc,113 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_3.pb,sha256=xxxsj5zURFnPlWj7Qthy8BnSXEWPmD0jqteuG9OYLzw,51 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/output_0.pb,sha256=XxDQiHg3N9hdXmZ1DvqGHcyQxln3qD178X2V3_tAm1w,75 +onnx/backend/test/data/node/test_sin/model.onnx,sha256=NCy6ksW2jHuvJYKWBWBRlX7WVn4o5QSxsXEh6CR4-SM,97 +onnx/backend/test/data/node/test_sin/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sin/test_data_set_0/output_0.pb,sha256=9o8tToPY2FZLrQ9kpgkTSRtcGUruDpzj4Mv-1YM3x7Q,254 +onnx/backend/test/data/node/test_sin_example/model.onnx,sha256=oTrtHp1BbeSHe2tIB0_tZvUW5tQdcYektZIV3vB9xyY,89 +onnx/backend/test/data/node/test_sin_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_sin_example/test_data_set_0/output_0.pb,sha256=rESUsCJt7xlSm0XiIouAgAB5X2EDtEkx1XgwSgNXt60,21 +onnx/backend/test/data/node/test_sinh/model.onnx,sha256=Si166WilXTVLMrsjMVbkEDm1VumhpwRsWPVGzAIlClM,99 +onnx/backend/test/data/node/test_sinh/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sinh/test_data_set_0/output_0.pb,sha256=zEQv_P636KZBRXg0oYuZwujFuQmZeZlKmqdxiVwDfs8,254 +onnx/backend/test/data/node/test_sinh_example/model.onnx,sha256=B62F7tp7mPSH9UYkuPdjqLWIpxeuhzCkQE8jgrKLmJ8,91 +onnx/backend/test/data/node/test_sinh_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_sinh_example/test_data_set_0/output_0.pb,sha256=K9t2_Mw4JTwHagenQVbXUofxj_teQvFtDY4StMA6np4,21 +onnx/backend/test/data/node/test_size/model.onnx,sha256=Qp4gXT4W5r6Swp2o8P4JfRROJKrvjqSSk1X3WslYl9U,87 +onnx/backend/test/data/node/test_size/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_size/test_data_set_0/output_0.pb,sha256=b1cKolCwb8qATNXxOwy-uZzIoYoFpdZ3uAldE3zbmBc,15 +onnx/backend/test/data/node/test_size_example/model.onnx,sha256=I1aDYcWqZy-uYGg-KgQNsHbxwANu9alxE8-6mFcMkxA,91 +onnx/backend/test/data/node/test_size_example/test_data_set_0/input_0.pb,sha256=4pQ6jBxU8_tBNnaRVRgYgck68GhQp-YW_tL388GcCvE,35 +onnx/backend/test/data/node/test_size_example/test_data_set_0/output_0.pb,sha256=7DuNFW7Z7uQ1cybMsorcUI-Yli8oj4V5HZFJX0W2oVk,15 +onnx/backend/test/data/node/test_slice/model.onnx,sha256=-Y-njaE0gcBSHb4aXWALKqZfPQCALE7BvM-MvRmTExs,212 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_1.pb,sha256=wc0xhhIxzp415JcdJvpBr3MTluCa3ilwjbTmaicBxXg,30 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_2.pb,sha256=cF5G7dCz_SnsX419hWpbVK4j_5H2YKZE-5xFMquukGw,28 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_3.pb,sha256=3uvlJ_2xYPsfOzK-E0Fz2WR-a1Yvmf3r1G6DZPUQ8v0,28 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_4.pb,sha256=FYpZ2BP2ch3ngdORN4Fd-XXCd1OqSsJv2WWY_whU-Jg,29 +onnx/backend/test/data/node/test_slice/test_data_set_0/output_0.pb,sha256=D_IVQ8WutqrVCZXsKWyJBT7ouKphKsCc0qSUJxTHWqM,614 +onnx/backend/test/data/node/test_slice_default_axes/model.onnx,sha256=4JJ6BOFJqe-cAZhCh_bTrU_jfCuwTmIyu1shAFTomA8,171 +onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_1.pb,sha256=0MyK8o_JTn-8OHMKQd2Fbs5NEoDrp0ZhGk5VXN4dmzU,38 +onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_2.pb,sha256=gMy-BWymFe5-HqAkM0EEfJd0pohqpQfkWvnkLE591wo,36 +onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/output_0.pb,sha256=x__ywPxcTlMOMVGXHmZiTOgKJLZByNMQhBM7bldOtX0,814 +onnx/backend/test/data/node/test_slice_default_steps/model.onnx,sha256=jwnfWp6zT12XSVPpY-HYg5haSqhx3yadBTmABYLgD3Y,198 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_1.pb,sha256=0MyK8o_JTn-8OHMKQd2Fbs5NEoDrp0ZhGk5VXN4dmzU,38 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_2.pb,sha256=gMy-BWymFe5-HqAkM0EEfJd0pohqpQfkWvnkLE591wo,36 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_3.pb,sha256=9iIJIH63usRCzPxS79uoJJal5z6hRmFovI6qk_j9cFg,36 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/output_0.pb,sha256=x__ywPxcTlMOMVGXHmZiTOgKJLZByNMQhBM7bldOtX0,814 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/model.onnx,sha256=k_XTlsDXa9msN9VdHe9K_J3ki5KaJeGOwfGPqtXWb0w,230 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_1.pb,sha256=XWv_EpyftbZOy7BvmcGybZQOKyOWxra7roBZ3Z22qRw,22 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_2.pb,sha256=P6LxgBoMoyanncUlS1nQkUDkj88OFJk_Ve-Xzhl2R1s,20 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_3.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_4.pb,sha256=H6nsc5oVsaH4Y0X2D1ZXmG5CRvWCq2I_iVx14iTm1rw,21 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/output_0.pb,sha256=widw8tjNc3GiW69yXjw3DNXyrRew0s0tW58CO06AOro,3614 +onnx/backend/test/data/node/test_slice_neg/model.onnx,sha256=JxZ24gL6ooXtIkwVYa4_T1xB4s1QRMztgMyuflxup8k,216 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_1.pb,sha256=y7Lo1gIZ0Noqo6CgxoS0eeiFhLvLERZtwLtJfDD_kQw,22 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_2.pb,sha256=HVPAD1MvsIO_DXFtTbbGyV4N8iyv-amZiqvFCmDwXo4,20 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_3.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_4.pb,sha256=H6nsc5oVsaH4Y0X2D1ZXmG5CRvWCq2I_iVx14iTm1rw,21 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/output_0.pb,sha256=WWi0BR0FvzzDXkYKRxk7YBwjvUAnpYN_1glTU9rocFA,3614 +onnx/backend/test/data/node/test_slice_neg_steps/model.onnx,sha256=jmxK1-OxeZ9jaaFhAH3-Kvi-Fm34eWPtlzRS4fvSM3I,222 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_1.pb,sha256=-Zy7pr4EQ4B7KtRMFQTOCSlyXXftEvJJ7ZN-ZDeNuZQ,38 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_2.pb,sha256=TtilbvYaT70fTxtYWUr_xaWr5e2v0OCMPMdtm6aZhfk,36 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_3.pb,sha256=9iIJIH63usRCzPxS79uoJJal5z6hRmFovI6qk_j9cFg,36 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_4.pb,sha256=7YuunH2YMZ_XZ8Axu63BxakwocdYdHjdAuBYtGoruJg,37 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/output_0.pb,sha256=yignEmTSPo1HLtKNxvQrL_hjHzz0YCWadWmUKIjD-Kk,470 +onnx/backend/test/data/node/test_slice_negative_axes/model.onnx,sha256=I_yla_KIgD4D6RFpTWtQrCU3f_1yFvyZjeisKwOknwY,198 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_1.pb,sha256=0MyK8o_JTn-8OHMKQd2Fbs5NEoDrp0ZhGk5VXN4dmzU,38 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_2.pb,sha256=gMy-BWymFe5-HqAkM0EEfJd0pohqpQfkWvnkLE591wo,36 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_3.pb,sha256=GzIxNVTw4ACJiY_83J53w9FTq-KK-8hroLrrDcD8Ql8,36 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/output_0.pb,sha256=x__ywPxcTlMOMVGXHmZiTOgKJLZByNMQhBM7bldOtX0,814 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/model.onnx,sha256=oOedHfZOtIflvQ5uiRdbfgb6Tx5LisRu4_PdGV_ZIZA,232 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_1.pb,sha256=54hVGhxKE_jcB9_6i2I-XxQHazFEivW1yktR1utgllg,22 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_2.pb,sha256=P6LxgBoMoyanncUlS1nQkUDkj88OFJk_Ve-Xzhl2R1s,20 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_3.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_4.pb,sha256=H6nsc5oVsaH4Y0X2D1ZXmG5CRvWCq2I_iVx14iTm1rw,21 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/output_0.pb,sha256=rrPue6VSpt1lUoRyxwKugP6KM5RSPt607YQ4WQ1KttU,13 +onnx/backend/test/data/node/test_softmax_axis_0/model.onnx,sha256=rPvEUpIpvKEMpLsORpNlc2C3eF4zPG3alrx0am9jiaw,125 +onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/output_0.pb,sha256=gReHANPYz0AKw3vwpUSfcfbkJyjj9NahVmvP3q9Eziw,254 +onnx/backend/test/data/node/test_softmax_axis_0_expanded/model.onnx,sha256=Uvf67IryWaNIbghB11ybsMl1oAd0RS4otNp0DYLc7fE,859 +onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/output_0.pb,sha256=gReHANPYz0AKw3vwpUSfcfbkJyjj9NahVmvP3q9Eziw,254 +onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/model.onnx,sha256=dXadX9DosmijwVIn1f6Jj5jfgGffos-9wm7XFUkkSl0,905 +onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb,sha256=gReHANPYz0AKw3vwpUSfcfbkJyjj9NahVmvP3q9Eziw,254 +onnx/backend/test/data/node/test_softmax_axis_1/model.onnx,sha256=-fdXWdlN_2pRTAR1NWUmS16_BOKalktHpA8N_fvP39I,125 +onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/output_0.pb,sha256=2NtZxKwupZCfKtMkHWpzmQmC7c88DQrshZJByIrSFHs,254 +onnx/backend/test/data/node/test_softmax_axis_1_expanded/model.onnx,sha256=bWJ1bsrya2jyX53AHNO_N8wj0ED72nM3lRP318wrxFI,859 +onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/output_0.pb,sha256=2NtZxKwupZCfKtMkHWpzmQmC7c88DQrshZJByIrSFHs,254 +onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/model.onnx,sha256=O9rrLRIkGh1qvn9uXTP_GuY_NBWnZ1_QmqRxr-bMK_4,905 +onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=2NtZxKwupZCfKtMkHWpzmQmC7c88DQrshZJByIrSFHs,254 +onnx/backend/test/data/node/test_softmax_axis_2/model.onnx,sha256=xI2MXHglefKmAVAq3tQcFcjgsm8eSu3TN-nbwtyF1Gs,125 +onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_axis_2_expanded/model.onnx,sha256=vndP3LBl1H73mq-JQ7igZVawXO4X-wjubBFQpxmX3Tc,859 +onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/model.onnx,sha256=vg2LyI1uLoTTsvne1I9d7c1OAEyqJAbT63sfLFhXrQ4,905 +onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_default_axis/model.onnx,sha256=cdN4CJp3aOtL9kxltySsMgE7nfDR0qU14TA4ZMPUYpo,118 +onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_default_axis_expanded/model.onnx,sha256=9TkAiCwfQq4IjN0VcW-QHCxpbdUTMb1dywNefX7NUg4,951 +onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/model.onnx,sha256=5jS9BaH8YIvWGy83ht5IRW_tfxoiSKxmnfkWqH9gD_I,994 +onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_example/model.onnx,sha256=feyA07cOiiKh-hENcmC-hWKB5kyneLCin5Ub7GZu6TE,105 +onnx/backend/test/data/node/test_softmax_example/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_softmax_example/test_data_set_0/output_0.pb,sha256=AxlcbRehwEN4TljnHvvA3UwR5A7TPVjLT-4ruMBkjVM,23 +onnx/backend/test/data/node/test_softmax_example_expanded/model.onnx,sha256=YbOfYjHr1VLVKasKhncA8X-GxiVvBHTvlRRgalIfHOM,881 +onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/output_0.pb,sha256=AxlcbRehwEN4TljnHvvA3UwR5A7TPVjLT-4ruMBkjVM,23 +onnx/backend/test/data/node/test_softmax_example_expanded_ver18/model.onnx,sha256=RpKwwJvijOgEJTtwWqBJgjRkgwkoqhxwFTnuD8NTQLY,919 +onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=AxlcbRehwEN4TljnHvvA3UwR5A7TPVjLT-4ruMBkjVM,23 +onnx/backend/test/data/node/test_softmax_large_number/model.onnx,sha256=SSF-_e-pfB3flN7K6UKFtiWmtvsDV0hOA4giV2S_cSY,110 +onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/output_0.pb,sha256=VVIksa1N2Whk8zHrBBuhgt3c6Grf8KBuxwwrI5lJM0A,43 +onnx/backend/test/data/node/test_softmax_large_number_expanded/model.onnx,sha256=_dWdXF9bLoxc2Rxon_ICSor9xHyr1rAEaatQaDs6TEA,943 +onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/output_0.pb,sha256=VVIksa1N2Whk8zHrBBuhgt3c6Grf8KBuxwwrI5lJM0A,43 +onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/model.onnx,sha256=IUVcW3Q_5J_U6sBO1BK3jPPdG67xElsLc5t77ASZ1EQ,986 +onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/output_0.pb,sha256=VVIksa1N2Whk8zHrBBuhgt3c6Grf8KBuxwwrI5lJM0A,43 +onnx/backend/test/data/node/test_softmax_negative_axis/model.onnx,sha256=LqbaqeEi_FLpNHU9XxKztZRbswQAo2oWyJwT6yAn6pY,141 +onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded/model.onnx,sha256=YwZwOKhiEh3xNC8oa4tNTAyg0sQfKpKeYLmR_JnwILw,963 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/model.onnx,sha256=uTMJBQCkfux5JdqgY4yKzsQJS2HQUFU8cEt050_cO2s,1007 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softplus/model.onnx,sha256=Pkm_IBpOrtdSipjj2RNW88U5eo5CZ-P9sBLZ4EMLg0o,107 +onnx/backend/test/data/node/test_softplus/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_softplus/test_data_set_0/output_0.pb,sha256=rHJ50Q-HF9yqjDagvyD5Y-sN3gPdoFkLA5AoQ-arwCY,254 +onnx/backend/test/data/node/test_softplus_example/model.onnx,sha256=wr7YWzpoH8WBBsW8xF-PbBhi1aZpOjnmMdipzgNgMRk,99 +onnx/backend/test/data/node/test_softplus_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_softplus_example/test_data_set_0/output_0.pb,sha256=hBr-1WJ2kvuYa9H8KU8JwzCmjoiJc3Hx2EEUrm1R7Gs,21 +onnx/backend/test/data/node/test_softplus_example_expanded_ver18/model.onnx,sha256=o8N5kGU49K5hQSpJktA_yOwPKSo3ryWMITSc61obz0s,653 +onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=hBr-1WJ2kvuYa9H8KU8JwzCmjoiJc3Hx2EEUrm1R7Gs,21 +onnx/backend/test/data/node/test_softplus_expanded_ver18/model.onnx,sha256=oGQzrTvruMiAZAh8rh0ieWvmiBWmF62IBASvIx0Necs,596 +onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/output_0.pb,sha256=rHJ50Q-HF9yqjDagvyD5Y-sN3gPdoFkLA5AoQ-arwCY,254 +onnx/backend/test/data/node/test_softsign/model.onnx,sha256=7h-fg9ExOGbBjI3I3B82PSmqrp1cxQEr50dY5HokLVE,107 +onnx/backend/test/data/node/test_softsign/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_softsign/test_data_set_0/output_0.pb,sha256=C1uB1I9A1YtJLV8Uk5qi0Kt4Qp4JgvRtwFC7jgpvPv0,254 +onnx/backend/test/data/node/test_softsign_example/model.onnx,sha256=MX8E5VO6mrEvm8mR4shSzwAs21cptSnftuvFQ-YsHdA,99 +onnx/backend/test/data/node/test_softsign_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_softsign_example/test_data_set_0/output_0.pb,sha256=0PjRkEThQLPQg-L9OX5IMgy3AKDBFVV19sCL_5lIw8s,21 +onnx/backend/test/data/node/test_softsign_example_expanded_ver18/model.onnx,sha256=ctkO0bzc-LtS7pGIvJ58OYyvGngyUVnUm6a7aLWgSek,661 +onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=0PjRkEThQLPQg-L9OX5IMgy3AKDBFVV19sCL_5lIw8s,21 +onnx/backend/test/data/node/test_softsign_expanded_ver18/model.onnx,sha256=kzujxj_7QVmYB_slW_nCKpbiowBThOZZHxqqBqCE1CA,605 +onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/output_0.pb,sha256=C1uB1I9A1YtJLV8Uk5qi0Kt4Qp4JgvRtwFC7jgpvPv0,254 +onnx/backend/test/data/node/test_spacetodepth/model.onnx,sha256=5bhFh8fjQS6TNDdICtgmDCob_KnzRygkh-56CaGgYeg,141 +onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/input_0.pb,sha256=RQwrUqEeNR-xpz-3gUYuK_U3iKOcH02SYQbl9v7xBq4,592 +onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/output_0.pb,sha256=bCbPbnCmL7gHpAW36xdWiJsJAR-Edj6WLGvzeQv-Dvc,592 +onnx/backend/test/data/node/test_spacetodepth_example/model.onnx,sha256=COrE-uxJ_5EJlYTiRbmDlzVrB-abPgnEKwV2BRJrWxY,149 +onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/input_0.pb,sha256=vzHIoweipp3I3wmKCKgBriLjySIPGzTodMmImqlK_js,111 +onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/output_0.pb,sha256=tit_KIMPTKvj4s3AmV4lFHs2di-xrcHDuk7J0GRVVDY,111 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/model.onnx,sha256=PdguF3n01jJ2BWS57bgVhz0nvJ6lAKsshODlU8qXvfs,254 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/input_0.pb,sha256=0MMLUhV-IwhwMRPXDWkkAOYhGXFio1ApRW7tIcwmzYg,41 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_3.pb,sha256=klI1oBl0uNJfSanTYax_iQ_y6jhdGIbAiyDMBPVj_6I,20 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/model.onnx,sha256=DC3MsMOmKoYOIeox6oW-ea9I9xE8UTpk7NQVYsl8uAM,249 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/input_0.pb,sha256=ne0IY_mmYi1Myo1AL7u3nGpHodjQpJbXmhu5LICcJMc,79 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_0.pb,sha256=lZJx7RYf8c-urSeibZ8DnaW0kP5i2lQfQly2Fb2f-Fc,42 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_1.pb,sha256=ZBvUdSiV_UXZTEDGHukB4UtnoIR11YOlHOXxleju8dY,42 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_2.pb,sha256=4EcXbQUeqluX6Taji-9zMhQCwDm1QZdb3FXNmAuSAx0,34 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/model.onnx,sha256=kq4EG6GOwMXdzGmK0_Cw1AJeLP3Bx6ZactogJKmm2vo,212 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/model.onnx,sha256=gHiamqUc_ThuSGkUE2fiCMc8DCfclBbFO12AYU7UKKM,232 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_equal_parts_2d/model.onnx,sha256=cTCvN8fr_EQTkk1XgE2uYKCh1dxQLqFdGxc6IFkGeMo,202 +onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/input_0.pb,sha256=wcsj07dMPwy_TgfeqO_LZn4LBOusGc6f2Toix53A0ks,63 +onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_0.pb,sha256=SRqisx8PBlmhEqo0lYWXWQ2JyCutfOy1SP3mfHqpUKA,42 +onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_1.pb,sha256=4oCTYs32ZK3rT5vrT3FIds25XjGHsz8MwlbQkr_sEZY,42 +onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/model.onnx,sha256=3Yo0dSUSNjV5uBK52USIf0OPPIeWkkVsryj52ISwMPk,190 +onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/input_0.pb,sha256=wcsj07dMPwy_TgfeqO_LZn4LBOusGc6f2Toix53A0ks,63 +onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_0.pb,sha256=SRqisx8PBlmhEqo0lYWXWQ2JyCutfOy1SP3mfHqpUKA,42 +onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_1.pb,sha256=4oCTYs32ZK3rT5vrT3FIds25XjGHsz8MwlbQkr_sEZY,42 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/model.onnx,sha256=jzvzdKnSNBTAOb6TiEs_N-f-g_tn-MALqiyObWJa-yI,209 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/model.onnx,sha256=TyUulY-Fid3BZkoAjctVoKT86f0zWauE3Yu-cMhNY5o,229 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_to_sequence_1/model.onnx,sha256=U1-1lWAzSa030XRfvGsS3HNdkGDhgoOYzj9ldZ5Yybg,159 +onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_0.pb,sha256=hohal__2jZZ7sW8FBCBj6k5KwzGvWUrrFo7_dmF8Zrk,86 +onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_1.pb,sha256=rRPJw_MP4GzZF9UqyUHod5oZNTZDCYD4LJ4iubKW3KY,19 +onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/output_0.pb,sha256=fV41UEmrLEzyFUfJvb60DaR7S_hdmzhe23IXBLiBtC0,109 +onnx/backend/test/data/node/test_split_to_sequence_2/model.onnx,sha256=nVSy2z05tdJtC1jdvsjUEXfTt-1yQAWz3MrlMhuYK5c,163 +onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_0.pb,sha256=hohal__2jZZ7sW8FBCBj6k5KwzGvWUrrFo7_dmF8Zrk,86 +onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_1.pb,sha256=Z3UXDkJvBF4Hf1WnsQpa7ifhVWCdbGzMyb-BGdfxSfQ,29 +onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/output_0.pb,sha256=-QRNSvDp1Qn7lrM4ldwcAd5Crm7M6kfAs4DAU-muPJw,99 +onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/model.onnx,sha256=uh850_OBl_ZGds4N_C8WlDYdzy_E7NWacTSC2IO8dEI,161 +onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/input_0.pb,sha256=hohal__2jZZ7sW8FBCBj6k5KwzGvWUrrFo7_dmF8Zrk,86 +onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/output_0.pb,sha256=08IDo97JLVHNcylBdWoEiBpsK_sehJED72UcixmIZic,127 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/model.onnx,sha256=NoEZGVziDX2zoDtLOYRVuCTkdghM66-MlXVZWg6MGPg,209 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_1.pb,sha256=2Q8n5Jfg3-M-8gGJ4RH4-w6ZMopbqb-TkncpX-x_ZYg,32 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/model.onnx,sha256=uAI7cQQ5yrWC4lV0L5RRIC9JgXCvkV80WyJ0EdzMTVk,209 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_1.pb,sha256=2Q8n5Jfg3-M-8gGJ4RH4-w6ZMopbqb-TkncpX-x_ZYg,32 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/model.onnx,sha256=D-cYrAkJDR1UeR3zk5_ylK5WFx_WNOsJSS7_p44iOnk,221 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_0.pb,sha256=wcsj07dMPwy_TgfeqO_LZn4LBOusGc6f2Toix53A0ks,63 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_0.pb,sha256=9pl6VjjiFVClVzpC4AhEkRQIBd1alqZxXzThCmDLhKk,34 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_1.pb,sha256=_3ZLeX0bUaRISuadzex91jHCMjQPZefG5c9_ZZj4zvs,50 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/model.onnx,sha256=tJv_THJn53mN0BM-XB4V5dxm3iQNPBLV2lUTneO6xjI,221 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_0.pb,sha256=wcsj07dMPwy_TgfeqO_LZn4LBOusGc6f2Toix53A0ks,63 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_0.pb,sha256=9pl6VjjiFVClVzpC4AhEkRQIBd1alqZxXzThCmDLhKk,34 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_1.pb,sha256=_3ZLeX0bUaRISuadzex91jHCMjQPZefG5c9_ZZj4zvs,50 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/model.onnx,sha256=lW6SmYm30zfpsf_Rb_-6pX8weVSZdb5ZSl4JPbcfRvM,206 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_1.pb,sha256=2Q8n5Jfg3-M-8gGJ4RH4-w6ZMopbqb-TkncpX-x_ZYg,32 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/model.onnx,sha256=sTCSMCCXeFnUb6_1YMMPlvpkoMJJlliDBbSk1EfcSO0,206 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_1.pb,sha256=2Q8n5Jfg3-M-8gGJ4RH4-w6ZMopbqb-TkncpX-x_ZYg,32 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/model.onnx,sha256=iQn5gh1rElU3EDnVlW3xQKsWeTKUIPlexQG_eBrT1kw,229 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_0.pb,sha256=PNWgucFe5Tf1mGk98Ir_bEaOELmES3FAPZpKbskJO6M,13 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_1.pb,sha256=o-O8kmlClSSIjeKhfy88IVCUriMV6Wsi10eqicjIVHA,37 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_0.pb,sha256=4cN5_4IAh3yvrFKoOn7wqzTUZaeUlMF0Y2JzSlAev8U,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_1.pb,sha256=SgOFp0XrEtOKXGCO2yCwjM-mmrnGiG43OJeVKPVQSCI,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_2.pb,sha256=Gve-t8o-LviHnt0QBVUYwp7TJLd1j_sJZbadWj0t-go,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/model.onnx,sha256=o1DgL2iQ7ybNT8OokLTzkpyEUCcdiC0XnhnGiLqcOPk,229 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_0.pb,sha256=PNWgucFe5Tf1mGk98Ir_bEaOELmES3FAPZpKbskJO6M,13 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_1.pb,sha256=o-O8kmlClSSIjeKhfy88IVCUriMV6Wsi10eqicjIVHA,37 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_0.pb,sha256=4cN5_4IAh3yvrFKoOn7wqzTUZaeUlMF0Y2JzSlAev8U,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_1.pb,sha256=SgOFp0XrEtOKXGCO2yCwjM-mmrnGiG43OJeVKPVQSCI,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_2.pb,sha256=Gve-t8o-LviHnt0QBVUYwp7TJLd1j_sJZbadWj0t-go,16 +onnx/backend/test/data/node/test_sqrt/model.onnx,sha256=h4jfkNJWaUfcoSQGcqHwdY15o5OLRjVoCc-1b7dVwS0,99 +onnx/backend/test/data/node/test_sqrt/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_sqrt/test_data_set_0/output_0.pb,sha256=As-Nz2MWaj1kh9fTPsNyeNwMUow9_A13pahFbHZVk-0,254 +onnx/backend/test/data/node/test_sqrt_example/model.onnx,sha256=7uQM7y_IGof70AbsYdJdLDmTWw0_7WDKZtPj4N_q8eI,91 +onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/input_0.pb,sha256=Nrf34J1rWfH_mvaflbCOOw7nNwxeOO-haem99-KYESk,21 +onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/output_0.pb,sha256=KW9J7uTWmyfHYqYwYwZyv64IeAl6_iDrPha7DI-bhcU,21 +onnx/backend/test/data/node/test_squeeze/model.onnx,sha256=ksEURd-pE1EXv-Ci3Q-8uBzEZMdyYqPXv88SBHRKA_s,135 +onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_0.pb,sha256=hFcc65NzF2jKbEvO_e8J60kUbf0yiM7kqrgc4fH_zcw,256 +onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_1.pb,sha256=3ZIfNI5JADuUCnYUjr-VBN77qOrY7__k-MJ2cszFazI,20 +onnx/backend/test/data/node/test_squeeze/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_squeeze_negative_axes/model.onnx,sha256=ggvaINpxLZXPPe1sFuQK2rblhval7BZ8Pe7H9Nucmzs,149 +onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_0.pb,sha256=aB6aWPKjpjxoogC4OWA9AtqtA_neDA-penHUJfcxTCQ,75 +onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/output_0.pb,sha256=Nw5Lbu_KXM7uUzsNQJyxkH74rempglPVlAcohSxDoLE,73 +onnx/backend/test/data/node/test_stft/model.onnx,sha256=tsMRYdduSuEfzNmFvwSvdo4n6XHrwMgNfY1Hs93Kj8w,199 +onnx/backend/test/data/node/test_stft/test_data_set_0/input_0.pb,sha256=8AO0tqkf6LPSAI3rAdEMf4BpkfPwW4XMIcz9Mc_CFO4,532 +onnx/backend/test/data/node/test_stft/test_data_set_0/input_1.pb,sha256=QWZmtDzOdzs5-9Q_NiVq1dbgf4ogy53xglu2F4-18dg,24 +onnx/backend/test/data/node/test_stft/test_data_set_0/input_2.pb,sha256=U21-PeJEIhgtSvlY30evxCn0p-LdDUIhR1irDFEoFmQ,26 +onnx/backend/test/data/node/test_stft/test_data_set_0/output_0.pb,sha256=IACcg3anVjOxSt-5wInGQEIOFNYVEJfPZP9qEIJfEZ8,1101 +onnx/backend/test/data/node/test_stft_with_window/model.onnx,sha256=7Ix1wx_t7d6ZphvQEq7CqQjtXzzPcLO0xR8nGwNugWo,201 +onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_0.pb,sha256=8AO0tqkf6LPSAI3rAdEMf4BpkfPwW4XMIcz9Mc_CFO4,532 +onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_1.pb,sha256=QWZmtDzOdzs5-9Q_NiVq1dbgf4ogy53xglu2F4-18dg,24 +onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_2.pb,sha256=aUODX4Nh96n2iuhAHz50tDbFL1QE4u1sbKa4IqeKuRY,78 +onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/output_0.pb,sha256=OO5tE-S-bivPAEUFfpAEBRdpodvuBUwxweQIFMSIjPU,1101 +onnx/backend/test/data/node/test_string_concat/model.onnx,sha256=V4HVX0Apd0nG72Xf_ocY_e_cqH7n--O1h0l1C-lImfU,130 +onnx/backend/test/data/node/test_string_concat/test_data_set_0/input_0.pb,sha256=WAb6sWZFYKW1LIru7MSRLhhwzazGUBtNJGtEkhZZ2FU,17 +onnx/backend/test/data/node/test_string_concat/test_data_set_0/input_1.pb,sha256=C4UHcDF6qLIvX8lPPvnN1Cq1IJhj_X1S1Y_Oyh1Ollw,19 +onnx/backend/test/data/node/test_string_concat/test_data_set_0/output_0.pb,sha256=vtiaZwPMnnzcSkkFGBhpOoIFeLPJvPKSY-iKQcq0Cr8,30 +onnx/backend/test/data/node/test_string_concat_broadcasting/model.onnx,sha256=pIw0kVroIMJJPDux74zZptIqxRZZVBpgo-nHanU_TPU,143 +onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/input_0.pb,sha256=g8umE9mK4nbafqeQqJPDNus3Mo9GKl5HzHLEV5CCKtc,24 +onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/input_1.pb,sha256=61MXBNeu3kgkjUDe06Bj72XsTRXS15buo8aeEzpqVA0,10 +onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/output_0.pb,sha256=Q2Z8aHvRjq90Zxdee7q5C4y9FvozMzCmOjJGWFXqb5E,32 +onnx/backend/test/data/node/test_string_concat_empty_string/model.onnx,sha256=axrDOcNhjUfIlP3MCEpQJxGUx-5x4bPcku_DL_6QKro,143 +onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/input_0.pb,sha256=4bX3C0zVcBmpqqlnCwjiLvsLiAeGTQRh3b1vnEsLj1Y,14 +onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/input_1.pb,sha256=NNqhNABxE4ldnXiKr5xqCu0DlAF3PKrb_8wvFRw9ffM,14 +onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/output_0.pb,sha256=HzMKwLLMEbUHqVquy5UKq89wbBGtOGZuw_pvjU7xBZ0,22 +onnx/backend/test/data/node/test_string_concat_utf8/model.onnx,sha256=q91FvEO8NduK8DhbBQ2ucWQRkLlsnIA6T40JMJ2hvDs,135 +onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/input_0.pb,sha256=32q4itbhVcHrg4jOFXv7YUevdgA4X2m1jCjxBAUKETI,17 +onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/input_1.pb,sha256=4xLYBwA5WD6V1tuwDJGoIRikUycy9TPoV5CYMTOAxPw,17 +onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/output_0.pb,sha256=OjvOO2BFyHWQn9fDXfLOQc4tnl5fC09D59QjxZ5zkcQ,28 +onnx/backend/test/data/node/test_string_concat_zero_dimensional/model.onnx,sha256=RWMbf8hdRMOGC7IjuBZ3ZUVjgtwV-6IfFQtmllUHWfg,135 +onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/input_0.pb,sha256=lC7SLuieEtx5ZKUfw9AC88_BTYMdctctD2JpZE1DLwY,10 +onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/input_1.pb,sha256=rCuW4N8-s8CeOag00vK3OQB2rSz9QguGP_b7a9be5v0,8 +onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/output_0.pb,sha256=2YAt0AaY7vuMYckXy79wIx1jOemGjEF84gQNxfCMYRw,16 +onnx/backend/test/data/node/test_string_split_basic/model.onnx,sha256=trlfotzvOj2dbTRLeIX3CBB_dQZ1x6dqbWOWnmf9t90,176 +onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/input_0.pb,sha256=piuT_LVlAUIMTWxojXsT_Iegr0UhW-nQZpBMCvcuzQM,25 +onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/output_0.pb,sha256=eSxG7MXxNHAhhYp6qbv7zjuoDMqhqy2Aqn3PYViNaXw,38 +onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/output_1.pb,sha256=tF5640dkxKgR-Mu-YhKv23-Dl-2shEt0mc3lwc_S068,30 +onnx/backend/test/data/node/test_string_split_consecutive_delimiters/model.onnx,sha256=XBLjqbffWXpSYMvyB5qJzo_WhbCaWMXEGK51r9DEdXw,193 +onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/input_0.pb,sha256=tQoYwhGu_kDGW2phfxV5xYWlsY9cjNw8GE-GDhVNjHU,29 +onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/output_0.pb,sha256=Gg8LH7Jg30rGSIH6Ajz793OMcHCAfpd5J8tc7y0Grkc,50 +onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/output_1.pb,sha256=HZrraho2OjK-YoIRraGoy3KzUH-5rB5Vxdg07GYC5Z0,30 +onnx/backend/test/data/node/test_string_split_empty_string_delimiter/model.onnx,sha256=Cz40MTTA_DE27jFTQO-MiaVZ3IRW5siOwnvwHO9z5Y0,192 +onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/input_0.pb,sha256=Lkk7Xliu4YQBMqmCNfiGw3e9NFq8dZPi5XuSK2HpB8M,60 +onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/output_0.pb,sha256=TlFjPdmg9QYAw87BGSTFgCxZ56k9y0jzst3jxqwq_Hs,69 +onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/output_1.pb,sha256=RKyl62yqTMrGNj1giVZZQoUAxGvRJ3UV35inlIw0Wwg,38 +onnx/backend/test/data/node/test_string_split_empty_tensor/model.onnx,sha256=ZkpBEwpbKXTJaMH8jpaQ4-PCicjHOwYpPFaZS4cDoho,162 +onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/input_0.pb,sha256=0vt_8lV5eLAUk7cNBRWVeZfQGWCKVZaoTRAsYoNVB8c,7 +onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/output_0.pb,sha256=rinTKTofPPAwoN5DGMisAVXS3kv88t6-SA-YwOmuTgk,18 +onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/output_1.pb,sha256=NJba867FCwoLhvj61B8qq1aF_0mhOxmm-HukkWIILY4,14 +onnx/backend/test/data/node/test_string_split_maxsplit/model.onnx,sha256=6tq06jJuJe-3W5da3INCxxR9RPw-VH9AAKoI1lt9RrU,189 +onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/input_0.pb,sha256=QuOpp74o_63oQzR3w5zvsGdSrZTZHaOSM_kNmCE5SaI,61 +onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/output_0.pb,sha256=-7Su4t0TNbvtTiix3ZU2WkBNgB0c-CMKVktl02CWEkk,83 +onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/output_1.pb,sha256=wFu0Vt3H3291L7GxgukDzFzNXDdTj1kqzQ-cmjfV-P0,48 +onnx/backend/test/data/node/test_string_split_no_delimiter/model.onnx,sha256=mF5gr4DOc9B2MnfXRKeyJgT6sVhaNmxbuxEWh-jxfBQ,164 +onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/input_0.pb,sha256=Lkk7Xliu4YQBMqmCNfiGw3e9NFq8dZPi5XuSK2HpB8M,60 +onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/output_0.pb,sha256=TlFjPdmg9QYAw87BGSTFgCxZ56k9y0jzst3jxqwq_Hs,69 +onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/output_1.pb,sha256=RKyl62yqTMrGNj1giVZZQoUAxGvRJ3UV35inlIw0Wwg,38 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/model.onnx,sha256=8WTCxTE83fSRwhNrP-Qh__Qmc-PmIIExxvbdUY4uyoQ,222 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/output_0.pb,sha256=_-mGRZ7G9I9iAx2P9lMk3aHUawP2XKjO9hn2fpR6tpY,37 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/model.onnx,sha256=93DFSw1HvmrQmyGjSG4nm8Dck9Ucc3cf63YZN_NpC1M,197 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb,sha256=_-mGRZ7G9I9iAx2P9lMk3aHUawP2XKjO9hn2fpR6tpY,37 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/model.onnx,sha256=jaCqkB5G5s9lkylgpZSBESwA8IeKqqtEqPSOsC47w-o,222 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/output_0.pb,sha256=7Zk-IeCaqHCfs5Z1zqHp5ERKMABu8eMRVVYNTMLdFc4,37 +onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/model.onnx,sha256=UX3g4dMXYOc0tuakv3AsxS4QxTTRPeWmb9Khcidb7rQ,214 +onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/input_0.pb,sha256=XGok6pzumeWYmW61YcE2gO49FZP4HhO5L7VQiaofooQ,23 +onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/output_0.pb,sha256=fve41mqTI11I7kUof7Bey6Rtk7Sv23j8xV9xaJLPzQ0,9 +onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/model.onnx,sha256=GHPpZvp0i0FgVto26sff1Ics_yUdMEKiSC-Adv9Q3UA,209 +onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb,sha256=5_crR6dG0l6PE3Zf0m0C1WePv2dsKuUUSeSBHD4-fx8,65 +onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb,sha256=etP-R5bCcemRt-RrzQK7MPjXOQwqbEBeZCcYma1Jb7M,49 +onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/model.onnx,sha256=CxFs65zLw1qHXcsN6vxSznvl3RFdX2mzbTO-WQBm0UY,156 +onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/input_0.pb,sha256=uBHq4M-aleAVs_ZnyQty-Yz85ya7wK6Dp7RjXk0bUZw,24 +onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/output_0.pb,sha256=NhjGWjPVxmkR0f35ghfx6YQm3Is2Eue9LWCC-NaQqQY,24 +onnx/backend/test/data/node/test_sub/model.onnx,sha256=mP10ldWkDDKH8APo3PpHCAEwuvxrP5mwXhG9tfEPvVM,125 +onnx/backend/test/data/node/test_sub/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sub/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_sub/test_data_set_0/output_0.pb,sha256=8dGJKtTismvzTYKNniWX7nI7kGv6E-yTz7tnd9fXnK4,254 +onnx/backend/test/data/node/test_sub_bcast/model.onnx,sha256=4wE4E0xFCLz9T8Z6v19gh5g9Q34MR-hWv5qLgNAbORs,123 +onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/output_0.pb,sha256=LyA5dyUqm2I4X1kd6ky4dvMue4RkuYrzpg9F7suqdhs,254 +onnx/backend/test/data/node/test_sub_example/model.onnx,sha256=0qCw4c6DH-9qPZRZFBEhJXzz0cuRYN_AA_kgjg_cB1Q,109 +onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_1.pb,sha256=ldaXLvrKYcVHRK_B5teZ_Wc4K33RQimHHQ1UI9lc1r4,21 +onnx/backend/test/data/node/test_sub_example/test_data_set_0/output_0.pb,sha256=PE0UGZkx639vsMtw-TNum1iHVl0LeudCk4ehTOso4a0,21 +onnx/backend/test/data/node/test_sub_int16/model.onnx,sha256=dt5GIDXT4LzHgTISHlM-_VuMEvXG3EzHNDuTisvGLfA,131 +onnx/backend/test/data/node/test_sub_int16/test_data_set_0/input_0.pb,sha256=Nbzd3HKgos8giskPfpb0x06oga3JrfZDxvg9cataorA,133 +onnx/backend/test/data/node/test_sub_int16/test_data_set_0/input_1.pb,sha256=bYXbfWEldc-4ToupVOx8dbNxdUlFqQvd2h-yfbg1Ue8,133 +onnx/backend/test/data/node/test_sub_int16/test_data_set_0/output_0.pb,sha256=KFMR9Ji102QpG4ZdAfxfWNOPiG4sAqFXsTzR1gfmkfE,133 +onnx/backend/test/data/node/test_sub_int8/model.onnx,sha256=xkA-jz4fV8kNbrvgYpT2pZg8v2dyXzFIHCTXy_9Bgyc,130 +onnx/backend/test/data/node/test_sub_int8/test_data_set_0/input_0.pb,sha256=m2_zn0SgRcwmUJDmJvszAXxt6sHldAq5c73PB8-3EXE,73 +onnx/backend/test/data/node/test_sub_int8/test_data_set_0/input_1.pb,sha256=_woLufMkN-rXPGkeJuppUW2Z5kTi6A2CTPNqcD3WV6Y,73 +onnx/backend/test/data/node/test_sub_int8/test_data_set_0/output_0.pb,sha256=pfYijHQVzbelGXHAvhdjpZyjm9W82Om-0bxi8FFM2-U,73 +onnx/backend/test/data/node/test_sub_uint16/model.onnx,sha256=Eqo168kWLcOmO-utKZjCWt56WVAZVoSdqYMLTi6yxrs,132 +onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/input_0.pb,sha256=efQhQ0uvWY1qlBs1edDitiWRZMCsUyUOmImmKJMrrq4,133 +onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/input_1.pb,sha256=J0VFhNRjx9LJYzqk99RPDPIg8KsuM0ftFVX9ranCBKM,133 +onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/output_0.pb,sha256=KjBRh58KH553fiu80R4k7EFnqDUuY589SNLenarDL0o,133 +onnx/backend/test/data/node/test_sub_uint32/model.onnx,sha256=Pu-r8neEy4k4ilW0Id9FZmxzJ-k5sg4RXwPSLWEfAx0,132 +onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/input_0.pb,sha256=iZQmmwzBtsG936xlepGzms_2lg6B3SaGJcBSjSAzrIY,254 +onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/input_1.pb,sha256=CBYECoArNIspy3Zv7sUVzoqrs4sVATs_fRp02y_jwNQ,254 +onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/output_0.pb,sha256=Q07bwMa0vy6m6Y8avnU7CyP2229-nOAqYiqDvfwlV_I,254 +onnx/backend/test/data/node/test_sub_uint64/model.onnx,sha256=K74Ir261x6mk4TC6n69Fv1WH6b64hJUzv9_plxOqL_Q,132 +onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/input_0.pb,sha256=zsuXsRuoQQWV7FyozneiGMQRkrCDoMvHbcBSrOMWhxI,494 +onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/input_1.pb,sha256=PW93f4xtIB2InNfJ2n1-LvJVh1BtJHpny0ZrA5Pm-5M,494 +onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/output_0.pb,sha256=3BMWCVNCJqeAfVPEzDGdsBYDxaRRYNSwWloaSgOynfg,494 +onnx/backend/test/data/node/test_sub_uint8/model.onnx,sha256=dOOLhNUqQJJzBYvl2d_gr0tELW8JumtINUnPeTHZ5hM,131 +onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_0.pb,sha256=PQ9gxBkYmukWvrg1_JnTSrOL25_KDlwFcy0OJRLcqRQ,73 +onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_1.pb,sha256=Tw2eYqucv609tkJbv2BJTkwUxDwp3kyBQfqcgCjljjc,73 +onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/output_0.pb,sha256=XvYotUU_QiEKety_EgvQZebrr0mt6PudXabbLa7MigE,73 +onnx/backend/test/data/node/test_sum_example/model.onnx,sha256=XZP8TSc2z90MlswCEnr5H06sUKLF0UvocBc-aNWaoqk,170 +onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_1.pb,sha256=CT8EqMoWnZgfvIbZCTZCcy5yi-scc6HUEY-s5dz8uC4,26 +onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_2.pb,sha256=_PLxlJ7xl9XIGa6nbKkonHq25eO5mYsALw5JQS7zyx8,26 +onnx/backend/test/data/node/test_sum_example/test_data_set_0/output_0.pb,sha256=uwkdb0lH_dEBq1A7Tmw4xNdVFOnbXYnaLhqJPa70el8,26 +onnx/backend/test/data/node/test_sum_one_input/model.onnx,sha256=6UQdw-WAFYgRrvWemfXV-9CzuTjQfgyYujsTaGUVV4g,111 +onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/output_0.pb,sha256=ZKhVafwrQna2mYQVSKmI2eivwdOVRllNuFJ0a3S4awM,26 +onnx/backend/test/data/node/test_sum_two_inputs/model.onnx,sha256=N8dWqhy-TnLXUw9HSex51GW0uGtetk3z_AiUh3gMZ2w,142 +onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_1.pb,sha256=CT8EqMoWnZgfvIbZCTZCcy5yi-scc6HUEY-s5dz8uC4,26 +onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/output_0.pb,sha256=TY8-bJ08UEwSu_EVLVl6Bwb7549mVnCWsDUHC5XHv88,26 +onnx/backend/test/data/node/test_swish/model.onnx,sha256=V_UE89Tz_lQvzfltEUgKFg3c-4VgU4pp_PgeGDoeT4E,102 +onnx/backend/test/data/node/test_swish/test_data_set_0/input_0.pb,sha256=FE9jwojB8Wqx5WRBQnaQqJMEsL78yqGWJNXCMumhCWg,21 +onnx/backend/test/data/node/test_swish/test_data_set_0/output_0.pb,sha256=NVri4mrbcz1YcuRgrRIXt-5N0QdM1W7cnbbL1JokhO4,21 +onnx/backend/test/data/node/test_swish_expanded/model.onnx,sha256=v3HqvtsWDmnfiNN-FdrlBDEprFV43pVZ-4QjeRVpVtQ,548 +onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/input_0.pb,sha256=FE9jwojB8Wqx5WRBQnaQqJMEsL78yqGWJNXCMumhCWg,21 +onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/output_0.pb,sha256=NVri4mrbcz1YcuRgrRIXt-5N0QdM1W7cnbbL1JokhO4,21 +onnx/backend/test/data/node/test_tan/model.onnx,sha256=D7e5ePaIjIvIn-cc0G4uoCxkekrFEMa7MXwxFXOjfoA,97 +onnx/backend/test/data/node/test_tan/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_tan/test_data_set_0/output_0.pb,sha256=WD2kasDAEGtoHDYoy37q3vXYt3_gFrugnEMp7rWQXrs,254 +onnx/backend/test/data/node/test_tan_example/model.onnx,sha256=NXlt7A7KqkIqe1Co-fMDDyRPiL7T-ygJRwkE7EU4bHc,89 +onnx/backend/test/data/node/test_tan_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_tan_example/test_data_set_0/output_0.pb,sha256=fqcp5u1o4BVyNsOREf4iXsbMXZziCecBb7Q7w1dF_70,21 +onnx/backend/test/data/node/test_tanh/model.onnx,sha256=U3A5tfcs_Hp17L6AxqD4qHr26dvWD_WZ4Lixxk8hGlg,99 +onnx/backend/test/data/node/test_tanh/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_tanh/test_data_set_0/output_0.pb,sha256=9epV2ujx5MyrnOrUIjmF5O9si_CqNGqtoyDQ6aWIGFg,254 +onnx/backend/test/data/node/test_tanh_example/model.onnx,sha256=AoBuuazpOgUw3IGATd5Au8wqhcnxvtw5xMRcno4TH34,91 +onnx/backend/test/data/node/test_tanh_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_tanh_example/test_data_set_0/output_0.pb,sha256=nFD1raZkukttNDNzXe2Qh0UKEk9cX0Ul4lLASfmYj9U,21 +onnx/backend/test/data/node/test_tensorscatter/model.onnx,sha256=W8-7pWfx1SBgJKPAFzO6-KRSN9NQ39dtILuCpaY8zFI,273 +onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_0.pb,sha256=kKMdewG7l8qp5P8bb263XlXzdexAVKnSiwSgr9D70kU,185 +onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_1.pb,sha256=HMxkUcyEVHuUHddxNuC-IO-FBnFV-6wDa1h2WyZmD70,60 +onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_2.pb,sha256=pnXDjVpg1DydhL63E9fwfv1FPqRNiHynvifkYyZWYos,37 +onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/output_0.pb,sha256=rtZbN7n5tr60MlWBmoUMd7JS-I1QGMW6nHflR6JTroA,188 +onnx/backend/test/data/node/test_tensorscatter_3d/model.onnx,sha256=r97dUpZAb4zUkKwCqxk3lnX3uOQ_5i3-yFTDpquH44E,245 +onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_0.pb,sha256=bcL218H6Yj8XSwTm1UaaT2wwRlqF1XOX_bemNXqII_U,263 +onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_1.pb,sha256=znDvZnQKrsfao9m3h9f34eDA2BlR1mBXQ4qMNU9-mDc,138 +onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_2.pb,sha256=2nNcDIGOhC7jXm8TmnmWOD0J-T8O6YwONyi5m2e8wDI,45 +onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/output_0.pb,sha256=l1IwpIHAlnAQldzPGGzp_SsNeNYR2bsIGZSDuxXajOM,266 +onnx/backend/test/data/node/test_tensorscatter_circular/model.onnx,sha256=9Zv_2hiVhdVbyyQpgMeq0-lPr4WG7gHazOxKwp41Euw,284 +onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_0.pb,sha256=kKMdewG7l8qp5P8bb263XlXzdexAVKnSiwSgr9D70kU,185 +onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_1.pb,sha256=3yUyj7W2nXzufdvpPsChYFH3AAjOui7AXN6klpKYxVk,100 +onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_2.pb,sha256=7x-NHtLKyG9id4X5VPtcUCp5yLbS69gL7gU5XdbTHQU,37 +onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/output_0.pb,sha256=dJVRsK1nkBTdIF_RTN4RZh_0bK12btA_zt_wSZErCCc,188 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/model.onnx,sha256=-EniRrPntw0dzQmhYCut6sPuBkfQU1xkIqQQLLoiTiw,323 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/input_0.pb,sha256=RuSeM5AAJoMD0_LUG3RLk0WKe_Yu3njy5AIvlpXBEGw,59 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/output_0.pb,sha256=5IdNsCA9je2XbErSYUmWdkfPsfxkwrUf7op6GaqXqf8,67 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/model.onnx,sha256=pS_36SRouNVGZo5He-ITKOBEKYJWADwNET22dbyuVI8,323 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/input_0.pb,sha256=RuSeM5AAJoMD0_LUG3RLk0WKe_Yu3njy5AIvlpXBEGw,59 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/output_0.pb,sha256=UD8F8mfp4Z-P7z4_poshzkhI1ONkSs8RWiioBZ6wXSs,67 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/model.onnx,sha256=hwFqXbWQ3m9HhGM1RdqQIWwT-0ShxF1yZbX8begEDIc,325 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/input_0.pb,sha256=RuSeM5AAJoMD0_LUG3RLk0WKe_Yu3njy5AIvlpXBEGw,59 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/output_0.pb,sha256=lZon0vYsJAmO9YgPUKEXr6zIAZvJOXYSLvkymMrzx_Y,67 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/model.onnx,sha256=GS8cEAj07bUmc0iwrHrR3BXlXmzJkKZG6iNwv9yORMo,310 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/input_0.pb,sha256=YCc_Bptl6ovGeLNS8nNKpq9kZn61r24klmgDmte_FF8,57 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/output_0.pb,sha256=OHQudUdGevZkYWHLjqghPTQjpE_rzikFq-mnC3u2Hkg,37 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/model.onnx,sha256=A2zNW-p1Kd0gFy1nlNxddLRwPfi25aBcGBN1s3tZgho,298 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/input_0.pb,sha256=YCc_Bptl6ovGeLNS8nNKpq9kZn61r24klmgDmte_FF8,57 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/output_0.pb,sha256=HqYz4t-IV0NRYVNdxt6tHgAr6cXkXZb9bhxw5eRZSG0,21 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/model.onnx,sha256=9BzVp8R0xgTHrWa6iEpnJE71YDoMSeA2j-bwkNZB5tU,309 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/input_0.pb,sha256=YCc_Bptl6ovGeLNS8nNKpq9kZn61r24klmgDmte_FF8,57 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/output_0.pb,sha256=bWYlhOyhr89Gu8Egsb-EZCem3F2ITmQ2T-pAAMoBkSM,37 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/model.onnx,sha256=7pVbMq_QNlnT5GEO49GAtvrWW6sUFq-dbT3m0cYWSdo,311 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/input_0.pb,sha256=YCc_Bptl6ovGeLNS8nNKpq9kZn61r24klmgDmte_FF8,57 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/output_0.pb,sha256=fWBlu9B5oyr0J1oSpwScOYEOm4wpBfIXOGcZDLMSEtc,37 +onnx/backend/test/data/node/test_thresholdedrelu/model.onnx,sha256=ARJRs-07zsykw6-eSTdrrBMH_mT3jJtI7P1wu2exhLs,138 +onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/output_0.pb,sha256=EYPDY0T-gVBpBycVsSv96EYC8I5OQKmOXlUd0PlqqTo,254 +onnx/backend/test/data/node/test_thresholdedrelu_default/model.onnx,sha256=eKL4dEvfWO2ifOV9wNATGg8anQYrV8x0akPzPAbxAgs,129 +onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/output_0.pb,sha256=R8JHO3yOt_f-HSe9W_6opD1vEVd0J_9IyfYvUqvYHb8,254 +onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/model.onnx,sha256=Xjy0FUJJHKbF_mLVMfXrmoLzkCIs5SiRNXSJ0DQqdpw,993 +onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/output_0.pb,sha256=R8JHO3yOt_f-HSe9W_6opD1vEVd0J_9IyfYvUqvYHb8,254 +onnx/backend/test/data/node/test_thresholdedrelu_example/model.onnx,sha256=WxEGcPBlBGJBMP_IWm8ccCJ3RZCvTMold8fuDunBwp8,130 +onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/input_0.pb,sha256=GyqQxuM6edhbQcLuvJ7Ff2l8cqNvuhOCWT6tq6GrCxQ,29 +onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/output_0.pb,sha256=56tfAjuqWM64ZQOZoGZe2HownMu6FhctDhrCWEX-U3c,29 +onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/model.onnx,sha256=dr6KzXPOEebHoFgYsZ2zIYjXMA2jz3p_M6Lk-0Ed8Uo,977 +onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=GyqQxuM6edhbQcLuvJ7Ff2l8cqNvuhOCWT6tq6GrCxQ,29 +onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=56tfAjuqWM64ZQOZoGZe2HownMu6FhctDhrCWEX-U3c,29 +onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/model.onnx,sha256=2RT0LcAGiGKRmi90hz2kxYpH3hUoMaXxSG-aM6goZOk,905 +onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/output_0.pb,sha256=EYPDY0T-gVBpBycVsSv96EYC8I5OQKmOXlUd0PlqqTo,254 +onnx/backend/test/data/node/test_tile/model.onnx,sha256=QfHZNXzmqFwu78ZWpKbrIoairQG5_T80e91VExVm5nQ,127 +onnx/backend/test/data/node/test_tile/test_data_set_0/input_0.pb,sha256=gw969Zq2ZPC3oIK5VZvEvK3ygLM6eqRhSyV89xoSWa0,496 +onnx/backend/test/data/node/test_tile/test_data_set_0/input_1.pb,sha256=3hLt-sVia_TlsVYqobdpF_RmIXzm-x9MlyzSKruqYmM,41 +onnx/backend/test/data/node/test_tile/test_data_set_0/output_0.pb,sha256=Rs-OKCKQNoROZ4obyQdCkRgsW6jV-IFq2p2uGO-rcCQ,161297 +onnx/backend/test/data/node/test_tile_precomputed/model.onnx,sha256=QXGzsgDOILyxC9mjPlMFdY7_WGynokKvLHY_-gKC5U8,123 +onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_0.pb,sha256=0phUVbSY99aYNDvbb4I7ZwTF4_oqB7I9Teh_3LZTlfk,27 +onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_1.pb,sha256=8YdPn9kXj5gTtZWZFpSg86zsyytFp2VxVrzLf29WrDM,25 +onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/output_0.pb,sha256=UhTwBP5SsiJy8mBvMpnEyfL8TWSEzsn2xB-b29BSfRc,75 +onnx/backend/test/data/node/test_top_k/model.onnx,sha256=9xoKnJ32rcYCvVhJ3piZym3yz_AuJ-gWoO85Oud-EIU,172 +onnx/backend/test/data/node/test_top_k/test_data_set_0/input_0.pb,sha256=XI00qhavYkKl_aHKei8a3IH_dsLyhI_Y57J38wFhkU0,59 +onnx/backend/test/data/node/test_top_k/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k/test_data_set_0/output_0.pb,sha256=vzxrEwUR_AoNSo5nsdkq3fMRD-TWJIdQTFnoTF5HOE8,52 +onnx/backend/test/data/node/test_top_k/test_data_set_0/output_1.pb,sha256=Lq4Jo5XkOjWTnkaaHX6oxn_k4xXtVuYESe87xYE4-JM,89 +onnx/backend/test/data/node/test_top_k_negative_axis/model.onnx,sha256=cwRDVoWcZUD5DZ_c_eftC78gv94evpUA4SI8fSSRV8c,195 +onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_0.pb,sha256=XI00qhavYkKl_aHKei8a3IH_dsLyhI_Y57J38wFhkU0,59 +onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_0.pb,sha256=vzxrEwUR_AoNSo5nsdkq3fMRD-TWJIdQTFnoTF5HOE8,52 +onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_1.pb,sha256=Lq4Jo5XkOjWTnkaaHX6oxn_k4xXtVuYESe87xYE4-JM,89 +onnx/backend/test/data/node/test_top_k_same_values/model.onnx,sha256=kpJFMTNurlHFHqN5GX0nuimt8Qd0buoRQoTAduj_HGU,172 +onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/input_0.pb,sha256=eE-L3gqErpDAhwbfZDWZ618mxe9vc3_-NOzGMd1cn5E,41 +onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/output_0.pb,sha256=KbkmpxqEJa152jI2cPIf7Suo4fpzovockEnKGiWKAIo,38 +onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/output_1.pb,sha256=68x4ari56tnfokBXDfBDelw4mDwPCBM2Jc1FFfRJ7N8,39 +onnx/backend/test/data/node/test_top_k_same_values_2d/model.onnx,sha256=kDJL4Zgt4RhBGeO2DL1O-4HRkfJdo_So2EaFDtix4Rc,187 +onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/input_0.pb,sha256=GijDRQDSJgZwuijGiWjVvVTz2RxeTzoc5htkhwDApTQ,107 +onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/output_0.pb,sha256=JWemRtldCG8_jWs2OCndda65oCvhhvTezw_Ng-AGPP4,88 +onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/output_1.pb,sha256=B0FldLqlYdgT28plwMM7by1ZXrtMHmDruTGHHoonhE4,89 +onnx/backend/test/data/node/test_top_k_same_values_largest/model.onnx,sha256=f4jAXvWx8iKHAAhq5hmzJE_Pv1cR5TEho2za5NI-GxY,180 +onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/input_0.pb,sha256=eE-L3gqErpDAhwbfZDWZ618mxe9vc3_-NOzGMd1cn5E,41 +onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/output_0.pb,sha256=KbkmpxqEJa152jI2cPIf7Suo4fpzovockEnKGiWKAIo,38 +onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/output_1.pb,sha256=68x4ari56tnfokBXDfBDelw4mDwPCBM2Jc1FFfRJ7N8,39 +onnx/backend/test/data/node/test_top_k_smallest/model.onnx,sha256=IrgJnbVt7Eyb1kAdrBBtvFYuENKHQ3HPBfUhKvS2E-g,212 +onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_0.pb,sha256=ryRK_hmxESRdBORPiEQGCBWqPscZuVkuLVdq4UiTkIk,59 +onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_0.pb,sha256=6NbpYxWiqeXH1aQ5Qsdxf5e4Thh3nDRzyF8nMxMU-v4,52 +onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_1.pb,sha256=8o2XaU6qQNbXjIpJgqXwjpFgTIBjtdHfok7ylx2w6Nc,89 +onnx/backend/test/data/node/test_top_k_uint64/model.onnx,sha256=roeJxhF2hk-IOsNoAcVML1Gd3hYfK1jwbMB0GQIookE,179 +onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/input_0.pb,sha256=A1jj45B0CxGToI1jpM6marqZiAxIXiQUk5NaMU8atfU,107 +onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/output_0.pb,sha256=1Sr-E890QfaIgGyjq5_sRrL-VcEfsRYQ4RLr9ngtaQs,88 +onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/output_1.pb,sha256=Lq4Jo5XkOjWTnkaaHX6oxn_k4xXtVuYESe87xYE4-JM,89 +onnx/backend/test/data/node/test_training_dropout/model.onnx,sha256=08MjjObwYGBJzViUP8O_gFhgysPEXmbeQs95RoWSOj4,160 +onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_1.pb,sha256=Ihb6BRVhibKnewisCvIZ4IdGYIG8RISUnIQOFl1wHSo,11 +onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout/test_data_set_0/output_0.pb,sha256=CmBjvEq_A4VxiIqoeJA9geeo6q067Zraon47UAQZysA,254 +onnx/backend/test/data/node/test_training_dropout_default/model.onnx,sha256=CxQWkz5SxpU8oCN1IB1acKki11f8D_fBj33nC8wB5jA,168 +onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_1.pb,sha256=x_s2_p7rxoVX_GfqD2NvSwHUYcx5i61p2DlsgKolOJE,11 +onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/output_0.pb,sha256=6RLLCaWhovCKRwj2lZPTEcsCXAXwpny9iHnJWVbZlqY,254 +onnx/backend/test/data/node/test_training_dropout_default_mask/model.onnx,sha256=Y0nVH9I_acw_B_NTsm2LWavRtqkgDC6oBvyU0fR6uQo,201 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_1.pb,sha256=x_s2_p7rxoVX_GfqD2NvSwHUYcx5i61p2DlsgKolOJE,11 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_0.pb,sha256=6RLLCaWhovCKRwj2lZPTEcsCXAXwpny9iHnJWVbZlqY,254 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_1.pb,sha256=U7w4KTIRqkX6TMfa8mTB9l88U4Byw-Gxr5-BTRWGzC0,73 +onnx/backend/test/data/node/test_training_dropout_mask/model.onnx,sha256=OMDUpoDgwg9Uihbk4kDhnZI5tSuPYTmbsOnE06Hyxi8,193 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_1.pb,sha256=Ihb6BRVhibKnewisCvIZ4IdGYIG8RISUnIQOFl1wHSo,11 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_0.pb,sha256=CmBjvEq_A4VxiIqoeJA9geeo6q067Zraon47UAQZysA,254 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_1.pb,sha256=rPswqfqePkmopvWjUY6xwIBzHLn8yFTlIEaC7zi_1ws,73 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/model.onnx,sha256=1350XxNnGa5huWbr_Gv1ZHNOVRpPN6RN2xUb0xhaUrc,171 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_1.pb,sha256=hZowRFBsf_dlyYrjzzS179SSCrfk16UaslAIJqe0JkA,11 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/model.onnx,sha256=ZJ2WuvFyRtsWMs__HsQvk8i9qxVRJktFwpS6V-L1oS8,204 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_1.pb,sha256=hZowRFBsf_dlyYrjzzS179SSCrfk16UaslAIJqe0JkA,11 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_1.pb,sha256=4sWzAHgaDiZSCGEr949BKLl9dNfAyqyQpzL1ccqJJ2M,73 +onnx/backend/test/data/node/test_transpose_all_permutations_0/model.onnx,sha256=wZFaXQXnGoSm0iTJfDZQcAi0tKoEwlJgl-iA4vsl5tY,170 +onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/output_0.pb,sha256=8m48HiFPwfnlF03aRhdOZsTuw4GtLKS-6Q7Kdu2CTHY,118 +onnx/backend/test/data/node/test_transpose_all_permutations_1/model.onnx,sha256=hZUmoO6fJWYKTcDSlgtKPV35CKffpSWKQT1yQsY3y4c,170 +onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/output_0.pb,sha256=KdRdeEJ8zlT8RRzybOAlbdCF6M66iCYf1ZXc1lZw7QY,118 +onnx/backend/test/data/node/test_transpose_all_permutations_2/model.onnx,sha256=HaPMdkWviHSlewcijdxOMXqqmHrdFZvzSJuNimW3dSc,170 +onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/output_0.pb,sha256=EDwdkyw_W6NnH7UTmY_FwWB6vJ2zZNEfhKTkro6t2mc,118 +onnx/backend/test/data/node/test_transpose_all_permutations_3/model.onnx,sha256=LGtNBO9lfegTA5ttzGb31W-YEOADQkTjMomxChJr8Bc,170 +onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/output_0.pb,sha256=hBbLAZf6HxZc9v80VT82V1DlS_5sknpc9ejUOibhPDs,118 +onnx/backend/test/data/node/test_transpose_all_permutations_4/model.onnx,sha256=SRjAV-QZ4UpKo1rxNmIZb3LguLPM6C7UOiQujwbZaBA,170 +onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/output_0.pb,sha256=eFo6pA8Z_W1f_lj5SuJSWG5TGGlFZaNO3jKaR7gq47o,118 +onnx/backend/test/data/node/test_transpose_all_permutations_5/model.onnx,sha256=LkcRGoaT1Tb7VldIE2EAnoaH-9Lg3jsznq_QPoNTnAk,170 +onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/output_0.pb,sha256=cHZA22uz70nv-VGa4Pz3DDZlMtCkO7A42XLP232Va5w,118 +onnx/backend/test/data/node/test_transpose_default/model.onnx,sha256=2K0P_-wVIXb4zwL9iZYMhZa8SuTI644-Qz61mOLR8PE,141 +onnx/backend/test/data/node/test_transpose_default/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_default/test_data_set_0/output_0.pb,sha256=cHZA22uz70nv-VGa4Pz3DDZlMtCkO7A42XLP232Va5w,118 +onnx/backend/test/data/node/test_tril/model.onnx,sha256=lhJDHmrNmmQmM3IE2vMEwWyxqjuE6E-lkEW1eqAnFRI,106 +onnx/backend/test/data/node/test_tril/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril/test_data_set_0/output_0.pb,sha256=0yOBOAhKCbt38Vyz7y8JwUrBoiwNlUWPKG9XTvmkyRE,172 +onnx/backend/test/data/node/test_tril_neg/model.onnx,sha256=lGWNM5bmJR0DyK5sZonj8a3CqcI9iZV8cABSDM87kaE,126 +onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_1.pb,sha256=i0ZHP5YqdC9NiwoL_Bm7HypdONtt3SVFXYuFeG3mUy4,15 +onnx/backend/test/data/node/test_tril_neg/test_data_set_0/output_0.pb,sha256=kYHROrSW_24f7h99TB3GfxE41l-6Pa-_xhnWeLyG9YE,172 +onnx/backend/test/data/node/test_tril_one_row_neg/model.onnx,sha256=yt6xj_XnWkJPKqkFDcbF8Dy6aRmVtXShqsMdd8gFF0Y,126 +onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/input_0.pb,sha256=ScwWPKBfy94Tzyt92uIxTxzOec9LWF6m_ox8cdpH3R0,133 +onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/output_0.pb,sha256=uQ0LME1uBl6FjFBG7-4pUsoQdykXVZdtHnbP4AclmWg,133 +onnx/backend/test/data/node/test_tril_out_neg/model.onnx,sha256=Pw6kQJ6Wxc_IG-6C_HZOswSAEUCLz4cgmPit3sMyTPc,130 +onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_1.pb,sha256=Tt-kDFMTEYFiH-Yfmgak7F401t7I7nrv4UpeGtdKD5M,15 +onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/output_0.pb,sha256=QfgazYHaPKrLW8AspgXsm4Kbyrfo3VZkoC7P73D11R8,172 +onnx/backend/test/data/node/test_tril_out_pos/model.onnx,sha256=z5gAacj6JzJo5-QaSZACl3WTeDFo68Cd9-yNVv1aTz8,130 +onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_1.pb,sha256=9bqFzalAARJbjjUBHRhuduhGUfbMRCaZbI2Jr8ayV7g,15 +onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/output_0.pb,sha256=3PmW_Dd84mJIfxdwLn1HgG7o8YwHhSGboTBaruGHyAQ,172 +onnx/backend/test/data/node/test_tril_pos/model.onnx,sha256=qtHANJJBn7vNMrkVc8B8nzEJObPVNtWtS0T4nFRFyIE,126 +onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_1.pb,sha256=gW2ZrFQv3ahq6TbMYWhXMbs0jzUdce0TXUK4945SMm4,15 +onnx/backend/test/data/node/test_tril_pos/test_data_set_0/output_0.pb,sha256=sstFogvuO6IXlRUwDjX2czo9TEKLz4Yv-y98cszv0so,172 +onnx/backend/test/data/node/test_tril_square/model.onnx,sha256=TXbYCWCohDH4w3nd77x_vjeOgCIFKiuxBaV2bqvCA3g,121 +onnx/backend/test/data/node/test_tril_square/test_data_set_0/input_0.pb,sha256=1lg6-XA3blxfCn0jtzXBITxdSjycH7mbLTN9GItwNHE,158 +onnx/backend/test/data/node/test_tril_square/test_data_set_0/output_0.pb,sha256=vdj5m3p8LBerTUcy8c8wUXgkKaCdstCfJyVpgzNKUog,158 +onnx/backend/test/data/node/test_tril_square_neg/model.onnx,sha256=qu1dUTCnaTWKK-fri2UpZv3Zz7j8oLpaZozxXiBpbr0,141 +onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_0.pb,sha256=1lg6-XA3blxfCn0jtzXBITxdSjycH7mbLTN9GItwNHE,158 +onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_1.pb,sha256=i0ZHP5YqdC9NiwoL_Bm7HypdONtt3SVFXYuFeG3mUy4,15 +onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/output_0.pb,sha256=RZf7iUnfN42u5ktYpTiiDwOXwdrhCQtT13GxJQZQH38,158 +onnx/backend/test/data/node/test_tril_zero/model.onnx,sha256=hnZmDv5ZOJztbmhw2IDOo1gFvL60AeMqWhl8UVjKTQw,135 +onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_0.pb,sha256=Kapx_xKdYnTZDHE0gZW2f4mFu_JoDYcW68ayR-ev2dA,13 +onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_1.pb,sha256=9bqFzalAARJbjjUBHRhuduhGUfbMRCaZbI2Jr8ayV7g,15 +onnx/backend/test/data/node/test_tril_zero/test_data_set_0/output_0.pb,sha256=y0-YZEpnT8AdgNRD6Us4QuB-FZaplytFQlXV8jEkrKc,13 +onnx/backend/test/data/node/test_triu/model.onnx,sha256=gpkyt4sDW1kzNziEz7gV68zyVAgo_57JweFnE0kJnDI,92 +onnx/backend/test/data/node/test_triu/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu/test_data_set_0/output_0.pb,sha256=-RYXmZuISX8RTZVbK_02g9AoUJ6v0GuQ4IE_4_KEBFE,172 +onnx/backend/test/data/node/test_triu_neg/model.onnx,sha256=eD2I1le73tiWp5Fg--vV_u_NXKv1sNEwOcXfl_um_rA,112 +onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_1.pb,sha256=i0ZHP5YqdC9NiwoL_Bm7HypdONtt3SVFXYuFeG3mUy4,15 +onnx/backend/test/data/node/test_triu_neg/test_data_set_0/output_0.pb,sha256=7V1XOQLF1dNocafYdMS-s2KYghNF3sRoYBRbeWR_vxs,172 +onnx/backend/test/data/node/test_triu_one_row/model.onnx,sha256=6_MwfrUOU_ZKMO0MhSE90ZuX3M--xqjNrXv1CSgHeIU,124 +onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_0.pb,sha256=ScwWPKBfy94Tzyt92uIxTxzOec9LWF6m_ox8cdpH3R0,133 +onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_1.pb,sha256=5dmgjxbBKzMl-btFlxmcAdeSrI3mggZSyGhb128Fw0c,15 +onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/output_0.pb,sha256=9bTgow1Cm656P2OpenExYLW1EomHftqLJulgaXYdf6o,133 +onnx/backend/test/data/node/test_triu_out_neg_out/model.onnx,sha256=XXpDfKfYM1Qp1XZDKqXainml-cAj2U768AmLeMnWfWU,120 +onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_1.pb,sha256=Tt-kDFMTEYFiH-Yfmgak7F401t7I7nrv4UpeGtdKD5M,15 +onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/output_0.pb,sha256=3PmW_Dd84mJIfxdwLn1HgG7o8YwHhSGboTBaruGHyAQ,172 +onnx/backend/test/data/node/test_triu_out_pos/model.onnx,sha256=uazDxppu435fjfwPfPxeEa8weRtNved_HuLgy1SpxwE,116 +onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_1.pb,sha256=9bqFzalAARJbjjUBHRhuduhGUfbMRCaZbI2Jr8ayV7g,15 +onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/output_0.pb,sha256=QfgazYHaPKrLW8AspgXsm4Kbyrfo3VZkoC7P73D11R8,172 +onnx/backend/test/data/node/test_triu_pos/model.onnx,sha256=tFHTxvcfOmNdZ7cbt8HE-a2UBj2mqMyMGE0Tb2udaEY,112 +onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_1.pb,sha256=gW2ZrFQv3ahq6TbMYWhXMbs0jzUdce0TXUK4945SMm4,15 +onnx/backend/test/data/node/test_triu_pos/test_data_set_0/output_0.pb,sha256=SLp3CwNp4vx0w13204jSX4McKeiz802CKiITnHiyldU,172 +onnx/backend/test/data/node/test_triu_square/model.onnx,sha256=RFsaV-Vew2pD0XJ9FHjbS3oYY9LIUlCVDi8Cu5ImGsA,107 +onnx/backend/test/data/node/test_triu_square/test_data_set_0/input_0.pb,sha256=1lg6-XA3blxfCn0jtzXBITxdSjycH7mbLTN9GItwNHE,158 +onnx/backend/test/data/node/test_triu_square/test_data_set_0/output_0.pb,sha256=36AMhLCF7SadJX9HRMgzRid74z5gEDPfF0pMKmZOu_A,158 +onnx/backend/test/data/node/test_triu_square_neg/model.onnx,sha256=zRGX45x3GZWKvvdWcydY3usiY8y3zqHKJ0mGaC88ifc,127 +onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_0.pb,sha256=1lg6-XA3blxfCn0jtzXBITxdSjycH7mbLTN9GItwNHE,158 +onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_1.pb,sha256=i0ZHP5YqdC9NiwoL_Bm7HypdONtt3SVFXYuFeG3mUy4,15 +onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/output_0.pb,sha256=bbzJaIibrNsk9884uaPj87_IBzuFWPmqc44QkKcbBQ4,158 +onnx/backend/test/data/node/test_triu_zero/model.onnx,sha256=iGyvccjcRHA99U1iqg8YmoSstOgVlB8MDgGfmArNLUk,113 +onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_0.pb,sha256=Q4GTabNiDzUJ2uTk3sAfLoeeFVE3N4nsJcyCSfj7r0A,11 +onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_1.pb,sha256=9bqFzalAARJbjjUBHRhuduhGUfbMRCaZbI2Jr8ayV7g,15 +onnx/backend/test/data/node/test_triu_zero/test_data_set_0/output_0.pb,sha256=Ofi3T4wcGmuiSbXYfYn0XSNmCZg-m6mMiCUYdRLjTyA,11 +onnx/backend/test/data/node/test_unique_length_1/model.onnx,sha256=VRHHPmGPSaA9KuryILDILO2aeuoNdLLSdvEsCDzdK28,222 +onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/input_0.pb,sha256=M-y-bQwMuqfTlNC-6AHjQNpAyVJOLq93fnE2R6NQsG4,17 +onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_0.pb,sha256=mRU_vgYG3rL52zW0YY08L5hNhZ-kMXpqcM-h8hCrKTY,17 +onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_1.pb,sha256=xwPsnbd9dIR-5mPgxqsFS0wvcLTzFxqFj1qzmo_dQMU,23 +onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_2.pb,sha256=1ISFq3R9orOIAaIZJJXxnLjjaziASjnzsny0H-7M4tU,31 +onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_3.pb,sha256=oWuhK8IC6YAzNqV-XrbR7TOKa6dTynZfU37e-zAvkm0,22 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/model.onnx,sha256=mI9ze_3FIMLoYnysIxv7sCLQs4gENmzvxUiQlnpEkNs,237 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/input_0.pb,sha256=Ns8OxpGU_k8PsN9mEqOHyqV6UppeCIXanwl42u0Ab1g,33 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_0.pb,sha256=LAq6nE8XXq5Mlam5kdTIVIADwEBfKtEo2fHe8-L5GHM,25 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_1.pb,sha256=Sxq63uhbT7l8GKBrtiC01yTSsQZgfHSvaaJGhCjbdws,47 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_2.pb,sha256=mgccksCXBKUz17RP65cS7NBD7n-XMa24IFiz6uIG5L8,71 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_3.pb,sha256=hPqVSpfdfcRPh5WvGmSgoojnYL_Baos0WzTXzYvnalA,46 +onnx/backend/test/data/node/test_unique_sorted_with_axis/model.onnx,sha256=eyviJg4BbaPZDQ-eC1eT_BO6nLcCG-9DJ1cqVNGCfaw,251 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/input_0.pb,sha256=-84LKk25M0JkwiVnp3fuOqet5lFGsWn9dkwOZerjeCI,47 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_0.pb,sha256=vMMWxLgUqNcKAkJLK7e4z-tIriWOQds5LQAJtgfkSmw,35 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_1.pb,sha256=xtKkdir_J2mcMJQPbbbmwXHUX-ZEs5nRyjgfBYz7-cA,31 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_2.pb,sha256=MtOqG-EXKfAEBzZbrrGh8qjnN1QcvDtmZIQxyYqi4gU,47 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_3.pb,sha256=v2ScObavRe4FpFQK5d3imkd0Sw8otdQv1znGst4Y5Oc,30 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/model.onnx,sha256=FlWgY6d_vk8x-490N2n9Qv_NCdybuq-6t0jinEr0eqQ,262 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/input_0.pb,sha256=6a9P3TPDB6QH4-3m3Gools1cGlBo_OIbWJeglabhcu0,77 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_0.pb,sha256=YzN-pRyi12eIXyALCN5eHojPdmVGuL-DMINTwLaK5WY,61 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_1.pb,sha256=BVBCngYFGHlKon1y_ZXgRTi7fN4UnWIl3BIx3Uz_0zA,39 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_2.pb,sha256=Q55BSlLZREX4SafY1xiRetTNeOjxaBk-rIXBKS_UOoM,55 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_3.pb,sha256=w9rka_9R3rrKcnipyjjE1aYp1bHAUXRAHaF6k1VFKZ8,38 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/model.onnx,sha256=BTdTVahQ20B9sj7qO7V0ORq4ctappfgvN7-dkPRuXVE,269 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/input_0.pb,sha256=pUCGtsou5GEKcbl6nLdN9pU29-_oadU6jb0lSXogOXo,47 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_0.pb,sha256=elaSiSMuIeTR5E3jLR2MmJYlSGW8Lf7kHm7XK9I21ms,35 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_1.pb,sha256=nEcWVbGWyBXKcIc0WWAAKlGfOu-ezo-7gMwo0n5jz9k,31 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_2.pb,sha256=dbkzp5DFsqzeGFufr0S2WHfnQj8ygai09efxFpfSBS8,47 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_3.pb,sha256=v2ScObavRe4FpFQK5d3imkd0Sw8otdQv1znGst4Y5Oc,30 +onnx/backend/test/data/node/test_unique_sorted_without_axis/model.onnx,sha256=u0wxMZgmvT8CQ79k7HphAOOqdPqIpSd1wc5iHeMX888,218 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/input_0.pb,sha256=Ns8OxpGU_k8PsN9mEqOHyqV6UppeCIXanwl42u0Ab1g,33 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_0.pb,sha256=1ZcKwXNjKdAcaeAtk_IWYB0fwW7DigTs9dL-8OcYehM,25 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_1.pb,sha256=Vzsgo_9q0aWXU7KrUGj_Ulkd-zmn6zGq8qHe8h5toX0,47 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_2.pb,sha256=DJYa6RfMUcag73E9JldAu99PExISkx_iQAYEGVl7arw,71 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_3.pb,sha256=FUDlaCFeY2YPucjoGxW3edfoBJyoqAVz_r5Jt9q5TWA,46 +onnx/backend/test/data/node/test_unsqueeze_axis_0/model.onnx,sha256=FXDKik6mZxFcFJt_si-x71KtMxIt8TyrmyCBvXY4h_Y,146 +onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_1.pb,sha256=3ZIfNI5JADuUCnYUjr-VBN77qOrY7__k-MJ2cszFazI,20 +onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/output_0.pb,sha256=7pBNI_l4wxYb22FSOMO0t85L0wi5LsIih7xtBBY5EtM,256 +onnx/backend/test/data/node/test_unsqueeze_axis_1/model.onnx,sha256=dosnH9CPHG9ZS57jaNkdENlJoN_-UBttZuToL0WbN54,146 +onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/output_0.pb,sha256=erjuk57H84W6c04_54gQIjRGdm6p4nVaR50I7tFpFyc,256 +onnx/backend/test/data/node/test_unsqueeze_axis_2/model.onnx,sha256=5Y9z3Ww228y9wxfF9gDg6DwGwjqrjFCXz7HuqhG6jlM,146 +onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/output_0.pb,sha256=FE6UwTuZHYy7nJYxcNYOjwbR6cpMSo5Mc13I4BxMW-o,256 +onnx/backend/test/data/node/test_unsqueeze_negative_axes/model.onnx,sha256=RcARJT6c5z2BMcm2ts2OoWXBOzkzsfqbN48eAwvBdNw,162 +onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_0.pb,sha256=aB6aWPKjpjxoogC4OWA9AtqtA_neDA-penHUJfcxTCQ,75 +onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/output_0.pb,sha256=M_rXEhjcZ9MDQd1SSpUxWFzwhQ_3dx4LQ5X6I5isi8E,77 +onnx/backend/test/data/node/test_unsqueeze_three_axes/model.onnx,sha256=j87sg9l-DeQA35uIGH5B9kAidsvHr41M7NoZmaGz79I,159 +onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_1.pb,sha256=XTLt93U00nr062yDPpKmKXnDxZAp-uRTWSE_mpGSYoI,36 +onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/output_0.pb,sha256=YspzhMTScvKa4iChfYrxn74bnYhE6oZNMMffc6VkSHM,260 +onnx/backend/test/data/node/test_unsqueeze_two_axes/model.onnx,sha256=1Gde8lkk-catGbl4GAr-4MseqdhDV54oC-9JIdKr7G4,153 +onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_1.pb,sha256=XBER72Hv68bXC29lHTLkcZZvWEOlhd5ifYnNGSA-QlA,28 +onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/output_0.pb,sha256=GfzpZxLfr85XoTxoLpWubUTBYq7QM3L5ovPrc5_sQ1U,258 +onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/model.onnx,sha256=_JcSymS5-vRjP3Qs1X-OI6BbKVSZYBqA96MRSW1ZMGE,162 +onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_1.pb,sha256=YePFsHywIWhMNzc3PugUCl7h4RavlIdU5IJGj5Jf09c,36 +onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/output_0.pb,sha256=YspzhMTScvKa4iChfYrxn74bnYhE6oZNMMffc6VkSHM,260 +onnx/backend/test/data/node/test_upsample_nearest/model.onnx,sha256=lC2-Cymd0v6CU906ju6rolvrrM6lek_-uoPdNsHQQXY,174 +onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_1.pb,sha256=3a1OyYYNdnWsgKm8R9EJ4Ja-reMSXI0q04mtA4aFGfo,30 +onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/output_0.pb,sha256=sqObjzJsZ_nVStepjZKmx3dOTVd9cGqBu3Uw2w6tYFg,111 +onnx/backend/test/data/node/test_where_example/model.onnx,sha256=4YX9T8syogoVpTQ7KiWunBIGYGSGKAOklJh9uEdjEP8,166 +onnx/backend/test/data/node/test_where_example/test_data_set_0/input_0.pb,sha256=ghkps-yp5CRRR8fRbC7fiqWG19bL00TcORlce2Dr8og,23 +onnx/backend/test/data/node/test_where_example/test_data_set_0/input_1.pb,sha256=lPIc8OteAp_-7KlBv6zvkdDRdCAfOoxPPaN_av_HSJQ,27 +onnx/backend/test/data/node/test_where_example/test_data_set_0/input_2.pb,sha256=7893d1VgDXW5UWBTA27uzhL4FaPrjXYO5MNy9JB3a04,27 +onnx/backend/test/data/node/test_where_example/test_data_set_0/output_0.pb,sha256=3asllVK1SP7UhYXVLz5tibbbeultaVH_nFb-UOh8-pU,27 +onnx/backend/test/data/node/test_where_long_example/model.onnx,sha256=IiJZuUKLbgaVXnSuiOXQRbggyn5ymP42iJeHb75n96c,171 +onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_0.pb,sha256=ghkps-yp5CRRR8fRbC7fiqWG19bL00TcORlce2Dr8og,23 +onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_1.pb,sha256=ihk2_EF7Vli4ISkpvz__BQzOCl_2COzVep_4BiFH43g,43 +onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_2.pb,sha256=f_zUgnAQ6lnkBPWONXb6jcZgcQ5HwulMKehbqLKYwqg,43 +onnx/backend/test/data/node/test_where_long_example/test_data_set_0/output_0.pb,sha256=XgBYedUw_ZiqoFlcvsS7HsIoJNZPFm-DE9Bx6qZeF70,43 +onnx/backend/test/data/node/test_wrap_pad/model.onnx,sha256=GPnYx4mSIh8p05M5Ue_8juqPZsZVCayYZdR9OHdRz_0,154 +onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_0.pb,sha256=umu-JvCA2frJXIw-HvgygGTng85wErTWgIoWSJRivzE,256 +onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_1.pb,sha256=8s4uRhNf19t1kZ-BWDxuitcnY9MeHgkG6w6i1Sghnz0,76 +onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/output_0.pb,sha256=g9TcriXsdlgExNte-G7DnSP10rAenwXVxWkiA-pXqM8,520 +onnx/backend/test/data/node/test_xor2d/model.onnx,sha256=3GJJUC1tVd_FIuAx1ZCV29I7vpp_jwEO_A_C8qFQl3c,119 +onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_0.pb,sha256=LjNp_gf5HfToURj-fOV-TL_10b7cTqoOj8RfPTNPYLQ,23 +onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_1.pb,sha256=goZmxegiEZPjRTXScUiQU9fpxPndF4EqAZy8oeToa8k,23 +onnx/backend/test/data/node/test_xor2d/test_data_set_0/output_0.pb,sha256=wYcj4-6dNRFaXwU1hntV05Gy5aHpr9Vv7uCuV61ad50,25 +onnx/backend/test/data/node/test_xor3d/model.onnx,sha256=cQQUDctDV6dJcdwK8vYh668uk1M4oHKIM9Oueba62ro,131 +onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_0.pb,sha256=Dr4k5dppNqEaWmFsMUXw_Pbp7QoEpqkXv4Bodqt7zMQ,73 +onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_1.pb,sha256=v5SpTzEGQijgxpt3GQdqFdpD-LCqlDgrPace75EL5pQ,73 +onnx/backend/test/data/node/test_xor3d/test_data_set_0/output_0.pb,sha256=Vh-V32zTffsrBgNhRvfhcFOZ1svl-bmYxXnxZHCuAQM,75 +onnx/backend/test/data/node/test_xor4d/model.onnx,sha256=zorAb8QHzWBFMEznyeOGSrgu-gMQ1B5BCQYS6sWXNkI,143 +onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_0.pb,sha256=sMKxU5gNQx6mv89ZOkmV0QCdEu9f8EhE-MZuoWNbcek,376 +onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_1.pb,sha256=9JaUvXVRf_NYTRwYWtPYsbSoKJDwOXPZuRBgFY7pYPc,376 +onnx/backend/test/data/node/test_xor4d/test_data_set_0/output_0.pb,sha256=7t2mIHhiY74BIpOpK5SfckyO__tT-EiLhluUCYb-6TA,378 +onnx/backend/test/data/node/test_xor_bcast3v1d/model.onnx,sha256=ZareaBAuTyUxBY2ReZrYhH1ejl0N5Qpgu45vJTsqlOQ,131 +onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_0.pb,sha256=wF52hvLEXCfryTN0FvgWPKXSx3PPlpiaC_aAZ5IXCMc,73 +onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_1.pb,sha256=0cP0kHJ95VbmGsyJW3rlozPO38YQocSctc5buLas0ZI,14 +onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/output_0.pb,sha256=8tkEvTgVHtTWyJZ3JJi-ap4ICdUqb0TyJoYleM7Xwjo,75 +onnx/backend/test/data/node/test_xor_bcast3v2d/model.onnx,sha256=PNKaP79liHG8NtmiYaeafrRs5qi2XUSu5fN37c0RqFw,135 +onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_0.pb,sha256=2Hi5gZzCyk3SWtB8dhtS5tIMipISnPJGI1SIjx08Fe0,73 +onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_1.pb,sha256=J1neLsOqZHTvGdagBF8_3O6sQk1byuUIMABR0wJxASA,31 +onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/output_0.pb,sha256=jsMfiHOic7b2QO8cGqTo5WGnBTeBPx83WXxh3j_bLkg,75 +onnx/backend/test/data/node/test_xor_bcast4v2d/model.onnx,sha256=jG3UhG63Rb3lWqlONWth4lsfURxHt-y2M_y10XGgRTU,143 +onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_0.pb,sha256=TG9PpNJBW-rhSdwYDpmwCMotWc8SOe2e2cLAoXaNQ8o,376 +onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_1.pb,sha256=D4JIlfVUzijC8rk152pkPsDWa33YJRlmutjMvkT-1FI,41 +onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/output_0.pb,sha256=Qgh2Pvp5xceZzOVQ9LbIq5hSoPcfBb2a3_UVolJSwH8,378 +onnx/backend/test/data/node/test_xor_bcast4v3d/model.onnx,sha256=ka5mFaag2sB3Wo-gr591NnmvwsVpkR6hQyR6KBmZWY0,147 +onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_0.pb,sha256=1gaunFCw_HO0ZAf_sAp9bfcwVRJW_aTJIwkv-2WYWMw,376 +onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_1.pb,sha256=26gLYNI9eQESqKzWzx1zrE8YDDCNIvfAE_0m_FoeT3E,133 +onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/output_0.pb,sha256=PSXb0kYNrXzlksKUyQCNo2US4L4q5PW5JY-q8RDCTDc,378 +onnx/backend/test/data/node/test_xor_bcast4v4d/model.onnx,sha256=itvh8evQEuNJ5pxrge9J62QTcH0OOr_3FRCL-v4fOIw,151 +onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_0.pb,sha256=f63fGhPch5eTkAvMXCrJTC0FOIdhKnaSfJ8Ox9hnol0,39 +onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_1.pb,sha256=iCGDAU6H1-WHvqKKRCD44UWeluKsnFCWMpevbsJ5ASU,105 +onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/output_0.pb,sha256=K5QEaUMGmY5feFywFKuoQfnj0csdxH87pELYOw4ib6Q,378 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d/model.onnx,sha256=8mAVDhS8q2983UD42Tn2UtYcj6o_GOx31Bf6rOQnmic,234 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/input_0.pb,sha256=zV1Vt8e4rt7BBMwCWTvpZ4ewNN6urxrFnE0-oTAebYo,155 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/output_0.pb,sha256=qn9ze93KKekBUHX1zcPFPQszhnb0xCGUQ2cUi4v-PBc,82 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/model.onnx,sha256=8mAVDhS8q2983UD42Tn2UtYcj6o_GOx31Bf6rOQnmic,234 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/input_0.pb,sha256=93fhfQkyWxsVEbiwnmhx5RtN3NuGixryFHcYGrBqiAk,155 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/output_0.pb,sha256=V98iRFVVabmSxa6RQGlOA7DLuTsCfMwULBopoq5OgEQ,82 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d/model.onnx,sha256=TB8sJRl2IhMEO9FUoayJ2MM85Fw3RhU9W1e5BipjB5I,180 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/input_0.pb,sha256=bNLdgLPEgneV2dYpx44Z_cNcu-P-1TtLe3BxHBzvSSc,877 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/output_0.pb,sha256=F40fDjWldQJxabM_XYkLzpEMez7jL6OzeJlgbouXRrc,229 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/model.onnx,sha256=TB8sJRl2IhMEO9FUoayJ2MM85Fw3RhU9W1e5BipjB5I,180 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/input_0.pb,sha256=TpDPisxlYGn58g52CgJ4HAsFm-BsfjIwEszTQcTV8y0,877 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/output_0.pb,sha256=Y_cshxOA9B_1xVCMY4SBn0Cmt_NuFf3gL5tmh-vNvPY,229 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d/model.onnx,sha256=pJRrVDIgyVnsXheUw0l8DEsCI3H-A9E1Fytt721SEvQ,196 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/input_0.pb,sha256=n-2GBmhLD0xffKPoJ5FnFBEW1kB0aMyZdET_GWifw6Q,1551 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/output_0.pb,sha256=FShc69O3dlB2g0mQ8-jI2kGpMyTyWdMA8TAFosrPyQo,207 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/model.onnx,sha256=i4Ana78vTj4DG_7vWo9TQqp8rR1SsMJQzNPtEZtncdY,196 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/input_0.pb,sha256=y_Tl_lr5uoFfr_mDOVp10o1Rqwto3dUX7uyqbZphtlY,3015 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/output_0.pb,sha256=50IuhwLSEvlySwQziXRKplBocjNERvL_Ug_QVvAtZ7E,207 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/model.onnx,sha256=7bss8slZ11_xPh6ekLnbPqwSx-2W7nzBlfSNrWguH_s,196 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/input_0.pb,sha256=hJelxSiUlg_o8SL7GnKSbwzK1xTJmFwOGbYnymULc60,1551 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/output_0.pb,sha256=PRmuI0KY_2RPQttWtH8mIBA71Ab1VLR65BqK2vmqPXQ,207 +onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/model.onnx,sha256=KavPmaT-7YmXr1yv85ueUtemurjesyB5noD0v3Mc7Rc,378 +onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/input_0.pb,sha256=WUmYIvacvUxOv8Z44Vt5oWHP3Rq0lRjXV0uTRrVB4O8,251 +onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/output_0.pb,sha256=F8hXf4ujaw9wkKXJOH22sy9d-CfBDLp13y16hP8_Qg4,251 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/model.onnx,sha256=8Yd0nlXaftKBaeljimCYJXMW99MU6ro6DDMkNFQzZ1I,354 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/input_0.pb,sha256=WZIsl8gdTSpkybVdM2eC-UDdnwUclJpv6Ciz1dJa2Vo,877 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/output_0.pb,sha256=prMmsJs86e9qAfIsik9a4EIZbCI_YgdcebO7mH571KI,877 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/model.onnx,sha256=pOJ6Q6RfjazEKRDHG3tfkl3iPgf-7XzDh1NdW6z1zIA,354 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/input_0.pb,sha256=Xl_bu5yQ7sA6heXBH0AC1ycwOKKz7x8yyDnXqGKsNKM,877 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/output_0.pb,sha256=0UTSeOyp4AgM1BSqfX8F1zt4Axxg5eWpxprQRlb-v0Q,877 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/model.onnx,sha256=oQCFAVSP_Lwz8YD_w3Qhg99sqtnJ-UPESFVhyfm_Z80,362 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/input_0.pb,sha256=xWcOlLS21xbvStXK5VyuQOqhPjlYHJVyXl7sb6DhOwo,1551 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/output_0.pb,sha256=QLvTKHFqJsIIaKNyJPxi3QB5_rQtQ7VJ_cvQ1sdPOKo,1551 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/model.onnx,sha256=yjD59gbBFMjuznApZPsJOxDoyKk1ce8meoT4y1aPun4,362 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/input_0.pb,sha256=KIyabETJj2PkS0Ck7y5IPAhEXrPQ3QLsQlstwZvCCnY,1551 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/output_0.pb,sha256=et4SSsQj6ySOcT9jh8TnzwTGicmyngVZafqJnWQ0q-4,1551 +onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/model.onnx,sha256=0SsEC_Z0DrELQVHraXG6BzRPfrdrI78eD93nd40gXXM,177 +onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/input_0.pb,sha256=QoOUMz7CIm79Vi7-FqFrNH_Fpm2pwjiJTJ5KHGsB-uw,397 +onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/output_0.pb,sha256=crHpXo4F_TPPkniDuVYpgF3TfubVLZFeSEKvqhTkvpo,1861 +onnx/backend/test/data/pytorch-converted/test_Conv1d/model.onnx,sha256=Z4QCn29y1djJ3JZnuFj4OIgsAqqSZj47jJ-FpQqc8Q4,525 +onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/input_0.pb,sha256=M1p3HfX3tyCNxMOUXytdx5cq4AUFr38MGd8C5i6PTHE,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/output_0.pb,sha256=XG8Vzj2qFCJBwS1zk5kl16mtDZXs3GjkTqX7kYHINqM,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/model.onnx,sha256=CWlj2QY04xL0V39Rf_Q_Eyy90kVUXLK6lWICIpET2KE,525 +onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/input_0.pb,sha256=3E2ZYHLqPEaVB7HRQ5NvJlXwC2luExxp_d1W2XYUhxI,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/output_0.pb,sha256=Rs6ytMEQmbUEfOLDX76YAQ6hDS-JxU3qR4v_lisgyd4,251 +onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/model.onnx,sha256=RC8liAaCSm35TMxBRnNrJKIMam82QkW1Jkc0O_qRi5w,433 +onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/input_0.pb,sha256=i2XCJCDESsEGqcZJiBpBtu-jRPVzh7K1h9PecjAtXK0,203 +onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/output_0.pb,sha256=Do0wjZqxfKbFCsZirn1INKtXTYSN0669VnKHyV-7wvw,203 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/model.onnx,sha256=TARXa4saDVX_6iYTSr_N3VAWGjAh65alUwmJi27dOBg,525 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/input_0.pb,sha256=vCs38klXgXvMU4xaQIA24rh0jrrlgyZ-JknlD6uk_0w,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/output_0.pb,sha256=5l7hug7Ooa6l_1pY7-BPJAQPe01YEanl37UKEalctvU,411 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/model.onnx,sha256=RPJomwlFC-2ZMW2wwl6o6YfYAtuprYuVgvnNE-NMsmo,473 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/input_0.pb,sha256=BV9L90-Mjw_hKFJo1KDsckTs9KNfDEYYNzOtEDEAbEY,26 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/output_0.pb,sha256=QrhPUkU1IiaaQG9co6aeB7PPn6I8zgqjRG4Dyt1xc0w,26 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/model.onnx,sha256=6BtfkkYnCOH_OddQBr2fi6Nbbwjo9YWCPKonFxCBW7A,685 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/input_0.pb,sha256=KwIVOkQUfZQsyVi4WOkmxQQ6jrtqcbVC9Hnu63ZoblQ,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/output_0.pb,sha256=P8I3CDmlvUVih56z4CBHvo_hwq_FP4AtTab4nYieP4Y,411 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/model.onnx,sha256=ZWRfSCErOjTP1vHZYQlCHMv3poCqHNdXlIZQ2QhVakY,601 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/input_0.pb,sha256=uS_fv_8ZJYypoe5d-EBLOLhaPQ4ATE_KPHOIQ3Gqeto,26 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/output_0.pb,sha256=oK8jgBMFbuJE87uSWda7mMKDDjFBmE0Vts17x29g3Dc,26 +onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/model.onnx,sha256=ptjiJVis2eF_cYg7wJuQy01kSdZ3LZjuoILl2hSdnR4,525 +onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/input_0.pb,sha256=9CHLFEq_ik_V5LaqT7mcz6SNeHOIhuIuv_jvyTNSRrk,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/output_0.pb,sha256=0pNh7Y0jeuA_RGC13raCipZ1qiqZu-Yz7cL1jAhOlEg,171 +onnx/backend/test/data/pytorch-converted/test_Conv2d/model.onnx,sha256=y432KyJAGqZE5G4TtVt6xfPDgU4AL_k5pLvhEnIPwGY,593 +onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/input_0.pb,sha256=1OBmuNrH0n2t8NGHYARcjbatJIjaK5tNQ3r5RJ9td5U,853 +onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/output_0.pb,sha256=Jlk7Om0xPxTfTD3ERkm1VAo0x_lWP1M01vtDQ-MOGHA,653 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/model.onnx,sha256=ifRT0arIIJm963Lu92VvSZGQoS2OQnQh35GwDZVF_BU,449 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/input_0.pb,sha256=oIPHf9UX_VMt_rNrr4y-WwbCf3Pa1ri9dzYzyPtDCAk,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/output_0.pb,sha256=_RPmQnqkoj4aVc9bQIhHiaSTggTE3t3AtUEfL1DhddM,525 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/model.onnx,sha256=fpGjNOhOxeUycys8ikMj065ilM73_LW2yQbz2h9ZqoQ,449 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/input_0.pb,sha256=8RivKZOj2PWj__57mFbs9rnGXRyydS9uMXCK7_D1-hs,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/output_0.pb,sha256=DHO7upgdKnVIz_7I0aN-oH1prFbEDoWKHhUUuD5unNA,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/model.onnx,sha256=9BZDcN_FQ4h5-GuyKnsrFiqFluDBhVzxy7ZjQYAYv9Y,449 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/input_0.pb,sha256=z4xSxpRG1WwCJdeH1dvUR3B-8pzhtCg7ItADQTwkoNs,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/output_0.pb,sha256=hKMKPzFqMzJQW_UZrWEU4utjyHzPavSUrjM_QLccCB8,141 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/model.onnx,sha256=p0zmWsZaMksp0qUv5dTsNa4bt-LLPIWkaUOeB38Q_YE,609 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/input_0.pb,sha256=4QOtaGsL1JztJ46gZNxToNKt-hzvC_b-gavbU-JTrvc,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/output_0.pb,sha256=d_Gg8Pwi-UEIlyZPIIZ1aIpFFv1whi6Ufjl6-j64yxw,1037 +onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/model.onnx,sha256=M4Tog0lHqJerdu9jcCuKNjCuEVOW0h9Eq4u36T7hjwQ,513 +onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/input_0.pb,sha256=R6GKeyEpmjB3-rRHJ7mnjGrTRfKCFJfguLjBEnZiGH8,1549 +onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/output_0.pb,sha256=w02ja9QxjYGDw606aWk7_oSr5lUCoStmytZlVme1evw,157 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/model.onnx,sha256=uh-iRrzSbF6r96Jq4NTGnKV726HBDnv-5phjp3iiEJI,601 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/input_0.pb,sha256=ATzHdOKHF7WLjEWSJmSuW_6v2nEyhI2ixRB2r8lbfvs,973 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/output_0.pb,sha256=jECSkjosOUIiACcNQrbmZ9wSua10w1XivubTJ9ExL5E,781 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/model.onnx,sha256=4x_JVppcm1xB2Es0ZKdSu54IT3X1UfN6pF2LTdsRVZA,601 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/input_0.pb,sha256=W2rRPvSGGsPzKpUVpFBw2eR1bfsdMu4vo66myacAb0M,973 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/output_0.pb,sha256=99GiPC_yeuHqMA4l-fWHO3Nrfptqn1h6yiyH5Vhyj40,781 +onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/model.onnx,sha256=ZsLuWnDa5_i6ms1o58ROf6NeBf82JHq8Jyg6ZK0jNxQ,546 +onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/input_0.pb,sha256=5AjXIP60cvhAdvKlUv1Mf0dnZ7YOESiyGhYH4A3zzMc,733 +onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/output_0.pb,sha256=XH-ZGTgDbQGOnSfcNq-orV6S2C8x11xzPDVUknUCLvg,525 +onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/model.onnx,sha256=7R3bRZT7rxJC6ll_papH9LqxC6xLMXLfjjMbOSyu8NU,737 +onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/input_0.pb,sha256=Cy-XsPZPkHKiafZJ9Y7iR7zj7sVVL3i4RAIjb_HN00o,877 +onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/output_0.pb,sha256=YZB_7e9uqA8ER15q1QenHfrIUXt2fQnPgOTbLX8CF-U,301 +onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/model.onnx,sha256=egZ--Av5rYKCJMGEGGns-pbOVvH5tqyISxx6BQqZeOI,737 +onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/input_0.pb,sha256=XIlefsfSL9PVbGn4KZSR6YnajJ71vd8dW1NI3rlXRQ0,877 +onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/output_0.pb,sha256=_OOVJ1t07lBsD3OmyMjhCFDd9iQeMw19glVEC4lOIaU,141 +onnx/backend/test/data/pytorch-converted/test_Conv3d/model.onnx,sha256=16JkMwetdzIJqDe9IN5rsD6C2fCNZUWat4q7kOW9vYA,1481 +onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/input_0.pb,sha256=4If0txoCf02Sxyb-TKsVSmnfyPeCyJUl0vlDcjhb_3Y,1455 +onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/output_0.pb,sha256=i7pEvDV-ZSeyS2rU96YaFK_KLKGPMtulFLQJx7ERNwM,271 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/model.onnx,sha256=gJoR548aEmQX7kEw-DegL18l6WG9PZiRG4myAGZJLLA,713 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/input_0.pb,sha256=sgU-wF7Lo5l0dwFX_FgXV2B6pO6PBk8C6Q8VuYl37Jo,3015 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/output_0.pb,sha256=ZVXm7ParEHvjD0FRcLyDw0sCStjwNg9LzyfB2YFLaZI,879 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/model.onnx,sha256=MF7-hVNyKxpSOYCPOtMqj4PPLumZvEyNLpKKdH0VZ8U,713 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/input_0.pb,sha256=EkFpNPI0uV-PEtZqr5nJ4DLxhk94Kip8KNpzHEL0Uq4,3015 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/output_0.pb,sha256=UoxcAqI9HHOERFKkYWf27G9B28-MFakBAtIAoYhQiB8,271 +onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/model.onnx,sha256=v9ICh0w4hqY5snMTyD92gTHhW1g7VQ6WVnYQoLSa02o,1633 +onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/input_0.pb,sha256=M_PRS9s6oz5E5R4hGjSJG7OtJdfGLWGW45Fn_UZWYY8,2575 +onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/output_0.pb,sha256=npPaSWCc4w_5xBE4uyXB2YRxGWa_hjmxTdOCrk3kb-E,591 +onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/model.onnx,sha256=M-IZkgZ_-Br1YoiwQvut2UFFXftUFF5UuqcNniqn_Tk,1434 +onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/input_0.pb,sha256=_MHSqR1rF_XUblE_4HbjInNfEM417inei05uy1cPIeA,1455 +onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/output_0.pb,sha256=ELnUZu6Tub3Nt-SbqAnuZ_bF167tpWqqxD8TE2rsa3k,271 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/model.onnx,sha256=EZb1n6bYJciHlcZPAzV08Wi7q1HcxvJXCy5aPOfynQ4,713 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/input_0.pb,sha256=HSk4UoX2KpcGlXg1SnnnWI1iUKh4PkPXxdGLlx6fXQc,3015 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/output_0.pb,sha256=QBprsW8RzmVrAoLVM0VQ9D1DOBZqh9YmluoNuDAlPKU,271 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/model.onnx,sha256=LDPW0JXDJeZnhYI12RKv_IwIdrS1U3GHr8uYEY_Ivi8,713 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/input_0.pb,sha256=SswSGowYkI_cfPsk1g9hEVsurerN_J2gFJJ_aPiGKwg,3015 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/output_0.pb,sha256=bmi0M7qU67vZyg50hdRO46QU35LTp2SmykyEnr3jK1Y,879 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/model.onnx,sha256=uiawKtrZn1qlhaKVjfD97MeD5wpWP4-BgfsgWqAHAqE,772 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/input_0.pb,sha256=04V2wjKmR5vpKXskDgyX-9EPbsPah_j6pnPgdn5m5ww,517 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/output_0.pb,sha256=2sxWuV8VYus2X51ShW3kRGXXB_YgSaP4pFbPkVxWvto,3853 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/model.onnx,sha256=4pzDYfTqDObpNKLQDnNoO4Sf4VCzALkhnj6g_KMbZXQ,725 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/input_0.pb,sha256=cDragHQ7hS-xtN1fMIGWyMXJ2NerZwn_JSD8CNZSGAI,517 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/output_0.pb,sha256=IA0L2r215O76xM761W_inWJBIV2dK4SvKb6guj76kt0,3853 +onnx/backend/test/data/pytorch-converted/test_ELU/model.onnx,sha256=2SeXax0MIzkha8Ha39cc2bQLXMTLIUwAgomrGh9xbaI,120 +onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/input_0.pb,sha256=luvTZVOagQKAbBjB9-H7TBlYEFI2Uqu3FTQRMTybmpk,130 +onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/output_0.pb,sha256=3p3X7-mRaLL9ssscsdr9mHcY3-Hn-b0bbAJ64qKhWyo,130 +onnx/backend/test/data/pytorch-converted/test_Embedding/model.onnx,sha256=_0o-LP_DjPwbBW0Dxap5Bprj7jdlHjX4UfbmKn4dZ9Q,188 +onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/input_0.pb,sha256=_0rc6-MctiMvWy8M6NSWVsm4bVxLADLFjOhsTv8xIMw,40 +onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/output_0.pb,sha256=j1g-AeOS1kcJXRL72P8UHZsuaFt2UiCjUXUoNDKnZRI,58 +onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/model.onnx,sha256=F5vU9vTQYqruQnldJ38QSMMLOuLQJEDfmwy2XlDO3hY,188 +onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/input_0.pb,sha256=_0rc6-MctiMvWy8M6NSWVsm4bVxLADLFjOhsTv8xIMw,40 +onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/output_0.pb,sha256=poXwHivKwggktTHae36VM5QmG8dryXX2SOtNAVUssuM,58 +onnx/backend/test/data/pytorch-converted/test_GLU/model.onnx,sha256=HQmhBaiXteu956BHP9oxeAwiqMlBqDwSX6tEsrBHau8,156 +onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/input_0.pb,sha256=S3wGQIwYbwGN0JopQ-SYCMqnIkBQ7EbqwE5OQRUBJ50,128 +onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/output_0.pb,sha256=KFzb3xYeFeA9xHmKlNhI6AXtfYCz99ON8DVzG1oihmE,68 +onnx/backend/test/data/pytorch-converted/test_GLU_dim/model.onnx,sha256=Xry3Ey1Ohmwx0Ou4JlncDobNbJVSokkJ2CyG5qj6DsI,155 +onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/input_0.pb,sha256=qgaBlwPclOrBoRpDWaRQKo47MQzUrXcHEoJo9op9vnM,851 +onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/output_0.pb,sha256=EEGmzp1nC91QOMpO3BXPusSKwYSBpa664LSOkOzCJH8,431 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU/model.onnx,sha256=iQptij6gd52DigK_wVZk1PNZSkgFwgzOx0w6iePLeeE,126 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/input_0.pb,sha256=SK7wRI8g-o1mvSNjDS9utXtEG8ATWXM2dr1VGOW3B7E,130 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/output_0.pb,sha256=q-0YWwHtpdz_9DWan9IbokhV1p9ti73MMonkFJpJ710,130 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/model.onnx,sha256=NM4JUm95vZvdMzAT2F5D2_q1XyfmtcCsocRF6IcpC-M,126 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/input_0.pb,sha256=djYXx0SejTe9i5wHFcKEo2abs4zfpMbcRLtUxikCSJE,130 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/output_0.pb,sha256=BCvDv2KDQ6j-LtkWz5ZcSs_6ZgNyVYBsTEpY5s_SxYQ,130 +onnx/backend/test/data/pytorch-converted/test_Linear/model.onnx,sha256=YKNUaSXYMmhseI0-oicy_q71vFJ-BGkcMuyfZ3yB9hI,585 +onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/input_0.pb,sha256=EVBDYsD6CZzsPoADTCeqHJmWarSTvnqSUkucBqN8YeY,169 +onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/output_0.pb,sha256=Y2MWMPgxI58ITCWNv9R1pkfR-I41JAKqIgdzxvTjoxQ,137 +onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/model.onnx,sha256=Bxzkm2mGNbCQSHaX7ObRgizQJdCQL0o5-XEbub1DPo4,492 +onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/input_0.pb,sha256=pdTU_UjclLXaiQv81fct2hf0azMiw-kEUrvR4Y7eeAY,169 +onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/output_0.pb,sha256=GLoTdF0mNzWWJSk7Eh1dUDd0jJtGYRZv915Fu-4wrYs,137 +onnx/backend/test/data/pytorch-converted/test_LogSoftmax/model.onnx,sha256=7OG_h8rN3YDf9U3fCDZxSE1snbwrkZE4qDytlOnLm0c,115 +onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/input_0.pb,sha256=aIvEbzha6zVWoOMyDQk0X0-F7ycVmOTQQPDPzCK_fdM,809 +onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/output_0.pb,sha256=kcLfEFJdOk46YnJH2AKfD9a9UeoM35TZKOLZ3H1WTdU,809 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d/model.onnx,sha256=IEtciU1nSV0VFZbrIf55J6lfpZ6_3VXOvgyPbdStnr4,160 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/input_0.pb,sha256=NGuPnKs6gIclbkt4IRL1z7WvbPm8A0Gu2fX-SaNVePE,331 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/output_0.pb,sha256=79siDNKe866D0fCh9xWgCat_Iltxvm7n-C-8h6HK2qY,90 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/model.onnx,sha256=IEtciU1nSV0VFZbrIf55J6lfpZ6_3VXOvgyPbdStnr4,160 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/input_0.pb,sha256=U6fj0KCQ4sggGDgUtqsPr81b3thuxSDfIYAuIK3q0ac,331 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/output_0.pb,sha256=9l6v8PiMMo2UIsA9mYoZcuS7ewxdsrqfYQPwp3XDkAo,90 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/model.onnx,sha256=flUyj5LMCtVUzJvaeJGW1xkB577pgEV4YIcczdGPNVY,165 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/input_0.pb,sha256=4qJvUOWUo3f91o8JddOTERM6MTcohmKrISyEnefIeiM,880014 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/output_0.pb,sha256=pOgx9JOSU_e-2nS5DZpaauJF9NpUBcDjN9OTYyVlgAI,87298 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d/model.onnx,sha256=6qw0Jl0dJZcgUXdgknbsKXPEtbxIPBxBSmuWU7TWBmA,176 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/input_0.pb,sha256=Gz4idq9I1lPqAHpTOusIQ_hfTeZvcEw0pXwdnFibumg,601 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/output_0.pb,sha256=fkrqthNBgDvYIaVm_bv6g2do8vvs-0AMbsKCLxf7DJg,205 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/model.onnx,sha256=B9dO0myVpZkPOTNRE_KSWNGZ0a2zALqPoRIpIEjBWg8,180 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/input_0.pb,sha256=KERNzX0dOh2dZWTf0dVh3ftuar0N1aTYH9kXJSuIjfU,4000017 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/output_0.pb,sha256=qmgdxgxSdjm-gXp16_WG_bGQn6U29XRZmLzNN8sljis,4313 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d/model.onnx,sha256=EkVIxU2Gvd-03OLvhzQwdP9gM48Ila14pNmsySHlTJ8,192 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/input_0.pb,sha256=dJ5NUUUFLIBlKgA8CIxs2U1CdTelFQM6GaOVcjdfXH8,3015 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/output_0.pb,sha256=MxSYbK5mw58Ewucz6ommkVScxLBbaSHxhnIoaYbIovE,207 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/model.onnx,sha256=EkVIxU2Gvd-03OLvhzQwdP9gM48Ila14pNmsySHlTJ8,192 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/input_0.pb,sha256=4xZ_MzlwtkraNLfBDMDjlNHR87cReCK4aN6jKCSvfic,3015 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/output_0.pb,sha256=jkevhpPha2nlXOhpYzU6bPhiiNhixWbDdJz5Yh6WT44,207 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/model.onnx,sha256=Y-1oo-lij06opYfKEwu65De_E_wn1_M10syRyZD-OrU,192 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/input_0.pb,sha256=vFZi989muj43A22p864N0y2TeuLIirF1QEWpeo0g0cQ,3015 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/output_0.pb,sha256=QWM4IdynZ3TeBEWJlrWcmiLuRzF8-GUDsIjU8RRaeRM,663 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d/model.onnx,sha256=4mjvE2iJgkg7zRTS0Y0Mwmi3rbxDzPNAXF6lw2kW0BA,140 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/input_0.pb,sha256=dwCj5dOo0Xb0LWoFEa02MXjNCBKek1Mb7p9loqn-qBY,106 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/output_0.pb,sha256=WVVfw7lN4bUO91ljJuOCrF0aAsAVeO7VxMWLJCPPf24,106 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/model.onnx,sha256=IvY8tpSEk0hJlbRtt5J_IzrQsIDrbYvGdRmHj_kAgyg,148 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/input_0.pb,sha256=qUglE2t9TlGG2PODCNryl96IZCMJRnn2s2kFKPtidug,106 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/output_0.pb,sha256=kTwdDuY0JawlXDtQyKba8alf87POvLW-H0svciJZIRs,106 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d/model.onnx,sha256=wt-aOA3QVpCLDlTprLv-5QTXKC9xqFoAF90G6m_D1Ls,148 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/input_0.pb,sha256=D1kkTnMRur2IBSkmCXshOMXBM31Trp3gcsBnHLoxwPY,493 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/output_0.pb,sha256=G_Dp6PuiE225MDYlJKnajeiYlMCwWTwm_3EvFjOzfto,493 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/model.onnx,sha256=kukgvtj4KMURYyG6ZxeZb7uPkBlyolfPCSDI2O99Jk8,157 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/input_0.pb,sha256=NVK5z3BB-7fMzSpEAVe9KJ8_sjW6_oteQ-lFs07YMmA,493 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/output_0.pb,sha256=5SPkRU_nkyPSqWawHP_s5I5nFnGXcea7i6rihB_vWHY,493 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d/model.onnx,sha256=VvZt8tBvrh1vuaXYca3DxeVODOxpsz2IaSRWtPgh_jQ,157 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/input_0.pb,sha256=kjNIdTEFfb16oMR_21gnH0-x1yufQ20r0JJwtEt-4no,2895 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/output_0.pb,sha256=k6V8hNaUEXKnZCUTKlyCcADbPdyZwabu97D4qzyU63E,2895 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/model.onnx,sha256=6I44FjDRNdOgmuwdeewtzNZQbbTYuPs50CxyS21RDIU,165 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/input_0.pb,sha256=7CLbhHgR9jhf6-fSx9oVVDPkyB3qVJyRqQVVsjM8TnA,2895 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/output_0.pb,sha256=b6pQPzS39brhgz_HkZsQaIU1rvRZP-ONgl36n2vGiKA,2895 +onnx/backend/test/data/pytorch-converted/test_PixelShuffle/model.onnx,sha256=4JEqlXzNhKwqniaLCOWSFSueWfuOn7VbaFKr42KIHKA,331 +onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/input_0.pb,sha256=A576kvtGuxWcgI872W5-c89GMBV1iQTtr6ZzsihfJf4,589 +onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/output_0.pb,sha256=XpsHUnOBLIoYD7eZK2V2Qwq6haDNVQI1_pg4jJZ5Zm8,589 +onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/model.onnx,sha256=tCWj-a4XelmO7y2SKKhmBKytRa9gzWH04L64BxoYBGM,569 +onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/input_0.pb,sha256=UKNDvDbMADHM63IF8twG9QID6pTJ3Cdsd3AazzCesvk,409 +onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/output_0.pb,sha256=W2gyxT0Yg9UxhnmysFE9lzrGT_6F4ZywIk9N5sxkiAs,409 +onnx/backend/test/data/pytorch-converted/test_ReLU/model.onnx,sha256=54bYFvc3RA1Ljsf68rFWpoazyI0bo_4V8nOzFnkRFKY,112 +onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/input_0.pb,sha256=Ey2pRpSgVvZhAp_fXdJLIVAidkpih_7XTMas2aU_x3Y,493 +onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/output_0.pb,sha256=p1LjECbj3CHtzc3dIr05bBrD_GeLzWOd0xNVstAg-pI,493 +onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/model.onnx,sha256=rRj1gGqwtSlWd14E5jpTt8i4gXR-gsHktOFH2VeclpY,159 +onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/input_0.pb,sha256=GdrCTnPr9lRVY_XPRDeMDg76bWDKxczmbLprbhFz81A,1549 +onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/output_0.pb,sha256=MItKenrxsfen0QqbAl3PIx9MTh2X8UsVszVaYmbTGNY,3973 +onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/model.onnx,sha256=iWrndt5r6y9xH9tJWVR_srvWd3qHRI-YzfMLgHIe_x4,156 +onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/input_0.pb,sha256=rvprCAB87mJqy5c2K47dXKz6lXiAg6Vk0PCSNIIf8fg,397 +onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/output_0.pb,sha256=CpGyltobSp8j5PiTJ1ELDekd0BvP3YG9VLaB34ibKds,1861 +onnx/backend/test/data/pytorch-converted/test_SELU/model.onnx,sha256=kbYX2BrYvTBNgqZ_FNNx5meiOXyCu9-7tFlQvzv2UfQ,104 +onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/input_0.pb,sha256=57MtXdSWmk8rV37-gl-meavMAFrNk1I1U1jRtRnfQv4,130 +onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/output_0.pb,sha256=vUvpliH3lpuLdxxQcTLm47OOxuFnkSlElGzpcbbcTlk,130 +onnx/backend/test/data/pytorch-converted/test_Sigmoid/model.onnx,sha256=r-jXvTu2OB1uoHSEc3weUBfipW-j-bomHEToiLRndZg,115 +onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/input_0.pb,sha256=xGqhiolQj1AXF_J9DI6RshclHdkTtvUfjA9UNeoH34g,493 +onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/output_0.pb,sha256=_aud8_qgy8myKoty42ouDGvc8LqB9P0wziM1WT9Udv0,493 +onnx/backend/test/data/pytorch-converted/test_Softmax/model.onnx,sha256=M8YU-Plr8Vox-xvg2ytI9dvOtVRmfrFA1WFtqrz1RrQ,112 +onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/input_0.pb,sha256=Mc2T2AKRlGbMn9JhKQCqvdNhMOd4yv6eoizRI4rQ3Es,809 +onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/output_0.pb,sha256=cEBcNyA-UO7PvJP05BNFPg34O0b9xuI2oIH0HujbJCA,809 +onnx/backend/test/data/pytorch-converted/test_Softmin/model.onnx,sha256=LkzcLVf0mVmKlV1Q7LaRz2roqZVUWOShqLA0F7CS3qw,125 +onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/input_0.pb,sha256=6EvkXgsM1qeqy4xXvrNmjzFgQIfUg1LADvKujrkhutE,809 +onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/output_0.pb,sha256=dM0ZzuuwBljCYCl5gwtz6dyl7xbwPq06OSJpbZz3rl0,809 +onnx/backend/test/data/pytorch-converted/test_Softplus/model.onnx,sha256=LW7eq1fDhqzTUcpreFM8MW1P-SXMU6R_-6TrI0bSeeY,100 +onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/input_0.pb,sha256=RHCWvbZJ2puJcskrkyp-UO7VJXgJbbtfngv50m-XBrQ,809 +onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/output_0.pb,sha256=T83BVCZNzgIMJeO_KjnLFCl3fvO6pI2swMn7AcHv2z4,809 +onnx/backend/test/data/pytorch-converted/test_Softsign/model.onnx,sha256=77Av428IZawS315gnrFwnQoxmzSxc8yyvjGvbpcg8I4,191 +onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/input_0.pb,sha256=OgR7ov0pN5ABVMr6BCcNwgO5LIM2kD3aZC8cakpK-JU,130 +onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/output_0.pb,sha256=dgsXbFOSn0KYtbVe_G4dJ--YwtKGY50m5L2hcy88lgI,130 +onnx/backend/test/data/pytorch-converted/test_Tanh/model.onnx,sha256=g7REbYpEDQKk-HFEUTr_edrTqEJzP7p6U41qAyRe9pg,112 +onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/input_0.pb,sha256=h-yYS6LvZ4ydAM-99zICo6VeQT7O187lkHDazxIon78,493 +onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/output_0.pb,sha256=GFqBj4MG7PAiujxMR6uzcTqQGD8YumwF75SzqvusSdo,493 +onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/model.onnx,sha256=mijCH0L13fd-XfpTow-vPLjuxzYrpqpewCmica_m4RI,177 +onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/input_0.pb,sha256=a2xkpLGBgCHkK36Ch5z9mMQMwaeo46gYSt_95Q7ViUs,397 +onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/output_0.pb,sha256=6aGq1RDiXJoI805HAFtG0ryTkbOZ6KvzjeoNUX8ZVuE,1861 +onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/model.onnx,sha256=iVa0we93ifXSp1JapVRj8Hm68mLpWXF2QQOmjcBZ9r0,131 +onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/input_0.pb,sha256=z9p6Tc4CGDfcMevMb3WI6R9nKVLSrmdsPnwCzB_YRz0,493 +onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/output_0.pb,sha256=5NXTb99k_ebDZZ8QdvNt2ZbVhIREH9c454g36hZXHcY,493 +onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/model.onnx,sha256=6b1s4M7kUTlLThqFJhrps_HEEDGGMRwmDcvg3LcMk7w,126 +onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/input_0.pb,sha256=vM6J5cm2YZRB4tCZwuPWtA4ItF8o4Hglhi78iySDgsY,1034 +onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/output_0.pb,sha256=LCqEWC3UH6W3AVeGaohUPNU8BJ0Qho_C259h6WlUN9U,1034 +onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/model.onnx,sha256=cW81QWpRLL4gWbYmKzo4crNfSP3o5kv7R59Xn1NTOtY,128 +onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/input_0.pb,sha256=1T7S2mfA3VyTw_Uu_xR1KZOkk6fR8gH1lRhqe77kCKc,493 +onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/output_0.pb,sha256=i3rXEzAEknBVyPI7uZ9b_3quJTfUfQRlhrHJPDzrI6U,493 +onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/model.onnx,sha256=AWWX8ISlHkfjfBJr-8cOPCVIVplDrZQ81mBh1Yg_3EQ,114 +onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/input_0.pb,sha256=II_c6Nd8HW6Q2S8wb99jN6__oTjkOq0LVrftA92K0Jc,1034 +onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/output_0.pb,sha256=L8ZOHtpkcNP-l-p17BcmWTK6ZUDAGA6OtgpSwjFwxfY,1034 +onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/model.onnx,sha256=4yoo6WnkuoE4hyDHi5yq3l3xs73PPdGJBDn8tsCtbmg,146 +onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_0.pb,sha256=WeKTF2a0gLSgFSE7RPu7suC8BakLI5JwxRIgcYBRMpE,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_1.pb,sha256=GlJ6YO-W-nl6W8Rn7NiA3VQBynnDcw0CHU0K60hAPxQ,30 +onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/output_0.pb,sha256=vAWPseKpiLhg5xbLv4brD66PGujVCowAWPy5xHf7MNs,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/model.onnx,sha256=Q_3UC9xYgU-Z1FCDqowXgtQYE5TFM3dv_nvw5nAW3GM,151 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_0.pb,sha256=dBZjS6f0YZq-PAmutf2KVyc5Ic8lkbaReqAjdLKIv9g,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_1.pb,sha256=Jm3kGLGMLfCLdjtlidztrRUtVcz4HaHKYpZojt7FbHo,24 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/output_0.pb,sha256=buFw95HzCCj2kzEsyFxO6VbO01-le7uTqki3YineAh8,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/model.onnx,sha256=4yoo6WnkuoE4hyDHi5yq3l3xs73PPdGJBDn8tsCtbmg,146 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_0.pb,sha256=G1yJUQGsG2uWKJX9PURVlIHVI1GLbKwq8oLWm3v9lEA,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_1.pb,sha256=mH_dZUm9K3R0jgvjqdsWve2qIOmh5Gu8qVQveA0iQyI,30 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/output_0.pb,sha256=KaDIjtF8dJTqVmxbm7bl-eNiGZM-3z4NqdhX8MFX6mg,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/model.onnx,sha256=W0u6KMQhEmUHe2aMKtEd1LP8RhdYPE42ZX0h4U1zU3Q,151 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_0.pb,sha256=Hgx9BDvjzAKv9uel5a1TqPgT_UgnDmf0WC7f8d3QDbI,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_1.pb,sha256=DvWV31gp254KnBk4m95GwdcvLI8e7GI0PIHV7Fb4akQ,32 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/output_0.pb,sha256=6EYYoWZQq5vpFlC5uj2bjNQs084U-fyAJdb5zLiphZc,56 +onnx/backend/test/data/pytorch-operator/test_operator_addconstant/model.onnx,sha256=PGsgLxLVxE6B-YnT5dTigfgO-0VUBuDkNxaLHQIpzIM,158 +onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/input_0.pb,sha256=aeAhCMgJONISiYFLETMGwolmnEWUviB-0r05x4Dj_QE,56 +onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/output_0.pb,sha256=3qSzQRI4ETvMsUTXU1C91aUqqIWvz211iPcREF1jNL4,56 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/model.onnx,sha256=pkXscfFqeA69tuw-s-5H15Yo8M5_a7-vwfoUF1E2kjw,245 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_0.pb,sha256=F8HIxuMvLzdYqNBU1WOhSu9BNb9f8sE2Nh4LScjkCv4,32 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_1.pb,sha256=wReWT7hu1wvpzVbdy4OQ3RLHmIGleWudjXtNzQxN3z8,56 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_2.pb,sha256=iSPe0APqyrCBab3JfQTvuXWKxYW1jq3wMM0ndaVHepQ,22 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/output_0.pb,sha256=2Q0N9b_FX6_Eli007JAr0zDu3FWCKLmiTtqJqJJJ6AY,40 +onnx/backend/test/data/pytorch-operator/test_operator_basic/model.onnx,sha256=j8SoAGDrf68-0Ty2zB9CuCbVpRP0WA3g1eYPyqwwthk,168 +onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_0.pb,sha256=Zssp45J1LZPvS6jAzlFOyLE5-R6r4ib6u0lGwdgrrls,10 +onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_1.pb,sha256=miH5Y5Wk3S1nVM23Js570P-CGR48fQrIQ2nUNDTy1U4,10 +onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/output_0.pb,sha256=ZFQSF2mOXhSlpLV3SiXplTBx4phBjRd63bhIcvS0scg,10 +onnx/backend/test/data/pytorch-operator/test_operator_chunk/model.onnx,sha256=Pv5XrJq5yDInM7YsNbYSFxdbZAxWT8s4a1yK5uX6lWw,138 +onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/input_0.pb,sha256=4UQkC9my1MZR7yS-gxUxLhHoDPcZRxOKVvPLOmF6I2Y,18 +onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_0.pb,sha256=vcT6Vt5kjiPQn_uVM30-vRqsKZvb0EHtSHQA-Zfe8dU,14 +onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_1.pb,sha256=RSc1IkqRdFLMBmDEQ7JzmC62gTBmianfJ-_9l05ev3E,10 +onnx/backend/test/data/pytorch-operator/test_operator_clip/model.onnx,sha256=d4_FGVudXbf56YhRlKKo7749XttVrIqHTtHnihmtwGs,126 +onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/output_0.pb,sha256=4akqZ8FX-HKNqVP2ano4QBijtZtg1XKrXBX2HLkDYYI,56 +onnx/backend/test/data/pytorch-operator/test_operator_concat2/model.onnx,sha256=_QTccgjLy9EPX9UF-JVnTvkGZ2QxzO-WCQCVesgj5Gw,135 +onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_0.pb,sha256=F8HIxuMvLzdYqNBU1WOhSu9BNb9f8sE2Nh4LScjkCv4,32 +onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_1.pb,sha256=x2uEGj8ly8Au6vONB5db3B2ZHsfzle6lcjWvcBsrm60,32 +onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/output_0.pb,sha256=amAMMN54fzkJ_ZeJCBvf51xwrKnoHs4i0fM0iR16ypY,56 +onnx/backend/test/data/pytorch-operator/test_operator_conv/model.onnx,sha256=hoZnLZ7StTm1yaZw2TzgB8VpMU9tdOM7SxARij8z1lY,7746 +onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/input_0.pb,sha256=UvIhWzUBbIXBelrU1HHHHr7b9JFAqIGvD3-A8CPr63A,2560015 +onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/output_0.pb,sha256=-1WPY6f7jpGTyYED8nmGHDidFx7eq14NTYKlkmgk1eo,1896974 +onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/model.onnx,sha256=V_1XB3M_HnRzMi0ZljeB0xj0LIzvIgQcMLk9BOSs6G4,617 +onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/input_0.pb,sha256=RFf6T5yV2ccdEeDEpKOX1Qka6Zw0JT5E3A45ct0zJRc,493 +onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/output_0.pb,sha256=3er0H-Tbr76YIcTT70mwgbc48b9QoMxTJKTJgge5uuM,4333 +onnx/backend/test/data/pytorch-operator/test_operator_exp/model.onnx,sha256=YLXCr5sIVod9gw7LO0QDJbuW-6wZWOLgripbCUCncKU,95 +onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/output_0.pb,sha256=EN1seuuM_1UBJFjXoz6xlX1FBepf8N0B5m7BTkWM8VU,56 +onnx/backend/test/data/pytorch-operator/test_operator_flatten/model.onnx,sha256=666oqdVmUbi6BFTyna0eHkclropUVJtqv6E8-TqjmtA,120 +onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/output_0.pb,sha256=wUt1WI2-KKlMOggC9wS59vZF8F_ROACdI3s7gmotw_U,104 +onnx/backend/test/data/pytorch-operator/test_operator_index/model.onnx,sha256=J1ty6t8ZzwyUhIz8R4zmc60rSqUa0_Jkt-0TWLluKm8,165 +onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/input_0.pb,sha256=hy5YLPPZ35Pu3PoQQVqGsxFpEvOOcTe127tUCiOf-yQ,12 +onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/output_0.pb,sha256=26QXjAPnTsE3QpqJjcP-PkSFVR-8imYTPkQwy9qdEpM,10 +onnx/backend/test/data/pytorch-operator/test_operator_max/model.onnx,sha256=RJnaYng4GaBOlE3io3sHHOCxOQHwRI_FJkBvXbZxVoc,119 +onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_1.pb,sha256=ofgAi6Cf8rn6vfsF7b8ZilqUiLtsn-griER2UzhkGpg,56 +onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/output_0.pb,sha256=piy6G5PPC3qlXr-0V6zHG0zvgArltR30tPVGS9lVraM,56 +onnx/backend/test/data/pytorch-operator/test_operator_maxpool/model.onnx,sha256=p7r_3V7RvgQx3OZFYYHkk20ocZF3KItd1P90Hxh-Fig,160 +onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/input_0.pb,sha256=aa_kAzlLZ3rm3CnRm9P7BhZKM5HFUJAKZWcpJqjTKhY,64012 +onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/output_0.pb,sha256=OguwhkdioYE3ge7me1NGCI81QPh1pYjmx5LdqJ01da4,30732 +onnx/backend/test/data/pytorch-operator/test_operator_min/model.onnx,sha256=Prwpo5VZNFPFoDnkSmRDXzMGetPh_WBwE4tA6YyTEy8,119 +onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_1.pb,sha256=ofgAi6Cf8rn6vfsF7b8ZilqUiLtsn-griER2UzhkGpg,56 +onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/output_0.pb,sha256=knO2XL2hje6BCvnjC7KMAGC4NNmTsKHdt-92jS9I5cw,56 +onnx/backend/test/data/pytorch-operator/test_operator_mm/model.onnx,sha256=vVO-SkTN9zcSOzdiDP7A7UxH6NUELPcnvesQ2DcG_bg,214 +onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_0.pb,sha256=F8HIxuMvLzdYqNBU1WOhSu9BNb9f8sE2Nh4LScjkCv4,32 +onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_1.pb,sha256=wReWT7hu1wvpzVbdy4OQ3RLHmIGleWudjXtNzQxN3z8,56 +onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/output_0.pb,sha256=6plZuSG8XBXIZx869mo4CIt_vk1_YamfsKNeqCCxh7s,40 +onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/model.onnx,sha256=SFxmoMG1q9-D0Do1Hwdh6GuapE6CF4fUvFFFzL_aVGU,181 +onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/input_0.pb,sha256=K70twgRARvUdaJmFeW6B-5p-XPeOnSI7UHikMCqGo5w,40 +onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/output_0.pb,sha256=g_q2_Vasu0pHakl1XkqeGqZ3mxXiykg-tDWqx8_VQz0,40 +onnx/backend/test/data/pytorch-operator/test_operator_pad/model.onnx,sha256=gXaZExe5rB9enuGhiokjEQIIa490pEoFFgKxoOEpSqA,159 +onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/input_0.pb,sha256=sPny-rLD9VzG1Qr1U03fcwqyvUHMgTJv1DCMw2uIOEo,44 +onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/output_0.pb,sha256=5J6xbmPIT527VCLp7VgEL6KPIMEKKkrSvtwXOH2WWmo,120 +onnx/backend/test/data/pytorch-operator/test_operator_params/model.onnx,sha256=Rhj1CwdUkGkdEadRYZBdl53hs-EvIPiSJVA5mTy04Os,209 +onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/input_0.pb,sha256=noOfxW6AHam2Av3f5rnGXx__oo2mqzch042fpYDSuVI,24 +onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/output_0.pb,sha256=tWqHSLbKRaikVQUxqOSUIYscqNyoXdiiiMdpyYowlHw,24 +onnx/backend/test/data/pytorch-operator/test_operator_permute2/model.onnx,sha256=0KrJH05LAsL-_L77wY67rTYcKl7O4C3YC7oTvPEHrTU,157 +onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/input_0.pb,sha256=L_NDecbs6B53f9DH3kVRb5Jg733mbzz1qLJi6ayQUSM,20 +onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/output_0.pb,sha256=L_NDecbs6B53f9DH3kVRb5Jg733mbzz1qLJi6ayQUSM,20 +onnx/backend/test/data/pytorch-operator/test_operator_pow/model.onnx,sha256=M7XNkUGAfZ5E2nkFjWW_7SXvK9UHb3JScOaCix8QuyE,143 +onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_1.pb,sha256=LQt-jviNzkk-G9vloxDlOGCy8KSCW7U63NTBwgns_D8,108 +onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/output_0.pb,sha256=XEN7AbFAM3Z4_8ItjckmF1DOvmIaQzPHLRWunkBESEM,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/model.onnx,sha256=O1IEJavHoDIP8kdZY1MemfLfvEabPS21oZ5woHqUWkA,144 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/output_0.pb,sha256=0GRusgT6llp9L4xRar3Wsx135lkRheHdk_yLjqPz6Z4,42 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/model.onnx,sha256=8acUiZ_yB2CvOmhE2V-LMPvKC35XfS-_B-jKPt7d3vo,148 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/output_0.pb,sha256=JT45FKL7fQp93nScOLNH5XVzpe5_LSd0JERoEk-ZbhQ,44 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/model.onnx,sha256=bUlOp9MQkbBdQJeZkj1agt-NtW6cKQtTatKD8OU_p98,143 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/output_0.pb,sha256=Utlni28fX3BXWdVXDcuLt0cu_ulgHjp_rgur3_lQyzY,42 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/model.onnx,sha256=L62_cXaEa-Cykw8LVM7XvGaKRbIdrBK4iamTWxh8OBg,147 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/output_0.pb,sha256=5MvToMGwW6pFTiCLuFJPxxkfYbFAg9-kwFeauYw4Mhc,44 +onnx/backend/test/data/pytorch-operator/test_operator_repeat/model.onnx,sha256=RQJOZuNAEdwW6PlCklxKlGhtZ22mF8kCpou8FAIlWyU,183 +onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/output_0.pb,sha256=-YlOKC1jEG5kWC86OwzjnWKFlazgBGUPbrz4wuOGNZc,2317 +onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/model.onnx,sha256=mIr4O3Jeff3HjNcLPtRgdNo8sqy3ij_EmRwtk0-_Lik,262 +onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/input_0.pb,sha256=PeeWjZl6s614QawpKlTzaa2M_qDKkuO8BBaz-qfk8ss,16 +onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/output_0.pb,sha256=fcp9lp_a0UFVqmJQjOurs65k3IERx-brNnyQREIxAN8,205 +onnx/backend/test/data/pytorch-operator/test_operator_selu/model.onnx,sha256=3mqKXDt5KwBID5o11HDtMyoILtWR14_9oPGtONyDuaw,112 +onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/output_0.pb,sha256=gd_7TvsfK6wzJF1ctWcoUAr7_EAii8eAr1Aw08qArU8,108 +onnx/backend/test/data/pytorch-operator/test_operator_sqrt/model.onnx,sha256=c-mj8KfwvSG6yoCZCL1RWVPC4YEsFq9m9H7UQ5_Yec8,96 +onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/output_0.pb,sha256=p3YSFtZwHoUIHrJqk7eOMcA7za5NaV97uor3259xh6I,56 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/model.onnx,sha256=TcukI5SQ2YCJEtjb6C-9S1Tpg93BRWVhmUJcLvQGyBk,291 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/input_0.pb,sha256=e1b3DFL0AWrzfrgYCD2Z_tmqUGzqz1XEfvLGynXik8Q,81934 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/output_0.pb,sha256=bqx1z2aK2tKWTHyU3O3EFn--0qeCgqvkwfZkm19C1WQ,81934 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/model.onnx,sha256=Y5HmWP09sqQ8D87KKCuNzacDAFTXvT9d2qrT1UQqCFs,188 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_0.pb,sha256=g4F_BI1dL9Zw7KRNa82h7qrc2ihraPzolEMraSI3Pq4,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_1.pb,sha256=RSc1IkqRdFLMBmDEQ7JzmC62gTBmianfJ-_9l05ev3E,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_2.pb,sha256=FmQxo2Hd_d2lkwKCgTubHR74fIGqSDeryUre8Zz2XbA,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_0.pb,sha256=3d2sF1KRdRHfCmRz_gE6aeW3U3FXdj6a5iJZ16GbqPE,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_1.pb,sha256=27DWRsqnvZq9m_3dBy-aOw_WF16XB0wQRmQTg3YFsqc,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_2.pb,sha256=YgmWdPXZb_anXNeasbA2AZ5vpd5tKBADxsOuwSBk6WM,10 +onnx/backend/test/data/pytorch-operator/test_operator_view/model.onnx,sha256=XT7TK6OPv6q7O3b3898MF0l2-r7_Y1qFG8C8TCGsM5s,108 +onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/input_0.pb,sha256=26QXjAPnTsE3QpqJjcP-PkSFVR-8imYTPkQwy9qdEpM,10 +onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/output_0.pb,sha256=hy5YLPPZ35Pu3PoQQVqGsxFpEvOOcTe127tUCiOf-yQ,12 +onnx/backend/test/data/real/test_bvlc_alexnet/data.json,sha256=gTz09RnRuoLoForPp-zduDCJNxfXByr-o62-4QpH7QQ,123 +onnx/backend/test/data/real/test_densenet121/data.json,sha256=K_awJig_u8V8iXzzvMGyKUB3tIfu-jv0NmknR4-10Es,121 +onnx/backend/test/data/real/test_inception_v1/data.json,sha256=ZWFpowuWI8N5Yy1aKLNhvNnXzNo5kmhpfandv4IMtiY,123 +onnx/backend/test/data/real/test_inception_v2/data.json,sha256=CyDIFBbTrRTiiuW9LVvLso_HtMLIbenVBR2qazMz6Ww,123 +onnx/backend/test/data/real/test_resnet50/data.json,sha256=4GWkjjl4-uCahU2h7NiwKZt33Expj2Pjk14N9tjuwSE,115 +onnx/backend/test/data/real/test_shufflenet/data.json,sha256=j-qHhpjQOfm6VTRw9joMZet2z1bt-7ziAhGUhtuoXag,119 +onnx/backend/test/data/real/test_squeezenet/data.json,sha256=Wc_Fxf5HPmehmoYP4UNckip3_Kk783zoO7U2xKecNH8,119 +onnx/backend/test/data/real/test_vgg19/data.json,sha256=zazHTUwGDFkcpUPTP95t_XZj5Xjozd40C19otzyuQo4,109 +onnx/backend/test/data/real/test_zfnet512/data.json,sha256=-uRgfrHvF6uF_KdVb01ehe6KexyoTLGZwKKkeJAY6hM,115 +onnx/backend/test/data/simple/test_expand_shape_model1/model.onnx,sha256=RjVogwevJIx-F_NCRrB78u3wz8J43liwi_4VXZ5zT3M,132 +onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_0.pb,sha256=FeacT0JWpRN8J4-0SXL6u5IFq8rqpzNiTg5j5-U39oU,25 +onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_1.pb,sha256=-kFoNUTrPOdcUABEXtz8Y0JvTYyaQKDWNoIlhldRde0,29 +onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/output_0.pb,sha256=Ory0VuIbWoxQQlFNuvfHKxsStsXUx98DHtV1L-0l_8E,25 +onnx/backend/test/data/simple/test_expand_shape_model2/model.onnx,sha256=8vMBfHTTsakvEYYAHRix0Rw5UlLLX2YLH_LHIauQ_dI,132 +onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_0.pb,sha256=FeacT0JWpRN8J4-0SXL6u5IFq8rqpzNiTg5j5-U39oU,25 +onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_1.pb,sha256=jtEjGRaQMY2aXanx5tzKSV1aQZqCMTz_eAe-NASuXvI,29 +onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/output_0.pb,sha256=Nfr-Y4hHMCx7RZd6zuGthvWOnTqq6B02AeKOTcNUibA,49 +onnx/backend/test/data/simple/test_expand_shape_model3/model.onnx,sha256=i2W7OvivVljkRuYyr7qgTJhoeMJ-DZaYTOYcE5ErhoM,132 +onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_0.pb,sha256=FeacT0JWpRN8J4-0SXL6u5IFq8rqpzNiTg5j5-U39oU,25 +onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_1.pb,sha256=90Jk8uu8W-Zk-IKoYDY1M9ynDidapdOgGlDsn-Nhzs0,37 +onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/output_0.pb,sha256=f3h1_JMnmSfaS5ve3NZ68hxYs9q56syzQIrZwBG4Yyc,121 +onnx/backend/test/data/simple/test_expand_shape_model4/model.onnx,sha256=-LCt6hxsHX6zj7BhYIcFVieavb3xJEOVhgysNc7Q_IM,136 +onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_0.pb,sha256=FeacT0JWpRN8J4-0SXL6u5IFq8rqpzNiTg5j5-U39oU,25 +onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_1.pb,sha256=TzuTXPf2kofUisXxxsPIjs9kGduOx7kUKo0GK6M0c1k,45 +onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/output_0.pb,sha256=-54z-uncN2E4Xp6GCo0JFdJ0Nvjgzlhr812uvk0Yrng,340 +onnx/backend/test/data/simple/test_gradient_of_add/model.onnx,sha256=hqxKd-FKyhCxjveUJXYk7AXEXvZHy0aKG0gf6AzYz78,264 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_0.pb,sha256=01kqGBPZb3rDpPA9T56CvZXs2yaYshAUG4N9Dnl25Mw,11 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_1.pb,sha256=fA_vLSZfxRw0E8uijMUP0AjksThofW6HfWZmZV2a59Y,11 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_0.pb,sha256=MoopEq7YvmlIiWp-ULnZQ7cgYLyeTTxqO1eqVNn9KQg,11 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_1.pb,sha256=Yo4qcMojcGk2JZPSRpcKSY_BWkbKcZoRuC-nT5OlCZM,15 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_2.pb,sha256=1xx1amq9P1-dPK30tNpnEdNn-SduOremceOw8uW8C3k,15 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/model.onnx,sha256=WNxpfuoymu3Q1SkrssVQABq55ea3GoCcGWxi7aSMHJc,297 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_0.pb,sha256=01kqGBPZb3rDpPA9T56CvZXs2yaYshAUG4N9Dnl25Mw,11 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_1.pb,sha256=fA_vLSZfxRw0E8uijMUP0AjksThofW6HfWZmZV2a59Y,11 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_0.pb,sha256=k_SlcYexZAOt4fP6X2ghd-7chiUMXOoyvCJveI3MTWc,11 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_1.pb,sha256=ZIUr0lNQxoOvyIvdFjkKNk_x10J0_El2BKhC1VO5Cqs,15 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_2.pb,sha256=nXyZvmlusCjPtriTAgchwXnlwHF4hAOFbPqA8wzz1Pk,15 +onnx/backend/test/data/simple/test_sequence_model1/model.onnx,sha256=5xFFoohE76wt8FmPC5aobMCnys9ZAbNtZXwJ1yB1zhk,371 +onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_1.pb,sha256=acWUJJJkjaegHyWZXk1TzmUv7Pj2A6Fj4Kau-LD68wQ,61 +onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_2.pb,sha256=8jc-ymVjyW4wPnnIHhZ5_BKaWy8WOsqrAa_mbJrRnaI,158 +onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/output_0.pb,sha256=7mBt-bM7EukBGQzUvqoyxL934b2LrCkDx_I3-PAaWZY,63 +onnx/backend/test/data/simple/test_sequence_model2/model.onnx,sha256=KZzZBGV-tDv_bkWo2KOjixr8YKbHXS_ornwssdPPpjY,322 +onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_1.pb,sha256=QYuDQFaYJk_vZOlJvOrFihGNRwYhQIvxW59i_dDFavA,109 +onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_2.pb,sha256=6yIT4GU0ai5jfrrMWxDYlnRCzdydqQHvj9AmzXn0aqg,109 +onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/output_0.pb,sha256=0VfhqZDCxkMww3kF8CHMsdPQ2ae6_3HHrWGfUUUhcxs,111 +onnx/backend/test/data/simple/test_sequence_model3/model.onnx,sha256=J9qvj7WaYXTfJJWbwlaOZq7uCSY1emnWv8Ot4bVzVmg,437 +onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_1.pb,sha256=QYuDQFaYJk_vZOlJvOrFihGNRwYhQIvxW59i_dDFavA,109 +onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_2.pb,sha256=6yIT4GU0ai5jfrrMWxDYlnRCzdydqQHvj9AmzXn0aqg,109 +onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/output_0.pb,sha256=0VfhqZDCxkMww3kF8CHMsdPQ2ae6_3HHrWGfUUUhcxs,111 +onnx/backend/test/data/simple/test_sequence_model4/model.onnx,sha256=1dZ8RAqL2C4M5qt2anAFL0XkW4q73_krGrOB-vR0IeA,219 +onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_1.pb,sha256=QYuDQFaYJk_vZOlJvOrFihGNRwYhQIvxW59i_dDFavA,109 +onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_2.pb,sha256=6yIT4GU0ai5jfrrMWxDYlnRCzdydqQHvj9AmzXn0aqg,109 +onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/output_0.pb,sha256=xn5AGPzsNiwU7zvOGMww3GK0K6mjZFeyctuICJDD_jk,304 +onnx/backend/test/data/simple/test_sequence_model5/model.onnx,sha256=1YqWf-J8logBWGMQl9wYHslyJeozA19o3ULV3gFrIeU,251 +onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_1.pb,sha256=QYuDQFaYJk_vZOlJvOrFihGNRwYhQIvxW59i_dDFavA,109 +onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_2.pb,sha256=6yIT4GU0ai5jfrrMWxDYlnRCzdydqQHvj9AmzXn0aqg,109 +onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/output_0.pb,sha256=M0bT0Bi-MmK76q7g_NGHZBGtBqCIRkOEHbZwQxOMS4M,306 +onnx/backend/test/data/simple/test_sequence_model6/model.onnx,sha256=JANoYkvy3KHwu0OQp7_JOebk2uyywXnF1kOhAh8v-A8,156 +onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/output_0.pb,sha256=WQhbsdsmsmPRHbpqfZ2MiS0DAKfdf-5atRiJ3PQSa8I,17 +onnx/backend/test/data/simple/test_sequence_model7/model.onnx,sha256=8W0ICmPH4I-RbyPg1sUAqS8g80VjI3b1w6KwX8LSthI,209 +onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/input_0.pb,sha256=iDb2BEF6r1s_Ivm2lami2Cd5mumrAH-iCufdqTWZtVg,206 +onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/output_0.pb,sha256=hRDk49zUKK-zx6kVhCyPbUW8GAbH2oHne4UBEZ-abPk,109 +onnx/backend/test/data/simple/test_sequence_model8/model.onnx,sha256=uRG-4PlDM24-SF0xEMigmVnRe_eTopTh5iPwAmRJngA,157 +onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_0.pb,sha256=MnclcMUBN86XdRdCIhDbiw8iXBNVY9m2zmyFUnlMLM8,9 +onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_1.pb,sha256=7EJgBev8JC7V0Rw_gwYv6p__Wn6ntHoisPgOXmLl680,38 +onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/output_0.pb,sha256=XQxLMlrcsgBaXyWLm5m5QW1Ph1e1xB8VoLsTnp-G9TI,17 +onnx/backend/test/data/simple/test_shrink/model.onnx,sha256=w20edVDLuFYRyg_mTFTeX28fDIvf5Eu2DkfmX0nVGzA,115 +onnx/backend/test/data/simple/test_shrink/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/simple/test_shrink/test_data_set_0/output_0.pb,sha256=AbQplXJ5FVu2LaNzGC0t3G9EZhZUCsd-_fnyXRD9T2I,29 +onnx/backend/test/data/simple/test_sign_model/model.onnx,sha256=x-DuU3N-mIY90B4uRxuhogKFVZq8nHXxJrFs5i-fDKQ,90 +onnx/backend/test/data/simple/test_sign_model/test_data_set_0/input_0.pb,sha256=OYoPx6Ht6FXdfpszUznfOHcHY34rscU83vgklJlGV_A,37 +onnx/backend/test/data/simple/test_sign_model/test_data_set_0/output_0.pb,sha256=CeKwUlQI9tHyyzENPyq43v-DgnaQhzqRFwnITipA7SY,37 +onnx/backend/test/data/simple/test_single_relu_model/model.onnx,sha256=81t2jgdqDN2px9zzoPPsu4STlrL3Ff1ELHcFx9H7Rzs,98 +onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/input_0.pb,sha256=z3PIwDv5elbsTylVjEIm6kzqZADwyn7wXFOKazkGPDo,19 +onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/output_0.pb,sha256=o_KNVxD7Z64gu7M_8ZB2SD7cbjBQg7ZcTid0oZk_lcA,19 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/model.onnx,sha256=YEJ4VUhWCA58OTuF7rc5CYazSwyDvm_hdNZhSJRSOsE,185 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/output_0.pb,sha256=_-mGRZ7G9I9iAx2P9lMk3aHUawP2XKjO9hn2fpR6tpY,37 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/model.onnx,sha256=chr1nCThp6Y4V52zC2WrTWUJ0GZJIJKCOJQTB6qruiA,153 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb,sha256=_-mGRZ7G9I9iAx2P9lMk3aHUawP2XKjO9hn2fpR6tpY,37 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/model.onnx,sha256=mTkMdQL9kKyFg-wXrRGcGZjp_JkEwLZB-Wv4bTteV2Y,185 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/output_0.pb,sha256=7Zk-IeCaqHCfs5Z1zqHp5ERKMABu8eMRVVYNTMLdFc4,37 +onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/model.onnx,sha256=7rQjPSYfgK49i9NXSP1wZbZjsKKaHQcuyaZXlfxblJA,185 +onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/input_0.pb,sha256=XGok6pzumeWYmW61YcE2gO49FZP4HhO5L7VQiaofooQ,23 +onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/output_0.pb,sha256=fve41mqTI11I7kUof7Bey6Rtk7Sv23j8xV9xaJLPzQ0,9 +onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/model.onnx,sha256=oA_EVTNecnOU1ep5n9OYERU5iqhaEXY7JhmSQE6ycDs,167 +onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb,sha256=5_crR6dG0l6PE3Zf0m0C1WePv2dsKuUUSeSBHD4-fx8,65 +onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb,sha256=etP-R5bCcemRt-RrzQK7MPjXOQwqbEBeZCcYma1Jb7M,49 +onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/model.onnx,sha256=bVmnHtYfTVDT2Dvx84KyrtEWEatTU3SfnlPGXDSGhGw,128 +onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/input_0.pb,sha256=uBHq4M-aleAVs_ZnyQty-Yz85ya7wK6Dp7RjXk0bUZw,24 +onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/output_0.pb,sha256=NhjGWjPVxmkR0f35ghfx6YQm3Is2Eue9LWCC-NaQqQY,24 +onnx/backend/test/loader/__init__.py,sha256=dJ0LSXgNfa67eAj-alBHE1C37YBAKLe8LB5852bJrpI,2078 +onnx/backend/test/report/__init__.py,sha256=cQbaLA-tVoUX63udmCoBB2DjA9MLDtx_KAXhh-ck47Q,1321 +onnx/backend/test/report/base.py,sha256=QSV2HAnus4jLv4cg9_6SEZ9YAcUJNAmNr65NCE9CDhM,147 +onnx/backend/test/report/coverage.py,sha256=ezxpVzMInB1M3lEfCLf6mc4JWhMUF1vkGBHIGqyTCzk,10942 +onnx/backend/test/runner/__init__.py,sha256=Vltff85lh3ky1fUpPuc9-v_e-Czt7qymRgNN6EhQC3c,21378 +onnx/backend/test/runner/item.py,sha256=PFacqyBet1zqbYJRwrIrgS64-sR6scf1-boAZq1A7YE,484 +onnx/bin/__init__.py,sha256=x6thC2ykdnq7G6hJ-ENaxiRV3WfttWPcBYskup5sjig,82 +onnx/bin/checker.py,sha256=Ic8G66MvA7mcH6iH9fR9Wi6OGG55fJiMY9EOGvkfA2M,693 +onnx/common/array_ref.h,sha256=a9qSAoXuLbWNZ8LiS8MdXeGfieLJd7bolDC-ZB4C4XY,5940 +onnx/common/assertions.cc,sha256=4Qy2xsMU24hqgUozuHQo9if0BMGuCDA-3cn8CGE0c8U,1419 +onnx/common/assertions.h,sha256=ZRlnglgABsEPBSfMimZ20VrFIaJRBvCDAYolMUxtAzY,3062 +onnx/common/common.h,sha256=BKtVTywGLcEhH1ESXLIMlKxE2c_Iu5tqalUFwbHAb6M,1736 +onnx/common/constants.h,sha256=0BHv7vi-gxKpirC3x3awTvknTcB6hnk4JyfMEn0XLN0,1552 +onnx/common/file_utils.h,sha256=BloauvYhc7hUxVRCs-cQGYbhVlmEFGmb7QE21wTbmCM,1210 +onnx/common/graph_node_list.h,sha256=BWg5hvq3X8J_PC9Te86dVJjl-X2sIn-QAjyNL6U5KiM,5511 +onnx/common/interned_strings.cc,sha256=RNGhLGwPLdfHoPvPXITaUv1S3JrR29a8Ty6h1pQF4rg,2015 +onnx/common/interned_strings.h,sha256=aNER1v_GzAjbg15mfwAjSRPRrwGcPusjTcGvVpD0A50,8629 +onnx/common/ir.h,sha256=nmyxu8lLb45hH8geId5rcdZ7ikXxMigRN-dOYHhqIho,43727 +onnx/common/ir_pb_converter.cc,sha256=17m6W0CvcwTp71DQEqIPa__1SRgwP2OPJ6vpCaV7uls,26514 +onnx/common/ir_pb_converter.h,sha256=Ut2pNchytw7GP9sr0XeqZmpGcvmWhidGI1sJqSxoTf0,1283 +onnx/common/model_helpers.cc,sha256=KaCTJwc9FoUcWhbUuC4IPhjBK6wl7yDm698YUsuqnJo,953 +onnx/common/model_helpers.h,sha256=cQl2dPhD5HTc019-0ppJqeBe-v9oE_4B2fduz_x1tAE,635 +onnx/common/path.h,sha256=GAzBlVPoZrg45c31k5InUXiSbYc2-Z3OJkkvP_IPj4k,2748 +onnx/common/platform_helpers.h,sha256=Zqiw-1q4SFsXRXkoJiPvQo6vfnhaUgYVPBtaIY_olFA,378 +onnx/common/proto_util.h,sha256=3O_sXC6D7mn1dkhDtS_n6Ys4FzBbtlaiywavH-KNfm4,1446 +onnx/common/safe_math.h,sha256=aOqZdSS6neixXUHFjbakSF6DRAjjZEG2jJ-5tbu-2ts,2557 +onnx/common/scoped_resource.h,sha256=GecOuYJxF8G-Hq2zkKxmtp5ACJ22xTI20dczpSnVXSI,1862 +onnx/common/status.cc,sha256=ZRUKJHSbWv0gbhpj0p2WxsHc7oM5LDwodh_tAitn0Kk,1960 +onnx/common/status.h,sha256=9OInqyEtqdiIO3BIDvDhtOGm8kje1J1aANtjMQm3xbs,2128 +onnx/common/tensor.h,sha256=wR3t47Vajeusvc6wH_YGG5hvu4FiQW43r5_uVul05pU,6101 +onnx/common/version.h.in,sha256=sXJKi2Sa2NOcOJ4ahrQOcqen2erzbIX9tIHuq2g2hbA,656 +onnx/common/visitor.h,sha256=HrN1j5FO52P0Nj39_BZFfZZq1jrot2xy2tBu-2ZUM5Q,2951 +onnx/defs/__init__.py,sha256=O8NbaREHzqJBzKnOfdOALLIXeNlezqnzH4ipi15UBRM,4569 +onnx/defs/attr_proto_util.cc,sha256=BCHzyMEywtKYdO9lq66T9ay_IukBEoV-9dPnCgdE510,3461 +onnx/defs/attr_proto_util.h,sha256=sbTVvV0dAPbKt2JflsvyD1cgLz5ATD3yqi2buk22CVA,2090 +onnx/defs/data_propagators.h,sha256=MBAPHN_sCSAwVxNChk2TdpkMBUdIwspQlK0mmOKqJG0,2542 +onnx/defs/data_type_utils.cc,sha256=cyE45GDCUpH4XQermIUTd_CqMnN0Kqo_w6Ft-RPZf0I,13331 +onnx/defs/data_type_utils.h,sha256=Ca5Gz9tTog49QapVufpGEaPC0uQzQ7mzJNo7tkH0NiU,2462 +onnx/defs/doc_strings.cc,sha256=KgCZpFVnZZ-T1zFyR4wtmnnoxbjWxtUGqj3hrv9K8u0,56798 +onnx/defs/doc_strings.h,sha256=V1X_M9dzvekY25rptl4obrfqE5mRP4jlLR5-WOVK4xk,3251 +onnx/defs/function.cc,sha256=GS6K5JZiVijm6_4ynu6vcMtYJ0OAluCBaQ2vZVS1jw0,6955 +onnx/defs/function.h,sha256=3l7Y2yZak7l2U3-zHdEM8zwW06VHmuV2eo8LHZL5VHk,8494 +onnx/defs/gen_doc.py,sha256=CfslSZpC2sySNPNxDa57yFFzeV16f0nXwfiqewJGReI,17078 +onnx/defs/gen_shape_inference_information.py,sha256=3XNt_AE_4rhu-ZW_xQRXOk4truC0UOCyKFSvp2B-7gc,875 +onnx/defs/operator_sets.h,sha256=G3nyQc2l5plJAtO7tpm3saOutx9EbhktjMLpYNWGbyE,97460 +onnx/defs/operator_sets_ml.h,sha256=DgHctlhyiAsA62GfNNImKonn7n-QOdZkuT3_uVts-Sg,5114 +onnx/defs/operator_sets_preview.h,sha256=Mj7jzkSbY6GNuCO1FPrTCUP1YRHB2_GMH98PQgwjuBU,1445 +onnx/defs/operator_sets_training.h,sha256=IO_yjxfHWqtqP8W6Khd-ahlWQ7gFiHNU9ruhNVf0k6E,549 +onnx/defs/parser.cc,sha256=wEro0oh9L-Ak7mCFgzwzkxWJoSKVfTy30wN6-DyZ7Is,30516 +onnx/defs/parser.h,sha256=-Vi0nUFV0ehv5ryj_-CRYZsgsRkng8TVpc9ZA5ZI7VA,14865 +onnx/defs/printer.cc,sha256=UrF9Vv-LXRiL-0qtZRq4PMxpeAqinGk0pqgTSmfYYLI,14804 +onnx/defs/printer.h,sha256=UJMlhWxWmVMNhc90kMyNMb5C9B0_yohqQ-Kd-4htb3Q,1424 +onnx/defs/schema.cc,sha256=AAHKim651vAaGIVlaTm-5_YNdIREX03-OFxdJkv49h4,65850 +onnx/defs/schema.h,sha256=mryLXy733tAL4s91JZZOfrx39oqz_gd6SlHO_3-yynw,55567 +onnx/defs/shape_inference.cc,sha256=ltvWN-oZORVrb0p0FdaHVftcB4AZSagDBFRowify5XY,24641 +onnx/defs/shape_inference.h,sha256=Z-iY8ZrVeWHu2QPHT_zm6XIiRBL_g7ebkjnDav3CLRo,39269 +onnx/defs/tensor_proto_util.cc,sha256=ZUFa-i7ShEd6O8-W6UAiAe7rYluRUHGZ749yVhbKEP4,13501 +onnx/defs/tensor_proto_util.h,sha256=wZFKxTgxNr6jrfpDKWOlTsHTZTkjiuz-Qa3fAy_4oD0,439 +onnx/defs/tensor_util.cc,sha256=qoASkpx9OAgpbfpI4zORj9mdsWia0zD105hBc_L6neA,3488 +onnx/defs/tensor_util.h,sha256=7r5thPet2JhDA8Odv2zGbNgz3KCeMmlKFIzMsgTi7SY,281 +onnx/defs/type_builders.h,sha256=IjVfAIK7QdslkkDZQL7XHTAuSDaRfVcg5pUrIXYFja0,4893 +onnx/defs/controlflow/defs.cc,sha256=6UGb4fiAJD3mvWVjseOes5mAt3CaVrLXHRJgY-7YbXA,8560 +onnx/defs/controlflow/old.cc,sha256=MqoAa7euDk2_y_VGxDfzYx0UCW8szyReCXPaA71lVQ8,115702 +onnx/defs/controlflow/utils.cc,sha256=sEPwJvQqFYZNtYhvm4MKngyqIRRqh7uXR3ouAz-V380,13579 +onnx/defs/controlflow/utils.h,sha256=cEsTNV0a-m-9CFmmVIHVqXjAVUPaMDNMjGNTWmqOxaA,486 +onnx/defs/generator/defs.cc,sha256=TAtpctWTPTL2n71cP-UCqoRTpM9_tj37nGH3uU3-LY8,24363 +onnx/defs/generator/old.cc,sha256=DTsoyg5B8Uqw7Ed6SAX43oQUJW-DoF33HU7RmRxs990,44293 +onnx/defs/generator/utils.cc,sha256=p2pPLRg5RYvRkxNdxeaNT1rcFxZWgPvItM-Kwpn7CbM,3764 +onnx/defs/generator/utils.h,sha256=pBPJGvbGmCzEWnP3mPytexk2h0eT-_pWd-S-Eg2I3_s,950 +onnx/defs/image/defs.cc,sha256=rtRiAqB2W1eoWWFF0qFWJMmev45uZDC_9lZ1ZQeHs_E,2760 +onnx/defs/logical/defs.cc,sha256=hjg8ySjqtZ3vv5q4NBi4zjqkBKmEpmHndjwnlBgbGgk,11778 +onnx/defs/logical/old.cc,sha256=NotXy6PrKIgSmFGG9vB0BBzyw5Fse6rsUwv_lshKFxo,9765 +onnx/defs/math/defs.cc,sha256=OWFAPRZ3lHZEJZ9TTppN8hqI5dYPVa567XoEe6nrGQI,127764 +onnx/defs/math/old.cc,sha256=pjmPRAl9-ORaJe0YyuHJjNQgKlL994ERipZxW9wQxJE,146967 +onnx/defs/math/utils.cc,sha256=QvHn7SElV33YQonRxYZ6zLWc4_grD9PSjultyz9-9Qg,11479 +onnx/defs/math/utils.h,sha256=BBOtxOM7s1oGGGsGbK8y3nOo2VGhubI0UYXJucPjZFo,1847 +onnx/defs/nn/defs.cc,sha256=QaeHN_1qg4fgOGdzhZwtKQpszQSJJvSVTVkvktES0D0,221688 +onnx/defs/nn/old.cc,sha256=LcBKiS86QBMpmQT1KothwW00GqkipJSclgp5dx2Jy7g,197226 +onnx/defs/nn/utils.cc,sha256=j3lhgHoSTV8c8TVbHbBWDjQXRuzaO7YNrkYLSvVFAv8,10538 +onnx/defs/nn/utils.h,sha256=Zibw-r5oXkRjr10pcy980gt8HLzZYg_ULIO4ggTH5j0,941 +onnx/defs/object_detection/defs.cc,sha256=2ALoRLnJbDxh843UH2gG_fOEvlM_nURwEb-DB42IhN0,7952 +onnx/defs/object_detection/old.cc,sha256=5HuD9Sve-sW5UeMwwQXjcLKEqjZr_ytSpVIRkhh7m5E,11287 +onnx/defs/optional/defs.cc,sha256=hsD4Mle_oJSbbnMQEjcK3NFwzlaVLnOMzNtn1EcjpEc,6581 +onnx/defs/optional/old.cc,sha256=6HwucuuW4eGWZs6lg7HPL7OlxYPa6je3NHyywmoI2XU,3432 +onnx/defs/preview/defs.cc,sha256=dgUPJ_nl7azGVpb6nhDTeyU-dg204Q0jbJ_TicTa3tk,21046 +onnx/defs/quantization/defs.cc,sha256=OMh2DzvCY-8CZ1_XEJycH9arIBUbN9YKF22S73NJ6rM,14418 +onnx/defs/quantization/old.cc,sha256=CndDH368VFAR7-s0LA_kjy8wgPSecOThEfmkayQmuOo,44889 +onnx/defs/reduction/defs.cc,sha256=6NIO7-1PcToQ2Y_9Vc2G-dX1tH1qdK2QHe1n2j_htOU,6470 +onnx/defs/reduction/old.cc,sha256=rPkb_-ryIx9vBkDlg6vxN_XbmjYhQ5Ose-Hof2K3iJY,19213 +onnx/defs/reduction/utils.cc,sha256=vrVggz4KVZSpYtHsumz9GPQTeYzKqWYqCcZW3heaVFw,6878 +onnx/defs/reduction/utils.h,sha256=mMNxCgdfw5kRydrAsnrVQF8UJXJUVJJGlK538nSIljc,1565 +onnx/defs/rnn/defs.cc,sha256=Bz_Slt1T1p9GK616JWTFkJRz7iO6zteaSGKuhgACuqM,14229 +onnx/defs/rnn/old.cc,sha256=gSegq9T5-Qnd4qdLr-_mdSOAqYpOx1c-GozqsS1UTW4,51713 +onnx/defs/sequence/defs.cc,sha256=hwDawGPFGbpXTfgTe_VWAeuZR4CkmHJVM56ncPeR9qM,26960 +onnx/defs/sequence/old.cc,sha256=8IFey3ziuplIJuUhvL7bASIpAl9G6AuA4eftvumhNkM,450 +onnx/defs/sequence/utils.cc,sha256=AUJOaqTXZnCymYW8r6Wsfo1gpefbXqooVsE6PwSUHU8,8361 +onnx/defs/sequence/utils.h,sha256=Dt3CpH7YPdV3QNqa4LkaXdQBbpENxDp1h2V25D65m_4,580 +onnx/defs/tensor/defs.cc,sha256=QWeXwxj_doMSFxMIrxuLhoiL4s1fWCar1OJk4T4vmM0,163298 +onnx/defs/tensor/old.cc,sha256=nq4PIxb6C4LTnYifd6MtcRHgHmWNLQ1l7I0x8J6eMwY,339221 +onnx/defs/tensor/utils.cc,sha256=GLaA_0VXqAuTiKtCwkGCihUhpstWIU-n-zCAgtvZc94,19116 +onnx/defs/tensor/utils.h,sha256=iDRMnnuMGdCX6r_0fSPO8qoq4szLlzpoOECvzBkNIrc,1848 +onnx/defs/text/defs.cc,sha256=uo1aaFIHDoH1eFgdFN6dv01WS6VwYyDGKiQpyXKh5qA,10463 +onnx/defs/traditionalml/defs.cc,sha256=T7KKC5kP54ORx4l_G79ZZjulyldLB3BDpbLE6N6CA_Y,63483 +onnx/defs/traditionalml/old.cc,sha256=tYc4_zNSCUAAFQZ1J0hVA4mWiIEFlktz8IGQyxxuvLg,33944 +onnx/defs/traditionalml/utils.h,sha256=-BwdYzfDKTs2-8ucxelYDbUYCKuFHOV10KhiruHj9mE,1020 +onnx/defs/training/defs.cc,sha256=aA-w0wcOZsZEXtetnEJ_2CJlSSVT9MOg5MWeFrWw0Ks,27876 +onnx/frontend/__init__.py,sha256=x6thC2ykdnq7G6hJ-ENaxiRV3WfttWPcBYskup5sjig,82 +onnx/inliner/inliner.cc,sha256=nxqh74rH3WEhKc1WRtihQbUwCrRzPYYE5Guq9jlb9LQ,27543 +onnx/inliner/inliner.h,sha256=qGI_x9J8x7Do23CcHq7HbF74COjUaU9gG2nHlgioLxk,5602 +onnx/onnx_cpp2py_export/__init__.pyi,sha256=iUJ8dr7hXw7q2N5DaSF-zEeLPwtqLP6mYkOMcswG-Dc,162 +onnx/onnx_cpp2py_export/checker.pyi,sha256=xv43-LA98FvA07q1zlxiTSg_cmqXD034GWaTX_XRoyI,1521 +onnx/onnx_cpp2py_export/defs.pyi,sha256=z2p68mZthl1J7ljjFaU9eqDP0Ymrw2133DG6HYwzGSY,7145 +onnx/onnx_cpp2py_export/inliner.pyi,sha256=XVe-Ehy73OgP2IR3R2mjxL7AP8qdOD-PyI1yUJDW-NE,1147 +onnx/onnx_cpp2py_export/parser.pyi,sha256=cIOlWZLLexO0W5PJHhdwdn6rcCrOfOVqgg9WPll86tc,1165 +onnx/onnx_cpp2py_export/printer.pyi,sha256=6eCH9YQx8njCKgjps5W9rIrxQfMNA23vq78Chu6QCwU,248 +onnx/onnx_cpp2py_export/shape_inference.pyi,sha256=8TkxH9cFK490I1R4Ni6r-iUe6cKV2vwOdJRgYiM694o,1483 +onnx/onnx_cpp2py_export/version_converter.pyi,sha256=jrdnCkaNbBZIZ9owKvwtzWHeeXJ1WToUPyIadljXnq0,163 +onnx/reference/__init__.py,sha256=oNpkJjFs4NfK9hr2Aaz0Z_Lc5hen2gfvrUKJbhw6uCU,218 +onnx/reference/op_run.py,sha256=2-b0Myf2k5bSfUixIfVDYfVdnqZ7eTzBITFO47o4n70,25409 +onnx/reference/reference_evaluator.py,sha256=BUitIVcI3Wah_fHiOnbRZ_TPVFA62Vuy8Z_pDjnoZmo,24519 +onnx/reference/ops/__init__.py,sha256=0-sY1CwYqagh6sp-Z0C8oeHTh-n1sD5tVYGi1d2tydo,189 +onnx/reference/ops/_helpers.py,sha256=W1iCRvkRgb4uqce5MFVJOm0Iqk_FtvFHt7fC9YeGtZ0,2139 +onnx/reference/ops/_op.py,sha256=X2aC75XzLUbo-OAaR6GIZ_k450GaYVOEJvDDyj6IiWU,6219 +onnx/reference/ops/_op_common_indices.py,sha256=ODagwINe0uUS1JWv9k8ehbW5AjygOapqZa0SG3G3Deo,746 +onnx/reference/ops/_op_common_pool.py,sha256=4fTVClKiYiw_bloFkD9sPfEcqef-Uj0lyv8RtDmMusQ,10283 +onnx/reference/ops/_op_common_random.py,sha256=toh7k6lkt0_4veouEB4iDYOrNO-HsCewsZGD1ETnngk,1771 +onnx/reference/ops/_op_common_window.py,sha256=o_g8DfOZYrcTOQ959kI8U61dYtFa63SJOA6i0pQnKFQ,750 +onnx/reference/ops/_op_list.py,sha256=bFnXLLM90AzJ4o-1eeSAFOUQeuBgkX5GpWMqrIPut-A,21544 +onnx/reference/ops/_quant_utils.py,sha256=Kfbeczzzie1T2qDk3o08vtekunbdQ-eS9mnnTrHBqLg,1907 +onnx/reference/ops/op_abs.py,sha256=Eil57XbL_MLPvRe-2LpPo3_fF5F_99GHFXBEakWhxBM,270 +onnx/reference/ops/op_acos.py,sha256=IDeRm43mhUs82hdH6qowj2-6MHiXDVb4Infx07JRoS0,269 +onnx/reference/ops/op_acosh.py,sha256=EKoBK9LDBLQuz9XStGkW20cDSiUpPeY822vLSEdswmE,271 +onnx/reference/ops/op_add.py,sha256=8DhhNOooLZN-iHPW8wlYOIfXIyD84eOawhuZDVfu70o,338 +onnx/reference/ops/op_affine_grid.py,sha256=vYbxsd-0gujRllY0CSHpElj5JZ6gr-LDTh9OqYwM_3s,3490 +onnx/reference/ops/op_and.py,sha256=oKTYScR6nslm9-0Ogrvj7TlKoF2ien8uTFoUmmvxB2I,275 +onnx/reference/ops/op_argmax.py,sha256=Ww_QzIO_ujgZHexHiJN848Dm-2dDrrEXG7jH9TXI3Kg,1182 +onnx/reference/ops/op_argmin.py,sha256=aMPnsMc6oacwsIzGzxdcuvg2s4Xmdcr0HJ4kvwqxh6I,1182 +onnx/reference/ops/op_asin.py,sha256=LZ-kUWRE68H0wECDuiAGjmZhMnfbUOVPYjf2KuL9xsE,269 +onnx/reference/ops/op_asinh.py,sha256=9mlAoJP8qMRXyxzdj4iZj-iGZk-xRmqjCplgELwjasI,271 +onnx/reference/ops/op_atan.py,sha256=-yhgljvDsfbwTEb1zAvxLLx-6DpcJvinTVD1GGqJD04,269 +onnx/reference/ops/op_atanh.py,sha256=3pfKoeUs4NMV0d7W9iK0FKeZQowdtc_gRK_sX_aHmrw,271 +onnx/reference/ops/op_attention.py,sha256=SljVL08VGyiY_5dXsMAoY1AcD7XxK7VR7BCQA5vRh4k,9988 +onnx/reference/ops/op_attribute_has_value.py,sha256=uKWh0zxddrMFtDwRAR1PbJxonVOEmw2mtaUSGwo-KCo,1084 +onnx/reference/ops/op_average_pool.py,sha256=W0f_VpF-QxO2OgZtvYfCpZhS6PDn1lR83a6p0nBD40Y,2349 +onnx/reference/ops/op_batch_normalization.py,sha256=5eVUDjIxRo1tRojeiiYzaA2Ezdj6Tc9l9osXZPYcLjo,3018 +onnx/reference/ops/op_bernoulli.py,sha256=l8PwHWdzN_43rwteBLiCefbp6zJYnJwxA30nL6YrYYY,576 +onnx/reference/ops/op_bitcast.py,sha256=JxR8vRrPuu0sMByHaZvHmmijbX9inpVLc4uVCEbEdKg,957 +onnx/reference/ops/op_bitshift.py,sha256=2gbipM_6dZt-elI7y_F3zmtfnzdgYW0MSm0E2FQ3glQ,569 +onnx/reference/ops/op_bitwise_and.py,sha256=p2u3HVCH-WqJxWsL_ffOVDp9OmByvn0eh7C1Pmf2bCY,282 +onnx/reference/ops/op_bitwise_not.py,sha256=OFea5olQtjWGdhmDv-UuI1I2oeuV4NVxwYkSj8CESdI,274 +onnx/reference/ops/op_bitwise_or.py,sha256=bEO5_ahr7M-KKSF_NYPCKYvPLVjf0eDmj8SGg3vPT48,280 +onnx/reference/ops/op_bitwise_xor.py,sha256=wCzrxEJRrXP7F6vdpQ2xmth9W0DVcikXfVNi9y2l89E,282 +onnx/reference/ops/op_blackman_window.py,sha256=ZNgapjkWi_bXtwpqBeIQn_9fyXgZrAVyltXxagpKsPs,945 +onnx/reference/ops/op_cast.py,sha256=ZWhC9tvzoeo8fx7CaW0rcRVaPSAMD9aC1AxLuZvi6nk,1417 +onnx/reference/ops/op_cast_like.py,sha256=Y7GYp0qzzQ12y0Agyhhb7-E9BxF3N7NPv03ccpzPtE4,679 +onnx/reference/ops/op_causal_conv_with_state.py,sha256=BLMBtqPTJUTkpljnsgPUAJ0VqzKYczdq_7GavJHToFc,2163 +onnx/reference/ops/op_ceil.py,sha256=MSoQT6VNbu8D0kurI7-UgIvKyDexJXnikF1Oz8Wihs0,267 +onnx/reference/ops/op_celu.py,sha256=peJZUI3ykHivolIn6pHyAxMSXkNOw9XbZgsI_51guks,498 +onnx/reference/ops/op_center_crop_pad.py,sha256=ScAqHv0Xr-6vEQP-7WrulJAFEZQWqzwaC4nlJPLwGjU,1626 +onnx/reference/ops/op_clip.py,sha256=MEL4nUTHasJYUX0MkeY9d5CMwHtVaGLa9l7dPD51XV0,806 +onnx/reference/ops/op_col2im.py,sha256=jZLCLbn-W0YGnn6okqFXUIJi3A4n5X61XkkaRsN7EKA,7976 +onnx/reference/ops/op_compress.py,sha256=dK6C48B388oIS5F2vYoB4Gi1qARLrb7E_ljVUYoQAZY,302 +onnx/reference/ops/op_concat.py,sha256=5f-O2sBtL8vIeyw86EBsdF9plKfeNztW6q2wWRHSA-g,682 +onnx/reference/ops/op_concat_from_sequence.py,sha256=rfpnvMSLikVcQ0g3IkuoC0O6NKxikxMnqWxXK_C58ac,887 +onnx/reference/ops/op_constant.py,sha256=_gLZ9nuU3LAEVr9hjWzoJstPdI0vkjjowVl-SzKqiQY,4332 +onnx/reference/ops/op_constant_of_shape.py,sha256=BdmfbrmVv4xkg_4-ccdl2oBocqPeYxa8hsKB5XDlPH0,951 +onnx/reference/ops/op_conv.py,sha256=XYTNQGLFqNkIk4Ls-v-3WzCWsK1UVEE2cCCUF2dGw1g,13111 +onnx/reference/ops/op_conv_integer.py,sha256=3e51GEGtLuoPAlRxZ1iPnUysRWN1nLMzrYrMDAmm4vo,1436 +onnx/reference/ops/op_conv_transpose.py,sha256=RR3yJW5i-6Eo2VhshV1vHe7BggyDihHdyMlLtXiv7PQ,5166 +onnx/reference/ops/op_cos.py,sha256=ryzeA7_daFCD1DayWa04i-bWTeqog90-wE1FOnZn7mw,265 +onnx/reference/ops/op_cosh.py,sha256=uToBDKjKx6SLH7ZcsFNcS1nXWc_U34yoYAcQlxASrhM,267 +onnx/reference/ops/op_cum_prod.py,sha256=piCxxUzpJyAb9NmAuuZZ2t5zOS5hVpE8vxNuzG3PlRc,1087 +onnx/reference/ops/op_cum_sum.py,sha256=sjnrdqgUNn9NdwofmeNDdGj5vbv0jzGRIoqiuW1qNHg,1085 +onnx/reference/ops/op_deform_conv.py,sha256=UaVX69mOOAsA7X9Wb8ywn83WZg-TV1WVByyoCgQPBP4,6291 +onnx/reference/ops/op_depth_to_space.py,sha256=ahzWqiXxVPga1Ja1hjKeq-KTiZHEsfVZ6ERasS0z2QE,1298 +onnx/reference/ops/op_dequantize_linear.py,sha256=e5t3B_aB5EKJzrFJg5FFlr5_rGdd7XnqA6zSKPJ4QhI,3182 +onnx/reference/ops/op_det.py,sha256=v68nQ4dbNAaK7V7RpDaovlX8DdaP-CwAeSUIPs6rwZo,265 +onnx/reference/ops/op_dft.py,sha256=a262GStOikQfHymTmm6zqWXBP5C-fOHMW1G8OKxP8Pg,4821 +onnx/reference/ops/op_div.py,sha256=ql_C5xbkBZ4uR7MgbqmHU1pt3SqE7l5ISDnSaPAYILo,1034 +onnx/reference/ops/op_dropout.py,sha256=RqwHVDW0aUEEEjPu1GR_yVs4lbsKO8nlrQO4WkqNavM,1779 +onnx/reference/ops/op_dynamic_quantize_linear.py,sha256=hTh5DDSyE8PF4Fs1WdIU5LY5ZsY5lSG6lT1T9dvHX4o,965 +onnx/reference/ops/op_einsum.py,sha256=3U-pRY5hVKBjeLA17xLnCjP_fPpLjB8s_a6Vqhi40m0,630 +onnx/reference/ops/op_elu.py,sha256=PVGMx0_8clbPwNAdaN0CNBjYl_nmd_5xiRK2Bq69CP0,363 +onnx/reference/ops/op_equal.py,sha256=LE0AoLpdJVxsdrblTCiYvSKt916dWJgZArhykIgEw7U,291 +onnx/reference/ops/op_erf.py,sha256=wD93V41tWN1Bb6VVUkMBvFsf8LWzaMaV_QoFoMkqXC8,466 +onnx/reference/ops/op_exp.py,sha256=JnKijeIDcGleXoYyoO5sVx2CmEtxA_hff-KQ_X5xIHU,281 +onnx/reference/ops/op_expand.py,sha256=aa2sdEHAaRhBDA0FJEXt4A0ZSr95UGbLN4NvRaYjPuM,453 +onnx/reference/ops/op_eyelike.py,sha256=Gg7HjfigignuE-Kho0qoBwXVMzq4FEjjqcBOZ8yifRs,991 +onnx/reference/ops/op_flatten.py,sha256=zff6Q-8XFMrev98s2OvZ9QYYCViG33ElMPz4rEy0PWc,419 +onnx/reference/ops/op_floor.py,sha256=qN5h1URRJdc5UxcSz6x1R_RZ35hjcNKwVobm6rsNyW0,269 +onnx/reference/ops/op_gather.py,sha256=bEtP1FfAaGnPDlLlssy-_sq0f5VeBIWPE3WVt6ye1PA,705 +onnx/reference/ops/op_gather_elements.py,sha256=1PK1nf7jTo_gSEK7gY77FMx1urqQGDlMqQi9u1OpGIE,1589 +onnx/reference/ops/op_gathernd.py,sha256=7n7Ier6TUVerOxLwndTCDs9SiJDjRRsy6WMlPYpUxLY,1992 +onnx/reference/ops/op_gemm.py,sha256=rXN90D97ndN6dleUdBfvVOn7yzOnKusv1xdMzE8H6hY,1945 +onnx/reference/ops/op_global_average_pool.py,sha256=1xNF-kR_cnKY3w9NPDFE7OpT7Mh2BLOyObgwBf1PF5E,487 +onnx/reference/ops/op_global_max_pool.py,sha256=G6x3U-v5RoUwRR4VZg0IUEAhwsU8mKGwB0nDOTQJpt0,523 +onnx/reference/ops/op_greater.py,sha256=GBTDBiBtJHTleyg6V4Fx4Edz2id5nlN2TOe8Lf6vhOc,295 +onnx/reference/ops/op_greater_or_equal.py,sha256=yY_TGRl4ZDi1XHTHmvgHCZkNTsW95foXXrNP5lin5ak,308 +onnx/reference/ops/op_grid_sample.py,sha256=5zOpfXBuSRwy8z-N_nF7MPj_MGukrTsUt7IVYfxjZbc,13169 +onnx/reference/ops/op_gru.py,sha256=oqutVeFMt3Wa33Toaj0Wq6Ttl4vtAe2TTcukFzAMC-c,4069 +onnx/reference/ops/op_hamming_window.py,sha256=OUXCUb7zhEVF6PYmhOJxg_yL5BtOy4vVDWjleoo_0Po,791 +onnx/reference/ops/op_hann_window.py,sha256=L-KXC-Vin3f780ufkeZXhrIMfzskQp9tBR_8OKwYUys,670 +onnx/reference/ops/op_hard_sigmoid.py,sha256=ncA8ToXnYgusw3UdrxSg7yof8BPvB6JQhR2631vaNJs,432 +onnx/reference/ops/op_hardmax.py,sha256=EZyDaIBgkbMAA-XYkoLXJaRg0VHOktb_IRvEgkP2vqw,564 +onnx/reference/ops/op_identity.py,sha256=p2KPjp8x5YUzbWdpG_1pqCjphyAQrIgk3-ZSqkJ-p-w,281 +onnx/reference/ops/op_if.py,sha256=ZXo9r8rVs1fVJYavTsuClxJcrE6bKUSlEwLDX2xmVQk,2578 +onnx/reference/ops/op_image_decoder.py,sha256=6ByErDstV699RBJshwYrg2eRqZAwvUNE4IInayw5Qg0,1077 +onnx/reference/ops/op_instance_normalization.py,sha256=r8UgEWwJXTRHfF7yV38EQrjrV41NJttLLpLiV_bph2s,646 +onnx/reference/ops/op_isinf.py,sha256=_QN7-RErUFoe8Uq40v9ZXM6cA0tAGwnblK_5MD8iR5s,568 +onnx/reference/ops/op_isnan.py,sha256=6gfnUQIzVBCCx_BKPntFs2p1DHlYxe2JfCP6n4xpRlc,269 +onnx/reference/ops/op_layer_normalization.py,sha256=kKgLEdpaOb2rAHHyHVotEPybL3ie-6ViKLcMsP1WHfY,2595 +onnx/reference/ops/op_leaky_relu.py,sha256=Nr6qw_L_f5k5U4hIb16ra2SUJkmeILlOhO2xoiLjKxE,569 +onnx/reference/ops/op_less.py,sha256=5HL8WmISN8A2zQ6QvkPnP2DddKl-zUz6UpIxZtWdB6A,289 +onnx/reference/ops/op_less_or_equal.py,sha256=beMfblNTk1bQQ0jZdqqeMFUhosd57z6phJ96ItdLgUA,302 +onnx/reference/ops/op_linear_attention.py,sha256=HH8DUwtu7LHduicZT2HLVVbIk-W1ZO2R-dB5KLmtvoA,7881 +onnx/reference/ops/op_log.py,sha256=my5pt7Y92_GC_NHE21iGmqOCxgk9sApiXKA6Uvk-AIw,281 +onnx/reference/ops/op_log_softmax.py,sha256=sknhZnEoi1J3NT3j0SZ_48PkTyhLvV-f9ywOADih17c,321 +onnx/reference/ops/op_loop.py,sha256=anjumngDoUK3zvZA5jcLA9IIkyA8q--gZVJpXNfAZz8,3454 +onnx/reference/ops/op_lp_normalization.py,sha256=JAFfQxgFk1X8F_0cQsLGy4QpGp7nNCGdZbDCZ2cnjoA,582 +onnx/reference/ops/op_lp_pool.py,sha256=EktiRrSqDH2puosTWdaNjdC2OGE69EPK_7JS-SOjV10,1252 +onnx/reference/ops/op_lrn.py,sha256=RipYPKEhVXs0WrrocN4RuoPjtylbHCe1c86hfUhAYgQ,880 +onnx/reference/ops/op_lstm.py,sha256=ruOW_6qxpDtdKUAnifu80WI1l4vOyD9-vOyLHqO47vs,4769 +onnx/reference/ops/op_matmul.py,sha256=s35f9pZvlqp6WPJjWxl3b1rGwdQ0GJKMIq00B47P7LQ,644 +onnx/reference/ops/op_matmul_integer.py,sha256=3K5kU-YeDZkV9HBR4jZSJHO6BgzUwCn_80jFRlnx7N4,503 +onnx/reference/ops/op_max.py,sha256=azUeosOTVnJs1jfd3YbidNLAEq3dAlEs22Ociv_KciM,729 +onnx/reference/ops/op_max_pool.py,sha256=khThUchAmcGVb7WfSp8I7sgP0UUwpB5FdIJNHt4lCLE,14553 +onnx/reference/ops/op_max_unpool.py,sha256=ueCSeRg9xbfe48BxezmMuY11ed3c9EhEmZFA50Ug19E,1794 +onnx/reference/ops/op_mean.py,sha256=sMY9gggfZ3cP7kEC4mk9rNRfND5O8lJJ2I6xYsl3nTE,340 +onnx/reference/ops/op_mel_weight_matrix.py,sha256=vtpMvD_nCuCvn4DhaYm0COL_ezXADqra6JJqwPZpsog,2353 +onnx/reference/ops/op_min.py,sha256=3NhXGZfV-DIGdtTYpLRb64sEEmTW4X-419k7QwjYBYs,729 +onnx/reference/ops/op_mod.py,sha256=vwfpEDGtTDH5mhw9RUqq50OmK2D0be1QVabJvkCwd6s,482 +onnx/reference/ops/op_mul.py,sha256=NY3wEtwh9T-oZPebJ5-6FKzaIVgtyg1Z2HWjehoF9jg,343 +onnx/reference/ops/op_neg.py,sha256=xcWagZqJ7xezdrMRxT27NPWOjwJSio-xb6QKfYblgXI,270 +onnx/reference/ops/op_negative_log_likelihood_loss.py,sha256=oSlLkTyuB5HKmHDFVtizNe-1kPRWUYrA6X6aY89AKAo,2902 +onnx/reference/ops/op_non_max_suppression.py,sha256=8LCJZEyTqPy4aTsGia875h_5rAezJ1N3f-ASroRmjY0,9282 +onnx/reference/ops/op_non_zero.py,sha256=J4evtx727KWb6AHM30uvqCcpmQHB-Uw006HVGd9sH8U,354 +onnx/reference/ops/op_not.py,sha256=8Kbtl__vXypnRBroNiCssv3R_0iVIkv3PfZI7QFHhqY,267 +onnx/reference/ops/op_one_hot.py,sha256=F8f6AKWJ0XPvRFGrXCzkCX5Q8CQbo9s9bWkADst9YAc,925 +onnx/reference/ops/op_optional.py,sha256=RdPnsOrapoYNFtBU820YuT20o3FHeLf-eZr2_BUSQEY,601 +onnx/reference/ops/op_optional_get_element.py,sha256=EXcBDFiHys7ewKJWj2fSdcnt7UBS3qFZWyKVKH5--_g,332 +onnx/reference/ops/op_optional_has_element.py,sha256=OVIEAMxl-4mj6EwBSM0wlgPkzcYplfaWVP3XewLy8F8,282 +onnx/reference/ops/op_or.py,sha256=MbGQI-L8uenKSzxUWUaqocUaD_cMIBXgyt4wGv5m1CY,273 +onnx/reference/ops/op_pad.py,sha256=ItLK5n6-7R4qJcJ-LNiMjW8zauAiJOjNwFk_uCidpyE,2004 +onnx/reference/ops/op_pool_common.py,sha256=IcFhJF5aDtPNHixmgDhDOVgtNfUK9R5CDlkxthsl0wY,12618 +onnx/reference/ops/op_pow.py,sha256=7pSU04OABWwd5CpBQozriki0djEj9DhQ5dbz6FPAfI4,393 +onnx/reference/ops/op_prelu.py,sha256=6N2u-kSl0bmdYzxO2y8WIlIutqsTkZBTDAVxSoUt774,1170 +onnx/reference/ops/op_qlinear_conv.py,sha256=pbdviEWBQs-zg3i4s2LwlYHnuqe-Fr9QVLzRX8ZC4SI,2516 +onnx/reference/ops/op_qlinear_matmul.py,sha256=q_0KVwicopU_loU65Z_ajh8C7yWF3IqxSAoAa1VOoNA,894 +onnx/reference/ops/op_quantize_linear.py,sha256=Aodx7179iDzNS5cnQnnesQTY_SwfgYbENKu8tsQkyWM,5661 +onnx/reference/ops/op_random_normal.py,sha256=FzV6PFwCKFoFBNcClQH7mVIpEr4fckpGajXDbNWIGf0,512 +onnx/reference/ops/op_random_normal_like.py,sha256=mhaUqbdo6NFFT91W5j7_220FA8rq12GyeWZQvtpAv7s,628 +onnx/reference/ops/op_random_uniform.py,sha256=ifwCy8ihO-AXt3Oa8KMh_i8cc3rBwEbC6LMN7zpnGaI,501 +onnx/reference/ops/op_random_uniform_like.py,sha256=FX582Hohhs85wvIcPgaZXefaFm13maGt8PxhTRoGSlU,630 +onnx/reference/ops/op_range.py,sha256=sp3SeVaZaokTJJikAzJYFl9zO_CsVu-dbc1aoUQTDBY,1410 +onnx/reference/ops/op_reciprocal.py,sha256=TyOBM8nIG7CC82B7xjUFrrBUqWCBg4b9Vv1sN3rsXU0,342 +onnx/reference/ops/op_reduce_l1.py,sha256=aM00m9IKrXU6yCw71HmA8UphdULm1i7VodGcacXZmZ8,1140 +onnx/reference/ops/op_reduce_l2.py,sha256=WBjMmW1HtGIreJkMrHlDIPyrfwoLE_zqFiLmpUpz8As,1164 +onnx/reference/ops/op_reduce_log_sum.py,sha256=unGkWLzj4iKItYeEbvOw5vnI6D1otEe9TiB0nyAzYmQ,1093 +onnx/reference/ops/op_reduce_log_sum_exp.py,sha256=7PXztWI_zyg-nKb9I6lBHrLEgELRAUN893IjjcKCg8U,1283 +onnx/reference/ops/op_reduce_max.py,sha256=PV6i-A2IPQR340MwfYdW5F6ZtjFi7YNZjlfBTW2Zzzs,1605 +onnx/reference/ops/op_reduce_mean.py,sha256=k7_G8fpUR4LGMWWlY_iMpgcbFb0PAfm-zXazODP8nuo,1283 +onnx/reference/ops/op_reduce_min.py,sha256=ipcAnuoV6hoTvz8HmUoIp5evTcEmyMasmS7vk3UeCfI,1647 +onnx/reference/ops/op_reduce_prod.py,sha256=b1sld9bBW99Jd7DFguIMzDn4YgvxisXT8vLkloarKpg,1071 +onnx/reference/ops/op_reduce_sum.py,sha256=4RHeMQohj3KrnFSpE1L93P3_T6eO2osO6n_lQwFEmz0,1249 +onnx/reference/ops/op_reduce_sum_square.py,sha256=mOEvZwsi6-IlNQvmk4PJS4Ya2EJ54cNr-_tjBN7UPh4,1066 +onnx/reference/ops/op_regex_full_match.py,sha256=GlJzi_J6_08YngLHjdJJGQv72BHm6oVRnWA3pTgrnpo,1292 +onnx/reference/ops/op_relu.py,sha256=kAW14P_h6tnf2iCHERJLBRinH9ZtVzX7XCsuwjKfNR0,289 +onnx/reference/ops/op_reshape.py,sha256=ydpYWEdiZ3tLgdycyu0efj8nVkA26OorV53MVJOpQZ0,1118 +onnx/reference/ops/op_resize.py,sha256=sVMmIDBjyVMvxfT2zJg87vheKJ5sWsNkgtTlIvhbWc4,23331 +onnx/reference/ops/op_reverse_sequence.py,sha256=PZy-KzDhLVaohxAZPz5_eotB5svnK75qmhK0CfhtS_A,705 +onnx/reference/ops/op_rms_normalization.py,sha256=uacW3XSD1qmFkBjIIUUZ7821rz-9gyQ1fWcwder2vwA,1334 +onnx/reference/ops/op_rnn.py,sha256=wy56If66Yv_z6r4coARFjvuOaiGy-ncBNxeKAzVlY0k,4829 +onnx/reference/ops/op_roi_align.py,sha256=wVlnnvfob1sL14OapytJnmwVbJ7BnVM4z2i-WvDNfGA,10843 +onnx/reference/ops/op_rotary_embedding.py,sha256=DW4yWikHjdLkn7Ug0tXLoX-YLBYyk4laTwVzUbbtYPg,4316 +onnx/reference/ops/op_round.py,sha256=Oytjy6wsyCIFfRBFacauqgm5xTtAevFNyxBbaMSSggg,285 +onnx/reference/ops/op_scan.py,sha256=35g7LSx0S4EwNNk8wK-XPmTV354IPoO5pQwtXN_bvtw,6573 +onnx/reference/ops/op_scatter_elements.py,sha256=hslxtIEwXuCRvTXsygmDZXBEr_D2muGWOvd_MOOEXX8,3806 +onnx/reference/ops/op_scatternd.py,sha256=XHkR9K1WZzHvunH6MEFV0tZhgNKLW40sh9jlBFA73m4,976 +onnx/reference/ops/op_selu.py,sha256=dJnJgLPVh8m4S0ldJnBebZE7nRxuZi0wJO-cFZbF8_M,357 +onnx/reference/ops/op_sequence_at.py,sha256=3aVTyQfJSp6Pol2EYYRBwlCTIclq8fqUCHVJHIbPyLo,245 +onnx/reference/ops/op_sequence_construct.py,sha256=DW_jxiV5LcTA1X0N7Mdf8IEC29mwiYucTQJYedyteiY,247 +onnx/reference/ops/op_sequence_empty.py,sha256=x8AP1bzksBllAq24nl0kQnk3Zmd_2HghMQlSGsLQK-M,282 +onnx/reference/ops/op_sequence_erase.py,sha256=vPdcB9ty347Q3V94fSpOqNeS5CzLz_xX8S_jGCx2paE,369 +onnx/reference/ops/op_sequence_insert.py,sha256=RX-IMFFbhyyvDNW67ekZxcz-xnkK-6mgtIetJLAgoaw,1796 +onnx/reference/ops/op_sequence_length.py,sha256=f51Bg8zO3Mp73a6MmD7gDHsHgHJWPxvHXxg2yKQKpiA,477 +onnx/reference/ops/op_sequence_map.py,sha256=7Uwf_E0FlBdzRz2wryWY8yQZZuEskx3vuNfCmi3ITso,1245 +onnx/reference/ops/op_shape.py,sha256=5sKoi_N_5ldbHjPosSD2pEraeKSZTFh0m52DjJCLp94,1023 +onnx/reference/ops/op_shrink.py,sha256=xk3rSzn92Jw6Bztbmp7t0QnDo7-8Dzcijsd7ixZOCSc,430 +onnx/reference/ops/op_sigmoid.py,sha256=d1BmT21Ii5BVHQ7HK1rqyqTrGPAqdXBDg1D73HGT864,680 +onnx/reference/ops/op_sign.py,sha256=VqHkuwHlfoI4lFKtRv3LTN9-4CXTsWgVRRtJFmu_xxY,267 +onnx/reference/ops/op_sin.py,sha256=TC7Y5svjc1owhqFsBOeHUClK-c55BPh2c7H4m1kePcA,265 +onnx/reference/ops/op_sinh.py,sha256=pCZInGW3QDHpfe2TWmhJbYjPlXQqETxbu5DClq9YM0E,267 +onnx/reference/ops/op_size.py,sha256=Srp3sPDNHC4eBC4u61dCS93P1jkz4ZZgerunTCTD8Wc,278 +onnx/reference/ops/op_slice.py,sha256=_Bt5A6k6h5OYHCQ7FMtvLTtlZlGM1iF-EMypoAsNm9o,2399 +onnx/reference/ops/op_softmax.py,sha256=QqpY_QxHQBmIP5apSV9t3TTyTyqznWbx3itrip-KdcA,482 +onnx/reference/ops/op_softmax_cross_entropy_loss.py,sha256=DIlWSIsyAitx1cQgQkRGKFj_AnR-TuhWHQDVLU_N0WE,2950 +onnx/reference/ops/op_softplus.py,sha256=bdyY7GbIQyQ6O-QvhBGLqEw0_dQOmTNkdf3HX-acWQ0,361 +onnx/reference/ops/op_softsign.py,sha256=d0o-PorM4jqXAk1gsaV1lrvHMrCo-TSgAWUunjNOS0E,340 +onnx/reference/ops/op_space_to_depth.py,sha256=hG9o8DvzcNVGPZtYBui_L5UypnNcTfF3zTjnCJ9v69o,883 +onnx/reference/ops/op_split.py,sha256=nd0Cizn1Vk01SuxdcTdIH2exY6CrR7lGki2zPYvIaww,1535 +onnx/reference/ops/op_split_to_sequence.py,sha256=wE7xltciA-_P9IvVDSzH7isF8Z27rdHr-TsGm2Wgpc4,1528 +onnx/reference/ops/op_sqrt.py,sha256=A1mjEUptb4oRbBRTeQ81HJcUFEa8Hb6NnMyresx7Zbk,404 +onnx/reference/ops/op_squeeze.py,sha256=oKmGQ-UqMIMLAymJr8yrocmKRl8VY_bMKqhIpbgaVaM,1154 +onnx/reference/ops/op_stft.py,sha256=EbQTOpzgVeR8FS_a6R4Rohvm65DPmfrNwpbenTFMeZA,5349 +onnx/reference/ops/op_string_concat.py,sha256=Oi-YtLHEeGsXDgP6yEfNmki9Y6T4fp7jrt5FFscuSFI,708 +onnx/reference/ops/op_string_normalizer.py,sha256=-eLajGbjBzhU9qc6-BGIVfsWEOHpQa0d8hUQttx0NnE,4941 +onnx/reference/ops/op_string_split.py,sha256=XrZ5YXlp-X7vfhZPgyJSRSw18Z4chkun6P6pzIatepA,1695 +onnx/reference/ops/op_sub.py,sha256=ZNydhyfGdHgz4-2ThZLiYHep-i171mvJFYa6raGAyHk,343 +onnx/reference/ops/op_sum.py,sha256=nvnH5qePzseLx_CFX6T4tAZlouBVXunL4FiQIQwCdnE,254 +onnx/reference/ops/op_swish.py,sha256=9oD7t93qTNkjZNf4NvvSe_mgot3DJG5N9Z_f8maZ-JY,375 +onnx/reference/ops/op_tan.py,sha256=OvPmtJtnujkouApplsy5ObN-PC1HrrqcjEXBtoQqn-4,265 +onnx/reference/ops/op_tanh.py,sha256=it9oslt-Qt2ymKamEC18DF_81fzMy0cJwaTY8HTS1qc,267 +onnx/reference/ops/op_tensor_scatter.py,sha256=LxIEmgWCz7TlyQF8GJseon2HLVULl81RVgCNebn77Vw,1910 +onnx/reference/ops/op_tfidf_vectorizer.py,sha256=eLs64Thv4iWXQ302XRbdfdNFAxI8I9iREGp4tx9bBFY,12527 +onnx/reference/ops/op_thresholded_relu.py,sha256=hzk3O1mY-cn8KCzofblyic8Jiv-89pnzQJj3AYpbqys,357 +onnx/reference/ops/op_tile.py,sha256=p5-Zkk91qywE_IJKSG-Q05zNUjU-wQqMe4s88xAfD20,268 +onnx/reference/ops/op_topk.py,sha256=cEbcaQWNONR-zW799fykGFj-uFwoPuu5El_2XG4wb0M,4065 +onnx/reference/ops/op_transpose.py,sha256=0GTeWgUJsNThxaXWzqbjDzmANRqZLNIFYs76UsOcI1g,592 +onnx/reference/ops/op_trilu.py,sha256=VHY6P3y-9LKm_TytpOgn8jicZmGWZcn-MIr88_ikvDc,385 +onnx/reference/ops/op_unique.py,sha256=Q4lSyKS5KZFPiiTeE_InO3fSJPtrw6kx0QFTS0d4q7Y,1773 +onnx/reference/ops/op_unsqueeze.py,sha256=tV1SmCxmTS8GbAAlD5CouwqcggOXSXa6Kb2FOKG9tSo,1592 +onnx/reference/ops/op_upsample.py,sha256=hfIqgFpXKFWN_UooVGAeR-iD_CQ-33E3OoDwlU0-zY0,608 +onnx/reference/ops/op_where.py,sha256=ddPsctQP5ZXeC4FY2amoF2n-yoqyFbwhQk72_H3VyFM,577 +onnx/reference/ops/op_xor.py,sha256=D3aNMRN7VSe2YK3Uqz49J_cjFAHIIPWW71xDftX1zjQ,275 +onnx/reference/ops/aionnx_preview/__init__.py,sha256=NZLYwi66mYt61D4fsjs0IGuQQ7odZ5BmgInKr2UCwv4,203 +onnx/reference/ops/aionnx_preview/_op_list.py,sha256=P5OMPCj511MWImEErgzFqWszj5hHrOkSxSSiPw-pPtE,2708 +onnx/reference/ops/aionnx_preview/op_flex_attention.py,sha256=1kLuFPNYJfmE2hfgh26ZglqtgpuJHqDele_AwfcEQn4,5305 +onnx/reference/ops/aionnx_preview_training/__init__.py,sha256=Koz1l_2P5sNA-18Hr349xTm0am5F9DUIlzvV9jdzgjk,315 +onnx/reference/ops/aionnx_preview_training/_op_list.py,sha256=5NFXwRBmK4vhhvUvyY0os9fSd13G49mRNAp7GsrrB4Q,2864 +onnx/reference/ops/aionnx_preview_training/_op_run_training.py,sha256=QOdXC6lnEBa3KUoytuwX9sZ2mevrB91xKhpHSO_iOjU,230 +onnx/reference/ops/aionnx_preview_training/op_adagrad.py,sha256=DFO_WeKHBzhgx3_ThtuB0M61IHS4IijP9vMbvqLyJGA,1917 +onnx/reference/ops/aionnx_preview_training/op_adam.py,sha256=IO8wgGKGu2Eam5qAG8zIaViMVkBBJDuBP8Elf1AiLXw,2863 +onnx/reference/ops/aionnx_preview_training/op_momentum.py,sha256=l3v6InqBBR22ZFguK3rswSOAK1m1WkOaj7SFHmIGOG0,2467 +onnx/reference/ops/aionnxml/__init__.py,sha256=QFSbBjsLAHCXYTamWRxJ1EE48gP0U3XabGWwkzsWHTQ,154 +onnx/reference/ops/aionnxml/_common_classifier.py,sha256=x2aJ0o3JsMMWbsgBM8LrGtb3tFgqZ_chrz7TZgG-2Xs,1928 +onnx/reference/ops/aionnxml/_op_list.py,sha256=p600rdUN6ghVB_HfPgIM_SI1O_dzGDVvQULJ51WdDsg,4326 +onnx/reference/ops/aionnxml/_op_run_aionnxml.py,sha256=O7ILlUh3sz-q1q2qBOPARG-MpAG_84tQ_18dvTuQfvw,173 +onnx/reference/ops/aionnxml/op_array_feature_extractor.py,sha256=dt7R7TPcaxRT7G9xwEqMqZkFvP8wNAjcXSXbB5Fib1E,1612 +onnx/reference/ops/aionnxml/op_binarizer.py,sha256=POf4Xkp3Nk6JPe9doS6UwzQrfRbULnRIIUG6-wjoYgE,398 +onnx/reference/ops/aionnxml/op_dict_vectorizer.py,sha256=MC2iKffNdoSb_qVe8wtNu_clJbNPdWcnSqZ2Vbf8DJQ,1731 +onnx/reference/ops/aionnxml/op_feature_vectorizer.py,sha256=h3uh9qcEmAHjOO9fXgoav-PWrGYjdUxpB6OUcOics7U,936 +onnx/reference/ops/aionnxml/op_imputer.py,sha256=nwub_0lbHv3e1aaPgD2V8lZqby-z1W54seXyHA4FZwY,1568 +onnx/reference/ops/aionnxml/op_label_encoder.py,sha256=mgetnQnRqwKZB4ezp1AEYkE2opINUDKwqsQRdSSohPw,1558 +onnx/reference/ops/aionnxml/op_linear_classifier.py,sha256=QY2YtBAkw5WXwZ1TLiDxx2QJlqoosg_5ZQKkqK1xCEw,3589 +onnx/reference/ops/aionnxml/op_linear_regressor.py,sha256=N1JgSkdsZxIaJJRkVVxsOKyYOScW-f9ivfui5jUgKEU,863 +onnx/reference/ops/aionnxml/op_normalizer.py,sha256=cu2DpQg0Yhd8JOZp78Q2Ht5mmDlDhf1ll9dtoeEnoYM,1158 +onnx/reference/ops/aionnxml/op_one_hot_encoder.py,sha256=i83oyu7Ihc9f58kOt31CBTQxDVbwWw5JSP0JiMZls-0,1913 +onnx/reference/ops/aionnxml/op_scaler.py,sha256=mv9EumyQPoCG0bAVgW7T8iCK5JCSgPH--y3FvnYJHVc,338 +onnx/reference/ops/aionnxml/op_svm_classifier.py,sha256=KTJYy3o5URxcAf7tmt_KdDXdQCTBQdMli9GcYMEOOTA,11382 +onnx/reference/ops/aionnxml/op_svm_helper.py,sha256=KlE72wRUEh_W5QbPNbnqX4g2KEx8RYZxwX9SZX99-c8,3080 +onnx/reference/ops/aionnxml/op_svm_regressor.py,sha256=YxcjRSx8M8C5rcRB3MT9V6xpGVFq0WeuNa4zmAc8fnc,1256 +onnx/reference/ops/aionnxml/op_tree_ensemble.py,sha256=ykHFjrLtPhA1s4HihASUXdiJ8tHZO4K6Re3-i8Rr97A,9388 +onnx/reference/ops/aionnxml/op_tree_ensemble_classifier.py,sha256=mHIXIV5-9ttIVeHYvb8V6B__hqpN5dmdSu5kOYz6IpQ,4844 +onnx/reference/ops/aionnxml/op_tree_ensemble_helper.py,sha256=_u5Q6Tgg8S-UkXXTuHimPOVL356al0T-lMrFrXD19hk,3591 +onnx/reference/ops/aionnxml/op_tree_ensemble_regressor.py,sha256=Ae5srpcV2a72oeJaYwBPHPUSD4P3sxSvgDXuflCQuik,4104 +onnx/reference/ops/experimental/__init__.py,sha256=ydyVHgJ6tX70JgPaYQDH1N9D5OFAiuSxNWsqhMLLKDU,202 +onnx/reference/ops/experimental/_op_list.py,sha256=6pVAlgX_mYp08K6y9ig3UofUmq5GqRqWADZITy_M4Js,2284 +onnx/reference/ops/experimental/_op_run_experimental.py,sha256=egFdzxX_NnlaVFiiU9S2QqnU5uNdP9RqAxhdobVNM00,223 +onnx/reference/ops/experimental/op_im2col.py,sha256=_BEM-p6e4Qfh7ayazDuQfAmKDpsMVxiN-SqE28S74x4,1406 +onnx/reference/ops_optimized/__init__.py,sha256=AOG0uBSZ9a2Td1vgIJh0n7sUk5FaAu8uxJln0j1IZkQ,255 +onnx/reference/ops_optimized/op_conv_optimized.py,sha256=L6wd1HyM_HK4n_ymQaPdu6cV9eQJwgvZYDDa9TtdyjQ,6398 +onnx/shape_inference/attribute_binder.h,sha256=QmkbZHYBb_Y1wHrN0Cua_NcU0G7Dx6sXcqX28sqsK68,2434 +onnx/shape_inference/implementation.cc,sha256=Sm46B6-2cYpAxHdblFNAzVquJPOyfuyWq-KVdDWejoU,45049 +onnx/shape_inference/implementation.h,sha256=SF531k_FK1SOuB5eNV09daW_Za-d7BgjbDPusr66FfA,20821 +onnx/test/basic_test.py,sha256=gIkKRkuzAfgUtCd6zAE5XZhm0fu3RDB-D9doSGioj9c,12832 +onnx/test/checker_test.py,sha256=MOOqvBRu--GRdmJbQoAwdAYk1tPfaH1l9H8JONrvE9o,54971 +onnx/test/compose_test.py,sha256=rPnFdI-rhHvIZMfgO7Gx9nTEAVo5QShphnWssEXHekk,41001 +onnx/test/data_propagation_test.py,sha256=imbtGWdW73zP2Wi8nuggqsTar4d7gLBepgXnJeei-eo,9052 +onnx/test/function_inference_test.py,sha256=idvm9X0KVwLBqE-hCXmOB9G-sf4QS_3QJN00tkTrK0w,4442 +onnx/test/function_test.py,sha256=YNXJ_Igvhlq32YIdxpuM1_8ENCS7RGsZ_IGeDajvlK4,8602 +onnx/test/helper_test.py,sha256=iHn2Kt6npLGjKXoCJViSSS1t7UI7NO_QIgm3zoRJDmQ,45594 +onnx/test/inference_function_test.py,sha256=EbFX7wb3hk1gQuWJohnw0Vkiv1BxP8jan3WzVZcqwYI,10330 +onnx/test/inliner_test.py,sha256=92VTuQXDIQ8heZ9E8HIAoCapFR23QBYR9Nvme3DacK8,5030 +onnx/test/model_container_refeval_test.py,sha256=rj3KAfLPZ8K_Ziiq3pGlttwVFfCC5mQDmHOGr0pPw2Y,4978 +onnx/test/model_container_test.py,sha256=JsSwzcdpxTnQ8nTfdIdvWfhyQXHrAdRDQRSRi3uEk9Q,5153 +onnx/test/model_inference_test.py,sha256=tO7YGgFFKgi6dC3Iv_nwHqbeBXqvGeC5TXvlpDwi4cM,9469 +onnx/test/node_shape_inference_test.py,sha256=6RCSVD38xB4VOta6clyhO3Yt5pJzDG9iPsFM5cVbYgQ,1151 +onnx/test/numpy_helper_test.py,sha256=OwQIAaAWhRfsyYqVzJLKQ8pZne0nfes1xyCZouY4RLU,14155 +onnx/test/parser_test.py,sha256=P4d8loqyHuuaMxhKV8qQRVnREIpHmKVhFqeOgVnxmNU,12864 +onnx/test/printer_test.py,sha256=PqKtjVCYUT-A7pnjUQPcqHbAsT_VZX-w4U7N6hXQ3zw,2791 +onnx/test/reference_evaluator_ml_test.py,sha256=ZiXFQQOLivt18Z6nHhDG4q1QasZYj7Y-GDVb7T6QtmM,85370 +onnx/test/reference_evaluator_model_test.py,sha256=z2Day1aN791emhqQ2VfBQ74lhoA4Lc_GB3RpF-6AALk,3921 +onnx/test/reference_evaluator_test.py,sha256=AqZddtdJYCVWAPuu9tFgNIc6ahFljg9zdaIQFfkjowk,242657 +onnx/test/schema_test.py,sha256=xRe_VF3R8-ukJpKsl5nf7KKPHlq8BUN4a8c3OWOrLZ4,22164 +onnx/test/serialization_test.py,sha256=wGCbMiKR-6xUMCEX6nwAgRewAHDKThJ-IucwEiHAp20,3229 +onnx/test/shape_inference_test.py,sha256=08w5mHaShVKuCi7Q2qNP8f-cmitdS4eb35xdnQp-SzM,486976 +onnx/test/symbolic_shape_test.py,sha256=lZa4iAmL9vrdPv8hOTVaqei1DO3n87k-KDKHlYvtkE8,8479 +onnx/test/test_backend_reference.py,sha256=lcka29i3KtJMfyKYbxqpPNidviJzFuQ3Eu2TsbdOucU,7118 +onnx/test/test_backend_test.py,sha256=oS-YRNK5O7PqNOIAUfHaxpPtZfmXuGofc_3i02rXNrw,4054 +onnx/test/test_env_python_executable.py,sha256=rh8RZXISKm4Bi4RgzinqKAe0WK2uP0pJlddqIk1uiRQ,9829 +onnx/test/test_external_data.py,sha256=vrA96xikLxBEJRP72ae-rxwDnVwyxZxgZXxEgf7MmPc,52372 +onnx/test/tools_test.py,sha256=HX2mKKRjWRt5nGFbrhGsWRLpXAHA5t7PzDQrLNT8Prk,13598 +onnx/test/training_tool_test.py,sha256=6l8i6nIT8icrxpSNx3GTOqu4gtI-exVmr7a8YqtRcoY,3711 +onnx/test/utils_test.py,sha256=2YW-8hv6X9FByFCeD4HcYEw-LyabzRHKLazQskvDKAI,3009 +onnx/test/version_converter_test.py,sha256=A53sFsI7Cvj60hm8p4iI_0_QJPlNytmeJ1fY4lDyULY,107836 +onnx/test/version_utils.py,sha256=MQWIfyeT_si4uwvKX_4Ug57apF1UZJMD4B6cfz_50nA,576 +onnx/test/cmake/main.cc,sha256=ql43Y8-D40Uqn6j1vLrdzd974S2IE_iALrDWOVmu_KE,847 +onnx/test/cpp/checker_test.cc,sha256=DjYft7xL2uwZqjcoyzEV2nW3CNpV0ri8FDpGqGxjIfE,6530 +onnx/test/cpp/data_propagation_test.cc,sha256=3Vqp_nxAoSCf02LdptJKPvO3E-bsXm7F9vPCr3YU824,13267 +onnx/test/cpp/function_context_test.cc,sha256=MfP0mPU-8WvqCc74UFDasI8Lnt8zjQQnPyxa2APhkgE,10731 +onnx/test/cpp/function_get_test.cc,sha256=eJkIr3Mt9328SJHqpjJa0T0eujkZlCShkIkMbdSlbbk,1511 +onnx/test/cpp/function_verify_test.cc,sha256=hZI6Ml43UJHzmU2CUL0kd1K9LtuF_MupQ3ytxGMgaFk,20986 +onnx/test/cpp/inliner_test.cc,sha256=R0HmP71dnqXlbcvzE1CEnjxznk4P2HAYFdjNaC06WoM,13890 +onnx/test/cpp/ir_test.cc,sha256=URjH52oYGSIKQKkgbGgHJyLkAqwosyzdWPGhXtJyahQ,2060 +onnx/test/cpp/op_reg_test.cc,sha256=0Jf8qh7i-EvhGoVGQtY16_bzwdb51btuggza0vQRD-I,900 +onnx/test/cpp/parser_test.cc,sha256=ATxGmlo12YYLuXQww79FxAXWSxNWFGcyXudnrI4M_L0,20038 +onnx/test/cpp/schema_registration_test.cc,sha256=5gdvSimd3NchenJTHPhm77w6mGxlvhFimItY-O7Nbuc,9494 +onnx/test/cpp/shape_inference_test.cc,sha256=a5GydFC1NGkOwSYC82AA5dVCkI-IVDhqZ5UTUEDrtFA,20256 +onnx/test/cpp/tensor_test.cc,sha256=MOkw089NRHRlQs5ed57oc-fYz08MrBs771yL1QtqdHk,961 +onnx/test/cpp/test_main.cc,sha256=f9SR7-yQlG_p3g9YsRkZTR60URSluCG1o9ZH1si5m0I,296 +onnx/test/cpp/type_builders_test.cc,sha256=H0dVhu8bU44JUaIQNfXVTejIzDSLC7GHrzwHL3txLlc,2185 +onnx/test/cpp/utf8_conversion_test.cc,sha256=sIUmtt0dzPKLBWgBHxqSzKO0K_BqJvdwP9QAeIHX-5Y,930 +onnx/test/version_converter/automatic_conversion_test_base.py,sha256=fbC_adx-t2O-c8NUgQW5oImVeTGOWnVMvVjgJiwV4eY,7139 +onnx/test/version_converter/automatic_downgrade_test.py,sha256=G1wB0Hh09adzs_YQSpUkw-vThxiR0iPnLEsM5A2Ru44,4517 +onnx/test/version_converter/automatic_upgrade_test.py,sha256=uBpj_UpCIpxEKLwguGHH7c72jmevN4Y5qP_mMk9I1aM,64945 +onnx/tools/__init__.py,sha256=x6thC2ykdnq7G6hJ-ENaxiRV3WfttWPcBYskup5sjig,82 +onnx/tools/net_drawer.py,sha256=FqQE5Htwb2mPctfxXxq4m-tPtJ6Ovn_6dYPtygC-Vj0,4941 +onnx/tools/replace_constants.py,sha256=08ANW-0n_2yPNW_U7SdIJCLK2YyuaQohsf2-gFgKiAQ,15375 +onnx/tools/update_model_dims.py,sha256=BNLHXDGyPfSTbjx3wjojrZwcHgKW1J10i-1dL2o_1PY,3462 +onnx/version_converter/BaseConverter.h,sha256=4ctRRvUCJIkFgd7sRmG4oSHudLJduhdbZsBxGop-osY,3675 +onnx/version_converter/convert.cc,sha256=4UmEeFzm3lTbPEp8tAv0UCgs0IZG7aYVmXAZHlT91oA,5515 +onnx/version_converter/convert.h,sha256=10dqngX0ilV2KNjh18YNNXpH1mlFFWR6jXVmMjVsul8,74393 +onnx/version_converter/helper.cc,sha256=Vy3bIoCEq3JdOd9beEKbj-d3aAkb_bgrCrFpiUejEDw,2694 +onnx/version_converter/helper.h,sha256=ntLn3lYwidfVGyd0nJICwYgCydgWnU7p7qTCZmgosZM,1583 +onnx/version_converter/adapters/Attention_24_23.h,sha256=sW4UGIxQxkDubSVWMVuWJG7aHEDyy4l-ifFDLb1qrAA,1301 +onnx/version_converter/adapters/adapter.h,sha256=MkQoGz4l3qMmkZPC9P8DpnniIDtNxPjrQlah0Q9shMI,1852 +onnx/version_converter/adapters/axes_attribute_to_input.h,sha256=ZKPfT5Ln0XoA5skl9WE4OL7NpGLIH-4-TH8Ca1h3n0A,1308 +onnx/version_converter/adapters/axes_input_to_attribute.h,sha256=X9uqfmao1CBm8iReupqRxmohrYv6Jt1xkhGP4-MIdpo,2007 +onnx/version_converter/adapters/axis_attribute_to_input.h,sha256=O8T-P3IZvilRKnNuZSbdwcQWdsfT26pI7ZX8PQpDjm8,2014 +onnx/version_converter/adapters/axis_input_to_attribute.h,sha256=iyC4GLHY5yrMEkrZaNYzz8HKoOBssSHEdjQ0QnJLj2Y,2902 +onnx/version_converter/adapters/batch_normalization_13_14.h,sha256=CMsDasRFficKNt63_zzg-ePsU3ViTSZso72VnGz3fqQ,869 +onnx/version_converter/adapters/broadcast_backward_compatibility.h,sha256=mogghY9Rlumr7M5v0appPklYvDsTUlF49KBc1d1LUk4,2275 +onnx/version_converter/adapters/broadcast_forward_compatibility.h,sha256=wPSDeyt8JngiKiLCCJ-o5vnQsVBIoNLNjmNkWpdoAhI,3326 +onnx/version_converter/adapters/cast_9_8.h,sha256=r7MWVTlvT8Ev8P2ctaaiBdk0LniMkHggpvjK75UORNg,973 +onnx/version_converter/adapters/clip_10_11.h,sha256=0jQyYFuOuIpkgd2uvJ3pqynfsmKprRjIhe1wHYRYu3U,1603 +onnx/version_converter/adapters/compatible.h,sha256=8BKUKCNMFf0Rx9wBdFO8xeD66At4dO5fnlCM0_4lwRk,704 +onnx/version_converter/adapters/dropout_11_12.h,sha256=QgxjSb9cEE979m4OACmzGsPM3t8Obnsznvae02ioMwE,1230 +onnx/version_converter/adapters/extend_supported_types.h,sha256=cl2DC0xFZBaA42RfQMddhcZwf2C3F-MI9SzQbfF_XzI,3848 +onnx/version_converter/adapters/gemm_6_7.h,sha256=0Z9fdc2pJMteGMN6E2jApyVpKZyIMqRou1Fk1s674NY,1826 +onnx/version_converter/adapters/gemm_7_6.h,sha256=n5z9F0nIT6csjZDbl84dvBzj1ogNP_FGTsBaid2WgR4,2139 +onnx/version_converter/adapters/gridsample_19_20.h,sha256=BxhhkNyyEj6N7VapGeMLnrVLabx1u1-hPiPLBAnY_kE,958 +onnx/version_converter/adapters/group_normalization_20_21.h,sha256=F_znBbJmubJbSMVlG97_XV36Eoi7LHTDFgnShZoNTxw,4538 +onnx/version_converter/adapters/maxpool_8_7.h,sha256=2ANx_0P5rejCrisGtqOxrtXObLjo61vnnfCwlEa7zqU,952 +onnx/version_converter/adapters/no_previous_version.h,sha256=EougsPnqcI-TnQ8PTiyvdDDlGk2H3KIdC-qAElih5uY,809 +onnx/version_converter/adapters/pad_10_11.h,sha256=MZGBCCgQzoVUigzIXK1OtJiUDM4mkda5C4hF3xDGBnc,1731 +onnx/version_converter/adapters/q_dq_21_20.h,sha256=TR0CK7b-Ai3SxbwZOGY7h-89NnAImNcmWxdrK0xx8U4,2723 +onnx/version_converter/adapters/range_27_26.h,sha256=PngI9nm9QJShXqDIEAgwadWSE_9zyw1mL_XOeY6DM6w,1875 +onnx/version_converter/adapters/remove_consumed_inputs.h,sha256=e4yYLvYy-HjbSy1vde_qCYAunyteXyS4ZG6eNjkE0nY,770 +onnx/version_converter/adapters/reshape_4_5.h,sha256=Wo2A_KDaeIQktp1nIJVw9nE6k7FIf9_YYLeTkXT9EoY,1457 +onnx/version_converter/adapters/reshape_5_4.h,sha256=P97Lotf-1I9Fw1_8COrsnQnzyIvObTAwg_-n9nLvT2g,2103 +onnx/version_converter/adapters/resize_10_11.h,sha256=N5O5JdEfSSg2Orvg0652S81UD5V2IpeNe6p91MY-4CE,1448 +onnx/version_converter/adapters/scan_8_9.h,sha256=myeNjCCsqAslRkSEWnxsjVKIosqdTpWCSJXAdAcHUOg,1748 +onnx/version_converter/adapters/scan_9_8.h,sha256=AFZnXKor96iuU9rIayrrGi9bKMCxFzvZG1lOqx5cNig,2898 +onnx/version_converter/adapters/scatter_10_11.h,sha256=TgR8QL8KFRryuZIib8s4ZpB2NMsdhtCBYi9JsA8gOck,1373 +onnx/version_converter/adapters/scatter_16_15.h,sha256=SDKce9hhtNQCN9E-CYSup8Nen06141AuHOHjZh_YIX0,1989 +onnx/version_converter/adapters/scatter_18_17.h,sha256=ehVFbsaOiYdvP25pcQXjBqP5NVGgxQQRxfVw2xA9iZE,1012 +onnx/version_converter/adapters/slice_9_10.h,sha256=CJtWNsWy_eR0S9wcchQMvIPtQG9LPuETanXoJ5VxVMs,1501 +onnx/version_converter/adapters/softmax_12_13.h,sha256=VJyc_Y9UOr_MX_usn7U6uxr3dyqu_bl7qyGGQHTJUjQ,2904 +onnx/version_converter/adapters/softmax_13_12.h,sha256=ecpATjkzDV0bHJ9OZH02fW8nIlTjwFZeypwu2bpb_hQ,2220 +onnx/version_converter/adapters/split_12_13.h,sha256=v4iI_OKTWBrI64ZimRqQWgol5h7rh9wR_hfT7WKOlzg,1204 +onnx/version_converter/adapters/split_13_12.h,sha256=3A2UgtIG05OUEOCFvVl-4MaraT-HuF5wTnMnXjwX3-4,1930 +onnx/version_converter/adapters/split_17_18.h,sha256=0KXwsqQf7-IxZp8ezQi87xm3R8HyAMPe5nw9rILCiOo,1018 +onnx/version_converter/adapters/sum_8_7.h,sha256=KnD4kQh9ZoJPXSronyj_c10PDtdB1VmsM1hiyZoqHaE,1094 +onnx/version_converter/adapters/topk_9_10.h,sha256=KOWfIjmu0GwIoDn1I26k0dw34ctF7Ombt2UQi5C9Eb4,1062 +onnx/version_converter/adapters/transformers.h,sha256=_hqv5gfhuZ22IOt2wB1jqvJMsvz_F0_IQIvFYmeGwow,2594 +onnx/version_converter/adapters/type_restriction.h,sha256=MDFUXNfzjBFTyOHFqqXY9zA-wViuXQUvO__soswQFLs,1764 +onnx/version_converter/adapters/upsample_6_7.h,sha256=tzOBeQj7wqYi7X8xlmi3AbCOgfuHJpNyIThCR5tQ6Mw,1605 +onnx/version_converter/adapters/upsample_8_9.h,sha256=HGqBmKRO-AB2-Diyn5HjS_Vr406CAVsYAzqOha_0BPs,1310 +onnx/version_converter/adapters/upsample_9_10.h,sha256=RlhIQvpkh73oO-PYdJuwGSfQXkvNCkterFtxCSi-Hdo,1244 +onnx/version_converter/adapters/upsample_9_8.h,sha256=qUKqK7-MbfD07kCblkyXd1Y3UHJ9kkiObqAWkn46JNE,2494 +onnx-1.22.0.dist-info/METADATA,sha256=BeJoEJ4RMefjPO6xUlk03lFdHjLtMn3McLIXk-Ci52A,8483 +onnx-1.22.0.dist-info/WHEEL,sha256=V1Ms5Z26x3A-PKxl4PGo9SfOAy9UfS14I_Bscv7nshU,157 +onnx-1.22.0.dist-info/entry_points.txt,sha256=l3zggZCce6pRcl7vU8Kd1A5l4GMaYMdV7LCKJtH97Fg,157 +onnx-1.22.0.dist-info/RECORD,, +onnx-1.22.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +onnx-1.22.0.dist-info/licenses/NOTICE,sha256=TWgPsfSPB_E0yfeo1xUwO49RYLV1e8nuxMrHg3A-pZI,2133 +onnx-1.22.0.dist-info/sboms/sbom.cdx.json,sha256=KOqMkR2DR1uuhzlj-HCus6YSJUoI_-FuLWmH1pQQ_vk,2142 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/REQUESTED b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/WHEEL b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..7ed3f256a6556845f65774262f9d802b3adfc2a5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx-1.22.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: scikit-build-core 0.12.2 +Root-Is-Purelib: false +Tag: cp311-cp311-manylinux_2_27_x86_64 +Tag: cp311-cp311-manylinux_2_28_x86_64 + diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4c286c4e6561beab79c721a62b6236255e919a0c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/__init__.py @@ -0,0 +1,470 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +__all__ = [ + # Constants + "ONNX_ML", + "IR_VERSION", + "IR_VERSION_2017_10_10", + "IR_VERSION_2017_10_30", + "IR_VERSION_2017_11_3", + "IR_VERSION_2019_1_22", + "IR_VERSION_2019_3_18", + "IR_VERSION_2019_9_19", + "IR_VERSION_2020_5_8", + "IR_VERSION_2021_7_30", + "IR_VERSION_2023_5_5", + "IR_VERSION_2024_3_25", + "EXPERIMENTAL", + "STABLE", + # Modules + "checker", + "compose", + "defs", + "gen_proto", + "helper", + "numpy_helper", + "parser", + "printer", + "shape_inference", + "utils", + "version_converter", + # Proto classes + "AttributeProto", + "DeviceConfigurationProto", + "FunctionProto", + "GraphProto", + "IntIntListEntryProto", + "MapProto", + "ModelProto", + "NodeDeviceConfigurationProto", + "NodeProto", + "OperatorProto", + "OperatorSetIdProto", + "OperatorSetProto", + "OperatorStatus", + "OptionalProto", + "SequenceProto", + "SimpleShardedDimProto", + "ShardedDimProto", + "ShardingSpecProto", + "SparseTensorProto", + "StringStringEntryProto", + "TensorAnnotation", + "TensorProto", + "TensorShapeProto", + "TrainingInfoProto", + "TypeProto", + "ValueInfoProto", + "Version", + # Utility functions + "convert_model_to_external_data", + "load_external_data_for_model", + "load_model_from_string", + "load_model", + "load_tensor_from_string", + "load_tensor", + "save_model", + "save_tensor", + "write_external_data_tensors", +] +# isort:skip_file + +import os +import typing +from typing import IO, Literal + + +from onnx import serialization +from onnx.onnx_cpp2py_export import ONNX_ML +from onnx.external_data_helper import ( + load_external_data_for_model, + write_external_data_tensors, + convert_model_to_external_data, +) +from onnx.onnx_pb import ( + AttributeProto, + DeviceConfigurationProto, + EXPERIMENTAL, + FunctionProto, + GraphProto, + IntIntListEntryProto, + IR_VERSION, + IR_VERSION_2017_10_10, + IR_VERSION_2017_10_30, + IR_VERSION_2017_11_3, + IR_VERSION_2019_1_22, + IR_VERSION_2019_3_18, + IR_VERSION_2019_9_19, + IR_VERSION_2020_5_8, + IR_VERSION_2021_7_30, + IR_VERSION_2023_5_5, + IR_VERSION_2024_3_25, + ModelProto, + NodeDeviceConfigurationProto, + NodeProto, + OperatorSetIdProto, + OperatorStatus, + STABLE, + SimpleShardedDimProto, + ShardedDimProto, + ShardingSpecProto, + SparseTensorProto, + StringStringEntryProto, + TensorAnnotation, + TensorProto, + TensorShapeProto, + TrainingInfoProto, + TypeProto, + ValueInfoProto, + Version, +) +from onnx.onnx_operators_pb import OperatorProto, OperatorSetProto +from onnx.onnx_data_pb import MapProto, OptionalProto, SequenceProto +import importlib.metadata + +# Import common subpackages so they're available when you 'import onnx' +from onnx import ( + checker, + compose, + defs, + gen_proto, + helper, + numpy_helper, + parser, + printer, + shape_inference, + utils, + version_converter, +) + +if typing.TYPE_CHECKING: + from collections.abc import Sequence + +try: + __version__ = importlib.metadata.version("onnx") +except importlib.metadata.PackageNotFoundError: + try: + __version__ = importlib.metadata.version("onnx-weekly") + except importlib.metadata.PackageNotFoundError: + __version__ = "unknown" + +# Supported model formats that can be loaded from and saved to +# The literals are formats with built-in support. But we also allow users to +# register their own formats. So we allow str as well. +_SupportedFormat = Literal["protobuf", "textproto", "onnxtxt", "json"] | str # noqa: PYI051 +# Default serialization format +_DEFAULT_FORMAT = "protobuf" + + +def _load_bytes(f: IO[bytes] | str | os.PathLike) -> bytes: + if hasattr(f, "read") and callable(typing.cast("IO[bytes]", f).read): + content = typing.cast("IO[bytes]", f).read() + else: + f = typing.cast("str | os.PathLike", f) + with open(f, "rb") as readable: + content = readable.read() + return content + + +def _save_bytes(content: bytes, f: IO[bytes] | str | os.PathLike) -> None: + if hasattr(f, "write") and callable(typing.cast("IO[bytes]", f).write): + typing.cast("IO[bytes]", f).write(content) + else: + f = typing.cast("str | os.PathLike", f) + with open(f, "wb") as writable: + writable.write(content) + + +def _get_file_path(f: IO[bytes] | str | os.PathLike | None) -> str | None: + if isinstance(f, (str, os.PathLike)): + return os.path.abspath(f) + if hasattr(f, "name"): + assert f is not None + return os.path.abspath(f.name) + return None + + +def _get_serializer( + fmt: _SupportedFormat | None, f: str | os.PathLike | IO[bytes] | None = None +) -> serialization.ProtoSerializer: + """Get the serializer for the given path and format from the serialization registry.""" + # Use fmt if it is specified + if fmt is not None: + return serialization.registry.get(fmt) + + if (file_path := _get_file_path(f)) is not None: + _, ext = os.path.splitext(file_path) + fmt = serialization.registry.get_format_from_file_extension(ext) + + # Failed to resolve format if fmt is None. Use protobuf as default + fmt = fmt or _DEFAULT_FORMAT + assert fmt is not None + + return serialization.registry.get(fmt) + + +def load_model( + f: IO[bytes] | str | os.PathLike, + format: _SupportedFormat | None = None, # noqa: A002 + load_external_data: bool = True, +) -> ModelProto: + """Loads a serialized ModelProto into memory. + + Args: + f: can be a file-like object (has "read" function) or a string/PathLike containing a file name + format: The serialization format. When it is not specified, it is inferred + from the file extension when ``f`` is a path. If not specified _and_ + ``f`` is not a path, 'protobuf' is used. The encoding is assumed to + be "utf-8" when the format is a text format. + load_external_data: Whether to load the external data. + Set to True if the data is under the same directory of the model. + If not, users need to call :func:`load_external_data_for_model` + with directory to load external data from. + + Returns: + Loaded in-memory ModelProto. + """ + model = _get_serializer(format, f).deserialize_proto(_load_bytes(f), ModelProto()) + + if load_external_data: + model_filepath = _get_file_path(f) + if model_filepath: + base_dir = os.path.dirname(model_filepath) + load_external_data_for_model(model, base_dir) + + return model + + +def load_tensor( + f: IO[bytes] | str | os.PathLike, + format: _SupportedFormat | None = None, # noqa: A002 +) -> TensorProto: + """Loads a serialized TensorProto into memory. + + Args: + f: can be a file-like object (has "read" function) or a string/PathLike containing a file name + format: The serialization format. When it is not specified, it is inferred + from the file extension when ``f`` is a path. If not specified _and_ + ``f`` is not a path, 'protobuf' is used. The encoding is assumed to + be "utf-8" when the format is a text format. + + Returns: + Loaded in-memory TensorProto. + """ + return _get_serializer(format, f).deserialize_proto(_load_bytes(f), TensorProto()) + + +def load_model_from_string( + s: bytes | str, + format: _SupportedFormat = _DEFAULT_FORMAT, # noqa: A002 +) -> ModelProto: + """Loads a binary string (bytes) that contains serialized ModelProto. + + Args: + s: a string, which contains serialized ModelProto + format: The serialization format. When it is not specified, it is inferred + from the file extension when ``f`` is a path. If not specified _and_ + ``f`` is not a path, 'protobuf' is used. The encoding is assumed to + be "utf-8" when the format is a text format. + + Returns: + Loaded in-memory ModelProto. + """ + return _get_serializer(format).deserialize_proto(s, ModelProto()) + + +def load_tensor_from_string( + s: bytes, + format: _SupportedFormat = _DEFAULT_FORMAT, # noqa: A002 +) -> TensorProto: + """Loads a binary string (bytes) that contains serialized TensorProto. + + Args: + s: a string, which contains serialized TensorProto + format: The serialization format. When it is not specified, it is inferred + from the file extension when ``f`` is a path. If not specified _and_ + ``f`` is not a path, 'protobuf' is used. The encoding is assumed to + be "utf-8" when the format is a text format. + + Returns: + Loaded in-memory TensorProto. + """ + return _get_serializer(format).deserialize_proto(s, TensorProto()) + + +def save_model( + proto: ModelProto | bytes, + f: IO[bytes] | str | os.PathLike, + format: _SupportedFormat | None = None, # noqa: A002 + *, + save_as_external_data: bool = False, + all_tensors_to_one_file: bool = True, + location: str | None = None, + size_threshold: int = 1024, + convert_attribute: bool = False, +) -> None: + """Saves the ModelProto to the specified path and optionally, serialize tensors with raw data as external data before saving. + + Args: + proto: should be a in-memory ModelProto + f: can be a file-like object (has "write" function) or a string containing + a file name or a pathlike object + format: The serialization format. When it is not specified, it is inferred + from the file extension when ``f`` is a path. If not specified _and_ + ``f`` is not a path, 'protobuf' is used. The encoding is assumed to + be "utf-8" when the format is a text format. + save_as_external_data: If true, save tensors to external file(s). + all_tensors_to_one_file: Effective only if save_as_external_data is True. + If true, save all tensors to one external file specified by location. + If false, save each tensor to a file named with the tensor name. + location: Effective only if save_as_external_data is true. + Specify the external file that all tensors to save to. + Path is relative to the model path. + If not specified, will use the model name. + size_threshold: Effective only if save_as_external_data is True. + Threshold for size of data. Only when tensor's data is >= the size_threshold it will be converted + to external data. To convert every tensor with raw data to external data set size_threshold=0. + convert_attribute: Effective only if save_as_external_data is True. + If true, convert all tensors to external data + If false, convert only non-attribute tensors to external data + """ + if isinstance(proto, bytes): + proto = _get_serializer(_DEFAULT_FORMAT).deserialize_proto(proto, ModelProto()) + + if save_as_external_data: + convert_model_to_external_data( + proto, all_tensors_to_one_file, location, size_threshold, convert_attribute + ) + + model_filepath = _get_file_path(f) + if model_filepath is not None: + basepath = os.path.dirname(model_filepath) + proto = write_external_data_tensors(proto, basepath) + + serialized = _get_serializer(format, model_filepath).serialize_proto(proto) + _save_bytes(serialized, f) + + +def save_tensor( + proto: TensorProto, + f: IO[bytes] | str | os.PathLike, + format: _SupportedFormat | None = None, # noqa: A002 +) -> None: + """Saves the TensorProto to the specified path. + + Args: + proto: should be a in-memory TensorProto + f: can be a file-like object (has "write" function) or a string + containing a file name or a pathlike object. + format: The serialization format. When it is not specified, it is inferred + from the file extension when ``f`` is a path. If not specified _and_ + ``f`` is not a path, 'protobuf' is used. The encoding is assumed to + be "utf-8" when the format is a text format. + """ + serialized = _get_serializer(format, f).serialize_proto(proto) + _save_bytes(serialized, f) + + +# For backward compatibility +load = load_model +load_from_string = load_model_from_string +save = save_model + + +def _model_proto_repr(self: ModelProto) -> str: + if self.domain: + domain = f", domain='{self.domain}'" + else: + domain = "" + if self.producer_name: + producer_name = f", producer_name='{self.producer_name}'" + else: + producer_name = "" + if self.producer_version: + producer_version = f", producer_version='{self.producer_version}'" + else: + producer_version = "" + if self.graph: + graph = f", graph={self.graph!r}" + else: + graph = "" + if self.functions: + functions = f", functions=<{len(self.functions)} functions>" + else: + functions = "" + if self.opset_import: + opset_import = f", opset_import={_operator_set_protos_repr(self.opset_import)}" + else: + opset_import = "" + return f"ModelProto(ir_version={self.ir_version}{opset_import}{domain}{producer_name}{producer_version}{graph}{functions})" + + +def _graph_proto_repr(self: GraphProto) -> str: + if self.initializer: + initializer = f", initializer=<{len(self.initializer)} initializers>" + else: + initializer = "" + if self.node: + node = f", node=<{len(self.node)} nodes>" + else: + node = "" + if self.value_info: + value_info = f", value_info=<{len(self.value_info)} value_info>" + else: + value_info = "" + if self.input: + input = f", input=<{len(self.input)} inputs>" + else: + input = "" + if self.output: + output = f", output=<{len(self.output)} outputs>" + else: + output = "" + return f"GraphProto('{self.name}'{input}{output}{initializer}{node}{value_info})" + + +def _function_proto_repr(self: FunctionProto) -> str: + if self.domain: + domain = f", domain='{self.domain}'" + else: + domain = "" + if self.overload: + overload = f", overload='{self.overload}'" + else: + overload = "" + if self.node: + node = f", node=<{len(self.node)} nodes>" + else: + node = "" + if self.attribute: + attribute = f", attribute={self.attribute}" + else: + attribute = "" + if self.opset_import: + opset_import = f", opset_import={_operator_set_protos_repr(self.opset_import)}" + else: + opset_import = "" + if self.input: + input = f", input=<{len(self.input)} inputs>" + else: + input = "" + if self.output: + output = f", output=<{len(self.output)} outputs>" + else: + output = "" + return f"FunctionProto('{self.name}'{domain}{overload}{opset_import}{input}{output}{attribute}{node})" + + +def _operator_set_protos_repr(protos: Sequence[OperatorSetIdProto]) -> str: + opset_imports = {proto.domain: proto.version for proto in protos} + return repr(opset_imports) + + +# Override __repr__ for some proto classes to make it more efficient +ModelProto.__repr__ = _model_proto_repr # type: ignore[method-assign,assignment] +GraphProto.__repr__ = _graph_proto_repr # type: ignore[method-assign,assignment] +FunctionProto.__repr__ = _function_proto_repr # type: ignore[method-assign,assignment] diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/_mapping.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/_mapping.py new file mode 100644 index 0000000000000000000000000000000000000000..ff4a602bdc0ace986d2d330790b3abe385618d3d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/_mapping.py @@ -0,0 +1,119 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import NamedTuple + +import ml_dtypes +import numpy as np + +from onnx.onnx_pb import TensorProto + + +class TensorDtypeMap(NamedTuple): + np_dtype: np.dtype + storage_dtype: int + name: str + + +# tensor_dtype: (numpy type, storage type, string name) +# The storage type is the type used to store the tensor in the *_data field of +# a TensorProto. All available fields are float_data, int32_data, int64_data, +# string_data, uint64_data and double_data. +TENSOR_TYPE_MAP: dict[int, TensorDtypeMap] = { + int(TensorProto.FLOAT): TensorDtypeMap( + np.dtype("float32"), int(TensorProto.FLOAT), "TensorProto.FLOAT" + ), + int(TensorProto.UINT8): TensorDtypeMap( + np.dtype("uint8"), int(TensorProto.INT32), "TensorProto.UINT8" + ), + int(TensorProto.INT8): TensorDtypeMap( + np.dtype("int8"), int(TensorProto.INT32), "TensorProto.INT8" + ), + int(TensorProto.UINT16): TensorDtypeMap( + np.dtype("uint16"), int(TensorProto.INT32), "TensorProto.UINT16" + ), + int(TensorProto.INT16): TensorDtypeMap( + np.dtype("int16"), int(TensorProto.INT32), "TensorProto.INT16" + ), + int(TensorProto.INT32): TensorDtypeMap( + np.dtype("int32"), int(TensorProto.INT32), "TensorProto.INT32" + ), + int(TensorProto.INT64): TensorDtypeMap( + np.dtype("int64"), int(TensorProto.INT64), "TensorProto.INT64" + ), + int(TensorProto.BOOL): TensorDtypeMap( + np.dtype("bool"), int(TensorProto.INT32), "TensorProto.BOOL" + ), + int(TensorProto.FLOAT16): TensorDtypeMap( + np.dtype("float16"), int(TensorProto.INT32), "TensorProto.FLOAT16" + ), + int(TensorProto.BFLOAT16): TensorDtypeMap( + np.dtype(ml_dtypes.bfloat16), + int(TensorProto.INT32), + "TensorProto.BFLOAT16", + ), + int(TensorProto.DOUBLE): TensorDtypeMap( + np.dtype("float64"), int(TensorProto.DOUBLE), "TensorProto.DOUBLE" + ), + int(TensorProto.COMPLEX64): TensorDtypeMap( + np.dtype("complex64"), int(TensorProto.FLOAT), "TensorProto.COMPLEX64" + ), + int(TensorProto.COMPLEX128): TensorDtypeMap( + np.dtype("complex128"), + int(TensorProto.DOUBLE), + "TensorProto.COMPLEX128", + ), + int(TensorProto.UINT32): TensorDtypeMap( + np.dtype("uint32"), int(TensorProto.UINT64), "TensorProto.UINT32" + ), + int(TensorProto.UINT64): TensorDtypeMap( + np.dtype("uint64"), int(TensorProto.UINT64), "TensorProto.UINT64" + ), + int(TensorProto.STRING): TensorDtypeMap( + np.dtype("object"), int(TensorProto.STRING), "TensorProto.STRING" + ), + int(TensorProto.FLOAT8E4M3FN): TensorDtypeMap( + np.dtype(ml_dtypes.float8_e4m3fn), + int(TensorProto.INT32), + "TensorProto.FLOAT8E4M3FN", + ), + int(TensorProto.FLOAT8E4M3FNUZ): TensorDtypeMap( + np.dtype(ml_dtypes.float8_e4m3fnuz), + int(TensorProto.INT32), + "TensorProto.FLOAT8E4M3FNUZ", + ), + int(TensorProto.FLOAT8E5M2): TensorDtypeMap( + np.dtype(ml_dtypes.float8_e5m2), + int(TensorProto.INT32), + "TensorProto.FLOAT8E5M2", + ), + int(TensorProto.FLOAT8E5M2FNUZ): TensorDtypeMap( + np.dtype(ml_dtypes.float8_e5m2fnuz), + int(TensorProto.INT32), + "TensorProto.FLOAT8E5M2FNUZ", + ), + int(TensorProto.UINT4): TensorDtypeMap( + np.dtype(ml_dtypes.uint4), int(TensorProto.INT32), "TensorProto.UINT4" + ), + int(TensorProto.INT4): TensorDtypeMap( + np.dtype(ml_dtypes.int4), int(TensorProto.INT32), "TensorProto.INT4" + ), + int(TensorProto.FLOAT4E2M1): TensorDtypeMap( + np.dtype(ml_dtypes.float4_e2m1fn), + int(TensorProto.INT32), + "TensorProto.FLOAT4E2M1", + ), + int(TensorProto.FLOAT8E8M0): TensorDtypeMap( + np.dtype(ml_dtypes.float8_e8m0fnu), + int(TensorProto.INT32), + "TensorProto.FLOAT8E8M0", + ), + int(TensorProto.UINT2): TensorDtypeMap( + np.dtype(ml_dtypes.uint2), int(TensorProto.INT32), "TensorProto.UINT2" + ), + int(TensorProto.INT2): TensorDtypeMap( + np.dtype(ml_dtypes.int2), int(TensorProto.INT32), "TensorProto.INT2" + ), +} diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c974dafd7dddc454b4c0208797d4e35a6c7b1ab2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/base.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/base.py new file mode 100644 index 0000000000000000000000000000000000000000..c4fd7654aaee8baebab72272257af18c33697c9a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/base.py @@ -0,0 +1,148 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from collections import namedtuple +from typing import TYPE_CHECKING, Any, NewType + +import onnx.checker +import onnx.onnx_cpp2py_export.checker as c_checker +from onnx import IR_VERSION, ModelProto, NodeProto + +if TYPE_CHECKING: + from collections.abc import Sequence + + import numpy + + +class DeviceType: + """Describes device type.""" + + _Type = NewType("_Type", int) + CPU: _Type = _Type(0) + CUDA: _Type = _Type(1) + + +class Device: + """Describes device type and device id + syntax: device_type:device_id(optional) + example: 'CPU', 'CUDA', 'CUDA:1' + """ + + def __init__(self, device: str) -> None: + options = device.split(":") + self.type = getattr(DeviceType, options[0]) + self.device_id = 0 + if len(options) > 1: + self.device_id = int(options[1]) + + +def namedtupledict( + typename: str, field_names: Sequence[str], *args: Any, **kwargs: Any +) -> type[tuple[Any, ...]]: + field_names_map = {n: i for i, n in enumerate(field_names)} + # Some output names are invalid python identifier, e.g. "0" + kwargs.setdefault("rename", True) + data = namedtuple(typename, field_names, *args, **kwargs) # type: ignore[misc] # noqa: PYI024 + + def getitem(self: Any, key: Any) -> Any: + if isinstance(key, str): + key = field_names_map[key] + return super(type(self), self).__getitem__(key) + + data.__getitem__ = getitem # type: ignore[method-assign] + return data + + +class BackendRep: + """BackendRep is the handle that a Backend returns after preparing to execute + a model repeatedly. Users will then pass inputs to the run function of + BackendRep to retrieve the corresponding results. + """ + + def run(self, inputs: Any, **kwargs: Any) -> tuple[Any, ...]: # noqa: ARG002 + """Abstract function.""" + return (None,) + + +class Backend: + """Backend is the entity that will take an ONNX model with inputs, + perform a computation, and then return the output. + + For one-off execution, users can use run_node and run_model to obtain results quickly. + + For repeated execution, users should use prepare, in which the Backend + does all of the preparation work for executing the model repeatedly + (e.g., loading initializers), and returns a BackendRep handle. + """ + + @classmethod + def is_compatible( + cls, + model: ModelProto, # noqa: ARG003 + device: str = "CPU", # noqa: ARG003 + **kwargs: Any, # noqa: ARG003 + ) -> bool: + # Return whether the model is compatible with the backend. + return True + + @classmethod + def prepare( + cls, + model: ModelProto, + device: str = "CPU", # noqa: ARG003 + **kwargs: Any, # noqa: ARG003 + ) -> BackendRep | None: + # TODO Remove Optional from return type + onnx.checker.check_model(model) + return None + + @classmethod + def run_model( + cls, model: ModelProto, inputs: Any, device: str = "CPU", **kwargs: Any + ) -> tuple[Any, ...]: + backend = cls.prepare(model, device, **kwargs) + assert backend is not None + return backend.run(inputs) + + @classmethod + def run_node( + cls, + node: NodeProto, + inputs: Any, # noqa: ARG003 + device: str = "CPU", # noqa: ARG003 + outputs_info: ( # noqa: ARG003 + Sequence[tuple[numpy.dtype, tuple[int, ...]]] | None + ) = None, + **kwargs: dict[str, Any], + ) -> tuple[Any, ...] | None: + """Simple run one operator and return the results. + + Args: + node: The node proto. + inputs: Inputs to the node. + device: The device to run on. + outputs_info: a list of tuples, which contains the element type and + shape of each output. First element of the tuple is the dtype, and + the second element is the shape. More use case can be found in + https://github.com/onnx/onnx/blob/main/onnx/backend/test/runner/__init__.py + kwargs: Other keyword arguments. + """ + # TODO Remove Optional from return type + if "opset_version" in kwargs: + special_context = c_checker.CheckerContext() + special_context.ir_version = IR_VERSION + special_context.opset_imports = {"": kwargs["opset_version"]} # type: ignore[dict-item] + onnx.checker.check_node(node, special_context) + else: + onnx.checker.check_node(node) + + return None + + @classmethod + def supports_device(cls, device: str) -> bool: # noqa: ARG003 + """Checks whether the backend is compiled with particular device support. + In particular it's used in the testing suite. + """ + return True diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e790f2403b446c1bb07eff20fa54f34f50735bab --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/ops/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/ops/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dbdaf610915032546aca0a05404d2c0ea2c62ad9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/ops/__init__.py @@ -0,0 +1,30 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import importlib +import inspect +import pkgutil +import sys +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from types import ModuleType + + +def collect_sample_implementations() -> dict[str, str]: + dict_: dict[str, str] = {} + _recursive_scan(sys.modules[__name__], dict_) + return dict_ + + +def _recursive_scan(package: ModuleType, dict_: dict[str, str]) -> None: + pkg_dir = package.__path__ + module_location = package.__name__ + for _module_loader, name, ispkg in pkgutil.iter_modules(pkg_dir): + module_name = f"{module_location}.{name}" # Module/package + module = importlib.import_module(module_name) + dict_[name] = inspect.getsource(module) + if ispkg: + _recursive_scan(module, dict_) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/ops/abs.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/ops/abs.py new file mode 100644 index 0000000000000000000000000000000000000000..d76cc5e9e215f67ffacfcf0f0ecd6d2295673ec0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/sample/ops/abs.py @@ -0,0 +1,8 @@ +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + + +def abs(input: np.ndarray) -> np.ndarray: # noqa: A001 + return np.abs(input) # type: ignore[no-any-return] diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f38efa7b54e39c7356b56ddcd477c568987c74e6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +__all__ = ["BackendTest"] +# for backward compatibility +from onnx.backend.test.runner import Runner as BackendTest diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f78d28852326bb5975c0235ba4978983b20a6e58 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/__init__.py @@ -0,0 +1,14 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import sys + +from onnx.backend.test.case.base import Snippets +from onnx.backend.test.case.utils import import_recursive + + +def collect_snippets() -> dict[str, list[tuple[str, str]]]: + import_recursive(sys.modules[__name__]) + return Snippets diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/base.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/base.py new file mode 100644 index 0000000000000000000000000000000000000000..b979fade2143491651bf92dc1cbb92ee732316fe --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/base.py @@ -0,0 +1,47 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import inspect +from collections import defaultdict +from textwrap import dedent +from typing import Any, ClassVar + +import numpy as np + + +def process_snippet(op_name: str, name: str, export: Any) -> tuple[str, str]: + snippet_name = name[len("export_") :] or op_name.lower() + source_code = dedent(inspect.getsource(export)) + # remove the function signature line + lines = source_code.splitlines() + assert lines[0] == "@staticmethod" + assert lines[1].startswith("def export") + return snippet_name, dedent("\n".join(lines[2:])) + + +Snippets: dict[str, list[tuple[str, str]]] = defaultdict(list) + + +class _Exporter(type): + exports: ClassVar[dict[str, list[tuple[str, str]]]] = defaultdict(list) + + def __init__( + cls, name: str, bases: tuple[type[Any], ...], dct: dict[str, Any] + ) -> None: + for k, v in dct.items(): + if k.startswith("export"): + if not isinstance(v, staticmethod): + raise ValueError("Only staticmethods could be named as export.*") + export = getattr(cls, k) + Snippets[name].append(process_snippet(name, k, export)) + # export functions should call expect and so populate + # TestCases + np.random.seed(seed=0) + export() + super().__init__(name, bases, dct) + + +class Base(metaclass=_Exporter): + pass diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75dfb8d75811af50a05cf331ec4d7882bb31fdc6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/__init__.py @@ -0,0 +1,81 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import sys +from typing import TYPE_CHECKING + +from onnx.backend.test.case.test_case import TestCase +from onnx.backend.test.case.utils import import_recursive + +if TYPE_CHECKING: + from collections.abc import Sequence + + import numpy as np + + from onnx import ModelProto + +_SimpleModelTestCases = [] + + +def expect( + model: ModelProto, + inputs: Sequence[np.ndarray], + outputs: Sequence[np.ndarray], + name: str | None = None, +) -> None: + name = name or model.graph.name + _SimpleModelTestCases.append( + TestCase( + name=name, + model_name=model.graph.name, + url=None, + model_dir=None, + model=model, + data_sets=[(inputs, outputs)], + kind="simple", + rtol=1e-3, + atol=1e-7, + ) + ) + + +BASE_URL = "onnx/backend/test/data/light/light_%s.onnx" + + +def collect_testcases() -> list[TestCase]: + """Collect model test cases defined in python/numpy code.""" + real_model_testcases = [] + + model_tests = [ + ("test_bvlc_alexnet", "bvlc_alexnet", 1e-3, 1e-7), + ("test_densenet121", "densenet121", 2e-3, 1e-7), + ("test_inception_v1", "inception_v1", 1e-3, 1e-7), + ("test_inception_v2", "inception_v2", 1e-3, 1e-7), + ("test_resnet50", "resnet50", 1e-3, 1e-7), + ("test_shufflenet", "shufflenet", 1e-3, 1e-7), + ("test_squeezenet", "squeezenet", 1e-3, 1e-7), + ("test_vgg19", "vgg19", 1e-3, 1e-7), + ("test_zfnet512", "zfnet512", 1e-3, 1e-7), + ] + + for test_name, model_name, rtol, atol in model_tests: + url = BASE_URL % model_name + real_model_testcases.append( + TestCase( + name=test_name, + model_name=model_name, + url=url, + model_dir=None, + model=None, + data_sets=None, + kind="real", + rtol=rtol, + atol=atol, + ) + ) + + import_recursive(sys.modules[__name__]) + + return real_model_testcases + _SimpleModelTestCases diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/expand.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/expand.py new file mode 100644 index 0000000000000000000000000000000000000000..b99ed469b31124bee375b8ce7cc6867181696581 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/expand.py @@ -0,0 +1,91 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import TYPE_CHECKING + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + +if TYPE_CHECKING: + from collections.abc import Sequence + + +class ExpandDynamicShape(Base): + @staticmethod + def export() -> None: + def make_graph( + node: onnx.helper.NodeProto, + input_shape: Sequence[int], + shape_shape: Sequence[int], + output_shape: Sequence[int], + ) -> onnx.helper.GraphProto: + return onnx.helper.make_graph( + nodes=[node], + name="Expand", + inputs=[ + onnx.helper.make_tensor_value_info( + "X", onnx.TensorProto.FLOAT, input_shape + ), + onnx.helper.make_tensor_value_info( + "shape", onnx.TensorProto.INT64, shape_shape + ), + ], + outputs=[ + onnx.helper.make_tensor_value_info( + "Y", onnx.TensorProto.FLOAT, output_shape + ) + ], + ) + + node = onnx.helper.make_node("Expand", ["X", "shape"], ["Y"], name="test") + input_shape = [1, 3, 1] + x = np.ones(input_shape, dtype=np.float32) + + # 1st testcase + shape = np.array([3, 1], dtype=np.int64) + y = x * np.ones(shape, dtype=np.float32) + graph = make_graph(node, input_shape, shape.shape, y.shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model1") + + # 2nd testcase + shape = np.array([1, 3], dtype=np.int64) + y = x * np.ones(shape, dtype=np.float32) + graph = make_graph(node, input_shape, shape.shape, y.shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model2") + + # 3rd testcase + shape = np.array([3, 1, 3], dtype=np.int64) + y = x * np.ones(shape, dtype=np.float32) + graph = make_graph(node, input_shape, shape.shape, y.shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model3") + + # 4th testcase + shape = np.array([3, 3, 1, 3], dtype=np.int64) + y = x * np.ones(shape, dtype=np.float32) + graph = make_graph(node, input_shape, shape.shape, y.shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model4") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/gradient.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..947ee2c94002f35aca60a4e6a652999c32dc335b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/gradient.py @@ -0,0 +1,110 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect +from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN, ONNX_DOMAIN + + +class Gradient(Base): + @staticmethod + def export_gradient_scalar_add() -> None: + add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add") + gradient_node = onnx.helper.make_node( + "Gradient", + ["a", "b"], + ["dc_da", "dc_db"], + name="my_gradient", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + xs=["a", "b"], + y="c", + ) + + a = np.array(1.0).astype(np.float32) + b = np.array(2.0).astype(np.float32) + c = a + b + # dc / da = d(a+b) / da = 1 + dc_da = np.array(1).astype(np.float32) + # db / db = d(a+b) / db = 1 + dc_db = np.array(1).astype(np.float32) + + graph = onnx.helper.make_graph( + nodes=[add_node, gradient_node], + name="GradientOfAdd", + inputs=[ + onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []), + ], + outputs=[ + onnx.helper.make_tensor_value_info("c", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("dc_da", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("dc_db", onnx.TensorProto.FLOAT, []), + ], + ) + opsets = [ + onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12), + onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1), + ] + model = onnx.helper.make_model_gen_version( + graph, producer_name="backend-test", opset_imports=opsets + ) + expect( + model, inputs=[a, b], outputs=[c, dc_da, dc_db], name="test_gradient_of_add" + ) + + @staticmethod + def export_gradient_scalar_add_and_mul() -> None: + add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add") + mul_node = onnx.helper.make_node("Mul", ["c", "a"], ["d"], name="my_mul") + gradient_node = onnx.helper.make_node( + "Gradient", + ["a", "b"], + ["dd_da", "dd_db"], + name="my_gradient", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + xs=["a", "b"], + y="d", + ) + + a = np.array(1.0).astype(np.float32) + b = np.array(2.0).astype(np.float32) + c = a + b + # d = a * c = a * (a + b) + d = a * c + # dd / da = d(a*a+a*b) / da = 2 * a + b + dd_da = (2 * a + b).astype(np.float32) + # dd / db = d(a*a+a*b) / db = a + dd_db = a + + graph = onnx.helper.make_graph( + nodes=[add_node, mul_node, gradient_node], + name="GradientOfTwoOperators", + inputs=[ + onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []), + ], + outputs=[ + onnx.helper.make_tensor_value_info("d", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("dd_da", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("dd_db", onnx.TensorProto.FLOAT, []), + ], + ) + + opsets = [ + onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12), + onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1), + ] + model = onnx.helper.make_model_gen_version( + graph, producer_name="backend-test", opset_imports=opsets + ) + expect( + model, + inputs=[a, b], + outputs=[d, dd_da, dd_db], + name="test_gradient_of_add_and_mul", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/sequence.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/sequence.py new file mode 100644 index 0000000000000000000000000000000000000000..9ac4513caf10c8da5d118feff2b6ce2c67d68325 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/sequence.py @@ -0,0 +1,456 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import typing + +import numpy as np + +import onnx +from onnx import TensorProto +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +def SequenceEmptyImpl() -> list[np.ndarray | None]: + return [] + + +def SequenceConstructImpl(*tensors: np.ndarray) -> list[np.ndarray]: + return list(tensors) + + +def SequenceInsertImpl( + sequence: list[np.ndarray], tensor: np.ndarray, position: int | None = None +) -> list[np.ndarray]: + if position is None: + position = len(sequence) + sequence.insert(position, tensor) + return sequence + + +def SequenceAtImpl(sequence: list[np.ndarray], position: int) -> np.ndarray: + return sequence[position] + + +def SequenceEraseImpl( + sequence: list[np.ndarray], position: int | None = None +) -> list[np.ndarray | None]: + if position is None: + position = -1 + del sequence[position] + return sequence + + +def SequenceLengthImpl(sequence: list[np.ndarray]) -> np.int64: + return np.int64(len(sequence)) + + +def SplitToSequenceImpl( + tensor: np.ndarray, + split: int | list[int] | None = None, + axis: int = 0, + keepdims: int = 1, +) -> list[np.ndarray]: + dim_size = tensor.shape[axis] + if split is None: + split = 1 + split_indices = [ + i * split + 1 for i in range(dim_size) if i * split + 1 < dim_size + ] + if not keepdims: + results = np.array_split(tensor, split_indices, axis) + return [np.squeeze(res, axis) for res in results] + if np.isscalar(split): + split_indices = [ + i * split + 1 for i in range(dim_size) if i * split + 1 < dim_size + ] + else: + split_indices = np.cumsum(split) + 1 + return np.array_split(tensor, split_indices, axis) + + +def ConcatFromSequenceImpl( + sequence: list[np.ndarray], axis: int, new_axis: int | None = 0 +) -> np.ndarray: + if not new_axis: + return np.concatenate(sequence, axis) + return np.stack(sequence, axis) + + +class Sequence(Base): + @staticmethod + def export() -> None: + def make_graph( + nodes: list[onnx.helper.NodeProto], + input_shapes: list[typing.Sequence[str | int] | None], + output_shapes: list[typing.Sequence[str | int] | None], + input_names: list[str], + output_names: list[str], + input_types: list[TensorProto.DataType], + output_types: list[TensorProto.DataType], + initializers: list[TensorProto] | None = None, + ) -> onnx.helper.GraphProto: + return onnx.helper.make_graph( + nodes=nodes, + name="Sequence", + inputs=[ + onnx.helper.make_tensor_value_info(name, input_type, input_shape) + for name, input_type, input_shape in zip( + input_names, input_types, input_shapes, strict=False + ) + ], + outputs=[ + onnx.helper.make_tensor_value_info(name, output_type, output_shape) + for name, output_type, output_shape in zip( + output_names, output_types, output_shapes, strict=False + ) + ], + initializer=initializers, + ) + + # 1st testcase - insert and at. + # 1. SequenceEmpty: -> [] + # 2. SequenceInsert(x): -> [x] + # 3. SequenceInsert(y): -> [x, y] + # 4. SequenceInsert(z, 1): -> [x, z, y] + # 5. SequenceAt(2): -> y + seq_empty_node = onnx.helper.make_node("SequenceEmpty", [], ["Seq_empty"]) + seq_insert_node = onnx.helper.make_node( + "SequenceInsert", ["Seq_empty", "X"], ["Seq_1"] + ) + seq_insert_node2 = onnx.helper.make_node( + "SequenceInsert", ["Seq_1", "Y"], ["Seq_2"] + ) + seq_insert_node3 = onnx.helper.make_node( + "SequenceInsert", ["Seq_2", "Z", "pos"], ["Seq_3"] + ) + seq_at_node = onnx.helper.make_node("SequenceAt", ["Seq_3", "pos_at"], ["out"]) + + x_shape = [2, 3, 4] + y_shape = [1, 3, 4] + z_shape = [3, 3, 4] + out_shape = [None, 3, 4] + + x = np.ones(x_shape, dtype=np.float32) + y = np.zeros(y_shape, dtype=np.float32) + z = np.ones(z_shape, dtype=np.float32) * 2 + pos_val = 1 + pos_at_val = 2 + + out = SequenceEmptyImpl() + out = SequenceInsertImpl(out, x) + out = SequenceInsertImpl(out, y) + out = SequenceInsertImpl(out, z, pos_val) + out = SequenceAtImpl(out, pos_at_val) + assert np.array_equal(out, y) + + pos = onnx.helper.make_tensor("pos", TensorProto.INT64, (), (pos_val,)) + pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,)) + + graph = make_graph( + [ + seq_empty_node, + seq_insert_node, + seq_insert_node2, + seq_insert_node3, + seq_at_node, + ], + [x_shape, y_shape, z_shape, [], []], + [out_shape], + ["X", "Y", "Z", "pos", "pos_at"], + ["out"], + [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 2, + [onnx.TensorProto.FLOAT], + [pos, pos_at], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model1") + + # 2nd testcase - erase and at. + # 1. SequenceConstruct(x, y, z): -> [x, y, z] + # 2. SequenceErase(1): -> [x, z] + # 3. SequenceAt(1): -> z + seq_construct_node = onnx.helper.make_node( + "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"] + ) + seq_erase_node = onnx.helper.make_node( + "SequenceErase", ["seq_1", "pos_erase"], ["seq_2"] + ) + seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_2", "pos_at"], ["out"]) + + tensor_shape = [2, 3, 4] + + x = np.ones(tensor_shape, dtype=np.float32) + y = np.zeros(tensor_shape, dtype=np.float32) + z = np.ones(tensor_shape, dtype=np.float32) * 2 + pos_erase_val = 1 + pos_at_val = 1 + + out = SequenceConstructImpl(x, y, z) + out = SequenceEraseImpl(out, pos_erase_val) + out = SequenceAtImpl(out, pos_at_val) + assert np.array_equal(out, z) + + pos_erase = onnx.helper.make_tensor( + "pos_erase", TensorProto.INT64, (), (pos_erase_val,) + ) + pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,)) + + graph = make_graph( + [seq_construct_node, seq_erase_node, seq_at_node], + [tensor_shape, tensor_shape, tensor_shape, [], []], + [tensor_shape], + ["X", "Y", "Z", "pos_erase", "pos_at"], + ["out"], + [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 2, + [onnx.TensorProto.FLOAT], + [pos_erase, pos_at], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model2") + + # 3rd testcase - erase, insert and at, with negative index value. + # 1. SequenceConstruct(x, y, z): -> [x, y, z] + # 2. SequenceErase(-3): -> [y, z] + # 3. SequenceInsert(x, -1): -> [y, x, z] + # 4. SequenceAt(-1): -> z + seq_construct_node = onnx.helper.make_node( + "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"] + ) + seq_erase_node = onnx.helper.make_node( + "SequenceErase", ["seq_1", "pos_erase"], ["seq_2"] + ) + seq_insert_node = onnx.helper.make_node( + "SequenceInsert", ["seq_2", "X", "pos_insert"], ["seq_3"] + ) + seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_3", "pos_at"], ["out"]) + + tensor_shape = [2, 3, 4] + + x = np.ones(tensor_shape, dtype=np.float32) + y = np.zeros(tensor_shape, dtype=np.float32) + z = np.ones(tensor_shape, dtype=np.float32) * 2 + pos_erase_val = -3 + pos_insert_val = -1 + pos_at_val = -1 + out = SequenceConstructImpl(x, y, z) + out = SequenceEraseImpl(out, pos_erase_val) + out = SequenceInsertImpl(out, x, pos_insert_val) + out = SequenceAtImpl(out, pos_at_val) + assert np.array_equal(out, z) + + pos_erase = onnx.helper.make_tensor( + "pos_erase", TensorProto.INT64, (), (pos_erase_val,) + ) + pos_insert = onnx.helper.make_tensor( + "pos_insert", TensorProto.INT64, (), (pos_insert_val,) + ) + pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,)) + + graph = make_graph( + [seq_construct_node, seq_erase_node, seq_insert_node, seq_at_node], + [tensor_shape, tensor_shape, tensor_shape, [], [], []], + [tensor_shape], + ["X", "Y", "Z", "pos_erase", "pos_insert", "pos_at"], + ["out"], + [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 3, + [onnx.TensorProto.FLOAT], + [pos_erase, pos_insert, pos_at], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model3") + + # 4th testcase - concat + seq_construct_node = onnx.helper.make_node( + "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"] + ) + seq_concat_node = onnx.helper.make_node( + "ConcatFromSequence", ["seq_1"], ["out"], axis=1 + ) + + tensor_shape = [2, 3, 4] + concat_out_shape = [2, None, 4] + + x = np.ones(tensor_shape, dtype=np.float32) + y = np.zeros(tensor_shape, dtype=np.float32) + z = np.ones(tensor_shape, dtype=np.float32) * 2 + out = SequenceConstructImpl(x, y, z) + concat_out = ConcatFromSequenceImpl(out, 1) + + graph = make_graph( + [seq_construct_node, seq_concat_node], + [tensor_shape] * 3, + [concat_out_shape], + ["X", "Y", "Z"], + ["out"], + [onnx.TensorProto.FLOAT] * 3, + [onnx.TensorProto.FLOAT], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect( + model, inputs=[x, y, z], outputs=[concat_out], name="test_sequence_model4" + ) + + # 5th testcase - concat with new_axis = 1 + seq_construct_node = onnx.helper.make_node( + "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"] + ) + seq_concat_node = onnx.helper.make_node( + "ConcatFromSequence", ["seq_1"], ["out"], axis=-1, new_axis=1 + ) + + tensor_shape = [2, 3, 4] + concat_out_shape = [2, 3, 4, 3] + + x = np.ones(tensor_shape, dtype=np.float32) + y = np.zeros(tensor_shape, dtype=np.float32) + z = np.ones(tensor_shape, dtype=np.float32) * 2 + out = SequenceConstructImpl(x, y, z) + concat_out = ConcatFromSequenceImpl(out, -1, 1) + + graph = make_graph( + [seq_construct_node, seq_concat_node], + [tensor_shape] * 3, + [concat_out_shape], + ["X", "Y", "Z"], + ["out"], + [onnx.TensorProto.FLOAT] * 3, + [onnx.TensorProto.FLOAT], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect( + model, inputs=[x, y, z], outputs=[concat_out], name="test_sequence_model5" + ) + + # 6th testcase - split and len + seq_split_node = onnx.helper.make_node( + "SplitToSequence", ["X"], ["seq_1"], axis=-1 + ) + seq_len_node = onnx.helper.make_node("SequenceLength", ["seq_1"], ["len"]) + + tensor_shape = [2, 3, 4] + len_shape = [] + + x = np.ones(tensor_shape, dtype=np.float32) + out = SplitToSequenceImpl(x, axis=-1) + out = SequenceLengthImpl(out) + assert np.array_equal(out, np.int64(4)) + + graph = onnx.helper.make_graph( + nodes=[seq_split_node, seq_len_node], + name="Sequence", + inputs=[ + onnx.helper.make_tensor_value_info( + "X", onnx.TensorProto.FLOAT, tensor_shape + ) + ], + outputs=[ + onnx.helper.make_tensor_value_info( + "len", onnx.TensorProto.INT64, len_shape + ) + ], + ) + + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x], outputs=[out], name="test_sequence_model6") + + # 7th testcase - split with keepdims=0, and SequenceAt + seq_split_node = onnx.helper.make_node( + "SplitToSequence", ["X"], ["seq_1"], axis=0, keepdims=0 + ) + seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_1", "pos_at"], ["out"]) + + tensor_shape = [2, 3, 4] + out_shape = [3, 4] + + x = np.random.rand(*tensor_shape) + pos_at_val = 1 + out = SplitToSequenceImpl(x, axis=0, keepdims=0) + out = SequenceAtImpl(out, pos_at_val) + assert np.array_equal(out, x[pos_at_val]) + + pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,)) + + graph = make_graph( + [seq_split_node, seq_at_node], + [tensor_shape, []], + [out_shape], + ["X", "pos_at"], + ["out"], + [onnx.TensorProto.DOUBLE, onnx.TensorProto.INT64], + [onnx.TensorProto.DOUBLE], + [pos_at], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x], outputs=[out], name="test_sequence_model7") + + # 8th testcase - split zero length + seq_split_node = onnx.helper.make_node( + "SplitToSequence", ["X", "Splits"], ["seq_1"] + ) + seq_len_node = onnx.helper.make_node("SequenceLength", ["seq_1"], ["len"]) + + tensor_shape = ["n"] + splits_shape = [3] + + x = np.array([]).astype(np.float32) + splits = np.array([0, 0, 0]).astype(np.int64) + out_len = np.int64(3) + + graph = onnx.helper.make_graph( + nodes=[seq_split_node, seq_len_node], + name="Sequence", + inputs=[ + onnx.helper.make_tensor_value_info( + "X", onnx.TensorProto.FLOAT, tensor_shape + ), + onnx.helper.make_tensor_value_info( + "Splits", onnx.TensorProto.INT64, splits_shape + ), + ], + outputs=[ + onnx.helper.make_tensor_value_info( + "len", onnx.TensorProto.INT64, len_shape + ) + ], + ) + + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect( + model, inputs=[x, splits], outputs=[out_len], name="test_sequence_model8" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/shrink.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/shrink.py new file mode 100644 index 0000000000000000000000000000000000000000..6a4ad6ae18ea159173cd8eeb20f5bd8796c788f9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/shrink.py @@ -0,0 +1,42 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +class ShrinkTest(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Shrink", + ["x"], + ["y"], + lambd=1.5, + bias=1.5, + ) + graph = onnx.helper.make_graph( + nodes=[node], + name="Shrink", + inputs=[ + onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [5]) + ], + outputs=[ + onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [5]) + ], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + + x = np.array([-2.0, -1.0, 0.0, 1.0, 2.0], dtype=np.float32) + y = np.array([-0.5, 0.0, 0.0, 0.0, 0.5], dtype=np.float32) + + expect(model, inputs=[x], outputs=[y], name="test_shrink") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/sign.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/sign.py new file mode 100644 index 0000000000000000000000000000000000000000..59b1b849ad5cd9390bb488a39e1573e478a6a89d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/sign.py @@ -0,0 +1,36 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +class SingleSign(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("Sign", ["x"], ["y"], name="test") + + x = np.array([-1.0, 4.5, -4.5, 3.1, 0.0, 2.4, -5.5]).astype(np.float32) + y = np.array([-1.0, 1.0, -1.0, 1.0, 0.0, 1.0, -1.0]).astype(np.float32) + + graph = onnx.helper.make_graph( + nodes=[node], + name="SingleSign", + inputs=[ + onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [7]) + ], + outputs=[ + onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [7]) + ], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x], outputs=[y], name="test_sign_model") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/single_relu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/single_relu.py new file mode 100644 index 0000000000000000000000000000000000000000..a7f8ab316422280d1a40dc9127782d13d3a60ec7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/single_relu.py @@ -0,0 +1,36 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +class SingleRelu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("Relu", ["x"], ["y"], name="test") + graph = onnx.helper.make_graph( + nodes=[node], + name="SingleRelu", + inputs=[ + onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [1, 2]) + ], + outputs=[ + onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [1, 2]) + ], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + + x = np.random.randn(1, 2).astype(np.float32) + y = np.maximum(x, 0) + + expect(model, inputs=[x], outputs=[y], name="test_single_relu_model") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/stringnormalizer.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/stringnormalizer.py new file mode 100644 index 0000000000000000000000000000000000000000..948ad3663809db2120dbf97310a5ed7858bb8a23 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/model/stringnormalizer.py @@ -0,0 +1,205 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import TYPE_CHECKING + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + +if TYPE_CHECKING: + from collections.abc import Sequence + + +class NormalizeStrings(Base): + @staticmethod + def export() -> None: + def make_graph( + node: onnx.helper.NodeProto, + input_shape: Sequence[int], + output_shape: Sequence[int], + ) -> onnx.helper.GraphProto: + return onnx.helper.make_graph( + nodes=[node], + name="StringNormalizer", + inputs=[ + onnx.helper.make_tensor_value_info( + "x", onnx.TensorProto.STRING, input_shape + ) + ], + outputs=[ + onnx.helper.make_tensor_value_info( + "y", onnx.TensorProto.STRING, output_shape + ) + ], + ) + + # 1st model_monday_casesensintive_nochangecase + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + is_case_sensitive=1, + stopwords=stopwords, + ) + + x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + y = np.array(["tuesday", "wednesday", "thursday"]).astype(object) + + graph = make_graph(node, [4], [3]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_casesensintive_nochangecase", + ) + + # 2nd model_nostopwords_nochangecase + node = onnx.helper.make_node( + "StringNormalizer", inputs=["x"], outputs=["y"], is_case_sensitive=1 + ) + + x = np.array(["monday", "tuesday"]).astype(object) + y = x + + graph = make_graph(node, [2], [2]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_nostopwords_nochangecase", + ) + + # 3rd model_monday_casesensintive_lower + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="LOWER", + is_case_sensitive=1, + stopwords=stopwords, + ) + + x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + y = np.array(["tuesday", "wednesday", "thursday"]).astype(object) + + graph = make_graph(node, [4], [3]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_casesensintive_lower", + ) + + # 4 model_monday_casesensintive_upper + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + is_case_sensitive=1, + stopwords=stopwords, + ) + + x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + y = np.array(["TUESDAY", "WEDNESDAY", "THURSDAY"]).astype(object) + + graph = make_graph(node, [4], [3]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_casesensintive_upper", + ) + + # 5 monday_insensintive_upper_twodim + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + stopwords=stopwords, + ) + + input_shape = [1, 6] + output_shape = [1, 4] + x = ( + np.array( + ["Monday", "tuesday", "wednesday", "Monday", "tuesday", "wednesday"] + ) + .astype(object) + .reshape(input_shape) + ) + y = ( + np.array(["TUESDAY", "WEDNESDAY", "TUESDAY", "WEDNESDAY"]) + .astype(object) + .reshape(output_shape) + ) + + graph = make_graph(node, input_shape, output_shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_insensintive_upper_twodim", + ) + + # 6 monday_empty_output + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + is_case_sensitive=0, + stopwords=stopwords, + ) + + x = np.array(["monday", "monday"]).astype(object) + y = np.array([""]).astype(object) + + graph = make_graph(node, [2], [1]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_empty_output", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4c9eb8d3fdae46bf050d55dd164018b1c4395ea9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/__init__.py @@ -0,0 +1,474 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import subprocess +import sys +from copy import deepcopy +from pathlib import Path +from typing import TYPE_CHECKING, Any + +import onnx +from onnx.backend.test.case.test_case import TestCase +from onnx.backend.test.case.utils import import_recursive +from onnx.onnx_pb import ( + AttributeProto, + FunctionProto, + GraphProto, + ModelProto, + NodeProto, + OperatorSetIdProto, + TensorProto, + TypeProto, +) + +if TYPE_CHECKING: + from collections.abc import Callable, Sequence + + import numpy as np + +_NodeTestCases = [] +_TargetOpType = None +_DiffOpTypes = None +_existing_names: dict[str, onnx.NodeProto] = {} + + +def _rename_edges_helper( + internal_node: NodeProto, + rename_helper: Callable[[str], str], + attribute_map: dict[str, AttributeProto], + prefix: str, +) -> NodeProto: + new_node = NodeProto() + new_node.CopyFrom(internal_node) + new_node.ClearField("input") + new_node.ClearField("output") + new_node.ClearField("attribute") + for internal_name in internal_node.input: + new_node.input.append(rename_helper(internal_name)) + for internal_name in internal_node.output: + new_node.output.append(rename_helper(internal_name)) + for attr in internal_node.attribute: + if attr.HasField("ref_attr_name"): + if attr.ref_attr_name in attribute_map: + new_attr = AttributeProto() + new_attr.CopyFrom(attribute_map[attr.ref_attr_name]) + new_attr.name = attr.name + new_node.attribute.extend([new_attr]) + else: + new_attr = AttributeProto() + new_attr.CopyFrom(attr) + if attr.type == AttributeProto.GRAPH: + new_graph = new_attr.g + sg_rename = {} + for in_desc in new_graph.input: + sg_rename[in_desc.name] = in_desc.name = prefix + in_desc.name + for out_desc in new_graph.output: + sg_rename[out_desc.name] = out_desc.name = prefix + out_desc.name + for init_desc in new_graph.initializer: + sg_rename[init_desc.name] = init_desc.name = prefix + init_desc.name + for sparse_init_desc in new_graph.sparse_initializer: + sg_rename[sparse_init_desc.values.name] = ( + sparse_init_desc.values.name + ) = prefix + sparse_init_desc.values.name + for sparse_init_desc in new_graph.sparse_initializer: + sg_rename[sparse_init_desc.indices.name] = ( + sparse_init_desc.indices.name + ) = prefix + sparse_init_desc.indices.name + + def subgraph_rename_helper(name: str) -> Any: + if name in sg_rename: # noqa: B023 + return sg_rename[name] # noqa: B023 + return rename_helper(name) + + new_nodes = [ + _rename_edges_helper( + node_desc, subgraph_rename_helper, attribute_map, prefix + ) + for node_desc in new_graph.node + ] + new_graph.ClearField("node") + new_graph.node.extend(new_nodes) + new_node.attribute.extend([new_attr]) + return new_node + + +# FIXME(TMVector): Any reason we can't get rid of this and use the C++ helper directly? +def function_expand_helper( + node: NodeProto, function_proto: FunctionProto, op_prefix: str +) -> list[NodeProto]: + io_names_map = {} + attribute_map = {a.name: a for a in node.attribute} + + for idx, input in enumerate(function_proto.input): + io_names_map[input] = node.input[idx] if idx in range(len(node.input)) else "" + + for idx, output in enumerate(function_proto.output): + # Even if the node has been created with optional outputs missing, we + # can't assume that the function body handles this correctly, such as in + # the case that output is also an intermediate value. + # So we only add a name mapping if the output is present. An internal + # name will be generated if the missing output is used, the same as any + # other internal tensor. + if idx in range(len(node.output)) and node.output[idx] != "": + io_names_map[output] = node.output[idx] + + def rename_helper(internal_name: str) -> Any: + if internal_name in io_names_map: + return io_names_map[internal_name] + if internal_name == "": + return "" + return op_prefix + internal_name + + return [ + _rename_edges_helper(internal_node, rename_helper, attribute_map, op_prefix) + for internal_node in function_proto.node + ] + + +def function_testcase_helper( + node: NodeProto, + input_types: list[TypeProto], + name: str, + opset_imports: Sequence[OperatorSetIdProto] | None = None, +) -> tuple[list[tuple[list[NodeProto], Any]], int]: + test_op = node.op_type + op_prefix = test_op + "_" + name + "_expanded_function_" + if opset_imports is None: + # No opset in the model. We take the most recent definition. + schema = onnx.defs.get_schema(test_op, domain=node.domain) + else: + # We take the function defined in the specific version mentioned + # in the model. Find the opset_import matching the node's domain. + node_domain = node.domain or "" + matching_opset = None + for opset in opset_imports: + opset_domain = opset.domain or "" + if opset_domain == node_domain or ( + node_domain in {"", "ai.onnx"} and opset_domain in {"", "ai.onnx"} + ): + matching_opset = opset + break + if matching_opset is None: + raise ValueError( + f"No matching opset_import found for domain {node_domain!r} " + f"in {[o.domain for o in opset_imports]}." + ) + version = matching_opset.version + schema = onnx.defs.get_schema(test_op, version, domain=node.domain) + + # an op schema may have several functions, each for one opset version + # opset versions include the op's since_version and other opset versions + # if it is needed to define the op for a opset version other than the op's since_version. + function_protos = [] + for opset_version in schema.function_opset_versions: # type: ignore[attr-defined] + function_proto_str = schema.get_function_with_opset_version(opset_version) # type: ignore[attr-defined] + function_proto = FunctionProto() + function_proto.ParseFromString(function_proto_str) + function_protos.append(function_proto) + for opset_version in schema.context_dependent_function_opset_versions: # type: ignore[attr-defined] + function_proto_str = schema.get_context_dependent_function_with_opset_version( # type: ignore[attr-defined] + opset_version, + node.SerializeToString(), + [t.SerializeToString() for t in input_types], + ) + function_proto = FunctionProto() + function_proto.ParseFromString(function_proto_str) + function_protos.append(function_proto) + + expanded_tests = [] + for function_proto in function_protos: + for attr in schema.attributes: + if attr in [a.name for a in node.attribute]: + continue + if schema.attributes[attr].default_value: + node.attribute.extend([schema.attributes[attr].default_value]) + + # function_proto.attributes + node_list = function_expand_helper(node, function_proto, op_prefix) + expanded_tests.append((node_list, function_proto.opset_import)) + + return expanded_tests, schema.since_version + + +def _extract_value_info( + input: list[Any] | np.ndarray | None, + name: str, + type_proto: TypeProto | None = None, +) -> onnx.ValueInfoProto: + if type_proto is None: + if input is None: + raise NotImplementedError( + "_extract_value_info: both input and type_proto arguments cannot be None." + ) + if isinstance(input, list): + elem_type = onnx.helper.np_dtype_to_tensor_dtype(input[0].dtype) + shape = None + tensor_type_proto = onnx.helper.make_tensor_type_proto(elem_type, shape) + type_proto = onnx.helper.make_sequence_type_proto(tensor_type_proto) + elif isinstance(input, TensorProto): + elem_type = input.data_type + shape = tuple(input.dims) + type_proto = onnx.helper.make_tensor_type_proto(elem_type, shape) + else: + elem_type = onnx.helper.np_dtype_to_tensor_dtype(input.dtype) + shape = input.shape + type_proto = onnx.helper.make_tensor_type_proto(elem_type, shape) + + return onnx.helper.make_value_info(name, type_proto) + + +def _make_test_model_gen_version(graph: GraphProto, **kwargs: Any) -> ModelProto: + ( + latest_onnx_version, + latest_ml_version, + latest_training_version, + ) = onnx.helper.VERSION_TABLE[-1][2:5] # type: ignore[index] + if "opset_imports" in kwargs: + for opset in kwargs["opset_imports"]: + # If the test model uses an unreleased opset version (latest_version+1), + # directly use make_model to create a model with the latest ir version + if ( + ( + (opset.domain in {"", "ai.onnx"}) + and opset.version == latest_onnx_version + 1 + ) + or ( + opset.domain == "ai.onnx.ml" + and opset.version == latest_ml_version + 1 + ) + or ( + ( + opset.domain + in {"ai.onnx.training version", "ai.onnx.preview.training"} + ) + and opset.version == latest_training_version + 1 + ) + ): + return onnx.helper.make_model(graph, **kwargs) + # Otherwise, find and use the corresponding ir version according to given opset version + return onnx.helper.make_model_gen_version(graph, **kwargs) + + +# In the case of ops with optional inputs and outputs, node_op.input and node_op.output indicate +# which inputs/outputs are present and which are omitted. However, the parameter inputs +# and outputs of this function include values only for inputs/outputs that are present. +# E.g., for an op with 3 inputs, if the second parameter is optional and we wish to omit it, +# node_op.inputs would look like ["Param1", "", "Param3"], while inputs would look like +# [input-1-value, input-3-value] +# Instead of creating model with latest version, it now generates models for since_version by default. +# Thus it can make every model uses the same opset version after every opset change. +# Besides, user can specify "use_max_opset_version" to generate models for +# the latest opset version that supports before targeted opset version +def expect( + node_op: onnx.NodeProto, + inputs: Sequence[np.ndarray | TensorProto], + outputs: Sequence[np.ndarray | TensorProto], + name: str, + **kwargs: Any, +) -> None: + # skip if the node_op's op_type is not same as the given one + if _TargetOpType and node_op.op_type != _TargetOpType: + return + if _DiffOpTypes is not None and node_op.op_type.lower() not in _DiffOpTypes: + return + if name in _existing_names: + raise ValueError( + f"Name {name!r} is already using by one test case for node type {node_op.op_type!r}." + ) + _existing_names[name] = node_op + + # in case node_op is modified + node = deepcopy(node_op) + present_inputs = [x for x in node.input if (x != "")] + present_outputs = [x for x in node.output if (x != "")] + input_type_protos = [None] * len(inputs) + if "input_type_protos" in kwargs: + input_type_protos = kwargs["input_type_protos"] + del kwargs["input_type_protos"] + output_type_protos = [None] * len(outputs) + if "output_type_protos" in kwargs: + output_type_protos = kwargs["output_type_protos"] + del kwargs["output_type_protos"] + inputs_vi = [ + _extract_value_info(arr, arr_name, input_type) + for arr, arr_name, input_type in zip( + inputs, present_inputs, input_type_protos, strict=False + ) + ] + outputs_vi = [ + _extract_value_info(arr, arr_name, output_type) + for arr, arr_name, output_type in zip( + outputs, present_outputs, output_type_protos, strict=False + ) + ] + graph = onnx.helper.make_graph( + nodes=[node], name=name, inputs=inputs_vi, outputs=outputs_vi + ) + kwargs["producer_name"] = "backend-test" + + if "opset_imports" not in kwargs: + # To make sure the model will be produced with the same opset_version after opset changes + # By default, it uses since_version as opset_version for produced models + produce_opset_version = onnx.defs.get_schema( + node.op_type, domain=node.domain + ).since_version + kwargs["opset_imports"] = [ + onnx.helper.make_operatorsetid(node.domain, produce_opset_version) + ] + + model = _make_test_model_gen_version(graph, **kwargs) + + _NodeTestCases.append( + TestCase( + name=name, + model_name=name, + url=None, + model_dir=None, + model=model, + data_sets=[(inputs, outputs)], + kind="node", + rtol=1e-3, + atol=1e-7, + ) + ) + + # Create list of types for node.input, filling a default TypeProto for missing inputs: + # E.g. merge(["x", "", "y"], [x-value-info, y-value-info]) will return [x-type, default-type, y-type] + def merge( + node_inputs: list[str], present_value_info: list[onnx.ValueInfoProto] + ) -> list[TypeProto]: + if node_inputs: + if node_inputs[0] != "": + return [ + present_value_info[0].type, + *merge(node_inputs[1:], present_value_info[1:]), + ] + return [TypeProto(), *merge(node_inputs[1:], present_value_info)] + return [] + + merged_types = merge(list(node.input), inputs_vi) + ( + expanded_tests, + since_version, + ) = function_testcase_helper( + node, merged_types, name, opset_imports=kwargs.get("opset_imports") + ) + for expanded_function_nodes, func_opset_import in expanded_tests: + kwargs["producer_name"] = "backend-test" + + # TODO: if kwargs["opset_imports"] already exists, only generate test case for the opset version. + # replace opset versions with what are specified in function proto + if "opset_imports" not in kwargs: + kwargs["opset_imports"] = func_opset_import + else: + for opset_import in func_opset_import: + matches = [ + opset + for opset in kwargs["opset_imports"] + if opset.domain == opset_import.domain + ] + if matches: + matches[0].version = opset_import.version + else: + kwargs["opset_imports"].append(opset_import) + + onnx_ai_opset_version = "" + if "opset_imports" in kwargs: + onnx_ai_opset_imports = [ + oi for oi in kwargs["opset_imports"] if oi.domain in ("", "ai.onnx") + ] + if len(onnx_ai_opset_imports) == 1: + onnx_ai_opset_version = onnx_ai_opset_imports[0].version + + function_test_name = name + "_expanded" + if onnx_ai_opset_version and onnx_ai_opset_version != since_version: + function_test_name += f"_ver{onnx_ai_opset_version}" + graph = onnx.helper.make_graph( + nodes=expanded_function_nodes, + name=function_test_name, + inputs=inputs_vi, + outputs=outputs_vi, + ) + model = _make_test_model_gen_version(graph, **kwargs) + _NodeTestCases.append( + TestCase( + name=function_test_name, + model_name=function_test_name, + url=None, + model_dir=None, + model=model, + data_sets=[(inputs, outputs)], + kind="node", + rtol=1e-3, + atol=1e-7, + ) + ) + + +def collect_testcases(op_type: str) -> list[TestCase]: + """Collect node test cases""" + # only keep those tests related to this operator + global _TargetOpType # noqa: PLW0603 + _TargetOpType = op_type + + import_recursive(sys.modules[__name__]) + return _NodeTestCases + + +def collect_diff_testcases() -> list[TestCase]: + """Collect node test cases which are different from the main branch""" + global _DiffOpTypes # noqa: PLW0603 + _DiffOpTypes = get_diff_op_types() + + import_recursive(sys.modules[__name__]) + return _NodeTestCases + + +def get_diff_op_types(): + cwd_path = Path.cwd() + # Resolve the upstream main branch from the canonical onnx/onnx repository + # to avoid depending on local branch or remote naming conventions. + upstream_url = "https://github.com/onnx/onnx.git" + ls_remote = subprocess.run( + ["git", "ls-remote", upstream_url, "refs/heads/main"], + cwd=cwd_path, + capture_output=True, + check=True, + ) + upstream_main_hash = ls_remote.stdout.split()[0].decode("utf-8") + # Fetch the upstream main commit so merge-base works even if the + # local repo hasn't fetched recently. + subprocess.run( + ["git", "fetch", upstream_url, upstream_main_hash], + cwd=cwd_path, + capture_output=True, + check=True, + ) + # Find the fork point from upstream main + merge_base = subprocess.run( + ["git", "merge-base", "HEAD", upstream_main_hash], + cwd=cwd_path, + capture_output=True, + check=True, + ) + base_commit = merge_base.stdout.strip().decode("utf-8") + # obtain list of added or modified files since the fork point + result = subprocess.run( + ["git", "diff", "--name-only", "--diff-filter=AM", base_commit, "HEAD"], + cwd=cwd_path, + capture_output=True, + check=True, + ) + diff_list = result.stdout.split() + changed_op_types = [] + for file in diff_list: + file_name = file.decode("utf-8") + if file_name.startswith("onnx/backend/test/case/node/") and file_name.endswith( + ".py" + ): + changed_op_types.append( + file_name.split("/")[-1].replace(".py", "").rstrip("_") + ) + return changed_op_types diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/_image_decoder_data.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/_image_decoder_data.py new file mode 100644 index 0000000000000000000000000000000000000000..90828e40253b5631ab1757be5c9f667d29b58161 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/_image_decoder_data.py @@ -0,0 +1,6353 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +# This file contains freeze NumPy array for ImageDecoder backend test's input/output +# They were generated by image_decoder.py's generate_test_data with pillow +# To make ONNX backend test generation simple, use freeze NumPy array directly +# People can still use generate_test_data to get these data here with installed pillow +from __future__ import annotations + +from typing import NamedTuple + +import numpy as np + + +class ImageData(NamedTuple): + data: np.ndarray + output: np.ndarray + + +# Remove black check for better readability with large NumPy array +# fmt: off +image_decoder_decode_jpeg_rgb = ImageData( + np.array([255, 216, 255, 224, 0, 16, 74, 70, 73, 70, 0, 1, 1, + 0, 0, 1, 0, 1, 0, 0, 255, 219, 0, 67, 0, 8, + 6, 6, 7, 6, 5, 8, 7, 7, 7, 9, 9, 8, 10, + 12, 20, 13, 12, 11, 11, 12, 25, 18, 19, 15, 20, 29, + 26, 31, 30, 29, 26, 28, 28, 32, 36, 46, 39, 32, 34, + 44, 35, 28, 28, 40, 55, 41, 44, 48, 49, 52, 52, 52, + 31, 39, 57, 61, 56, 50, 60, 46, 51, 52, 50, 255, 219, + 0, 67, 1, 9, 9, 9, 12, 11, 12, 24, 13, 13, 24, + 50, 33, 28, 33, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 255, 192, 0, 17, 8, 0, 32, 0, 32, 3, 1, + 34, 0, 2, 17, 1, 3, 17, 1, 255, 196, 0, 31, 0, + 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 255, 196, 0, 181, 16, 0, 2, 1, 3, 3, 2, + 4, 3, 5, 5, 4, 4, 0, 0, 1, 125, 1, 2, 3, + 0, 4, 17, 5, 18, 33, 49, 65, 6, 19, 81, 97, 7, + 34, 113, 20, 50, 129, 145, 161, 8, 35, 66, 177, 193, 21, + 82, 209, 240, 36, 51, 98, 114, 130, 9, 10, 22, 23, 24, + 25, 26, 37, 38, 39, 40, 41, 42, 52, 53, 54, 55, 56, + 57, 58, 67, 68, 69, 70, 71, 72, 73, 74, 83, 84, 85, + 86, 87, 88, 89, 90, 99, 100, 101, 102, 103, 104, 105, 106, + 115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135, + 136, 137, 138, 146, 147, 148, 149, 150, 151, 152, 153, 154, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 255, 196, 0, 31, 1, 0, 3, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 255, 196, 0, + 181, 17, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, + 4, 0, 1, 2, 119, 0, 1, 2, 3, 17, 4, 5, 33, + 49, 6, 18, 65, 81, 7, 97, 113, 19, 34, 50, 129, 8, + 20, 66, 145, 161, 177, 193, 9, 35, 51, 82, 240, 21, 98, + 114, 209, 10, 22, 36, 52, 225, 37, 241, 23, 24, 25, 26, + 38, 39, 40, 41, 42, 53, 54, 55, 56, 57, 58, 67, 68, + 69, 70, 71, 72, 73, 74, 83, 84, 85, 86, 87, 88, 89, + 90, 99, 100, 101, 102, 103, 104, 105, 106, 115, 116, 117, 118, + 119, 120, 121, 122, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 194, 195, 196, 197, 198, 199, 200, 201, 202, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 242, 243, 244, 245, 246, 247, 248, 249, 250, 255, 218, + 0, 12, 3, 1, 0, 2, 17, 3, 17, 0, 63, 0, 93, + 15, 199, 122, 93, 181, 235, 187, 193, 120, 65, 140, 143, 149, + 23, 212, 127, 181, 93, 36, 95, 16, 180, 150, 145, 36, 22, + 247, 187, 119, 3, 247, 19, 255, 0, 138, 175, 29, 180, 183, + 153, 37, 36, 195, 32, 249, 123, 169, 174, 175, 68, 138, 194, + 73, 108, 226, 187, 104, 193, 105, 66, 186, 180, 155, 78, 11, + 125, 120, 226, 184, 243, 204, 13, 12, 101, 117, 141, 154, 110, + 46, 209, 211, 123, 247, 125, 45, 243, 61, 156, 62, 34, 141, + 92, 59, 173, 137, 77, 201, 221, 46, 94, 253, 14, 135, 198, + 14, 62, 32, 253, 139, 251, 39, 48, 253, 135, 127, 153, 246, + 191, 151, 59, 246, 227, 27, 119, 127, 112, 245, 199, 106, 224, + 124, 90, 134, 211, 194, 183, 118, 114, 96, 201, 8, 142, 54, + 43, 208, 149, 117, 7, 30, 220, 87, 166, 234, 22, 182, 250, + 103, 151, 253, 132, 163, 247, 153, 243, 188, 166, 50, 244, 198, + 220, 231, 56, 234, 107, 142, 241, 245, 157, 168, 240, 86, 161, + 114, 80, 11, 179, 229, 179, 18, 199, 59, 140, 139, 158, 51, + 238, 107, 179, 15, 130, 246, 20, 21, 55, 36, 224, 175, 202, + 147, 214, 251, 235, 243, 60, 117, 78, 166, 38, 42, 53, 218, + 92, 154, 174, 154, 147, 29, 35, 96, 207, 159, 159, 248, 7, + 255, 0, 94, 179, 100, 180, 251, 62, 168, 178, 239, 221, 229, + 186, 182, 49, 140, 227, 6, 181, 173, 124, 127, 224, 229, 148, + 153, 181, 4, 43, 142, 51, 107, 33, 231, 254, 248, 170, 26, + 151, 141, 124, 35, 52, 243, 52, 23, 145, 144, 203, 242, 145, + 107, 32, 231, 31, 238, 215, 6, 89, 154, 85, 141, 79, 99, + 94, 140, 185, 31, 149, 149, 219, 93, 108, 107, 71, 56, 132, + 40, 243, 209, 161, 40, 174, 145, 123, 223, 190, 167, 75, 164, + 106, 249, 243, 191, 113, 253, 223, 227, 250, 251, 86, 119, 196, + 109, 63, 30, 0, 212, 175, 124, 223, 188, 34, 125, 155, 122, + 110, 149, 56, 206, 125, 235, 147, 255, 0, 132, 199, 71, 143, + 253, 86, 160, 201, 158, 187, 99, 144, 103, 244, 170, 158, 37, + 241, 133, 166, 167, 225, 155, 155, 8, 181, 73, 166, 103, 8, + 4, 76, 36, 193, 195, 41, 238, 49, 218, 175, 49, 194, 42, + 88, 181, 245, 95, 134, 234, 246, 215, 77, 58, 234, 24, 90, + 95, 95, 162, 241, 56, 185, 165, 36, 155, 73, 232, 238, 180, + 90, 105, 216, 255, 217], dtype=np.uint8), + np.array([[[230, 73, 255], + [227, 76, 255], + [222, 81, 255], + [211, 95, 206], + [204, 123, 142], + [251, 202, 133], + [245, 226, 72], + [234, 230, 34], + [235, 234, 32], + [231, 229, 32], + [227, 221, 37], + [233, 224, 45], + [237, 227, 42], + [232, 216, 32], + [243, 219, 35], + [255, 247, 63], + [246, 255, 71], + [249, 255, 83], + [243, 253, 68], + [255, 251, 134], + [ 97, 23, 46], + [127, 19, 121], + [123, 0, 124], + [118, 19, 128], + [ 63, 28, 82], + [ 99, 133, 143], + [ 39, 146, 128], + [ 24, 162, 110], + [ 26, 157, 64], + [ 66, 154, 76], + [ 0, 9, 0], + [ 15, 0, 9]], + + [[232, 77, 255], + [228, 79, 255], + [221, 83, 254], + [210, 93, 208], + [202, 117, 146], + [248, 193, 137], + [242, 216, 77], + [230, 222, 35], + [239, 237, 40], + [235, 233, 36], + [230, 225, 37], + [235, 227, 41], + [238, 228, 42], + [230, 220, 34], + [237, 225, 41], + [255, 253, 70], + [242, 250, 68], + [242, 251, 70], + [255, 255, 79], + [255, 232, 124], + [112, 32, 57], + [119, 9, 108], + [132, 10, 129], + [117, 21, 121], + [ 83, 50, 95], + [ 98, 132, 134], + [ 34, 137, 108], + [ 31, 165, 106], + [ 40, 168, 75], + [ 62, 151, 71], + [ 0, 9, 0], + [ 11, 0, 5]], + + [[234, 81, 255], + [229, 82, 255], + [221, 86, 250], + [211, 95, 218], + [207, 115, 164], + [254, 189, 161], + [249, 213, 101], + [238, 224, 57], + [235, 232, 41], + [231, 229, 30], + [229, 221, 26], + [229, 221, 26], + [231, 225, 29], + [218, 219, 27], + [215, 229, 45], + [237, 252, 71], + [252, 252, 76], + [255, 248, 80], + [255, 249, 94], + [255, 225, 135], + [120, 30, 58], + [120, 6, 101], + [126, 9, 116], + [109, 20, 104], + [ 75, 47, 72], + [ 97, 130, 113], + [ 48, 144, 98], + [ 37, 163, 89], + [ 48, 169, 72], + [ 59, 151, 66], + [ 0, 16, 0], + [ 0, 13, 0]], + + [[216, 83, 236], + [211, 83, 238], + [205, 88, 246], + [203, 98, 226], + [205, 114, 181], + [255, 184, 178], + [255, 207, 120], + [251, 220, 77], + [246, 228, 56], + [247, 228, 46], + [248, 216, 43], + [251, 214, 45], + [250, 217, 50], + [234, 217, 51], + [217, 232, 69], + [234, 255, 95], + [245, 251, 93], + [255, 254, 104], + [252, 232, 101], + [255, 228, 153], + [111, 34, 52], + [126, 33, 103], + [109, 15, 93], + [103, 34, 91], + [ 52, 33, 39], + [ 98, 127, 99], + [ 75, 152, 106], + [ 48, 148, 86], + [ 53, 151, 78], + [ 69, 148, 83], + [ 0, 16, 0], + [ 0, 15, 0]], + + [[202, 104, 227], + [196, 103, 235], + [191, 106, 253], + [192, 111, 242], + [200, 117, 199], + [253, 176, 192], + [255, 193, 127], + [255, 204, 85], + [255, 210, 67], + [255, 209, 67], + [255, 195, 76], + [255, 189, 82], + [255, 193, 88], + [255, 197, 88], + [229, 217, 97], + [229, 246, 118], + [228, 250, 123], + [249, 255, 148], + [245, 251, 145], + [239, 224, 155], + [ 97, 57, 49], + [ 87, 35, 58], + [ 72, 21, 52], + [ 83, 48, 68], + [ 80, 76, 65], + [ 99, 122, 96], + [ 88, 136, 110], + [ 63, 123, 98], + [ 70, 127, 108], + [ 86, 130, 115], + [ 0, 9, 0], + [ 0, 7, 0]], + + [[ 83, 27, 128], + [ 76, 23, 137], + [ 70, 23, 161], + [ 73, 22, 151], + [ 84, 16, 103], + [138, 60, 86], + [146, 66, 13], + [150, 72, 0], + [146, 73, 0], + [164, 71, 0], + [186, 55, 0], + [198, 48, 15], + [202, 51, 24], + [176, 56, 19], + [136, 81, 16], + [116, 114, 31], + [ 94, 131, 38], + [ 62, 112, 17], + [ 75, 109, 23], + [108, 125, 55], + [173, 175, 128], + [200, 194, 162], + [203, 197, 175], + [175, 174, 153], + [150, 161, 131], + [ 98, 117, 95], + [ 83, 105, 102], + [ 80, 103, 117], + [ 92, 111, 143], + [ 92, 107, 138], + [ 0, 3, 12], + [ 0, 5, 2]], + + [[ 52, 43, 132], + [ 45, 40, 142], + [ 41, 38, 167], + [ 51, 35, 159], + [ 70, 21, 103], + [129, 55, 82], + [144, 53, 6], + [155, 53, 0], + [163, 53, 0], + [189, 52, 10], + [224, 32, 53], + [242, 23, 77], + [251, 25, 88], + [223, 33, 77], + [172, 59, 61], + [131, 98, 65], + [ 62, 111, 55], + [ 47, 130, 58], + [ 80, 146, 72], + [ 73, 128, 44], + [153, 200, 104], + [139, 183, 86], + [160, 202, 120], + [169, 206, 139], + [174, 203, 155], + [ 92, 109, 91], + [ 92, 92, 116], + [101, 90, 148], + [103, 88, 171], + [ 97, 87, 160], + [ 0, 0, 23], + [ 0, 4, 4]], + + [[ 26, 47, 140], + [ 21, 44, 146], + [ 22, 48, 169], + [ 39, 47, 158], + [ 67, 31, 103], + [131, 62, 83], + [153, 56, 14], + [170, 52, 0], + [164, 37, 0], + [195, 37, 25], + [233, 21, 71], + [255, 13, 100], + [255, 14, 111], + [236, 20, 103], + [180, 45, 88], + [131, 84, 92], + [ 70, 118, 92], + [ 46, 136, 85], + [ 43, 118, 59], + [ 53, 122, 41], + [153, 222, 106], + [156, 225, 100], + [143, 209, 101], + [150, 205, 122], + [155, 192, 141], + [ 89, 101, 91], + [119, 98, 137], + [120, 83, 161], + [104, 65, 174], + [104, 78, 167], + [ 4, 6, 27], + [ 0, 7, 0]], + + [[ 18, 50, 161], + [ 20, 54, 164], + [ 13, 53, 166], + [ 26, 47, 140], + [ 69, 44, 99], + [118, 52, 64], + [155, 55, 23], + [170, 48, 0], + [169, 41, 2], + [190, 36, 26], + [233, 35, 71], + [249, 26, 91], + [239, 10, 92], + [218, 23, 102], + [177, 54, 117], + [129, 83, 119], + [ 75, 112, 105], + [ 58, 131, 101], + [ 56, 116, 78], + [ 64, 120, 57], + [151, 214, 110], + [153, 217, 103], + [138, 203, 109], + [147, 202, 134], + [169, 199, 163], + [102, 102, 104], + [124, 88, 132], + [120, 67, 147], + [131, 78, 184], + [101, 68, 147], + [ 3, 9, 7], + [ 0, 18, 0]], + + [[ 15, 46, 136], + [ 16, 52, 138], + [ 11, 53, 135], + [ 23, 46, 114], + [ 66, 43, 89], + [114, 48, 76], + [151, 46, 60], + [164, 39, 45], + [167, 43, 51], + [164, 28, 38], + [200, 43, 54], + [214, 43, 59], + [210, 42, 59], + [195, 56, 79], + [144, 65, 94], + [115, 93, 114], + [ 72, 103, 106], + [ 63, 116, 108], + [ 70, 111, 103], + [ 87, 127, 103], + [139, 187, 129], + [151, 201, 138], + [147, 198, 155], + [160, 198, 177], + [150, 162, 162], + [117, 97, 124], + [143, 86, 141], + [142, 68, 147], + [148, 76, 176], + [124, 74, 145], + [ 6, 0, 0], + [ 0, 10, 0]], + + [[ 36, 57, 88], + [ 37, 62, 92], + [ 29, 65, 91], + [ 39, 55, 88], + [ 76, 47, 95], + [118, 47, 115], + [150, 39, 134], + [158, 32, 132], + [154, 41, 123], + [146, 43, 86], + [196, 101, 79], + [194, 111, 45], + [180, 109, 17], + [170, 126, 37], + [140, 138, 77], + [173, 197, 165], + [185, 215, 215], + [183, 214, 235], + [186, 206, 239], + [173, 192, 225], + [120, 142, 165], + [107, 128, 157], + [101, 121, 171], + [112, 118, 178], + [158, 138, 199], + [180, 129, 195], + [215, 130, 198], + [226, 125, 203], + [222, 126, 216], + [201, 125, 189], + [ 44, 6, 3], + [ 23, 5, 0]], + + [[ 43, 58, 65], + [ 43, 62, 66], + [ 36, 65, 63], + [ 42, 55, 64], + [ 72, 44, 84], + [112, 41, 121], + [140, 28, 156], + [143, 21, 158], + [130, 28, 140], + [115, 39, 86], + [164, 121, 70], + [151, 132, 14], + [131, 127, 0], + [127, 142, 0], + [115, 151, 55], + [196, 235, 190], + [189, 214, 218], + [192, 206, 245], + [201, 208, 255], + [202, 207, 255], + [110, 114, 188], + [109, 113, 202], + [117, 115, 225], + [126, 109, 224], + [137, 95, 195], + [195, 127, 212], + [225, 129, 201], + [237, 127, 200], + [229, 120, 203], + [217, 125, 188], + [ 41, 0, 0], + [ 32, 0, 0]], + + [[ 44, 55, 73], + [ 46, 63, 73], + [ 41, 66, 63], + [ 46, 57, 59], + [ 74, 50, 76], + [111, 47, 108], + [141, 35, 146], + [142, 27, 148], + [146, 52, 148], + [114, 55, 85], + [139, 130, 55], + [125, 147, 10], + [119, 155, 0], + [115, 158, 16], + [104, 140, 68], + [186, 213, 194], + [196, 209, 226], + [186, 190, 235], + [187, 187, 247], + [198, 197, 255], + [109, 105, 202], + [121, 113, 232], + [123, 108, 249], + [122, 91, 231], + [149, 99, 214], + [211, 141, 230], + [225, 133, 200], + [232, 126, 190], + [224, 118, 192], + [227, 132, 196], + [ 51, 0, 14], + [ 43, 0, 4]], + + [[ 33, 57, 59], + [ 36, 62, 59], + [ 34, 66, 53], + [ 39, 58, 52], + [ 69, 52, 70], + [107, 50, 105], + [137, 36, 140], + [142, 27, 148], + [128, 30, 131], + [110, 49, 93], + [126, 120, 68], + [116, 146, 32], + [115, 160, 18], + [112, 150, 31], + [121, 131, 81], + [205, 200, 196], + [215, 206, 227], + [218, 206, 242], + [215, 207, 248], + [214, 206, 255], + [120, 113, 193], + [121, 110, 215], + [125, 106, 234], + [135, 105, 229], + [141, 97, 192], + [190, 133, 202], + [206, 133, 178], + [216, 135, 176], + [210, 132, 184], + [209, 139, 193], + [ 36, 0, 21], + [ 29, 0, 18]], + + [[ 22, 75, 33], + [ 27, 79, 40], + [ 26, 77, 44], + [ 33, 65, 50], + [ 61, 57, 72], + [ 99, 50, 106], + [134, 32, 141], + [143, 19, 153], + [146, 29, 162], + [142, 57, 150], + [136, 108, 120], + [123, 131, 84], + [123, 141, 57], + [123, 124, 48], + [162, 121, 91], + [248, 192, 193], + [227, 185, 197], + [233, 201, 214], + [221, 199, 201], + [207, 192, 197], + [134, 126, 150], + [122, 114, 161], + [116, 105, 174], + [133, 116, 184], + [150, 127, 171], + [171, 143, 165], + [181, 149, 154], + [189, 157, 160], + [188, 156, 177], + [175, 152, 181], + [ 11, 0, 30], + [ 1, 0, 27]], + + [[ 58, 122, 61], + [ 61, 125, 64], + [ 60, 121, 64], + [ 66, 106, 71], + [ 92, 93, 97], + [129, 81, 133], + [165, 59, 170], + [174, 41, 184], + [172, 40, 185], + [151, 48, 165], + [102, 50, 112], + [ 82, 60, 73], + [ 91, 77, 50], + [ 94, 59, 27], + [134, 53, 50], + [199, 106, 114], + [193, 121, 124], + [186, 127, 121], + [173, 115, 101], + [184, 143, 121], + [179, 165, 139], + [192, 189, 170], + [181, 172, 175], + [180, 174, 176], + [168, 169, 155], + [150, 158, 134], + [134, 151, 119], + [125, 148, 120], + [123, 150, 133], + [121, 143, 140], + [ 0, 4, 17], + [ 0, 3, 26]], + + [[ 61, 119, 61], + [ 60, 121, 54], + [ 60, 124, 38], + [ 71, 116, 47], + [ 96, 97, 79], + [127, 76, 119], + [164, 51, 167], + [181, 39, 183], + [181, 41, 172], + [164, 45, 161], + [118, 40, 139], + [100, 45, 113], + [106, 56, 85], + [124, 56, 71], + [140, 31, 60], + [224, 107, 126], + [212, 114, 105], + [213, 116, 97], + [223, 109, 99], + [206, 116, 89], + [205, 181, 109], + [185, 190, 100], + [192, 182, 110], + [188, 185, 116], + [170, 194, 118], + [112, 162, 89], + [104, 180, 118], + [ 87, 176, 120], + [ 76, 166, 105], + [ 98, 165, 121], + [ 0, 20, 7], + [ 0, 0, 5]], + + [[ 61, 114, 72], + [ 61, 116, 59], + [ 63, 121, 37], + [ 77, 114, 44], + [100, 97, 78], + [128, 77, 120], + [161, 54, 168], + [178, 43, 182], + [183, 50, 169], + [174, 52, 163], + [135, 37, 158], + [120, 35, 139], + [120, 38, 104], + [135, 39, 87], + [151, 24, 77], + [231, 100, 132], + [223, 109, 98], + [227, 111, 86], + [240, 101, 94], + [220, 111, 82], + [210, 183, 92], + [186, 193, 79], + [195, 186, 85], + [189, 191, 94], + [161, 199, 98], + [ 94, 165, 71], + [ 80, 181, 105], + [ 76, 190, 118], + [ 72, 184, 100], + [ 91, 174, 104], + [ 0, 13, 0], + [ 0, 1, 0]], + + [[ 59, 110, 91], + [ 65, 111, 82], + [ 73, 113, 63], + [ 86, 107, 68], + [106, 94, 98], + [127, 79, 131], + [149, 62, 169], + [163, 54, 179], + [163, 47, 154], + [164, 48, 155], + [138, 26, 154], + [134, 23, 144], + [136, 23, 111], + [149, 30, 98], + [162, 27, 94], + [231, 98, 141], + [223, 106, 99], + [226, 110, 87], + [235, 102, 95], + [214, 110, 85], + [208, 181, 102], + [184, 190, 92], + [189, 184, 103], + [181, 189, 112], + [167, 211, 126], + [102, 174, 90], + [ 81, 173, 98], + [ 83, 181, 104], + [ 86, 179, 88], + [102, 173, 95], + [ 0, 14, 0], + [ 1, 12, 0]], + + [[ 88, 95, 88], + [ 94, 95, 81], + [104, 95, 64], + [114, 90, 66], + [124, 81, 88], + [133, 73, 111], + [138, 65, 138], + [143, 60, 142], + [155, 66, 132], + [163, 62, 142], + [144, 29, 148], + [151, 26, 154], + [152, 25, 130], + [160, 33, 124], + [162, 35, 124], + [204, 91, 157], + [200, 115, 138], + [199, 120, 125], + [207, 115, 130], + [190, 121, 114], + [196, 187, 128], + [180, 194, 115], + [186, 189, 122], + [182, 193, 125], + [145, 189, 102], + [115, 176, 81], + [104, 170, 80], + [105, 171, 74], + [110, 167, 60], + [124, 167, 75], + [ 0, 12, 0], + [ 0, 7, 0]], + + [[194, 115, 111], + [198, 114, 103], + [207, 113, 88], + [210, 112, 87], + [204, 111, 96], + [192, 111, 108], + [178, 113, 121], + [171, 114, 123], + [171, 111, 111], + [175, 99, 127], + [159, 49, 144], + [170, 44, 169], + [167, 39, 158], + [164, 43, 159], + [146, 43, 160], + [148, 77, 181], + [108, 84, 162], + [ 99, 93, 155], + [107, 89, 147], + [100, 94, 122], + [124, 153, 122], + [121, 157, 96], + [135, 148, 92], + [139, 152, 82], + [142, 179, 76], + [170, 211, 91], + [191, 217, 92], + [200, 212, 84], + [202, 206, 70], + [207, 207, 93], + [ 14, 19, 0], + [ 2, 8, 0]], + + [[230, 98, 93], + [234, 97, 87], + [239, 97, 77], + [236, 97, 74], + [220, 101, 79], + [197, 105, 80], + [170, 113, 84], + [158, 117, 85], + [170, 127, 92], + [177, 112, 118], + [159, 53, 143], + [180, 50, 184], + [175, 44, 182], + [167, 48, 192], + [143, 51, 198], + [117, 69, 205], + [ 81, 93, 205], + [ 66, 105, 198], + [ 73, 105, 182], + [ 73, 108, 148], + [113, 160, 142], + [117, 161, 112], + [134, 154, 103], + [140, 158, 84], + [122, 156, 44], + [185, 213, 77], + [214, 213, 73], + [223, 200, 58], + [225, 192, 51], + [224, 201, 89], + [ 4, 7, 0], + [ 0, 8, 0]], + + [[245, 93, 82], + [247, 93, 81], + [250, 92, 80], + [242, 95, 79], + [222, 101, 82], + [196, 109, 81], + [168, 119, 79], + [155, 122, 79], + [158, 120, 81], + [169, 106, 115], + [156, 45, 148], + [179, 44, 199], + [173, 36, 201], + [166, 44, 215], + [148, 53, 233], + [113, 66, 232], + [ 73, 92, 220], + [ 54, 108, 204], + [ 56, 110, 184], + [ 59, 113, 147], + [111, 160, 139], + [119, 159, 109], + [133, 153, 100], + [137, 158, 83], + [133, 170, 54], + [198, 222, 84], + [220, 203, 63], + [231, 189, 53], + [235, 183, 61], + [229, 197, 110], + [ 0, 8, 0], + [ 0, 18, 21]], + + [[222, 106, 57], + [223, 107, 60], + [225, 106, 66], + [218, 109, 70], + [202, 115, 72], + [182, 120, 69], + [159, 128, 64], + [150, 129, 64], + [158, 129, 71], + [170, 118, 107], + [150, 59, 138], + [167, 58, 185], + [152, 46, 178], + [142, 54, 192], + [128, 68, 216], + [ 95, 76, 218], + [ 60, 99, 218], + [ 44, 113, 208], + [ 42, 116, 187], + [ 49, 117, 152], + [111, 159, 147], + [124, 154, 116], + [135, 149, 113], + [142, 153, 93], + [137, 162, 61], + [205, 209, 86], + [230, 185, 58], + [255, 183, 62], + [255, 182, 73], + [246, 190, 116], + [ 0, 5, 0], + [ 0, 12, 25]], + + [[167, 145, 26], + [163, 140, 28], + [162, 137, 37], + [162, 137, 45], + [153, 136, 46], + [145, 134, 42], + [144, 140, 40], + [150, 146, 46], + [156, 142, 45], + [153, 122, 65], + [134, 81, 99], + [130, 76, 126], + [123, 85, 126], + [105, 89, 128], + [ 92, 102, 153], + [ 60, 97, 165], + [ 50, 114, 202], + [ 31, 115, 205], + [ 28, 119, 189], + [ 54, 131, 173], + [105, 144, 151], + [138, 151, 141], + [147, 146, 141], + [149, 143, 117], + [160, 159, 92], + [217, 188, 96], + [255, 176, 77], + [255, 179, 77], + [255, 162, 64], + [255, 159, 89], + [ 31, 6, 0], + [ 0, 3, 5]], + + [[119, 197, 23], + [121, 197, 29], + [124, 193, 42], + [132, 194, 49], + [145, 196, 55], + [161, 203, 59], + [178, 206, 59], + [191, 207, 59], + [196, 199, 58], + [187, 183, 75], + [153, 145, 99], + [135, 138, 117], + [118, 148, 110], + [ 96, 152, 115], + [ 78, 155, 139], + [ 46, 135, 153], + [ 33, 125, 192], + [ 26, 121, 205], + [ 21, 122, 192], + [ 43, 117, 166], + [ 87, 105, 127], + [114, 97, 107], + [121, 90, 105], + [126, 86, 84], + [132, 88, 49], + [175, 104, 42], + [205, 78, 9], + [231, 73, 0], + [230, 69, 0], + [219, 95, 35], + [ 34, 0, 0], + [ 7, 3, 2]], + + [[ 41, 226, 10], + [ 46, 226, 15], + [ 51, 219, 20], + [ 62, 212, 16], + [ 93, 215, 16], + [131, 224, 22], + [164, 223, 21], + [177, 214, 13], + [191, 217, 22], + [180, 207, 42], + [131, 173, 63], + [102, 168, 78], + [ 82, 184, 82], + [ 64, 193, 101], + [ 45, 188, 134], + [ 13, 152, 147], + [ 28, 143, 198], + [ 36, 139, 218], + [ 37, 140, 209], + [ 62, 125, 178], + [111, 96, 127], + [140, 78, 101], + [151, 73, 97], + [164, 72, 83], + [167, 65, 50], + [210, 83, 50], + [234, 64, 28], + [252, 67, 23], + [238, 63, 8], + [210, 82, 37], + [ 34, 0, 0], + [ 1, 0, 4]], + + [[ 14, 255, 23], + [ 22, 255, 27], + [ 27, 248, 23], + [ 38, 234, 10], + [ 77, 234, 5], + [127, 245, 13], + [163, 239, 7], + [176, 225, 0], + [178, 216, 0], + [166, 209, 15], + [113, 177, 29], + [ 78, 171, 41], + [ 62, 189, 50], + [ 53, 200, 83], + [ 38, 191, 127], + [ 2, 149, 143], + [ 4, 133, 190], + [ 12, 131, 213], + [ 20, 132, 206], + [ 52, 116, 177], + [113, 85, 125], + [150, 67, 95], + [164, 66, 91], + [181, 66, 81], + [194, 63, 55], + [226, 71, 51], + [239, 52, 33], + [250, 56, 29], + [234, 57, 15], + [203, 75, 38], + [ 42, 0, 0], + [ 10, 2, 0]], + + [[ 0, 251, 19], + [ 5, 252, 23], + [ 15, 241, 17], + [ 29, 228, 1], + [ 70, 231, 0], + [122, 242, 4], + [159, 237, 3], + [171, 222, 0], + [186, 228, 6], + [175, 222, 22], + [126, 188, 29], + [ 93, 174, 33], + [ 80, 184, 37], + [ 76, 189, 73], + [ 69, 175, 127], + [ 25, 138, 154], + [ 8, 140, 212], + [ 1, 140, 235], + [ 8, 138, 224], + [ 44, 121, 191], + [113, 91, 137], + [150, 74, 102], + [160, 72, 88], + [174, 68, 70], + [195, 65, 51], + [224, 69, 49], + [235, 53, 40], + [248, 63, 43], + [230, 67, 26], + [192, 70, 29], + [ 46, 0, 0], + [ 15, 0, 0]], + + [[ 37, 234, 58], + [ 45, 233, 60], + [ 55, 225, 58], + [ 70, 216, 47], + [101, 215, 39], + [137, 220, 44], + [163, 216, 48], + [170, 207, 42], + [170, 205, 43], + [163, 203, 55], + [125, 176, 55], + [103, 168, 52], + [ 96, 173, 43], + [ 94, 170, 70], + [ 99, 159, 133], + [ 66, 133, 160], + [ 33, 131, 192], + [ 19, 133, 206], + [ 17, 130, 200], + [ 48, 117, 174], + [114, 93, 126], + [144, 80, 96], + [141, 81, 83], + [146, 78, 69], + [166, 73, 58], + [191, 77, 66], + [204, 68, 70], + [219, 81, 78], + [205, 83, 59], + [168, 79, 47], + [ 50, 13, 0], + [ 10, 1, 0]], + + [[ 0, 28, 0], + [ 0, 25, 0], + [ 0, 19, 0], + [ 0, 15, 0], + [ 0, 10, 0], + [ 0, 7, 0], + [ 5, 4, 0], + [ 5, 6, 0], + [ 1, 13, 0], + [ 0, 21, 0], + [ 0, 15, 0], + [ 0, 19, 0], + [ 0, 24, 0], + [ 0, 20, 0], + [ 0, 8, 6], + [ 0, 1, 30], + [ 0, 5, 28], + [ 0, 10, 32], + [ 0, 15, 41], + [ 0, 9, 28], + [ 18, 0, 0], + [ 31, 0, 0], + [ 10, 0, 0], + [ 4, 1, 0], + [ 18, 0, 0], + [ 27, 0, 0], + [ 32, 0, 7], + [ 36, 0, 5], + [ 35, 0, 0], + [ 31, 1, 0], + [ 0, 1, 0], + [ 0, 5, 7]], + + [[ 0, 2, 0], + [ 3, 0, 0], + [ 10, 0, 4], + [ 17, 0, 10], + [ 22, 0, 11], + [ 18, 0, 14], + [ 15, 0, 25], + [ 9, 0, 29], + [ 0, 0, 21], + [ 0, 5, 18], + [ 0, 8, 11], + [ 0, 16, 0], + [ 0, 20, 0], + [ 0, 13, 0], + [ 7, 4, 15], + [ 8, 0, 25], + [ 6, 0, 2], + [ 0, 4, 0], + [ 0, 13, 16], + [ 0, 8, 9], + [ 22, 0, 0], + [ 25, 0, 0], + [ 0, 7, 0], + [ 0, 12, 0], + [ 0, 7, 0], + [ 0, 5, 15], + [ 1, 0, 32], + [ 10, 0, 33], + [ 9, 0, 10], + [ 8, 6, 11], + [ 0, 5, 14], + [ 0, 16, 27]]], dtype=np.uint8), +) + +image_decoder_decode_jpeg_grayscale = ImageData( + image_decoder_decode_jpeg_rgb.data, + np.array([[[141], [142], [143], [142], [149], [209], [214], [209], [211], [207], [202], [206], [209], [200], [205], [228], [231], [234], [229], [239], [ 48], [ 63], [ 51], [ 61], [ 45], [124], [112], [115], [107], [119], [ 5], [ 6]],[[144], [144], [144], [141], [146], [203], [208], [203], [215], [211], [205], [208], [210], [202], [208], [233], [227], [228], [235], [227], [ 59], [ 53], [ 60], [ 61], [ 65], [122], [103], [118], [119], [115], [ 5], [ 4]],[[147], [146], [145], [144], [148], [205], [211], [209], [211], [207], [201], [201], [204], [197], [204], [227], [232], [231], [233], [224], [ 60], [ 51], [ 56], [ 56], [ 58], [118], [110], [117], [122], [114], [ 9], [ 8]],[[140], [139], [141], [144], [149], [205], [211], [213], [214], [213], [206], [206], [208], [203], [209], [230], [231], [237], [223], [228], [ 59], [ 69], [ 52], [ 61], [ 39], [115], [124], [111], [113], [117], [ 9], [ 9]],[[147], [146], [148], [150], [151], [201], [204], [206], [207], [207], [199], [197], [200], [202], [207], [226], [229], [241], [237], [221], [ 68], [ 53], [ 40], [ 61], [ 76], [112], [119], [102], [108], [115], [ 5], [ 4]],[[ 55], [ 52], [ 53], [ 52], [ 46], [ 86], [ 84], [ 87], [ 87], [ 91], [ 88], [ 89], [ 93], [ 88], [ 90], [105], [109], [ 86], [ 89], [112], [169], [192], [196], [172], [154], [109], [ 98], [ 98], [109], [106], [ 3], [ 3]],[[ 56], [ 53], [ 54], [ 54], [ 45], [ 80], [ 75], [ 77], [ 80], [ 88], [ 92], [ 95], [100], [ 95], [ 93], [104], [ 90], [ 97], [118], [102], [175], [159], [180], [187], [189], [102], [ 95], [100], [102], [ 98], [ 3], [ 3]],[[ 51], [ 49], [ 54], [ 57], [ 50], [ 85], [ 80], [ 81], [ 71], [ 83], [ 90], [ 95], [ 97], [ 94], [ 90], [ 99], [101], [103], [ 89], [ 92], [188], [190], [177], [179], [175], [ 96], [109], [103], [ 89], [ 96], [ 8], [ 4]],[[ 53], [ 56], [ 54], [ 51], [ 58], [ 73], [ 81], [ 79], [ 75], [ 81], [ 98], [100], [ 88], [ 90], [ 98], [101], [100], [106], [ 94], [ 96], [183], [185], [173], [178], [186], [102], [104], [ 92], [106], [ 87], [ 7], [ 11]],[[ 47], [ 51], [ 50], [ 47], [ 55], [ 71], [ 79], [ 77], [ 81], [ 70], [ 91], [ 96], [ 94], [100], [ 92], [102], [ 94], [ 99], [ 98], [112], [166], [179], [178], [184], [158], [106], [109], [ 99], [109], [ 97], [ 2], [ 6]],[[ 54], [ 58], [ 57], [ 54], [ 61], [ 76], [ 83], [ 81], [ 84], [ 79], [127], [128], [120], [129], [132], [186], [206], [207], [204], [190], [138], [125], [121], [123], [151], [152], [163], [164], [165], [155], [ 17], [ 10]],[[ 54], [ 57], [ 56], [ 52], [ 57], [ 71], [ 76], [ 73], [ 71], [ 67], [128], [124], [114], [121], [129], [218], [207], [206], [211], [211], [121], [122], [128], [127], [119], [157], [166], [168], [162], [160], [ 12], [ 10]],[[ 54], [ 59], [ 58], [ 54], [ 60], [ 73], [ 79], [ 75], [ 91], [ 76], [124], [125], [127], [129], [121], [203], [207], [194], [194], [204], [117], [129], [129], [116], [127], [172], [168], [165], [158], [168], [ 17], [ 13]],[[ 50], [ 54], [ 55], [ 52], [ 59], [ 73], [ 78], [ 75], [ 71], [ 72], [116], [124], [130], [125], [122], [201], [211], [214], [214], [214], [124], [125], [126], [128], [121], [158], [160], [164], [161], [166], [ 13], [ 11]],[[ 54], [ 59], [ 58], [ 54], [ 60], [ 71], [ 75], [ 71], [ 79], [ 93], [118], [123], [126], [115], [130], [209], [199], [212], [206], [197], [131], [122], [116], [129], [139], [154], [159], [167], [168], [162], [ 7], [ 3]],[[ 96], [ 99], [ 96], [ 90], [ 93], [101], [103], [ 97], [ 96], [ 92], [ 73], [ 68], [ 78], [ 66], [ 77], [135], [143], [144], [131], [153], [166], [188], [175], [176], [167], [153], [142], [138], [140], [136], [ 4], [ 5]],[[ 95], [ 95], [ 95], [ 95], [ 95], [ 96], [ 98], [ 98], [ 98], [ 94], [ 75], [ 69], [ 74], [ 78], [ 67], [144], [142], [143], [142], [140], [180], [178], [177], [178], [178], [139], [150], [143], [132], [140], [ 13], [ 1]],[[ 93], [ 93], [ 94], [ 95], [ 96], [ 97], [ 99], [ 99], [103], [101], [ 80], [ 72], [ 70], [ 73], [ 68], [143], [142], [143], [142], [140], [181], [178], [177], [179], [176], [133], [142], [148], [141], [141], [ 8], [ 1]],[[ 93], [ 94], [ 95], [ 96], [ 98], [ 99], [100], [101], [ 94], [ 95], [ 74], [ 70], [ 67], [ 73], [ 75], [143], [140], [142], [141], [138], [180], [177], [176], [178], [188], [143], [137], [143], [141], [143], [ 8], [ 7]],[[ 92], [ 93], [ 94], [ 94], [ 95], [ 95], [ 95], [ 94], [100], [101], [ 77], [ 78], [ 75], [ 81], [ 83], [132], [143], [144], [144], [141], [183], [181], [180], [182], [166], [147], [140], [140], [138], [144], [ 7], [ 4]],[[138], [138], [138], [138], [137], [135], [133], [132], [129], [125], [ 93], [ 96], [ 91], [ 92], [ 87], [110], [100], [102], [101], [ 99], [141], [139], [138], [140], [156], [185], [195], [194], [189], [194], [ 15], [ 5]],[[137], [137], [137], [136], [134], [130], [127], [126], [136], [132], [ 95], [104], [ 99], [100], [ 95], [ 99], [102], [104], [104], [102], [144], [142], [142], [144], [133], [189], [197], [191], [186], [195], [ 5], [ 5]],[[137], [138], [138], [137], [135], [132], [129], [127], [127], [126], [ 90], [102], [ 96], [100], [102], [ 99], [101], [103], [102], [101], [143], [141], [141], [143], [146], [199], [192], [186], [185], [197], [ 5], [ 13]],[[135], [136], [137], [137], [136], [133], [130], [128], [131], [132], [ 95], [105], [ 93], [ 96], [103], [ 98], [101], [103], [102], [101], [143], [141], [141], [143], [143], [194], [184], [191], [191], [198], [ 3], [ 10]],[[138], [134], [133], [134], [131], [127], [130], [136], [135], [125], [ 99], [ 98], [101], [ 98], [105], [ 94], [105], [100], [100], [113], [133], [146], [146], [142], [152], [186], [188], [190], [179], [180], [ 13], [ 2]],[[154], [155], [155], [159], [165], [174], [181], [185], [182], [172], [142], [135], [135], [131], [130], [110], [105], [102], [100], [100], [102], [103], [101], [ 98], [ 97], [118], [108], [112], [109], [125], [ 10], [ 4]],[[146], [148], [146], [145], [156], [173], [182], [180], [187], [180], [148], [138], [142], [144], [139], [110], [115], [117], [117], [112], [104], [ 99], [ 99], [101], [ 94], [117], [111], [117], [109], [115], [ 10], [ 1]],[[156], [159], [156], [150], [161], [183], [190], [185], [180], [174], [141], [128], [135], [143], [138], [104], [101], [105], [107], [104], [ 98], [ 95], [ 98], [102], [101], [115], [106], [111], [105], [109], [ 13], [ 4]],[[150], [152], [148], [143], [157], [179], [187], [181], [190], [185], [151], [134], [136], [142], [138], [106], [109], [109], [109], [106], [103], [100], [100], [100], [102], [113], [106], [116], [111], [102], [ 14], [ 4]],[[155], [157], [155], [153], [161], [175], [181], [177], [176], [174], [147], [135], [135], [136], [138], [116], [109], [107], [104], [103], [103], [101], [ 99], [ 97], [ 99], [110], [109], [122], [117], [102], [ 23], [ 4]],[[ 16], [ 15], [ 11], [ 9], [ 6], [ 4], [ 4], [ 5], [ 8], [ 12], [ 9], [ 11], [ 14], [ 12], [ 5], [ 4], [ 6], [ 10], [ 13], [ 8], [ 5], [ 9], [ 3], [ 2], [ 5], [ 8], [ 10], [ 11], [ 10], [ 10], [ 1], [ 4]],[[ 1], [ 1], [ 3], [ 6], [ 8], [ 7], [ 7], [ 6], [ 2], [ 5], [ 6], [ 9], [ 12], [ 8], [ 6], [ 5], [ 2], [ 2], [ 9], [ 6], [ 7], [ 7], [ 4], [ 7], [ 4], [ 5], [ 4], [ 7], [ 4], [ 7], [ 5], [ 12]]], dtype=np.uint8), +) + +image_decoder_decode_jpeg_bgr = ImageData( + image_decoder_decode_jpeg_rgb.data, + np.array([[[255, 73, 230], + [255, 76, 227], + [255, 81, 222], + [206, 95, 211], + [142, 123, 204], + [133, 202, 251], + [ 72, 226, 245], + [ 34, 230, 234], + [ 32, 234, 235], + [ 32, 229, 231], + [ 37, 221, 227], + [ 45, 224, 233], + [ 42, 227, 237], + [ 32, 216, 232], + [ 35, 219, 243], + [ 63, 247, 255], + [ 71, 255, 246], + [ 83, 255, 249], + [ 68, 253, 243], + [134, 251, 255], + [ 46, 23, 97], + [121, 19, 127], + [124, 0, 123], + [128, 19, 118], + [ 82, 28, 63], + [143, 133, 99], + [128, 146, 39], + [110, 162, 24], + [ 64, 157, 26], + [ 76, 154, 66], + [ 0, 9, 0], + [ 9, 0, 15]], + + [[255, 77, 232], + [255, 79, 228], + [254, 83, 221], + [208, 93, 210], + [146, 117, 202], + [137, 193, 248], + [ 77, 216, 242], + [ 35, 222, 230], + [ 40, 237, 239], + [ 36, 233, 235], + [ 37, 225, 230], + [ 41, 227, 235], + [ 42, 228, 238], + [ 34, 220, 230], + [ 41, 225, 237], + [ 70, 253, 255], + [ 68, 250, 242], + [ 70, 251, 242], + [ 79, 255, 255], + [124, 232, 255], + [ 57, 32, 112], + [108, 9, 119], + [129, 10, 132], + [121, 21, 117], + [ 95, 50, 83], + [134, 132, 98], + [108, 137, 34], + [106, 165, 31], + [ 75, 168, 40], + [ 71, 151, 62], + [ 0, 9, 0], + [ 5, 0, 11]], + + [[255, 81, 234], + [255, 82, 229], + [250, 86, 221], + [218, 95, 211], + [164, 115, 207], + [161, 189, 254], + [101, 213, 249], + [ 57, 224, 238], + [ 41, 232, 235], + [ 30, 229, 231], + [ 26, 221, 229], + [ 26, 221, 229], + [ 29, 225, 231], + [ 27, 219, 218], + [ 45, 229, 215], + [ 71, 252, 237], + [ 76, 252, 252], + [ 80, 248, 255], + [ 94, 249, 255], + [135, 225, 255], + [ 58, 30, 120], + [101, 6, 120], + [116, 9, 126], + [104, 20, 109], + [ 72, 47, 75], + [113, 130, 97], + [ 98, 144, 48], + [ 89, 163, 37], + [ 72, 169, 48], + [ 66, 151, 59], + [ 0, 16, 0], + [ 0, 13, 0]], + + [[236, 83, 216], + [238, 83, 211], + [246, 88, 205], + [226, 98, 203], + [181, 114, 205], + [178, 184, 255], + [120, 207, 255], + [ 77, 220, 251], + [ 56, 228, 246], + [ 46, 228, 247], + [ 43, 216, 248], + [ 45, 214, 251], + [ 50, 217, 250], + [ 51, 217, 234], + [ 69, 232, 217], + [ 95, 255, 234], + [ 93, 251, 245], + [104, 254, 255], + [101, 232, 252], + [153, 228, 255], + [ 52, 34, 111], + [103, 33, 126], + [ 93, 15, 109], + [ 91, 34, 103], + [ 39, 33, 52], + [ 99, 127, 98], + [106, 152, 75], + [ 86, 148, 48], + [ 78, 151, 53], + [ 83, 148, 69], + [ 0, 16, 0], + [ 0, 15, 0]], + + [[227, 104, 202], + [235, 103, 196], + [253, 106, 191], + [242, 111, 192], + [199, 117, 200], + [192, 176, 253], + [127, 193, 255], + [ 85, 204, 255], + [ 67, 210, 255], + [ 67, 209, 255], + [ 76, 195, 255], + [ 82, 189, 255], + [ 88, 193, 255], + [ 88, 197, 255], + [ 97, 217, 229], + [118, 246, 229], + [123, 250, 228], + [148, 255, 249], + [145, 251, 245], + [155, 224, 239], + [ 49, 57, 97], + [ 58, 35, 87], + [ 52, 21, 72], + [ 68, 48, 83], + [ 65, 76, 80], + [ 96, 122, 99], + [110, 136, 88], + [ 98, 123, 63], + [108, 127, 70], + [115, 130, 86], + [ 0, 9, 0], + [ 0, 7, 0]], + + [[128, 27, 83], + [137, 23, 76], + [161, 23, 70], + [151, 22, 73], + [103, 16, 84], + [ 86, 60, 138], + [ 13, 66, 146], + [ 0, 72, 150], + [ 0, 73, 146], + [ 0, 71, 164], + [ 0, 55, 186], + [ 15, 48, 198], + [ 24, 51, 202], + [ 19, 56, 176], + [ 16, 81, 136], + [ 31, 114, 116], + [ 38, 131, 94], + [ 17, 112, 62], + [ 23, 109, 75], + [ 55, 125, 108], + [128, 175, 173], + [162, 194, 200], + [175, 197, 203], + [153, 174, 175], + [131, 161, 150], + [ 95, 117, 98], + [102, 105, 83], + [117, 103, 80], + [143, 111, 92], + [138, 107, 92], + [ 12, 3, 0], + [ 2, 5, 0]], + + [[132, 43, 52], + [142, 40, 45], + [167, 38, 41], + [159, 35, 51], + [103, 21, 70], + [ 82, 55, 129], + [ 6, 53, 144], + [ 0, 53, 155], + [ 0, 53, 163], + [ 10, 52, 189], + [ 53, 32, 224], + [ 77, 23, 242], + [ 88, 25, 251], + [ 77, 33, 223], + [ 61, 59, 172], + [ 65, 98, 131], + [ 55, 111, 62], + [ 58, 130, 47], + [ 72, 146, 80], + [ 44, 128, 73], + [104, 200, 153], + [ 86, 183, 139], + [120, 202, 160], + [139, 206, 169], + [155, 203, 174], + [ 91, 109, 92], + [116, 92, 92], + [148, 90, 101], + [171, 88, 103], + [160, 87, 97], + [ 23, 0, 0], + [ 4, 4, 0]], + + [[140, 47, 26], + [146, 44, 21], + [169, 48, 22], + [158, 47, 39], + [103, 31, 67], + [ 83, 62, 131], + [ 14, 56, 153], + [ 0, 52, 170], + [ 0, 37, 164], + [ 25, 37, 195], + [ 71, 21, 233], + [100, 13, 255], + [111, 14, 255], + [103, 20, 236], + [ 88, 45, 180], + [ 92, 84, 131], + [ 92, 118, 70], + [ 85, 136, 46], + [ 59, 118, 43], + [ 41, 122, 53], + [106, 222, 153], + [100, 225, 156], + [101, 209, 143], + [122, 205, 150], + [141, 192, 155], + [ 91, 101, 89], + [137, 98, 119], + [161, 83, 120], + [174, 65, 104], + [167, 78, 104], + [ 27, 6, 4], + [ 0, 7, 0]], + + [[161, 50, 18], + [164, 54, 20], + [166, 53, 13], + [140, 47, 26], + [ 99, 44, 69], + [ 64, 52, 118], + [ 23, 55, 155], + [ 0, 48, 170], + [ 2, 41, 169], + [ 26, 36, 190], + [ 71, 35, 233], + [ 91, 26, 249], + [ 92, 10, 239], + [102, 23, 218], + [117, 54, 177], + [119, 83, 129], + [105, 112, 75], + [101, 131, 58], + [ 78, 116, 56], + [ 57, 120, 64], + [110, 214, 151], + [103, 217, 153], + [109, 203, 138], + [134, 202, 147], + [163, 199, 169], + [104, 102, 102], + [132, 88, 124], + [147, 67, 120], + [184, 78, 131], + [147, 68, 101], + [ 7, 9, 3], + [ 0, 18, 0]], + + [[136, 46, 15], + [138, 52, 16], + [135, 53, 11], + [114, 46, 23], + [ 89, 43, 66], + [ 76, 48, 114], + [ 60, 46, 151], + [ 45, 39, 164], + [ 51, 43, 167], + [ 38, 28, 164], + [ 54, 43, 200], + [ 59, 43, 214], + [ 59, 42, 210], + [ 79, 56, 195], + [ 94, 65, 144], + [114, 93, 115], + [106, 103, 72], + [108, 116, 63], + [103, 111, 70], + [103, 127, 87], + [129, 187, 139], + [138, 201, 151], + [155, 198, 147], + [177, 198, 160], + [162, 162, 150], + [124, 97, 117], + [141, 86, 143], + [147, 68, 142], + [176, 76, 148], + [145, 74, 124], + [ 0, 0, 6], + [ 0, 10, 0]], + + [[ 88, 57, 36], + [ 92, 62, 37], + [ 91, 65, 29], + [ 88, 55, 39], + [ 95, 47, 76], + [115, 47, 118], + [134, 39, 150], + [132, 32, 158], + [123, 41, 154], + [ 86, 43, 146], + [ 79, 101, 196], + [ 45, 111, 194], + [ 17, 109, 180], + [ 37, 126, 170], + [ 77, 138, 140], + [165, 197, 173], + [215, 215, 185], + [235, 214, 183], + [239, 206, 186], + [225, 192, 173], + [165, 142, 120], + [157, 128, 107], + [171, 121, 101], + [178, 118, 112], + [199, 138, 158], + [195, 129, 180], + [198, 130, 215], + [203, 125, 226], + [216, 126, 222], + [189, 125, 201], + [ 3, 6, 44], + [ 0, 5, 23]], + + [[ 65, 58, 43], + [ 66, 62, 43], + [ 63, 65, 36], + [ 64, 55, 42], + [ 84, 44, 72], + [121, 41, 112], + [156, 28, 140], + [158, 21, 143], + [140, 28, 130], + [ 86, 39, 115], + [ 70, 121, 164], + [ 14, 132, 151], + [ 0, 127, 131], + [ 0, 142, 127], + [ 55, 151, 115], + [190, 235, 196], + [218, 214, 189], + [245, 206, 192], + [255, 208, 201], + [255, 207, 202], + [188, 114, 110], + [202, 113, 109], + [225, 115, 117], + [224, 109, 126], + [195, 95, 137], + [212, 127, 195], + [201, 129, 225], + [200, 127, 237], + [203, 120, 229], + [188, 125, 217], + [ 0, 0, 41], + [ 0, 0, 32]], + + [[ 73, 55, 44], + [ 73, 63, 46], + [ 63, 66, 41], + [ 59, 57, 46], + [ 76, 50, 74], + [108, 47, 111], + [146, 35, 141], + [148, 27, 142], + [148, 52, 146], + [ 85, 55, 114], + [ 55, 130, 139], + [ 10, 147, 125], + [ 0, 155, 119], + [ 16, 158, 115], + [ 68, 140, 104], + [194, 213, 186], + [226, 209, 196], + [235, 190, 186], + [247, 187, 187], + [255, 197, 198], + [202, 105, 109], + [232, 113, 121], + [249, 108, 123], + [231, 91, 122], + [214, 99, 149], + [230, 141, 211], + [200, 133, 225], + [190, 126, 232], + [192, 118, 224], + [196, 132, 227], + [ 14, 0, 51], + [ 4, 0, 43]], + + [[ 59, 57, 33], + [ 59, 62, 36], + [ 53, 66, 34], + [ 52, 58, 39], + [ 70, 52, 69], + [105, 50, 107], + [140, 36, 137], + [148, 27, 142], + [131, 30, 128], + [ 93, 49, 110], + [ 68, 120, 126], + [ 32, 146, 116], + [ 18, 160, 115], + [ 31, 150, 112], + [ 81, 131, 121], + [196, 200, 205], + [227, 206, 215], + [242, 206, 218], + [248, 207, 215], + [255, 206, 214], + [193, 113, 120], + [215, 110, 121], + [234, 106, 125], + [229, 105, 135], + [192, 97, 141], + [202, 133, 190], + [178, 133, 206], + [176, 135, 216], + [184, 132, 210], + [193, 139, 209], + [ 21, 0, 36], + [ 18, 0, 29]], + + [[ 33, 75, 22], + [ 40, 79, 27], + [ 44, 77, 26], + [ 50, 65, 33], + [ 72, 57, 61], + [106, 50, 99], + [141, 32, 134], + [153, 19, 143], + [162, 29, 146], + [150, 57, 142], + [120, 108, 136], + [ 84, 131, 123], + [ 57, 141, 123], + [ 48, 124, 123], + [ 91, 121, 162], + [193, 192, 248], + [197, 185, 227], + [214, 201, 233], + [201, 199, 221], + [197, 192, 207], + [150, 126, 134], + [161, 114, 122], + [174, 105, 116], + [184, 116, 133], + [171, 127, 150], + [165, 143, 171], + [154, 149, 181], + [160, 157, 189], + [177, 156, 188], + [181, 152, 175], + [ 30, 0, 11], + [ 27, 0, 1]], + + [[ 61, 122, 58], + [ 64, 125, 61], + [ 64, 121, 60], + [ 71, 106, 66], + [ 97, 93, 92], + [133, 81, 129], + [170, 59, 165], + [184, 41, 174], + [185, 40, 172], + [165, 48, 151], + [112, 50, 102], + [ 73, 60, 82], + [ 50, 77, 91], + [ 27, 59, 94], + [ 50, 53, 134], + [114, 106, 199], + [124, 121, 193], + [121, 127, 186], + [101, 115, 173], + [121, 143, 184], + [139, 165, 179], + [170, 189, 192], + [175, 172, 181], + [176, 174, 180], + [155, 169, 168], + [134, 158, 150], + [119, 151, 134], + [120, 148, 125], + [133, 150, 123], + [140, 143, 121], + [ 17, 4, 0], + [ 26, 3, 0]], + + [[ 61, 119, 61], + [ 54, 121, 60], + [ 38, 124, 60], + [ 47, 116, 71], + [ 79, 97, 96], + [119, 76, 127], + [167, 51, 164], + [183, 39, 181], + [172, 41, 181], + [161, 45, 164], + [139, 40, 118], + [113, 45, 100], + [ 85, 56, 106], + [ 71, 56, 124], + [ 60, 31, 140], + [126, 107, 224], + [105, 114, 212], + [ 97, 116, 213], + [ 99, 109, 223], + [ 89, 116, 206], + [109, 181, 205], + [100, 190, 185], + [110, 182, 192], + [116, 185, 188], + [118, 194, 170], + [ 89, 162, 112], + [118, 180, 104], + [120, 176, 87], + [105, 166, 76], + [121, 165, 98], + [ 7, 20, 0], + [ 5, 0, 0]], + + [[ 72, 114, 61], + [ 59, 116, 61], + [ 37, 121, 63], + [ 44, 114, 77], + [ 78, 97, 100], + [120, 77, 128], + [168, 54, 161], + [182, 43, 178], + [169, 50, 183], + [163, 52, 174], + [158, 37, 135], + [139, 35, 120], + [104, 38, 120], + [ 87, 39, 135], + [ 77, 24, 151], + [132, 100, 231], + [ 98, 109, 223], + [ 86, 111, 227], + [ 94, 101, 240], + [ 82, 111, 220], + [ 92, 183, 210], + [ 79, 193, 186], + [ 85, 186, 195], + [ 94, 191, 189], + [ 98, 199, 161], + [ 71, 165, 94], + [105, 181, 80], + [118, 190, 76], + [100, 184, 72], + [104, 174, 91], + [ 0, 13, 0], + [ 0, 1, 0]], + + [[ 91, 110, 59], + [ 82, 111, 65], + [ 63, 113, 73], + [ 68, 107, 86], + [ 98, 94, 106], + [131, 79, 127], + [169, 62, 149], + [179, 54, 163], + [154, 47, 163], + [155, 48, 164], + [154, 26, 138], + [144, 23, 134], + [111, 23, 136], + [ 98, 30, 149], + [ 94, 27, 162], + [141, 98, 231], + [ 99, 106, 223], + [ 87, 110, 226], + [ 95, 102, 235], + [ 85, 110, 214], + [102, 181, 208], + [ 92, 190, 184], + [103, 184, 189], + [112, 189, 181], + [126, 211, 167], + [ 90, 174, 102], + [ 98, 173, 81], + [104, 181, 83], + [ 88, 179, 86], + [ 95, 173, 102], + [ 0, 14, 0], + [ 0, 12, 1]], + + [[ 88, 95, 88], + [ 81, 95, 94], + [ 64, 95, 104], + [ 66, 90, 114], + [ 88, 81, 124], + [111, 73, 133], + [138, 65, 138], + [142, 60, 143], + [132, 66, 155], + [142, 62, 163], + [148, 29, 144], + [154, 26, 151], + [130, 25, 152], + [124, 33, 160], + [124, 35, 162], + [157, 91, 204], + [138, 115, 200], + [125, 120, 199], + [130, 115, 207], + [114, 121, 190], + [128, 187, 196], + [115, 194, 180], + [122, 189, 186], + [125, 193, 182], + [102, 189, 145], + [ 81, 176, 115], + [ 80, 170, 104], + [ 74, 171, 105], + [ 60, 167, 110], + [ 75, 167, 124], + [ 0, 12, 0], + [ 0, 7, 0]], + + [[111, 115, 194], + [103, 114, 198], + [ 88, 113, 207], + [ 87, 112, 210], + [ 96, 111, 204], + [108, 111, 192], + [121, 113, 178], + [123, 114, 171], + [111, 111, 171], + [127, 99, 175], + [144, 49, 159], + [169, 44, 170], + [158, 39, 167], + [159, 43, 164], + [160, 43, 146], + [181, 77, 148], + [162, 84, 108], + [155, 93, 99], + [147, 89, 107], + [122, 94, 100], + [122, 153, 124], + [ 96, 157, 121], + [ 92, 148, 135], + [ 82, 152, 139], + [ 76, 179, 142], + [ 91, 211, 170], + [ 92, 217, 191], + [ 84, 212, 200], + [ 70, 206, 202], + [ 93, 207, 207], + [ 0, 19, 14], + [ 0, 8, 2]], + + [[ 93, 98, 230], + [ 87, 97, 234], + [ 77, 97, 239], + [ 74, 97, 236], + [ 79, 101, 220], + [ 80, 105, 197], + [ 84, 113, 170], + [ 85, 117, 158], + [ 92, 127, 170], + [118, 112, 177], + [143, 53, 159], + [184, 50, 180], + [182, 44, 175], + [192, 48, 167], + [198, 51, 143], + [205, 69, 117], + [205, 93, 81], + [198, 105, 66], + [182, 105, 73], + [148, 108, 73], + [142, 160, 113], + [112, 161, 117], + [103, 154, 134], + [ 84, 158, 140], + [ 44, 156, 122], + [ 77, 213, 185], + [ 73, 213, 214], + [ 58, 200, 223], + [ 51, 192, 225], + [ 89, 201, 224], + [ 0, 7, 4], + [ 0, 8, 0]], + + [[ 82, 93, 245], + [ 81, 93, 247], + [ 80, 92, 250], + [ 79, 95, 242], + [ 82, 101, 222], + [ 81, 109, 196], + [ 79, 119, 168], + [ 79, 122, 155], + [ 81, 120, 158], + [115, 106, 169], + [148, 45, 156], + [199, 44, 179], + [201, 36, 173], + [215, 44, 166], + [233, 53, 148], + [232, 66, 113], + [220, 92, 73], + [204, 108, 54], + [184, 110, 56], + [147, 113, 59], + [139, 160, 111], + [109, 159, 119], + [100, 153, 133], + [ 83, 158, 137], + [ 54, 170, 133], + [ 84, 222, 198], + [ 63, 203, 220], + [ 53, 189, 231], + [ 61, 183, 235], + [110, 197, 229], + [ 0, 8, 0], + [ 21, 18, 0]], + + [[ 57, 106, 222], + [ 60, 107, 223], + [ 66, 106, 225], + [ 70, 109, 218], + [ 72, 115, 202], + [ 69, 120, 182], + [ 64, 128, 159], + [ 64, 129, 150], + [ 71, 129, 158], + [107, 118, 170], + [138, 59, 150], + [185, 58, 167], + [178, 46, 152], + [192, 54, 142], + [216, 68, 128], + [218, 76, 95], + [218, 99, 60], + [208, 113, 44], + [187, 116, 42], + [152, 117, 49], + [147, 159, 111], + [116, 154, 124], + [113, 149, 135], + [ 93, 153, 142], + [ 61, 162, 137], + [ 86, 209, 205], + [ 58, 185, 230], + [ 62, 183, 255], + [ 73, 182, 255], + [116, 190, 246], + [ 0, 5, 0], + [ 25, 12, 0]], + + [[ 26, 145, 167], + [ 28, 140, 163], + [ 37, 137, 162], + [ 45, 137, 162], + [ 46, 136, 153], + [ 42, 134, 145], + [ 40, 140, 144], + [ 46, 146, 150], + [ 45, 142, 156], + [ 65, 122, 153], + [ 99, 81, 134], + [126, 76, 130], + [126, 85, 123], + [128, 89, 105], + [153, 102, 92], + [165, 97, 60], + [202, 114, 50], + [205, 115, 31], + [189, 119, 28], + [173, 131, 54], + [151, 144, 105], + [141, 151, 138], + [141, 146, 147], + [117, 143, 149], + [ 92, 159, 160], + [ 96, 188, 217], + [ 77, 176, 255], + [ 77, 179, 255], + [ 64, 162, 255], + [ 89, 159, 255], + [ 0, 6, 31], + [ 5, 3, 0]], + + [[ 23, 197, 119], + [ 29, 197, 121], + [ 42, 193, 124], + [ 49, 194, 132], + [ 55, 196, 145], + [ 59, 203, 161], + [ 59, 206, 178], + [ 59, 207, 191], + [ 58, 199, 196], + [ 75, 183, 187], + [ 99, 145, 153], + [117, 138, 135], + [110, 148, 118], + [115, 152, 96], + [139, 155, 78], + [153, 135, 46], + [192, 125, 33], + [205, 121, 26], + [192, 122, 21], + [166, 117, 43], + [127, 105, 87], + [107, 97, 114], + [105, 90, 121], + [ 84, 86, 126], + [ 49, 88, 132], + [ 42, 104, 175], + [ 9, 78, 205], + [ 0, 73, 231], + [ 0, 69, 230], + [ 35, 95, 219], + [ 0, 0, 34], + [ 2, 3, 7]], + + [[ 10, 226, 41], + [ 15, 226, 46], + [ 20, 219, 51], + [ 16, 212, 62], + [ 16, 215, 93], + [ 22, 224, 131], + [ 21, 223, 164], + [ 13, 214, 177], + [ 22, 217, 191], + [ 42, 207, 180], + [ 63, 173, 131], + [ 78, 168, 102], + [ 82, 184, 82], + [101, 193, 64], + [134, 188, 45], + [147, 152, 13], + [198, 143, 28], + [218, 139, 36], + [209, 140, 37], + [178, 125, 62], + [127, 96, 111], + [101, 78, 140], + [ 97, 73, 151], + [ 83, 72, 164], + [ 50, 65, 167], + [ 50, 83, 210], + [ 28, 64, 234], + [ 23, 67, 252], + [ 8, 63, 238], + [ 37, 82, 210], + [ 0, 0, 34], + [ 4, 0, 1]], + + [[ 23, 255, 14], + [ 27, 255, 22], + [ 23, 248, 27], + [ 10, 234, 38], + [ 5, 234, 77], + [ 13, 245, 127], + [ 7, 239, 163], + [ 0, 225, 176], + [ 0, 216, 178], + [ 15, 209, 166], + [ 29, 177, 113], + [ 41, 171, 78], + [ 50, 189, 62], + [ 83, 200, 53], + [127, 191, 38], + [143, 149, 2], + [190, 133, 4], + [213, 131, 12], + [206, 132, 20], + [177, 116, 52], + [125, 85, 113], + [ 95, 67, 150], + [ 91, 66, 164], + [ 81, 66, 181], + [ 55, 63, 194], + [ 51, 71, 226], + [ 33, 52, 239], + [ 29, 56, 250], + [ 15, 57, 234], + [ 38, 75, 203], + [ 0, 0, 42], + [ 0, 2, 10]], + + [[ 19, 251, 0], + [ 23, 252, 5], + [ 17, 241, 15], + [ 1, 228, 29], + [ 0, 231, 70], + [ 4, 242, 122], + [ 3, 237, 159], + [ 0, 222, 171], + [ 6, 228, 186], + [ 22, 222, 175], + [ 29, 188, 126], + [ 33, 174, 93], + [ 37, 184, 80], + [ 73, 189, 76], + [127, 175, 69], + [154, 138, 25], + [212, 140, 8], + [235, 140, 1], + [224, 138, 8], + [191, 121, 44], + [137, 91, 113], + [102, 74, 150], + [ 88, 72, 160], + [ 70, 68, 174], + [ 51, 65, 195], + [ 49, 69, 224], + [ 40, 53, 235], + [ 43, 63, 248], + [ 26, 67, 230], + [ 29, 70, 192], + [ 0, 0, 46], + [ 0, 0, 15]], + + [[ 58, 234, 37], + [ 60, 233, 45], + [ 58, 225, 55], + [ 47, 216, 70], + [ 39, 215, 101], + [ 44, 220, 137], + [ 48, 216, 163], + [ 42, 207, 170], + [ 43, 205, 170], + [ 55, 203, 163], + [ 55, 176, 125], + [ 52, 168, 103], + [ 43, 173, 96], + [ 70, 170, 94], + [133, 159, 99], + [160, 133, 66], + [192, 131, 33], + [206, 133, 19], + [200, 130, 17], + [174, 117, 48], + [126, 93, 114], + [ 96, 80, 144], + [ 83, 81, 141], + [ 69, 78, 146], + [ 58, 73, 166], + [ 66, 77, 191], + [ 70, 68, 204], + [ 78, 81, 219], + [ 59, 83, 205], + [ 47, 79, 168], + [ 0, 13, 50], + [ 0, 1, 10]], + + [[ 0, 28, 0], + [ 0, 25, 0], + [ 0, 19, 0], + [ 0, 15, 0], + [ 0, 10, 0], + [ 0, 7, 0], + [ 0, 4, 5], + [ 0, 6, 5], + [ 0, 13, 1], + [ 0, 21, 0], + [ 0, 15, 0], + [ 0, 19, 0], + [ 0, 24, 0], + [ 0, 20, 0], + [ 6, 8, 0], + [ 30, 1, 0], + [ 28, 5, 0], + [ 32, 10, 0], + [ 41, 15, 0], + [ 28, 9, 0], + [ 0, 0, 18], + [ 0, 0, 31], + [ 0, 0, 10], + [ 0, 1, 4], + [ 0, 0, 18], + [ 0, 0, 27], + [ 7, 0, 32], + [ 5, 0, 36], + [ 0, 0, 35], + [ 0, 1, 31], + [ 0, 1, 0], + [ 7, 5, 0]], + + [[ 0, 2, 0], + [ 0, 0, 3], + [ 4, 0, 10], + [ 10, 0, 17], + [ 11, 0, 22], + [ 14, 0, 18], + [ 25, 0, 15], + [ 29, 0, 9], + [ 21, 0, 0], + [ 18, 5, 0], + [ 11, 8, 0], + [ 0, 16, 0], + [ 0, 20, 0], + [ 0, 13, 0], + [ 15, 4, 7], + [ 25, 0, 8], + [ 2, 0, 6], + [ 0, 4, 0], + [ 16, 13, 0], + [ 9, 8, 0], + [ 0, 0, 22], + [ 0, 0, 25], + [ 0, 7, 0], + [ 0, 12, 0], + [ 0, 7, 0], + [ 15, 5, 0], + [ 32, 0, 1], + [ 33, 0, 10], + [ 10, 0, 9], + [ 11, 6, 8], + [ 14, 5, 0], + [ 27, 16, 0]]], dtype=np.uint8), +) + +image_decoder_decode_jpeg2k_rgb = ImageData( + np.array([ 0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10, 0, + 0, 0, 20, 102, 116, 121, 112, 106, 112, 50, 32, 0, 0, + 0, 0, 106, 112, 50, 32, 0, 0, 0, 45, 106, 112, 50, + 104, 0, 0, 0, 22, 105, 104, 100, 114, 0, 0, 0, 32, + 0, 0, 0, 32, 0, 3, 7, 7, 0, 0, 0, 0, 0, + 15, 99, 111, 108, 114, 1, 0, 0, 0, 0, 0, 16, 0, + 0, 7, 18, 106, 112, 50, 99, 255, 79, 255, 81, 0, 47, + 0, 0, 0, 0, 0, 32, 0, 0, 0, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 7, 1, 1, + 7, 1, 1, 7, 1, 1, 255, 82, 0, 12, 0, 0, 0, + 1, 0, 5, 4, 4, 0, 1, 255, 92, 0, 19, 64, 64, + 72, 72, 80, 72, 72, 80, 72, 72, 80, 72, 72, 80, 72, + 72, 80, 255, 100, 0, 37, 0, 1, 67, 114, 101, 97, 116, + 101, 100, 32, 98, 121, 32, 79, 112, 101, 110, 74, 80, 69, + 71, 32, 118, 101, 114, 115, 105, 111, 110, 32, 50, 46, 53, + 46, 48, 255, 144, 0, 10, 0, 0, 0, 0, 6, 139, 0, + 1, 255, 147, 195, 231, 4, 0, 31, 193, 242, 2, 9, 127, + 195, 231, 2, 7, 195, 234, 2, 143, 180, 10, 31, 104, 16, + 4, 115, 5, 159, 0, 79, 199, 218, 5, 15, 168, 10, 31, + 104, 8, 3, 25, 8, 159, 9, 193, 243, 130, 131, 231, 5, + 63, 48, 32, 9, 111, 8, 127, 4, 167, 199, 218, 11, 63, + 0, 104, 252, 1, 64, 14, 25, 236, 129, 63, 10, 242, 160, + 112, 52, 191, 3, 34, 223, 152, 23, 207, 192, 22, 62, 208, + 88, 125, 160, 192, 14, 120, 105, 193, 230, 9, 210, 147, 177, + 25, 9, 144, 148, 195, 126, 191, 207, 192, 26, 62, 208, 88, + 252, 1, 64, 7, 247, 239, 48, 181, 159, 12, 90, 58, 122, + 9, 12, 13, 199, 195, 143, 207, 192, 78, 126, 2, 113, 248, + 10, 0, 22, 170, 96, 67, 117, 221, 185, 238, 123, 216, 135, + 177, 65, 60, 79, 209, 148, 7, 159, 1, 17, 79, 179, 172, + 17, 21, 60, 101, 99, 223, 82, 254, 246, 110, 40, 44, 0, + 127, 21, 238, 219, 43, 124, 121, 243, 213, 250, 63, 49, 33, + 98, 47, 113, 45, 170, 153, 160, 243, 207, 192, 78, 126, 2, + 144, 251, 68, 64, 34, 100, 150, 169, 72, 29, 190, 139, 77, + 175, 243, 121, 86, 141, 46, 115, 17, 255, 127, 27, 206, 245, + 36, 137, 3, 88, 150, 229, 17, 22, 80, 214, 179, 155, 191, + 9, 119, 234, 159, 22, 133, 163, 43, 90, 41, 169, 46, 72, + 36, 172, 70, 56, 17, 202, 131, 183, 199, 218, 37, 63, 1, + 41, 249, 137, 128, 20, 147, 110, 123, 141, 178, 193, 87, 126, + 222, 22, 15, 24, 73, 29, 111, 114, 149, 32, 218, 201, 39, + 120, 134, 155, 184, 134, 66, 58, 217, 10, 0, 156, 49, 44, + 239, 22, 2, 193, 92, 254, 178, 255, 95, 37, 196, 94, 93, + 83, 106, 3, 55, 215, 87, 63, 223, 154, 12, 252, 17, 35, + 240, 60, 57, 83, 92, 9, 186, 184, 253, 97, 108, 204, 42, + 121, 198, 54, 152, 214, 158, 133, 109, 255, 22, 77, 129, 217, + 162, 182, 150, 79, 119, 10, 227, 28, 236, 98, 161, 32, 251, + 158, 183, 120, 79, 138, 187, 174, 187, 111, 254, 30, 115, 99, + 23, 127, 60, 252, 16, 118, 155, 70, 55, 232, 247, 73, 175, + 224, 111, 60, 142, 99, 107, 203, 71, 232, 40, 144, 21, 187, + 70, 32, 169, 182, 179, 169, 171, 82, 155, 15, 190, 227, 163, + 167, 10, 254, 246, 118, 49, 244, 220, 255, 116, 207, 201, 87, + 180, 16, 121, 97, 154, 12, 240, 180, 206, 164, 0, 13, 219, + 227, 153, 33, 36, 212, 33, 89, 109, 6, 212, 168, 226, 221, + 243, 0, 50, 17, 127, 97, 234, 151, 12, 94, 181, 84, 194, + 7, 118, 33, 72, 104, 4, 221, 22, 70, 229, 50, 52, 80, + 241, 134, 38, 236, 26, 66, 70, 23, 53, 244, 221, 116, 56, + 165, 197, 163, 99, 7, 113, 30, 233, 241, 30, 91, 217, 146, + 56, 101, 216, 39, 56, 250, 172, 211, 15, 16, 47, 65, 127, + 207, 192, 254, 126, 7, 208, 251, 77, 192, 39, 93, 199, 157, + 201, 217, 6, 20, 49, 113, 89, 51, 238, 155, 138, 137, 202, + 96, 134, 221, 198, 47, 240, 209, 203, 72, 12, 202, 155, 22, + 157, 81, 250, 5, 207, 71, 13, 208, 91, 14, 180, 66, 25, + 170, 123, 251, 123, 200, 96, 140, 228, 107, 89, 93, 20, 28, + 69, 249, 146, 179, 144, 250, 127, 62, 97, 226, 175, 173, 54, + 142, 247, 5, 69, 105, 71, 176, 25, 38, 200, 187, 193, 148, + 222, 254, 21, 255, 122, 230, 25, 106, 31, 176, 84, 10, 231, + 179, 117, 255, 50, 202, 29, 225, 188, 22, 227, 11, 177, 103, + 37, 205, 237, 14, 73, 88, 35, 83, 169, 242, 85, 211, 102, + 4, 142, 68, 95, 37, 82, 80, 214, 20, 11, 88, 115, 195, + 98, 106, 218, 114, 145, 123, 75, 75, 137, 231, 55, 77, 234, + 255, 15, 84, 210, 255, 64, 64, 20, 121, 57, 78, 253, 249, + 212, 65, 128, 151, 92, 94, 202, 110, 182, 34, 187, 7, 53, + 92, 36, 83, 100, 165, 121, 71, 207, 192, 250, 126, 7, 176, + 251, 77, 128, 36, 198, 178, 18, 76, 218, 211, 240, 218, 60, + 13, 248, 75, 214, 67, 64, 18, 66, 236, 198, 84, 245, 51, + 12, 3, 1, 92, 45, 35, 139, 118, 66, 222, 137, 88, 222, + 75, 85, 44, 193, 125, 206, 91, 163, 92, 147, 203, 52, 24, + 223, 120, 99, 100, 87, 72, 29, 61, 233, 70, 212, 108, 239, + 82, 243, 93, 156, 226, 55, 118, 254, 179, 72, 189, 40, 125, + 216, 140, 179, 219, 226, 142, 202, 239, 14, 133, 104, 196, 156, + 84, 111, 170, 186, 228, 127, 214, 32, 165, 68, 129, 204, 171, + 3, 120, 212, 6, 164, 158, 250, 178, 132, 138, 76, 206, 80, + 43, 120, 0, 235, 221, 142, 194, 133, 111, 76, 233, 61, 247, + 7, 103, 43, 113, 35, 140, 59, 224, 80, 183, 221, 52, 198, + 22, 127, 253, 147, 102, 60, 126, 241, 91, 200, 146, 170, 69, + 217, 123, 36, 141, 88, 160, 132, 121, 239, 104, 123, 227, 227, + 123, 190, 157, 71, 12, 179, 28, 187, 245, 45, 111, 207, 193, + 146, 126, 12, 112, 251, 77, 192, 172, 193, 118, 152, 92, 250, + 245, 178, 145, 220, 2, 246, 200, 173, 130, 233, 43, 23, 207, + 176, 154, 220, 79, 208, 152, 232, 49, 148, 197, 12, 28, 187, + 215, 231, 74, 253, 114, 157, 45, 56, 62, 45, 55, 37, 63, + 220, 131, 255, 32, 189, 251, 116, 36, 204, 16, 72, 124, 138, + 94, 44, 96, 110, 62, 104, 57, 246, 44, 174, 179, 147, 146, + 32, 91, 92, 114, 196, 87, 209, 170, 88, 95, 21, 139, 254, + 78, 207, 156, 124, 151, 116, 227, 49, 30, 171, 162, 67, 120, + 31, 199, 127, 172, 192, 52, 46, 151, 230, 141, 248, 110, 35, + 243, 135, 232, 26, 43, 142, 196, 185, 12, 31, 123, 137, 118, + 145, 48, 91, 56, 46, 85, 72, 18, 97, 34, 253, 207, 73, + 6, 204, 217, 124, 228, 59, 146, 216, 33, 21, 121, 105, 196, + 65, 232, 214, 181, 33, 112, 35, 55, 32, 33, 125, 46, 251, + 203, 242, 226, 175, 225, 187, 121, 111, 111, 255, 29, 75, 9, + 3, 194, 219, 238, 88, 133, 72, 196, 238, 51, 233, 109, 12, + 25, 10, 233, 187, 9, 192, 207, 13, 156, 39, 179, 130, 200, + 62, 211, 143, 151, 41, 170, 39, 11, 131, 60, 130, 78, 123, + 42, 202, 95, 61, 144, 135, 25, 74, 217, 191, 126, 75, 2, + 248, 229, 162, 158, 203, 118, 243, 164, 243, 12, 46, 4, 178, + 182, 205, 93, 28, 245, 197, 208, 12, 129, 253, 202, 125, 52, + 175, 199, 218, 191, 31, 106, 252, 62, 211, 16, 28, 232, 48, + 162, 23, 193, 178, 85, 202, 167, 50, 213, 135, 203, 213, 27, + 46, 88, 209, 38, 100, 195, 157, 78, 8, 92, 80, 131, 1, + 63, 224, 212, 8, 26, 89, 41, 113, 24, 140, 81, 51, 226, + 213, 93, 247, 195, 32, 162, 62, 37, 90, 178, 221, 91, 29, + 208, 212, 99, 228, 11, 68, 39, 232, 182, 168, 128, 68, 47, + 120, 91, 215, 14, 39, 113, 211, 156, 72, 108, 30, 128, 171, + 43, 176, 182, 171, 113, 246, 165, 179, 121, 20, 155, 19, 123, + 199, 34, 225, 202, 31, 38, 55, 160, 175, 114, 38, 236, 62, + 89, 241, 175, 49, 106, 198, 41, 44, 173, 11, 243, 12, 6, + 173, 111, 165, 11, 112, 162, 192, 47, 188, 234, 18, 87, 128, + 156, 125, 24, 251, 76, 185, 246, 22, 208, 211, 181, 43, 9, + 5, 168, 66, 222, 117, 48, 39, 165, 199, 250, 206, 38, 56, + 205, 16, 78, 244, 43, 227, 148, 36, 44, 93, 250, 6, 159, + 16, 86, 5, 48, 155, 224, 126, 49, 225, 114, 202, 48, 143, + 249, 97, 218, 162, 47, 65, 170, 89, 251, 164, 134, 209, 85, + 26, 37, 116, 11, 118, 109, 5, 54, 2, 191, 141, 206, 195, + 31, 248, 32, 125, 3, 11, 136, 183, 82, 5, 75, 21, 29, + 7, 133, 33, 216, 139, 51, 76, 2, 21, 246, 232, 226, 180, + 170, 62, 199, 218, 181, 31, 106, 236, 62, 211, 80, 28, 76, + 84, 159, 4, 65, 45, 39, 210, 159, 35, 192, 202, 118, 120, + 113, 103, 253, 75, 75, 29, 51, 207, 47, 118, 61, 205, 24, + 61, 63, 1, 17, 52, 104, 120, 192, 211, 103, 43, 123, 71, + 170, 107, 8, 243, 28, 56, 166, 39, 181, 109, 213, 6, 39, + 56, 190, 181, 90, 56, 15, 152, 255, 45, 19, 192, 235, 243, + 23, 245, 230, 151, 239, 68, 55, 179, 23, 15, 235, 29, 68, + 125, 242, 9, 113, 86, 86, 21, 82, 207, 67, 115, 187, 10, + 73, 82, 210, 112, 95, 199, 163, 129, 28, 179, 43, 72, 187, + 122, 30, 152, 227, 80, 163, 50, 129, 121, 138, 9, 19, 10, + 19, 44, 101, 108, 69, 246, 105, 58, 85, 146, 155, 114, 216, + 168, 49, 23, 223, 94, 202, 124, 62, 127, 16, 20, 86, 26, + 183, 95, 189, 192, 165, 141, 55, 91, 79, 49, 229, 108, 77, + 250, 123, 247, 184, 138, 47, 103, 176, 157, 8, 81, 201, 192, + 156, 59, 240, 251, 47, 34, 71, 39, 3, 179, 38, 223, 110, + 159, 133, 196, 85, 72, 241, 227, 104, 224, 110, 127, 216, 242, + 88, 42, 220, 81, 93, 138, 63, 86, 78, 76, 149, 234, 116, + 126, 32, 5, 40, 46, 103, 109, 144, 200, 232, 34, 217, 153, + 38, 76, 185, 122, 147, 225, 110, 237, 245, 41, 121, 206, 151, + 255, 217], dtype=np.uint8), + np.array([[[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0]]], dtype=np.uint8), +) + +image_decoder_decode_bmp_rgb = ImageData( + np.array([ 66, 77, 54, 12, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 0, 40, 0, 0, 0, 32, 0, 0, 0, 32, 0, 0, 0, + 1, 0, 24, 0, 0, 0, 0, 0, 0, 12, 0, 0, 196, + 14, 0, 0, 196, 14, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, + 246, 24, 11, 246, 24, 11, 246, 24, 11, 246, 24, 11, 246, + 24, 6, 219, 177, 6, 219, 177, 6, 219, 177, 6, 219, 177, + 6, 219, 177, 37, 188, 77, 37, 188, 77, 37, 188, 77, 37, + 188, 77, 37, 188, 77, 230, 138, 2, 230, 138, 2, 230, 138, + 2, 230, 138, 2, 230, 138, 2, 81, 74, 159, 81, 74, 159, + 81, 74, 159, 81, 74, 159, 81, 74, 159, 27, 63, 240, 27, + 63, 240, 27, 63, 240, 27, 63, 240, 27, 63, 240, 0, 0, + 0, 0, 0, 0, 11, 246, 24, 11, 246, 24, 11, 246, 24, + 11, 246, 24, 11, 246, 24, 6, 219, 177, 6, 219, 177, 6, + 219, 177, 6, 219, 177, 6, 219, 177, 37, 188, 77, 37, 188, + 77, 37, 188, 77, 37, 188, 77, 37, 188, 77, 230, 138, 2, + 230, 138, 2, 230, 138, 2, 230, 138, 2, 230, 138, 2, 81, + 74, 159, 81, 74, 159, 81, 74, 159, 81, 74, 159, 81, 74, + 159, 27, 63, 240, 27, 63, 240, 27, 63, 240, 27, 63, 240, + 27, 63, 240, 0, 0, 0, 0, 0, 0, 11, 246, 24, 11, + 246, 24, 11, 246, 24, 11, 246, 24, 11, 246, 24, 6, 219, + 177, 6, 219, 177, 6, 219, 177, 6, 219, 177, 6, 219, 177, + 37, 188, 77, 37, 188, 77, 37, 188, 77, 37, 188, 77, 37, + 188, 77, 230, 138, 2, 230, 138, 2, 230, 138, 2, 230, 138, + 2, 230, 138, 2, 81, 74, 159, 81, 74, 159, 81, 74, 159, + 81, 74, 159, 81, 74, 159, 27, 63, 240, 27, 63, 240, 27, + 63, 240, 27, 63, 240, 27, 63, 240, 0, 0, 0, 0, 0, + 0, 11, 246, 24, 11, 246, 24, 11, 246, 24, 11, 246, 24, + 11, 246, 24, 6, 219, 177, 6, 219, 177, 6, 219, 177, 6, + 219, 177, 6, 219, 177, 37, 188, 77, 37, 188, 77, 37, 188, + 77, 37, 188, 77, 37, 188, 77, 230, 138, 2, 230, 138, 2, + 230, 138, 2, 230, 138, 2, 230, 138, 2, 81, 74, 159, 81, + 74, 159, 81, 74, 159, 81, 74, 159, 81, 74, 159, 27, 63, + 240, 27, 63, 240, 27, 63, 240, 27, 63, 240, 27, 63, 240, + 0, 0, 0, 0, 0, 0, 11, 246, 24, 11, 246, 24, 11, + 246, 24, 11, 246, 24, 11, 246, 24, 6, 219, 177, 6, 219, + 177, 6, 219, 177, 6, 219, 177, 6, 219, 177, 37, 188, 77, + 37, 188, 77, 37, 188, 77, 37, 188, 77, 37, 188, 77, 230, + 138, 2, 230, 138, 2, 230, 138, 2, 230, 138, 2, 230, 138, + 2, 81, 74, 159, 81, 74, 159, 81, 74, 159, 81, 74, 159, + 81, 74, 159, 27, 63, 240, 27, 63, 240, 27, 63, 240, 27, + 63, 240, 27, 63, 240, 0, 0, 0, 0, 0, 0, 80, 90, + 247, 80, 90, 247, 80, 90, 247, 80, 90, 247, 80, 90, 247, + 85, 118, 167, 85, 118, 167, 85, 118, 167, 85, 118, 167, 85, + 118, 167, 208, 39, 172, 208, 39, 172, 208, 39, 172, 208, 39, + 172, 208, 39, 172, 191, 106, 60, 191, 106, 60, 191, 106, 60, + 191, 106, 60, 191, 106, 60, 112, 163, 114, 112, 163, 114, 112, + 163, 114, 112, 163, 114, 112, 163, 114, 50, 201, 228, 50, 201, + 228, 50, 201, 228, 50, 201, 228, 50, 201, 228, 0, 0, 0, + 0, 0, 0, 80, 90, 247, 80, 90, 247, 80, 90, 247, 80, + 90, 247, 80, 90, 247, 85, 118, 167, 85, 118, 167, 85, 118, + 167, 85, 118, 167, 85, 118, 167, 208, 39, 172, 208, 39, 172, + 208, 39, 172, 208, 39, 172, 208, 39, 172, 191, 106, 60, 191, + 106, 60, 191, 106, 60, 191, 106, 60, 191, 106, 60, 112, 163, + 114, 112, 163, 114, 112, 163, 114, 112, 163, 114, 112, 163, 114, + 50, 201, 228, 50, 201, 228, 50, 201, 228, 50, 201, 228, 50, + 201, 228, 0, 0, 0, 0, 0, 0, 80, 90, 247, 80, 90, + 247, 80, 90, 247, 80, 90, 247, 80, 90, 247, 85, 118, 167, + 85, 118, 167, 85, 118, 167, 85, 118, 167, 85, 118, 167, 208, + 39, 172, 208, 39, 172, 208, 39, 172, 208, 39, 172, 208, 39, + 172, 191, 106, 60, 191, 106, 60, 191, 106, 60, 191, 106, 60, + 191, 106, 60, 112, 163, 114, 112, 163, 114, 112, 163, 114, 112, + 163, 114, 112, 163, 114, 50, 201, 228, 50, 201, 228, 50, 201, + 228, 50, 201, 228, 50, 201, 228, 0, 0, 0, 0, 0, 0, + 80, 90, 247, 80, 90, 247, 80, 90, 247, 80, 90, 247, 80, + 90, 247, 85, 118, 167, 85, 118, 167, 85, 118, 167, 85, 118, + 167, 85, 118, 167, 208, 39, 172, 208, 39, 172, 208, 39, 172, + 208, 39, 172, 208, 39, 172, 191, 106, 60, 191, 106, 60, 191, + 106, 60, 191, 106, 60, 191, 106, 60, 112, 163, 114, 112, 163, + 114, 112, 163, 114, 112, 163, 114, 112, 163, 114, 50, 201, 228, + 50, 201, 228, 50, 201, 228, 50, 201, 228, 50, 201, 228, 0, + 0, 0, 0, 0, 0, 80, 90, 247, 80, 90, 247, 80, 90, + 247, 80, 90, 247, 80, 90, 247, 85, 118, 167, 85, 118, 167, + 85, 118, 167, 85, 118, 167, 85, 118, 167, 208, 39, 172, 208, + 39, 172, 208, 39, 172, 208, 39, 172, 208, 39, 172, 191, 106, + 60, 191, 106, 60, 191, 106, 60, 191, 106, 60, 191, 106, 60, + 112, 163, 114, 112, 163, 114, 112, 163, 114, 112, 163, 114, 112, + 163, 114, 50, 201, 228, 50, 201, 228, 50, 201, 228, 50, 201, + 228, 50, 201, 228, 0, 0, 0, 0, 0, 0, 59, 118, 64, + 59, 118, 64, 59, 118, 64, 59, 118, 64, 59, 118, 64, 167, + 54, 157, 167, 54, 157, 167, 54, 157, 167, 54, 157, 167, 54, + 157, 122, 26, 142, 122, 26, 142, 122, 26, 142, 122, 26, 142, + 122, 26, 142, 88, 105, 236, 88, 105, 236, 88, 105, 236, 88, + 105, 236, 88, 105, 236, 91, 191, 184, 91, 191, 184, 91, 191, + 184, 91, 191, 184, 91, 191, 184, 95, 185, 76, 95, 185, 76, + 95, 185, 76, 95, 185, 76, 95, 185, 76, 0, 0, 0, 0, + 0, 0, 59, 118, 64, 59, 118, 64, 59, 118, 64, 59, 118, + 64, 59, 118, 64, 167, 54, 157, 167, 54, 157, 167, 54, 157, + 167, 54, 157, 167, 54, 157, 122, 26, 142, 122, 26, 142, 122, + 26, 142, 122, 26, 142, 122, 26, 142, 88, 105, 236, 88, 105, + 236, 88, 105, 236, 88, 105, 236, 88, 105, 236, 91, 191, 184, + 91, 191, 184, 91, 191, 184, 91, 191, 184, 91, 191, 184, 95, + 185, 76, 95, 185, 76, 95, 185, 76, 95, 185, 76, 95, 185, + 76, 0, 0, 0, 0, 0, 0, 59, 118, 64, 59, 118, 64, + 59, 118, 64, 59, 118, 64, 59, 118, 64, 167, 54, 157, 167, + 54, 157, 167, 54, 157, 167, 54, 157, 167, 54, 157, 122, 26, + 142, 122, 26, 142, 122, 26, 142, 122, 26, 142, 122, 26, 142, + 88, 105, 236, 88, 105, 236, 88, 105, 236, 88, 105, 236, 88, + 105, 236, 91, 191, 184, 91, 191, 184, 91, 191, 184, 91, 191, + 184, 91, 191, 184, 95, 185, 76, 95, 185, 76, 95, 185, 76, + 95, 185, 76, 95, 185, 76, 0, 0, 0, 0, 0, 0, 59, + 118, 64, 59, 118, 64, 59, 118, 64, 59, 118, 64, 59, 118, + 64, 167, 54, 157, 167, 54, 157, 167, 54, 157, 167, 54, 157, + 167, 54, 157, 122, 26, 142, 122, 26, 142, 122, 26, 142, 122, + 26, 142, 122, 26, 142, 88, 105, 236, 88, 105, 236, 88, 105, + 236, 88, 105, 236, 88, 105, 236, 91, 191, 184, 91, 191, 184, + 91, 191, 184, 91, 191, 184, 91, 191, 184, 95, 185, 76, 95, + 185, 76, 95, 185, 76, 95, 185, 76, 95, 185, 76, 0, 0, + 0, 0, 0, 0, 59, 118, 64, 59, 118, 64, 59, 118, 64, + 59, 118, 64, 59, 118, 64, 167, 54, 157, 167, 54, 157, 167, + 54, 157, 167, 54, 157, 167, 54, 157, 122, 26, 142, 122, 26, + 142, 122, 26, 142, 122, 26, 142, 122, 26, 142, 88, 105, 236, + 88, 105, 236, 88, 105, 236, 88, 105, 236, 88, 105, 236, 91, + 191, 184, 91, 191, 184, 91, 191, 184, 91, 191, 184, 91, 191, + 184, 95, 185, 76, 95, 185, 76, 95, 185, 76, 95, 185, 76, + 95, 185, 76, 0, 0, 0, 0, 0, 0, 54, 66, 34, 54, + 66, 34, 54, 66, 34, 54, 66, 34, 54, 66, 34, 158, 29, + 136, 158, 29, 136, 158, 29, 136, 158, 29, 136, 158, 29, 136, + 1, 152, 117, 1, 152, 117, 1, 152, 117, 1, 152, 117, 1, + 152, 117, 244, 208, 187, 244, 208, 187, 244, 208, 187, 244, 208, + 187, 244, 208, 187, 234, 108, 118, 234, 108, 118, 234, 108, 118, + 234, 108, 118, 234, 108, 118, 205, 113, 246, 205, 113, 246, 205, + 113, 246, 205, 113, 246, 205, 113, 246, 0, 0, 0, 0, 0, + 0, 54, 66, 34, 54, 66, 34, 54, 66, 34, 54, 66, 34, + 54, 66, 34, 158, 29, 136, 158, 29, 136, 158, 29, 136, 158, + 29, 136, 158, 29, 136, 1, 152, 117, 1, 152, 117, 1, 152, + 117, 1, 152, 117, 1, 152, 117, 244, 208, 187, 244, 208, 187, + 244, 208, 187, 244, 208, 187, 244, 208, 187, 234, 108, 118, 234, + 108, 118, 234, 108, 118, 234, 108, 118, 234, 108, 118, 205, 113, + 246, 205, 113, 246, 205, 113, 246, 205, 113, 246, 205, 113, 246, + 0, 0, 0, 0, 0, 0, 54, 66, 34, 54, 66, 34, 54, + 66, 34, 54, 66, 34, 54, 66, 34, 158, 29, 136, 158, 29, + 136, 158, 29, 136, 158, 29, 136, 158, 29, 136, 1, 152, 117, + 1, 152, 117, 1, 152, 117, 1, 152, 117, 1, 152, 117, 244, + 208, 187, 244, 208, 187, 244, 208, 187, 244, 208, 187, 244, 208, + 187, 234, 108, 118, 234, 108, 118, 234, 108, 118, 234, 108, 118, + 234, 108, 118, 205, 113, 246, 205, 113, 246, 205, 113, 246, 205, + 113, 246, 205, 113, 246, 0, 0, 0, 0, 0, 0, 54, 66, + 34, 54, 66, 34, 54, 66, 34, 54, 66, 34, 54, 66, 34, + 158, 29, 136, 158, 29, 136, 158, 29, 136, 158, 29, 136, 158, + 29, 136, 1, 152, 117, 1, 152, 117, 1, 152, 117, 1, 152, + 117, 1, 152, 117, 244, 208, 187, 244, 208, 187, 244, 208, 187, + 244, 208, 187, 244, 208, 187, 234, 108, 118, 234, 108, 118, 234, + 108, 118, 234, 108, 118, 234, 108, 118, 205, 113, 246, 205, 113, + 246, 205, 113, 246, 205, 113, 246, 205, 113, 246, 0, 0, 0, + 0, 0, 0, 54, 66, 34, 54, 66, 34, 54, 66, 34, 54, + 66, 34, 54, 66, 34, 158, 29, 136, 158, 29, 136, 158, 29, + 136, 158, 29, 136, 158, 29, 136, 1, 152, 117, 1, 152, 117, + 1, 152, 117, 1, 152, 117, 1, 152, 117, 244, 208, 187, 244, + 208, 187, 244, 208, 187, 244, 208, 187, 244, 208, 187, 234, 108, + 118, 234, 108, 118, 234, 108, 118, 234, 108, 118, 234, 108, 118, + 205, 113, 246, 205, 113, 246, 205, 113, 246, 205, 113, 246, 205, + 113, 246, 0, 0, 0, 0, 0, 0, 169, 47, 21, 169, 47, + 21, 169, 47, 21, 169, 47, 21, 169, 47, 21, 10, 45, 173, + 10, 45, 173, 10, 45, 173, 10, 45, 173, 10, 45, 173, 94, + 15, 254, 94, 15, 254, 94, 15, 254, 94, 15, 254, 94, 15, + 254, 81, 126, 52, 81, 126, 52, 81, 126, 52, 81, 126, 52, + 81, 126, 52, 101, 211, 145, 101, 211, 145, 101, 211, 145, 101, + 211, 145, 101, 211, 145, 145, 86, 109, 145, 86, 109, 145, 86, + 109, 145, 86, 109, 145, 86, 109, 0, 0, 0, 0, 0, 0, + 169, 47, 21, 169, 47, 21, 169, 47, 21, 169, 47, 21, 169, + 47, 21, 10, 45, 173, 10, 45, 173, 10, 45, 173, 10, 45, + 173, 10, 45, 173, 94, 15, 254, 94, 15, 254, 94, 15, 254, + 94, 15, 254, 94, 15, 254, 81, 126, 52, 81, 126, 52, 81, + 126, 52, 81, 126, 52, 81, 126, 52, 101, 211, 145, 101, 211, + 145, 101, 211, 145, 101, 211, 145, 101, 211, 145, 145, 86, 109, + 145, 86, 109, 145, 86, 109, 145, 86, 109, 145, 86, 109, 0, + 0, 0, 0, 0, 0, 169, 47, 21, 169, 47, 21, 169, 47, + 21, 169, 47, 21, 169, 47, 21, 10, 45, 173, 10, 45, 173, + 10, 45, 173, 10, 45, 173, 10, 45, 173, 94, 15, 254, 94, + 15, 254, 94, 15, 254, 94, 15, 254, 94, 15, 254, 81, 126, + 52, 81, 126, 52, 81, 126, 52, 81, 126, 52, 81, 126, 52, + 101, 211, 145, 101, 211, 145, 101, 211, 145, 101, 211, 145, 101, + 211, 145, 145, 86, 109, 145, 86, 109, 145, 86, 109, 145, 86, + 109, 145, 86, 109, 0, 0, 0, 0, 0, 0, 169, 47, 21, + 169, 47, 21, 169, 47, 21, 169, 47, 21, 169, 47, 21, 10, + 45, 173, 10, 45, 173, 10, 45, 173, 10, 45, 173, 10, 45, + 173, 94, 15, 254, 94, 15, 254, 94, 15, 254, 94, 15, 254, + 94, 15, 254, 81, 126, 52, 81, 126, 52, 81, 126, 52, 81, + 126, 52, 81, 126, 52, 101, 211, 145, 101, 211, 145, 101, 211, + 145, 101, 211, 145, 101, 211, 145, 145, 86, 109, 145, 86, 109, + 145, 86, 109, 145, 86, 109, 145, 86, 109, 0, 0, 0, 0, + 0, 0, 169, 47, 21, 169, 47, 21, 169, 47, 21, 169, 47, + 21, 169, 47, 21, 10, 45, 173, 10, 45, 173, 10, 45, 173, + 10, 45, 173, 10, 45, 173, 94, 15, 254, 94, 15, 254, 94, + 15, 254, 94, 15, 254, 94, 15, 254, 81, 126, 52, 81, 126, + 52, 81, 126, 52, 81, 126, 52, 81, 126, 52, 101, 211, 145, + 101, 211, 145, 101, 211, 145, 101, 211, 145, 101, 211, 145, 145, + 86, 109, 145, 86, 109, 145, 86, 109, 145, 86, 109, 145, 86, + 109, 0, 0, 0, 0, 0, 0, 251, 81, 226, 251, 81, 226, + 251, 81, 226, 251, 81, 226, 251, 81, 226, 45, 229, 237, 45, + 229, 237, 45, 229, 237, 45, 229, 237, 45, 229, 237, 29, 227, + 225, 29, 227, 225, 29, 227, 225, 29, 227, 225, 29, 227, 225, + 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, + 253, 253, 118, 8, 129, 118, 8, 129, 118, 8, 129, 118, 8, + 129, 118, 8, 129, 77, 164, 33, 77, 164, 33, 77, 164, 33, + 77, 164, 33, 77, 164, 33, 0, 0, 0, 0, 0, 0, 251, + 81, 226, 251, 81, 226, 251, 81, 226, 251, 81, 226, 251, 81, + 226, 45, 229, 237, 45, 229, 237, 45, 229, 237, 45, 229, 237, + 45, 229, 237, 29, 227, 225, 29, 227, 225, 29, 227, 225, 29, + 227, 225, 29, 227, 225, 80, 253, 253, 80, 253, 253, 80, 253, + 253, 80, 253, 253, 80, 253, 253, 118, 8, 129, 118, 8, 129, + 118, 8, 129, 118, 8, 129, 118, 8, 129, 77, 164, 33, 77, + 164, 33, 77, 164, 33, 77, 164, 33, 77, 164, 33, 0, 0, + 0, 0, 0, 0, 251, 81, 226, 251, 81, 226, 251, 81, 226, + 251, 81, 226, 251, 81, 226, 45, 229, 237, 45, 229, 237, 45, + 229, 237, 45, 229, 237, 45, 229, 237, 29, 227, 225, 29, 227, + 225, 29, 227, 225, 29, 227, 225, 29, 227, 225, 80, 253, 253, + 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, 253, 118, + 8, 129, 118, 8, 129, 118, 8, 129, 118, 8, 129, 118, 8, + 129, 77, 164, 33, 77, 164, 33, 77, 164, 33, 77, 164, 33, + 77, 164, 33, 0, 0, 0, 0, 0, 0, 251, 81, 226, 251, + 81, 226, 251, 81, 226, 251, 81, 226, 251, 81, 226, 45, 229, + 237, 45, 229, 237, 45, 229, 237, 45, 229, 237, 45, 229, 237, + 29, 227, 225, 29, 227, 225, 29, 227, 225, 29, 227, 225, 29, + 227, 225, 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, + 253, 80, 253, 253, 118, 8, 129, 118, 8, 129, 118, 8, 129, + 118, 8, 129, 118, 8, 129, 77, 164, 33, 77, 164, 33, 77, + 164, 33, 77, 164, 33, 77, 164, 33, 0, 0, 0, 0, 0, + 0, 251, 81, 226, 251, 81, 226, 251, 81, 226, 251, 81, 226, + 251, 81, 226, 45, 229, 237, 45, 229, 237, 45, 229, 237, 45, + 229, 237, 45, 229, 237, 29, 227, 225, 29, 227, 225, 29, 227, + 225, 29, 227, 225, 29, 227, 225, 80, 253, 253, 80, 253, 253, + 80, 253, 253, 80, 253, 253, 80, 253, 253, 118, 8, 129, 118, + 8, 129, 118, 8, 129, 118, 8, 129, 118, 8, 129, 77, 164, + 33, 77, 164, 33, 77, 164, 33, 77, 164, 33, 77, 164, 33, + 0, 0, 0, 0, 0, 0], dtype=np.uint8), + image_decoder_decode_jpeg2k_rgb.output, +) + +image_decoder_decode_png_rgb = ImageData( + np.array([137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, + 72, 68, 82, 0, 0, 0, 32, 0, 0, 0, 32, 8, 2, + 0, 0, 0, 252, 24, 237, 163, 0, 0, 0, 255, 73, 68, + 65, 84, 120, 156, 99, 124, 20, 248, 155, 1, 9, 112, 79, + 49, 66, 230, 126, 249, 247, 1, 153, 43, 35, 101, 140, 204, + 109, 225, 86, 67, 230, 46, 152, 115, 29, 153, 123, 63, 102, + 51, 3, 3, 3, 19, 3, 141, 193, 168, 5, 4, 1, 139, + 241, 189, 117, 200, 252, 25, 30, 119, 145, 185, 129, 143, 66, + 144, 185, 102, 249, 159, 145, 185, 177, 167, 223, 35, 115, 125, + 154, 93, 144, 185, 147, 25, 70, 35, 121, 112, 88, 192, 168, + 228, 100, 134, 204, 79, 187, 157, 129, 204, 125, 91, 157, 140, + 204, 117, 179, 64, 137, 228, 221, 115, 190, 33, 115, 27, 88, + 31, 35, 115, 185, 250, 141, 25, 134, 67, 16, 13, 125, 11, + 88, 228, 76, 88, 145, 249, 162, 95, 56, 145, 185, 108, 77, + 149, 200, 92, 67, 255, 20, 100, 238, 223, 48, 102, 100, 110, + 216, 47, 22, 20, 179, 251, 25, 24, 134, 67, 16, 13, 125, + 11, 88, 182, 63, 17, 69, 230, 111, 112, 64, 41, 189, 249, + 55, 86, 35, 115, 3, 24, 81, 202, 103, 179, 39, 27, 145, + 185, 51, 212, 14, 33, 115, 101, 24, 24, 24, 134, 67, 16, + 13, 125, 11, 88, 20, 231, 236, 70, 230, 207, 124, 138, 210, + 14, 155, 227, 118, 1, 153, 123, 236, 220, 65, 100, 110, 242, + 242, 135, 200, 92, 158, 175, 47, 49, 45, 24, 250, 65, 52, + 244, 45, 24, 250, 0, 0, 70, 253, 59, 210, 74, 38, 46, + 197, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130], + dtype=np.uint8), + image_decoder_decode_bmp_rgb.output, +) + +image_decoder_decode_tiff_rgb = ImageData( + np.array([ 73, 73, 42, 0, 8, 0, 0, 0, 10, 0, 0, 1, 4, + 0, 1, 0, 0, 0, 32, 0, 0, 0, 1, 1, 4, 0, + 1, 0, 0, 0, 32, 0, 0, 0, 2, 1, 3, 0, 3, + 0, 0, 0, 134, 0, 0, 0, 3, 1, 3, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, + 0, 2, 0, 0, 0, 17, 1, 4, 0, 1, 0, 0, 0, + 140, 0, 0, 0, 21, 1, 3, 0, 1, 0, 0, 0, 3, + 0, 0, 0, 22, 1, 4, 0, 1, 0, 0, 0, 32, 0, + 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 0, 12, 0, + 0, 28, 1, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 8, 0, 8, 0, 226, 81, 251, + 226, 81, 251, 226, 81, 251, 226, 81, 251, 226, 81, 251, 237, + 229, 45, 237, 229, 45, 237, 229, 45, 237, 229, 45, 237, 229, + 45, 225, 227, 29, 225, 227, 29, 225, 227, 29, 225, 227, 29, + 225, 227, 29, 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, + 253, 80, 253, 253, 80, 129, 8, 118, 129, 8, 118, 129, 8, + 118, 129, 8, 118, 129, 8, 118, 33, 164, 77, 33, 164, 77, + 33, 164, 77, 33, 164, 77, 33, 164, 77, 0, 0, 0, 0, + 0, 0, 226, 81, 251, 226, 81, 251, 226, 81, 251, 226, 81, + 251, 226, 81, 251, 237, 229, 45, 237, 229, 45, 237, 229, 45, + 237, 229, 45, 237, 229, 45, 225, 227, 29, 225, 227, 29, 225, + 227, 29, 225, 227, 29, 225, 227, 29, 253, 253, 80, 253, 253, + 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 129, 8, 118, + 129, 8, 118, 129, 8, 118, 129, 8, 118, 129, 8, 118, 33, + 164, 77, 33, 164, 77, 33, 164, 77, 33, 164, 77, 33, 164, + 77, 0, 0, 0, 0, 0, 0, 226, 81, 251, 226, 81, 251, + 226, 81, 251, 226, 81, 251, 226, 81, 251, 237, 229, 45, 237, + 229, 45, 237, 229, 45, 237, 229, 45, 237, 229, 45, 225, 227, + 29, 225, 227, 29, 225, 227, 29, 225, 227, 29, 225, 227, 29, + 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, + 253, 80, 129, 8, 118, 129, 8, 118, 129, 8, 118, 129, 8, + 118, 129, 8, 118, 33, 164, 77, 33, 164, 77, 33, 164, 77, + 33, 164, 77, 33, 164, 77, 0, 0, 0, 0, 0, 0, 226, + 81, 251, 226, 81, 251, 226, 81, 251, 226, 81, 251, 226, 81, + 251, 237, 229, 45, 237, 229, 45, 237, 229, 45, 237, 229, 45, + 237, 229, 45, 225, 227, 29, 225, 227, 29, 225, 227, 29, 225, + 227, 29, 225, 227, 29, 253, 253, 80, 253, 253, 80, 253, 253, + 80, 253, 253, 80, 253, 253, 80, 129, 8, 118, 129, 8, 118, + 129, 8, 118, 129, 8, 118, 129, 8, 118, 33, 164, 77, 33, + 164, 77, 33, 164, 77, 33, 164, 77, 33, 164, 77, 0, 0, + 0, 0, 0, 0, 226, 81, 251, 226, 81, 251, 226, 81, 251, + 226, 81, 251, 226, 81, 251, 237, 229, 45, 237, 229, 45, 237, + 229, 45, 237, 229, 45, 237, 229, 45, 225, 227, 29, 225, 227, + 29, 225, 227, 29, 225, 227, 29, 225, 227, 29, 253, 253, 80, + 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 129, + 8, 118, 129, 8, 118, 129, 8, 118, 129, 8, 118, 129, 8, + 118, 33, 164, 77, 33, 164, 77, 33, 164, 77, 33, 164, 77, + 33, 164, 77, 0, 0, 0, 0, 0, 0, 21, 47, 169, 21, + 47, 169, 21, 47, 169, 21, 47, 169, 21, 47, 169, 173, 45, + 10, 173, 45, 10, 173, 45, 10, 173, 45, 10, 173, 45, 10, + 254, 15, 94, 254, 15, 94, 254, 15, 94, 254, 15, 94, 254, + 15, 94, 52, 126, 81, 52, 126, 81, 52, 126, 81, 52, 126, + 81, 52, 126, 81, 145, 211, 101, 145, 211, 101, 145, 211, 101, + 145, 211, 101, 145, 211, 101, 109, 86, 145, 109, 86, 145, 109, + 86, 145, 109, 86, 145, 109, 86, 145, 0, 0, 0, 0, 0, + 0, 21, 47, 169, 21, 47, 169, 21, 47, 169, 21, 47, 169, + 21, 47, 169, 173, 45, 10, 173, 45, 10, 173, 45, 10, 173, + 45, 10, 173, 45, 10, 254, 15, 94, 254, 15, 94, 254, 15, + 94, 254, 15, 94, 254, 15, 94, 52, 126, 81, 52, 126, 81, + 52, 126, 81, 52, 126, 81, 52, 126, 81, 145, 211, 101, 145, + 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, 109, 86, + 145, 109, 86, 145, 109, 86, 145, 109, 86, 145, 109, 86, 145, + 0, 0, 0, 0, 0, 0, 21, 47, 169, 21, 47, 169, 21, + 47, 169, 21, 47, 169, 21, 47, 169, 173, 45, 10, 173, 45, + 10, 173, 45, 10, 173, 45, 10, 173, 45, 10, 254, 15, 94, + 254, 15, 94, 254, 15, 94, 254, 15, 94, 254, 15, 94, 52, + 126, 81, 52, 126, 81, 52, 126, 81, 52, 126, 81, 52, 126, + 81, 145, 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, + 145, 211, 101, 109, 86, 145, 109, 86, 145, 109, 86, 145, 109, + 86, 145, 109, 86, 145, 0, 0, 0, 0, 0, 0, 21, 47, + 169, 21, 47, 169, 21, 47, 169, 21, 47, 169, 21, 47, 169, + 173, 45, 10, 173, 45, 10, 173, 45, 10, 173, 45, 10, 173, + 45, 10, 254, 15, 94, 254, 15, 94, 254, 15, 94, 254, 15, + 94, 254, 15, 94, 52, 126, 81, 52, 126, 81, 52, 126, 81, + 52, 126, 81, 52, 126, 81, 145, 211, 101, 145, 211, 101, 145, + 211, 101, 145, 211, 101, 145, 211, 101, 109, 86, 145, 109, 86, + 145, 109, 86, 145, 109, 86, 145, 109, 86, 145, 0, 0, 0, + 0, 0, 0, 21, 47, 169, 21, 47, 169, 21, 47, 169, 21, + 47, 169, 21, 47, 169, 173, 45, 10, 173, 45, 10, 173, 45, + 10, 173, 45, 10, 173, 45, 10, 254, 15, 94, 254, 15, 94, + 254, 15, 94, 254, 15, 94, 254, 15, 94, 52, 126, 81, 52, + 126, 81, 52, 126, 81, 52, 126, 81, 52, 126, 81, 145, 211, + 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, + 109, 86, 145, 109, 86, 145, 109, 86, 145, 109, 86, 145, 109, + 86, 145, 0, 0, 0, 0, 0, 0, 34, 66, 54, 34, 66, + 54, 34, 66, 54, 34, 66, 54, 34, 66, 54, 136, 29, 158, + 136, 29, 158, 136, 29, 158, 136, 29, 158, 136, 29, 158, 117, + 152, 1, 117, 152, 1, 117, 152, 1, 117, 152, 1, 117, 152, + 1, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, + 187, 208, 244, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, + 108, 234, 118, 108, 234, 246, 113, 205, 246, 113, 205, 246, 113, + 205, 246, 113, 205, 246, 113, 205, 0, 0, 0, 0, 0, 0, + 34, 66, 54, 34, 66, 54, 34, 66, 54, 34, 66, 54, 34, + 66, 54, 136, 29, 158, 136, 29, 158, 136, 29, 158, 136, 29, + 158, 136, 29, 158, 117, 152, 1, 117, 152, 1, 117, 152, 1, + 117, 152, 1, 117, 152, 1, 187, 208, 244, 187, 208, 244, 187, + 208, 244, 187, 208, 244, 187, 208, 244, 118, 108, 234, 118, 108, + 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 246, 113, 205, + 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, 205, 0, + 0, 0, 0, 0, 0, 34, 66, 54, 34, 66, 54, 34, 66, + 54, 34, 66, 54, 34, 66, 54, 136, 29, 158, 136, 29, 158, + 136, 29, 158, 136, 29, 158, 136, 29, 158, 117, 152, 1, 117, + 152, 1, 117, 152, 1, 117, 152, 1, 117, 152, 1, 187, 208, + 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, + 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, + 108, 234, 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, + 205, 246, 113, 205, 0, 0, 0, 0, 0, 0, 34, 66, 54, + 34, 66, 54, 34, 66, 54, 34, 66, 54, 34, 66, 54, 136, + 29, 158, 136, 29, 158, 136, 29, 158, 136, 29, 158, 136, 29, + 158, 117, 152, 1, 117, 152, 1, 117, 152, 1, 117, 152, 1, + 117, 152, 1, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, + 208, 244, 187, 208, 244, 118, 108, 234, 118, 108, 234, 118, 108, + 234, 118, 108, 234, 118, 108, 234, 246, 113, 205, 246, 113, 205, + 246, 113, 205, 246, 113, 205, 246, 113, 205, 0, 0, 0, 0, + 0, 0, 34, 66, 54, 34, 66, 54, 34, 66, 54, 34, 66, + 54, 34, 66, 54, 136, 29, 158, 136, 29, 158, 136, 29, 158, + 136, 29, 158, 136, 29, 158, 117, 152, 1, 117, 152, 1, 117, + 152, 1, 117, 152, 1, 117, 152, 1, 187, 208, 244, 187, 208, + 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, 118, 108, 234, + 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 246, + 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, + 205, 0, 0, 0, 0, 0, 0, 64, 118, 59, 64, 118, 59, + 64, 118, 59, 64, 118, 59, 64, 118, 59, 157, 54, 167, 157, + 54, 167, 157, 54, 167, 157, 54, 167, 157, 54, 167, 142, 26, + 122, 142, 26, 122, 142, 26, 122, 142, 26, 122, 142, 26, 122, + 236, 105, 88, 236, 105, 88, 236, 105, 88, 236, 105, 88, 236, + 105, 88, 184, 191, 91, 184, 191, 91, 184, 191, 91, 184, 191, + 91, 184, 191, 91, 76, 185, 95, 76, 185, 95, 76, 185, 95, + 76, 185, 95, 76, 185, 95, 0, 0, 0, 0, 0, 0, 64, + 118, 59, 64, 118, 59, 64, 118, 59, 64, 118, 59, 64, 118, + 59, 157, 54, 167, 157, 54, 167, 157, 54, 167, 157, 54, 167, + 157, 54, 167, 142, 26, 122, 142, 26, 122, 142, 26, 122, 142, + 26, 122, 142, 26, 122, 236, 105, 88, 236, 105, 88, 236, 105, + 88, 236, 105, 88, 236, 105, 88, 184, 191, 91, 184, 191, 91, + 184, 191, 91, 184, 191, 91, 184, 191, 91, 76, 185, 95, 76, + 185, 95, 76, 185, 95, 76, 185, 95, 76, 185, 95, 0, 0, + 0, 0, 0, 0, 64, 118, 59, 64, 118, 59, 64, 118, 59, + 64, 118, 59, 64, 118, 59, 157, 54, 167, 157, 54, 167, 157, + 54, 167, 157, 54, 167, 157, 54, 167, 142, 26, 122, 142, 26, + 122, 142, 26, 122, 142, 26, 122, 142, 26, 122, 236, 105, 88, + 236, 105, 88, 236, 105, 88, 236, 105, 88, 236, 105, 88, 184, + 191, 91, 184, 191, 91, 184, 191, 91, 184, 191, 91, 184, 191, + 91, 76, 185, 95, 76, 185, 95, 76, 185, 95, 76, 185, 95, + 76, 185, 95, 0, 0, 0, 0, 0, 0, 64, 118, 59, 64, + 118, 59, 64, 118, 59, 64, 118, 59, 64, 118, 59, 157, 54, + 167, 157, 54, 167, 157, 54, 167, 157, 54, 167, 157, 54, 167, + 142, 26, 122, 142, 26, 122, 142, 26, 122, 142, 26, 122, 142, + 26, 122, 236, 105, 88, 236, 105, 88, 236, 105, 88, 236, 105, + 88, 236, 105, 88, 184, 191, 91, 184, 191, 91, 184, 191, 91, + 184, 191, 91, 184, 191, 91, 76, 185, 95, 76, 185, 95, 76, + 185, 95, 76, 185, 95, 76, 185, 95, 0, 0, 0, 0, 0, + 0, 64, 118, 59, 64, 118, 59, 64, 118, 59, 64, 118, 59, + 64, 118, 59, 157, 54, 167, 157, 54, 167, 157, 54, 167, 157, + 54, 167, 157, 54, 167, 142, 26, 122, 142, 26, 122, 142, 26, + 122, 142, 26, 122, 142, 26, 122, 236, 105, 88, 236, 105, 88, + 236, 105, 88, 236, 105, 88, 236, 105, 88, 184, 191, 91, 184, + 191, 91, 184, 191, 91, 184, 191, 91, 184, 191, 91, 76, 185, + 95, 76, 185, 95, 76, 185, 95, 76, 185, 95, 76, 185, 95, + 0, 0, 0, 0, 0, 0, 247, 90, 80, 247, 90, 80, 247, + 90, 80, 247, 90, 80, 247, 90, 80, 167, 118, 85, 167, 118, + 85, 167, 118, 85, 167, 118, 85, 167, 118, 85, 172, 39, 208, + 172, 39, 208, 172, 39, 208, 172, 39, 208, 172, 39, 208, 60, + 106, 191, 60, 106, 191, 60, 106, 191, 60, 106, 191, 60, 106, + 191, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, + 114, 163, 112, 228, 201, 50, 228, 201, 50, 228, 201, 50, 228, + 201, 50, 228, 201, 50, 0, 0, 0, 0, 0, 0, 247, 90, + 80, 247, 90, 80, 247, 90, 80, 247, 90, 80, 247, 90, 80, + 167, 118, 85, 167, 118, 85, 167, 118, 85, 167, 118, 85, 167, + 118, 85, 172, 39, 208, 172, 39, 208, 172, 39, 208, 172, 39, + 208, 172, 39, 208, 60, 106, 191, 60, 106, 191, 60, 106, 191, + 60, 106, 191, 60, 106, 191, 114, 163, 112, 114, 163, 112, 114, + 163, 112, 114, 163, 112, 114, 163, 112, 228, 201, 50, 228, 201, + 50, 228, 201, 50, 228, 201, 50, 228, 201, 50, 0, 0, 0, + 0, 0, 0, 247, 90, 80, 247, 90, 80, 247, 90, 80, 247, + 90, 80, 247, 90, 80, 167, 118, 85, 167, 118, 85, 167, 118, + 85, 167, 118, 85, 167, 118, 85, 172, 39, 208, 172, 39, 208, + 172, 39, 208, 172, 39, 208, 172, 39, 208, 60, 106, 191, 60, + 106, 191, 60, 106, 191, 60, 106, 191, 60, 106, 191, 114, 163, + 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, + 228, 201, 50, 228, 201, 50, 228, 201, 50, 228, 201, 50, 228, + 201, 50, 0, 0, 0, 0, 0, 0, 247, 90, 80, 247, 90, + 80, 247, 90, 80, 247, 90, 80, 247, 90, 80, 167, 118, 85, + 167, 118, 85, 167, 118, 85, 167, 118, 85, 167, 118, 85, 172, + 39, 208, 172, 39, 208, 172, 39, 208, 172, 39, 208, 172, 39, + 208, 60, 106, 191, 60, 106, 191, 60, 106, 191, 60, 106, 191, + 60, 106, 191, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, + 163, 112, 114, 163, 112, 228, 201, 50, 228, 201, 50, 228, 201, + 50, 228, 201, 50, 228, 201, 50, 0, 0, 0, 0, 0, 0, + 247, 90, 80, 247, 90, 80, 247, 90, 80, 247, 90, 80, 247, + 90, 80, 167, 118, 85, 167, 118, 85, 167, 118, 85, 167, 118, + 85, 167, 118, 85, 172, 39, 208, 172, 39, 208, 172, 39, 208, + 172, 39, 208, 172, 39, 208, 60, 106, 191, 60, 106, 191, 60, + 106, 191, 60, 106, 191, 60, 106, 191, 114, 163, 112, 114, 163, + 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, 228, 201, 50, + 228, 201, 50, 228, 201, 50, 228, 201, 50, 228, 201, 50, 0, + 0, 0, 0, 0, 0, 24, 246, 11, 24, 246, 11, 24, 246, + 11, 24, 246, 11, 24, 246, 11, 177, 219, 6, 177, 219, 6, + 177, 219, 6, 177, 219, 6, 177, 219, 6, 77, 188, 37, 77, + 188, 37, 77, 188, 37, 77, 188, 37, 77, 188, 37, 2, 138, + 230, 2, 138, 230, 2, 138, 230, 2, 138, 230, 2, 138, 230, + 159, 74, 81, 159, 74, 81, 159, 74, 81, 159, 74, 81, 159, + 74, 81, 240, 63, 27, 240, 63, 27, 240, 63, 27, 240, 63, + 27, 240, 63, 27, 0, 0, 0, 0, 0, 0, 24, 246, 11, + 24, 246, 11, 24, 246, 11, 24, 246, 11, 24, 246, 11, 177, + 219, 6, 177, 219, 6, 177, 219, 6, 177, 219, 6, 177, 219, + 6, 77, 188, 37, 77, 188, 37, 77, 188, 37, 77, 188, 37, + 77, 188, 37, 2, 138, 230, 2, 138, 230, 2, 138, 230, 2, + 138, 230, 2, 138, 230, 159, 74, 81, 159, 74, 81, 159, 74, + 81, 159, 74, 81, 159, 74, 81, 240, 63, 27, 240, 63, 27, + 240, 63, 27, 240, 63, 27, 240, 63, 27, 0, 0, 0, 0, + 0, 0, 24, 246, 11, 24, 246, 11, 24, 246, 11, 24, 246, + 11, 24, 246, 11, 177, 219, 6, 177, 219, 6, 177, 219, 6, + 177, 219, 6, 177, 219, 6, 77, 188, 37, 77, 188, 37, 77, + 188, 37, 77, 188, 37, 77, 188, 37, 2, 138, 230, 2, 138, + 230, 2, 138, 230, 2, 138, 230, 2, 138, 230, 159, 74, 81, + 159, 74, 81, 159, 74, 81, 159, 74, 81, 159, 74, 81, 240, + 63, 27, 240, 63, 27, 240, 63, 27, 240, 63, 27, 240, 63, + 27, 0, 0, 0, 0, 0, 0, 24, 246, 11, 24, 246, 11, + 24, 246, 11, 24, 246, 11, 24, 246, 11, 177, 219, 6, 177, + 219, 6, 177, 219, 6, 177, 219, 6, 177, 219, 6, 77, 188, + 37, 77, 188, 37, 77, 188, 37, 77, 188, 37, 77, 188, 37, + 2, 138, 230, 2, 138, 230, 2, 138, 230, 2, 138, 230, 2, + 138, 230, 159, 74, 81, 159, 74, 81, 159, 74, 81, 159, 74, + 81, 159, 74, 81, 240, 63, 27, 240, 63, 27, 240, 63, 27, + 240, 63, 27, 240, 63, 27, 0, 0, 0, 0, 0, 0, 24, + 246, 11, 24, 246, 11, 24, 246, 11, 24, 246, 11, 24, 246, + 11, 177, 219, 6, 177, 219, 6, 177, 219, 6, 177, 219, 6, + 177, 219, 6, 77, 188, 37, 77, 188, 37, 77, 188, 37, 77, + 188, 37, 77, 188, 37, 2, 138, 230, 2, 138, 230, 2, 138, + 230, 2, 138, 230, 2, 138, 230, 159, 74, 81, 159, 74, 81, + 159, 74, 81, 159, 74, 81, 159, 74, 81, 240, 63, 27, 240, + 63, 27, 240, 63, 27, 240, 63, 27, 240, 63, 27, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0], dtype=np.uint8), + image_decoder_decode_bmp_rgb.output, +) + +image_decoder_decode_webp_rgb = ImageData( + np.array([ 82, 73, 70, 70, 32, 2, 0, 0, 87, 69, 66, 80, 86, + 80, 56, 32, 20, 2, 0, 0, 80, 13, 0, 157, 1, 42, + 32, 0, 32, 0, 62, 109, 46, 146, 70, 164, 34, 161, 161, + 40, 13, 80, 128, 13, 137, 108, 0, 157, 50, 132, 112, 55, + 151, 254, 57, 126, 51, 115, 134, 108, 25, 128, 93, 115, 126, + 83, 204, 7, 168, 15, 178, 191, 82, 95, 48, 15, 232, 29, + 32, 63, 93, 191, 183, 117, 128, 253, 57, 246, 0, 255, 147, + 230, 171, 236, 1, 232, 1, 230, 153, 254, 107, 245, 239, 225, + 11, 246, 51, 246, 239, 218, 118, 236, 247, 43, 147, 15, 163, + 180, 0, 165, 21, 251, 68, 81, 89, 121, 30, 65, 221, 213, + 115, 111, 216, 229, 96, 0, 253, 210, 122, 138, 75, 92, 219, + 102, 22, 86, 171, 131, 154, 9, 97, 230, 179, 178, 43, 43, + 206, 57, 143, 19, 232, 129, 21, 139, 23, 214, 170, 75, 14, + 52, 78, 111, 88, 54, 0, 216, 240, 73, 98, 154, 194, 36, + 47, 34, 68, 148, 194, 197, 79, 81, 220, 205, 223, 88, 250, + 42, 71, 218, 15, 124, 129, 12, 38, 200, 116, 251, 93, 147, + 57, 36, 183, 245, 31, 100, 160, 116, 212, 180, 65, 118, 26, + 4, 133, 242, 198, 50, 89, 34, 109, 244, 199, 253, 50, 134, + 185, 19, 231, 104, 63, 202, 255, 252, 169, 61, 255, 112, 75, + 33, 165, 235, 249, 208, 254, 59, 253, 66, 115, 104, 1, 198, + 21, 242, 126, 158, 181, 152, 55, 50, 77, 29, 83, 7, 74, + 139, 7, 157, 145, 131, 163, 5, 105, 181, 174, 38, 245, 83, + 73, 183, 195, 243, 162, 207, 173, 142, 14, 38, 114, 149, 107, + 162, 8, 74, 172, 85, 135, 196, 54, 62, 66, 159, 28, 239, + 150, 13, 1, 197, 236, 121, 183, 69, 189, 23, 138, 22, 15, + 245, 216, 244, 67, 220, 105, 77, 80, 101, 145, 47, 254, 82, + 86, 190, 233, 60, 253, 192, 109, 30, 199, 255, 255, 11, 191, + 132, 172, 157, 189, 172, 98, 91, 223, 41, 168, 79, 177, 124, + 248, 219, 66, 28, 89, 184, 193, 218, 73, 123, 199, 170, 197, + 85, 60, 244, 144, 65, 180, 53, 51, 76, 101, 246, 98, 255, + 202, 147, 239, 114, 41, 19, 231, 202, 205, 1, 24, 55, 73, + 164, 212, 62, 253, 138, 147, 181, 58, 249, 167, 19, 186, 248, + 198, 120, 78, 227, 215, 3, 206, 125, 176, 241, 255, 249, 143, + 31, 16, 189, 165, 240, 216, 14, 60, 28, 102, 246, 10, 178, + 9, 29, 179, 207, 170, 34, 51, 136, 167, 194, 160, 17, 118, + 203, 188, 35, 229, 124, 128, 245, 253, 232, 250, 94, 77, 150, + 161, 46, 3, 185, 215, 69, 122, 167, 159, 211, 209, 119, 111, + 211, 153, 178, 160, 153, 174, 180, 229, 61, 15, 196, 225, 48, + 93, 243, 101, 64, 200, 23, 47, 211, 242, 50, 31, 133, 231, + 63, 151, 123, 87, 178, 77, 165, 172, 205, 35, 249, 186, 231, + 150, 205, 218, 230, 245, 10, 39, 42, 157, 116, 223, 241, 120, + 201, 34, 28, 59, 113, 38, 151, 73, 39, 119, 255, 227, 105, + 45, 148, 84, 0, 0, 0], dtype=np.uint8), + np.array([[[230, 84, 242], + [230, 84, 240], + [232, 84, 238], + [225, 94, 202], + [207, 108, 126], + [255, 199, 131], + [243, 221, 74], + [229, 229, 47], + [232, 234, 65], + [228, 231, 61], + [228, 226, 43], + [228, 223, 31], + [232, 225, 31], + [227, 221, 34], + [224, 219, 43], + [255, 250, 82], + [255, 247, 84], + [255, 248, 82], + [254, 253, 76], + [255, 236, 130], + [121, 22, 71], + [132, 5, 128], + [126, 10, 122], + [105, 23, 107], + [ 70, 43, 86], + [ 90, 125, 122], + [ 49, 154, 98], + [ 27, 166, 83], + [ 29, 168, 80], + [ 48, 155, 87], + [ 0, 13, 0], + [ 0, 0, 0]], + + [[229, 84, 244], + [229, 84, 242], + [229, 85, 240], + [222, 95, 204], + [205, 108, 130], + [255, 198, 137], + [244, 219, 80], + [232, 227, 49], + [235, 233, 61], + [232, 230, 55], + [228, 227, 39], + [227, 224, 29], + [230, 226, 31], + [225, 222, 32], + [223, 220, 41], + [255, 251, 80], + [255, 249, 82], + [255, 250, 80], + [252, 254, 76], + [255, 237, 130], + [118, 23, 71], + [130, 6, 126], + [126, 10, 122], + [107, 22, 109], + [ 70, 43, 84], + [ 90, 125, 120], + [ 51, 153, 98], + [ 31, 165, 83], + [ 32, 167, 80], + [ 50, 154, 87], + [ 0, 13, 0], + [ 0, 0, 0]], + + [[224, 86, 246], + [224, 86, 246], + [222, 87, 244], + [217, 96, 210], + [202, 108, 138], + [255, 196, 147], + [249, 215, 90], + [239, 223, 55], + [240, 233, 53], + [235, 231, 43], + [230, 228, 33], + [227, 224, 27], + [227, 227, 31], + [224, 223, 32], + [221, 221, 37], + [252, 254, 76], + [252, 254, 76], + [250, 254, 76], + [247, 255, 76], + [255, 238, 132], + [115, 25, 69], + [129, 7, 126], + [126, 9, 126], + [107, 21, 112], + [ 70, 43, 82], + [ 92, 125, 116], + [ 56, 152, 94], + [ 35, 163, 81], + [ 37, 164, 80], + [ 55, 151, 89], + [ 0, 11, 0], + [ 0, 0, 2]], + + [[208, 93, 250], + [208, 93, 250], + [208, 93, 250], + [205, 101, 218], + [194, 111, 148], + [255, 195, 157], + [255, 209, 104], + [250, 215, 67], + [255, 222, 63], + [252, 220, 53], + [249, 215, 49], + [246, 211, 47], + [245, 214, 54], + [237, 212, 56], + [231, 212, 59], + [255, 249, 94], + [244, 254, 94], + [239, 255, 94], + [239, 255, 96], + [252, 241, 142], + [103, 33, 59], + [116, 17, 107], + [116, 17, 107], + [100, 27, 97], + [ 69, 46, 74], + [ 95, 124, 112], + [ 64, 147, 98], + [ 47, 156, 87], + [ 48, 157, 88], + [ 63, 146, 95], + [ 0, 9, 0], + [ 0, 0, 2]], + + [[183, 109, 255], + [183, 109, 255], + [185, 108, 255], + [186, 113, 229], + [189, 120, 166], + [255, 195, 174], + [255, 217, 133], + [255, 208, 93], + [255, 202, 86], + [255, 195, 84], + [255, 183, 86], + [255, 176, 88], + [255, 180, 98], + [255, 183, 101], + [255, 202, 115], + [255, 230, 132], + [235, 247, 134], + [223, 254, 132], + [224, 253, 130], + [235, 242, 158], + [ 84, 46, 41], + [ 95, 35, 69], + [ 97, 34, 69], + [ 86, 41, 65], + [ 70, 57, 64], + [102, 125, 112], + [ 77, 135, 104], + [ 69, 143, 104], + [ 72, 147, 108], + [ 77, 134, 108], + [ 0, 11, 3], + [ 0, 0, 2]], + + [[ 55, 31, 165], + [ 57, 30, 167], + [ 62, 27, 171], + [ 70, 28, 142], + [ 78, 26, 78], + [123, 60, 52], + [140, 64, 1], + [155, 66, 0], + [155, 55, 0], + [174, 52, 0], + [199, 48, 10], + [208, 48, 25], + [204, 54, 38], + [183, 56, 38], + [164, 79, 44], + [146, 109, 58], + [ 93, 112, 37], + [ 75, 121, 35], + [ 77, 121, 33], + [ 85, 115, 43], + [184, 183, 147], + [194, 177, 155], + [195, 176, 153], + [190, 178, 157], + [176, 176, 163], + [ 92, 107, 97], + [ 83, 114, 106], + [ 77, 116, 110], + [ 75, 115, 111], + [ 81, 110, 109], + [ 0, 1, 4], + [ 0, 0, 1]], + + [[ 20, 51, 168], + [ 23, 48, 172], + [ 31, 43, 176], + [ 47, 40, 150], + [ 78, 46, 100], + [121, 61, 63], + [142, 53, 8], + [165, 60, 0], + [163, 46, 0], + [189, 45, 18], + [229, 39, 48], + [248, 40, 72], + [233, 35, 75], + [201, 39, 71], + [163, 64, 72], + [131, 95, 79], + [ 84, 113, 74], + [ 63, 124, 72], + [ 63, 124, 72], + [ 70, 123, 64], + [158, 197, 127], + [164, 195, 118], + [164, 195, 116], + [167, 191, 129], + [170, 182, 150], + [103, 108, 104], + [ 98, 99, 119], + [ 93, 93, 125], + [ 95, 93, 130], + [ 96, 96, 125], + [ 0, 0, 11], + [ 0, 2, 7]], + + [[ 0, 55, 168], + [ 3, 53, 168], + [ 13, 47, 172], + [ 32, 43, 146], + [ 58, 36, 91], + [121, 63, 71], + [155, 58, 22], + [173, 56, 4], + [170, 47, 9], + [191, 38, 30], + [232, 22, 63], + [249, 17, 84], + [255, 30, 102], + [220, 32, 93], + [171, 56, 90], + [128, 89, 95], + [ 77, 112, 89], + [ 53, 125, 85], + [ 51, 126, 85], + [ 56, 127, 69], + [147, 207, 119], + [152, 208, 103], + [151, 209, 101], + [157, 203, 117], + [166, 187, 146], + [105, 105, 105], + [102, 87, 122], + [106, 84, 139], + [113, 92, 149], + [108, 95, 138], + [ 1, 0, 13], + [ 0, 2, 3]], + + [[ 7, 56, 174], + [ 10, 55, 172], + [ 16, 52, 168], + [ 34, 48, 141], + [ 61, 38, 94], + [122, 60, 74], + [152, 50, 20], + [167, 45, 0], + [171, 48, 8], + [184, 32, 26], + [232, 28, 78], + [248, 16, 96], + [254, 20, 99], + [228, 28, 95], + [180, 53, 93], + [120, 73, 82], + [ 78, 114, 88], + [ 49, 129, 84], + [ 47, 131, 80], + [ 54, 130, 66], + [145, 210, 118], + [152, 210, 102], + [150, 212, 100], + [157, 205, 116], + [169, 189, 148], + [104, 102, 102], + [112, 92, 133], + [111, 86, 145], + [108, 89, 148], + [104, 93, 134], + [ 2, 0, 4], + [ 1, 3, 0]], + + [[ 15, 58, 141], + [ 16, 58, 139], + [ 21, 56, 137], + [ 36, 51, 123], + [ 59, 39, 94], + [119, 58, 92], + [149, 44, 57], + [162, 39, 39], + [165, 44, 48], + [168, 36, 49], + [197, 45, 71], + [199, 35, 65], + [210, 39, 65], + [201, 54, 72], + [157, 65, 73], + [116, 83, 78], + [ 78, 111, 91], + [ 56, 122, 93], + [ 54, 123, 91], + [ 59, 122, 85], + [152, 200, 154], + [157, 199, 146], + [155, 200, 146], + [163, 194, 156], + [175, 178, 177], + [114, 93, 123], + [123, 80, 135], + [125, 73, 143], + [125, 80, 148], + [117, 83, 133], + [ 6, 0, 6], + [ 0, 0, 0]], + + [[ 28, 65, 73], + [ 28, 64, 77], + [ 28, 63, 83], + [ 39, 56, 91], + [ 56, 41, 94], + [111, 56, 127], + [137, 37, 125], + [149, 29, 124], + [141, 26, 117], + [144, 50, 98], + [168, 112, 76], + [164, 128, 45], + [163, 130, 36], + [151, 124, 40], + [149, 134, 75], + [206, 206, 174], + [191, 212, 205], + [181, 214, 221], + [179, 214, 225], + [183, 210, 235], + [113, 125, 173], + [116, 122, 183], + [114, 122, 187], + [124, 116, 189], + [142, 109, 189], + [195, 134, 218], + [215, 126, 210], + [228, 123, 209], + [223, 120, 207], + [209, 129, 199], + [ 20, 0, 18], + [ 6, 0, 8]], + + [[ 37, 66, 43], + [ 36, 66, 47], + [ 34, 65, 55], + [ 40, 59, 69], + [ 54, 43, 88], + [106, 56, 137], + [130, 35, 156], + [140, 26, 164], + [133, 25, 157], + [128, 56, 119], + [133, 126, 55], + [117, 147, 5], + [118, 151, 4], + [119, 152, 20], + [123, 147, 55], + [197, 218, 170], + [191, 211, 211], + [189, 208, 233], + [189, 206, 239], + [192, 201, 255], + [117, 115, 212], + [121, 110, 230], + [121, 109, 234], + [130, 105, 230], + [148, 97, 215], + [207, 125, 234], + [228, 114, 212], + [242, 111, 203], + [244, 109, 207], + [222, 118, 197], + [ 26, 0, 20], + [ 3, 0, 10]], + + [[ 42, 62, 49], + [ 40, 63, 49], + [ 37, 64, 51], + [ 42, 60, 61], + [ 55, 48, 78], + [ 96, 53, 120], + [118, 31, 142], + [137, 31, 163], + [133, 32, 160], + [120, 54, 113], + [129, 125, 49], + [113, 143, 0], + [114, 149, 7], + [115, 149, 24], + [117, 146, 54], + [191, 217, 167], + [186, 213, 213], + [186, 208, 237], + [189, 206, 239], + [191, 202, 255], + [113, 115, 215], + [115, 111, 233], + [118, 109, 233], + [129, 105, 227], + [150, 100, 213], + [204, 123, 228], + [230, 117, 212], + [242, 111, 203], + [246, 112, 207], + [223, 120, 194], + [ 27, 0, 18], + [ 3, 0, 4]], + + [[ 42, 63, 45], + [ 40, 64, 45], + [ 37, 65, 47], + [ 42, 61, 57], + [ 61, 55, 80], + [102, 60, 122], + [124, 38, 144], + [143, 38, 165], + [139, 37, 162], + [123, 49, 112], + [149, 134, 73], + [129, 142, 22], + [131, 143, 27], + [131, 143, 41], + [132, 142, 66], + [206, 215, 173], + [201, 209, 213], + [201, 206, 231], + [204, 204, 231], + [202, 202, 246], + [119, 119, 199], + [119, 117, 213], + [120, 116, 211], + [130, 112, 205], + [142, 105, 190], + [198, 137, 215], + [212, 126, 196], + [225, 122, 191], + [231, 131, 199], + [212, 135, 188], + [ 21, 0, 14], + [ 2, 0, 3]], + + [[ 41, 72, 34], + [ 39, 72, 38], + [ 37, 71, 46], + [ 44, 65, 60], + [ 61, 52, 82], + [104, 56, 122], + [127, 35, 139], + [148, 34, 159], + [139, 23, 151], + [134, 41, 122], + [157, 110, 92], + [152, 124, 56], + [151, 119, 50], + [155, 120, 59], + [156, 120, 77], + [231, 193, 174], + [230, 195, 202], + [228, 194, 212], + [228, 194, 208], + [222, 196, 216], + [129, 120, 157], + [122, 122, 165], + [122, 123, 161], + [124, 123, 157], + [131, 121, 154], + [174, 153, 183], + [187, 149, 173], + [185, 140, 162], + [188, 151, 170], + [178, 151, 167], + [ 10, 0, 10], + [ 2, 0, 6]], + + [[ 72, 113, 67], + [ 72, 112, 71], + [ 70, 112, 79], + [ 80, 104, 93], + [ 86, 77, 103], + [128, 82, 143], + [152, 60, 162], + [174, 58, 182], + [165, 47, 173], + [162, 58, 153], + [125, 50, 76], + [122, 58, 47], + [120, 49, 36], + [125, 50, 39], + [128, 51, 45], + [204, 127, 128], + [195, 118, 126], + [193, 119, 126], + [193, 120, 122], + [179, 127, 124], + [190, 176, 169], + [178, 182, 171], + [178, 182, 167], + [175, 184, 167], + [167, 184, 165], + [136, 155, 135], + [137, 150, 127], + [138, 151, 128], + [134, 154, 129], + [137, 154, 137], + [ 0, 0, 0], + [ 2, 0, 4]], + + [[ 64, 116, 73], + [ 65, 115, 73], + [ 67, 114, 73], + [ 76, 108, 83], + [ 97, 95, 107], + [121, 78, 129], + [146, 60, 155], + [159, 51, 169], + [159, 49, 168], + [163, 55, 159], + [135, 37, 111], + [137, 38, 97], + [139, 35, 90], + [141, 33, 81], + [143, 35, 67], + [221, 110, 129], + [220, 108, 112], + [222, 109, 104], + [222, 109, 102], + [201, 121, 98], + [200, 179, 129], + [181, 189, 125], + [181, 189, 125], + [173, 193, 125], + [153, 199, 125], + [112, 174, 98], + [103, 172, 101], + [101, 174, 106], + [ 96, 171, 105], + [112, 168, 117], + [ 0, 8, 0], + [ 2, 3, 0]], + + [[ 60, 118, 71], + [ 62, 117, 71], + [ 64, 117, 69], + [ 75, 109, 79], + [ 95, 97, 101], + [117, 81, 125], + [143, 62, 153], + [157, 52, 167], + [159, 50, 164], + [164, 53, 164], + [143, 29, 129], + [145, 30, 121], + [146, 26, 117], + [149, 25, 103], + [152, 28, 81], + [232, 104, 131], + [233, 104, 102], + [236, 104, 90], + [238, 103, 90], + [214, 117, 84], + [203, 181, 107], + [181, 194, 101], + [181, 194, 101], + [171, 198, 103], + [147, 207, 104], + [102, 182, 80], + [ 87, 183, 87], + [ 84, 185, 94], + [ 80, 181, 92], + [ 99, 177, 107], + [ 0, 12, 0], + [ 0, 7, 0]], + + [[ 62, 119, 63], + [ 62, 119, 63], + [ 64, 118, 65], + [ 73, 110, 77], + [ 93, 98, 99], + [117, 81, 123], + [143, 63, 149], + [159, 52, 163], + [163, 48, 164], + [169, 51, 162], + [145, 29, 125], + [145, 30, 119], + [146, 27, 115], + [148, 26, 103], + [151, 28, 81], + [232, 105, 129], + [236, 102, 100], + [239, 103, 88], + [239, 103, 90], + [215, 116, 82], + [203, 182, 101], + [179, 196, 95], + [179, 195, 97], + [170, 199, 101], + [148, 206, 104], + [104, 182, 80], + [ 91, 181, 85], + [ 87, 184, 90], + [ 82, 181, 88], + [ 99, 177, 105], + [ 0, 14, 0], + [ 0, 9, 0]], + + [[ 97, 102, 55], + [ 97, 102, 57], + [ 99, 101, 59], + [105, 96, 67], + [117, 88, 85], + [130, 78, 105], + [145, 67, 125], + [153, 61, 135], + [155, 58, 134], + [163, 58, 143], + [143, 29, 129], + [146, 26, 135], + [144, 24, 131], + [141, 25, 121], + [138, 30, 105], + [211, 109, 162], + [206, 111, 134], + [204, 114, 124], + [204, 114, 124], + [187, 125, 112], + [189, 186, 121], + [171, 197, 107], + [171, 197, 109], + [167, 200, 109], + [155, 202, 106], + [118, 175, 74], + [113, 173, 69], + [111, 176, 68], + [106, 173, 66], + [117, 171, 89], + [ 0, 11, 0], + [ 0, 7, 0]], + + [[205, 108, 89], + [207, 107, 89], + [210, 106, 89], + [210, 105, 91], + [204, 107, 99], + [192, 106, 103], + [180, 107, 111], + [172, 107, 113], + [167, 110, 111], + [174, 103, 138], + [164, 55, 167], + [170, 43, 193], + [170, 43, 191], + [161, 50, 188], + [142, 60, 186], + [124, 73, 179], + [103, 86, 165], + [ 92, 96, 156], + [ 89, 98, 152], + [ 88, 104, 131], + [123, 153, 125], + [122, 158, 101], + [119, 161, 97], + [122, 160, 90], + [129, 161, 77], + [188, 209, 108], + [202, 208, 85], + [205, 206, 74], + [204, 212, 79], + [197, 205, 104], + [ 6, 5, 0], + [ 1, 0, 0]], + + [[240, 92, 81], + [242, 91, 81], + [245, 90, 81], + [240, 92, 83], + [228, 98, 85], + [207, 102, 85], + [182, 111, 87], + [165, 116, 85], + [159, 119, 83], + [170, 108, 122], + [164, 53, 173], + [171, 39, 207], + [168, 41, 205], + [156, 49, 208], + [131, 61, 212], + [103, 77, 209], + [ 73, 95, 199], + [ 58, 106, 192], + [ 53, 109, 188], + [ 59, 113, 159], + [111, 156, 143], + [115, 159, 113], + [112, 162, 109], + [117, 161, 99], + [134, 158, 82], + [201, 203, 102], + [222, 201, 69], + [229, 198, 52], + [226, 205, 57], + [215, 199, 86], + [ 14, 2, 0], + [ 4, 0, 0]], + + [[242, 93, 73], + [242, 92, 75], + [245, 90, 79], + [239, 93, 81], + [226, 99, 85], + [205, 104, 83], + [182, 111, 83], + [167, 116, 81], + [164, 117, 81], + [173, 107, 120], + [166, 53, 169], + [171, 40, 205], + [168, 42, 203], + [155, 50, 206], + [129, 62, 212], + [103, 77, 209], + [ 75, 94, 197], + [ 60, 105, 190], + [ 57, 107, 188], + [ 61, 113, 157], + [111, 157, 137], + [114, 161, 107], + [111, 163, 105], + [117, 162, 94], + [134, 158, 80], + [202, 202, 102], + [226, 199, 67], + [231, 198, 48], + [228, 205, 53], + [215, 200, 84], + [ 12, 3, 0], + [ 1, 0, 0]], + + [[212, 111, 58], + [212, 111, 60], + [213, 109, 64], + [210, 110, 66], + [201, 115, 68], + [187, 116, 67], + [172, 120, 65], + [162, 121, 64], + [159, 123, 64], + [166, 114, 102], + [154, 64, 142], + [157, 52, 176], + [152, 55, 176], + [140, 61, 184], + [118, 71, 192], + [ 95, 84, 197], + [ 67, 98, 197], + [ 53, 107, 196], + [ 50, 110, 192], + [ 59, 113, 161], + [115, 155, 137], + [123, 157, 105], + [120, 159, 103], + [127, 157, 94], + [145, 153, 80], + [213, 196, 104], + [238, 192, 73], + [245, 190, 56], + [241, 197, 61], + [224, 193, 92], + [ 14, 2, 0], + [ 0, 0, 0]], + + [[149, 147, 36], + [149, 147, 38], + [151, 146, 38], + [151, 145, 40], + [154, 144, 40], + [158, 145, 43], + [153, 135, 34], + [160, 142, 43], + [152, 139, 39], + [160, 139, 73], + [127, 84, 92], + [129, 81, 124], + [122, 83, 128], + [104, 80, 131], + [ 99, 94, 155], + [ 76, 98, 173], + [ 58, 114, 204], + [ 43, 119, 214], + [ 40, 121, 210], + [ 58, 119, 176], + [125, 146, 144], + [141, 145, 109], + [140, 146, 107], + [146, 145, 97], + [167, 144, 86], + [232, 182, 108], + [255, 181, 91], + [255, 168, 68], + [255, 179, 80], + [238, 174, 102], + [ 26, 3, 0], + [ 1, 0, 0]], + + [[106, 198, 38], + [108, 198, 36], + [108, 198, 36], + [114, 195, 34], + [130, 193, 35], + [173, 212, 60], + [190, 205, 59], + [195, 197, 55], + [190, 198, 52], + [191, 199, 80], + [142, 150, 88], + [136, 148, 115], + [120, 142, 109], + [117, 148, 128], + [104, 149, 152], + [ 60, 122, 161], + [ 39, 124, 202], + [ 27, 125, 222], + [ 24, 127, 220], + [ 51, 121, 184], + [ 97, 98, 107], + [123, 92, 73], + [121, 93, 71], + [128, 92, 61], + [142, 86, 43], + [183, 98, 45], + [205, 88, 22], + [214, 84, 14], + [206, 83, 15], + [181, 89, 40], + [ 23, 0, 0], + [ 3, 0, 2]], + + [[ 46, 230, 22], + [ 48, 230, 20], + [ 51, 229, 16], + [ 64, 223, 10], + [ 80, 207, 0], + [143, 231, 30], + [180, 220, 31], + [186, 207, 20], + [186, 213, 21], + [175, 214, 44], + [111, 171, 42], + [ 95, 170, 60], + [ 92, 172, 60], + [ 91, 181, 87], + [ 73, 177, 124], + [ 23, 137, 135], + [ 18, 135, 196], + [ 11, 133, 224], + [ 8, 134, 226], + [ 43, 124, 190], + [115, 94, 111], + [152, 83, 74], + [147, 84, 78], + [155, 82, 70], + [182, 80, 60], + [209, 84, 53], + [219, 71, 30], + [232, 73, 29], + [220, 66, 20], + [194, 79, 45], + [ 29, 0, 0], + [ 8, 3, 7]], + + [[ 22, 251, 21], + [ 24, 250, 19], + [ 27, 250, 13], + [ 43, 243, 5], + [ 73, 231, 0], + [130, 241, 19], + [167, 224, 13], + [182, 213, 7], + [185, 221, 13], + [169, 225, 31], + [ 95, 184, 20], + [ 76, 182, 35], + [ 75, 183, 35], + [ 69, 187, 61], + [ 53, 186, 109], + [ 16, 155, 138], + [ 7, 141, 194], + [ 2, 138, 224], + [ 0, 139, 226], + [ 40, 125, 192], + [119, 88, 110], + [161, 74, 76], + [158, 75, 80], + [166, 72, 74], + [181, 62, 54], + [217, 76, 60], + [231, 69, 41], + [237, 67, 35], + [235, 65, 31], + [205, 74, 50], + [ 30, 0, 0], + [ 3, 0, 2]], + + [[ 24, 246, 19], + [ 24, 246, 17], + [ 28, 246, 10], + [ 42, 240, 4], + [ 71, 232, 0], + [130, 243, 21], + [164, 225, 13], + [175, 213, 9], + [176, 219, 15], + [163, 224, 33], + [ 85, 179, 11], + [ 69, 176, 24], + [ 79, 184, 39], + [ 73, 185, 70], + [ 53, 179, 114], + [ 11, 145, 136], + [ 6, 145, 198], + [ 1, 142, 226], + [ 1, 142, 224], + [ 42, 128, 192], + [117, 90, 117], + [159, 76, 83], + [159, 76, 83], + [167, 72, 79], + [188, 74, 74], + [209, 74, 63], + [229, 70, 49], + [237, 66, 37], + [239, 70, 36], + [202, 72, 46], + [ 37, 0, 0], + [ 4, 0, 0]], + + [[ 60, 221, 53], + [ 58, 222, 51], + [ 58, 223, 47], + [ 68, 219, 43], + [ 87, 211, 37], + [135, 224, 55], + [166, 214, 55], + [181, 210, 57], + [174, 208, 57], + [163, 211, 70], + [106, 175, 47], + [ 94, 171, 56], + [ 96, 172, 67], + [ 90, 169, 88], + [ 76, 167, 125], + [ 43, 141, 140], + [ 28, 132, 175], + [ 25, 131, 193], + [ 25, 131, 193], + [ 56, 119, 166], + [113, 91, 112], + [143, 81, 88], + [145, 80, 88], + [151, 78, 82], + [164, 80, 77], + [180, 81, 71], + [196, 78, 63], + [203, 74, 54], + [206, 76, 51], + [178, 79, 58], + [ 31, 0, 0], + [ 8, 0, 0]], + + [[ 0, 24, 0], + [ 0, 25, 0], + [ 0, 27, 0], + [ 0, 26, 0], + [ 0, 24, 0], + [ 0, 28, 0], + [ 0, 13, 0], + [ 1, 11, 0], + [ 0, 14, 0], + [ 0, 13, 0], + [ 0, 10, 0], + [ 0, 7, 0], + [ 0, 15, 0], + [ 0, 10, 0], + [ 0, 13, 7], + [ 0, 4, 9], + [ 0, 5, 24], + [ 0, 5, 28], + [ 0, 6, 28], + [ 0, 1, 17], + [ 4, 0, 0], + [ 16, 0, 0], + [ 15, 0, 0], + [ 16, 0, 0], + [ 20, 0, 0], + [ 28, 0, 0], + [ 33, 0, 0], + [ 34, 0, 0], + [ 36, 0, 0], + [ 29, 0, 0], + [ 10, 0, 0], + [ 2, 0, 0]], + + [[ 4, 0, 1], + [ 1, 1, 1], + [ 0, 4, 1], + [ 0, 5, 1], + [ 0, 3, 0], + [ 0, 8, 5], + [ 0, 0, 0], + [ 4, 7, 6], + [ 0, 1, 0], + [ 0, 0, 0], + [ 6, 0, 0], + [ 7, 0, 0], + [ 12, 0, 6], + [ 2, 0, 2], + [ 2, 0, 9], + [ 0, 0, 3], + [ 1, 0, 2], + [ 0, 0, 0], + [ 0, 0, 2], + [ 0, 0, 0], + [ 4, 0, 0], + [ 7, 0, 0], + [ 6, 0, 0], + [ 4, 0, 0], + [ 3, 0, 0], + [ 6, 2, 0], + [ 5, 2, 6], + [ 4, 0, 8], + [ 6, 1, 2], + [ 8, 0, 0], + [ 8, 0, 0], + [ 10, 0, 0]]], dtype=np.uint8), +) + +image_decoder_decode_pnm_rgb = ImageData( + np.array([ 80, 54, 10, 51, 50, 32, 51, 50, 10, 50, 53, 53, 10, + 226, 81, 251, 226, 81, 251, 226, 81, 251, 226, 81, 251, 226, + 81, 251, 237, 229, 45, 237, 229, 45, 237, 229, 45, 237, 229, + 45, 237, 229, 45, 225, 227, 29, 225, 227, 29, 225, 227, 29, + 225, 227, 29, 225, 227, 29, 253, 253, 80, 253, 253, 80, 253, + 253, 80, 253, 253, 80, 253, 253, 80, 129, 8, 118, 129, 8, + 118, 129, 8, 118, 129, 8, 118, 129, 8, 118, 33, 164, 77, + 33, 164, 77, 33, 164, 77, 33, 164, 77, 33, 164, 77, 0, + 0, 0, 0, 0, 0, 226, 81, 251, 226, 81, 251, 226, 81, + 251, 226, 81, 251, 226, 81, 251, 237, 229, 45, 237, 229, 45, + 237, 229, 45, 237, 229, 45, 237, 229, 45, 225, 227, 29, 225, + 227, 29, 225, 227, 29, 225, 227, 29, 225, 227, 29, 253, 253, + 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, + 129, 8, 118, 129, 8, 118, 129, 8, 118, 129, 8, 118, 129, + 8, 118, 33, 164, 77, 33, 164, 77, 33, 164, 77, 33, 164, + 77, 33, 164, 77, 0, 0, 0, 0, 0, 0, 226, 81, 251, + 226, 81, 251, 226, 81, 251, 226, 81, 251, 226, 81, 251, 237, + 229, 45, 237, 229, 45, 237, 229, 45, 237, 229, 45, 237, 229, + 45, 225, 227, 29, 225, 227, 29, 225, 227, 29, 225, 227, 29, + 225, 227, 29, 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, + 253, 80, 253, 253, 80, 129, 8, 118, 129, 8, 118, 129, 8, + 118, 129, 8, 118, 129, 8, 118, 33, 164, 77, 33, 164, 77, + 33, 164, 77, 33, 164, 77, 33, 164, 77, 0, 0, 0, 0, + 0, 0, 226, 81, 251, 226, 81, 251, 226, 81, 251, 226, 81, + 251, 226, 81, 251, 237, 229, 45, 237, 229, 45, 237, 229, 45, + 237, 229, 45, 237, 229, 45, 225, 227, 29, 225, 227, 29, 225, + 227, 29, 225, 227, 29, 225, 227, 29, 253, 253, 80, 253, 253, + 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 129, 8, 118, + 129, 8, 118, 129, 8, 118, 129, 8, 118, 129, 8, 118, 33, + 164, 77, 33, 164, 77, 33, 164, 77, 33, 164, 77, 33, 164, + 77, 0, 0, 0, 0, 0, 0, 226, 81, 251, 226, 81, 251, + 226, 81, 251, 226, 81, 251, 226, 81, 251, 237, 229, 45, 237, + 229, 45, 237, 229, 45, 237, 229, 45, 237, 229, 45, 225, 227, + 29, 225, 227, 29, 225, 227, 29, 225, 227, 29, 225, 227, 29, + 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, 253, 80, 253, + 253, 80, 129, 8, 118, 129, 8, 118, 129, 8, 118, 129, 8, + 118, 129, 8, 118, 33, 164, 77, 33, 164, 77, 33, 164, 77, + 33, 164, 77, 33, 164, 77, 0, 0, 0, 0, 0, 0, 21, + 47, 169, 21, 47, 169, 21, 47, 169, 21, 47, 169, 21, 47, + 169, 173, 45, 10, 173, 45, 10, 173, 45, 10, 173, 45, 10, + 173, 45, 10, 254, 15, 94, 254, 15, 94, 254, 15, 94, 254, + 15, 94, 254, 15, 94, 52, 126, 81, 52, 126, 81, 52, 126, + 81, 52, 126, 81, 52, 126, 81, 145, 211, 101, 145, 211, 101, + 145, 211, 101, 145, 211, 101, 145, 211, 101, 109, 86, 145, 109, + 86, 145, 109, 86, 145, 109, 86, 145, 109, 86, 145, 0, 0, + 0, 0, 0, 0, 21, 47, 169, 21, 47, 169, 21, 47, 169, + 21, 47, 169, 21, 47, 169, 173, 45, 10, 173, 45, 10, 173, + 45, 10, 173, 45, 10, 173, 45, 10, 254, 15, 94, 254, 15, + 94, 254, 15, 94, 254, 15, 94, 254, 15, 94, 52, 126, 81, + 52, 126, 81, 52, 126, 81, 52, 126, 81, 52, 126, 81, 145, + 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, + 101, 109, 86, 145, 109, 86, 145, 109, 86, 145, 109, 86, 145, + 109, 86, 145, 0, 0, 0, 0, 0, 0, 21, 47, 169, 21, + 47, 169, 21, 47, 169, 21, 47, 169, 21, 47, 169, 173, 45, + 10, 173, 45, 10, 173, 45, 10, 173, 45, 10, 173, 45, 10, + 254, 15, 94, 254, 15, 94, 254, 15, 94, 254, 15, 94, 254, + 15, 94, 52, 126, 81, 52, 126, 81, 52, 126, 81, 52, 126, + 81, 52, 126, 81, 145, 211, 101, 145, 211, 101, 145, 211, 101, + 145, 211, 101, 145, 211, 101, 109, 86, 145, 109, 86, 145, 109, + 86, 145, 109, 86, 145, 109, 86, 145, 0, 0, 0, 0, 0, + 0, 21, 47, 169, 21, 47, 169, 21, 47, 169, 21, 47, 169, + 21, 47, 169, 173, 45, 10, 173, 45, 10, 173, 45, 10, 173, + 45, 10, 173, 45, 10, 254, 15, 94, 254, 15, 94, 254, 15, + 94, 254, 15, 94, 254, 15, 94, 52, 126, 81, 52, 126, 81, + 52, 126, 81, 52, 126, 81, 52, 126, 81, 145, 211, 101, 145, + 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, 109, 86, + 145, 109, 86, 145, 109, 86, 145, 109, 86, 145, 109, 86, 145, + 0, 0, 0, 0, 0, 0, 21, 47, 169, 21, 47, 169, 21, + 47, 169, 21, 47, 169, 21, 47, 169, 173, 45, 10, 173, 45, + 10, 173, 45, 10, 173, 45, 10, 173, 45, 10, 254, 15, 94, + 254, 15, 94, 254, 15, 94, 254, 15, 94, 254, 15, 94, 52, + 126, 81, 52, 126, 81, 52, 126, 81, 52, 126, 81, 52, 126, + 81, 145, 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, + 145, 211, 101, 109, 86, 145, 109, 86, 145, 109, 86, 145, 109, + 86, 145, 109, 86, 145, 0, 0, 0, 0, 0, 0, 34, 66, + 54, 34, 66, 54, 34, 66, 54, 34, 66, 54, 34, 66, 54, + 136, 29, 158, 136, 29, 158, 136, 29, 158, 136, 29, 158, 136, + 29, 158, 117, 152, 1, 117, 152, 1, 117, 152, 1, 117, 152, + 1, 117, 152, 1, 187, 208, 244, 187, 208, 244, 187, 208, 244, + 187, 208, 244, 187, 208, 244, 118, 108, 234, 118, 108, 234, 118, + 108, 234, 118, 108, 234, 118, 108, 234, 246, 113, 205, 246, 113, + 205, 246, 113, 205, 246, 113, 205, 246, 113, 205, 0, 0, 0, + 0, 0, 0, 34, 66, 54, 34, 66, 54, 34, 66, 54, 34, + 66, 54, 34, 66, 54, 136, 29, 158, 136, 29, 158, 136, 29, + 158, 136, 29, 158, 136, 29, 158, 117, 152, 1, 117, 152, 1, + 117, 152, 1, 117, 152, 1, 117, 152, 1, 187, 208, 244, 187, + 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, 118, 108, + 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, + 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, + 113, 205, 0, 0, 0, 0, 0, 0, 34, 66, 54, 34, 66, + 54, 34, 66, 54, 34, 66, 54, 34, 66, 54, 136, 29, 158, + 136, 29, 158, 136, 29, 158, 136, 29, 158, 136, 29, 158, 117, + 152, 1, 117, 152, 1, 117, 152, 1, 117, 152, 1, 117, 152, + 1, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, + 187, 208, 244, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, + 108, 234, 118, 108, 234, 246, 113, 205, 246, 113, 205, 246, 113, + 205, 246, 113, 205, 246, 113, 205, 0, 0, 0, 0, 0, 0, + 34, 66, 54, 34, 66, 54, 34, 66, 54, 34, 66, 54, 34, + 66, 54, 136, 29, 158, 136, 29, 158, 136, 29, 158, 136, 29, + 158, 136, 29, 158, 117, 152, 1, 117, 152, 1, 117, 152, 1, + 117, 152, 1, 117, 152, 1, 187, 208, 244, 187, 208, 244, 187, + 208, 244, 187, 208, 244, 187, 208, 244, 118, 108, 234, 118, 108, + 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 246, 113, 205, + 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, 205, 0, + 0, 0, 0, 0, 0, 34, 66, 54, 34, 66, 54, 34, 66, + 54, 34, 66, 54, 34, 66, 54, 136, 29, 158, 136, 29, 158, + 136, 29, 158, 136, 29, 158, 136, 29, 158, 117, 152, 1, 117, + 152, 1, 117, 152, 1, 117, 152, 1, 117, 152, 1, 187, 208, + 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, + 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, + 108, 234, 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, + 205, 246, 113, 205, 0, 0, 0, 0, 0, 0, 64, 118, 59, + 64, 118, 59, 64, 118, 59, 64, 118, 59, 64, 118, 59, 157, + 54, 167, 157, 54, 167, 157, 54, 167, 157, 54, 167, 157, 54, + 167, 142, 26, 122, 142, 26, 122, 142, 26, 122, 142, 26, 122, + 142, 26, 122, 236, 105, 88, 236, 105, 88, 236, 105, 88, 236, + 105, 88, 236, 105, 88, 184, 191, 91, 184, 191, 91, 184, 191, + 91, 184, 191, 91, 184, 191, 91, 76, 185, 95, 76, 185, 95, + 76, 185, 95, 76, 185, 95, 76, 185, 95, 0, 0, 0, 0, + 0, 0, 64, 118, 59, 64, 118, 59, 64, 118, 59, 64, 118, + 59, 64, 118, 59, 157, 54, 167, 157, 54, 167, 157, 54, 167, + 157, 54, 167, 157, 54, 167, 142, 26, 122, 142, 26, 122, 142, + 26, 122, 142, 26, 122, 142, 26, 122, 236, 105, 88, 236, 105, + 88, 236, 105, 88, 236, 105, 88, 236, 105, 88, 184, 191, 91, + 184, 191, 91, 184, 191, 91, 184, 191, 91, 184, 191, 91, 76, + 185, 95, 76, 185, 95, 76, 185, 95, 76, 185, 95, 76, 185, + 95, 0, 0, 0, 0, 0, 0, 64, 118, 59, 64, 118, 59, + 64, 118, 59, 64, 118, 59, 64, 118, 59, 157, 54, 167, 157, + 54, 167, 157, 54, 167, 157, 54, 167, 157, 54, 167, 142, 26, + 122, 142, 26, 122, 142, 26, 122, 142, 26, 122, 142, 26, 122, + 236, 105, 88, 236, 105, 88, 236, 105, 88, 236, 105, 88, 236, + 105, 88, 184, 191, 91, 184, 191, 91, 184, 191, 91, 184, 191, + 91, 184, 191, 91, 76, 185, 95, 76, 185, 95, 76, 185, 95, + 76, 185, 95, 76, 185, 95, 0, 0, 0, 0, 0, 0, 64, + 118, 59, 64, 118, 59, 64, 118, 59, 64, 118, 59, 64, 118, + 59, 157, 54, 167, 157, 54, 167, 157, 54, 167, 157, 54, 167, + 157, 54, 167, 142, 26, 122, 142, 26, 122, 142, 26, 122, 142, + 26, 122, 142, 26, 122, 236, 105, 88, 236, 105, 88, 236, 105, + 88, 236, 105, 88, 236, 105, 88, 184, 191, 91, 184, 191, 91, + 184, 191, 91, 184, 191, 91, 184, 191, 91, 76, 185, 95, 76, + 185, 95, 76, 185, 95, 76, 185, 95, 76, 185, 95, 0, 0, + 0, 0, 0, 0, 64, 118, 59, 64, 118, 59, 64, 118, 59, + 64, 118, 59, 64, 118, 59, 157, 54, 167, 157, 54, 167, 157, + 54, 167, 157, 54, 167, 157, 54, 167, 142, 26, 122, 142, 26, + 122, 142, 26, 122, 142, 26, 122, 142, 26, 122, 236, 105, 88, + 236, 105, 88, 236, 105, 88, 236, 105, 88, 236, 105, 88, 184, + 191, 91, 184, 191, 91, 184, 191, 91, 184, 191, 91, 184, 191, + 91, 76, 185, 95, 76, 185, 95, 76, 185, 95, 76, 185, 95, + 76, 185, 95, 0, 0, 0, 0, 0, 0, 247, 90, 80, 247, + 90, 80, 247, 90, 80, 247, 90, 80, 247, 90, 80, 167, 118, + 85, 167, 118, 85, 167, 118, 85, 167, 118, 85, 167, 118, 85, + 172, 39, 208, 172, 39, 208, 172, 39, 208, 172, 39, 208, 172, + 39, 208, 60, 106, 191, 60, 106, 191, 60, 106, 191, 60, 106, + 191, 60, 106, 191, 114, 163, 112, 114, 163, 112, 114, 163, 112, + 114, 163, 112, 114, 163, 112, 228, 201, 50, 228, 201, 50, 228, + 201, 50, 228, 201, 50, 228, 201, 50, 0, 0, 0, 0, 0, + 0, 247, 90, 80, 247, 90, 80, 247, 90, 80, 247, 90, 80, + 247, 90, 80, 167, 118, 85, 167, 118, 85, 167, 118, 85, 167, + 118, 85, 167, 118, 85, 172, 39, 208, 172, 39, 208, 172, 39, + 208, 172, 39, 208, 172, 39, 208, 60, 106, 191, 60, 106, 191, + 60, 106, 191, 60, 106, 191, 60, 106, 191, 114, 163, 112, 114, + 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, 228, 201, + 50, 228, 201, 50, 228, 201, 50, 228, 201, 50, 228, 201, 50, + 0, 0, 0, 0, 0, 0, 247, 90, 80, 247, 90, 80, 247, + 90, 80, 247, 90, 80, 247, 90, 80, 167, 118, 85, 167, 118, + 85, 167, 118, 85, 167, 118, 85, 167, 118, 85, 172, 39, 208, + 172, 39, 208, 172, 39, 208, 172, 39, 208, 172, 39, 208, 60, + 106, 191, 60, 106, 191, 60, 106, 191, 60, 106, 191, 60, 106, + 191, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, + 114, 163, 112, 228, 201, 50, 228, 201, 50, 228, 201, 50, 228, + 201, 50, 228, 201, 50, 0, 0, 0, 0, 0, 0, 247, 90, + 80, 247, 90, 80, 247, 90, 80, 247, 90, 80, 247, 90, 80, + 167, 118, 85, 167, 118, 85, 167, 118, 85, 167, 118, 85, 167, + 118, 85, 172, 39, 208, 172, 39, 208, 172, 39, 208, 172, 39, + 208, 172, 39, 208, 60, 106, 191, 60, 106, 191, 60, 106, 191, + 60, 106, 191, 60, 106, 191, 114, 163, 112, 114, 163, 112, 114, + 163, 112, 114, 163, 112, 114, 163, 112, 228, 201, 50, 228, 201, + 50, 228, 201, 50, 228, 201, 50, 228, 201, 50, 0, 0, 0, + 0, 0, 0, 247, 90, 80, 247, 90, 80, 247, 90, 80, 247, + 90, 80, 247, 90, 80, 167, 118, 85, 167, 118, 85, 167, 118, + 85, 167, 118, 85, 167, 118, 85, 172, 39, 208, 172, 39, 208, + 172, 39, 208, 172, 39, 208, 172, 39, 208, 60, 106, 191, 60, + 106, 191, 60, 106, 191, 60, 106, 191, 60, 106, 191, 114, 163, + 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, + 228, 201, 50, 228, 201, 50, 228, 201, 50, 228, 201, 50, 228, + 201, 50, 0, 0, 0, 0, 0, 0, 24, 246, 11, 24, 246, + 11, 24, 246, 11, 24, 246, 11, 24, 246, 11, 177, 219, 6, + 177, 219, 6, 177, 219, 6, 177, 219, 6, 177, 219, 6, 77, + 188, 37, 77, 188, 37, 77, 188, 37, 77, 188, 37, 77, 188, + 37, 2, 138, 230, 2, 138, 230, 2, 138, 230, 2, 138, 230, + 2, 138, 230, 159, 74, 81, 159, 74, 81, 159, 74, 81, 159, + 74, 81, 159, 74, 81, 240, 63, 27, 240, 63, 27, 240, 63, + 27, 240, 63, 27, 240, 63, 27, 0, 0, 0, 0, 0, 0, + 24, 246, 11, 24, 246, 11, 24, 246, 11, 24, 246, 11, 24, + 246, 11, 177, 219, 6, 177, 219, 6, 177, 219, 6, 177, 219, + 6, 177, 219, 6, 77, 188, 37, 77, 188, 37, 77, 188, 37, + 77, 188, 37, 77, 188, 37, 2, 138, 230, 2, 138, 230, 2, + 138, 230, 2, 138, 230, 2, 138, 230, 159, 74, 81, 159, 74, + 81, 159, 74, 81, 159, 74, 81, 159, 74, 81, 240, 63, 27, + 240, 63, 27, 240, 63, 27, 240, 63, 27, 240, 63, 27, 0, + 0, 0, 0, 0, 0, 24, 246, 11, 24, 246, 11, 24, 246, + 11, 24, 246, 11, 24, 246, 11, 177, 219, 6, 177, 219, 6, + 177, 219, 6, 177, 219, 6, 177, 219, 6, 77, 188, 37, 77, + 188, 37, 77, 188, 37, 77, 188, 37, 77, 188, 37, 2, 138, + 230, 2, 138, 230, 2, 138, 230, 2, 138, 230, 2, 138, 230, + 159, 74, 81, 159, 74, 81, 159, 74, 81, 159, 74, 81, 159, + 74, 81, 240, 63, 27, 240, 63, 27, 240, 63, 27, 240, 63, + 27, 240, 63, 27, 0, 0, 0, 0, 0, 0, 24, 246, 11, + 24, 246, 11, 24, 246, 11, 24, 246, 11, 24, 246, 11, 177, + 219, 6, 177, 219, 6, 177, 219, 6, 177, 219, 6, 177, 219, + 6, 77, 188, 37, 77, 188, 37, 77, 188, 37, 77, 188, 37, + 77, 188, 37, 2, 138, 230, 2, 138, 230, 2, 138, 230, 2, + 138, 230, 2, 138, 230, 159, 74, 81, 159, 74, 81, 159, 74, + 81, 159, 74, 81, 159, 74, 81, 240, 63, 27, 240, 63, 27, + 240, 63, 27, 240, 63, 27, 240, 63, 27, 0, 0, 0, 0, + 0, 0, 24, 246, 11, 24, 246, 11, 24, 246, 11, 24, 246, + 11, 24, 246, 11, 177, 219, 6, 177, 219, 6, 177, 219, 6, + 177, 219, 6, 177, 219, 6, 77, 188, 37, 77, 188, 37, 77, + 188, 37, 77, 188, 37, 77, 188, 37, 2, 138, 230, 2, 138, + 230, 2, 138, 230, 2, 138, 230, 2, 138, 230, 159, 74, 81, + 159, 74, 81, 159, 74, 81, 159, 74, 81, 159, 74, 81, 240, + 63, 27, 240, 63, 27, 240, 63, 27, 240, 63, 27, 240, 63, + 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], dtype=np.uint8), + np.array([[[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [226, 81, 251], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [237, 229, 45], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [225, 227, 29], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [253, 253, 80], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [129, 8, 118], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 33, 164, 77], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [ 21, 47, 169], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [173, 45, 10], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [254, 15, 94], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [ 52, 126, 81], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [145, 211, 101], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [109, 86, 145], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [ 34, 66, 54], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [136, 29, 158], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [117, 152, 1], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [187, 208, 244], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [118, 108, 234], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [246, 113, 205], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [ 64, 118, 59], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [157, 54, 167], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [142, 26, 122], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [236, 105, 88], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [184, 191, 91], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 76, 185, 95], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [247, 90, 80], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [167, 118, 85], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [172, 39, 208], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [ 60, 106, 191], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [114, 163, 112], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [228, 201, 50], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [ 24, 246, 11], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [177, 219, 6], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 77, 188, 37], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [ 2, 138, 230], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [159, 74, 81], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [240, 63, 27], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0]], + + [[ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0], + [ 0, 0, 0]]], dtype=np.uint8), +) +# fmt: on diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/abs.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/abs.py new file mode 100644 index 0000000000000000000000000000000000000000..5054fdd050b9219bf9fbb5afcc4ed534fdef3762 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/abs.py @@ -0,0 +1,24 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Abs(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Abs", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.abs(x) + + expect(node, inputs=[x], outputs=[y], name="test_abs") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/acos.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/acos.py new file mode 100644 index 0000000000000000000000000000000000000000..4083407b18ca4101b5fc200ec2c6af04d0683bf4 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/acos.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Acos(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Acos", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-0.5, 0, 0.5]).astype(np.float32) + y = np.arccos(x) + expect(node, inputs=[x], outputs=[y], name="test_acos_example") + + x = np.random.rand(3, 4, 5).astype(np.float32) + y = np.arccos(x) + expect(node, inputs=[x], outputs=[y], name="test_acos") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/acosh.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/acosh.py new file mode 100644 index 0000000000000000000000000000000000000000..665c441754de53f07673733dc2b03ef9dd569532 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/acosh.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Acosh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Acosh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([10, np.e, 1]).astype(np.float32) + y = np.arccosh(x) # expected output [2.99322295, 1.65745449, 0.] + expect(node, inputs=[x], outputs=[y], name="test_acosh_example") + + x = np.random.uniform(1.0, 10.0, (3, 4, 5)).astype(np.float32) + y = np.arccosh(x) + expect(node, inputs=[x], outputs=[y], name="test_acosh") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/adagrad.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/adagrad.py new file mode 100644 index 0000000000000000000000000000000000000000..1a3d4a0f7b387a52018cd91aa6d17684e7ad4c33 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/adagrad.py @@ -0,0 +1,116 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN + + +def apply_adagrad(r, t, x, g, h, norm_coefficient, epsilon, decay_factor): + # Compute adjusted learning-rate. + r_ = r / (1 + t * decay_factor) + # Add gradient of regularization term. + g_regularized = norm_coefficient * x + g + # Update squared accumulated gradient. + h_new = h + g_regularized * g_regularized + # Compute ADAGRAD's gradient scaling factors + h_sqrt = np.sqrt(h_new) + epsilon + # Apply ADAGRAD update rule. + x_new = x - r_ * g_regularized / h_sqrt + return (x_new.astype(x.dtype), h_new.astype(h.dtype)) + + +class Adagrad(Base): + @staticmethod + def export_adagrad() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + epsilon = 1e-5 + decay_factor = 0.1 + + # Create operator. + node = onnx.helper.make_node( + "Adagrad", + inputs=["R", "T", "X", "G", "H"], + outputs=["X_new", "H_new"], + norm_coefficient=norm_coefficient, + epsilon=epsilon, + decay_factor=decay_factor, + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + x = np.array([1.0], dtype=np.float32) + g = np.array([-1.0], dtype=np.float32) + h = np.array([2.0], dtype=np.float32) + + # Compute expected outputs of Adagrad. + x_new, h_new = apply_adagrad( + r, t, x, g, h, norm_coefficient, epsilon, decay_factor + ) + + # Check results. + expect( + node, + inputs=[r, t, x, g, h], + outputs=[x_new, h_new], + name="test_adagrad", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) + + @staticmethod + def export_adagrad_multiple() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + epsilon = 1e-5 + decay_factor = 0.1 + + node = onnx.helper.make_node( + "Adagrad", + inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"], + outputs=["X1_new", "X2_new", "H1_new", "H2_new"], + norm_coefficient=norm_coefficient, + epsilon=epsilon, + decay_factor=decay_factor, + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + + x1 = np.array([1.0], dtype=np.float32) + g1 = np.array([-1.0], dtype=np.float32) + h1 = np.array([2.0], dtype=np.float32) + + x2 = np.array([1.0, 2.0], dtype=np.float32) + g2 = np.array([-1.0, -3.0], dtype=np.float32) + h2 = np.array([4.0, 1.0], dtype=np.float32) + + # Compute expected outputs of Adagrad. + x1_new, h1_new = apply_adagrad( + r, t, x1, g1, h1, norm_coefficient, epsilon, decay_factor + ) + x2_new, h2_new = apply_adagrad( + r, t, x2, g2, h2, norm_coefficient, epsilon, decay_factor + ) + + # Check results. + expect( + node, + inputs=[r, t, x1, x2, g1, g2, h1, h2], + outputs=[x1_new, x2_new, h1_new, h2_new], + name="test_adagrad_multiple", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/adam.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/adam.py new file mode 100644 index 0000000000000000000000000000000000000000..108b84dc0902ed8946b960a9c0cf78cc6da82cfd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/adam.py @@ -0,0 +1,135 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN + + +def apply_adam( + r, t, x, g, v, h, norm_coefficient, norm_coefficient_post, alpha, beta, epsilon +): + # Add gradient of regularization term. + g_regularized = norm_coefficient * x + g + # Update momentum. + v_new = alpha * v + (1 - alpha) * g_regularized + # Update second-order momentum. + h_new = beta * h + (1 - beta) * (g_regularized * g_regularized) + # Compute element-wise square root. + h_sqrt = np.sqrt(h_new) + epsilon + # Adjust learning rate. + r_adjusted = None + if t > 0: + # Consider bias correction on momentums. + r_adjusted = r * np.sqrt(1 - beta**t) / (1 - alpha**t) + else: + # No bias correction on momentums. + r_adjusted = r + # Apply Adam update rule. + x_new = x - r_adjusted * (v_new / h_sqrt) + # It's possible to apply regularization in the end. + x_final = (1 - norm_coefficient_post) * x_new + return x_final, v_new, h_new + + +class Adam(Base): + @staticmethod + def export_adam() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + alpha = 0.95 + beta = 0.1 + epsilon = 1e-7 + + # Create operator. + node = onnx.helper.make_node( + "Adam", + inputs=["R", "T", "X", "G", "V", "H"], + outputs=["X_new", "V_new", "H_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + epsilon=epsilon, + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + x = np.array([1.2, 2.8], dtype=np.float32) + g = np.array([-0.94, -2.5], dtype=np.float32) + v = np.array([1.7, 3.6], dtype=np.float32) + h = np.array([0.1, 0.1], dtype=np.float32) + + # Compute expected outputs of Adam. + x_new, v_new, h_new = apply_adam( + r, t, x, g, v, h, norm_coefficient, 0.0, alpha, beta, epsilon + ) + + # Check results. + expect( + node, + inputs=[r, t, x, g, v, h], + outputs=[x_new, v_new, h_new], + name="test_adam", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) + + @staticmethod + def export_adam_multiple() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + alpha = 0.95 + beta = 0.85 + epsilon = 1e-2 + + node = onnx.helper.make_node( + "Adam", + inputs=["R", "T", "X1", "X2", "G1", "G2", "V1", "V2", "H1", "H2"], + outputs=["X1_new", "X2_new", "V1_new", "V2_new", "H1_new", "H2_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + epsilon=epsilon, + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + + x1 = np.array([1.0], dtype=np.float32) + g1 = np.array([-1.0], dtype=np.float32) + v1 = np.array([2.0], dtype=np.float32) + h1 = np.array([0.5], dtype=np.float32) + + x2 = np.array([1.0, 2.0], dtype=np.float32) + g2 = np.array([-1.0, -3.0], dtype=np.float32) + v2 = np.array([4.0, 1.0], dtype=np.float32) + h2 = np.array([1.0, 10.0], dtype=np.float32) + + # Compute expected outputs of Adam. + x1_new, v1_new, h1_new = apply_adam( + r, t, x1, g1, v1, h1, norm_coefficient, 0.0, alpha, beta, epsilon + ) + x2_new, v2_new, h2_new = apply_adam( + r, t, x2, g2, v2, h2, norm_coefficient, 0.0, alpha, beta, epsilon + ) + + # Check results. + expect( + node, + inputs=[r, t, x1, x2, g1, g2, v1, v2, h1, h2], + outputs=[x1_new, x2_new, v1_new, v2_new, h1_new, h2_new], + name="test_adam_multiple", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/add.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/add.py new file mode 100644 index 0000000000000000000000000000000000000000..0a3d9ac9a456c8f302d468bacb91eb99b4e2354f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/add.py @@ -0,0 +1,60 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Add(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Add", + inputs=["x", "y"], + outputs=["sum"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_int8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_int16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint32") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint64") + + @staticmethod + def export_add_broadcast() -> None: + node = onnx.helper.make_node( + "Add", + inputs=["x", "y"], + outputs=["sum"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_bcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/affinegrid.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/affinegrid.py new file mode 100644 index 0000000000000000000000000000000000000000..5eb281fccf83cd37362ae5247b96d2b69a80dc18 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/affinegrid.py @@ -0,0 +1,208 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_affine_grid import ( + apply_affine_transform, + construct_original_grid, +) + + +def create_affine_matrix_3d( + angle1, + angle2, + offset_x, + offset_y, + offset_z, + shear_x, + shear_y, + shear_z, + scale_x, + scale_y, + scale_z, +): + rot_x = np.stack( + [ + np.ones_like(angle1), + np.zeros_like(angle1), + np.zeros_like(angle1), + np.zeros_like(angle1), + np.cos(angle1), + -np.sin(angle1), + np.zeros_like(angle1), + np.sin(angle1), + np.cos(angle1), + ], + axis=-1, + ).reshape(-1, 3, 3) + rot_y = np.stack( + [ + np.cos(angle2), + np.zeros_like(angle2), + np.sin(angle2), + np.zeros_like(angle2), + np.ones_like(angle2), + np.zeros_like(angle2), + -np.sin(angle2), + np.zeros_like(angle2), + np.cos(angle2), + ], + axis=-1, + ).reshape(-1, 3, 3) + shear = np.stack( + [ + np.ones_like(shear_x), + shear_x, + shear_y, + shear_z, + np.ones_like(shear_x), + shear_x, + shear_y, + shear_x, + np.ones_like(shear_x), + ], + axis=-1, + ).reshape(-1, 3, 3) + scale = np.stack( + [ + scale_x, + np.zeros_like(scale_x), + np.zeros_like(scale_x), + np.zeros_like(scale_x), + scale_y, + np.zeros_like(scale_x), + np.zeros_like(scale_x), + np.zeros_like(scale_x), + scale_z, + ], + axis=-1, + ).reshape(-1, 3, 3) + translation = np.transpose(np.array([offset_x, offset_y, offset_z])).reshape( + -1, 1, 3 + ) + rotation_matrix = rot_y @ rot_x @ shear @ scale # (N, 3, 3) + rotation_matrix = np.transpose(rotation_matrix, (0, 2, 1)) + affine_matrix = np.hstack((rotation_matrix, translation)) + affine_matrix = np.transpose(affine_matrix, (0, 2, 1)) + return affine_matrix.astype(np.float32) + + +def create_affine_matrix_2d( + angle1, offset_x, offset_y, shear_x, shear_y, scale_x, scale_y +): + rot = np.stack( + [np.cos(angle1), -np.sin(angle1), np.sin(angle1), np.cos(angle1)], axis=-1 + ).reshape(-1, 2, 2) + shear = np.stack( + [np.ones_like(shear_x), shear_x, shear_y, np.ones_like(shear_x)], axis=-1 + ).reshape(-1, 2, 2) + scale = np.stack( + [scale_x, np.zeros_like(scale_x), np.zeros_like(scale_x), scale_y], axis=-1 + ).reshape(-1, 2, 2) + translation = np.transpose(np.array([offset_x, offset_y])).reshape(-1, 1, 2) + rotation_matrix = rot @ shear @ scale # (N, 3, 3) + rotation_matrix = np.transpose(rotation_matrix, (0, 2, 1)) + affine_matrix = np.hstack((rotation_matrix, translation)) + affine_matrix = np.transpose(affine_matrix, (0, 2, 1)) + return affine_matrix.astype(np.float32) + + +def create_theta_2d(): + angle = np.array([np.pi / 4, np.pi / 3]) + offset_x = np.array([5.0, 2.5]) + offset_y = np.array([-3.3, 1.1]) + shear_x = np.array([-0.5, 0.5]) + shear_y = np.array([0.3, -0.3]) + scale_x = np.array([2.2, 1.1]) + scale_y = np.array([3.1, 0.9]) + return create_affine_matrix_2d( + angle, offset_x, offset_y, shear_x, shear_y, scale_x, scale_y + ) + + +def create_theta_3d(): + angle1 = np.array([np.pi / 4, np.pi / 3]) + angle2 = np.array([np.pi / 6, np.pi / 2]) + offset_x = np.array([5.0, 2.5]) + offset_y = np.array([-3.3, 1.1]) + offset_z = np.array([-1.1, 2.2]) + shear_x = np.array([-0.5, 0.5]) + shear_y = np.array([0.3, -0.3]) + shear_z = np.array([0.7, -0.2]) + scale_x = np.array([2.2, 1.1]) + scale_y = np.array([3.1, 0.9]) + scale_z = np.array([0.5, 1.5]) + + return create_affine_matrix_3d( + angle1, + angle2, + offset_x, + offset_y, + offset_z, + shear_x, + shear_y, + shear_z, + scale_x, + scale_y, + scale_z, + ) + + +class AffineGrid(Base): + @staticmethod + def export_2d_no_reference_evaluator() -> None: + theta_2d = create_theta_2d() + N, C, H, W = len(theta_2d), 3, 5, 6 + data_size = (H, W) + for align_corners in (0, 1): + node = onnx.helper.make_node( + "AffineGrid", + inputs=["theta", "size"], + outputs=["grid"], + align_corners=align_corners, + ) + + original_grid = construct_original_grid(data_size, align_corners) + grid = apply_affine_transform(theta_2d, original_grid) + + test_name = "test_affine_grid_2d" + if align_corners == 1: + test_name += "_align_corners" + expect( + node, + inputs=[theta_2d, np.array([N, C, H, W], dtype=np.int64)], + outputs=[grid], + name=test_name, + ) + + @staticmethod + def export_3d_no_reference_evaluator() -> None: + theta_3d = create_theta_3d() + N, C, D, H, W = len(theta_3d), 3, 4, 5, 6 + data_size = (D, H, W) + for align_corners in (0, 1): + node = onnx.helper.make_node( + "AffineGrid", + inputs=["theta", "size"], + outputs=["grid"], + align_corners=align_corners, + ) + + original_grid = construct_original_grid(data_size, align_corners) + grid = apply_affine_transform(theta_3d, original_grid) + + test_name = "test_affine_grid_3d" + if align_corners == 1: + test_name += "_align_corners" + expect( + node, + inputs=[theta_3d, np.array([N, C, D, H, W], dtype=np.int64)], + outputs=[grid], + name=test_name, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py new file mode 100644 index 0000000000000000000000000000000000000000..2292dd6f5dc0514e1891248e09af4e99f68454b3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py @@ -0,0 +1,31 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ArrayFeatureExtractor(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "ArrayFeatureExtractor", + inputs=["x", "y"], + outputs=["z"], + domain="ai.onnx.ml", + ) + + x = np.arange(12).reshape((3, 4)).astype(np.float32) + y = np.array([0, 1], dtype=np.int64) + z = np.array([[0, 4, 8], [1, 5, 9]], dtype=np.float32).T + expect( + node, + inputs=[x, y], + outputs=[z], + name="test_ai_onnx_ml_array_feature_extractor", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py new file mode 100644 index 0000000000000000000000000000000000000000..fc4c63682507bd8839705165214a3fa8fe80a4fd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.aionnxml.op_binarizer import compute_binarizer + + +class Binarizer(Base): + @staticmethod + def export() -> None: + threshold = 1.0 + node = onnx.helper.make_node( + "Binarizer", + inputs=["X"], + outputs=["Y"], + threshold=threshold, + domain="ai.onnx.ml", + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = compute_binarizer(x, threshold)[0] + + expect(node, inputs=[x], outputs=[y], name="test_ai_onnx_ml_binarizer") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/label_encoder.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/label_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..c8f5177c486c8d4da8a26711183ae6367daff794 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/label_encoder.py @@ -0,0 +1,101 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import make_tensor + + +class LabelEncoder(Base): + @staticmethod + def export_string_int_label_encoder() -> None: + node = onnx.helper.make_node( + "LabelEncoder", + inputs=["X"], + outputs=["Y"], + domain="ai.onnx.ml", + keys_strings=["a", "b", "c"], + values_int64s=[0, 1, 2], + default_int64=42, + ) + x = np.array(["a", "b", "d", "c", "g"]).astype(object) + y = np.array([0, 1, 42, 2, 42]).astype(np.int64) + expect( + node, + inputs=[x], + outputs=[y], + name="test_ai_onnx_ml_label_encoder_string_int", + ) + + node = onnx.helper.make_node( + "LabelEncoder", + inputs=["X"], + outputs=["Y"], + domain="ai.onnx.ml", + keys_strings=["a", "b", "c"], + values_int64s=[0, 1, 2], + ) + x = np.array(["a", "b", "d", "c", "g"]).astype(object) + y = np.array([0, 1, -1, 2, -1]).astype(np.int64) + expect( + node, + inputs=[x], + outputs=[y], + name="test_ai_onnx_ml_label_encoder_string_int_no_default", + ) + + @staticmethod + def export_tensor_based_label_encoder() -> None: + tensor_keys = make_tensor( + "keys_tensor", onnx.TensorProto.STRING, (3,), ["a", "b", "c"] + ) + repeated_string_keys = ["a", "b", "c"] + x = np.array(["a", "b", "d", "c", "g"]).astype(object) + y = np.array([0, 1, 42, 2, 42]).astype(np.int16) + + node = onnx.helper.make_node( + "LabelEncoder", + inputs=["X"], + outputs=["Y"], + domain="ai.onnx.ml", + keys_tensor=tensor_keys, + values_tensor=make_tensor( + "values_tensor", onnx.TensorProto.INT16, (3,), [0, 1, 2] + ), + default_tensor=make_tensor( + "default_tensor", onnx.TensorProto.INT16, (1,), [42] + ), + ) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_ai_onnx_ml_label_encoder_tensor_mapping", + ) + + node = onnx.helper.make_node( + "LabelEncoder", + inputs=["X"], + outputs=["Y"], + domain="ai.onnx.ml", + keys_strings=repeated_string_keys, + values_tensor=make_tensor( + "values_tensor", onnx.TensorProto.INT16, (3,), [0, 1, 2] + ), + default_tensor=make_tensor( + "default_tensor", onnx.TensorProto.INT16, (1,), [42] + ), + ) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_ai_onnx_ml_label_encoder_tensor_value_only_mapping", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/tree_ensemble.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/tree_ensemble.py new file mode 100644 index 0000000000000000000000000000000000000000..72d3edfbfa8c769a6b94bbc1521f019eb7a323bd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ai_onnx_ml/tree_ensemble.py @@ -0,0 +1,123 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import make_tensor + + +class TreeEnsemble(Base): + @staticmethod + def export_tree_ensemble_single_tree() -> None: + node = onnx.helper.make_node( + "TreeEnsemble", + ["X"], + ["Y"], + domain="ai.onnx.ml", + n_targets=2, + membership_values=None, + nodes_missing_value_tracks_true=None, + nodes_hitrates=None, + aggregate_function=1, + post_transform=0, + tree_roots=[0], + nodes_modes=make_tensor( + "nodes_modes", + onnx.TensorProto.UINT8, + (3,), + np.array([0, 0, 0], dtype=np.uint8), + ), + nodes_featureids=[0, 0, 0], + nodes_splits=make_tensor( + "nodes_splits", + onnx.TensorProto.DOUBLE, + (3,), + np.array([3.14, 1.2, 4.2], dtype=np.float64), + ), + nodes_truenodeids=[1, 0, 1], + nodes_trueleafs=[0, 1, 1], + nodes_falsenodeids=[2, 2, 3], + nodes_falseleafs=[0, 1, 1], + leaf_targetids=[0, 1, 0, 1], + leaf_weights=make_tensor( + "leaf_weights", + onnx.TensorProto.DOUBLE, + (4,), + np.array([5.23, 12.12, -12.23, 7.21], dtype=np.float64), + ), + ) + + x = np.array([1.2, 3.4, -0.12, 1.66, 4.14, 1.77], np.float64).reshape(3, 2) + y = np.array([[5.23, 0], [5.23, 0], [0, 12.12]], dtype=np.float64) + expect( + node, + inputs=[x], + outputs=[y], + name="test_ai_onnx_ml_tree_ensemble_single_tree", + ) + + @staticmethod + def export_tree_ensemble_set_membership() -> None: + node = onnx.helper.make_node( + "TreeEnsemble", + ["X"], + ["Y"], + domain="ai.onnx.ml", + n_targets=4, + aggregate_function=1, + membership_values=make_tensor( + "membership_values", + onnx.TensorProto.FLOAT, + (8,), + [1.2, 3.7, 8, 9, np.nan, 12, 7, np.nan], + ), + nodes_missing_value_tracks_true=None, + nodes_hitrates=None, + post_transform=0, + tree_roots=[0], + nodes_modes=make_tensor( + "nodes_modes", + onnx.TensorProto.UINT8, + (3,), + np.array([0, 6, 6], dtype=np.uint8), + ), + nodes_featureids=[0, 0, 0], + nodes_splits=make_tensor( + "nodes_splits", + onnx.TensorProto.FLOAT, + (3,), + np.array([11, 232344.0, np.nan], dtype=np.float32), + ), + nodes_trueleafs=[0, 1, 1], + nodes_truenodeids=[1, 0, 1], + nodes_falseleafs=[1, 0, 1], + nodes_falsenodeids=[2, 2, 3], + leaf_targetids=[0, 1, 2, 3], + leaf_weights=make_tensor( + "leaf_weights", onnx.TensorProto.FLOAT, (4,), [1, 10, 1000, 100] + ), + ) + + x = np.array([1.2, 3.4, -0.12, np.nan, 12, 7], np.float32).reshape(-1, 1) + expected = np.array( + [ + [1, 0, 0, 0], + [0, 0, 0, 100], + [0, 0, 0, 100], + [0, 0, 1000, 0], + [0, 0, 1000, 0], + [0, 10, 0, 0], + ], + dtype=np.float32, + ) + expect( + node, + inputs=[x], + outputs=[expected], + name="test_ai_onnx_ml_tree_ensemble_set_membership", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/and_.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/and_.py new file mode 100644 index 0000000000000000000000000000000000000000..025ce6a3ba3a63afdf8c05a0132edd3969122da8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/and_.py @@ -0,0 +1,76 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class And(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "And", + inputs=["x", "y"], + outputs=["and"], + ) + + # 2d + x = (np.random.randn(3, 4) > 0).astype(bool) + y = (np.random.randn(3, 4) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and2d") + + # 3d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(3, 4, 5) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and3d") + + # 4d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and4d") + + @staticmethod + def export_and_broadcast() -> None: + node = onnx.helper.make_node( + "And", + inputs=["x", "y"], + outputs=["and"], + ) + + # 3d vs 1d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(5) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v1d") + + # 3d vs 2d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(4, 5) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v2d") + + # 4d vs 2d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(5, 6) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v2d") + + # 4d vs 3d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(4, 5, 6) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v3d") + + # 4d vs 4d + x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool) + y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v4d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/argmax.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/argmax.py new file mode 100644 index 0000000000000000000000000000000000000000..ca3e1535952815e9058a1531d545dba2ea808cd5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/argmax.py @@ -0,0 +1,256 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def argmax_use_numpy(data: np.ndarray, axis: int = 0, keepdims: int = 1) -> np.ndarray: + result = np.argmax(data, axis=axis) + if keepdims == 1: + result = np.expand_dims(result, axis) + return result.astype(np.int64) + + +def argmax_use_numpy_select_last_index( + data: np.ndarray, axis: int = 0, keepdims: int = True +) -> np.ndarray: + data = np.flip(data, axis) + result = np.argmax(data, axis=axis) + result = data.shape[axis] - result - 1 + if keepdims: + result = np.expand_dims(result, axis) + return result.astype(np.int64) + + +class ArgMax(Base): + @staticmethod + def export_no_keepdims() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 0 + node = onnx.helper.make_node( + "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # result: [0, 1] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_no_keepdims_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 4] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmax_no_keepdims_random" + ) + + @staticmethod + def export_keepdims() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # result: [[0], [1]] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmax_keepdims_example" + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 1, 4] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmax_keepdims_random" + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", inputs=["data"], outputs=["result"], keepdims=keepdims + ) + + # result: [[1, 1]] + result = argmax_use_numpy(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_default_axis_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [1, 3, 4] + result = argmax_use_numpy(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_default_axis_random", + ) + + @staticmethod + def export_negative_axis_keepdims() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = -1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # result: [[0], [1]] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_negative_axis_keepdims_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 3, 1] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_negative_axis_keepdims_random", + ) + + @staticmethod + def export_no_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 0 + node = onnx.helper.make_node( + "ArgMax", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [1, 1] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_no_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 4] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_no_keepdims_random_select_last_index", + ) + + @staticmethod + def export_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1], [1]] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 1, 4] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_keepdims_random_select_last_index", + ) + + @staticmethod + def export_default_axes_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", + inputs=["data"], + outputs=["result"], + keepdims=keepdims, + select_last_index=True, + ) + + # result: [[1, 1]] + result = argmax_use_numpy_select_last_index(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_default_axis_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [1, 3, 4] + result = argmax_use_numpy_select_last_index(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_default_axis_random_select_last_index", + ) + + @staticmethod + def export_negative_axis_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = -1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1], [1]] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_negative_axis_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 3, 1] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_negative_axis_keepdims_random_select_last_index", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/argmin.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/argmin.py new file mode 100644 index 0000000000000000000000000000000000000000..0279ecdd14b59567c9c7cfd9a40c56f2e7b8235d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/argmin.py @@ -0,0 +1,256 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def argmin_use_numpy(data: np.ndarray, axis: int = 0, keepdims: int = 1) -> np.ndarray: + result = np.argmin(data, axis=axis) + if keepdims == 1: + result = np.expand_dims(result, axis) + return result.astype(np.int64) + + +def argmin_use_numpy_select_last_index( + data: np.ndarray, axis: int = 0, keepdims: int = True +) -> np.ndarray: + data = np.flip(data, axis) + result = np.argmin(data, axis=axis) + result = data.shape[axis] - result - 1 + if keepdims: + result = np.expand_dims(result, axis) + return result.astype(np.int64) + + +class ArgMin(Base): + @staticmethod + def export_no_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 0 + node = onnx.helper.make_node( + "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # The content of result is : [[1, 0]] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_no_keepdims_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 4] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmin_no_keepdims_random" + ) + + @staticmethod + def export_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # The content of result is : [[1], [0]] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmin_keepdims_example" + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 1, 4] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmin_keepdims_random" + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", inputs=["data"], outputs=["result"], keepdims=keepdims + ) + + # The content of result is : [[0], [0]] + result = argmin_use_numpy(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_default_axis_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [1, 3, 4] + result = argmin_use_numpy(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_default_axis_random", + ) + + @staticmethod + def export_negative_axis_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = -1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # The content of result is : [[1], [0]] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_negative_axis_keepdims_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 3, 1] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_negative_axis_keepdims_random", + ) + + @staticmethod + def export_no_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 0 + node = onnx.helper.make_node( + "ArgMin", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1, 0]] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_no_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 4] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_no_keepdims_random_select_last_index", + ) + + @staticmethod + def export_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1], [0]] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 1, 4] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_keepdims_random_select_last_index", + ) + + @staticmethod + def export_default_axes_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", + inputs=["data"], + outputs=["result"], + keepdims=keepdims, + select_last_index=True, + ) + + # result: [[0, 0]] + result = argmin_use_numpy_select_last_index(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_default_axis_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [1, 3, 4] + result = argmin_use_numpy_select_last_index(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_default_axis_random_select_last_index", + ) + + @staticmethod + def export_negative_axis_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = -1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1], [0]] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_negative_axis_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 3, 1] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_negative_axis_keepdims_random_select_last_index", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/asin.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/asin.py new file mode 100644 index 0000000000000000000000000000000000000000..8db0e38e0471e3d9b45f3e778e6ba9b5ea2fe9f1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/asin.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Asin(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Asin", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-0.5, 0, 0.5]).astype(np.float32) + y = np.arcsin(x) + expect(node, inputs=[x], outputs=[y], name="test_asin_example") + + x = np.random.rand(3, 4, 5).astype(np.float32) + y = np.arcsin(x) + expect(node, inputs=[x], outputs=[y], name="test_asin") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/asinh.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/asinh.py new file mode 100644 index 0000000000000000000000000000000000000000..3023b9dac253eb2c58b314dc350428a3695d0afa --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/asinh.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Asinh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Asinh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.arcsinh(x) # expected output [-0.88137358, 0., 0.88137358] + expect(node, inputs=[x], outputs=[y], name="test_asinh_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.arcsinh(x) + expect(node, inputs=[x], outputs=[y], name="test_asinh") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/atan.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/atan.py new file mode 100644 index 0000000000000000000000000000000000000000..8d606b84f85e979a7d99b6ab991b54d40542aa4d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/atan.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Atan(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Atan", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.arctan(x) + expect(node, inputs=[x], outputs=[y], name="test_atan_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.arctan(x) + expect(node, inputs=[x], outputs=[y], name="test_atan") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/atanh.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/atanh.py new file mode 100644 index 0000000000000000000000000000000000000000..35428c05836fd01b01de4ef7e88b25276d7923bc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/atanh.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Atanh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Atanh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-0.5, 0, 0.5]).astype(np.float32) + y = np.arctanh(x) # expected output [-0.54930615, 0., 0.54930615] + expect(node, inputs=[x], outputs=[y], name="test_atanh_example") + + x = np.random.uniform(0.0, 1.0, (3, 4, 5)).astype(np.float32) + y = np.arctanh(x) + expect(node, inputs=[x], outputs=[y], name="test_atanh") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/attention.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/attention.py new file mode 100644 index 0000000000000000000000000000000000000000..d7f3e207b7e7f623569929b1f8039dc1896ade12 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/attention.py @@ -0,0 +1,2017 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_attention import _compute_attention + + +class Attention(Base): + @staticmethod + def export_attention() -> None: + node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"]) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_fp16() -> None: + node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"]) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float16) + K = np.random.rand(2, 3, 6, 8).astype(np.float16) + V = np.random.rand(2, 3, 6, 8).astype(np.float16) + + Y, _, _, _ = _compute_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_fp16", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_gqa() -> None: + node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"]) + + Q = np.random.rand(2, 9, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_gqa", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_diff_head_sizes() -> None: + node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"]) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_diff_heads_sizes", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_scaled() -> None: + scale = 1e-2 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + scale=scale, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V, scale=scale) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_scaled", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_gqa_scaled() -> None: + scale = 1e-2 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + scale=scale, + ) + + Q = np.random.rand(2, 9, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V, scale=scale) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_gqa_scaled", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_diff_head_sizes_scaled() -> None: + scale = 1e-2 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + scale=scale, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V, scale=scale) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_diff_heads_sizes_scaled", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_causal() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + is_causal=1, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V, is_causal=1) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_gqa_causal() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + is_causal=1, + ) + + Q = np.random.rand(2, 9, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V, is_causal=1) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_gqa_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_diff_head_sizes_causal() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + is_causal=1, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + is_causal=1, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_diff_heads_sizes_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_attn_mask() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_attn_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_attn_3d_mask() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 1, 4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_attn_mask_3d", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_attn_3d_mask_causal() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + is_causal=1, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 1, 4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + is_causal=1, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_attn_mask_3d_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_attn_4d_mask() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 3, 4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_attn_mask_4d", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_attn_4d_mask_causal() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + is_causal=1, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 3, 4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + is_causal=1, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_attn_mask_4d_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_attn_mask_bool() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(bool) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_attn_mask_bool", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_attn_mask_bool_4d() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 3, 4, 6).astype(bool) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_attn_mask_bool_4d", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_gqa_attn_mask() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + ) + + Q = np.random.rand(2, 9, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_gqa_attn_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_diff_head_sizes_attn_mask() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_diff_heads_sizes_attn_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_past_and_present() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_4d_with_past_and_present", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_gqa_with_past_and_present() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 9, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_4d_gqa_with_past_and_present", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_gqa_with_past_and_present_fp16() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 9, 4, 8).astype(np.float16) + K = np.random.rand(2, 3, 6, 8).astype(np.float16) + V = np.random.rand(2, 3, 6, 8).astype(np.float16) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float16) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float16) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float16) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_4d_gqa_with_past_and_present_fp16", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_diff_head_sizes_with_past_and_present() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_4d_diff_heads_with_past_and_present", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_diff_head_sizes_with_past_and_present_mask3D() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_4d_diff_heads_with_past_and_present_mask3d", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_diff_head_sizes_with_past_and_present_mask4D() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_4d_diff_heads_with_past_and_present_mask4d", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_softcap() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + softcap=2.0, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V, softcap=2.0) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_softcap", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_gqa_softcap() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + softcap=2.0, + ) + + Q = np.random.rand(2, 9, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, _ = _compute_attention(Q, K, V, softcap=2.0) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_gqa_softcap", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_diff_head_sizes_softcap() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + softcap=2.0, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + softcap=2.0, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_4d_diff_heads_sizes_softcap", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_qk_matmul() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y", "", "", "qk_matmul_output"], + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + + Y, _, _, qk_matmul_output = _compute_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y, qk_matmul_output], + name="test_attention_4d_with_qk_matmul", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_qk_matmul_bias() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y", "", "", "qk_matmul_output"], + qk_matmul_output_mode=2, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + qk_matmul_output_mode=2, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y, qk_matmul_output], + name="test_attention_4d_with_qk_matmul_bias", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_qk_matmul_softcap() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y", "", "", "qk_matmul_output"], + softcap=2.0, + qk_matmul_output_mode=1, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + softcap=2.0, + qk_matmul_output_mode=1, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y, qk_matmul_output], + name="test_attention_4d_with_qk_matmul_softcap", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_qk_matmul_softmax() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y", "", "", "qk_matmul_output"], + qk_matmul_output_mode=3, + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + qk_matmul_output_mode=3, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y, qk_matmul_output], + name="test_attention_4d_with_qk_matmul_softmax", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_past_and_present_qk_matmul_bias() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + qk_matmul_output_mode=2, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + qk_matmul_output_mode=2, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_4d_with_past_and_present_qk_matmul_bias", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_past_and_present_qk_matmul_bias_3d_mask() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + qk_matmul_output_mode=2, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + qk_matmul_output_mode=2, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_past_and_present_qk_matmul_bias_4d_mask() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + qk_matmul_output_mode=2, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + qk_matmul_output_mode=2, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_past_and_present_qk_matmul_bias_3d_mask_causal() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + qk_matmul_output_mode=2, + is_causal=1, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + qk_matmul_output_mode=2, + is_causal=1, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_past_and_present_qk_matmul_bias_4d_mask_causal() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + qk_matmul_output_mode=2, + is_causal=1, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + qk_matmul_output_mode=2, + is_causal=1, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_with_past_and_present_qk_matmul() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 8).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_4d_with_past_and_present_qk_matmul", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_gqa() -> None: + q_num_heads, kv_num_heads = 9, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 72).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_gqa", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_diff_head_sizes() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 30).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_diff_heads_sizes", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_scaled() -> None: + scale = 1e-2 + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + scale=scale, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + scale=scale, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_scaled", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_gqa_scaled() -> None: + scale = 1e-2 + q_num_heads, kv_num_heads = 9, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + scale=scale, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 72).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + scale=scale, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_gqa_scaled", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_diff_head_sizes_scaled() -> None: + scale = 1e-2 + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + scale=scale, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 30).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + scale=scale, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_diff_heads_sizes_scaled", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_causal() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + is_causal=1, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + is_causal=1, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_gqa_causal() -> None: + q_num_heads, kv_num_heads = 9, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + is_causal=1, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 72).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + is_causal=1, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_gqa_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_diff_head_sizes_causal() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + is_causal=1, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 30).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + is_causal=1, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_diff_heads_sizes_causal", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_attn_mask() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_3d_attn_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_gqa_attn_mask() -> None: + q_num_heads, kv_num_heads = 9, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 72).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_3d_gqa_attn_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_diff_head_sizes_attn_mask() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 30).astype(np.float32) + attn_mask = np.random.rand(4, 6).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_3d_diff_heads_sizes_attn_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_softcap() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + softcap=3.0, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + softcap=3.0, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_softcap", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_gqa_softcap() -> None: + q_num_heads, kv_num_heads = 9, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + softcap=3.0, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 72).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + softcap=3.0, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_gqa_softcap", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_diff_head_sizes_softcap() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + softcap=3.0, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 30).astype(np.float32) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + softcap=3.0, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_diff_heads_sizes_softcap", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_with_past_and_present() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_3d_with_past_and_present", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_gqa_with_past_and_present() -> None: + q_num_heads, kv_num_heads = 9, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 4, 72).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_3d_gqa_with_past_and_present", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_diff_head_sizes_with_past_and_present() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 30).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32) + + Y, present_key, present_value, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value], + name="test_attention_3d_diff_heads_with_past_and_present", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_with_past_and_present_qk_matmul() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_3d_with_past_and_present_qk_matmul", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_with_past_and_present_qk_matmul_bias() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + qk_matmul_output_mode=2, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + qk_matmul_output_mode=2, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_3d_with_past_and_present_qk_matmul_bias", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_with_past_and_present_qk_matmul_softcap() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + softcap=2.0, + qk_matmul_output_mode=1, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + softcap=2.0, + qk_matmul_output_mode=1, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_3d_with_past_and_present_qk_matmul_softcap", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_with_past_and_present_qk_matmul_softmax() -> None: + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"], + outputs=["Y", "present_key", "present_value", "qk_matmul_output"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + qk_matmul_output_mode=3, + ) + + past_sequence_length = 12 + Q = np.random.rand(2, 4, 24).astype(np.float32) + K = np.random.rand(2, 6, 24).astype(np.float32) + V = np.random.rand(2, 6, 24).astype(np.float32) + attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32) + past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32) + + Y, present_key, present_value, qk_matmul_output = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + past_key=past_key, + past_value=past_value, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + qk_matmul_output_mode=3, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, past_key, past_value], + outputs=[Y, present_key, present_value, qk_matmul_output], + name="test_attention_3d_with_past_and_present_qk_matmul_softmax", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_3d_transpose_verification() -> None: + """Test case to verify correct 3D to 4D transpose behavior. + + This test verifies that 3D inputs are correctly reshaped and transposed + according to the ONNX specification: + [batch_size, seq_length, hidden_size] -> + [batch_size, seq_length, num_heads, head_size] -> + [batch_size, num_heads, seq_length, head_size] + """ + q_num_heads, kv_num_heads = 3, 3 + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V"], + outputs=["Y"], + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + # Test inputs that will clearly demonstrate the transpose behavior + batch_size = 1 + q_seq_length = 2 + kv_seq_length = 2 + head_size = 4 + q_hidden_size = q_num_heads * head_size # 3 * 4 = 12 + kv_hidden_size = kv_num_heads * head_size # 3 * 4 = 12 + + # Create structured inputs to verify correct transpose behavior + # Q has a pattern where each position in hidden dimension has a specific value + Q = np.zeros((batch_size, q_seq_length, q_hidden_size), dtype=np.float32) + # Fill Q with pattern: head0=[1,1,1,1], head1=[2,2,2,2], head2=[3,3,3,3] + for head in range(q_num_heads): + start_idx = head * head_size + end_idx = start_idx + head_size + Q[0, :, start_idx:end_idx] = float(head + 1) + + K = np.ones((batch_size, kv_seq_length, kv_hidden_size), dtype=np.float32) * 0.1 + V = np.ones((batch_size, kv_seq_length, kv_hidden_size), dtype=np.float32) * 0.1 + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + q_num_heads=q_num_heads, + kv_num_heads=kv_num_heads, + ) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_attention_3d_transpose_verification", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_4d_diff_heads_mask4d_padded_kv() -> None: + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask", "", "", "nonpad_kv_seqlen"], + outputs=["Y"], + ) + + Q = np.random.rand(2, 3, 4, 8).astype(np.float32) + K = np.random.rand(2, 3, 6, 8).astype(np.float32) + V = np.random.rand(2, 3, 6, 10).astype(np.float32) + attn_mask = np.random.rand(2, 3, 4, 4).astype(np.float32) + nonpad_kv_seqlen = np.array([3, 4], dtype=np.int64) + + Y, _, _, _ = _compute_attention( + Q, + K, + V, + attn_mask=attn_mask, + nonpad_kv_seqlen=nonpad_kv_seqlen, + ) + + expect( + node, + inputs=[Q, K, V, attn_mask, nonpad_kv_seqlen], + outputs=[Y], + name="test_attention_4d_diff_heads_mask4d_padded_kv", + opset_imports=[onnx.helper.make_opsetid("", 24)], + ) + + @staticmethod + def export_attention_softcap_with_neginf_mask() -> None: + """Softcap + -inf mask: verifies softcap is applied BEFORE mask/bias. + + If ordering were wrong (mask then softcap), tanh(-inf/softcap) = -1, + so softcap * tanh(-inf/softcap) = -softcap (finite). That leaks + probability to masked positions. With correct ordering (softcap then + mask), the -inf mask values survive to softmax and yield zero weight. + """ + np.random.seed(42) + B, H, S_q, S_kv, D = 1, 1, 4, 6, 8 + + Q = np.random.rand(B, H, S_q, D).astype(np.float32) + K = np.random.rand(B, H, S_kv, D).astype(np.float32) + V = np.random.rand(B, H, S_kv, D).astype(np.float32) + + # All Q positions are blocked from KV positions 4 and 5. + attn_mask = np.zeros((S_q, S_kv), dtype=np.float32) + attn_mask[:, 4:] = -np.inf + + softcap = 0.5 + + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + softcap=softcap, + ) + + Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask, softcap=softcap) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_softcap_neginf_mask", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) + + @staticmethod + def export_attention_softcap_with_neginf_mask_poison() -> None: + """Softcap + -inf mask + poison values at masked KV positions. + + V has value 1000 at the masked positions (4 and 5). With correct + ordering the output stays in [0, 1] because the mask zeros out those + positions. With wrong ordering the output explodes (> 50), making + the failure obvious even with loose tolerances. + """ + np.random.seed(42) + B, H, S_q, S_kv, D = 1, 1, 4, 6, 8 + + Q = np.random.rand(B, H, S_q, D).astype(np.float32) + K = np.random.rand(B, H, S_kv, D).astype(np.float32) + V = np.random.rand(B, H, S_kv, D).astype(np.float32) + + # Block all Q positions from KV positions 4 and 5. + attn_mask = np.zeros((S_q, S_kv), dtype=np.float32) + attn_mask[:, 4:] = -np.inf + + # Poison: if attention leaks to masked positions, output >> 1. + V[:, :, 4:, :] = 1000.0 + + softcap = 0.5 + + node = onnx.helper.make_node( + "Attention", + inputs=["Q", "K", "V", "attn_mask"], + outputs=["Y"], + softcap=softcap, + ) + + Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask, softcap=softcap) + + expect( + node, + inputs=[Q, K, V, attn_mask], + outputs=[Y], + name="test_attention_4d_softcap_neginf_mask_poison", + opset_imports=[onnx.helper.make_opsetid("", 23)], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/averagepool.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/averagepool.py new file mode 100644 index 0000000000000000000000000000000000000000..61044f6a39a8000f8bd3f135410a5e31b0a93152 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/averagepool.py @@ -0,0 +1,695 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_pool_common import ( + get_output_shape_auto_pad, + get_output_shape_explicit_padding, + get_pad_shape, + pool, +) + + +class AveragePool(Base): + @staticmethod + def export_averagepool_2d_precomputed_pads() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array( + [ + [ + [ + [7, 7.5, 8, 8.5, 9], + [9.5, 10, 10.5, 11, 11.5], + [12, 12.5, 13, 13.5, 14], + [14.5, 15, 15.5, 16, 16.5], + [17, 17.5, 18, 18.5, 19], + ] + ] + ] + ).astype(np.float32) + + expect( + node, inputs=[x], outputs=[y], name="test_averagepool_2d_precomputed_pads" + ) + + @staticmethod + def export_averagepool_2d_precomputed_pads_count_include_pad() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + count_include_pad=1, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array( + [ + [ + [ + [2.5200, 3.6000, 4.8000, 4.0800, 3.2400], + [4.5600, 6.4000, 8.4000, 7.0400, 5.5200], + [7.2000, 10.0000, 13.0000, 10.8000, 8.4000], + [6.9600, 9.6000, 12.4000, 10.2400, 7.9200], + [6.1200, 8.4000, 10.8000, 8.8800, 6.8400], + ] + ] + ] + ).astype(np.float32) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_precomputed_pads_count_include_pad", + ) + + @staticmethod + def export_averagepool_2d_precomputed_strides() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[4, 6], [14, 16]]]]).astype(np.float32) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_precomputed_strides", + ) + + @staticmethod + def export_averagepool_2d_precomputed_same_upper() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 3, 3] + pad_shape: [2, 2] -> [1, 1, 1, 1] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[2, 2], + auto_pad="SAME_UPPER", + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[4, 5.5, 7], [11.5, 13, 14.5], [19, 20.5, 22]]]]).astype( + np.float32 + ) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_precomputed_same_upper", + ) + + @staticmethod + def export_averagepool_1d_default() -> None: + """input_shape: [1, 3, 32] + output_shape: [1, 3, 31] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2], + ) + x = np.random.randn(1, 3, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = [2] + strides = [1] + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_1d_default") + + @staticmethod + def export_averagepool_2d_default() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 31, 31] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = (2, 2) + strides = (1, 1) + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_default") + + @staticmethod + def export_averagepool_3d_default() -> None: + """input_shape: [1, 3, 32, 32, 32] + output_shape: [1, 3, 31, 31, 31] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + ) + x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = [2, 2, 2] + strides = [1, 1, 1] + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_3d_default") + + @staticmethod + def export_averagepool_2d_same_upper() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [0, 1, 0, 1] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_UPPER", + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape_auto_pad( + "SAME_UPPER", x_shape[2:], kernel_shape, strides + ) + pad_shape = get_pad_shape( + "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_top = pad_shape[0] // 2 + pad_bottom = pad_shape[0] - pad_top + pad_left = pad_shape[1] // 2 + pad_right = pad_shape[1] - pad_left + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + pads = (pad_top, pad_left, pad_bottom, pad_right) + y = pool( + padded, + x_shape, + kernel_shape, + strides, + out_shape, + "AVG", + pads_required=pads, + pads=pads, + ) + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_upper") + + @staticmethod + def export_averagepool_2d_same_lower() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [1, 0, 1, 0] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_LOWER", + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape_auto_pad( + "SAME_LOWER", x_shape[2:], kernel_shape, strides + ) + pad_shape = get_pad_shape( + "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_bottom = pad_shape[0] // 2 + pad_top = pad_shape[0] - pad_bottom + pad_right = pad_shape[1] // 2 + pad_left = pad_shape[1] - pad_right + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + pads = (pad_top, pad_left, pad_bottom, pad_right) + y = pool( + padded, + x_shape, + kernel_shape, + strides, + out_shape, + "AVG", + pads_required=pads, + pads=pads, + ) + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_lower") + + @staticmethod + def export_averagepool_2d_pads() -> None: + """input_shape: [1, 3, 28, 28] + output_shape: [1, 3, 30, 30] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[2, 2, 2, 2], + ) + x = np.random.randn(1, 3, 28, 28).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (3, 3) + strides = (1, 1) + pad_bottom = 2 + pad_top = 2 + pad_right = 2 + pad_left = 2 + pads = [pad_top, pad_left, pad_bottom, pad_right] + out_shape, extra_pads = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides, ceil_mode=False + ) + padded = np.pad( + x, + ( + (0, 0), + (0, 0), + (extra_pads[0], extra_pads[2]), + (extra_pads[1], extra_pads[3]), + ), + mode="constant", + constant_values=np.nan, + ) + y = pool( + padded, + x_shape, + kernel_shape, + strides, + out_shape, + "AVG", + pads_required=extra_pads, + pads=pads, + ) + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_pads") + + @staticmethod + def export_averagepool_2d_pads_count_include_pad() -> None: + """input_shape: [1, 3, 28, 28] + output_shape: [1, 3, 30, 30] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[2, 2, 2, 2], + count_include_pad=1, + ) + x = np.random.randn(1, 3, 28, 28).astype(np.float32) + x_shape = np.shape(x) + dilations = (1, 1) + kernel_shape = (3, 3) + strides = (1, 1) + pad_bottom = 2 + pad_top = 2 + pad_right = 2 + pad_left = 2 + pads = [pad_top, pad_left, pad_bottom, pad_right] + out_shape, extra_pads = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides, dilations, ceil_mode=False + ) + padded = np.pad( + x, + ( + (0, 0), + (0, 0), + (extra_pads[0], extra_pads[2]), + (extra_pads[1], extra_pads[3]), + ), + mode="constant", + constant_values=0, + ) + y = pool( + padded, + x_shape, + kernel_shape, + strides, + out_shape, + "AVG", + pads_required=extra_pads, + pads=pads, + count_include_pad=1, + ) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_pads_count_include_pad", + ) + + @staticmethod + def export_averagepool_2d_strides() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 10, 10] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + strides=[3, 3], + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (5, 5) + strides = (3, 3) + out_shape, pads = get_output_shape_explicit_padding( + None, x_shape[2:], kernel_shape, strides, ceil_mode=False + ) + padded = x + y = pool( + padded, + x_shape, + kernel_shape, + strides, + out_shape, + "AVG", + pads_required=pads, + pads=None, + ) + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_strides") + + @staticmethod + def export_averagepool_2d_ceil() -> None: + """input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[2, 2], + ceil_mode=True, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[6, 7.5], [12, 13.5]]]]).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_ceil") + + @staticmethod + def export_averagepool_2d_ceil_last_window_starts_on_pad() -> None: + """input_shape: [1, 3, 2, 2] + output_shape: [1, 3, 1, 1] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[3, 3], + pads=[1, 1, 1, 1], + ceil_mode=True, + count_include_pad=1, + ) + x = np.array( + [ + [ + [[0.8580, 0.0786], [0.2692, 0.1537]], + [[0.8816, 0.4353], [0.5772, 0.6623]], + [[0.9067, 0.9483], [0.5970, 0.7630]], + ] + ] + ).astype(np.float32) + y = np.array([[[[0.1511]], [[0.2841]], [[0.3572]]]]).astype(np.float32) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_ceil_last_window_starts_on_pad", + ) + + @staticmethod + def export_averagepool_2d_dilations() -> None: + """input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[1, 1], + dilations=[2, 2], + ceil_mode=True, + ) + + # input shape: [1, 1, 4, 4] + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + + y = np.array([[[[6, 7], [10, 11]]]]).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_dilations") + + @staticmethod + def export_averagepool_3d_dilations() -> None: + """input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + strides=[1, 1, 1], + dilations=[2, 2, 2], + ceil_mode=True, + ) + + # input shape: [1, 1, 4, 4, 4] + x = np.array( + [ + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + ] + ] + ] + ).astype(np.float32) + + y = np.array([[[[[6, 7], [10, 11]], [[6, 7], [10, 11]]]]]).astype(np.float32) + + expect( + node, inputs=[x], outputs=[y], name="test_averagepool_3d_dilations_small" + ) + + @staticmethod + def export_averagepool_3d_dilations_large() -> None: + x_shape = (32, 32, 32) + dilations = (2, 2, 2) + kernel_shape = (5, 5, 5) + strides = (3, 3, 3) + count_include_pad = 0 + + for count_include_pad in (0, 1): + for ceil_mode in (True, False): + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=kernel_shape, + strides=strides, + dilations=dilations, + count_include_pad=count_include_pad, + ceil_mode=ceil_mode, + ) + + x = np.random.randn(1, 1, *x_shape).astype(np.float32) + out_shape, extra_pads = get_output_shape_explicit_padding( + None, + x_shape, + kernel_shape, + strides, + dilations=dilations, + ceil_mode=ceil_mode, + ) + padded = np.pad( + x, + ( + (0, 0), + (0, 0), + (extra_pads[0], extra_pads[3]), + (extra_pads[1], extra_pads[4]), + (extra_pads[2], extra_pads[5]), + ), + mode="constant", + constant_values=0 if count_include_pad == 1 else np.nan, + ) + y = pool( + padded, + (1, 1, *x_shape), + kernel_shape, + strides, + out_shape, + "AVG", + pads_required=extra_pads, + pads=None, + dilations=dilations, + count_include_pad=count_include_pad, + ) + + test_name = f"test_averagepool_3d_dilations_large_count_include_pad_is_{count_include_pad}_ceil_mode_is_{ceil_mode}" + expect(node, inputs=[x], outputs=[y], name=test_name) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/batchnorm.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/batchnorm.py new file mode 100644 index 0000000000000000000000000000000000000000..83e321f7dafc7831b79e85de47a35efb9bf8e4dd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/batchnorm.py @@ -0,0 +1,137 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def _batchnorm_test_mode(x, s, bias, mean, var, epsilon=1e-5): + dims_x = len(x.shape) + dim_ones = (1,) * (dims_x - 2) + s = s.reshape(-1, *dim_ones) + bias = bias.reshape(-1, *dim_ones) + mean = mean.reshape(-1, *dim_ones) + var = var.reshape(-1, *dim_ones) + return s * (x - mean) / np.sqrt(var + epsilon) + bias + + +def _batchnorm_training_mode(x, s, bias, mean, var, momentum=0.9, epsilon=1e-5): + axis = tuple(np.delete(np.arange(len(x.shape)), 1)) + saved_mean = x.mean(axis=axis) + saved_var = x.var(axis=axis) + output_mean = mean * momentum + saved_mean * (1 - momentum) + output_var = var * momentum + saved_var * (1 - momentum) + y = _batchnorm_test_mode(x, s, bias, saved_mean, saved_var, epsilon=epsilon) + return y.astype(np.float32), output_mean, output_var + + +class BatchNormalization(Base): + @staticmethod + def export() -> None: + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + mean = np.random.randn(3).astype(np.float32) + var = np.random.rand(3).astype(np.float32) + y = _batchnorm_test_mode(x, s, bias, mean, var).astype(np.float32) + + node = onnx.helper.make_node( + "BatchNormalization", + inputs=["x", "s", "bias", "mean", "var"], + outputs=["y"], + ) + + # output size: (2, 3, 4, 5) + expect( + node, + inputs=[x, s, bias, mean, var], + outputs=[y], + name="test_batchnorm_example", + ) + + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + mean = np.random.randn(3).astype(np.float32) + var = np.random.rand(3).astype(np.float32) + epsilon = 1e-2 + y = _batchnorm_test_mode(x, s, bias, mean, var, epsilon).astype(np.float32) + + node = onnx.helper.make_node( + "BatchNormalization", + inputs=["x", "s", "bias", "mean", "var"], + outputs=["y"], + epsilon=epsilon, + ) + + # output size: (2, 3, 4, 5) + expect( + node, + inputs=[x, s, bias, mean, var], + outputs=[y], + name="test_batchnorm_epsilon", + ) + + @staticmethod + def export_train() -> None: + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + mean = np.random.randn(3).astype(np.float32) + var = np.random.rand(3).astype(np.float32) + # using np.bool(1) while generating test data with "'bool' object has no attribute 'dtype'" + # working around by using np.byte(1).astype(bool) + training_mode = 1 + y, output_mean, output_var = _batchnorm_training_mode(x, s, bias, mean, var) + + node = onnx.helper.make_node( + "BatchNormalization", + inputs=["x", "s", "bias", "mean", "var"], + outputs=["y", "output_mean", "output_var"], + training_mode=training_mode, + ) + + # output size: (2, 3, 4, 5) + expect( + node, + inputs=[x, s, bias, mean, var], + outputs=[y, output_mean, output_var], + name="test_batchnorm_example_training_mode", + ) + + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + mean = np.random.randn(3).astype(np.float32) + var = np.random.rand(3).astype(np.float32) + training_mode = 1 + momentum = 0.9 + epsilon = 1e-2 + y, output_mean, output_var = _batchnorm_training_mode( + x, s, bias, mean, var, momentum, epsilon + ) + + node = onnx.helper.make_node( + "BatchNormalization", + inputs=["x", "s", "bias", "mean", "var"], + outputs=["y", "output_mean", "output_var"], + epsilon=epsilon, + training_mode=training_mode, + ) + + # output size: (2, 3, 4, 5) + expect( + node, + inputs=[x, s, bias, mean, var], + outputs=[y, output_mean, output_var], + name="test_batchnorm_epsilon_training_mode", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bernoulli.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bernoulli.py new file mode 100644 index 0000000000000000000000000000000000000000..164ec9e19f937998e216ffaaf0aae4db148d11df --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bernoulli.py @@ -0,0 +1,59 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def bernoulli_reference_implementation(x, dtype): + # binomial n = 1 equal bernoulli + # This example and test-case is for informational purpose. The generator operator is + # non-deterministic and may not produce the same values in different implementations + # even if a seed is specified. + return np.random.binomial(1, p=x).astype(dtype) + + +class Bernoulli(Base): + @staticmethod + def export_bernoulli_without_dtype() -> None: + node = onnx.helper.make_node( + "Bernoulli", + inputs=["x"], + outputs=["y"], + ) + + x = np.random.uniform(0.0, 1.0, 10).astype(float) + y = bernoulli_reference_implementation(x, float) + expect(node, inputs=[x], outputs=[y], name="test_bernoulli") + + @staticmethod + def export_bernoulli_with_dtype() -> None: + node = onnx.helper.make_node( + "Bernoulli", + inputs=["x"], + outputs=["y"], + dtype=onnx.TensorProto.DOUBLE, + ) + + x = np.random.uniform(0.0, 1.0, 10).astype(np.float32) + y = bernoulli_reference_implementation(x, float) + expect(node, inputs=[x], outputs=[y], name="test_bernoulli_double") + + @staticmethod + def export_bernoulli_with_seed() -> None: + seed = float(0) + node = onnx.helper.make_node( + "Bernoulli", + inputs=["x"], + outputs=["y"], + seed=seed, + ) + + x = np.random.uniform(0.0, 1.0, 10).astype(np.float32) + y = bernoulli_reference_implementation(x, np.float32) + expect(node, inputs=[x], outputs=[y], name="test_bernoulli_seed") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitcast.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitcast.py new file mode 100644 index 0000000000000000000000000000000000000000..15f2a3b5bc80d18058795b3757b5e54e265aeea1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitcast.py @@ -0,0 +1,147 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class BitCast(Base): + @staticmethod + def export_bitcast_float32_to_int32() -> None: + """Test bitcasting from float32 to int32 (same size).""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.INT32, + ) + x = np.array([1.0, -2.5, 3.75], dtype=np.float32) + y = x.view(np.int32) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_float32_to_int32") + + @staticmethod + def export_bitcast_int32_to_float32() -> None: + """Test bitcasting from int32 to float32 (same size).""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.FLOAT, + ) + x = np.array([1065353216, -1071644672, 1081081856], dtype=np.int32) + y = x.view(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_int32_to_float32") + + @staticmethod + def export_bitcast_float64_to_int64() -> None: + """Test bitcasting from float64 to int64 (same size).""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.INT64, + ) + x = np.array([1.0, -2.5, 3.75], dtype=np.float64) + y = x.view(np.int64) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_float64_to_int64") + + @staticmethod + def export_bitcast_int64_to_float64() -> None: + """Test bitcasting from int64 to float64 (same size).""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.DOUBLE, + ) + x = np.array( + [4607182418800017408, -4611686018427387904, 4614256656552045184], + dtype=np.int64, + ) + y = x.view(np.float64) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_int64_to_float64") + + @staticmethod + def export_bitcast_uint32_to_int32() -> None: + """Test bitcasting from uint32 to int32 (same size, different signedness).""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.INT32, + ) + x = np.array([4294967295, 2147483648, 2147483647], dtype=np.uint32) + y = x.view(np.int32) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_uint32_to_int32") + + @staticmethod + def export_bitcast_2d_float32_to_int32() -> None: + """Test bitcasting 2D array from float32 to int32.""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.INT32, + ) + x = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32) + y = x.view(np.int32) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_2d_float32_to_int32") + + @staticmethod + def export_bitcast_int8_to_uint8() -> None: + """Test bitcasting from int8 to uint8 (same size, different signedness).""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.UINT8, + ) + x = np.array([-1, -128, 127, 0], dtype=np.int8) + y = x.view(np.uint8) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_int8_to_uint8") + + @staticmethod + def export_bitcast_scalar_float32_to_int32() -> None: + """Test bitcasting scalar from float32 to int32.""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.INT32, + ) + x = np.array(1.0, dtype=np.float32) + y = x.view(np.int32) + expect( + node, inputs=[x], outputs=[y], name="test_bitcast_scalar_float32_to_int32" + ) + + @staticmethod + def export_bitcast_uint16_to_int16() -> None: + """Test bitcasting from uint16 to int16 (same size, different signedness).""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.INT16, + ) + x = np.array([1, 32768, 65535], dtype=np.uint16) + y = x.view(np.int16) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_uint16_to_int16") + + @staticmethod + def export_bitcast_bool_to_uint8() -> None: + """Test bitcasting from bool to uint8 (same size).""" + node = onnx.helper.make_node( + "BitCast", + inputs=["x"], + outputs=["y"], + to=onnx.TensorProto.UINT8, + ) + x = np.array([True, False, True, False], dtype=np.bool_) + y = x.view(np.uint8) + expect(node, inputs=[x], outputs=[y], name="test_bitcast_bool_to_uint8") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitshift.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitshift.py new file mode 100644 index 0000000000000000000000000000000000000000..4eeb4ba7b235b534db72ed48c0ff7139eb263a62 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitshift.py @@ -0,0 +1,100 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class BitShift(Base): + @staticmethod + def export_right_unit8() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT" + ) + + x = np.array([16, 4, 1]).astype(np.uint8) + y = np.array([1, 2, 3]).astype(np.uint8) + z = x >> y # expected output [8, 1, 0] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint8") + + @staticmethod + def export_right_unit16() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT" + ) + + x = np.array([16, 4, 1]).astype(np.uint16) + y = np.array([1, 2, 3]).astype(np.uint16) + z = x >> y # expected output [8, 1, 0] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint16") + + @staticmethod + def export_right_unit32() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT" + ) + + x = np.array([16, 4, 1]).astype(np.uint32) + y = np.array([1, 2, 3]).astype(np.uint32) + z = x >> y # expected output [8, 1, 0] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint32") + + @staticmethod + def export_right_unit64() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT" + ) + + x = np.array([16, 4, 1]).astype(np.uint64) + y = np.array([1, 2, 3]).astype(np.uint64) + z = x >> y # expected output [8, 1, 0] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint64") + + @staticmethod + def export_left_unit8() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT" + ) + + x = np.array([16, 4, 1]).astype(np.uint8) + y = np.array([1, 2, 3]).astype(np.uint8) + z = x << y # expected output [32, 16, 8] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint8") + + @staticmethod + def export_left_unit16() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT" + ) + + x = np.array([16, 4, 1]).astype(np.uint16) + y = np.array([1, 2, 3]).astype(np.uint16) + z = x << y # expected output [32, 16, 8] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint16") + + @staticmethod + def export_left_unit32() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT" + ) + + x = np.array([16, 4, 1]).astype(np.uint32) + y = np.array([1, 2, 3]).astype(np.uint32) + z = x << y # expected output [32, 16, 8] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint32") + + @staticmethod + def export_left_unit64() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT" + ) + + x = np.array([16, 4, 1]).astype(np.uint64) + y = np.array([1, 2, 3]).astype(np.uint64) + z = x << y # expected output [32, 16, 8] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint64") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwiseand.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwiseand.py new file mode 100644 index 0000000000000000000000000000000000000000..723b66dc6c4ae602fb707d9cbcd5c18d5e0de933 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwiseand.py @@ -0,0 +1,55 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.numpy_helper import create_random_int + + +class BitwiseAnd(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "BitwiseAnd", + inputs=["x", "y"], + outputs=["bitwiseand"], + ) + + # 2d + x = create_random_int((3, 4), np.int32) + y = create_random_int((3, 4), np.int32) + z = np.bitwise_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i32_2d") + + # 3d + x = create_random_int((3, 4, 5), np.int16) + y = create_random_int((3, 4, 5), np.int16) + z = np.bitwise_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i16_3d") + + @staticmethod + def export_bitwiseand_broadcast() -> None: + node = onnx.helper.make_node( + "BitwiseAnd", + inputs=["x", "y"], + outputs=["bitwiseand"], + ) + + # 3d vs 1d + x = create_random_int((3, 4, 5), np.uint64) + y = create_random_int((5,), np.uint64) + z = np.bitwise_and(x, y) + expect( + node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui64_bcast_3v1d" + ) + + # 4d vs 3d + x = create_random_int((3, 4, 5, 6), np.uint8) + y = create_random_int((4, 5, 6), np.uint8) + z = np.bitwise_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui8_bcast_4v3d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwisenot.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwisenot.py new file mode 100644 index 0000000000000000000000000000000000000000..fb0ba200f8b6385ca08f6ca0f3121f3448575a12 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwisenot.py @@ -0,0 +1,36 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.numpy_helper import create_random_int + + +class BitwiseNot(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "BitwiseNot", + inputs=["x"], + outputs=["bitwise_not"], + ) + + # 2d + x = create_random_int((3, 4), np.int32) + y = np.bitwise_not(x) + expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_2d") + + # 3d + x = create_random_int((3, 4, 5), np.uint16) + y = np.bitwise_not(x) + expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_3d") + + # 4d + x = create_random_int((3, 4, 5, 6), np.uint8) + y = np.bitwise_not(x) + expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_4d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwiseor.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwiseor.py new file mode 100644 index 0000000000000000000000000000000000000000..596800292318797805b23c2eb4ace8566a4add39 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwiseor.py @@ -0,0 +1,52 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.numpy_helper import create_random_int + + +class BitwiseOr(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "BitwiseOr", + inputs=["x", "y"], + outputs=["bitwiseor"], + ) + # 2d + x = create_random_int((3, 4), np.int32) + y = create_random_int((3, 4), np.int32) + z = np.bitwise_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i32_2d") + + # 4d + x = create_random_int((3, 4, 5, 6), np.int8) + y = create_random_int((3, 4, 5, 6), np.int8) + z = np.bitwise_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i16_4d") + + @staticmethod + def export_bitwiseor_broadcast() -> None: + node = onnx.helper.make_node( + "BitwiseOr", + inputs=["x", "y"], + outputs=["bitwiseor"], + ) + + # 3d vs 1d + x = create_random_int((3, 4, 5), np.uint64) + y = create_random_int((5,), np.uint64) + z = np.bitwise_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui64_bcast_3v1d") + + # 4d vs 3d + x = create_random_int((3, 4, 5, 6), np.uint8) + y = create_random_int((4, 5, 6), np.uint8) + z = np.bitwise_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui8_bcast_4v3d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwisexor.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwisexor.py new file mode 100644 index 0000000000000000000000000000000000000000..338ebc008f6325938cfe857d0f648f713c5fd21b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/bitwisexor.py @@ -0,0 +1,55 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.numpy_helper import create_random_int + + +class BitwiseXor(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "BitwiseXor", + inputs=["x", "y"], + outputs=["bitwisexor"], + ) + + # 2d + x = create_random_int((3, 4), np.int32) + y = create_random_int((3, 4), np.int32) + z = np.bitwise_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i32_2d") + + # 3d + x = create_random_int((3, 4, 5), np.int16) + y = create_random_int((3, 4, 5), np.int16) + z = np.bitwise_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i16_3d") + + @staticmethod + def export_bitwiseor_broadcast() -> None: + node = onnx.helper.make_node( + "BitwiseXor", + inputs=["x", "y"], + outputs=["bitwisexor"], + ) + + # 3d vs 1d + x = create_random_int((3, 4, 5), np.uint64) + y = create_random_int((5,), np.uint64) + z = np.bitwise_xor(x, y) + expect( + node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui64_bcast_3v1d" + ) + + # 4d vs 3d + x = create_random_int((3, 4, 5, 6), np.uint8) + y = create_random_int((4, 5, 6), np.uint8) + z = np.bitwise_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui8_bcast_4v3d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/blackmanwindow.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/blackmanwindow.py new file mode 100644 index 0000000000000000000000000000000000000000..b0da12b3b8940a9ab334330cb0c5fa07866d3f6a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/blackmanwindow.py @@ -0,0 +1,56 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class BlackmanWindow(Base): + @staticmethod + def export() -> None: + # Test periodic window + node = onnx.helper.make_node( + "BlackmanWindow", + inputs=["x"], + outputs=["y"], + ) + size = np.int32(10) + a0 = 0.42 + a1 = -0.5 + a2 = 0.08 + y = a0 + y += a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size) + y += a2 * np.cos(4 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size) + expect( + node, + inputs=[size], + outputs=[y.astype(np.float32)], + name="test_blackmanwindow", + ) + + # Test symmetric window + node = onnx.helper.make_node( + "BlackmanWindow", inputs=["x"], outputs=["y"], periodic=0 + ) + size = np.int32(10) + a0 = 0.42 + a1 = -0.5 + a2 = 0.08 + y = a0 + y += a1 * np.cos( + 2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1) + ) + y += a2 * np.cos( + 4 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1) + ) + expect( + node, + inputs=[size], + outputs=[y.astype(np.float32)], + name="test_blackmanwindow_symmetric", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cast.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cast.py new file mode 100644 index 0000000000000000000000000000000000000000..dc3218a009f4ff0607cad4cf06db6e218a459e49 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cast.py @@ -0,0 +1,398 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import itertools + +import numpy as np + +import onnx +from onnx import TensorProto +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import ( + make_tensor, + tensor_dtype_to_np_dtype, +) +from onnx.numpy_helper import to_float8e8m0 + +F8_TYPES = frozenset({"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"}) +FOUR_BIT_TYPES = frozenset({"UINT4", "INT4", "FLOAT4E2M1"}) +TWO_BIT_TYPES = frozenset({"UINT2", "INT2"}) + + +class Cast(Base): + @staticmethod + def export() -> None: + test_cases = [ + ("FLOAT", "FLOAT16"), + ("FLOAT", "DOUBLE"), + ("FLOAT16", "FLOAT"), + ("FLOAT16", "DOUBLE"), + ("DOUBLE", "FLOAT"), + ("DOUBLE", "FLOAT16"), + ("FLOAT", "BFLOAT16"), + ("BFLOAT16", "FLOAT"), + ("FLOAT", "FLOAT8E4M3FN"), + ("FLOAT16", "FLOAT8E4M3FN"), + ("FLOAT", "FLOAT8E4M3FNUZ"), + ("FLOAT16", "FLOAT8E4M3FNUZ"), + ("FLOAT8E4M3FN", "FLOAT"), + ("FLOAT8E4M3FN", "FLOAT16"), + ("FLOAT8E4M3FNUZ", "FLOAT"), + ("FLOAT8E4M3FNUZ", "FLOAT16"), + ("FLOAT", "FLOAT8E5M2"), + ("FLOAT16", "FLOAT8E5M2"), + ("FLOAT", "FLOAT8E5M2FNUZ"), + ("FLOAT16", "FLOAT8E5M2FNUZ"), + ("FLOAT8E5M2", "FLOAT"), + ("FLOAT8E5M2", "FLOAT16"), + ("FLOAT8E5M2FNUZ", "FLOAT"), + ("FLOAT8E5M2FNUZ", "FLOAT16"), + ("FLOAT", "UINT4"), + ("FLOAT16", "UINT4"), + ("FLOAT", "INT4"), + ("FLOAT16", "INT4"), + ("UINT4", "FLOAT"), + ("UINT4", "FLOAT16"), + ("UINT4", "UINT8"), + ("INT4", "FLOAT"), + ("INT4", "FLOAT16"), + ("INT4", "INT8"), + ("FLOAT4E2M1", "FLOAT"), + ("FLOAT4E2M1", "FLOAT16"), + ("FLOAT", "FLOAT4E2M1"), + ("FLOAT16", "FLOAT4E2M1"), + ("FLOAT", "UINT2"), + ("FLOAT16", "UINT2"), + ("FLOAT", "INT2"), + ("FLOAT16", "INT2"), + ("UINT2", "FLOAT"), + ("UINT2", "FLOAT16"), + ("UINT2", "UINT8"), + ("INT2", "FLOAT"), + ("INT2", "FLOAT16"), + ("INT2", "INT8"), + ] + + for from_type, to_type in test_cases: + if from_type == to_type: + # Skip cases where from_type and to_type are the same + continue + from_dtype = getattr(TensorProto, from_type) + to_dtype = getattr(TensorProto, to_type) + from_np_dtype = tensor_dtype_to_np_dtype(from_dtype) + to_np_dtype = tensor_dtype_to_np_dtype(to_dtype) + + if from_type == "BFLOAT16" or to_type == "BFLOAT16": + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ) + input_shape = (3, 4) + + elif from_type in F8_TYPES or to_type in F8_TYPES: + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.7229038", + "1000000", + "1e-7", + "NaN", + "INF", + "+INF", + "-INF", + "-0.0000001", + "0.0000001", + "-1000000", + ], + dtype=np.float32, + ) + input_shape = (3, 5) + elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"): + np_fp32 = np.arange(-9, 16).astype(np.float32) + input_shape = (5, 5) + elif from_type in ("UINT2", "INT2") or to_type in ("UINT2", "INT2"): + np_fp32 = np.arange(-3, 4).astype(np.float32) + input_shape = (7, 1) + elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1": + np_fp32 = np.array( + [ + "0.48", + "0.25", + "1.05", + "-3.5", + "-8", + "9", + "1000000", + "1e-7", + "NaN", + "INF", + "+INF", + "-INF", + "-4", + "0.01", + "-0.0", + ], + dtype=np.float32, + ) + input_shape = (3, 5) + + else: + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ).reshape([3, 4]) + input_shape = (3, 4) + + if from_type in F8_TYPES: + np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype) + input = make_tensor( + "input", + from_dtype, + input_shape, + vals=np_from, + raw=True, + ) + elif from_type in FOUR_BIT_TYPES: + np_from = np_fp32.astype(from_np_dtype) + packed = onnx.numpy_helper._pack_4bitx2(np_from) + # No byteswap needed on big-endian machines as _pack_4bitx2() + # returns a numpy array with uint8 datatype. + input = make_tensor( + "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True + ) + elif from_type in TWO_BIT_TYPES: + np_from = np_fp32.astype(from_np_dtype) + packed = onnx.numpy_helper._pack_2bitx4(np_from) + input = make_tensor( + "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True + ) + else: + np_from = np_fp32.astype(from_np_dtype) + input = make_tensor( + "input", from_dtype, input_shape, vals=np_from, raw=True + ) + + if to_type in F8_TYPES: + output = make_tensor( + "output", + to_dtype, + input_shape, + vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype), + raw=True, + ) + elif to_type in FOUR_BIT_TYPES: + packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype)) + # No byteswap needed on big-endian machines as _pack_4bitx2() + # returns a numpy array with uint8 datatype. + output = make_tensor( + "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True + ) + elif to_type in TWO_BIT_TYPES: + packed = onnx.numpy_helper._pack_2bitx4(np_from.astype(to_np_dtype)) + output = make_tensor( + "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True + ) + else: + output = make_tensor( + "output", + to_dtype, + input_shape, + vals=np_from.astype(to_np_dtype), + raw=True, + ) + + node = onnx.helper.make_node( + "Cast", + inputs=["input"], + outputs=["output"], + to=to_dtype, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_cast_" + from_type + "_to_" + to_type, + ) + + @staticmethod + def export_saturate_false() -> None: + test_cases = itertools.product( + [ + "FLOAT", + "FLOAT16", + ], + [ + "FLOAT8E4M3FN", + "FLOAT8E4M3FNUZ", + "FLOAT8E5M2", + "FLOAT8E5M2FNUZ", + ], + ) + input_shape = (3, 5) + for from_type, to_type in test_cases: + from_dtype = getattr(TensorProto, from_type) + to_dtype = getattr(TensorProto, to_type) + from_np_dtype = tensor_dtype_to_np_dtype(from_dtype) + to_np_dtype = tensor_dtype_to_np_dtype(to_dtype) + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.7229038", + "1000000", + "1e-7", + "NaN", + "INF", + "+INF", + "-INF", + "-0.0000001", + "0.0000001", + "-1000000", + ], + dtype=np.float32, + ) + + input = make_tensor( + "input", + from_dtype, + input_shape, + vals=np_fp32.astype(from_np_dtype), + raw=True, + ) + output = make_tensor( + "output", + to_dtype, + input_shape, + vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype), + raw=True, + ) + + node = onnx.helper.make_node( + "Cast", + inputs=["input"], + outputs=["output"], + to=to_dtype, + saturate=0, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_cast_no_saturate_" + from_type + "_to_" + to_type, + ) + + @staticmethod + def export_e8m0() -> None: + np_fp32 = np.array( + [ + "0.0", + "0.124", + "0.25", + "0.5", + "1.1", + "2.0", + "4.0", + "8.0", + ], + dtype=np.float32, + ) + test_cases = [ + ("FLOAT", "FLOAT8E8M0"), + ("FLOAT16", "FLOAT8E8M0"), + ("FLOAT8E8M0", "FLOAT"), + ("FLOAT8E8M0", "FLOAT16"), + ] + for from_type, to_type in test_cases: + if from_type == "FLOAT": + input_np = np_fp32 + output_np = to_float8e8m0(np_fp32) + elif from_type == "FLOAT16": + input_np = np_fp32.astype(np.float16) + output_np = to_float8e8m0(input_np) + elif from_type == "FLOAT8E8M0": + input_np = to_float8e8m0(np_fp32) + if to_type == "FLOAT": + output_np = input_np.astype(np.float32) + elif to_type == "FLOAT16": + output_np = input_np.astype(np.float16) + else: + raise ValueError( + f"Conversion from {from_type} to {to_type} is not tested." + ) + else: + raise ValueError( + f"Conversion from {from_type} to {to_type} is not tested." + ) + input = make_tensor( + "input", + getattr(TensorProto, from_type), + [2, 4], + input_np, + raw=True, + ) + output = make_tensor( + "output", + getattr(TensorProto, to_type), + [2, 4], + output_np, + raw=True, + ) + if to_type == "FLOAT8E8M0": + node = onnx.helper.make_node( + "Cast", + inputs=["input"], + outputs=["output"], + to=getattr(TensorProto, to_type), + saturate=1, + round_mode="up", + ) + else: + node = onnx.helper.make_node( + "Cast", + inputs=["input"], + outputs=["output"], + to=getattr(TensorProto, to_type), + ) + + expect( + node, + inputs=[input], + outputs=[output], + name="test_cast_e8m0_" + from_type + "_to_" + to_type, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/castlike.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/castlike.py new file mode 100644 index 0000000000000000000000000000000000000000..7bd90186fb1323087b6a001fee13b927bf0a01e5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/castlike.py @@ -0,0 +1,324 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import itertools + +import numpy as np + +import onnx +from onnx import TensorProto +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import make_tensor, tensor_dtype_to_np_dtype + +F8_TYPES = frozenset({"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"}) +FOUR_BIT_TYPES = frozenset({"UINT4", "INT4", "FLOAT4E2M1"}) +TWO_BIT_TYPES = frozenset({"UINT2", "INT2"}) + + +class CastLike(Base): + @staticmethod + def export() -> None: + test_cases = [ + ("FLOAT", "FLOAT16"), + ("FLOAT", "DOUBLE"), + ("FLOAT16", "FLOAT"), + ("FLOAT16", "DOUBLE"), + ("DOUBLE", "FLOAT"), + ("DOUBLE", "FLOAT16"), + ("FLOAT", "BFLOAT16"), + ("BFLOAT16", "FLOAT"), + ("FLOAT", "FLOAT8E4M3FN"), + ("FLOAT16", "FLOAT8E4M3FN"), + ("FLOAT", "FLOAT8E4M3FNUZ"), + ("FLOAT16", "FLOAT8E4M3FNUZ"), + ("FLOAT8E4M3FN", "FLOAT"), + ("FLOAT8E4M3FN", "FLOAT16"), + ("FLOAT8E4M3FNUZ", "FLOAT"), + ("FLOAT8E4M3FNUZ", "FLOAT16"), + ("FLOAT", "FLOAT8E5M2"), + ("FLOAT16", "FLOAT8E5M2"), + ("FLOAT", "FLOAT8E5M2FNUZ"), + ("FLOAT16", "FLOAT8E5M2FNUZ"), + ("FLOAT8E5M2", "FLOAT"), + ("FLOAT8E5M2", "FLOAT16"), + ("FLOAT8E5M2FNUZ", "FLOAT"), + ("FLOAT8E5M2FNUZ", "FLOAT16"), + ("FLOAT", "UINT4"), + ("FLOAT16", "UINT4"), + ("FLOAT", "INT4"), + ("FLOAT16", "INT4"), + ("UINT4", "FLOAT"), + ("UINT4", "FLOAT16"), + ("UINT4", "UINT8"), + ("INT4", "FLOAT"), + ("INT4", "FLOAT16"), + ("INT4", "INT8"), + ("FLOAT4E2M1", "FLOAT"), + ("FLOAT4E2M1", "FLOAT16"), + ("FLOAT", "FLOAT4E2M1"), + ("FLOAT16", "FLOAT4E2M1"), + ("FLOAT", "UINT2"), + ("FLOAT16", "UINT2"), + ("FLOAT", "INT2"), + ("FLOAT16", "INT2"), + ("UINT2", "FLOAT"), + ("UINT2", "FLOAT16"), + ("UINT2", "UINT8"), + ("INT2", "FLOAT"), + ("INT2", "FLOAT16"), + ("INT2", "INT8"), + ] + + f8_types = {"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"} + + for from_type, to_type in test_cases: + if from_type == to_type: + # Skip cases where from_type and to_type are the same + continue + from_dtype = getattr(TensorProto, from_type) + to_dtype = getattr(TensorProto, to_type) + from_np_dtype = tensor_dtype_to_np_dtype(from_dtype) + to_np_dtype = tensor_dtype_to_np_dtype(to_dtype) + + if from_type == "BFLOAT16" or to_type == "BFLOAT16": + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ) + input_shape = (3, 4) + + elif from_type in f8_types or to_type in f8_types: + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.7229038", + "1000000", + "1e-7", + "NaN", + "INF", + "+INF", + "-INF", + "-0.0000001", + "0.0000001", + "-1000000", + ], + dtype=np.float32, + ) + input_shape = (3, 5) + elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"): + np_fp32 = np.arange(-9, 16).astype(np.float32) + input_shape = (5, 5) + elif from_type in ("UINT2", "INT2") or to_type in ("UINT2", "INT2"): + np_fp32 = np.arange(-3, 4).astype(np.float32) + input_shape = (7, 1) + elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1": + np_fp32 = np.array( + [ + "0.48", + "0.25", + "1.05", + "-3.5", + "-8", + "9", + "1000000", + "1e-7", + "NaN", + "INF", + "+INF", + "-INF", + "-4", + "0.01", + "-0.0", + ], + dtype=np.float32, + ) + input_shape = (3, 5) + + else: + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ).reshape([3, 4]) + input_shape = (3, 4) + + if from_type in F8_TYPES: + np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype) + input = make_tensor( + "input", + from_dtype, + input_shape, + vals=np_from, + raw=True, + ) + elif from_type in FOUR_BIT_TYPES: + np_from = np_fp32.astype(from_np_dtype) + packed = onnx.numpy_helper._pack_4bitx2(np_from) + # No byteswap needed on big-endian machines as _pack_4bitx2() + # returns a numpy array with uint8 datatype. + input = make_tensor( + "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True + ) + elif from_type in TWO_BIT_TYPES: + np_from = np_fp32.astype(from_np_dtype) + packed = onnx.numpy_helper._pack_2bitx4(np_from) + # No byteswap needed on big-endian machines as _pack_2bitx4() + # returns a numpy array with uint8 datatype. + input = make_tensor( + "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True + ) + else: + np_from = np_fp32.astype(from_np_dtype) + input = make_tensor( + "input", from_dtype, input_shape, vals=np_from, raw=True + ) + + if to_type in F8_TYPES: + output = make_tensor( + "output", + to_dtype, + input_shape, + vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype), + raw=True, + ) + elif to_type in FOUR_BIT_TYPES: + packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype)) + # No byteswap needed on big-endian machines as _pack_4bitx2() + # returns a numpy array with uint8 datatype. + output = make_tensor( + "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True + ) + elif to_type in TWO_BIT_TYPES: + packed = onnx.numpy_helper._pack_2bitx4(np_from.astype(to_np_dtype)) + # No byteswap needed on big-endian machines as _pack_2bitx4() + # returns a numpy array with uint8 datatype. + output = make_tensor( + "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True + ) + else: + output = make_tensor( + "output", + to_dtype, + input_shape, + vals=np_from.astype(to_np_dtype), + raw=True, + ) + + like = make_tensor("like", to_dtype, (0,), vals=[]) + + node = onnx.helper.make_node( + "CastLike", + inputs=["input", "like"], + outputs=["output"], + ) + + expect( + node, + inputs=[input, like], + outputs=[output], + name="test_castlike_" + from_type + "_to_" + to_type, + ) + + @staticmethod + def export_saturate_false() -> None: + test_cases = itertools.product( + [ + "FLOAT", + "FLOAT16", + ], + [ + "FLOAT8E4M3FN", + "FLOAT8E4M3FNUZ", + "FLOAT8E5M2", + "FLOAT8E5M2FNUZ", + ], + ) + input_shape = (3, 5) + for from_type, to_type in test_cases: + from_dtype = getattr(TensorProto, from_type) + to_dtype = getattr(TensorProto, to_type) + from_np_dtype = tensor_dtype_to_np_dtype(from_dtype) + to_np_dtype = tensor_dtype_to_np_dtype(to_dtype) + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.7229038", + "1000000", + "1e-7", + "NaN", + "INF", + "+INF", + "-INF", + "-0.0000001", + "0.0000001", + "-1000000", + ], + dtype=np.float32, + ) + + input = make_tensor( + "input", + from_dtype, + input_shape, + vals=np_fp32.astype(from_np_dtype), + raw=True, + ) + output = make_tensor( + "output", + to_dtype, + input_shape, + vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype), + raw=True, + ) + + like = make_tensor("like", to_dtype, (0,), vals=[]) + + node = onnx.helper.make_node( + "CastLike", + inputs=["input", "like"], + outputs=["output"], + saturate=0, + ) + + expect( + node, + inputs=[input, like], + outputs=[output], + name="test_castlike_no_saturate_" + from_type + "_to_" + to_type, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/causal_conv_with_state.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/causal_conv_with_state.py new file mode 100644 index 0000000000000000000000000000000000000000..a06e6731b65d5872b6ff627070945fe41c8efb01 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/causal_conv_with_state.py @@ -0,0 +1,335 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_causal_conv_with_state import ( + CausalConvWithState as _RefCausalConvWithState, +) + + +def _compute(input_, weight, bias=None, past_state=None, activation="none"): + op = _RefCausalConvWithState.__new__(_RefCausalConvWithState) + return op._run( + input_, + weight, + bias=bias, + past_state=past_state, + activation=activation, + ) + + +class CausalConvWithState(Base): + @staticmethod + def export_basic() -> None: + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + + output, present_state = _compute(input_, weight) + + expect( + node, + inputs=[input_, weight], + outputs=[output, present_state], + name="test_causal_conv_with_state_basic", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_with_bias() -> None: + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight", "bias"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + bias = np.random.randn(channels).astype(np.float32) + + output, present_state = _compute(input_, weight, bias=bias) + + expect( + node, + inputs=[input_, weight, bias], + outputs=[output, present_state], + name="test_causal_conv_with_state_with_bias", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_with_past_state() -> None: + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight", "", "past_state"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32) + + output, present_state = _compute(input_, weight, past_state=past_state) + + expect( + node, + inputs=[input_, weight, past_state], + outputs=[output, present_state], + name="test_causal_conv_with_state_with_past_state", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_silu() -> None: + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight"], + outputs=["output", "present_state"], + activation="silu", + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + + output, present_state = _compute(input_, weight, activation="silu") + + expect( + node, + inputs=[input_, weight], + outputs=[output, present_state], + name="test_causal_conv_with_state_silu", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_swish_alias() -> None: + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight"], + outputs=["output", "present_state"], + activation="swish", + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + + output, present_state = _compute(input_, weight, activation="swish") + + expect( + node, + inputs=[input_, weight], + outputs=[output, present_state], + name="test_causal_conv_with_state_swish_alias", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_decode_step() -> None: + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight", "bias", "past_state"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 2, 4, 1, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + bias = np.random.randn(channels).astype(np.float32) + past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32) + + output, present_state = _compute( + input_, weight, bias=bias, past_state=past_state + ) + + expect( + node, + inputs=[input_, weight, bias, past_state], + outputs=[output, present_state], + name="test_causal_conv_with_state_decode_step", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_kernel_size_one() -> None: + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 2, 4, 8, 1 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + + output, present_state = _compute(input_, weight) + + expect( + node, + inputs=[input_, weight], + outputs=[output, present_state], + name="test_causal_conv_with_state_kernel_size_one", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_with_bias_and_past_state() -> None: + # Multi-token (T>1) path through Concat(past, input) -> Conv(+bias). + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight", "bias", "past_state"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + bias = np.random.randn(channels).astype(np.float32) + past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32) + + output, present_state = _compute( + input_, weight, bias=bias, past_state=past_state + ) + + expect( + node, + inputs=[input_, weight, bias, past_state], + outputs=[output, present_state], + name="test_causal_conv_with_state_with_bias_and_past_state", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_silu_with_past_state() -> None: + # Fused activation combined with concat-from-past variant of PaddedInput. + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight", "", "past_state"], + outputs=["output", "present_state"], + activation="silu", + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32) + + output, present_state = _compute( + input_, weight, past_state=past_state, activation="silu" + ) + + expect( + node, + inputs=[input_, weight, past_state], + outputs=[output, present_state], + name="test_causal_conv_with_state_silu_with_past_state", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_b1_c1_degenerate() -> None: + # Mamba/GDN inner-head edge case: B=1, C=1. + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 1, 1, 6, 4 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + + output, present_state = _compute(input_, weight) + + expect( + node, + inputs=[input_, weight], + outputs=[output, present_state], + name="test_causal_conv_with_state_b1_c1_degenerate", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_short_input_no_past_state() -> None: + # L < k-1 with no past_state: zero-pad is wider than the input. + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 2, 4, 2, 5 + input_ = np.random.randn(batch_size, channels, length).astype(np.float32) + weight = np.random.randn(channels, 1, k).astype(np.float32) + + output, present_state = _compute(input_, weight) + + expect( + node, + inputs=[input_, weight], + outputs=[output, present_state], + name="test_causal_conv_with_state_short_input_no_past_state", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_fp16() -> None: + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight"], + outputs=["output", "present_state"], + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.rand(batch_size, channels, length).astype(np.float16) + weight = np.random.rand(channels, 1, k).astype(np.float16) + + output, present_state = _compute(input_, weight) + + expect( + node, + inputs=[input_, weight], + outputs=[output, present_state], + name="test_causal_conv_with_state_fp16", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) + + @staticmethod + def export_silu_fp16() -> None: + # fp16 + SiLU: the reference upcasts Sigmoid/Mul to float32, so the + # function-body expansion must do the same to stay numerically faithful. + node = onnx.helper.make_node( + "CausalConvWithState", + inputs=["input", "weight"], + outputs=["output", "present_state"], + activation="silu", + ) + + batch_size, channels, length, k = 2, 4, 8, 4 + input_ = np.random.rand(batch_size, channels, length).astype(np.float16) + weight = np.random.rand(channels, 1, k).astype(np.float16) + + output, present_state = _compute(input_, weight, activation="silu") + + expect( + node, + inputs=[input_, weight], + outputs=[output, present_state], + name="test_causal_conv_with_state_silu_fp16", + opset_imports=[onnx.helper.make_opsetid("", 27)], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ceil.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ceil.py new file mode 100644 index 0000000000000000000000000000000000000000..bce69e825ab7c135acbd4a0e12dc7dd8b245fcb3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/ceil.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Ceil(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Ceil", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.5, 1.2]).astype(np.float32) + y = np.ceil(x) # expected output [-1., 2.] + expect(node, inputs=[x], outputs=[y], name="test_ceil_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.ceil(x) + expect(node, inputs=[x], outputs=[y], name="test_ceil") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/celu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/celu.py new file mode 100644 index 0000000000000000000000000000000000000000..6eb9080fd5f492fa3efbf5f0401bedf024e476dc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/celu.py @@ -0,0 +1,50 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Celu(Base): + @staticmethod + def export() -> None: + alpha = 2.0 + node = onnx.helper.make_node( + "Celu", + inputs=["X"], + outputs=["Y"], + alpha=alpha, + ) + + input_data = np.array( + [ + [ + [[0.8439683], [0.5665144], [0.05836735]], + [[0.02916367], [0.12964272], [0.5060197]], + [[0.79538304], [0.9411346], [0.9546573]], + ], + [ + [[0.17730942], [0.46192095], [0.26480448]], + [[0.6746842], [0.01665257], [0.62473077]], + [[0.9240844], [0.9722341], [0.11965699]], + ], + [ + [[0.41356155], [0.9129373], [0.59330076]], + [[0.81929934], [0.7862604], [0.11799799]], + [[0.69248444], [0.54119414], [0.07513223]], + ], + ], + dtype=np.float32, + ) + + # Calculate expected output data + positive_input = np.maximum(0, input_data) + negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1)) + expected_output = positive_input + negative_input + + expect(node, inputs=[input_data], outputs=[expected_output], name="test_celu") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/center_crop_pad.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/center_crop_pad.py new file mode 100644 index 0000000000000000000000000000000000000000..90e89d7da209bbc592e4c9dff688bc16398ce2c0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/center_crop_pad.py @@ -0,0 +1,130 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class CenterCropPad(Base): + @staticmethod + def export_center_crop_pad_crop() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + ) + + # First dim is even diff, second is uneven + x = np.random.randn(20, 10, 3).astype(np.float32) + shape = np.array([10, 7, 3], dtype=np.int64) + y = x[5:15, 1:8, :] + + expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_crop") + + @staticmethod + def export_center_crop_pad_pad() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + ) + + # First dim is even diff, second is uneven + x = np.random.randn(10, 7, 3).astype(np.float32) + shape = np.array([20, 10, 3], dtype=np.int64) + y = np.zeros([20, 10, 3], dtype=np.float32) + y[5:15, 1:8, :] = x + + expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_pad") + + @staticmethod + def export_center_crop_pad_crop_and_pad() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + ) + + # Cropping on first dim, padding on second, third stays the same + x = np.random.randn(20, 8, 3).astype(np.float32) + shape = np.array([10, 10, 3], dtype=np.int64) + y = np.zeros([10, 10, 3], dtype=np.float32) + y[:, 1:9, :] = x[5:15, :, :] + + expect( + node, + inputs=[x, shape], + outputs=[y], + name="test_center_crop_pad_crop_and_pad", + ) + + @staticmethod + def export_center_crop_pad_crop_axes_hwc() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + axes=[0, 1], + ) + + # Cropping on first dim, padding on second, third stays the same + x = np.random.randn(20, 8, 3).astype(np.float32) + shape = np.array([10, 9], dtype=np.int64) + y = np.zeros([10, 9, 3], dtype=np.float32) + y[:, :8, :] = x[5:15, :, :] + + expect( + node, + inputs=[x, shape], + outputs=[y], + name="test_center_crop_pad_crop_axes_hwc", + ) + + @staticmethod + def export_center_crop_pad_crop_negative_axes_hwc() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + axes=[-3, -2], + ) + + # Cropping on first dim, padding on second, third stays the same + x = np.random.randn(20, 8, 3).astype(np.float32) + shape = np.array([10, 9], dtype=np.int64) + y = np.zeros([10, 9, 3], dtype=np.float32) + y[:, :8, :] = x[5:15, :, :] + + expect( + node, + inputs=[x, shape], + outputs=[y], + name="test_center_crop_pad_crop_negative_axes_hwc", + ) + + @staticmethod + def export_center_crop_pad_crop_axes_chw() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + axes=[1, 2], + ) + + # Cropping on second dim, padding on third, first stays the same + x = np.random.randn(3, 20, 8).astype(np.float32) + shape = np.array([10, 9], dtype=np.int64) + y = np.zeros([3, 10, 9], dtype=np.float32) + y[:, :, :8] = x[:, 5:15, :] + + expect( + node, + inputs=[x, shape], + outputs=[y], + name="test_center_crop_pad_crop_axes_chw", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/clip.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..c9b9e6f6fdd74952169977342d06c2d37dd66c27 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/clip.py @@ -0,0 +1,144 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Clip(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Clip", + inputs=["x", "min", "max"], + outputs=["y"], + ) + + x = np.array([-2, 0, 2]).astype(np.float32) + min_val = np.float32(-1) + max_val = np.float32(1) + y = np.clip(x, min_val, max_val) # expected output [-1., 0., 1.] + expect( + node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_example" + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, min_val, max_val) + expect(node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip") + node = onnx.helper.make_node( + "Clip", + inputs=["x", "min", "max"], + outputs=["y"], + ) + + min_val = np.float32(-5) + max_val = np.float32(5) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.array([-1, 0, 1]).astype(np.float32) + expect( + node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_inbounds" + ) + + x = np.array([-6, 0, 6]).astype(np.float32) + y = np.array([-5, 0, 5]).astype(np.float32) + expect( + node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_outbounds" + ) + + x = np.array([-1, 0, 6]).astype(np.float32) + y = np.array([-1, 0, 5]).astype(np.float32) + expect( + node, + inputs=[x, min_val, max_val], + outputs=[y], + name="test_clip_splitbounds", + ) + + x = np.array([-2, 0, 6]).astype(np.float32) + y = np.array([1, 1, 1]).astype(np.float32) + min_val = np.float32(2) + max_val = np.float32(1) + expect( + node, + inputs=[x, min_val, max_val], + outputs=[y], + name="test_clip_min_greater_than_max", + ) + + @staticmethod + def export_clip_default() -> None: + node = onnx.helper.make_node( + "Clip", + inputs=["x", "min"], + outputs=["y"], + ) + min_val = np.float32(0) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, min_val, np.inf) + expect(node, inputs=[x, min_val], outputs=[y], name="test_clip_default_min") + + no_min = "" # optional input, not supplied + node = onnx.helper.make_node( + "Clip", + inputs=["x", no_min, "max"], + outputs=["y"], + ) + max_val = np.float32(0) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, -np.inf, max_val) + expect(node, inputs=[x, max_val], outputs=[y], name="test_clip_default_max") + + no_max = "" # optional input, not supplied + node = onnx.helper.make_node( + "Clip", + inputs=["x", no_min, no_max], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.array([-1, 0, 1]).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_clip_default_inbounds") + + @staticmethod + def export_clip_default_int8() -> None: + node = onnx.helper.make_node( + "Clip", + inputs=["x", "min"], + outputs=["y"], + ) + min_val = np.int8(0) + x = np.random.randn(3, 4, 5).astype(np.int8) + y = np.clip(x, min_val, np.iinfo(np.int8).max) + expect( + node, inputs=[x, min_val], outputs=[y], name="test_clip_default_int8_min" + ) + + no_min = "" # optional input, not supplied + node = onnx.helper.make_node( + "Clip", + inputs=["x", no_min, "max"], + outputs=["y"], + ) + max_val = np.int8(0) + x = np.random.randn(3, 4, 5).astype(np.int8) + y = np.clip(x, np.iinfo(np.int8).min, max_val) + expect( + node, inputs=[x, max_val], outputs=[y], name="test_clip_default_int8_max" + ) + + no_max = "" # optional input, not supplied + node = onnx.helper.make_node( + "Clip", + inputs=["x", no_min, no_max], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.int8) + y = np.array([-1, 0, 1]).astype(np.int8) + expect(node, inputs=[x], outputs=[y], name="test_clip_default_int8_inbounds") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/col2im.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/col2im.py new file mode 100644 index 0000000000000000000000000000000000000000..8516985b26238e0b7a528114bae5a98b9285098b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/col2im.py @@ -0,0 +1,349 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Col2Im(Base): + """Col2Im operator with N-dimension support + + The tests below can be reproduced in Python using https://github.com/f-dangel/unfoldNd/ + """ + + @staticmethod + def export() -> None: + input = np.array( + [ + [ + [1.0, 6.0, 11.0, 16.0, 21.0], # (1, 5, 5) + [2.0, 7.0, 12.0, 17.0, 22.0], + [3.0, 8.0, 13.0, 18.0, 23.0], + [4.0, 9.0, 14.0, 19.0, 24.0], + [5.0, 0.0, 15.0, 20.0, 25.0], + ] + ] + ).astype(np.float32) + + image_shape = np.array([5, 5]).astype(np.int64) + block_shape = np.array([1, 5]).astype(np.int64) + node = onnx.helper.make_node( + "Col2Im", ["input", "image_shape", "block_shape"], ["output"] + ) + + output = np.array( + [ + [ + [ + [1.0, 2.0, 3.0, 4.0, 5.0], # (1, 1, 5, 5) + [6.0, 7.0, 8.0, 9.0, 0.0], + [11.0, 12.0, 13.0, 14.0, 15.0], + [16.0, 17.0, 18.0, 19.0, 20.0], + [21.0, 22.0, 23.0, 24.0, 25.0], + ] + ] + ] + ).astype(np.float32) + + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im", + ) + + @staticmethod + def export_col2im_strides() -> None: + input = np.array( + [ + [ + [0.0, 0.0, 0.0, 0.0], # (1, 9, 4) + [1.0, 1.0, 1.0, 1.0], + [1.0, 1.0, 1.0, 1.0], + [1.0, 1.0, 1.0, 1.0], + [0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0], + [1.0, 1.0, 1.0, 1.0], + [0.0, 0.0, 0.0, 0.0], + ] + ] + ).astype(np.float32) + image_shape = np.array([5, 5]).astype(np.int64) + block_shape = np.array([3, 3]).astype(np.int64) + + output = np.array( + [ + [ + [ + [0.0, 1.0, 1.0, 1.0, 1.0], # (1, 1, 5, 5) + [1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 2.0, 1.0, 2.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0], + ] + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Col2Im", + ["input", "image_shape", "block_shape"], + ["output"], + strides=[2, 2], + ) + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im_strides", + ) + + @staticmethod + def export_col2im_pads() -> None: + input = np.array( + [ + [ + [ + 1.0, + 6.0, + 11.0, + 16.0, + 21.0, + 26, + 31, + 36, + 41, + 46, + 51, + 56, + 61, + 66, + 71, + ], # (1, 5, 15) + [ + 2.0, + 7.0, + 12.0, + 17.0, + 22.0, + 27, + 32, + 37, + 42, + 47, + 52, + 57, + 62, + 67, + 72, + ], + [ + 3.0, + 8.0, + 13.0, + 18.0, + 23.0, + 28, + 33, + 38, + 43, + 48, + 53, + 58, + 63, + 68, + 73, + ], + [ + 4.0, + 9.0, + 14.0, + 19.0, + 24.0, + 29, + 34, + 39, + 44, + 49, + 54, + 59, + 64, + 69, + 74, + ], + [ + 5.0, + 10.0, + 15.0, + 20.0, + 25.0, + 30, + 35, + 40, + 45, + 50, + 55, + 60, + 65, + 70, + 75, + ], + ] + ] + ).astype(np.float32) + image_shape = np.array([5, 5]).astype(np.int64) + block_shape = np.array([1, 5]).astype(np.int64) + + output = np.array( + [ + [ + [ + [8.0, 21.0, 24.0, 27.0, 24.0], # (1, 1, 5, 5) + [38.0, 66.0, 69.0, 72.0, 54.0], + [68.0, 111.0, 114.0, 117.0, 84.0], + [98.0, 156.0, 159.0, 162.0, 114.0], + [128.0, 201.0, 204.0, 207.0, 144.0], + ] + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Col2Im", + ["input", "image_shape", "block_shape"], + ["output"], + pads=[0, 1, 0, 1], + ) + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im_pads", + ) + + @staticmethod + def export_col2im_dilations() -> None: + input = np.array( + [ + [ + [1.0, 5.0, 9.0, 13.0, 17], # (1, 4, 5) + [2.0, 6.0, 10.0, 14.0, 18], + [3.0, 7.0, 11.0, 15.0, 19], + [4.0, 8.0, 12.0, 16.0, 20], + ] + ] + ).astype(np.float32) + image_shape = np.array([6, 6]).astype(np.int64) + block_shape = np.array([2, 2]).astype(np.int64) + + output = np.array( + [ + [ + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 2.0], # (1, 1, 6, 6) + [8.0, 0.0, 0.0, 0.0, 0.0, 10.0], + [16.0, 0.0, 0.0, 0.0, 0.0, 18.0], + [24.0, 0.0, 0.0, 0.0, 0.0, 26.0], + [32.0, 0.0, 0.0, 0.0, 0.0, 34.0], + [19.0, 0.0, 0.0, 0.0, 0.0, 20.0], + ] + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Col2Im", + ["input", "image_shape", "block_shape"], + ["output"], + dilations=[1, 5], + ) + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im_dilations", + ) + + @staticmethod + def export_col2im_5d() -> None: + input = np.array( + [ + [ + [1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56], # (1, 10, 12) + [2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57], + [3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58], + [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59], + [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60], + [61, 66, 71, 76, 81, 86, 91, 96, 101, 106, 111, 116], + [62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117], + [63, 68, 73, 78, 83, 88, 93, 98, 103, 108, 113, 118], + [64, 69, 74, 79, 84, 89, 94, 99, 104, 109, 114, 119], + [65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120], + ] + ] + ).astype(np.float32) + image_shape = np.array([3, 4, 5]).astype(np.int64) + block_shape = np.array([1, 1, 5]).astype(np.int64) + + output = np.array( + [ + [ + [ + [ + [1, 2, 3, 4, 5], # (1, 2, 3, 4, 5) + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + ], + [ + [21, 22, 23, 24, 25], + [26, 27, 28, 29, 30], + [31, 32, 33, 34, 35], + [36, 37, 38, 39, 40], + ], + [ + [41, 42, 43, 44, 45], + [46, 47, 48, 49, 50], + [51, 52, 53, 54, 55], + [56, 57, 58, 59, 60], + ], + ], + [ + [ + [61, 62, 63, 64, 65], + [66, 67, 68, 69, 70], + [71, 72, 73, 74, 75], + [76, 77, 78, 79, 80], + ], + [ + [81, 82, 83, 84, 85], + [86, 87, 88, 89, 90], + [91, 92, 93, 94, 95], + [96, 97, 98, 99, 100], + ], + [ + [101, 102, 103, 104, 105], + [106, 107, 108, 109, 110], + [111, 112, 113, 114, 115], + [116, 117, 118, 119, 120], + ], + ], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Col2Im", ["input", "image_shape", "block_shape"], ["output"] + ) + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im_5d", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/compress.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/compress.py new file mode 100644 index 0000000000000000000000000000000000000000..aa20c17b3bcfb81132ad255e47b99d7aded6306d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/compress.py @@ -0,0 +1,99 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Compress(Base): + @staticmethod + def export_compress_0() -> None: + node = onnx.helper.make_node( + "Compress", + inputs=["input", "condition"], + outputs=["output"], + axis=0, + ) + input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32) + condition = np.array([0, 1, 1]) + output = np.compress(condition, input, axis=0) + # print(output) + # [[ 3. 4.] + # [ 5. 6.]] + + expect( + node, + inputs=[input, condition.astype(bool)], + outputs=[output], + name="test_compress_0", + ) + + @staticmethod + def export_compress_1() -> None: + node = onnx.helper.make_node( + "Compress", + inputs=["input", "condition"], + outputs=["output"], + axis=1, + ) + input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32) + condition = np.array([0, 1]) + output = np.compress(condition, input, axis=1) + # print(output) + # [[ 2.] + # [ 4.] + # [ 6.]] + + expect( + node, + inputs=[input, condition.astype(bool)], + outputs=[output], + name="test_compress_1", + ) + + @staticmethod + def export_compress_default_axis() -> None: + node = onnx.helper.make_node( + "Compress", + inputs=["input", "condition"], + outputs=["output"], + ) + input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32) + condition = np.array([0, 1, 0, 0, 1]) + output = np.compress(condition, input) + # print(output) + # [ 2., 5.] + + expect( + node, + inputs=[input, condition.astype(bool)], + outputs=[output], + name="test_compress_default_axis", + ) + + @staticmethod + def export_compress_negative_axis() -> None: + node = onnx.helper.make_node( + "Compress", + inputs=["input", "condition"], + outputs=["output"], + axis=-1, + ) + input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32) + condition = np.array([0, 1]) + output = np.compress(condition, input, axis=-1) + # print(output) + # [[ 2.] + # [ 4.] + # [ 6.]] + expect( + node, + inputs=[input, condition.astype(bool)], + outputs=[output], + name="test_compress_negative_axis", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/concat.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/concat.py new file mode 100644 index 0000000000000000000000000000000000000000..25807eb64828b84f3bd338533cab6bfa4924ba31 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/concat.py @@ -0,0 +1,56 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + +if TYPE_CHECKING: + from collections.abc import Sequence + + +class Concat(Base): + @staticmethod + def export() -> None: + test_cases: dict[str, Sequence[Any]] = { + "1d": ([1, 2], [3, 4]), + "2d": ([[1, 2], [3, 4]], [[5, 6], [7, 8]]), + "3d": ( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]]], + [[[9, 10], [11, 12]], [[13, 14], [15, 16]]], + ), + } + + for test_case, values_ in test_cases.items(): + values = [np.asarray(v, dtype=np.float32) for v in values_] + for i in range(len(values[0].shape)): + in_args = ["value" + str(k) for k in range(len(values))] + node = onnx.helper.make_node( + "Concat", inputs=list(in_args), outputs=["output"], axis=i + ) + output = np.concatenate(values, i) + expect( + node, + inputs=list(values), + outputs=[output], + name="test_concat_" + test_case + "_axis_" + str(i), + ) + + for i in range(-len(values[0].shape), 0): + in_args = ["value" + str(k) for k in range(len(values))] + node = onnx.helper.make_node( + "Concat", inputs=list(in_args), outputs=["output"], axis=i + ) + output = np.concatenate(values, i) + expect( + node, + inputs=list(values), + outputs=[output], + name="test_concat_" + test_case + "_axis_negative_" + str(abs(i)), + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/constant.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/constant.py new file mode 100644 index 0000000000000000000000000000000000000000..82a1942b53ba0eed203147bf0135860aaec26183 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/constant.py @@ -0,0 +1,29 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Constant(Base): + @staticmethod + def export() -> None: + values = np.random.randn(5, 5).astype(np.float32) + node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["values"], + value=onnx.helper.make_tensor( + name="const_tensor", + data_type=onnx.TensorProto.FLOAT, + dims=values.shape, + vals=values.flatten().astype(float), + ), + ) + + expect(node, inputs=[], outputs=[values], name="test_constant") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/constantofshape.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/constantofshape.py new file mode 100644 index 0000000000000000000000000000000000000000..90838427ccc2294569c8c433d56f455848764880 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/constantofshape.py @@ -0,0 +1,64 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ConstantOfShape(Base): + @staticmethod + def export_float_ones() -> None: + x = np.array([4, 3, 2]).astype(np.int64) + tensor_value = onnx.helper.make_tensor( + "value", onnx.TensorProto.FLOAT, [1], [1] + ) + node = onnx.helper.make_node( + "ConstantOfShape", + inputs=["x"], + outputs=["y"], + value=tensor_value, + ) + + y = np.ones(x, dtype=np.float32) + expect(node, inputs=[x], outputs=[y], name="test_constantofshape_float_ones") + + @staticmethod + def export_int32_zeros() -> None: + x = np.array([10, 6]).astype(np.int64) + tensor_value = onnx.helper.make_tensor( + "value", onnx.TensorProto.INT32, [1], [0] + ) + node = onnx.helper.make_node( + "ConstantOfShape", + inputs=["x"], + outputs=["y"], + value=tensor_value, + ) + y = np.zeros(x, dtype=np.int32) + expect(node, inputs=[x], outputs=[y], name="test_constantofshape_int_zeros") + + @staticmethod + def export_int32_shape_zero() -> None: + x = np.array( + [ + 0, + ] + ).astype(np.int64) + tensor_value = onnx.helper.make_tensor( + "value", onnx.TensorProto.INT32, [1], [0] + ) + node = onnx.helper.make_node( + "ConstantOfShape", + inputs=["x"], + outputs=["y"], + value=tensor_value, + ) + y = np.zeros(x, dtype=np.int32) + expect( + node, inputs=[x], outputs=[y], name="test_constantofshape_int_shape_zero" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/conv.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/conv.py new file mode 100644 index 0000000000000000000000000000000000000000..0be699e2a21795c327fbcc72b0ee178039c38ee1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/conv.py @@ -0,0 +1,257 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Conv(Base): + @staticmethod + def export() -> None: + x = np.array( + [ + [ + [ + [0.0, 1.0, 2.0, 3.0, 4.0], # (1, 1, 5, 5) input tensor + [5.0, 6.0, 7.0, 8.0, 9.0], + [10.0, 11.0, 12.0, 13.0, 14.0], + [15.0, 16.0, 17.0, 18.0, 19.0], + [20.0, 21.0, 22.0, 23.0, 24.0], + ] + ] + ] + ).astype(np.float32) + W = np.array( + [ + [ + [ + [1.0, 1.0, 1.0], # (1, 1, 3, 3) tensor for convolution weights + [1.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + ] + ] + ] + ).astype(np.float32) + + # Convolution with padding + node_with_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1 + pads=[1, 1, 1, 1], + ) + y_with_padding = np.array( + [ + [ + [ + [12.0, 21.0, 27.0, 33.0, 24.0], # (1, 1, 5, 5) output tensor + [33.0, 54.0, 63.0, 72.0, 51.0], + [63.0, 99.0, 108.0, 117.0, 81.0], + [93.0, 144.0, 153.0, 162.0, 111.0], + [72.0, 111.0, 117.0, 123.0, 84.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_with_padding, + inputs=[x, W], + outputs=[y_with_padding], + name="test_basic_conv_with_padding", + ) + + # Convolution without padding + node_without_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1 + pads=[0, 0, 0, 0], + ) + y_without_padding = np.array( + [ + [ + [ + [54.0, 63.0, 72.0], # (1, 1, 3, 3) output tensor + [99.0, 108.0, 117.0], + [144.0, 153.0, 162.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_without_padding, + inputs=[x, W], + outputs=[y_without_padding], + name="test_basic_conv_without_padding", + ) + + @staticmethod + def export_conv_with_strides() -> None: + x = np.array( + [ + [ + [ + [0.0, 1.0, 2.0, 3.0, 4.0], # (1, 1, 7, 5) input tensor + [5.0, 6.0, 7.0, 8.0, 9.0], + [10.0, 11.0, 12.0, 13.0, 14.0], + [15.0, 16.0, 17.0, 18.0, 19.0], + [20.0, 21.0, 22.0, 23.0, 24.0], + [25.0, 26.0, 27.0, 28.0, 29.0], + [30.0, 31.0, 32.0, 33.0, 34.0], + ] + ] + ] + ).astype(np.float32) + W = np.array( + [ + [ + [ + [1.0, 1.0, 1.0], # (1, 1, 3, 3) tensor for convolution weights + [1.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + ] + ] + ] + ).astype(np.float32) + + # Convolution with strides=2 and padding + node_with_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[1, 1, 1, 1], + strides=[ + 2, + 2, + ], # Default values for other attributes: dilations=[1, 1], groups=1 + ) + y_with_padding = np.array( + [ + [ + [ + [12.0, 27.0, 24.0], # (1, 1, 4, 3) output tensor + [63.0, 108.0, 81.0], + [123.0, 198.0, 141.0], + [112.0, 177.0, 124.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_with_padding, + inputs=[x, W], + outputs=[y_with_padding], + name="test_conv_with_strides_padding", + ) + + # Convolution with strides=2 and no padding + node_without_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[0, 0, 0, 0], + strides=[ + 2, + 2, + ], # Default values for other attributes: dilations=[1, 1], groups=1 + ) + y_without_padding = np.array( + [ + [ + [ + [54.0, 72.0], # (1, 1, 3, 2) output tensor + [144.0, 162.0], + [234.0, 252.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_without_padding, + inputs=[x, W], + outputs=[y_without_padding], + name="test_conv_with_strides_no_padding", + ) + + # Convolution with strides=2 and padding only along one dimension (the H dimension in NxCxHxW tensor) + node_with_asymmetric_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[1, 0, 1, 0], + strides=[ + 2, + 2, + ], # Default values for other attributes: dilations=[1, 1], groups=1 + ) + y_with_asymmetric_padding = np.array( + [ + [ + [ + [21.0, 33.0], # (1, 1, 4, 2) output tensor + [99.0, 117.0], + [189.0, 207.0], + [171.0, 183.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_with_asymmetric_padding, + inputs=[x, W], + outputs=[y_with_asymmetric_padding], + name="test_conv_with_strides_and_asymmetric_padding", + ) + + @staticmethod + def export_conv_with_autopad_same() -> None: + x = np.array( + [ + [ + [ + [0.0, 1.0, 2.0, 3.0, 4.0], # (1, 1, 5, 5) input tensor + [5.0, 6.0, 7.0, 8.0, 9.0], + [10.0, 11.0, 12.0, 13.0, 14.0], + [15.0, 16.0, 17.0, 18.0, 19.0], + [20.0, 21.0, 22.0, 23.0, 24.0], + ] + ] + ] + ).astype(np.float32) + W = np.array( + [ + [ + [ + [1.0, 1.0, 1.0], # (1, 1, 3, 3) tensor for convolution weights + [1.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + ] + ] + ] + ).astype(np.float32) + + # Convolution with auto_pad='SAME_LOWER' and strides=2 + node = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + auto_pad="SAME_LOWER", + kernel_shape=[3, 3], + strides=[2, 2], + ) + y = np.array( + [[[[12.0, 27.0, 24.0], [63.0, 108.0, 81.0], [72.0, 117.0, 84.0]]]] + ).astype(np.float32) + expect(node, inputs=[x, W], outputs=[y], name="test_conv_with_autopad_same") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/convinteger.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/convinteger.py new file mode 100644 index 0000000000000000000000000000000000000000..1b000a2bb391c8f43db46cb192334d0027ef3c09 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/convinteger.py @@ -0,0 +1,103 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ConvInteger(Base): + @staticmethod + def export_without_padding() -> None: + x = ( + np.array([2, 3, 4, 5, 6, 7, 8, 9, 10]) + .astype(np.uint8) + .reshape((1, 1, 3, 3)) + ) + x_zero_point = np.uint8(1) + w = np.array([1, 1, 1, 1]).astype(np.uint8).reshape((1, 1, 2, 2)) + + y = np.array([12, 16, 24, 28]).astype(np.int32).reshape(1, 1, 2, 2) + + # ConvInteger without padding + convinteger_node = onnx.helper.make_node( + "ConvInteger", inputs=["x", "w", "x_zero_point"], outputs=["y"] + ) + + expect( + convinteger_node, + inputs=[x, w, x_zero_point], + outputs=[y], + name="test_convinteger_without_padding", + ) + + @staticmethod + def export_with_padding() -> None: + x = ( + np.array([2, 3, 4, 5, 6, 7, 8, 9, 10]) + .astype(np.uint8) + .reshape((1, 1, 3, 3)) + ) + x_zero_point = np.uint8(1) + w_zero_points = np.array([0, 1], dtype=np.uint8) + w = np.array([1, 1, 1, 1, 1, 1, 1, 1]).astype(np.uint8).reshape((2, 1, 2, 2)) + + y = ( + np.array( + [ + 1, + 3, + 5, + 3, + 5, + 12, + 16, + 9, + 11, + 24, + 28, + 15, + 7, + 15, + 17, + 9, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ] + ) + .astype(np.int32) + .reshape((1, 2, 4, 4)) + ) + + # ConvInteger with padding + convinteger_node_with_padding = onnx.helper.make_node( + "ConvInteger", + inputs=["x", "w", "x_zero_point", "w_zero_points"], + outputs=["y"], + pads=[1, 1, 1, 1], + ) + + expect( + convinteger_node_with_padding, + inputs=[x, w, x_zero_point, w_zero_points], + outputs=[y], + name="test_convinteger_with_padding", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/convtranspose.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/convtranspose.py new file mode 100644 index 0000000000000000000000000000000000000000..64a9fdd088107811024280fd6de4ceb94dd96aeb --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/convtranspose.py @@ -0,0 +1,532 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ConvTranspose(Base): + @staticmethod + def export() -> None: + x = np.array( + [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], # (1, 2, 3, 3) + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"]) + + y = np.array( + [ + [ + [ + [0.0, 1.0, 3.0, 3.0, 2.0], # (1, 2, 5, 5) + [3.0, 8.0, 15.0, 12.0, 7.0], + [9.0, 21.0, 36.0, 27.0, 15.0], + [9.0, 20.0, 33.0, 24.0, 13.0], + [6.0, 13.0, 21.0, 15.0, 8.0], + ], + [ + [0.0, 1.0, 3.0, 3.0, 2.0], + [3.0, 8.0, 15.0, 12.0, 7.0], + [9.0, 21.0, 36.0, 27.0, 15.0], + [9.0, 20.0, 33.0, 24.0, 13.0], + [6.0, 13.0, 21.0, 15.0, 8.0], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose") + + @staticmethod + def export_convtranspose_1d() -> None: + x = np.array([[[0.0, 1.0, 2.0]]]).astype(np.float32) # (1, 1, 3) + + W = np.array([[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]]).astype( # (1, 2, 3) + np.float32 + ) + + node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"]) + + y = np.array( + [[[0.0, 1.0, 3.0, 3.0, 2.0], [0.0, 1.0, 3.0, 3.0, 2.0]]] # (1, 2, 5) + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_1d") + + @staticmethod + def export_convtranspose_3d() -> None: + x = np.array( + [ + [ + [ + [ + [0.0, 1.0, 2.0, 3.0, 4.0], # (1, 1, 3, 4, 5) + [5.0, 6.0, 7.0, 8.0, 9.0], + [10.0, 11.0, 12.0, 13.0, 14.0], + [15.0, 16.0, 17.0, 18.0, 19.0], + ], + [ + [20.0, 21.0, 22.0, 23.0, 24.0], + [25.0, 26.0, 27.0, 28.0, 29.0], + [30.0, 31.0, 32.0, 33.0, 34.0], + [35.0, 36.0, 37.0, 38.0, 39.0], + ], + [ + [40.0, 41.0, 42.0, 43.0, 44.0], + [45.0, 46.0, 47.0, 48.0, 49.0], + [50.0, 51.0, 52.0, 53.0, 54.0], + [55.0, 56.0, 57.0, 58.0, 59.0], + ], + ] + ] + ] + ).astype(np.float32) + + W = np.array( + [ + [ + [ + [ + [1.0, 1.0, 1.0], # (1, 2, 3, 3, 3) + [1.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + ], + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ], + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"]) + + y = np.array( + [ + [ + [ + [ + [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0], # (1, 2, 5, 6, 7) + [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0], + [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0], + [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0], + [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0], + [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0], + ], + [ + [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0], + [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0], + [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0], + [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0], + [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0], + [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0], + ], + [ + [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0], + [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0], + [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0], + [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0], + [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0], + [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0], + ], + [ + [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0], + [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0], + [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0], + [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0], + [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0], + [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0], + ], + [ + [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0], + [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0], + [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0], + [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0], + [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0], + [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0], + ], + ], + [ + [ + [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0], + [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0], + [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0], + [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0], + [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0], + [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0], + ], + [ + [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0], + [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0], + [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0], + [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0], + [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0], + [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0], + ], + [ + [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0], + [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0], + [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0], + [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0], + [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0], + [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0], + ], + [ + [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0], + [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0], + [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0], + [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0], + [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0], + [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0], + ], + [ + [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0], + [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0], + [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0], + [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0], + [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0], + [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0], + ], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_3d") + + @staticmethod + def export_convtranspose_attributes() -> None: + x = np.array( + [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], # (1, 2, 3, 3) + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ] + ] + ).astype(np.float32) + + y = np.array( + [ + [ + [ + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], # (1, 2, 10, 8) + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + ], + [ + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + ], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_shape=[10, 8] + ) + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_output_shape") + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_padding=[1, 1] + ) + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pad") + + node = onnx.helper.make_node( + "ConvTranspose", + ["X", "W"], + ["Y"], + name="test", + strides=[3, 2], + output_shape=[10, 8], + kernel_shape=[3, 3], + output_padding=[1, 1], + ) + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_kernel_shape") + + @staticmethod + def export_convtranspose_pads() -> None: + x = np.array( + [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], # (1, 2, 3, 3) + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], pads=[1, 2, 1, 2] + ) + + y = np.array( + [ + [ + [ + [1.0, 1.0, 3.0], # (1, 2, 7, 3) + [1.0, 1.0, 3.0], + [7.0, 4.0, 9.0], + [7.0, 4.0, 9.0], + [7.0, 4.0, 9.0], + [13.0, 7.0, 15.0], + [13.0, 7.0, 15.0], + ], + [ + [1.0, 1.0, 3.0], + [1.0, 1.0, 3.0], + [7.0, 4.0, 9.0], + [7.0, 4.0, 9.0], + [7.0, 4.0, 9.0], + [13.0, 7.0, 15.0], + [13.0, 7.0, 15.0], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pads") + + @staticmethod + def export_convtranspose_dilations() -> None: + x = np.array( + [[[[3.0, 8.0, 1.0], [9.0, 5.0, 7.0], [3.0, 2.0, 6.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + W = np.array([[[[7.0, 2.0], [1.0, 9.0]]]]).astype(np.float32) # (1, 1, 2, 2) + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], dilations=[2, 2] + ) + + y = np.array( + [ + [ + [ + [21.0, 56.0, 13.0, 16.0, 2.0], # [1, 1, 5, 5] + [63.0, 35.0, 67.0, 10.0, 14.0], + [24.0, 22.0, 76.0, 76.0, 21.0], + [9.0, 5.0, 88.0, 45.0, 63.0], + [3.0, 2.0, 33.0, 18.0, 54.0], + ] + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_dilations") + + @staticmethod + def export_convtranspose_autopad_same() -> None: + x = np.array( + [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], # (1, 2, 3, 3) + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], auto_pad="SAME_UPPER", strides=[2, 2] + ) + + y = np.array( + [ + [ + [ + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0], + [3.0, 3.0, 8.0, 5.0, 12.0, 7.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0], + [9.0, 9.0, 20.0, 11.0, 24.0, 13.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0], + ], + [ + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0], + [3.0, 3.0, 8.0, 5.0, 12.0, 7.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0], + [9.0, 9.0, 20.0, 11.0, 24.0, 13.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_autopad_same") + + @staticmethod + def export_convtranspose_group_2() -> None: + x = np.array( + [ + [ + [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]], + [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]], + ] + ] + ).astype(np.float32) + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ], + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ], + ] + ).astype(np.float32) + + node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=2) + + y = np.array( + [ + [ + [ + [0.0, 1.0, 3.0, 3.0, 2.0], + [3.0, 8.0, 15.0, 12.0, 7.0], + [9.0, 21.0, 36.0, 27.0, 15.0], + [9.0, 20.0, 33.0, 24.0, 13.0], + [6.0, 13.0, 21.0, 15.0, 8.0], + ], + [ + [9.0, 19.0, 30.0, 21.0, 11.0], + [21.0, 44.0, 69.0, 48.0, 25.0], + [36.0, 75.0, 117.0, 81.0, 42.0], + [27.0, 56.0, 87.0, 60.0, 31.0], + [15.0, 31.0, 48.0, 33.0, 17.0], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_group_2") + + @staticmethod + def export_convtranspose_group_2_image_3() -> None: + x = np.array( + [ + [ + [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]], + [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]], + ], + [ + [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0], [24.0, 25.0, 26.0]], + [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]], + ], + [ + [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]], + [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]], + ], + ] + ).astype(np.float32) + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ], + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ], + ] + ).astype(np.float32) + + node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=2) + + y = np.array( + [ + [ + [ + [0.0, 1.0, 3.0, 3.0, 2.0], + [3.0, 8.0, 15.0, 12.0, 7.0], + [9.0, 21.0, 36.0, 27.0, 15.0], + [9.0, 20.0, 33.0, 24.0, 13.0], + [6.0, 13.0, 21.0, 15.0, 8.0], + ], + [ + [9.0, 19.0, 30.0, 21.0, 11.0], + [21.0, 44.0, 69.0, 48.0, 25.0], + [36.0, 75.0, 117.0, 81.0, 42.0], + [27.0, 56.0, 87.0, 60.0, 31.0], + [15.0, 31.0, 48.0, 33.0, 17.0], + ], + ], + [ + [ + [18.0, 37.0, 57.0, 39.0, 20.0], + [39.0, 80.0, 123.0, 84.0, 43.0], + [63.0, 129.0, 198.0, 135.0, 69.0], + [45.0, 92.0, 141.0, 96.0, 49.0], + [24.0, 49.0, 75.0, 51.0, 26.0], + ], + [ + [9.0, 19.0, 30.0, 21.0, 11.0], + [21.0, 44.0, 69.0, 48.0, 25.0], + [36.0, 75.0, 117.0, 81.0, 42.0], + [27.0, 56.0, 87.0, 60.0, 31.0], + [15.0, 31.0, 48.0, 33.0, 17.0], + ], + ], + [ + [ + [0.0, 1.0, 3.0, 3.0, 2.0], + [3.0, 8.0, 15.0, 12.0, 7.0], + [9.0, 21.0, 36.0, 27.0, 15.0], + [9.0, 20.0, 33.0, 24.0, 13.0], + [6.0, 13.0, 21.0, 15.0, 8.0], + ], + [ + [9.0, 19.0, 30.0, 21.0, 11.0], + [21.0, 44.0, 69.0, 48.0, 25.0], + [36.0, 75.0, 117.0, 81.0, 42.0], + [27.0, 56.0, 87.0, 60.0, 31.0], + [15.0, 31.0, 48.0, 33.0, 17.0], + ], + ], + ] + ).astype(np.float32) + + expect( + node, inputs=[x, W], outputs=[y], name="test_convtranspose_group_2_image_3" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cos.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cos.py new file mode 100644 index 0000000000000000000000000000000000000000..ce520931e0161d8f1f81e983a655874fedf9e537 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cos.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Cos(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Cos", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.cos(x) + expect(node, inputs=[x], outputs=[y], name="test_cos_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.cos(x) + expect(node, inputs=[x], outputs=[y], name="test_cos") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cosh.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cosh.py new file mode 100644 index 0000000000000000000000000000000000000000..2c3bf23a0d433006a95c726824473c733a0fc859 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cosh.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Cosh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Cosh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.cosh(x) # expected output [1.54308069, 1., 1.54308069] + expect(node, inputs=[x], outputs=[y], name="test_cosh_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.cosh(x) + expect(node, inputs=[x], outputs=[y], name="test_cosh") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cumprod.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cumprod.py new file mode 100644 index 0000000000000000000000000000000000000000..3b75dedd9752a2f9b3c1aad82747cc34d7cf29ba --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cumprod.py @@ -0,0 +1,129 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class CumProd(Base): + @staticmethod + def export_cumprod_1d() -> None: + node = onnx.helper.make_node("CumProd", inputs=["x", "axis"], outputs=["y"]) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.array(0, dtype=np.int32) + y = np.array([1.0, 2.0, 6.0, 24.0, 120.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d") + + @staticmethod + def export_cumprod_1d_exclusive() -> None: + node = onnx.helper.make_node( + "CumProd", inputs=["x", "axis"], outputs=["y"], exclusive=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.array(0, dtype=np.int32) + y = np.array([1.0, 1.0, 2.0, 6.0, 24.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_exclusive") + + @staticmethod + def export_cumprod_1d_reverse() -> None: + node = onnx.helper.make_node( + "CumProd", inputs=["x", "axis"], outputs=["y"], reverse=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.array(0, dtype=np.int32) + y = np.array([120.0, 120.0, 60.0, 20.0, 5.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_reverse") + + @staticmethod + def export_cumprod_1d_reverse_exclusive() -> None: + node = onnx.helper.make_node( + "CumProd", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.array(0, dtype=np.int32) + y = np.array([120.0, 60.0, 20.0, 5.0, 1.0]).astype(np.float64) + expect( + node, + inputs=[x, axis], + outputs=[y], + name="test_cumprod_1d_reverse_exclusive", + ) + + @staticmethod + def export_cumprod_2d_axis_0() -> None: + node = onnx.helper.make_node( + "CumProd", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.array(0, dtype=np.int32) + y = ( + np.array([1.0, 2.0, 3.0, 4.0, 10.0, 18.0]) + .astype(np.float64) + .reshape((2, 3)) + ) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_axis_0") + + @staticmethod + def export_cumprod_2d_axis_1() -> None: + node = onnx.helper.make_node( + "CumProd", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.array(1, dtype=np.int32) + y = ( + np.array([1.0, 2.0, 6.0, 4.0, 20.0, 120.0]) + .astype(np.float64) + .reshape((2, 3)) + ) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_axis_1") + + @staticmethod + def export_cumprod_2d_negative_axis() -> None: + node = onnx.helper.make_node( + "CumProd", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.array(-1, dtype=np.int32) + y = ( + np.array([1.0, 2.0, 6.0, 4.0, 20.0, 120.0]) + .astype(np.float64) + .reshape((2, 3)) + ) + expect( + node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_negative_axis" + ) + + @staticmethod + def export_cumprod_2d_int32() -> None: + node = onnx.helper.make_node( + "CumProd", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3)) + axis = np.array(0, dtype=np.int32) + y = np.array([1, 2, 3, 4, 10, 18]).astype(np.int32).reshape((2, 3)) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_int32") + + @staticmethod + def export_cumprod_1d_int32_exclusive() -> None: + node = onnx.helper.make_node( + "CumProd", inputs=["x", "axis"], outputs=["y"], exclusive=1 + ) + x = np.array([1, 2, 3, 4, 5]).astype(np.int32) + axis = np.array(0, dtype=np.int32) + y = np.array([1, 1, 2, 6, 24]).astype(np.int32) + expect( + node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_int32_exclusive" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cumsum.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cumsum.py new file mode 100644 index 0000000000000000000000000000000000000000..81a35f2a5438c07142d17cde0974490cf9867b32 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/cumsum.py @@ -0,0 +1,112 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class CumSum(Base): + @staticmethod + def export_cumsum_1d() -> None: + node = onnx.helper.make_node("CumSum", inputs=["x", "axis"], outputs=["y"]) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.int32(0) + y = np.array([1.0, 3.0, 6.0, 10.0, 15.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d") + + @staticmethod + def export_cumsum_1d_exclusive() -> None: + node = onnx.helper.make_node( + "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.int32(0) + y = np.array([0.0, 1.0, 3.0, 6.0, 10.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_exclusive") + + @staticmethod + def export_cumsum_1d_reverse() -> None: + node = onnx.helper.make_node( + "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.int32(0) + y = np.array([15.0, 14.0, 12.0, 9.0, 5.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse") + + @staticmethod + def export_cumsum_1d_reverse_exclusive() -> None: + node = onnx.helper.make_node( + "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.int32(0) + y = np.array([14.0, 12.0, 9.0, 5.0, 0.0]).astype(np.float64) + expect( + node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse_exclusive" + ) + + @staticmethod + def export_cumsum_2d_axis_0() -> None: + node = onnx.helper.make_node( + "CumSum", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.int32(0) + y = np.array([1.0, 2.0, 3.0, 5.0, 7.0, 9.0]).astype(np.float64).reshape((2, 3)) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_0") + + @staticmethod + def export_cumsum_2d_axis_1() -> None: + node = onnx.helper.make_node( + "CumSum", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.int32(1) + y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3)) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_1") + + @staticmethod + def export_cumsum_2d_negative_axis() -> None: + node = onnx.helper.make_node( + "CumSum", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.int32(-1) + y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3)) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_negative_axis") + + @staticmethod + def export_cumsum_2d_int32() -> None: + node = onnx.helper.make_node( + "CumSum", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3)) + axis = np.int32(0) + y = np.array([1, 2, 3, 5, 7, 9]).astype(np.int32).reshape((2, 3)) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_int32") + + @staticmethod + def export_cumsum_1d_int32_exclusive() -> None: + node = onnx.helper.make_node( + "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1 + ) + x = np.array([1, 2, 3, 4, 5]).astype(np.int32) + axis = np.int32(0) + y = np.array([0, 1, 3, 6, 10]).astype(np.int32) + expect( + node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_int32_exclusive" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/deformconv.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/deformconv.py new file mode 100644 index 0000000000000000000000000000000000000000..85c53f440ec678371b54c3b81148c5336d716a43 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/deformconv.py @@ -0,0 +1,161 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class DeformConv(Base): + @staticmethod + def export() -> None: + X = np.arange(9).astype(np.float32) + X.shape = (1, 1, 3, 3) + W = np.ones((1, 1, 2, 2), dtype=np.float32) + + # Convolution with padding + offset_with_padding = np.zeros((1, 8, 4, 4), dtype=np.float32) + # h-coord of [0, 0] element of kernel, at output position [0, 0] + offset_with_padding[0, 0, 0, 0] = 0.5 + # w-coord of [1, 0] element of kernel, at output position [1, 2] + offset_with_padding[0, 5, 1, 2] = -0.1 + + node_with_padding = onnx.helper.make_node( + "DeformConv", + inputs=["X", "W", "offset_with_padding"], + outputs=["Y_with_padding"], + kernel_shape=[2, 2], + pads=[1, 1, 1, 1], + ) + Y_with_padding = np.array( + [ + [ + [ + [0.0, 1.0, 3.0, 2.0], # (1, 1, 4, 4) output tensor + [3.0, 8.0, 11.9, 7.0], + [9.0, 20.0, 24.0, 13.0], + [6.0, 13.0, 15.0, 8.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_with_padding, + inputs=[X, W, offset_with_padding], + outputs=[Y_with_padding], + name="test_basic_deform_conv_with_padding", + ) + + # Convolution without padding + offset_without_padding = np.zeros((1, 8, 2, 2), dtype=np.float32) + # h-coord of [0, 0] element of kernel, at output position [0, 0] + offset_without_padding[0, 0, 0, 0] = 0.5 + # w-coord of [1, 0] element of kernel, at output position [0, 1] + offset_without_padding[0, 5, 0, 1] = -0.1 + + node_without_padding = onnx.helper.make_node( + "DeformConv", + inputs=["X", "W", "offset_without_padding"], + outputs=["Y_without_padding"], + kernel_shape=[2, 2], + pads=[0, 0, 0, 0], + ) + Y_without_padding = np.array( + [ + [ + [ + [9.5, 11.9], # (1, 1, 2, 2) output tensor + [20.0, 24.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_without_padding, + inputs=[X, W, offset_without_padding], + outputs=[Y_without_padding], + name="test_basic_deform_conv_without_padding", + ) + + @staticmethod + def export_deformconv_with_mask_bias() -> None: + X = np.arange(9).astype(np.float32) + X.shape = (1, 1, 3, 3) + W = np.ones((1, 1, 2, 2), dtype=np.float32) + B = np.ones((1,), dtype=np.float32) + + offset = np.zeros((1, 8, 2, 2), dtype=np.float32) + # h-coord of [0, 0] element of kernel, at output position [0, 0] + offset[0, 0, 0, 0] = 0.5 + # w-coord of [1, 0] element of kernel, at output position [0, 1] + offset[0, 5, 0, 1] = -0.1 + + mask = np.ones((1, 4, 2, 2), dtype=np.float32) + mask[0, 2, 1, 1] = 0.2 # [1, 0] element of kernel at output position [1, 1] + + node = onnx.helper.make_node( + "DeformConv", + inputs=["X", "W", "offset", "B", "mask"], + outputs=["Y"], + kernel_shape=[2, 2], + pads=[0, 0, 0, 0], + ) + Y = np.array( + [ + [ + [ + [10.5, 12.9], # (1, 1, 2, 2) output tensor + [21.0, 19.4], + ] + ] + ] + ).astype(np.float32) + expect( + node, + inputs=[X, W, offset, B, mask], + outputs=[Y], + name="test_deform_conv_with_mask_bias", + ) + + @staticmethod + def export_deformconv_with_multiple_offset_groups() -> None: + X = np.zeros((1, 2, 3, 3), dtype=np.float32) + X[0, 0] = np.reshape(np.arange(9).astype(np.float32), (3, 3)) + X[0, 1] = np.reshape(np.arange(8, -1, -1).astype(np.float32), (3, 3)) + X.shape = (1, 2, 3, 3) + W = np.ones((1, 2, 2, 2), dtype=np.float32) + + offset = np.zeros((1, 16, 2, 2), dtype=np.float32) + # h-coord of [0, 0] element of kernel in channel 0, at output position [0, 0] + offset[0, 0, 0, 0] = 0.5 + # w-coord of [1, 0] element of kernel in channel 1, at output position [0, 1] + offset[0, 13, 0, 1] = -0.1 + + node = onnx.helper.make_node( + "DeformConv", + inputs=["X", "W", "offset"], + outputs=["Y"], + kernel_shape=[2, 2], + pads=[0, 0, 0, 0], + offset_group=2, + ) + Y = np.array( + [ + [ + [ + [33.5, 32.1], # (1, 1, 2, 2) output tensor + [32.0, 32.0], + ] + ] + ] + ).astype(np.float32) + expect( + node, + inputs=[X, W, offset], + outputs=[Y], + name="test_deform_conv_with_multiple_offset_groups", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/depthtospace.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/depthtospace.py new file mode 100644 index 0000000000000000000000000000000000000000..0049f9e968190136cd78311093119341574173f8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/depthtospace.py @@ -0,0 +1,98 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class DepthToSpace(Base): + @staticmethod + def export_default_mode_example() -> None: + node = onnx.helper.make_node( + "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="DCR" + ) + + # (1, 8, 2, 3) input tensor + x = np.array( + [ + [ + [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]], + [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]], + [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]], + [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]], + [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]], + [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]], + [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]], + [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]], + ] + ] + ).astype(np.float32) + + # (1, 2, 4, 6) output tensor + y = np.array( + [ + [ + [ + [0.0, 18.0, 1.0, 19.0, 2.0, 20.0], + [36.0, 54.0, 37.0, 55.0, 38.0, 56.0], + [3.0, 21.0, 4.0, 22.0, 5.0, 23.0], + [39.0, 57.0, 40.0, 58.0, 41.0, 59.0], + ], + [ + [9.0, 27.0, 10.0, 28.0, 11.0, 29.0], + [45.0, 63.0, 46.0, 64.0, 47.0, 65.0], + [12.0, 30.0, 13.0, 31.0, 14.0, 32.0], + [48.0, 66.0, 49.0, 67.0, 50.0, 68.0], + ], + ] + ] + ).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_depthtospace_example") + + @staticmethod + def export_crd_mode_example() -> None: + node = onnx.helper.make_node( + "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="CRD" + ) + + # (1, 8, 2, 3) input tensor + x = np.array( + [ + [ + [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]], + [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]], + [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]], + [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]], + [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]], + [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]], + [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]], + [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]], + ] + ] + ).astype(np.float32) + + # (1, 2, 4, 6) output tensor + y = np.array( + [ + [ + [ + [0.0, 9.0, 1.0, 10.0, 2.0, 11.0], + [18.0, 27.0, 19.0, 28.0, 20.0, 29.0], + [3.0, 12.0, 4.0, 13.0, 5.0, 14.0], + [21.0, 30.0, 22.0, 31.0, 23.0, 32.0], + ], + [ + [36.0, 45.0, 37.0, 46.0, 38.0, 47.0], + [54.0, 63.0, 55.0, 64.0, 56.0, 65.0], + [39.0, 48.0, 40.0, 49.0, 41.0, 50.0], + [57.0, 66.0, 58.0, 67.0, 59.0, 68.0], + ], + ] + ] + ).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_depthtospace_crd_mode_example") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dequantizelinear.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dequantizelinear.py new file mode 100644 index 0000000000000000000000000000000000000000..d1b8b5504e5d9ca9619f89f3114bf20c028379ce --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dequantizelinear.py @@ -0,0 +1,373 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx import TensorProto +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import make_tensor + + +class DequantizeLinear(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + ) + + # scalar zero point and scale + x = np.array([0, 3, 128, 255]).astype(np.uint8) + x_scale = np.float32(2) + x_zero_point = np.uint8(128) + y = np.array([-256, -250, 0, 254], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear", + ) + + @staticmethod + def export_axis() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + ) + + # 1-D tensor zero point and scale of size equal to axis 1 of the input tensor + x = np.array( + [ + [ + [[3, 89], [34, 200], [74, 59]], + [[5, 24], [24, 87], [32, 13]], + [[245, 99], [4, 142], [121, 102]], + ], + ], + dtype=np.uint8, + ) + x_scale = np.array([2, 4, 5], dtype=np.float32) + x_zero_point = np.array([84, 24, 196], dtype=np.uint8) + y = ( + x.astype(np.float32) - x_zero_point.reshape(1, 3, 1, 1).astype(np.float32) + ) * x_scale.reshape(1, 3, 1, 1) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_axis", + ) + + @staticmethod + def export_e4m3fn() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104]) + x_scale = np.float32(2) + y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale], + outputs=[y], + name="test_dequantizelinear_e4m3fn", + ) + + @staticmethod + def export_e4m3fn_float16() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104]) + x_scale = np.float16(2) + y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float16) + + expect( + node, + inputs=[x, x_scale], + outputs=[y], + name="test_dequantizelinear_e4m3fn_float16", + ) + + @staticmethod + def export_e4m3fn_zero_point() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "zero_point"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104]) + zero_point = make_tensor("zero_point", TensorProto.FLOAT8E4M3FN, [1], [0]) + x_scale = np.float32(2) + y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, zero_point], + outputs=[y], + name="test_dequantizelinear_e4m3fn_zero_point", + ) + + @staticmethod + def export_e5m2() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, -96]) + x_scale = np.float32(2) + y = np.array([0.0, 1.0, 2.0, 98304.0, -192.0], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale], + outputs=[y], + name="test_dequantizelinear_e5m2", + ) + + @staticmethod + def export_uint16() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + ) + + x = np.array([30000, 31000, 32768, 33000]).astype(np.uint16) + x_scale = np.float32(2) + x_zero_point = np.uint16(32767) + y = np.array([-5534.0, -3534.0, 2.0, 466.0], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_uint16", + ) + + @staticmethod + def export_int16() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + ) + + x = np.array([-300, -30, -1025, 1270]).astype(np.int16) + x_scale = np.float32(2) + x_zero_point = np.int16(-1024) + y = np.array([1448.0, 1988.0, -2.0, 4588.0], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_int16", + ) + + @staticmethod + def export_uint4() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.UINT4, [5], [0, 1, 7, 10, 15]) + x_scale = np.float32(2) + x_zero_point = make_tensor("x_zero_point", TensorProto.UINT4, (1,), [1]) + y = np.array([-2, 0, 12, 18, 28], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_uint4", + ) + + @staticmethod + def export_int4() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.INT4, [5], [0, 1, 7, -4, -8]) + x_scale = np.float32(2) + x_zero_point = make_tensor("x_zero_point", TensorProto.INT4, (1,), [1]) + y = np.array([-2, 0, 12, -10, -18], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_int4", + ) + + @staticmethod + def export_uint2() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.UINT2, [4], [0, 1, 2, 3]) + x_scale = np.float32(2) + x_zero_point = make_tensor("x_zero_point", TensorProto.UINT2, (1,), [1]) + y = np.array([-2, 0, 2, 4], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_uint2", + ) + + @staticmethod + def export_int2() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.INT2, [4], [0, 1, -1, -2]) + x_scale = np.float32(2) + x_zero_point = make_tensor("x_zero_point", TensorProto.INT2, (1,), [1]) + y = np.array([-2, 0, -4, -6], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_int2", + ) + + @staticmethod + def export_float4e2m1() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + axis=0, + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.FLOAT4E2M1, [5], [0, 1, -1, 1.5, -4]) + x_scale = np.float32(2) + x_zero_point = make_tensor("x_zero_point", TensorProto.FLOAT4E2M1, (1,), [0]) + y = np.array([0, 2, -2, 3, -8], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_float4e2m1", + ) + + @staticmethod + def export_blocked() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + axis=1, + block_size=2, + ) + + x = np.array( + [ + [ + [[3, 89], [34, 200], [74, 59]], + [[5, 24], [24, 87], [32, 13]], + [[5, 12], [12, 33], [65, 42]], + [[245, 99], [4, 142], [121, 102]], + ], + ], + dtype=np.uint8, + ) + + x_scale = np.array( + [ + [ + [[3.0, 2.0], [4.0, 1.0], [2.0, 2.0]], + [[5.0, 2.0], [4.0, 3.0], [5.0, 2.0]], + ], + ], + dtype=np.float32, + ) + x_zero_point = np.array( + [ + [ + [[1, 0], [0, 1], [2, 20]], + [[3, 2], [4, 3], [15, 2]], + ], + ], + dtype=np.uint8, + ) + + # x.shape = (1, 4, 3, 2) + # x_scale.shape = (1, 2, 3, 2) + assert x_scale.shape == x_zero_point.shape + block_axis = 1 + # The block shape is [x.shape[i] // x_scale.shape[i] for i in range(len(x.shape))] = (1, 2, 1, 1) + assert all( + x.shape[i] == x_scale.shape[i] + for i in range(len(x.shape)) + if i != block_axis + ) + assert x.shape[block_axis] % x_scale.shape[block_axis] == 0 + repeats = x.shape[block_axis] // x_scale.shape[block_axis] + + # Create element-wise scale and zero point + x_scale_elementwise = np.repeat(x_scale, repeats=repeats, axis=block_axis) + x_zero_point_elementwise = np.repeat( + x_zero_point, repeats=repeats, axis=block_axis + ) + + y = ( + x.astype(np.float32) - x_zero_point_elementwise.astype(np.float32) + ) * x_scale_elementwise + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_blocked", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/det.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/det.py new file mode 100644 index 0000000000000000000000000000000000000000..0815b95200196a7900cbf01bbd5db154a7557c0e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/det.py @@ -0,0 +1,38 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Det(Base): + @staticmethod + def export_2d() -> None: + node = onnx.helper.make_node( + "Det", + inputs=["x"], + outputs=["y"], + ) + + x = np.arange(4).reshape(2, 2).astype(np.float32) + y = np.linalg.det(x) # expect -2 + expect(node, inputs=[x], outputs=[y], name="test_det_2d") + + @staticmethod + def export_nd() -> None: + node = onnx.helper.make_node( + "Det", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([[[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]]]).astype( + np.float32 + ) + y = np.linalg.det(x) # expect array([-2., -3., -8.]) + expect(node, inputs=[x], outputs=[y], name="test_det_nd") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dft.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dft.py new file mode 100644 index 0000000000000000000000000000000000000000..713cc8b8949087325ec3097d1e7d37c2dae6a2c0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dft.py @@ -0,0 +1,152 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class DFT(Base): + @staticmethod + def export_opset19() -> None: + node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=1) + x = np.arange(0, 100).reshape(10, 10).astype(np.float32) + y = np.fft.fft(x, axis=0) + + x = x.reshape(1, 10, 10, 1) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect( + node, + inputs=[x], + outputs=[y], + name="test_dft_opset19", + opset_imports=[onnx.helper.make_opsetid("", 19)], + ) + + node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=2) + x = np.arange(0, 100).reshape(10, 10).astype(np.float32) + y = np.fft.fft(x, axis=1) + + x = x.reshape(1, 10, 10, 1) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect( + node, + inputs=[x], + outputs=[y], + name="test_dft_axis_opset19", + opset_imports=[onnx.helper.make_opsetid("", 19)], + ) + + node = onnx.helper.make_node( + "DFT", inputs=["x"], outputs=["y"], inverse=1, axis=1 + ) + x = np.arange(0, 100, dtype=np.complex64).reshape( + 10, + 10, + ) + y = np.fft.ifft(x, axis=0) + + x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect( + node, + inputs=[x], + outputs=[y], + name="test_dft_inverse_opset19", + opset_imports=[onnx.helper.make_opsetid("", 19)], + ) + + # Test RFFT (Real FFT): real input -> one-sided complex output + node = onnx.helper.make_node( + "DFT", inputs=["x"], outputs=["y"], onesided=1, axis=1 + ) + x = np.arange(0, 100).reshape(10, 10).astype(np.float32) + y = np.fft.rfft(x, axis=0) + + x = x.reshape(1, 10, 10, 1) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2) + expect( + node, + inputs=[x], + outputs=[y], + name="test_dft_rfft_opset19", + opset_imports=[onnx.helper.make_opsetid("", 19)], + ) + + # Test IRFFT (Inverse Real FFT): one-sided complex input -> real output + node = onnx.helper.make_node( + "DFT", inputs=["x"], outputs=["y"], onesided=1, inverse=1, axis=1 + ) + # Create one-sided complex input (6 bins for signal length 10) + x = np.fft.rfft(np.arange(0, 100).reshape(10, 10), axis=0).astype(np.complex64) + y = np.fft.irfft(x, n=10, axis=0) + + x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2) + y = y.reshape(1, 10, 10, 1).astype(np.float32) + expect( + node, + inputs=[x], + outputs=[y], + name="test_dft_irfft_opset19", + opset_imports=[onnx.helper.make_opsetid("", 19)], + ) + + @staticmethod + def export() -> None: + node = onnx.helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"]) + x = np.arange(0, 100).reshape(10, 10).astype(np.float32) + axis = np.array(1, dtype=np.int64) + y = np.fft.fft(x, axis=0) + + x = x.reshape(1, 10, 10, 1) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect(node, inputs=[x, axis], outputs=[y], name="test_dft") + + node = onnx.helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"]) + x = np.arange(0, 100).reshape(10, 10).astype(np.float32) + axis = np.array(2, dtype=np.int64) + y = np.fft.fft(x, axis=1) + + x = x.reshape(1, 10, 10, 1) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect(node, inputs=[x, axis], outputs=[y], name="test_dft_axis") + + node = onnx.helper.make_node( + "DFT", inputs=["x", "", "axis"], outputs=["y"], inverse=1 + ) + x = np.arange(0, 100, dtype=np.complex64).reshape(10, 10) + axis = np.array(1, dtype=np.int64) + y = np.fft.ifft(x, axis=0) + + x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect(node, inputs=[x, axis], outputs=[y], name="test_dft_inverse") + + # Test RFFT (Real FFT): real input -> one-sided complex output + node = onnx.helper.make_node( + "DFT", inputs=["x", "", "axis"], outputs=["y"], onesided=1 + ) + x = np.arange(0, 100).reshape(10, 10).astype(np.float32) + axis = np.array(1, dtype=np.int64) + y = np.fft.rfft(x, axis=0) + + x = x.reshape(1, 10, 10, 1) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2) + expect(node, inputs=[x, axis], outputs=[y], name="test_dft_rfft") + + # Test IRFFT (Inverse Real FFT): one-sided complex input -> real output + node = onnx.helper.make_node( + "DFT", inputs=["x", "", "axis"], outputs=["y"], onesided=1, inverse=1 + ) + # Create one-sided complex input (6 bins for signal length 10) + x = np.fft.rfft(np.arange(0, 100).reshape(10, 10), axis=0).astype(np.complex64) + axis = np.array(1, dtype=np.int64) + y = np.fft.irfft(x, n=10, axis=0) + + x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2) + y = y.reshape(1, 10, 10, 1).astype(np.float32) + expect(node, inputs=[x, axis], outputs=[y], name="test_dft_irfft") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/div.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/div.py new file mode 100644 index 0000000000000000000000000000000000000000..0b34c7122f4082f75f9c5e88d5e3875c1577b2ff --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/div.py @@ -0,0 +1,78 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Div(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Div", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([3, 4]).astype(np.float32) + y = np.array([1, 2]).astype(np.float32) + z = x / y # expected output [3., 2.] + expect(node, inputs=[x, y], outputs=[z], name="test_div_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.rand(3, 4, 5).astype(np.float32) + 1.0 + z = x / y + expect(node, inputs=[x, y], outputs=[z], name="test_div") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + 1 + z = x // y + expect(node, inputs=[x, y], outputs=[z], name="test_div_int8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + 1 + z = x // y + expect(node, inputs=[x, y], outputs=[z], name="test_div_int16") + + x = np.array([-3, 3, -3, 3], dtype=np.int32) + y = np.array([2, 2, -2, -2], dtype=np.int32) + z = np.array([-1, 1, 1, -1], dtype=np.int32) + expect(node, inputs=[x, y], outputs=[z], name="test_div_int32_trunc") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + 1 + z = x // y + expect(node, inputs=[x, y], outputs=[z], name="test_div_uint8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + 1 + z = x // y + expect(node, inputs=[x, y], outputs=[z], name="test_div_uint16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + 1 + z = x // y + expect(node, inputs=[x, y], outputs=[z], name="test_div_uint32") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + 1 + z = x // y + expect(node, inputs=[x, y], outputs=[z], name="test_div_uint64") + + @staticmethod + def export_div_broadcast() -> None: + node = onnx.helper.make_node( + "Div", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.rand(5).astype(np.float32) + 1.0 + z = x / y + expect(node, inputs=[x, y], outputs=[z], name="test_div_bcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dropout.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dropout.py new file mode 100644 index 0000000000000000000000000000000000000000..87f25549fac20274bb3160e5a34625847e9a7f59 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dropout.py @@ -0,0 +1,209 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx import helper +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def dropout(X, drop_probability=0.5, seed=0, training_mode=False, return_mask=False): + if drop_probability == 0 or training_mode is False: + if return_mask is True: + return X, np.ones(X.shape, dtype=bool) + return X + + np.random.seed(seed) + mask = np.random.uniform(0, 1.0, X.shape) >= drop_probability + scale = 1 / (1 - drop_probability) + if return_mask: + return mask * X * scale, mask.astype(bool) + return mask * X * scale + + +class Dropout(Base): + # Inferencing tests. + @staticmethod + def export_default() -> None: + seed = np.int64(0) + node = onnx.helper.make_node("Dropout", inputs=["x"], outputs=["y"], seed=seed) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = dropout(x) + expect(node, inputs=[x], outputs=[y], name="test_dropout_default") + + @staticmethod + def export_default_ratio() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r"], outputs=["y"], seed=seed + ) + + r = np.float32(0.1) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = dropout(x, r) + expect(node, inputs=[x, r], outputs=[y], name="test_dropout_default_ratio") + + @staticmethod + def export_default_mask() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x"], outputs=["y", "z"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y, z = dropout(x, return_mask=True) + expect(node, inputs=[x], outputs=[y, z], name="test_dropout_default_mask") + + @staticmethod + def export_default_mask_ratio() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r"], outputs=["y", "z"], seed=seed + ) + + r = np.float32(0.1) + x = np.random.randn(3, 4, 5).astype(np.float32) + y, z = dropout(x, r, return_mask=True) + expect( + node, inputs=[x, r], outputs=[y, z], name="test_dropout_default_mask_ratio" + ) + + # Training tests. + + @staticmethod + def export_training_default() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.5) + t = np.bool_(True) + y = dropout(x, r, training_mode=t) + expect( + node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_default" + ) + + @staticmethod + def export_training_default_ratio_mask() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.5) + t = np.bool_(True) + y, z = dropout(x, r, training_mode=t, return_mask=True) + expect( + node, + inputs=[x, r, t], + outputs=[y, z], + name="test_training_dropout_default_mask", + ) + + @staticmethod + def export_training() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.75) + t = np.bool_(True) + y = dropout(x, r, training_mode=t) + expect(node, inputs=[x, r, t], outputs=[y], name="test_training_dropout") + + @staticmethod + def export_training_ratio_mask() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.75) + t = np.bool_(True) + y, z = dropout(x, r, training_mode=t, return_mask=True) + expect( + node, inputs=[x, r, t], outputs=[y, z], name="test_training_dropout_mask" + ) + + @staticmethod + def export_training_default_zero_ratio() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.0) + t = np.bool_(True) + y = dropout(x, r, training_mode=t) + expect( + node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_zero_ratio" + ) + + @staticmethod + def export_training_default_zero_ratio_mask() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.0) + t = np.bool_(True) + y, z = dropout(x, r, training_mode=t, return_mask=True) + expect( + node, + inputs=[x, r, t], + outputs=[y, z], + name="test_training_dropout_zero_ratio_mask", + ) + + # Old dropout tests + + @staticmethod + def export_default_old() -> None: + node = onnx.helper.make_node( + "Dropout", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = x + expect( + node, + inputs=[x], + outputs=[y], + name="test_dropout_default_old", + opset_imports=[helper.make_opsetid("", 11)], + ) + + @staticmethod + def export_random_old() -> None: + node = onnx.helper.make_node( + "Dropout", + inputs=["x"], + outputs=["y"], + ratio=0.2, + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = x + expect( + node, + inputs=[x], + outputs=[y], + name="test_dropout_random_old", + opset_imports=[helper.make_opsetid("", 11)], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dynamicquantizelinear.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dynamicquantizelinear.py new file mode 100644 index 0000000000000000000000000000000000000000..66553a36f889f57ebecdb48f3e0306b38d76ac91 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/dynamicquantizelinear.py @@ -0,0 +1,70 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class DynamicQuantizeLinear(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "DynamicQuantizeLinear", + inputs=["x"], + outputs=["y", "y_scale", "y_zero_point"], + ) + + # expected scale 0.0196078438 and zero point 153 + X = np.array([0, 2, -3, -2.5, 1.34, 0.5]).astype(np.float32) + x_min = np.minimum(0, np.min(X)) + x_max = np.maximum(0, np.max(X)) + Y_Scale = np.float32((x_max - x_min) / (255 - 0)) # uint8 -> [0, 255] + Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8) + Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8) + + expect( + node, + inputs=[X], + outputs=[Y, Y_Scale, Y_ZeroPoint], + name="test_dynamicquantizelinear", + ) + + # expected scale 0.0156862754 and zero point 255 + X = np.array([-1.0, -2.1, -1.3, -2.5, -3.34, -4.0]).astype(np.float32) + x_min = np.minimum(0, np.min(X)) + x_max = np.maximum(0, np.max(X)) + Y_Scale = np.float32((x_max - x_min) / (255 - 0)) # uint8 -> [0, 255] + Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8) + Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8) + + expect( + node, + inputs=[X], + outputs=[Y, Y_Scale, Y_ZeroPoint], + name="test_dynamicquantizelinear_max_adjusted", + ) + + X = ( + np.array([1, 2.1, 1.3, 2.5, 3.34, 4.0, 1.5, 2.6, 3.9, 4.0, 3.0, 2.345]) + .astype(np.float32) + .reshape((3, 4)) + ) + + # expected scale 0.0156862754 and zero point 0 + x_min = np.minimum(0, np.min(X)) + x_max = np.maximum(0, np.max(X)) + Y_Scale = np.float32((x_max - x_min) / (255 - 0)) # uint8 -> [0, 255] + Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8) + Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8) + + expect( + node, + inputs=[X], + outputs=[Y, Y_Scale, Y_ZeroPoint], + name="test_dynamicquantizelinear_min_adjusted", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/einsum.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/einsum.py new file mode 100644 index 0000000000000000000000000000000000000000..e6c4e2e518008913ff2f4775204e5413f1461ecc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/einsum.py @@ -0,0 +1,92 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def einsum_reference_implementation( + Eqn: str, Operands: tuple[np.ndarray, ...] +) -> np.ndarray: + return np.einsum(Eqn, *Operands) + + +class Einsum(Base): + @staticmethod + def export_einsum_transpose() -> None: + Eqn = "ij->ji" + node = onnx.helper.make_node( + "Einsum", inputs=["x"], outputs=["y"], equation=Eqn + ) + + X = np.random.randn(3, 4) + Y = einsum_reference_implementation(Eqn, (X,)) + + expect(node, inputs=[X], outputs=[Y], name="test_einsum_transpose") + + @staticmethod + def export_einsum_sum() -> None: + Eqn = "ij->i" + node = onnx.helper.make_node( + "Einsum", inputs=["x"], outputs=["y"], equation=Eqn + ) + + X = np.random.randn(3, 4) + Z = einsum_reference_implementation(Eqn, (X,)) + + expect(node, inputs=[X], outputs=[Z], name="test_einsum_sum") + + @staticmethod + def export_einsum_batch_diagonal() -> None: + Eqn = "...ii ->...i" + node = onnx.helper.make_node( + "Einsum", inputs=["x"], outputs=["y"], equation=Eqn + ) + + X = np.random.randn(3, 5, 5) + Z = einsum_reference_implementation(Eqn, (X,)) + + expect(node, inputs=[X], outputs=[Z], name="test_einsum_batch_diagonal") + + @staticmethod + def export_einsum_inner_prod() -> None: + Eqn = "i,i" + node = onnx.helper.make_node( + "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn + ) + + X = np.random.randn(5) + Y = np.random.randn(5) + Z = einsum_reference_implementation(Eqn, (X, Y)) + + expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_inner_prod") + + @staticmethod + def export_einsum_batch_matmul() -> None: + Eqn = "bij, bjk -> bik" + node = onnx.helper.make_node( + "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn + ) + + X = np.random.randn(5, 2, 3) + Y = np.random.randn(5, 3, 4) + Z = einsum_reference_implementation(Eqn, (X, Y)) + + expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_batch_matmul") + + @staticmethod + def export_einsum_scalar() -> None: + Eqn = "->" + node = onnx.helper.make_node( + "Einsum", inputs=["x"], outputs=["y"], equation=Eqn + ) + + X = np.array(5.0) # scalar input + Z = einsum_reference_implementation(Eqn, (X,)) + + expect(node, inputs=[X], outputs=[Z], name="test_einsum_scalar") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/elu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/elu.py new file mode 100644 index 0000000000000000000000000000000000000000..d19132f0caccb3047912c09964ab96aecedb4f56 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/elu.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Elu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("Elu", inputs=["x"], outputs=["y"], alpha=2.0) + + x = np.array([-1, 0, 1]).astype(np.float32) + # expected output [-1.2642411, 0., 1.] + y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 + expect(node, inputs=[x], outputs=[y], name="test_elu_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 + expect(node, inputs=[x], outputs=[y], name="test_elu") + + @staticmethod + def export_elu_default() -> None: + default_alpha = 1.0 + node = onnx.helper.make_node( + "Elu", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha + expect(node, inputs=[x], outputs=[y], name="test_elu_default") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/equal.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/equal.py new file mode 100644 index 0000000000000000000000000000000000000000..ea09b43b0692090e02bb3593e66ced22d28df0a9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/equal.py @@ -0,0 +1,92 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Equal(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Equal", + inputs=["x", "y"], + outputs=["z"], + ) + + x = (np.random.randn(3, 4, 5) * 10).astype(np.int32) + y = (np.random.randn(3, 4, 5) * 10).astype(np.int32) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal") + + x = (np.random.randn(3, 4, 5) * 10).astype(np.int8) + y = (np.random.randn(3, 4, 5) * 10).astype(np.int8) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_int8") + + x = (np.random.randn(3, 4, 5) * 10).astype(np.int16) + y = (np.random.randn(3, 4, 5) * 10).astype(np.int16) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_int16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint32") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint64") + + @staticmethod + def export_equal_broadcast() -> None: + node = onnx.helper.make_node( + "Equal", + inputs=["x", "y"], + outputs=["z"], + ) + + x = (np.random.randn(3, 4, 5) * 10).astype(np.int32) + y = (np.random.randn(5) * 10).astype(np.int32) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_bcast") + + @staticmethod + def export_equal_string() -> None: + node = onnx.helper.make_node( + "Equal", + inputs=["x", "y"], + outputs=["z"], + ) + x = np.array(["string1", "string2"], dtype=np.dtype(object)) + y = np.array(["string1", "string3"], dtype=np.dtype(object)) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_string") + + @staticmethod + def export_equal_string_broadcast() -> None: + node = onnx.helper.make_node( + "Equal", + inputs=["x", "y"], + outputs=["z"], + ) + x = np.array(["string1", "string2"], dtype=np.dtype(object)) + y = np.array(["string1"], dtype=np.dtype(object)) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_string_broadcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/erf.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/erf.py new file mode 100644 index 0000000000000000000000000000000000000000..3a5842a9e012ad8280c19553cafc13536080749a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/erf.py @@ -0,0 +1,26 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import math + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Erf(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Erf", + inputs=["x"], + outputs=["y"], + ) + + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + y = np.vectorize(math.erf)(x).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_erf") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/exp.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/exp.py new file mode 100644 index 0000000000000000000000000000000000000000..c0a069224d938f4b8224e547a5b5fe91a610413c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/exp.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Exp(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Exp", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.exp(x) # expected output [0.36787945, 1., 2.71828175] + expect(node, inputs=[x], outputs=[y], name="test_exp_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.exp(x) + expect(node, inputs=[x], outputs=[y], name="test_exp") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/expand.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/expand.py new file mode 100644 index 0000000000000000000000000000000000000000..d88a625ecba88a21b144459d4296b4b3aa424f49 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/expand.py @@ -0,0 +1,66 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Expand(Base): + @staticmethod + def export_dim_changed() -> None: + node = onnx.helper.make_node( + "Expand", + inputs=["data", "new_shape"], + outputs=["expanded"], + ) + shape = [3, 1] + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[1.], [2.], [3.]] + new_shape = [2, 1, 6] + expanded = data * np.ones(new_shape, dtype=np.float32) + # print(expanded) + # [[[1., 1., 1., 1., 1., 1.], + # [2., 2., 2., 2., 2., 2.], + # [3., 3., 3., 3., 3., 3.]], + # + # [[1., 1., 1., 1., 1., 1.], + # [2., 2., 2., 2., 2., 2.], + # [3., 3., 3., 3., 3., 3.]]] + new_shape = np.array(new_shape, dtype=np.int64) + expect( + node, + inputs=[data, new_shape], + outputs=[expanded], + name="test_expand_dim_changed", + ) + + @staticmethod + def export_dim_unchanged() -> None: + node = onnx.helper.make_node( + "Expand", + inputs=["data", "new_shape"], + outputs=["expanded"], + ) + shape = [3, 1] + new_shape = [3, 4] + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[1.], [2.], [3.]] + expanded = np.tile(data, 4) + # print(expanded) + # [[1., 1., 1., 1.], + # [2., 2., 2., 2.], + # [3., 3., 3., 3.]] + new_shape = np.array(new_shape, dtype=np.int64) + expect( + node, + inputs=[data, new_shape], + outputs=[expanded], + name="test_expand_dim_unchanged", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/eyelike.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/eyelike.py new file mode 100644 index 0000000000000000000000000000000000000000..6ea785f0c54102e9c0626e36db694b113c6d6060 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/eyelike.py @@ -0,0 +1,60 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class EyeLike(Base): + @staticmethod + def export_without_dtype() -> None: + shape = (4, 4) + node = onnx.helper.make_node( + "EyeLike", + inputs=["x"], + outputs=["y"], + ) + + x = np.random.randint(0, 100, size=shape, dtype=np.int32) + y = np.eye(shape[0], shape[1], dtype=np.int32) + expect(node, inputs=[x], outputs=[y], name="test_eyelike_without_dtype") + + @staticmethod + def export_with_dtype() -> None: + shape = (3, 4) + node = onnx.helper.make_node( + "EyeLike", + inputs=["x"], + outputs=["y"], + dtype=onnx.TensorProto.DOUBLE, + ) + + x = np.random.randint(0, 100, size=shape, dtype=np.int32) + y = np.eye(shape[0], shape[1], dtype=np.float64) + expect(node, inputs=[x], outputs=[y], name="test_eyelike_with_dtype") + + @staticmethod + def export_populate_off_main_diagonal() -> None: + shape = (4, 5) + off_diagonal_offset = 1 + node = onnx.helper.make_node( + "EyeLike", + inputs=["x"], + outputs=["y"], + k=off_diagonal_offset, + dtype=onnx.TensorProto.FLOAT, + ) + + x = np.random.randint(0, 100, size=shape, dtype=np.int32) + y = np.eye(shape[0], shape[1], k=off_diagonal_offset, dtype=np.float32) + expect( + node, + inputs=[x], + outputs=[y], + name="test_eyelike_populate_off_main_diagonal", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/flatten.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/flatten.py new file mode 100644 index 0000000000000000000000000000000000000000..ab2268f31919b09229cf3613c19860847e8f3702 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/flatten.py @@ -0,0 +1,65 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Flatten(Base): + @staticmethod + def export() -> None: + shape = (2, 3, 4, 5) + a = np.random.random_sample(shape).astype(np.float32) + + for i in range(len(shape)): + node = onnx.helper.make_node( + "Flatten", + inputs=["a"], + outputs=["b"], + axis=i, + ) + + new_shape = (1, -1) if i == 0 else (np.prod(shape[0:i]).astype(int), -1) + b = np.reshape(a, new_shape) + expect(node, inputs=[a], outputs=[b], name="test_flatten_axis" + str(i)) + + @staticmethod + def export_flatten_with_default_axis() -> None: + node = onnx.helper.make_node( + "Flatten", + inputs=["a"], + outputs=["b"], # Default value for axis: axis=1 + ) + + shape = (5, 4, 3, 2) + a = np.random.random_sample(shape).astype(np.float32) + new_shape = (5, 24) + b = np.reshape(a, new_shape) + expect(node, inputs=[a], outputs=[b], name="test_flatten_default_axis") + + @staticmethod + def export_flatten_negative_axis() -> None: + shape = (2, 3, 4, 5) + a = np.random.random_sample(shape).astype(np.float32) + + for i in range(-len(shape), 0): + node = onnx.helper.make_node( + "Flatten", + inputs=["a"], + outputs=["b"], + axis=i, + ) + + new_shape = (np.prod(shape[0:i]).astype(int), -1) + b = np.reshape(a, new_shape) + expect( + node, + inputs=[a], + outputs=[b], + name="test_flatten_negative_axis" + str(abs(i)), + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/flexattention.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/flexattention.py new file mode 100644 index 0000000000000000000000000000000000000000..c6b1d09678045ee9f7590baf0c5dcdf2610cf232 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/flexattention.py @@ -0,0 +1,583 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx import TensorProto, helper +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.defs import AI_ONNX_PREVIEW_DOMAIN +from onnx.reference.ops.aionnx_preview.op_flex_attention import ( + _compute_flex_attention, +) + + +def _make_score_mod_bias_graph( + bias_value: float, + dtype: TensorProto.DataType = TensorProto.FLOAT, +) -> onnx.GraphProto: + """Create a score_mod subgraph that adds a constant bias to the scores. + + score_mod(scores) -> scores + bias + """ + score_in = helper.make_tensor_value_info("scores", dtype, ["B", "H", "L", "S"]) + score_out = helper.make_tensor_value_info("scores_out", dtype, ["B", "H", "L", "S"]) + + bias_tensor = helper.make_tensor("bias", dtype, [], [bias_value]) + add_node = helper.make_node("Add", ["scores", "bias"], ["scores_out"]) + + return helper.make_graph( + [add_node], + "score_mod_bias", + [score_in], + [score_out], + [bias_tensor], + ) + + +def _make_prob_mod_scale_graph( + scale_value: float, + dtype: TensorProto.DataType = TensorProto.FLOAT, +) -> onnx.GraphProto: + """Create a prob_mod subgraph that scales the probabilities. + + prob_mod(probs) -> probs * scale + """ + prob_in = helper.make_tensor_value_info("probs", dtype, ["B", "H", "L", "S"]) + prob_out = helper.make_tensor_value_info("probs_out", dtype, ["B", "H", "L", "S"]) + + scale_tensor = helper.make_tensor("scale", dtype, [], [scale_value]) + mul_node = helper.make_node("Mul", ["probs", "scale"], ["probs_out"]) + + return helper.make_graph( + [mul_node], + "prob_mod_scale", + [prob_in], + [prob_out], + [scale_tensor], + ) + + +def _make_score_mod_causal_mask_graph( + dtype: TensorProto.DataType = TensorProto.FLOAT, +) -> onnx.GraphProto: + """Create a score_mod subgraph that applies causal masking. + + For each position, masks out future tokens by setting scores to -inf + where k_idx > q_idx. This pattern is used in Qwen-3, Gemma-3, Llama-3, etc. + + score_mod(scores) -> Where(q_idx >= k_idx, scores, -inf) + """ + score_in = helper.make_tensor_value_info("scores", dtype, ["B", "H", "L", "S"]) + score_out = helper.make_tensor_value_info("scores_out", dtype, ["B", "H", "L", "S"]) + + nodes = [ + # Extract L and S from scores shape [B, H, L, S] + helper.make_node("Shape", ["scores"], ["scores_shape"]), + helper.make_node("Gather", ["scores_shape", "idx_2"], ["L_dim"], axis=0), + helper.make_node("Gather", ["scores_shape", "idx_3"], ["S_dim"], axis=0), + # Build q_idx: range(L) reshaped to [1, 1, L, 1] + helper.make_node("Range", ["zero", "L_dim", "one"], ["q_range"]), + helper.make_node("Reshape", ["q_range", "q_shape"], ["q_idx"]), + # Build k_idx: range(S) reshaped to [1, 1, 1, S] + helper.make_node("Range", ["zero", "S_dim", "one"], ["k_range"]), + helper.make_node("Reshape", ["k_range", "k_shape"], ["k_idx"]), + # Causal mask: q_idx >= k_idx + helper.make_node("GreaterOrEqual", ["q_idx", "k_idx"], ["mask"]), + # Where(mask, scores, -inf) + helper.make_node("Where", ["mask", "scores", "neg_inf"], ["scores_out"]), + ] + + initializers = [ + helper.make_tensor("zero", TensorProto.INT64, [], [0]), + helper.make_tensor("one", TensorProto.INT64, [], [1]), + helper.make_tensor("idx_2", TensorProto.INT64, [], [2]), + helper.make_tensor("idx_3", TensorProto.INT64, [], [3]), + helper.make_tensor("q_shape", TensorProto.INT64, [4], [1, 1, -1, 1]), + helper.make_tensor("k_shape", TensorProto.INT64, [4], [1, 1, 1, -1]), + helper.make_tensor("neg_inf", dtype, [], [float("-inf")]), + ] + + return helper.make_graph( + nodes, + "score_mod_causal_mask", + [score_in], + [score_out], + initializers, + ) + + +def _make_score_mod_soft_cap_graph( + cap_value: float, + dtype: TensorProto.DataType = TensorProto.FLOAT, +) -> onnx.GraphProto: + """Create a score_mod subgraph that applies soft capping. + + Used in Gemma-2 to stabilize attention scores. + + score_mod(scores) -> tanh(scores / cap) * cap + """ + score_in = helper.make_tensor_value_info("scores", dtype, ["B", "H", "L", "S"]) + score_out = helper.make_tensor_value_info("scores_out", dtype, ["B", "H", "L", "S"]) + + nodes = [ + helper.make_node("Div", ["scores", "cap"], ["scaled"]), + helper.make_node("Tanh", ["scaled"], ["tanh_out"]), + helper.make_node("Mul", ["tanh_out", "cap"], ["scores_out"]), + ] + + initializers = [ + helper.make_tensor("cap", dtype, [], [cap_value]), + ] + + return helper.make_graph( + nodes, + "score_mod_soft_cap", + [score_in], + [score_out], + initializers, + ) + + +def _make_score_mod_relative_positional_graph( + dtype: TensorProto.DataType = TensorProto.FLOAT, +) -> onnx.GraphProto: + """Create a score_mod subgraph that adds relative positional bias. + + Adds (q_idx - k_idx) to the scores. This pattern captures the core idea + of relative position embeddings used in various Transformer models. + + score_mod(scores) -> scores + Cast(q_idx - k_idx, dtype) + """ + score_in = helper.make_tensor_value_info("scores", dtype, ["B", "H", "L", "S"]) + score_out = helper.make_tensor_value_info("scores_out", dtype, ["B", "H", "L", "S"]) + + nodes = [ + # Extract L and S from scores shape [B, H, L, S] + helper.make_node("Shape", ["scores"], ["scores_shape"]), + helper.make_node("Gather", ["scores_shape", "idx_2"], ["L_dim"], axis=0), + helper.make_node("Gather", ["scores_shape", "idx_3"], ["S_dim"], axis=0), + # Build q_idx: range(L) reshaped to [L, 1] + helper.make_node("Range", ["zero", "L_dim", "one"], ["q_range"]), + helper.make_node("Reshape", ["q_range", "q_shape"], ["q_idx"]), + # Build k_idx: range(S) reshaped to [1, S] + helper.make_node("Range", ["zero", "S_dim", "one"], ["k_range"]), + helper.make_node("Reshape", ["k_range", "k_shape"], ["k_idx"]), + # Relative position: q_idx - k_idx (broadcasts to [L, S]) + helper.make_node("Sub", ["q_idx", "k_idx"], ["rel_pos"]), + # Cast to score dtype and add to scores + helper.make_node("Cast", ["rel_pos"], ["rel_pos_cast"], to=dtype), + helper.make_node("Add", ["scores", "rel_pos_cast"], ["scores_out"]), + ] + + initializers = [ + helper.make_tensor("zero", TensorProto.INT64, [], [0]), + helper.make_tensor("one", TensorProto.INT64, [], [1]), + helper.make_tensor("idx_2", TensorProto.INT64, [], [2]), + helper.make_tensor("idx_3", TensorProto.INT64, [], [3]), + helper.make_tensor("q_shape", TensorProto.INT64, [2], [-1, 1]), + helper.make_tensor("k_shape", TensorProto.INT64, [2], [1, -1]), + ] + + return helper.make_graph( + nodes, + "score_mod_relative_positional", + [score_in], + [score_out], + initializers, + ) + + +class FlexAttention(Base): + @staticmethod + def export_flexattention() -> None: + """Basic FlexAttention test with default settings.""" + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + + B, Hq, L, E = 2, 4, 8, 16 + S, Ev = 6, 16 + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hq, S, E).astype(np.float32) + V = np.random.rand(B, Hq, S, Ev).astype(np.float32) + + (Y,) = _compute_flex_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_scaled() -> None: + """FlexAttention with explicit scale attribute.""" + scale = 0.1 + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + scale=scale, + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + + B, Hq, L, E = 2, 4, 8, 16 + S, Ev = 6, 16 + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hq, S, E).astype(np.float32) + V = np.random.rand(B, Hq, S, Ev).astype(np.float32) + + (Y,) = _compute_flex_attention(Q, K, V, scale=scale) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_scaled", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_gqa() -> None: + """FlexAttention with Grouped Query Attention (GQA).""" + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + + B, Hq, Hkv, L, S, E, Ev = 2, 8, 2, 4, 6, 16, 16 + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hkv, S, E).astype(np.float32) + V = np.random.rand(B, Hkv, S, Ev).astype(np.float32) + + (Y,) = _compute_flex_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_gqa", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_diff_head_sizes() -> None: + """FlexAttention with different head sizes for Q/K vs V.""" + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + + B, Hq, L, E = 2, 4, 8, 16 + S, Ev = 6, 32 # V has different head size + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hq, S, E).astype(np.float32) + V = np.random.rand(B, Hq, S, Ev).astype(np.float32) + + (Y,) = _compute_flex_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_diff_head_sizes", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_score_mod() -> None: + """FlexAttention with score_mod subgraph (adds bias to scores).""" + bias_value = 0.5 + score_mod_graph = _make_score_mod_bias_graph(bias_value, TensorProto.FLOAT) + + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + # Add score_mod as a graph attribute + score_mod_attr = helper.make_attribute("score_mod", score_mod_graph) + node.attribute.append(score_mod_attr) + + B, Hq, L, E = 1, 2, 3, 4 + S, Ev = 3, 4 + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hq, S, E).astype(np.float32) + V = np.random.rand(B, Hq, S, Ev).astype(np.float32) + + scale = 1.0 / np.sqrt(E) + scores = np.einsum("bhle,bhse->bhls", Q, K) * scale + scores = scores + bias_value # score_mod: add bias + probs = np.exp(scores - scores.max(axis=-1, keepdims=True)) + probs = probs / probs.sum(axis=-1, keepdims=True) + Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_score_mod", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_prob_mod() -> None: + """FlexAttention with prob_mod subgraph (scales probabilities).""" + scale_value = 0.5 + prob_mod_graph = _make_prob_mod_scale_graph(scale_value, TensorProto.FLOAT) + + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + prob_mod_attr = helper.make_attribute("prob_mod", prob_mod_graph) + node.attribute.append(prob_mod_attr) + + B, Hq, L, E = 1, 2, 3, 4 + S, Ev = 3, 4 + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hq, S, E).astype(np.float32) + V = np.random.rand(B, Hq, S, Ev).astype(np.float32) + + scale = 1.0 / np.sqrt(E) + scores = np.einsum("bhle,bhse->bhls", Q, K) * scale + probs = np.exp(scores - scores.max(axis=-1, keepdims=True)) + probs = probs / probs.sum(axis=-1, keepdims=True) + probs = probs * scale_value + Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_prob_mod", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_fp16() -> None: + """FlexAttention with float16 inputs.""" + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + + B, Hq, L, E = 2, 4, 8, 16 + S, Ev = 6, 16 + + Q = np.random.rand(B, Hq, L, E).astype(np.float16) + K = np.random.rand(B, Hq, S, E).astype(np.float16) + V = np.random.rand(B, Hq, S, Ev).astype(np.float16) + + (Y,) = _compute_flex_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_fp16", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_double() -> None: + """FlexAttention with double precision inputs.""" + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + + B, Hq, L, E = 2, 4, 8, 16 + S, Ev = 6, 16 + + Q = np.random.rand(B, Hq, L, E).astype(np.float64) + K = np.random.rand(B, Hq, S, E).astype(np.float64) + V = np.random.rand(B, Hq, S, Ev).astype(np.float64) + + (Y,) = _compute_flex_attention(Q, K, V) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_double", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_causal_mask() -> None: + """FlexAttention with causal masking score_mod (Qwen-3, Gemma-3, Llama-3 pattern).""" + score_mod_graph = _make_score_mod_causal_mask_graph(TensorProto.FLOAT) + + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + score_mod_attr = helper.make_attribute("score_mod", score_mod_graph) + node.attribute.append(score_mod_attr) + + B, Hq, L, E = 1, 2, 4, 8 + S, Ev = 4, 8 + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hq, S, E).astype(np.float32) + V = np.random.rand(B, Hq, S, Ev).astype(np.float32) + + # Manually compute expected output with causal masking + scale = 1.0 / np.sqrt(E) + scores = np.einsum("bhle,bhse->bhls", Q, K) * scale + # Apply causal mask: set future positions to -inf + q_idx = np.arange(L).reshape(1, 1, L, 1) + k_idx = np.arange(S).reshape(1, 1, 1, S) + mask = q_idx >= k_idx + scores = np.where(mask, scores, -np.inf) + probs = np.exp(scores - scores.max(axis=-1, keepdims=True)) + probs = probs / probs.sum(axis=-1, keepdims=True) + Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_causal_mask", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_soft_cap() -> None: + """FlexAttention with soft capping score_mod (Gemma-2 pattern).""" + cap_value = 20.0 + score_mod_graph = _make_score_mod_soft_cap_graph(cap_value, TensorProto.FLOAT) + + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + score_mod_attr = helper.make_attribute("score_mod", score_mod_graph) + node.attribute.append(score_mod_attr) + + B, Hq, L, E = 1, 2, 4, 8 + S, Ev = 4, 8 + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hq, S, E).astype(np.float32) + V = np.random.rand(B, Hq, S, Ev).astype(np.float32) + + # Manually compute expected output with soft capping + scale = 1.0 / np.sqrt(E) + scores = np.einsum("bhle,bhse->bhls", Q, K) * scale + scores = np.tanh(scores / cap_value) * cap_value + probs = np.exp(scores - scores.max(axis=-1, keepdims=True)) + probs = probs / probs.sum(axis=-1, keepdims=True) + Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_soft_cap", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) + + @staticmethod + def export_flexattention_relative_positional() -> None: + """FlexAttention with relative positional bias score_mod.""" + score_mod_graph = _make_score_mod_relative_positional_graph(TensorProto.FLOAT) + + node = helper.make_node( + "FlexAttention", + inputs=["Q", "K", "V"], + outputs=["Y"], + domain=AI_ONNX_PREVIEW_DOMAIN, + ) + score_mod_attr = helper.make_attribute("score_mod", score_mod_graph) + node.attribute.append(score_mod_attr) + + B, Hq, L, E = 1, 2, 4, 8 + S, Ev = 4, 8 + + Q = np.random.rand(B, Hq, L, E).astype(np.float32) + K = np.random.rand(B, Hq, S, E).astype(np.float32) + V = np.random.rand(B, Hq, S, Ev).astype(np.float32) + + # Manually compute expected output with relative positional bias + scale = 1.0 / np.sqrt(E) + scores = np.einsum("bhle,bhse->bhls", Q, K) * scale + q_idx = np.arange(L).reshape(-1, 1) + k_idx = np.arange(S).reshape(1, -1) + rel_pos = (q_idx - k_idx).astype(np.float32) + scores = scores + rel_pos + probs = np.exp(scores - scores.max(axis=-1, keepdims=True)) + probs = probs / probs.sum(axis=-1, keepdims=True) + Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32) + + expect( + node, + inputs=[Q, K, V], + outputs=[Y], + name="test_flexattention_relative_positional", + opset_imports=[ + helper.make_opsetid("", 26), + helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1), + ], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/floor.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/floor.py new file mode 100644 index 0000000000000000000000000000000000000000..76373dd93a171b3430be6c77d03a85937499013a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/floor.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Floor(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Floor", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.5, 1.2, 2]).astype(np.float32) + y = np.floor(x) # expected output [-2., 1., 2.] + expect(node, inputs=[x], outputs=[y], name="test_floor_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.floor(x) + expect(node, inputs=[x], outputs=[y], name="test_floor") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gather.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gather.py new file mode 100644 index 0000000000000000000000000000000000000000..20435ecea9c93e67c83f458774833b38d7a2a55c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gather.py @@ -0,0 +1,91 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Gather(Base): + @staticmethod + def export_gather_0() -> None: + node = onnx.helper.make_node( + "Gather", + inputs=["data", "indices"], + outputs=["y"], + axis=0, + ) + data = np.random.randn(5, 4, 3, 2).astype(np.float32) + indices = np.array([0, 1, 3]) + y = np.take(data, indices, axis=0) + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_0", + ) + + @staticmethod + def export_gather_1() -> None: + node = onnx.helper.make_node( + "Gather", + inputs=["data", "indices"], + outputs=["y"], + axis=1, + ) + data = np.random.randn(5, 4, 3, 2).astype(np.float32) + indices = np.array([0, 1, 3]) + y = np.take(data, indices, axis=1) + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_1", + ) + + @staticmethod + def export_gather_2d_indices() -> None: + node = onnx.helper.make_node( + "Gather", + inputs=["data", "indices"], + outputs=["y"], + axis=1, + ) + data = np.random.randn(3, 3).astype(np.float32) + indices = np.array([[0, 2]]) + y = np.take(data, indices, axis=1) + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_2d_indices", + ) + + @staticmethod + def export_gather_negative_indices() -> None: + node = onnx.helper.make_node( + "Gather", + inputs=["data", "indices"], + outputs=["y"], + axis=0, + ) + data = np.arange(10).astype(np.float32) + indices = np.array([0, -9, -10]) + y = np.take(data, indices, axis=0) + + # print(y) + # [0. 1. 0.] + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_negative_indices", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gatherelements.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gatherelements.py new file mode 100644 index 0000000000000000000000000000000000000000..56dd77e01ca489969f01db51bc53fbe18992d07f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gatherelements.py @@ -0,0 +1,92 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# The below GatherElements' numpy implementation is from https://stackoverflow.com/a/46204790/11767360 +def gather_elements(data, indices, axis=0): + data_swapped = np.swapaxes(data, 0, axis) + index_swapped = np.swapaxes(indices, 0, axis) + gathered = np.choose(index_swapped, data_swapped, mode="wrap") + return np.swapaxes(gathered, 0, axis) + + +class GatherElements(Base): + @staticmethod + def export_gather_elements_0() -> None: + axis = 1 + node = onnx.helper.make_node( + "GatherElements", + inputs=["data", "indices"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1, 2], [3, 4]], dtype=np.float32) + indices = np.array([[0, 0], [1, 0]], dtype=np.int32) + + y = gather_elements(data, indices, axis) + # print(y) produces + # [[1, 1], + # [4, 3]] + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_elements_0", + ) + + @staticmethod + def export_gather_elements_1() -> None: + axis = 0 + node = onnx.helper.make_node( + "GatherElements", + inputs=["data", "indices"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32) + indices = np.array([[1, 2, 0], [2, 0, 0]], dtype=np.int32) + + y = gather_elements(data, indices, axis) + # print(y) produces + # [[4, 8, 3], + # [7, 2, 3]] + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_elements_1", + ) + + @staticmethod + def export_gather_elements_negative_indices() -> None: + axis = 0 + node = onnx.helper.make_node( + "GatherElements", + inputs=["data", "indices"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32) + indices = np.array([[-1, -2, 0], [-2, 0, 0]], dtype=np.int32) + + y = gather_elements(data, indices, axis) + # print(y) produces + # [[7, 5, 3], + # [4, 2, 3]] + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_elements_negative_indices", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gathernd.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gathernd.py new file mode 100644 index 0000000000000000000000000000000000000000..971a83e189fc3883a48ca7b00abd0af8fdbabf06 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gathernd.py @@ -0,0 +1,121 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def gather_nd_impl( + data: np.ndarray, indices: np.ndarray, batch_dims: int +) -> np.ndarray: + # Note the data rank - will be reused multiple times later + data_rank = len(data.shape) + + # Check input tensors' shape/rank condition + assert indices.shape[-1] <= data_rank + + # The list of data/indice shape of batch_dims + batch_dims_shape = [] + + # The number of elements in the batch_dims for data/indice array + batch_dims_size = 1 + + # Check the shape of indice and data are identical for batch dims. + for i in range(batch_dims): + batch_dims_shape.append(indices.shape[i]) + batch_dims_size *= indices.shape[i] + + # Compute output of the op as below + + # Compute shape of output array + output_shape = ( + batch_dims_shape + list(indices.shape)[batch_dims:-1] + if (indices.shape[-1] == data_rank - batch_dims) + else batch_dims_shape + + list(indices.shape)[batch_dims:-1] + + list(data.shape)[batch_dims + indices.shape[-1] :] + ) + + # Placeholder for output data + output_data_buffer = [] + + # Flatten 'indices' to 2D array + reshaped_indices = indices.reshape(batch_dims_size, -1, indices.shape[-1]) + + # Flatten 'data' to array of shape (batch_dim_size, data.shape[batch_dimes:]) + reshaped_data = data.reshape((batch_dims_size, *data.shape[batch_dims:])) + + # gather each scalar value from 'data' + for batch_dim in range(reshaped_indices.shape[0]): + for outer_dim in range(reshaped_indices.shape[1]): + gather_index = tuple(reshaped_indices[batch_dim][outer_dim]) + output_data_buffer.append(reshaped_data[(batch_dim, *gather_index)]) + return np.asarray(output_data_buffer, dtype=data.dtype).reshape(output_shape) + + +class GatherND(Base): + @staticmethod + def export_int32() -> None: + node = onnx.helper.make_node( + "GatherND", + inputs=["data", "indices"], + outputs=["output"], + ) + + data = np.array([[0, 1], [2, 3]], dtype=np.int32) + indices = np.array([[0, 0], [1, 1]], dtype=np.int64) + output = gather_nd_impl(data, indices, 0) + expected_output = np.array([0, 3], dtype=np.int32) + assert np.array_equal(output, expected_output) + expect( + node, + inputs=[data, indices], + outputs=[output], + name="test_gathernd_example_int32", + ) + + @staticmethod + def export_float32() -> None: + node = onnx.helper.make_node( + "GatherND", + inputs=["data", "indices"], + outputs=["output"], + ) + + data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.float32) + indices = np.array([[[0, 1]], [[1, 0]]], dtype=np.int64) + output = gather_nd_impl(data, indices, 0) + expected_output = np.array([[[2, 3]], [[4, 5]]], dtype=np.float32) + assert np.array_equal(output, expected_output) + expect( + node, + inputs=[data, indices], + outputs=[output], + name="test_gathernd_example_float32", + ) + + @staticmethod + def export_int32_batchdim_1() -> None: + node = onnx.helper.make_node( + "GatherND", + inputs=["data", "indices"], + outputs=["output"], + batch_dims=1, + ) + + data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.int32) + indices = np.array([[1], [0]], dtype=np.int64) + output = gather_nd_impl(data, indices, 1) + expected_output = np.array([[2, 3], [4, 5]], dtype=np.int32) + assert np.array_equal(output, expected_output) + expect( + node, + inputs=[data, indices], + outputs=[output], + name="test_gathernd_example_int32_batch_dim1", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gelu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gelu.py new file mode 100644 index 0000000000000000000000000000000000000000..86ac9d64d7ddb8de3d325fc824db8044e973074f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gelu.py @@ -0,0 +1,52 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import math + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Gelu(Base): + @staticmethod + def export_gelu_tanh() -> None: + node = onnx.helper.make_node( + "Gelu", inputs=["x"], outputs=["y"], approximate="tanh" + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + # expected output [-0.158808, 0., 0.841192] + y = ( + 0.5 + * x + * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3)))) + ).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_gelu_tanh_1") + + x = np.random.randn(3, 4, 5).astype(np.float32) + # expected output [2.9963627, 3.99993, 4.9999995] + y = ( + 0.5 + * x + * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3)))) + ).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_gelu_tanh_2") + + @staticmethod + def export_gelu_default() -> None: + node = onnx.helper.make_node("Gelu", inputs=["x"], outputs=["y"]) + + x = np.array([-1, 0, 1]).astype(np.float32) + # expected output [-0.15865526, 0., 0.84134474] + y = (0.5 * x * (1 + np.vectorize(math.erf)(x / np.sqrt(2)))).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_gelu_default_1") + + x = np.random.randn(3, 4, 5).astype(np.float32) + # expected output [2.99595031, 3.99987331, 4.99999857] + y = (0.5 * x * (1 + np.vectorize(math.erf)(x / np.sqrt(2)))).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_gelu_default_2") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gemm.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gemm.py new file mode 100644 index 0000000000000000000000000000000000000000..5ad7aca698f4a90ea6a51cb0c227cfd0be8df064 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gemm.py @@ -0,0 +1,157 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def gemm_reference_implementation( + A: np.ndarray, + B: np.ndarray, + C: np.ndarray | None = None, + alpha: float = 1.0, + beta: float = 1.0, + transA: int = 0, + transB: int = 0, +) -> np.ndarray: + A = A if transA == 0 else A.T + B = B if transB == 0 else B.T + C = C if C is not None else np.array(0) + + Y = alpha * np.dot(A, B) + beta * C + + return Y.astype(A.dtype) + + +class Gemm(Base): + @staticmethod + def export_default_zero_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([3, 5]).astype(np.float32) + b = np.random.ranf([5, 4]).astype(np.float32) + c = np.zeros([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_zero_bias") + + @staticmethod + def export_default_no_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b"], outputs=["y"]) + a = np.random.ranf([2, 10]).astype(np.float32) + b = np.random.ranf([10, 3]).astype(np.float32) + y = gemm_reference_implementation(a, b) + expect(node, inputs=[a, b], outputs=[y], name="test_gemm_default_no_bias") + + @staticmethod + def export_default_scalar_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([2, 3]).astype(np.float32) + b = np.random.ranf([3, 4]).astype(np.float32) + c = np.array(3.14).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect( + node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_scalar_bias" + ) + + @staticmethod + def export_default_single_elem_vector_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([3, 7]).astype(np.float32) + b = np.random.ranf([7, 3]).astype(np.float32) + c = np.random.ranf([1]).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect( + node, + inputs=[a, b, c], + outputs=[y], + name="test_gemm_default_single_elem_vector_bias", + ) + + @staticmethod + def export_default_vector_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([2, 7]).astype(np.float32) + b = np.random.ranf([7, 4]).astype(np.float32) + c = np.random.ranf([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect( + node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_vector_bias" + ) + + @staticmethod + def export_default_matrix_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([3, 6]).astype(np.float32) + b = np.random.ranf([6, 4]).astype(np.float32) + c = np.random.ranf([3, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect( + node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_matrix_bias" + ) + + @staticmethod + def export_transposeA() -> None: + node = onnx.helper.make_node( + "Gemm", inputs=["a", "b", "c"], outputs=["y"], transA=1 + ) + a = np.random.ranf([6, 3]).astype(np.float32) + b = np.random.ranf([6, 4]).astype(np.float32) + c = np.zeros([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c, transA=1) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeA") + + @staticmethod + def export_transposeB() -> None: + node = onnx.helper.make_node( + "Gemm", inputs=["a", "b", "c"], outputs=["y"], transB=1 + ) + a = np.random.ranf([3, 6]).astype(np.float32) + b = np.random.ranf([4, 6]).astype(np.float32) + c = np.zeros([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c, transB=1) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeB") + + @staticmethod + def export_alpha() -> None: + node = onnx.helper.make_node( + "Gemm", inputs=["a", "b", "c"], outputs=["y"], alpha=0.5 + ) + a = np.random.ranf([3, 5]).astype(np.float32) + b = np.random.ranf([5, 4]).astype(np.float32) + c = np.zeros([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c, alpha=0.5) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_alpha") + + @staticmethod + def export_beta() -> None: + node = onnx.helper.make_node( + "Gemm", inputs=["a", "b", "c"], outputs=["y"], beta=0.5 + ) + a = np.random.ranf([2, 7]).astype(np.float32) + b = np.random.ranf([7, 4]).astype(np.float32) + c = np.random.ranf([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c, beta=0.5) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_beta") + + @staticmethod + def export_all_attributes() -> None: + node = onnx.helper.make_node( + "Gemm", + inputs=["a", "b", "c"], + outputs=["y"], + alpha=0.25, + beta=0.35, + transA=1, + transB=1, + ) + a = np.random.ranf([4, 3]).astype(np.float32) + b = np.random.ranf([5, 4]).astype(np.float32) + c = np.random.ranf([1, 5]).astype(np.float32) + y = gemm_reference_implementation( + a, b, c, transA=1, transB=1, alpha=0.25, beta=0.35 + ) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_all_attributes") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/globalaveragepool.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/globalaveragepool.py new file mode 100644 index 0000000000000000000000000000000000000000..eaab769e30aaa9a18ecd333c72a3df00e09eb812 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/globalaveragepool.py @@ -0,0 +1,44 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class GlobalAveragePool(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "GlobalAveragePool", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(1, 3, 5, 5).astype(np.float32) + y = np.mean(x, axis=tuple(range(2, np.ndim(x))), keepdims=True) + expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool") + + @staticmethod + def export_globalaveragepool_precomputed() -> None: + node = onnx.helper.make_node( + "GlobalAveragePool", + inputs=["x"], + outputs=["y"], + ) + x = np.array( + [ + [ + [ + [1, 2, 3], + [4, 5, 6], + [7, 8, 9], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[5]]]]).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool_precomputed") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/globalmaxpool.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/globalmaxpool.py new file mode 100644 index 0000000000000000000000000000000000000000..9e7e94bc4e967d249105db81448fe296b998bc22 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/globalmaxpool.py @@ -0,0 +1,44 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class GlobalMaxPool(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "GlobalMaxPool", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(1, 3, 5, 5).astype(np.float32) + y = np.max(x, axis=tuple(range(2, np.ndim(x))), keepdims=True) + expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool") + + @staticmethod + def export_globalmaxpool_precomputed() -> None: + node = onnx.helper.make_node( + "GlobalMaxPool", + inputs=["x"], + outputs=["y"], + ) + x = np.array( + [ + [ + [ + [1, 2, 3], + [4, 5, 6], + [7, 8, 9], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[9]]]]).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool_precomputed") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/greater.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/greater.py new file mode 100644 index 0000000000000000000000000000000000000000..958b698bcb9faa0b7ed3a389ff55854607ea1e20 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/greater.py @@ -0,0 +1,68 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Greater(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Greater", + inputs=["x", "y"], + outputs=["greater"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater") + + x = np.random.randn(3, 4, 5).astype(np.int8) + y = np.random.randn(3, 4, 5).astype(np.int8) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_int8") + + x = np.random.randn(3, 4, 5).astype(np.int16) + y = np.random.randn(3, 4, 5).astype(np.int16) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_int16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint32") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint64") + + @staticmethod + def export_greater_broadcast() -> None: + node = onnx.helper.make_node( + "Greater", + inputs=["x", "y"], + outputs=["greater"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_bcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/greater_equal.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/greater_equal.py new file mode 100644 index 0000000000000000000000000000000000000000..e34660228a80f782298e28d04e2acc5d932818b2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/greater_equal.py @@ -0,0 +1,68 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Greater(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "GreaterOrEqual", + inputs=["x", "y"], + outputs=["greater_equal"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal") + + x = np.random.randn(3, 4, 5).astype(np.int8) + y = np.random.randn(3, 4, 5).astype(np.int8) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int8") + + x = np.random.randn(3, 4, 5).astype(np.int16) + y = np.random.randn(3, 4, 5).astype(np.int16) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint32") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint64") + + @staticmethod + def export_greater_broadcast() -> None: + node = onnx.helper.make_node( + "GreaterOrEqual", + inputs=["x", "y"], + outputs=["greater_equal"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_bcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gridsample.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gridsample.py new file mode 100644 index 0000000000000000000000000000000000000000..26ecc8338fe2cf788dd9d746b2f32b0e3f71b934 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gridsample.py @@ -0,0 +1,642 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class GridSample(Base): + @staticmethod + def export_gridsample() -> None: + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="linear", + padding_mode="zeros", + align_corners=0, + ) + # X shape, [N, C, H, W] - [1, 1, 4, 4] + X = np.array( + [ + [ + [ + [0.0, 1.0, 2.0, 3.0], + [4.0, 5.0, 6.0, 7.0], + [8.0, 9.0, 10.0, 11.0], + [12.0, 13.0, 14.0, 15.0], + ] + ] + ], + dtype=np.float32, + ) + # Grid shape, [N, H_out, W_out, 2] - [1, 6, 6, 2] + Grid = np.array( + [ + [ + [ + [-1.0000, -1.0000], + [-0.6000, -1.0000], + [-0.2000, -1.0000], + [0.2000, -1.0000], + [0.6000, -1.0000], + [1.0000, -1.0000], + ], + [ + [-1.0000, -0.6000], + [-0.6000, -0.6000], + [-0.2000, -0.6000], + [0.2000, -0.6000], + [0.6000, -0.6000], + [1.0000, -0.6000], + ], + [ + [-1.0000, -0.2000], + [-0.6000, -0.2000], + [-0.2000, -0.2000], + [0.2000, -0.2000], + [0.6000, -0.2000], + [1.0000, -0.2000], + ], + [ + [-1.0000, 0.2000], + [-0.6000, 0.2000], + [-0.2000, 0.2000], + [0.2000, 0.2000], + [0.6000, 0.2000], + [1.0000, 0.2000], + ], + [ + [-1.0000, 0.6000], + [-0.6000, 0.6000], + [-0.2000, 0.6000], + [0.2000, 0.6000], + [0.6000, 0.6000], + [1.0000, 0.6000], + ], + [ + [-1.0000, 1.0000], + [-0.6000, 1.0000], + [-0.2000, 1.0000], + [0.2000, 1.0000], + [0.6000, 1.0000], + [1.0000, 1.0000], + ], + ] + ], + dtype=np.float32, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 6, 6] + Y = np.array( + [ + [ + [ + [0.0000, 0.1500, 0.5500, 0.9500, 1.3500, 0.7500], + [0.6000, 1.5000, 2.3000, 3.1000, 3.9000, 2.1000], + [2.2000, 4.7000, 5.5000, 6.3000, 7.1000, 3.7000], + [3.8000, 7.9000, 8.7000, 9.5000, 10.3000, 5.3000], + [5.4000, 11.1000, 11.9000, 12.7000, 13.5000, 6.9000], + [3.0000, 6.1500, 6.5500, 6.9500, 7.3500, 3.7500], + ] + ] + ], + dtype=np.float32, + ) + expect(node, inputs=[X, Grid], outputs=[Y], name="test_gridsample") + + @staticmethod + def export_gridsample_paddingmode() -> None: + # X shape, [N, C, H, W] - [1, 1, 3, 2] + X = np.array( + [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]], + dtype=np.float32, + ) + # Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2] + Grid = np.array( + [ + [ + [ + [-10.0000, -10.0000], + [-5.0000, -5.0000], + [-0.2000, -0.2000], + [10.0000, 10.0000], + ], + [ + [10.0000, 10.0000], + [-0.2000, -0.2000], + [5.0000, 5.0000], + [10.0000, 10.0000], + ], + ] + ], + dtype=np.float32, + ) + + # setting padding_mode = 'zeros' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + padding_mode="zeros", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_zeros = np.array( + [[[[0.0000, 0.0000, 1.7000, 0.0000], [0.0000, 1.7000, 0.0000, 0.0000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_zeros], + name="test_gridsample_zeros_padding", + ) + + # setting padding_mode = 'border' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + padding_mode="border", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_border = np.array( + [[[[0.0000, 0.0000, 1.7000, 5.0000], [5.0000, 1.7000, 5.0000, 5.0000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_border], + name="test_gridsample_border_padding", + ) + + # setting padding_mode = 'reflection' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + padding_mode="reflection", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_reflection = np.array( + [[[[2.5000, 0.0000, 1.7000, 2.5000], [2.5000, 1.7000, 5.0000, 2.5000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_reflection], + name="test_gridsample_reflection_padding", + ) + + @staticmethod + def export_gridsample_mode_aligncorners() -> None: + # X shape, [N, C, H, W] - [1, 1, 3, 2] + X = np.array( + [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]], + dtype=np.float32, + ) + # Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2] + Grid = np.array( + [ + [ + [ + [-1.0000, -1.0000], + [-0.5000, -0.5000], + [-0.2000, -0.2000], + [0.0000, 0.0000], + ], + [ + [0.0000, 0.0000], + [-0.2000, -0.2000], + [0.5000, 0.5000], + [1.0000, 1.0000], + ], + ] + ], + dtype=np.float32, + ) + + # setting mode = 'bilinear', default align_corners = 0 + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="linear", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bilinear = np.array( + [[[[0.0000, 0.5000, 1.7000, 2.5000], [2.5000, 1.7000, 4.5000, 1.2500]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_bilinear], + name="test_gridsample_bilinear", + ) + + # setting mode = 'bilinear', align_corners = 1 + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="linear", + align_corners=1, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_align_corners = np.array( + [[[[0.0000, 1.2500, 2.0000, 2.5000], [2.5000, 2.0000, 3.7500, 5.0000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_align_corners], + name="test_gridsample_aligncorners_true", + ) + + # setting mode = 'nearest' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="nearest", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_nearest = np.array( + [[[[0.0, 0.0, 2.0, 2.0], [2.0, 2.0, 5.0, 0.0]]]], + dtype=np.float32, + ) + + expect( + node, inputs=[X, Grid], outputs=[Y_nearest], name="test_gridsample_nearest" + ) + + # setting mode = 'bicubic' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="cubic", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bicubic = np.array( + [[[[-0.1406, 0.3828, 1.7556, 2.9688], [2.9688, 1.7556, 5.1445, 1.3906]]]], + dtype=np.float32, + ) + + expect( + node, inputs=[X, Grid], outputs=[Y_bicubic], name="test_gridsample_bicubic" + ) + + # ============================================================================ + # Additional tests + # The reference output tensors were generated using PyTorch 2.0. + Grid = np.array( + [ + [ + [[-1.0, -0.8], [-0.6, -0.5], [-0.1, -0.2], [0.7, 0.0]], + [[0.0, 0.4], [0.2, -0.2], [-0.3, 0.5], [-1.0, 1.0]], + ] + ], + dtype=np.float32, + ) + + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="nearest", + align_corners=0, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_nearest = np.array( + [[[[0.0, 0.0, 2.0, 3.0], [4.0, 3.0, 4.0, 4.0]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_nearest], + name="test_gridsample_nearest_align_corners_0_additional_1", + ) + + # setting mode = 'nearest' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="nearest", + align_corners=1, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_nearest = np.array( + [[[[0.0, 0.0, 2.0, 3.0], [2.0, 3.0, 4.0, 4.0]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_nearest], + name="test_gridsample_nearest_align_corners_1_additional_1", + ) + + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="linear", + align_corners=0, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bilinear = np.array( + [[[[0.0000, 0.4500, 1.8000, 2.4000], [3.7000, 2.1000, 3.7000, 1.0000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_bilinear], + name="test_gridsample_bilinear_align_corners_0_additional_1", + ) + + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="linear", + align_corners=1, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bilinear = np.array( + [[[[0.4000, 1.2000, 2.0500, 2.8500], [3.3000, 2.2000, 3.3500, 4.0000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_bilinear], + name="test_gridsample_bilinear_align_corners_1_additional_1", + ) + + # These two new bicubic tests produces slightly higher error ~5e-5 + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="cubic", + align_corners=0, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bicubic = np.array( + [ + [ + [ + [-0.173250, 0.284265, 1.923106, 2.568000], + [5.170375, 2.284414, 4.744844, 1.046875], + ] + ] + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_bicubic], + name="test_gridsample_bicubic_align_corners_0_additional_1", + ) + + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="cubic", + align_corners=1, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bicubic = np.array( + [ + [ + [ + [0.304001, 1.128750, 2.266270, 3.144844], + [4.531500, 2.455360, 4.599819, 4.000000], + ] + ] + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_bicubic], + name="test_gridsample_bicubic_align_corners_1_additional_1", + ) + + @staticmethod + def export_volumeetric_gridsample_mode_aligncorners() -> None: + X = np.array( + [ + [ + [ + [[1.0, 2.0], [3.0, 4.0]], + [[5.0, 6.0], [7.0, 8.0]], + [[9.0, 10.0], [11.0, 12.0]], + ] + ] + ], + dtype=np.float32, + ) + + Grid = np.array( + [ + [ + [ + [[-1.0, -1.0, -1.0], [-1.0, -0.5, 0.3]], + [[-0.5, -0.5, -0.5], [1.0, -0.6, -1.0]], + [[-0.2, -0.2, -0.2], [0.4, 0.2, 0.6]], + [[0.0, 0.0, 0.0], [-1.0, 0.0, 0.0]], + ], + [ + [[0.0, 0.0, 0.0], [-1.0, 1.0, 0.0]], + [[-0.2, -0.2, -0.2], [1.0, 0.4, -0.2]], + [[0.5, 0.5, 0.5], [-1.0, -0.8, 0.8]], + [[1.0, 1.0, 1.0], [0.4, 0.6, -0.3]], + ], + ] + ], + dtype=np.float32, + ) + + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="nearest", + align_corners=0, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_nearest = np.array( + [ + [ + [ + [[1.0, 5.0], [1.0, 0.0], [5.0, 12.0], [5.0, 5.0]], + [[5.0, 0.0], [5.0, 0.0], [12.0, 9.0], [0.0, 8.0]], + ] + ] + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_nearest], + name="test_gridsample_volumetric_nearest_align_corners_0", + ) + + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="nearest", + align_corners=1, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_nearest = np.array( + [ + [ + [ + [[1.0, 5.0], [1.0, 2.0], [5.0, 12.0], [5.0, 5.0]], + [[5.0, 7.0], [5.0, 8.0], [12.0, 9.0], [12.0, 8.0]], + ] + ] + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_nearest], + name="test_gridsample_volumetric_nearest_align_corners_1", + ) + + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="linear", + align_corners=0, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bilinear = np.array( + [ + [ + [ + [ + [0.1250, 3.4000], + [2.0000, 0.4500], + [4.7000, 10.9000], + [6.5000, 3.0000], + ], + [ + [6.5000, 1.7500], + [4.7000, 3.3000], + [11.0000, 2.5200], + [1.5000, 5.4900], + ], + ] + ] + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_bilinear], + name="test_gridsample_volumetric_bilinear_align_corners_0", + ) + + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="linear", + align_corners=1, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bilinear = np.array( + [ + [ + [ + [ + [1.0000, 6.7000], + [3.7500, 2.4000], + [5.4000, 9.3000], + [6.5000, 6.0000], + ], + [ + [6.5000, 7.0000], + [5.4000, 6.6000], + [9.2500, 8.4000], + [12.0000, 6.1000], + ], + ] + ] + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_bilinear], + name="test_gridsample_volumetric_bilinear_align_corners_1", + ) + + """ + For someone who want to test by script. Comment it cause github ONNX CI + do not have the torch python package. + @staticmethod + def export_gridsample_torch(): # type: () -> None + node = onnx.helper.make_node( + 'GridSample', + inputs=['X', 'Grid'], + outputs=['Y'], + mode='bilinear', + padding_mode='zeros', + align_corners=0, + ) + + # X shape, [N, C, H, W] - [1, 1, 4, 4] + # Grid shape, [N, H_out, W_out, 2] - [1, 6, 6, 2] + # Y shape, [N, C, H_out, W_out] - [1, 1, 6, 6] + import torch + X = torch.arange(3 * 3).view(1, 1, 3, 3).float() + d = torch.linspace(-1, 1, 6) + meshx, meshy = torch.meshgrid((d, d)) + grid = torch.stack((meshy, meshx), 2) + Grid = grid.unsqueeze(0) + Y = torch.nn.functional.grid_sample(X, Grid, mode='bilinear', + padding_mode='zeros', align_corners=False) + expect(node, inputs=[X.numpy(), Grid.numpy()], outputs=[Y.numpy()], + name='test_gridsample_torch') + """ diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/groupnormalization.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/groupnormalization.py new file mode 100644 index 0000000000000000000000000000000000000000..69a79096b90ab3891b005b3cf9d90622d9a294b1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/groupnormalization.py @@ -0,0 +1,78 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# Group normalization's reference implementation +def _group_normalization(x, num_groups, scale, bias, epsilon=1e-5): + # Assume channel is first dim + assert x.shape[1] % num_groups == 0 + group_size = x.shape[1] // num_groups + # Reshape to [N, group_size, C/group_size, H, W, ...] + new_shape = [x.shape[0], num_groups, group_size, *list(x.shape[2:])] + x_reshaped = x.reshape(new_shape) + axes = tuple(range(2, len(new_shape))) + mean = np.mean(x_reshaped, axis=axes, keepdims=True) + var = np.var(x_reshaped, axis=axes, keepdims=True) + x_normalized = ((x_reshaped - mean) / np.sqrt(var + epsilon)).reshape(x.shape) + dim_ones = (1,) * (len(x.shape) - 2) + scale = scale.reshape(-1, *dim_ones) + bias = bias.reshape(-1, *dim_ones) + return scale * x_normalized + bias + + +class GroupNormalization(Base): + @staticmethod + def export() -> None: + c = 4 + num_groups = 2 + x = np.random.randn(3, c, 2, 2).astype(np.float32) + scale = np.random.randn(c).astype(np.float32) + bias = np.random.randn(c).astype(np.float32) + y = _group_normalization(x, num_groups, scale, bias).astype(np.float32) + + node = onnx.helper.make_node( + "GroupNormalization", + inputs=["x", "scale", "bias"], + outputs=["y"], + num_groups=num_groups, + ) + + expect( + node, + inputs=[x, scale, bias], + outputs=[y], + name="test_group_normalization_example", + ) + + @staticmethod + def export_epsilon() -> None: + c = 4 + num_groups = 2 + x = np.random.randn(3, c, 2, 2).astype(np.float32) + scale = np.random.randn(c).astype(np.float32) + bias = np.random.randn(c).astype(np.float32) + epsilon = 1e-2 + y = _group_normalization(x, num_groups, scale, bias, epsilon).astype(np.float32) + + node = onnx.helper.make_node( + "GroupNormalization", + inputs=["x", "scale", "bias"], + outputs=["y"], + epsilon=epsilon, + num_groups=num_groups, + ) + + expect( + node, + inputs=[x, scale, bias], + outputs=[y], + name="test_group_normalization_epsilon", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gru.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gru.py new file mode 100644 index 0000000000000000000000000000000000000000..4ff29fc1011aa00cfb0666f6e0d09ff588e7780b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/gru.py @@ -0,0 +1,264 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class GRUHelper: + def __init__(self, **params: Any) -> None: + # GRU Input Names + X = "X" + W = "W" + R = "R" + B = "B" + H_0 = "initial_h" + LBR = "linear_before_reset" + LAYOUT = "layout" + number_of_gates = 3 + + required_inputs = [X, W, R] + for i in required_inputs: + assert i in params, f"Missing Required Input: {i}" + + self.num_directions = params[W].shape[0] + + if self.num_directions == 1: + for k, v in params.items(): + if k != X: + params[k] = np.squeeze(v, axis=0) + + hidden_size = params[R].shape[-1] + batch_size = params[X].shape[1] + + layout = params.get(LAYOUT, 0) + x = params[X] + x = x if layout == 0 else np.swapaxes(x, 0, 1) + b = ( + params[B] + if B in params + else np.zeros(2 * number_of_gates * hidden_size) + ) + h_0 = params[H_0] if H_0 in params else np.zeros((batch_size, hidden_size)) + lbr = params.get(LBR, 0) + + self.X = x + self.W = params[W] + self.R = params[R] + self.B = b + self.H_0 = h_0 + self.LBR = lbr + self.LAYOUT = layout + + else: + raise NotImplementedError + + def f(self, x: np.ndarray) -> np.ndarray: + return 1 / (1 + np.exp(-x)) + + def g(self, x: np.ndarray) -> np.ndarray: + return np.tanh(x) + + def step(self) -> tuple[np.ndarray, np.ndarray]: + seq_length = self.X.shape[0] + hidden_size = self.H_0.shape[-1] + batch_size = self.X.shape[1] + + Y = np.empty([seq_length, self.num_directions, batch_size, hidden_size]) + h_list = [] + + [w_z, w_r, w_h] = np.split(self.W, 3) + [r_z, r_r, r_h] = np.split(self.R, 3) + [w_bz, w_br, w_bh, r_bz, r_br, r_bh] = np.split(self.B, 6) + gates_w = np.transpose(np.concatenate((w_z, w_r))) + gates_r = np.transpose(np.concatenate((r_z, r_r))) + gates_b = np.add(np.concatenate((w_bz, w_br)), np.concatenate((r_bz, r_br))) + + H_t = self.H_0 + for x in np.split(self.X, self.X.shape[0], axis=0): + gates = np.dot(x, gates_w) + np.dot(H_t, gates_r) + gates_b + z, r = np.split(gates, 2, -1) + z = self.f(z) + r = self.f(r) + h_default = self.g( + np.dot(x, np.transpose(w_h)) + + np.dot(r * H_t, np.transpose(r_h)) + + w_bh + + r_bh + ) + h_linear = self.g( + np.dot(x, np.transpose(w_h)) + + r * (np.dot(H_t, np.transpose(r_h)) + r_bh) + + w_bh + ) + h = h_linear if self.LBR else h_default + H = (1 - z) * h + z * H_t + h_list.append(H) + H_t = H + + concatenated = np.concatenate(h_list) + if self.num_directions == 1: + Y[:, 0, :, :] = concatenated + + if self.LAYOUT == 0: + Y_h = Y[-1] + else: + Y = np.transpose(Y, [2, 0, 1, 3]) + Y_h = Y[:, :, -1, :] + + return Y, Y_h + + +class GRU(Base): + @staticmethod + def export_defaults() -> None: + input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 5 + weight_scale = 0.1 + number_of_gates = 3 + + node = onnx.helper.make_node( + "GRU", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + gru = GRUHelper(X=input, W=W, R=R) + _, Y_h = gru.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y_h.astype(np.float32)], + name="test_gru_defaults", + ) + + @staticmethod + def export_initial_bias() -> None: + input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype( + np.float32 + ) + + input_size = 3 + hidden_size = 3 + weight_scale = 0.1 + custom_bias = 0.1 + number_of_gates = 3 + + node = onnx.helper.make_node( + "GRU", + inputs=["X", "W", "R", "B"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + # Adding custom bias + W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype( + np.float32 + ) + R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32) + B = np.concatenate((W_B, R_B), axis=1) + + gru = GRUHelper(X=input, W=W, R=R, B=B) + _, Y_h = gru.step() + expect( + node, + inputs=[input, W, R, B], + outputs=[Y_h.astype(np.float32)], + name="test_gru_with_initial_bias", + ) + + @staticmethod + def export_seq_length() -> None: + input = np.array( + [ + [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], + [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]], + ] + ).astype(np.float32) + + input_size = 3 + hidden_size = 5 + number_of_gates = 3 + + node = onnx.helper.make_node( + "GRU", + inputs=["X", "W", "R", "B"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + W = np.random.randn(1, number_of_gates * hidden_size, input_size).astype( + np.float32 + ) + R = np.random.randn(1, number_of_gates * hidden_size, hidden_size).astype( + np.float32 + ) + + # Adding custom bias + W_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32) + R_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32) + B = np.concatenate((W_B, R_B), axis=1) + + gru = GRUHelper(X=input, W=W, R=R, B=B) + _, Y_h = gru.step() + expect( + node, + inputs=[input, W, R, B], + outputs=[Y_h.astype(np.float32)], + name="test_gru_seq_length", + ) + + @staticmethod + def export_batchwise() -> None: + input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 6 + number_of_gates = 3 + weight_scale = 0.2 + layout = 1 + + node = onnx.helper.make_node( + "GRU", + inputs=["X", "W", "R"], + outputs=["Y", "Y_h"], + hidden_size=hidden_size, + layout=layout, + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + gru = GRUHelper(X=input, W=W, R=R, layout=layout) + Y, Y_h = gru.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y.astype(np.float32), Y_h.astype(np.float32)], + name="test_gru_batchwise", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hammingwindow.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hammingwindow.py new file mode 100644 index 0000000000000000000000000000000000000000..7cd3bf5743cf52dbe09d08ad404e212196337ae1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hammingwindow.py @@ -0,0 +1,48 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class HammingWindow(Base): + @staticmethod + def export() -> None: + # Test periodic window + node = onnx.helper.make_node( + "HammingWindow", + inputs=["x"], + outputs=["y"], + ) + size = np.int32(10) + a0 = 25 / 46 + a1 = 1 - a0 + y = a0 - a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size) + expect( + node, + inputs=[size], + outputs=[y.astype(np.float32)], + name="test_hammingwindow", + ) + + # Test symmetric window + node = onnx.helper.make_node( + "HammingWindow", inputs=["x"], outputs=["y"], periodic=0 + ) + size = np.int32(10) + a0 = 25 / 46 + a1 = 1 - a0 + y = a0 - a1 * np.cos( + 2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1) + ) + expect( + node, + inputs=[size], + outputs=[y.astype(np.float32)], + name="test_hammingwindow_symmetric", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hannwindow.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hannwindow.py new file mode 100644 index 0000000000000000000000000000000000000000..ba41c4ad06428b5fabb3f6554f0ee9b1c79a4cc7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hannwindow.py @@ -0,0 +1,45 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class HannWindow(Base): + @staticmethod + def export() -> None: + # Test periodic window + node = onnx.helper.make_node( + "HannWindow", + inputs=["x"], + outputs=["y"], + ) + size = np.int32(10) + a0 = 0.5 + a1 = 0.5 + y = a0 - a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size) + expect( + node, inputs=[size], outputs=[y.astype(np.float32)], name="test_hannwindow" + ) + + # Test symmetric window + node = onnx.helper.make_node( + "HannWindow", inputs=["x"], outputs=["y"], periodic=0 + ) + size = np.int32(10) + a0 = 0.5 + a1 = 0.5 + y = a0 - a1 * np.cos( + 2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1) + ) + expect( + node, + inputs=[size], + outputs=[y.astype(np.float32)], + name="test_hannwindow_symmetric", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardmax.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardmax.py new file mode 100644 index 0000000000000000000000000000000000000000..4af4592c905d16d160eb16c2115087208833fbbe --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardmax.py @@ -0,0 +1,92 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def hardmax(x: np.ndarray, axis: int = -1) -> np.ndarray: + x_argmax = np.argmax(x, axis=axis) + y = np.zeros_like(x) + np.put_along_axis(y, np.expand_dims(x_argmax, axis=axis), 1, axis=axis) + return y + + +class Hardmax(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([[3, 0, 1, 2], [2, 5, 1, 0], [0, 1, 3, 2], [0, 1, 2, 3]]).astype( + np.float32 + ) + # expect result: + # [[1. 0. 0. 0.] + # [0. 1. 0. 0.] + # [0. 0. 1. 0.] + # [0. 0. 0. 1.]] + y = hardmax(x) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_example") + + # For multiple occurrences of the maximal values, the first occurrence is selected for one-hot output + x = np.array([[3, 3, 3, 1]]).astype(np.float32) + # expect result: + # [[1, 0, 0, 0]] + y = hardmax(x) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_one_hot") + + @staticmethod + def export_hardmax_axis() -> None: + x = np.random.randn(3, 4, 5).astype(np.float32) + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + axis=0, + ) + y = hardmax(x, axis=0) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_0") + + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + axis=1, + ) + y = hardmax(x, axis=1) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_1") + + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + axis=2, + ) + y = hardmax(x, axis=2) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_2") + + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + axis=-1, + ) + y = hardmax(x, axis=-1) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_negative_axis") + + # default axis is -1 + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + ) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_default_axis") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardsigmoid.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardsigmoid.py new file mode 100644 index 0000000000000000000000000000000000000000..f7881415aea22609d005f04e0329094cc3bac372 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardsigmoid.py @@ -0,0 +1,39 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class HardSigmoid(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "HardSigmoid", inputs=["x"], outputs=["y"], alpha=0.5, beta=0.6 + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.clip(x * 0.5 + 0.6, 0, 1) # expected output [0.1, 0.6, 1.] + expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x * 0.5 + 0.6, 0, 1) + expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid") + + @staticmethod + def export_hardsigmoid_default() -> None: + default_alpha = 0.2 + default_beta = 0.5 + node = onnx.helper.make_node( + "HardSigmoid", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x * default_alpha + default_beta, 0, 1) + expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_default") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardswish.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardswish.py new file mode 100644 index 0000000000000000000000000000000000000000..72dd67582f7929514b7649641979af0f7f25e46d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/hardswish.py @@ -0,0 +1,30 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def hardswish(x: np.ndarray) -> np.ndarray: + alfa = float(1 / 6) + beta = 0.5 + return x * np.maximum(0, np.minimum(1, alfa * x + beta)) + + +class HardSwish(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "HardSwish", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = hardswish(x) + + expect(node, inputs=[x], outputs=[y], name="test_hardswish") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/identity.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/identity.py new file mode 100644 index 0000000000000000000000000000000000000000..d399ae93568f68186a4c1679167034099662bd3b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/identity.py @@ -0,0 +1,93 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Identity(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Identity", + inputs=["x"], + outputs=["y"], + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + expect(node, inputs=[data], outputs=[data], name="test_identity") + + @staticmethod + def export_sequence() -> None: + node = onnx.helper.make_node( + "Identity", + inputs=["x"], + outputs=["y"], + ) + + data = [ + np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ), + np.array( + [ + [ + [ + [2, 3], + [1, 5], + ] + ] + ], + dtype=np.float32, + ), + ] + + expect(node, inputs=[data], outputs=[data], name="test_identity_sequence") + + @staticmethod + def export_identity_opt() -> None: + ten_in_tp = onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, shape=[5] + ) + seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp) + opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp) + + identity_node = onnx.helper.make_node( + "Identity", inputs=["opt_in"], outputs=["opt_out"] + ) + + x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)] + + expect( + identity_node, + inputs=[x], + outputs=[x], + name="test_identity_opt", + opset_imports=[onnx.helper.make_opsetid("", 16)], + input_type_protos=[opt_in_tp], + output_type_protos=[opt_in_tp], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/if_.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/if_.py new file mode 100644 index 0000000000000000000000000000000000000000..d22c8a0730bd2b66ce2cb355cffa17f691ae501a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/if_.py @@ -0,0 +1,210 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def compute_if_outputs(x, cond): + if cond: + return [] + return x + + +class If(Base): + @staticmethod + def export_if() -> None: + # Given a bool scalar input cond. + # return constant tensor x if cond is True, otherwise return constant tensor y. + + then_out = onnx.helper.make_tensor_value_info( + "then_out", onnx.TensorProto.FLOAT, [5] + ) + else_out = onnx.helper.make_tensor_value_info( + "else_out", onnx.TensorProto.FLOAT, [5] + ) + + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + y = np.array([5, 4, 3, 2, 1]).astype(np.float32) + + then_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["then_out"], + value=onnx.numpy_helper.from_array(x), + ) + + else_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["else_out"], + value=onnx.numpy_helper.from_array(y), + ) + + then_body = onnx.helper.make_graph( + [then_const_node], "then_body", [], [then_out] + ) + + else_body = onnx.helper.make_graph( + [else_const_node], "else_body", [], [else_out] + ) + + if_node = onnx.helper.make_node( + "If", + inputs=["cond"], + outputs=["res"], + then_branch=then_body, + else_branch=else_body, + ) + + cond = np.array(1).astype(bool) + res = x if cond else y + expect( + if_node, + inputs=[cond], + outputs=[res], + name="test_if", + opset_imports=[onnx.helper.make_opsetid("", 11)], + ) + + @staticmethod + def export_if_seq() -> None: + # Given a bool scalar input cond. + # return constant sequence x if cond is True, otherwise return constant sequence y. + + then_out = onnx.helper.make_tensor_sequence_value_info( + "then_out", onnx.TensorProto.FLOAT, shape=[5] + ) + else_out = onnx.helper.make_tensor_sequence_value_info( + "else_out", onnx.TensorProto.FLOAT, shape=[5] + ) + + x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)] + y = [np.array([5, 4, 3, 2, 1]).astype(np.float32)] + + then_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.numpy_helper.from_array(x[0]), + ) + + then_seq_node = onnx.helper.make_node( + "SequenceConstruct", inputs=["x"], outputs=["then_out"] + ) + + else_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["y"], + value=onnx.numpy_helper.from_array(y[0]), + ) + + else_seq_node = onnx.helper.make_node( + "SequenceConstruct", inputs=["y"], outputs=["else_out"] + ) + + then_body = onnx.helper.make_graph( + [then_const_node, then_seq_node], "then_body", [], [then_out] + ) + + else_body = onnx.helper.make_graph( + [else_const_node, else_seq_node], "else_body", [], [else_out] + ) + + if_node = onnx.helper.make_node( + "If", + inputs=["cond"], + outputs=["res"], + then_branch=then_body, + else_branch=else_body, + ) + + cond = np.array(1).astype(bool) + res = x if cond else y + expect( + if_node, + inputs=[cond], + outputs=[res], + name="test_if_seq", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + @staticmethod + def export_if_optional() -> None: + # Given a bool scalar input cond, return an empty optional sequence of + # tensor if True, return an optional sequence with value x + # (the input optional sequence) otherwise. + + ten_in_tp = onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, shape=[5] + ) + seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp) + + then_out_tensor_tp = onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, shape=[5] + ) + then_out_seq_tp = onnx.helper.make_sequence_type_proto(then_out_tensor_tp) + then_out_opt_tp = onnx.helper.make_optional_type_proto(then_out_seq_tp) + then_out = onnx.helper.make_value_info("optional_empty", then_out_opt_tp) + + else_out_tensor_tp = onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, shape=[5] + ) + else_out_seq_tp = onnx.helper.make_sequence_type_proto(else_out_tensor_tp) + else_out_opt_tp = onnx.helper.make_optional_type_proto(else_out_seq_tp) + else_out = onnx.helper.make_value_info("else_opt", else_out_opt_tp) + + x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)] + cond = np.array(0).astype(bool) + res = compute_if_outputs(x, cond) + + opt_empty_in = onnx.helper.make_node( + "Optional", inputs=[], outputs=["optional_empty"], type=seq_in_tp + ) + + then_body = onnx.helper.make_graph([opt_empty_in], "then_body", [], [then_out]) + + else_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.numpy_helper.from_array(x[0]), + ) + + else_seq_node = onnx.helper.make_node( + "SequenceConstruct", inputs=["x"], outputs=["else_seq"] + ) + + else_optional_seq_node = onnx.helper.make_node( + "Optional", inputs=["else_seq"], outputs=["else_opt"] + ) + + else_body = onnx.helper.make_graph( + [else_const_node, else_seq_node, else_optional_seq_node], + "else_body", + [], + [else_out], + ) + + if_node = onnx.helper.make_node( + "If", + inputs=["cond"], + outputs=["sequence"], + then_branch=then_body, + else_branch=else_body, + ) + + expect( + if_node, + inputs=[cond], + outputs=[res], + name="test_if_opt", + output_type_protos=[else_out_opt_tp], + opset_imports=[onnx.helper.make_opsetid("", 16)], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/image_decoder.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/image_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..883845da33131378c8f188aa5e752ee4c3c282cf --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/image_decoder.py @@ -0,0 +1,249 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import io + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import _image_decoder_data, expect + + +def generate_checkerboard(width: int, height: int, square_size: int) -> np.ndarray: + # Create an empty RGB image + image = np.zeros((height, width, 3), dtype=np.uint8) + + # Calculate the number of squares in each dimension + num_squares_x = width // square_size + num_squares_y = height // square_size + + # Generate a random color for each square + colors = np.random.randint( + 0, 256, size=(num_squares_y, num_squares_x, 3), dtype=np.uint8 + ) + + # Iterate over each square + for i in range(num_squares_y): + for j in range(num_squares_x): + # Calculate the position of the current square + x = j * square_size + y = i * square_size + + # Get the color for the current square + color = colors[i, j] + + # Fill the square with the corresponding color + image[y : y + square_size, x : x + square_size, :] = color + + return image + + +def _generate_test_data( + format_: str, + frozen_data: _image_decoder_data.ImageDecoderData, + pixel_format: str = "RGB", + height: int = 32, + width: int = 32, + tile_sz: int = 5, +) -> tuple[np.ndarray, np.ndarray]: + try: + import PIL.Image # noqa: PLC0415 + except ImportError: + # Since pillow is not installed to generate test data for the ImageDecoder operator + # directly use the frozen data from _image_decoder_data.py. + return frozen_data.data, frozen_data.output + np.random.seed(12345) + image = generate_checkerboard(height, width, tile_sz) + image_pil = PIL.Image.fromarray(image) + with io.BytesIO() as f: + image_pil.save(f, format=format_) + data = f.getvalue() + data_array = np.frombuffer(data, dtype=np.uint8) + if pixel_format == "BGR": + output_pil = PIL.Image.open(io.BytesIO(data)) + output = np.array(output_pil)[:, :, ::-1] + elif pixel_format == "RGB": + output_pil = PIL.Image.open(io.BytesIO(data)) + output = np.array(output_pil) + elif pixel_format == "Grayscale": + output_pil = PIL.Image.open(io.BytesIO(data)).convert("L") + output = np.array(output_pil)[:, :, np.newaxis] + else: + raise ValueError(f"Unsupported pixel format: {pixel_format}") + return data_array, output + + +class ImageDecoder(Base): + @staticmethod + def export_image_decoder_decode_jpeg_rgb() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="RGB", + ) + + data, output = _generate_test_data( + "jpeg", _image_decoder_data.image_decoder_decode_jpeg_rgb, "RGB" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_jpeg_rgb", + ) + + @staticmethod + def export_image_decoder_decode_jpeg_grayscale() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="Grayscale", + ) + + data, output = _generate_test_data( + "jpeg", _image_decoder_data.image_decoder_decode_jpeg_grayscale, "Grayscale" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_jpeg_grayscale", + ) + + @staticmethod + def export_image_decoder_decode_jpeg_bgr() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="BGR", + ) + + data, output = _generate_test_data( + "jpeg", _image_decoder_data.image_decoder_decode_jpeg_bgr, "BGR" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_jpeg_bgr", + ) + + @staticmethod + def export_image_decoder_decode_jpeg2k_rgb() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="RGB", + ) + + data, output = _generate_test_data( + "jpeg2000", _image_decoder_data.image_decoder_decode_jpeg2k_rgb, "RGB" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_jpeg2k_rgb", + ) + + @staticmethod + def export_image_decoder_decode_bmp_rgb() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="RGB", + ) + + data, output = _generate_test_data( + "bmp", _image_decoder_data.image_decoder_decode_bmp_rgb, "RGB" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_bmp_rgb", + ) + + @staticmethod + def export_image_decoder_decode_png_rgb() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="RGB", + ) + + data, output = _generate_test_data( + "png", _image_decoder_data.image_decoder_decode_png_rgb, "RGB" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_png_rgb", + ) + + @staticmethod + def export_image_decoder_decode_tiff_rgb() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="RGB", + ) + + data, output = _generate_test_data( + "tiff", _image_decoder_data.image_decoder_decode_tiff_rgb, "RGB" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_tiff_rgb", + ) + + @staticmethod + def export_image_decoder_decode_webp_rgb() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="RGB", + ) + + data, output = _generate_test_data( + "webp", _image_decoder_data.image_decoder_decode_webp_rgb, "RGB" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_webp_rgb", + ) + + @staticmethod + def export_image_decoder_decode_pnm_rgb() -> None: + node = onnx.helper.make_node( + "ImageDecoder", + inputs=["data"], + outputs=["output"], + pixel_format="RGB", + ) + + data, output = _generate_test_data( + "ppm", _image_decoder_data.image_decoder_decode_pnm_rgb, "RGB" + ) + expect( + node, + inputs=[data], + outputs=[output], + name="test_image_decoder_decode_pnm_rgb", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/instancenorm.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/instancenorm.py new file mode 100644 index 0000000000000000000000000000000000000000..09b1f43ed35302c8b85d771d87c672ee072aa7e3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/instancenorm.py @@ -0,0 +1,58 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class InstanceNormalization(Base): + @staticmethod + def export() -> None: + def _instancenorm_test_mode( + x: np.ndarray, s: np.ndarray, bias: np.ndarray, epsilon: float = 1e-5 + ) -> np.ndarray: + dims_x = len(x.shape) + axis = tuple(range(2, dims_x)) + mean = np.mean(x, axis=axis, keepdims=True) + var = np.var(x, axis=axis, keepdims=True) + dim_ones = (1,) * (dims_x - 2) + s = s.reshape(-1, *dim_ones) + bias = bias.reshape(-1, *dim_ones) + return s * (x - mean) / np.sqrt(var + epsilon) + bias + + # input size: (1, 2, 1, 3) + x = np.array([[[[-1, 0, 1]], [[2, 3, 4]]]]).astype(np.float32) + s = np.array([1.0, 1.5]).astype(np.float32) + bias = np.array([0, 1]).astype(np.float32) + y = _instancenorm_test_mode(x, s, bias).astype(np.float32) + + node = onnx.helper.make_node( + "InstanceNormalization", + inputs=["x", "s", "bias"], + outputs=["y"], + ) + + # output size: (1, 2, 1, 3) + expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_example") + + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + epsilon = 1e-2 + y = _instancenorm_test_mode(x, s, bias, epsilon).astype(np.float32) + + node = onnx.helper.make_node( + "InstanceNormalization", + inputs=["x", "s", "bias"], + outputs=["y"], + epsilon=epsilon, + ) + + # output size: (2, 3, 4, 5) + expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_epsilon") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/isinf.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/isinf.py new file mode 100644 index 0000000000000000000000000000000000000000..11ffcd58218a139a3a088e4c3c4c239b3946959d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/isinf.py @@ -0,0 +1,56 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class IsInf(Base): + @staticmethod + def export_infinity() -> None: + node = onnx.helper.make_node( + "IsInf", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32) + y = np.isinf(x) + expect(node, inputs=[x], outputs=[y], name="test_isinf") + + @staticmethod + def export_positive_infinity_only() -> None: + node = onnx.helper.make_node( + "IsInf", inputs=["x"], outputs=["y"], detect_negative=0 + ) + + x = np.array([-1.7, np.nan, np.inf, 3.6, -np.inf, np.inf], dtype=np.float32) + y = np.isposinf(x) + expect(node, inputs=[x], outputs=[y], name="test_isinf_positive") + + @staticmethod + def export_negative_infinity_only() -> None: + node = onnx.helper.make_node( + "IsInf", inputs=["x"], outputs=["y"], detect_positive=0 + ) + + x = np.array([-1.7, np.nan, np.inf, -3.6, -np.inf, np.inf], dtype=np.float32) + y = np.isneginf(x) + expect(node, inputs=[x], outputs=[y], name="test_isinf_negative") + + @staticmethod + def export_infinity_float16() -> None: + node = onnx.helper.make_node( + "IsInf", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16) + y = np.isinf(x) + expect(node, inputs=[x], outputs=[y], name="test_isinf_float16") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/isnan.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/isnan.py new file mode 100644 index 0000000000000000000000000000000000000000..a8cecf87a97cc849cb4590453b3d5187ffd956d5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/isnan.py @@ -0,0 +1,36 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class IsNaN(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "IsNaN", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32) + y = np.isnan(x) + expect(node, inputs=[x], outputs=[y], name="test_isnan") + + @staticmethod + def export_float16() -> None: + node = onnx.helper.make_node( + "IsNaN", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16) + y = np.isnan(x) + expect(node, inputs=[x], outputs=[y], name="test_isnan_float16") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/layernormalization.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/layernormalization.py new file mode 100644 index 0000000000000000000000000000000000000000..5f2776e52bd2e6b4e2fa719242d269494b25ce8b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/layernormalization.py @@ -0,0 +1,178 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# Layer normalization's reference implementation +def _layer_normalization(X, W, B, axis=-1, epsilon=1e-5): + X_shape = X.shape + X_rank = len(X_shape) + if axis < 0: + # If axis = -1 and rank of X is 4, + # the axis is changed to -1 + 4 = 3, + # which means the last axis. + axis = axis + X_rank + unsqueezed_rank = X_rank - axis + reduction_shape = X_shape[0:axis] + (1,) * unsqueezed_rank + + # Parameter used to convert N-D tensor layer + # normalization to equivalent 2-D matrix operations. + row_number = 1 + col_number = 1 + for i in range(X_rank): + if i < axis: + row_number *= X_shape[i] + else: + col_number *= X_shape[i] + + # After reshaping input tensor X into a matrix, + # layer normalization is equivalent to conducting + # standardization on each column vector (s.t. each + # column has zero mean and unit variance). + x_mat = np.reshape(X, (row_number, col_number)) + # This computes mean for every x_mat's column. + x_mean = np.sum(x_mat, axis=1, keepdims=True) / col_number + x_diff = x_mat - x_mean + x_squared_diff = x_diff * x_diff + # This computes variance for every x_mat's column. + variance = np.sum(x_squared_diff, axis=1, keepdims=True) / col_number + variance_eps = variance + epsilon + std_dev = np.sqrt(variance_eps) + inv_std_dev = np.reciprocal(std_dev) + # Standardization step. y_mat is zero-mean and unit-variance. + y_mat = x_diff * inv_std_dev + # Apply affine transform on normalization outcome. + # W is linear coefficient while B is bias. + Y = np.reshape(y_mat, X_shape) * W + B + # Matrix-level operations' outputs should be reshaped + # to compensate the initial tensor-to-matrix reshape. + X_mean = np.reshape(x_mean, reduction_shape) + X_inv_std_dev = np.reshape(inv_std_dev, reduction_shape) + + return Y, X_mean, X_inv_std_dev + + +def calculate_normalized_shape(X_shape, axis): + X_rank = len(X_shape) + if axis < 0: + axis = axis + X_rank + return X_shape[axis:] + + +class LayerNormalization(Base): + @staticmethod + def export() -> None: + X = np.random.randn(2, 3, 4, 5).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + B = np.random.randn(*normalized_shape).astype(np.float32) + Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis) + + node = onnx.helper.make_node( + "LayerNormalization", + inputs=["X", "W", "B"], + outputs=["Y", "Mean", "InvStdDev"], + axis=axis, + ) + + if axis < 0: + name = f"test_layer_normalization_4d_axis_negative_{-axis}" + else: + name = f"test_layer_normalization_4d_axis{axis}" + + expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) + + @staticmethod + def export_default_axis() -> None: + X = np.random.randn(2, 3, 4, 5).astype(np.float32) + + # Default axis in LayerNormalization is -1. + normalized_shape = calculate_normalized_shape(X.shape, -1) + W = np.random.randn(*normalized_shape).astype(np.float32) + B = np.random.randn(*normalized_shape).astype(np.float32) + # Axis is default to -1 in the reference implementation. + Y, mean, inv_std_dev = _layer_normalization(X, W, B) + + # Not specifying axis attribute means -1. + node = onnx.helper.make_node( + "LayerNormalization", + inputs=["X", "W", "B"], + outputs=["Y", "Mean", "InvStdDev"], + ) + + expect( + node, + inputs=[X, W, B], + outputs=[Y, mean, inv_std_dev], + name="test_layer_normalization_default_axis", + ) + + @staticmethod + def export2d() -> None: + X = np.random.randn(3, 4).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + B = np.random.randn(*normalized_shape).astype(np.float32) + Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis=axis) + + node = onnx.helper.make_node( + "LayerNormalization", + inputs=["X", "W", "B"], + outputs=["Y", "Mean", "InvStdDev"], + axis=axis, + ) + + if axis < 0: + name = f"test_layer_normalization_2d_axis_negative_{-axis}" + else: + name = f"test_layer_normalization_2d_axis{axis}" + + expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) + + @staticmethod + def export3d_epsilon() -> None: + epsilon = 1e-1 + X = np.random.randn(2, 3, 5).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + B = np.random.randn(*normalized_shape).astype(np.float32) + Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis, epsilon) + node = onnx.helper.make_node( + "LayerNormalization", + inputs=["X", "W", "B"], + outputs=["Y", "Mean", "InvStdDev"], + axis=axis, + epsilon=epsilon, + ) + + if axis < 0: + name = f"test_layer_normalization_3d_axis_negative_{-axis}_epsilon" + else: + name = f"test_layer_normalization_3d_axis{axis}_epsilon" + + expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/leakyrelu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/leakyrelu.py new file mode 100644 index 0000000000000000000000000000000000000000..b24b5a948ce9e12e6454cd9374bc64d5fae72c5f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/leakyrelu.py @@ -0,0 +1,39 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class LeakyRelu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "LeakyRelu", inputs=["x"], outputs=["y"], alpha=0.1 + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + # expected output [-0.1, 0., 1.] + y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1 + expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1 + expect(node, inputs=[x], outputs=[y], name="test_leakyrelu") + + @staticmethod + def export_leakyrelu_default() -> None: + default_alpha = 0.01 + node = onnx.helper.make_node( + "LeakyRelu", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * default_alpha + expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_default") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/less.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/less.py new file mode 100644 index 0000000000000000000000000000000000000000..b3252798f5bba1a2d583038cd0278510928281b4 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/less.py @@ -0,0 +1,68 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Less(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Less", + inputs=["x", "y"], + outputs=["less"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less") + + x = np.random.randn(3, 4, 5).astype(np.int8) + y = np.random.randn(3, 4, 5).astype(np.int8) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_int8") + + x = np.random.randn(3, 4, 5).astype(np.int16) + y = np.random.randn(3, 4, 5).astype(np.int16) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_int16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_uint8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_uint16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_uint32") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_uint64") + + @staticmethod + def export_less_broadcast() -> None: + node = onnx.helper.make_node( + "Less", + inputs=["x", "y"], + outputs=["less"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_bcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/less_equal.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/less_equal.py new file mode 100644 index 0000000000000000000000000000000000000000..d49413cf914cdbd2aa16916a38a6153f385c509e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/less_equal.py @@ -0,0 +1,68 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Less(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "LessOrEqual", + inputs=["x", "y"], + outputs=["less_equal"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal") + + x = np.random.randn(3, 4, 5).astype(np.int8) + y = np.random.randn(3, 4, 5).astype(np.int8) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int8") + + x = np.random.randn(3, 4, 5).astype(np.int16) + y = np.random.randn(3, 4, 5).astype(np.int16) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint8") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint16") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint32") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint64") + + @staticmethod + def export_less_broadcast() -> None: + node = onnx.helper.make_node( + "LessOrEqual", + inputs=["x", "y"], + outputs=["less_equal"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_bcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/linear_attention.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/linear_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..2564b0cf8f65f6844d3953e4bdb108fa2db5571e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/linear_attention.py @@ -0,0 +1,541 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_linear_attention import ( + LinearAttention as _RefLinearAttention, +) + +_OPSET = [onnx.helper.make_opsetid("", 27)] + + +def _compute( + query, + key, + value, + past_state=None, + decay=None, + beta=None, + *, + q_num_heads, + kv_num_heads, + update_rule="gated_delta", + scale=0.0, + chunk_size=64, +): + op = _RefLinearAttention.__new__(_RefLinearAttention) + return op._run( + query, + key, + value, + past_state, + decay, + beta, + chunk_size=chunk_size, + kv_num_heads=kv_num_heads, + q_num_heads=q_num_heads, + scale=scale, + update_rule=update_rule, + ) + + +def _l2_normalize(x: np.ndarray, num_heads: int) -> np.ndarray: + """L2-normalize key along the per-head feature dim. Required for delta rules.""" + b, t, hd = x.shape + d = hd // num_heads + x4 = x.reshape(b, t, num_heads, d) + norm = np.linalg.norm(x4, axis=-1, keepdims=True) + x4 = x4 / np.maximum(norm, 1e-6) + return x4.reshape(b, t, hd).astype(x.dtype) + + +class LinearAttention(Base): + # ------------------------------------------------------------------ + # Update-rule axis (B=2, T=4, H_q=H_kv=4, d_k=d_v=8) + # ------------------------------------------------------------------ + @staticmethod + def export_linear() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value"], + outputs=["output", "present_state"], + update_rule="linear", + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = np.random.randn(b, t, h_kv * d_k).astype(np.float32) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + q_num_heads=h_q, + kv_num_heads=h_kv, + update_rule="linear", + ) + expect( + node, + inputs=[query, key, value], + outputs=[output, present_state], + name="test_linear_attention_linear", + opset_imports=_OPSET, + ) + + @staticmethod + def export_gated() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "decay"], + outputs=["output", "present_state"], + update_rule="gated", + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = np.random.randn(b, t, h_kv * d_k).astype(np.float32) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + # Per-key-dim decay in log-space (negative -> decay). + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + + output, present_state = _compute( + query, + key, + value, + decay=decay, + q_num_heads=h_q, + kv_num_heads=h_kv, + update_rule="gated", + ) + expect( + node, + inputs=[query, key, value, decay], + outputs=[output, present_state], + name="test_linear_attention_gated", + opset_imports=_OPSET, + ) + + @staticmethod + def export_gated_per_head_decay() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "decay"], + outputs=["output", "present_state"], + update_rule="gated", + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = np.random.randn(b, t, h_kv * d_k).astype(np.float32) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + # Per-head scalar decay. + decay = -np.abs(np.random.randn(b, t, h_kv)).astype(np.float32) * 0.1 + + output, present_state = _compute( + query, + key, + value, + decay=decay, + q_num_heads=h_q, + kv_num_heads=h_kv, + update_rule="gated", + ) + expect( + node, + inputs=[query, key, value, decay], + outputs=[output, present_state], + name="test_linear_attention_gated_per_head_decay", + opset_imports=_OPSET, + ) + + @staticmethod + def export_delta() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "", "beta"], + outputs=["output", "present_state"], + update_rule="delta", + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + beta = np.random.rand(b, t, h_kv).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + update_rule="delta", + ) + expect( + node, + inputs=[query, key, value, beta], + outputs=[output, present_state], + name="test_linear_attention_delta", + opset_imports=_OPSET, + ) + + @staticmethod + def export_gated_delta() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + beta = np.random.rand(b, t, h_kv).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + ) + expect( + node, + inputs=[query, key, value, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_gated_delta", + opset_imports=_OPSET, + ) + + @staticmethod + def export_gated_delta_beta_scalar() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + beta = np.random.rand(b, t, 1).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + ) + expect( + node, + inputs=[query, key, value, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_gated_delta_beta_scalar", + opset_imports=_OPSET, + ) + + # ------------------------------------------------------------------ + # GQA / MQA axis + # ------------------------------------------------------------------ + @staticmethod + def export_gated_delta_gqa() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=8, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + beta = np.random.rand(b, t, h_kv).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + ) + expect( + node, + inputs=[query, key, value, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_gated_delta_gqa", + opset_imports=_OPSET, + ) + + @staticmethod + def export_gated_delta_mqa() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=8, + kv_num_heads=1, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 1, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + beta = np.random.rand(b, t, h_kv).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + ) + expect( + node, + inputs=[query, key, value, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_gated_delta_mqa", + opset_imports=_OPSET, + ) + + # ------------------------------------------------------------------ + # Decoding / past_state axis + # ------------------------------------------------------------------ + @staticmethod + def export_decode_step() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "past_state", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 1, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + past_state = np.random.randn(b, h_kv, d_k, d_v).astype(np.float32) * 0.1 + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + beta = np.random.rand(b, t, h_kv).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + past_state=past_state, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + ) + expect( + node, + inputs=[query, key, value, past_state, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_decode_step", + opset_imports=_OPSET, + ) + + @staticmethod + def export_prefill_with_past() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "past_state", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + past_state = np.random.randn(b, h_kv, d_k, d_v).astype(np.float32) * 0.1 + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + beta = np.random.rand(b, t, h_kv).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + past_state=past_state, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + ) + expect( + node, + inputs=[query, key, value, past_state, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_prefill_with_past", + opset_imports=_OPSET, + ) + + @staticmethod + def export_no_past_explicit_zeros() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "past_state", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + past_state = np.zeros((b, h_kv, d_k, d_v), dtype=np.float32) + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + beta = np.random.rand(b, t, h_kv).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + past_state=past_state, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + ) + expect( + node, + inputs=[query, key, value, past_state, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_no_past_explicit_zeros", + opset_imports=_OPSET, + ) + + # ------------------------------------------------------------------ + # Scale & dtype axis + # ------------------------------------------------------------------ + @staticmethod + def export_explicit_scale() -> None: + scale = 0.25 + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=4, + kv_num_heads=4, + scale=scale, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1 + beta = np.random.rand(b, t, h_kv).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + scale=scale, + ) + expect( + node, + inputs=[query, key, value, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_explicit_scale", + opset_imports=_OPSET, + ) + + @staticmethod + def export_fp16() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value", "", "decay", "beta"], + outputs=["output", "present_state"], + q_num_heads=8, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float16) + key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float16), h_kv) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float16) + decay = (-np.abs(np.random.randn(b, t, h_kv * d_k)) * 0.1).astype(np.float16) + beta = np.random.rand(b, t, h_kv).astype(np.float16) + + output, present_state = _compute( + query, + key, + value, + decay=decay, + beta=beta, + q_num_heads=h_q, + kv_num_heads=h_kv, + ) + expect( + node, + inputs=[query, key, value, decay, beta], + outputs=[output, present_state], + name="test_linear_attention_fp16", + opset_imports=_OPSET, + ) + + # ------------------------------------------------------------------ + # Edge cases + # ------------------------------------------------------------------ + @staticmethod + def export_linear_t1_no_past() -> None: + node = onnx.helper.make_node( + "LinearAttention", + inputs=["query", "key", "value"], + outputs=["output", "present_state"], + update_rule="linear", + q_num_heads=4, + kv_num_heads=4, + ) + b, t, h_q, h_kv, d_k, d_v = 2, 1, 4, 4, 8, 8 + query = np.random.randn(b, t, h_q * d_k).astype(np.float32) + key = np.random.randn(b, t, h_kv * d_k).astype(np.float32) + value = np.random.randn(b, t, h_kv * d_v).astype(np.float32) + + output, present_state = _compute( + query, + key, + value, + q_num_heads=h_q, + kv_num_heads=h_kv, + update_rule="linear", + ) + expect( + node, + inputs=[query, key, value], + outputs=[output, present_state], + name="test_linear_attention_linear_t1_no_past", + opset_imports=_OPSET, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/log.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/log.py new file mode 100644 index 0000000000000000000000000000000000000000..62ac4daad06983fc28d34ee07748aa2f0668f3bb --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/log.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Log(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Log", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([1, 10]).astype(np.float32) + y = np.log(x) # expected output [0., 2.30258512] + expect(node, inputs=[x], outputs=[y], name="test_log_example") + + x = np.exp(np.random.randn(3, 4, 5).astype(np.float32)) + y = np.log(x) + expect(node, inputs=[x], outputs=[y], name="test_log") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/logsoftmax.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/logsoftmax.py new file mode 100644 index 0000000000000000000000000000000000000000..96ed103e5a0527667e19c9636d711a1c30653ea8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/logsoftmax.py @@ -0,0 +1,92 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def logsoftmax(x: np.ndarray, axis: int = -1) -> np.ndarray: + x_max = np.max(x, axis=axis, keepdims=True) + tmp = np.exp(x - x_max) + s = np.sum(tmp, axis=axis, keepdims=True) + return (x - x_max) - np.log(s) + + +class LogSoftmax(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + ) + x = np.array([[-1, 0, 1]]).astype(np.float32) + # expected output + # [[-2.4076061 -1.407606 -0.407606 ]] + y = logsoftmax(x) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_example_1") + + @staticmethod + def export_logsoftmax_axis() -> None: + x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32) + # expected output + # [[-3.4401896 -2.4401896 -1.4401896 -0.44018966] + # [-3.4401896 -2.4401896 -1.4401896 -0.44018966]] + y = logsoftmax(x) + + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + ) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_large_number") + + x = np.abs(np.random.randn(3, 4, 5).astype(np.float32)) + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + axis=0, + ) + y = logsoftmax(x, axis=0) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_0") + + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + axis=1, + ) + y = logsoftmax(x, axis=1) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_1") + + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + axis=2, + ) + y = logsoftmax(x, axis=2) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_2") + + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + axis=-1, + ) + y = logsoftmax(x, axis=-1) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_negative_axis") + + # default axis is -1 + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + ) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_default_axis") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/loop.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/loop.py new file mode 100644 index 0000000000000000000000000000000000000000..7de826d9b1698b4350719b8010c6cc1c33594ebf --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/loop.py @@ -0,0 +1,459 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def compute_loop_outputs(x, seq, trip_count): + for i in range(trip_count): + if seq is None: + seq = [] + seq += [x[: int(i + 1)]] + return seq + + +class Loop(Base): + @staticmethod + def export_loop_11() -> None: + # Given a tensor x of values [x1, ..., xN], and initial tensor y + # sum up its elements using a scan + # returning the final state (y+x1+x2+...+xN) as well the scan_output + # [y+x1, y+x1+x2, ..., y+x1+x2+...+xN] + + y_in = onnx.helper.make_tensor_value_info("y_in", onnx.TensorProto.FLOAT, [1]) + y_out = onnx.helper.make_tensor_value_info("y_out", onnx.TensorProto.FLOAT, [1]) + scan_out = onnx.helper.make_tensor_value_info( + "scan_out", onnx.TensorProto.FLOAT, [1] + ) + cond_in = onnx.helper.make_tensor_value_info( + "cond_in", onnx.TensorProto.BOOL, [] + ) + cond_out = onnx.helper.make_tensor_value_info( + "cond_out", onnx.TensorProto.BOOL, [] + ) + iter_count = onnx.helper.make_tensor_value_info( + "iter_count", onnx.TensorProto.INT64, [] + ) + + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + y = np.array([-2]).astype(np.float32) + + x_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.helper.make_tensor( + name="const_tensor_x", + data_type=onnx.TensorProto.FLOAT, + dims=x.shape, + vals=x.flatten().astype(float), + ), + ) + + one_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["one"], + value=onnx.helper.make_tensor( + name="const_tensor_one", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[1], + ), + ) + + i_add_node = onnx.helper.make_node( + "Add", inputs=["iter_count", "one"], outputs=["end"] + ) + + start_unsqueeze_node = onnx.helper.make_node( + "Unsqueeze", inputs=["iter_count"], outputs=["slice_start"], axes=[0] + ) + + end_unsqueeze_node = onnx.helper.make_node( + "Unsqueeze", inputs=["end"], outputs=["slice_end"], axes=[0] + ) + + slice_node = onnx.helper.make_node( + "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"] + ) + + y_add_node = onnx.helper.make_node( + "Add", inputs=["y_in", "slice_out"], outputs=["y_out"] + ) + + identity_node = onnx.helper.make_node( + "Identity", inputs=["cond_in"], outputs=["cond_out"] + ) + + scan_identity_node = onnx.helper.make_node( + "Identity", inputs=["y_out"], outputs=["scan_out"] + ) + + loop_body = onnx.helper.make_graph( + [ + identity_node, + x_const_node, + one_const_node, + i_add_node, + start_unsqueeze_node, + end_unsqueeze_node, + slice_node, + y_add_node, + scan_identity_node, + ], + "loop_body", + [iter_count, cond_in, y_in], + [cond_out, y_out, scan_out], + ) + + node = onnx.helper.make_node( + "Loop", + inputs=["trip_count", "cond", "y"], + outputs=["res_y", "res_scan"], + body=loop_body, + ) + + trip_count = np.array(5).astype(np.int64) + res_y = np.array([13]).astype(np.float32) + cond = np.array(1).astype(bool) + res_scan = np.array([-1, 1, 4, 8, 13]).astype(np.float32).reshape((5, 1)) + expect( + node, + inputs=[trip_count, cond, y], + outputs=[res_y, res_scan], + name="test_loop11", + opset_imports=[onnx.helper.make_opsetid("", 11)], + ) + + @staticmethod + def export_loop_13() -> None: + # Given a tensor x of values [x1, ..., xN], + # Return a sequence of tensors of + # [[x1], [x1, x2], ..., [x1, ..., xN]] + + seq_in = onnx.helper.make_tensor_sequence_value_info( + "seq_in", onnx.TensorProto.FLOAT, None + ) + seq_out = onnx.helper.make_tensor_sequence_value_info( + "seq_out", onnx.TensorProto.FLOAT, None + ) + cond_in = onnx.helper.make_tensor_value_info( + "cond_in", onnx.TensorProto.BOOL, [] + ) + cond_out = onnx.helper.make_tensor_value_info( + "cond_out", onnx.TensorProto.BOOL, [] + ) + iter_count = onnx.helper.make_tensor_value_info( + "iter_count", onnx.TensorProto.INT64, [] + ) + + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + + x_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.helper.make_tensor( + name="const_tensor_x", + data_type=onnx.TensorProto.FLOAT, + dims=x.shape, + vals=x.flatten().astype(float), + ), + ) + + one_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["one"], + value=onnx.helper.make_tensor( + name="const_tensor_one", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[1], + ), + ) + + zero_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["slice_start"], + value=onnx.helper.make_tensor( + name="const_tensor_zero", + data_type=onnx.TensorProto.INT64, + dims=(1,), + vals=[0], + ), + ) + + axes_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["axes"], + value=onnx.helper.make_tensor( + name="const_tensor_axes", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[0], + ), + ) + + add_node = onnx.helper.make_node( + "Add", inputs=["iter_count", "one"], outputs=["end"] + ) + + end_unsqueeze_node = onnx.helper.make_node( + "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"] + ) + + slice_node = onnx.helper.make_node( + "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"] + ) + + insert_node = onnx.helper.make_node( + "SequenceInsert", inputs=["seq_in", "slice_out"], outputs=["seq_out"] + ) + + identity_node = onnx.helper.make_node( + "Identity", inputs=["cond_in"], outputs=["cond_out"] + ) + + loop_body = onnx.helper.make_graph( + [ + identity_node, + x_const_node, + one_const_node, + zero_const_node, + add_node, + axes_node, + end_unsqueeze_node, + slice_node, + insert_node, + ], + "loop_body", + [iter_count, cond_in, seq_in], + [cond_out, seq_out], + ) + + node = onnx.helper.make_node( + "Loop", + inputs=["trip_count", "cond", "seq_empty"], + outputs=["seq_res"], + body=loop_body, + ) + + trip_count = np.array(5).astype(np.int64) + seq_empty: list[Any] = [] + seq_res = [x[: int(i)] for i in x] + cond = np.array(1).astype(bool) + expect( + node, + inputs=[trip_count, cond, seq_empty], + outputs=[seq_res], + name="test_loop13_seq", + opset_imports=[onnx.helper.make_opsetid("", 13)], + input_type_protos=[ + onnx.helper.make_tensor_type_proto( + onnx.TensorProto.INT64, trip_count.shape + ), + onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape), + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, []) + ), + ], + ) + + @staticmethod + def export_loop_16_none() -> None: + # Given a tensor sequence of values [x1, ..., xN], and an initial optional sequence of tensors [x0], + # Return a concatenated sequence of tensors of + # [x0, [x1], [x1, x2], ..., [x1, ..., xN]] + + ten_in_tp = onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, []) + seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp) + opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp) + opt_in = onnx.helper.make_value_info("opt_seq_in", opt_in_tp) + seq_out = onnx.helper.make_tensor_sequence_value_info( + "seq_out", onnx.TensorProto.FLOAT, [] + ) + cond_in = onnx.helper.make_tensor_value_info( + "cond_in", onnx.TensorProto.BOOL, [] + ) + cond_out = onnx.helper.make_tensor_value_info( + "cond_out", onnx.TensorProto.BOOL, [] + ) + iter_count = onnx.helper.make_tensor_value_info( + "iter_count", onnx.TensorProto.INT64, [] + ) + + x0 = np.array(0).astype(np.float32) + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + + optional_has_elem_node = onnx.helper.make_node( + "OptionalHasElement", inputs=["opt_seq_in"], outputs=["optional_has_elem"] + ) + + optional_is_none = onnx.helper.make_node( + "Not", inputs=["optional_has_elem"], outputs=["optional_is_none"] + ) + + optional_get_elem = onnx.helper.make_node( + "OptionalGetElement", inputs=["opt_seq_in"], outputs=["seq_in"] + ) + + constant_in = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["constant_in"], + value=onnx.helper.make_tensor( + name="const_tensor", data_type=onnx.TensorProto.FLOAT, dims=(), vals=[0] + ), + ) + + seq_const_in = onnx.helper.make_node( + "SequenceConstruct", inputs=["constant_in"], outputs=["init_seq_in"] + ) + + then_seq_out = onnx.helper.make_tensor_sequence_value_info( + "init_seq_in", onnx.TensorProto.FLOAT, [] + ) + then_body = onnx.helper.make_graph( + [constant_in, seq_const_in], "then_body", [], [then_seq_out] + ) + + else_seq_out = onnx.helper.make_tensor_sequence_value_info( + "seq_in", onnx.TensorProto.FLOAT, [] + ) + else_body = onnx.helper.make_graph( + [optional_get_elem], "else_body", [], [else_seq_out] + ) + + if_node = onnx.helper.make_node( + "If", + inputs=["optional_is_none"], + outputs=["sequence"], + then_branch=then_body, + else_branch=else_body, + ) + + x_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.helper.make_tensor( + name="const_tensor_x", + data_type=onnx.TensorProto.FLOAT, + dims=x.shape, + vals=x.flatten().astype(float), + ), + ) + + one_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["one"], + value=onnx.helper.make_tensor( + name="const_tensor_one", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[1], + ), + ) + + zero_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["slice_start"], + value=onnx.helper.make_tensor( + name="const_tensor_zero", + data_type=onnx.TensorProto.INT64, + dims=(1,), + vals=[0], + ), + ) + + axes_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["axes"], + value=onnx.helper.make_tensor( + name="const_tensor_axes", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[0], + ), + ) + + add_node = onnx.helper.make_node( + "Add", inputs=["iter_count", "one"], outputs=["end"] + ) + + end_unsqueeze_node = onnx.helper.make_node( + "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"] + ) + + slice_node = onnx.helper.make_node( + "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"] + ) + + insert_node = onnx.helper.make_node( + "SequenceInsert", inputs=["sequence", "slice_out"], outputs=["seq_out"] + ) + + identity_node = onnx.helper.make_node( + "Identity", inputs=["cond_in"], outputs=["cond_out"] + ) + + loop_body = onnx.helper.make_graph( + [ + identity_node, + optional_has_elem_node, + optional_is_none, + if_node, + x_const_node, + one_const_node, + zero_const_node, + add_node, + axes_node, + end_unsqueeze_node, + slice_node, + insert_node, + ], + "loop_body", + [iter_count, cond_in, opt_in], + [cond_out, seq_out], + ) + + node = onnx.helper.make_node( + "Loop", + inputs=["trip_count", "cond", "opt_seq"], + outputs=["seq_res"], + body=loop_body, + ) + + trip_count = np.array(5).astype(np.int64) + cond = np.array(1).astype(bool) + seq_res = compute_loop_outputs(x, [x0], trip_count) + opt_seq_in: list[Any] = [x0] + expect( + node, + inputs=[trip_count, cond, opt_seq_in], + outputs=[seq_res], + name="test_loop16_seq_none", + opset_imports=[onnx.helper.make_opsetid("", 16)], + input_type_protos=[ + onnx.helper.make_tensor_type_proto( + onnx.TensorProto.INT64, trip_count.shape + ), + onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape), + opt_in_tp, + ], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lpnormalization.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lpnormalization.py new file mode 100644 index 0000000000000000000000000000000000000000..d258e57dee7b52d9b2710a3348320014f71444aa --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lpnormalization.py @@ -0,0 +1,80 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class LpNormalization(Base): + @staticmethod + def export_l2normalization_axis_0() -> None: + node = onnx.helper.make_node( + "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=2 + ) + x = np.array( + [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]], + dtype=np.float32, + ) + l2_norm_axis_0 = np.sqrt(np.sum(x**2, axis=0, keepdims=True)) + # When norm is 0, output is 0 (0/0 = 0) + y = np.where(l2_norm_axis_0 == 0, 0, x / l2_norm_axis_0) + expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_0") + + @staticmethod + def export_l2normalization_axis_1() -> None: + node = onnx.helper.make_node( + "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=2 + ) + x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32) + l2_norm_axis_1 = np.sqrt(np.sum(x**2, axis=1, keepdims=True)) + y = x / l2_norm_axis_1 + expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_1") + + @staticmethod + def export_l1normalization_axis_0() -> None: + node = onnx.helper.make_node( + "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=1 + ) + x = np.array([3.0, 4.0], dtype=np.float32) + l1_norm_axis_0 = np.sum(abs(x), axis=0, keepdims=True) + y = x / l1_norm_axis_0 + expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_0") + + @staticmethod + def export_l1normalization_axis_1() -> None: + node = onnx.helper.make_node( + "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=1 + ) + x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32) + l1_norm_axis_1 = np.sum(abs(x), axis=1, keepdims=True) + y = x / l1_norm_axis_1 + expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_1") + + @staticmethod + def export_l1normalization_axis_last() -> None: + node = onnx.helper.make_node( + "LpNormalization", inputs=["x"], outputs=["y"], axis=-1, p=1 + ) + x = np.array( + [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]], + dtype=np.float32, + ) + l1_norm_axis_last = np.sum(abs(x), axis=-1, keepdims=True) + y = x / l1_norm_axis_last + expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_last") + + @staticmethod + def export_default() -> None: + node = onnx.helper.make_node("LpNormalization", inputs=["x"], outputs=["y"]) + x = np.array( + [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]], + dtype=np.float32, + ) + lp_norm_default = np.sqrt(np.sum(x**2, axis=-1, keepdims=True)) + y = x / lp_norm_default + expect(node, inputs=[x], outputs=[y], name="test_lpnormalization_default") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lppool.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lppool.py new file mode 100644 index 0000000000000000000000000000000000000000..9f4182833c5a88c74c1f2ca2ce34f58d2a9a3048 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lppool.py @@ -0,0 +1,298 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_pool_common import ( + get_output_shape_auto_pad, + get_output_shape_explicit_padding, + get_pad_shape, + pool, +) + + +class LpPool(Base): + @staticmethod + def export_lppool_1d_default() -> None: + """input_shape: [1, 3, 32] + output_shape: [1, 3, 31] + """ + p = 3 + kernel_shape = [2] + strides = [1] + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=kernel_shape, + strides=strides, + p=p, + ) + x = np.random.randn(1, 3, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_1d_default") + + @staticmethod + def export_lppool_2d_default() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 31, 31] + """ + p = 4 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + p=p, + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = (2, 2) + strides = (1, 1) + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_default") + + @staticmethod + def export_lppool_3d_default() -> None: + """input_shape: [1, 3, 32, 32, 32] + output_shape: [1, 3, 31, 31, 31] + """ + p = 3 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + p=p, + ) + x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = [2, 2, 2] + strides = [1, 1, 1] + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_3d_default") + + @staticmethod + def export_lppool_2d_same_upper() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [0, 1, 0, 1] by axis + """ + p = 2 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_UPPER", + p=p, + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape_auto_pad( + "SAME_UPPER", x_shape[2:], kernel_shape, strides + ) + pad_shape = get_pad_shape( + "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_top = pad_shape[0] // 2 + pad_bottom = pad_shape[0] - pad_top + pad_left = pad_shape[1] // 2 + pad_right = pad_shape[1] - pad_left + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=0, + ) + pads = [pad_top, pad_left, pad_bottom, pad_right] + y = pool( + padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_upper") + + @staticmethod + def export_lppool_2d_same_lower() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [1, 0, 1, 0] by axis + """ + p = 4 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_LOWER", + p=p, + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape_auto_pad( + "SAME_LOWER", x_shape[2:], kernel_shape, strides + ) + pad_shape = get_pad_shape( + "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_bottom = pad_shape[0] // 2 + pad_top = pad_shape[0] - pad_bottom + pad_right = pad_shape[1] // 2 + pad_left = pad_shape[1] - pad_right + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=0, + ) + pads = [pad_top, pad_left, pad_bottom, pad_right] + y = pool( + padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_lower") + + @staticmethod + def export_lppool_2d_pads() -> None: + """input_shape: [1, 3, 28, 28] + output_shape: [1, 3, 30, 30] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + p = 3 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[2, 2, 2, 2], + p=p, + ) + x = np.random.randn(1, 3, 28, 28).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (3, 3) + strides = (1, 1) + pad_bottom = pad_top = pad_right = pad_left = 2 + pads = [pad_top, pad_left, pad_bottom, pad_right] + out_shape, extra_pads = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = np.pad( + x, + ( + (0, 0), + (0, 0), + (extra_pads[0], extra_pads[2]), + (extra_pads[1], extra_pads[3]), + ), + mode="constant", + constant_values=0, + ) + y = pool( + padded, + x_shape, + kernel_shape, + strides, + out_shape, + "LPPOOL", + pads_required=extra_pads, + pads=pads, + p=p, + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_pads") + + @staticmethod + def export_lppool_2d_strides() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 10, 10] + """ + p = 2 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + strides=[3, 3], + p=p, + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = (5, 5) + strides = (3, 3) + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_strides") + + @staticmethod + def export_lppool_2d_dilations() -> None: + """input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + p = 2 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[1, 1], + dilations=[2, 2], + p=p, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + + y = np.array( + [ + [ + [ + [14.560219778561036, 16.24807680927192], + [21.633307652783937, 23.49468024894146], + ] + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_dilations") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lrn.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lrn.py new file mode 100644 index 0000000000000000000000000000000000000000..05244c1001d1430ac17141597244c48a8abe5796 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lrn.py @@ -0,0 +1,70 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import math + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class LRN(Base): + @staticmethod + def export() -> None: + alpha = 0.0002 + beta = 0.5 + bias = 2.0 + nsize = 3 + node = onnx.helper.make_node( + "LRN", + inputs=["x"], + outputs=["y"], + alpha=alpha, + beta=beta, + bias=bias, + size=nsize, + ) + x = np.random.randn(5, 5, 5, 5).astype(np.float32) + square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32) + for n, c, h, w in np.ndindex(x.shape): + square_sum[n, c, h, w] = sum( + x[ + n, + max(0, c - math.floor((nsize - 1) / 2)) : min( + 5, c + math.ceil((nsize - 1) / 2) + 1 + ), + h, + w, + ] + ** 2 + ) + y = x / ((bias + (alpha / nsize) * square_sum) ** beta) + expect(node, inputs=[x], outputs=[y], name="test_lrn") + + @staticmethod + def export_default() -> None: + alpha = 0.0001 + beta = 0.75 + bias = 1.0 + nsize = 3 + node = onnx.helper.make_node("LRN", inputs=["x"], outputs=["y"], size=3) + x = np.random.randn(5, 5, 5, 5).astype(np.float32) + square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32) + for n, c, h, w in np.ndindex(x.shape): + square_sum[n, c, h, w] = sum( + x[ + n, + max(0, c - math.floor((nsize - 1) / 2)) : min( + 5, c + math.ceil((nsize - 1) / 2) + 1 + ), + h, + w, + ] + ** 2 + ) + y = x / ((bias + (alpha / nsize) * square_sum) ** beta) + expect(node, inputs=[x], outputs=[y], name="test_lrn_default") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lstm.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lstm.py new file mode 100644 index 0000000000000000000000000000000000000000..02132753fce6581b1be6dee58ebc9c4509b0c798 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/lstm.py @@ -0,0 +1,278 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class LSTMHelper: + def __init__(self, **params: Any) -> None: + # LSTM Input Names + X = "X" + W = "W" + R = "R" + B = "B" + H_0 = "initial_h" + C_0 = "initial_c" + P = "P" + LAYOUT = "layout" + number_of_gates = 4 + number_of_peepholes = 3 + + required_inputs = [X, W, R] + for i in required_inputs: + assert i in params, f"Missing Required Input: {i}" + + self.num_directions = params[W].shape[0] + + if self.num_directions == 1: + for k, v in params.items(): + if k != X: + params[k] = np.squeeze(v, axis=0) + + hidden_size = params[R].shape[-1] + batch_size = params[X].shape[1] + + layout = params.get(LAYOUT, 0) + x = params[X] + x = x if layout == 0 else np.swapaxes(x, 0, 1) + b = ( + params[B] + if B in params + else np.zeros(2 * number_of_gates * hidden_size, dtype=np.float32) + ) + p = ( + params[P] + if P in params + else np.zeros(number_of_peepholes * hidden_size, dtype=np.float32) + ) + h_0 = ( + params[H_0] + if H_0 in params + else np.zeros((batch_size, hidden_size), dtype=np.float32) + ) + c_0 = ( + params[C_0] + if C_0 in params + else np.zeros((batch_size, hidden_size), dtype=np.float32) + ) + + self.X = x + self.W = params[W] + self.R = params[R] + self.B = b + self.P = p + self.H_0 = h_0 + self.C_0 = c_0 + self.LAYOUT = layout + + else: + raise NotImplementedError + + def f(self, x: np.ndarray) -> np.ndarray: + return 1 / (1 + np.exp(-x)) + + def g(self, x: np.ndarray) -> np.ndarray: + return np.tanh(x) + + def h(self, x: np.ndarray) -> np.ndarray: + return np.tanh(x) + + def step(self) -> tuple[np.ndarray, np.ndarray]: + seq_length = self.X.shape[0] + hidden_size = self.H_0.shape[-1] + batch_size = self.X.shape[1] + + Y = np.empty([seq_length, self.num_directions, batch_size, hidden_size]) + h_list = [] + + [p_i, p_o, p_f] = np.split(self.P, 3) + H_t = self.H_0 + C_t = self.C_0 + for x in np.split(self.X, self.X.shape[0], axis=0): + gates = ( + np.dot(x, np.transpose(self.W)) + + np.dot(H_t, np.transpose(self.R)) + + np.add(*np.split(self.B, 2)) + ) + i, o, f, c = np.split(gates, 4, -1) + i = self.f(i + p_i * C_t) + f = self.f(f + p_f * C_t) + c = self.g(c) + C = f * C_t + i * c + o = self.f(o + p_o * C) + H = o * self.h(C) + h_list.append(H) + H_t = H + C_t = C + + concatenated = np.concatenate(h_list) + if self.num_directions == 1: + Y[:, 0, :, :] = concatenated + + if self.LAYOUT == 0: + Y_h = Y[-1] + else: + Y = np.transpose(Y, [2, 0, 1, 3]) + Y_h = Y[:, :, -1, :] + + return Y, Y_h + + +class LSTM(Base): + @staticmethod + def export_defaults() -> None: + input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 3 + weight_scale = 0.1 + number_of_gates = 4 + + node = onnx.helper.make_node( + "LSTM", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + lstm = LSTMHelper(X=input, W=W, R=R) + _, Y_h = lstm.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y_h.astype(np.float32)], + name="test_lstm_defaults", + ) + + @staticmethod + def export_initial_bias() -> None: + input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype( + np.float32 + ) + + input_size = 3 + hidden_size = 4 + weight_scale = 0.1 + custom_bias = 0.1 + number_of_gates = 4 + + node = onnx.helper.make_node( + "LSTM", + inputs=["X", "W", "R", "B"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + # Adding custom bias + W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype( + np.float32 + ) + R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32) + B = np.concatenate((W_B, R_B), 1) + + lstm = LSTMHelper(X=input, W=W, R=R, B=B) + _, Y_h = lstm.step() + expect( + node, + inputs=[input, W, R, B], + outputs=[Y_h.astype(np.float32)], + name="test_lstm_with_initial_bias", + ) + + @staticmethod + def export_peepholes() -> None: + input = np.array([[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]]]).astype( + np.float32 + ) + + input_size = 4 + hidden_size = 3 + weight_scale = 0.1 + number_of_gates = 4 + number_of_peepholes = 3 + + node = onnx.helper.make_node( + "LSTM", + inputs=["X", "W", "R", "B", "sequence_lens", "initial_h", "initial_c", "P"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + # Initializing Inputs + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + B = np.zeros((1, 2 * number_of_gates * hidden_size)).astype(np.float32) + seq_lens = np.repeat(input.shape[0], input.shape[1]).astype(np.int32) + init_h = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32) + init_c = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32) + P = weight_scale * np.ones((1, number_of_peepholes * hidden_size)).astype( + np.float32 + ) + + lstm = LSTMHelper( + X=input, W=W, R=R, B=B, P=P, initial_c=init_c, initial_h=init_h + ) + _, Y_h = lstm.step() + expect( + node, + inputs=[input, W, R, B, seq_lens, init_h, init_c, P], + outputs=[Y_h.astype(np.float32)], + name="test_lstm_with_peepholes", + ) + + @staticmethod + def export_batchwise() -> None: + input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 7 + weight_scale = 0.3 + number_of_gates = 4 + layout = 1 + + node = onnx.helper.make_node( + "LSTM", + inputs=["X", "W", "R"], + outputs=["Y", "Y_h"], + hidden_size=hidden_size, + layout=layout, + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + lstm = LSTMHelper(X=input, W=W, R=R, layout=layout) + Y, Y_h = lstm.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y.astype(np.float32), Y_h.astype(np.float32)], + name="test_lstm_batchwise", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/matmul.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/matmul.py new file mode 100644 index 0000000000000000000000000000000000000000..3a8aeaa3ce53fbd80404c86000008b769044a4a2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/matmul.py @@ -0,0 +1,62 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MatMul(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "MatMul", + inputs=["a", "b"], + outputs=["c"], + ) + + # 2d + a = np.random.randn(3, 4).astype(np.float32) + b = np.random.randn(4, 3).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_2d") + + # 3d + a = np.random.randn(2, 3, 4).astype(np.float32) + b = np.random.randn(2, 4, 3).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_3d") + + # 4d + a = np.random.randn(1, 2, 3, 4).astype(np.float32) + b = np.random.randn(1, 2, 4, 3).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d") + + # broadcasting + a = np.random.randn(3, 1, 3, 4).astype(np.float32) + b = np.random.randn(1, 2, 4, 2).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_bcast") + + # 1d + 3d + a = np.random.randn(4).astype(np.float32) + b = np.random.randn(2, 4, 1).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_1d_3d") + + # 3d + 1d + a = np.random.randn(1, 2, 4, 3).astype(np.float32) + b = np.random.randn(3).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d_1d") + + # 1d + 1d + a = np.random.randn(3).astype(np.float32) + b = np.random.randn(3).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_1d_1d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/matmulinteger.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/matmulinteger.py new file mode 100644 index 0000000000000000000000000000000000000000..4df5633f29d167baffaefb8689faeba65015c752 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/matmulinteger.py @@ -0,0 +1,60 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MatMulInteger(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "MatMulInteger", + inputs=["A", "B", "a_zero_point", "b_zero_point"], + outputs=["Y"], + ) + + A = np.array( + [ + [11, 7, 3], + [10, 6, 2], + [9, 5, 1], + [8, 4, 0], + ], + dtype=np.uint8, + ) + + a_zero_point = np.array([12], dtype=np.uint8) + + B = np.array( + [ + [1, 4], + [2, 5], + [3, 6], + ], + dtype=np.uint8, + ) + + b_zero_point = np.array([0], dtype=np.uint8) + + output = np.array( + [ + [-38, -83], + [-44, -98], + [-50, -113], + [-56, -128], + ], + dtype=np.int32, + ) + + expect( + node, + inputs=[A, B, a_zero_point, b_zero_point], + outputs=[output], + name="test_matmulinteger", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/max.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/max.py new file mode 100644 index 0000000000000000000000000000000000000000..139cfc84855074edc1360212eadf553e9f88a7f2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/max.py @@ -0,0 +1,66 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.backend.test.case.utils import all_numeric_dtypes + + +class Max(Base): + @staticmethod + def export() -> None: + data_0 = np.array([3, 2, 1]).astype(np.float32) + data_1 = np.array([1, 4, 4]).astype(np.float32) + data_2 = np.array([2, 5, 3]).astype(np.float32) + result = np.array([3, 5, 4]).astype(np.float32) + node = onnx.helper.make_node( + "Max", + inputs=["data_0", "data_1", "data_2"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1, data_2], + outputs=[result], + name="test_max_example", + ) + + node = onnx.helper.make_node( + "Max", + inputs=["data_0"], + outputs=["result"], + ) + expect(node, inputs=[data_0], outputs=[data_0], name="test_max_one_input") + + result = np.maximum(data_0, data_1) + node = onnx.helper.make_node( + "Max", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, inputs=[data_0, data_1], outputs=[result], name="test_max_two_inputs" + ) + + @staticmethod + def export_max_all_numeric_types() -> None: + for op_dtype in all_numeric_dtypes: + data_0 = np.array([3, 2, 1]).astype(op_dtype) + data_1 = np.array([1, 4, 4]).astype(op_dtype) + result = np.array([3, 4, 4]).astype(op_dtype) + node = onnx.helper.make_node( + "Max", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1], + outputs=[result], + name=f"test_max_{np.dtype(op_dtype).name}", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/maxpool.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/maxpool.py new file mode 100644 index 0000000000000000000000000000000000000000..c9f6b60f5ddbbe42a5a3c67793611f0a46ed6549 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/maxpool.py @@ -0,0 +1,725 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_pool_common import ( + get_output_shape_auto_pad, + get_output_shape_explicit_padding, + get_pad_shape, + pool, +) + + +class MaxPool(Base): + @staticmethod + def export_maxpool_2d_uint8() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.uint8) + y = np.array( + [ + [ + [ + [13, 14, 15, 15, 15], + [18, 19, 20, 20, 20], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + ] + ] + ] + ).astype(np.uint8) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_uint8") + + @staticmethod + def export_maxpool_2d_precomputed_pads() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array( + [ + [ + [ + [13, 14, 15, 15, 15], + [18, 19, 20, 20, 20], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + ] + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_pads") + + @staticmethod + def export_maxpool_with_argmax_2d_precomputed_pads() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y", "z"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array( + [ + [ + [ + [13, 14, 15, 15, 15], + [18, 19, 20, 20, 20], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + ] + ] + ] + ).astype(np.float32) + z = np.array( + [ + [ + [ + [12, 13, 14, 14, 14], + [17, 18, 19, 19, 19], + [22, 23, 24, 24, 24], + [22, 23, 24, 24, 24], + [22, 23, 24, 24, 24], + ] + ] + ] + ).astype(np.int64) + + expect( + node, + inputs=[x], + outputs=[y, z], + name="test_maxpool_with_argmax_2d_precomputed_pads", + ) + + @staticmethod + def export_maxpool_2d_precomputed_strides() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[2, 2], strides=[2, 2] + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32) + + expect( + node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_strides" + ) + + @staticmethod + def export_maxpool_with_argmax_2d_precomputed_strides() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y", "z"], + kernel_shape=[2, 2], + strides=[2, 2], + storage_order=1, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32) + z = np.array([[[[6, 16], [8, 18]]]]).astype(np.int64) + + expect( + node, + inputs=[x], + outputs=[y, z], + name="test_maxpool_with_argmax_2d_precomputed_strides", + ) + + @staticmethod + def export_maxpool_2d_precomputed_same_upper() -> None: + """input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 3, 3] + pad_shape: [2, 2] -> [1, 1, 1, 1] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[2, 2], + auto_pad="SAME_UPPER", + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[7, 9, 10], [17, 19, 20], [22, 24, 25]]]]).astype(np.float32) + + expect( + node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_same_upper" + ) + + @staticmethod + def export_maxpool_1d_default() -> None: + """input_shape: [1, 3, 32] + output_shape: [1, 3, 31] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2], + ) + x = np.random.randn(1, 3, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = [2] + strides = [1] + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_1d_default") + + @staticmethod + def export_maxpool_2d_default() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 31, 31] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = (2, 2) + strides = (1, 1) + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_default") + + @staticmethod + def export_maxpool_3d_default() -> None: + """input_shape: [1, 3, 32, 32, 32] + output_shape: [1, 3, 31, 31, 31] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + ) + x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = [2, 2, 2] + strides = [1, 1, 1] + out_shape, _ = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_default") + + @staticmethod + def export_maxpool_2d_same_upper() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [0, 1, 0, 1] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_UPPER", + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape_auto_pad( + "SAME_UPPER", x_shape[2:], kernel_shape, strides + ) + pad_shape = get_pad_shape( + "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_top = pad_shape[0] // 2 + pad_bottom = pad_shape[0] - pad_top + pad_left = pad_shape[1] // 2 + pad_right = pad_shape[1] - pad_left + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + pads = [pad_top, pad_left, pad_bottom, pad_right] + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_upper") + + @staticmethod + def export_maxpool_2d_same_lower() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [1, 0, 1, 0] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_LOWER", + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape_auto_pad( + "SAME_LOWER", x_shape[2:], kernel_shape, strides + ) + pad_shape = get_pad_shape( + "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_bottom = pad_shape[0] // 2 + pad_top = pad_shape[0] - pad_bottom + pad_right = pad_shape[1] // 2 + pad_left = pad_shape[1] - pad_right + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + pads = [pad_top, pad_left, pad_bottom, pad_right] + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_lower") + + @staticmethod + def export_maxpool_2d_pads() -> None: + """input_shape: [1, 3, 28, 28] + output_shape: [1, 3, 30, 30] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[2, 2, 2, 2], + ) + x = np.random.randn(1, 3, 28, 28).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (3, 3) + strides = (1, 1) + pad_bottom = pad_top = pad_right = pad_left = 2 + pads = [pad_top, pad_left, pad_bottom, pad_right] + out_shape, extra_pads = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + + y = pool( + padded, + x_shape, + kernel_shape, + strides, + out_shape, + "MAX", + pads_required=extra_pads, + pads=pads, + ) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_pads") + + @staticmethod + def export_maxpool_2d_strides() -> None: + """input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 10, 10] + """ + node = onnx.helper.make_node( + "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[5, 5], strides=[3, 3] + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + pads = None + kernel_shape = (5, 5) + strides = (3, 3) + out_shape, pads = get_output_shape_explicit_padding( + pads, x_shape[2:], kernel_shape, strides + ) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_strides") + + @staticmethod + def export_maxpool_2d_ceil() -> None: + """input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[2, 2], + ceil_mode=True, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_ceil") + + @staticmethod + def export_maxpool_2d_ceil_output_size_reduce_by_one() -> None: + """input_shape: [1, 1, 2, 2] + output_shape: [1, 1, 1, 1] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[1, 1], + strides=[2, 2], + ceil_mode=True, + ) + x = np.array([[[[1, 2], [3, 4]]]]).astype(np.float32) + y = np.array([[[[1]]]]).astype(np.float32) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_maxpool_2d_ceil_output_size_reduce_by_one", + ) + + @staticmethod + def export_maxpool_2d_dilations() -> None: + """input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[1, 1], + dilations=[2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_dilations") + + @staticmethod + def export_maxpool_3d_dilations() -> None: + """input_shape: [1, 1, 4, 4, 4] + output_shape: [1, 1, 2, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + strides=[1, 1, 1], + dilations=[2, 2, 2], + ) + x = np.array( + [ + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[[11, 12], [15, 16]], [[11, 12], [15, 16]]]]]).astype( + np.float32 + ) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_dilations") + + @staticmethod + def export_maxpool_3d_dilations_use_ref_impl() -> None: + """input_shape: [1, 1, 4, 4, 4] + output_shape: [1, 1, 2, 2, 2] + """ + dilations = [2, 2, 2] + kernel_shape = [2, 2, 2] + strides = [1, 1, 1] + ceil_mode = False + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + strides=[1, 1, 1], + dilations=dilations, + ) + x = np.array( + [ + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ], + ] + ] + ] + ).astype(np.float32) + + x_shape = x.shape[2:] + out_shape, pads = get_output_shape_explicit_padding( + None, x_shape, kernel_shape, strides, dilations, ceil_mode=ceil_mode + ) + padded = x + y = pool( + padded, + (1, 1, *x_shape), + kernel_shape, + strides, + out_shape, + "MAX", + pads_required=pads, + pads=None, + dilations=dilations, + ) + + expect( + node, inputs=[x], outputs=[y], name="test_maxpool_3d_dilations_use_ref_impl" + ) + + @staticmethod + def export_maxpool_3d_dilations_use_ref_impl_large() -> None: + x_shape = (32, 32, 32) + dilations = (2, 2, 2) + kernel_shape = (5, 5, 5) + strides = (3, 3, 3) + ceil_mode = True + + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=kernel_shape, + strides=strides, + dilations=dilations, + ceil_mode=ceil_mode, + ) + + x = np.random.randn(1, 1, *x_shape).astype(np.float32) + out_shape, pads = get_output_shape_explicit_padding( + None, x_shape, kernel_shape, strides, dilations, ceil_mode=ceil_mode + ) + padded = np.pad( + x, + ( + (0, 0), + (0, 0), + (pads[0], pads[3]), + (pads[1], pads[4]), + (pads[2], pads[5]), + ), + mode="constant", + constant_values=0, + ) + y = pool( + padded, + (1, 1, *x_shape), + kernel_shape, + strides, + out_shape, + "MAX", + pads_required=pads, + pads=None, + dilations=dilations, + ) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_maxpool_3d_dilations_use_ref_impl_large", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/maxunpool.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/maxunpool.py new file mode 100644 index 0000000000000000000000000000000000000000..a30aa067e681ebdf783695893953ab3d568ccd2f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/maxunpool.py @@ -0,0 +1,67 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MaxUnpool(Base): + @staticmethod + def export_without_output_shape() -> None: + node = onnx.helper.make_node( + "MaxUnpool", + inputs=["xT", "xI"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[2, 2], + ) + xT = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32) + xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64) + y = np.array( + [[[[0, 0, 0, 0], [0, 1, 0, 2], [0, 0, 0, 0], [0, 3, 0, 4]]]], + dtype=np.float32, + ) + expect( + node, + inputs=[xT, xI], + outputs=[y], + name="test_maxunpool_export_without_output_shape", + ) + + @staticmethod + def export_with_output_shape() -> None: + node = onnx.helper.make_node( + "MaxUnpool", + inputs=["xT", "xI", "output_shape"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[2, 2], + ) + xT = np.array([[[[5, 6], [7, 8]]]], dtype=np.float32) + xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64) + output_shape = np.array((1, 1, 5, 5), dtype=np.int64) + y = np.array( + [ + [ + [ + [0, 0, 0, 0, 0], + [0, 5, 0, 6, 0], + [0, 0, 0, 0, 0], + [0, 7, 0, 8, 0], + [0, 0, 0, 0, 0], + ] + ] + ], + dtype=np.float32, + ) + expect( + node, + inputs=[xT, xI, output_shape], + outputs=[y], + name="test_maxunpool_export_with_output_shape", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mean.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mean.py new file mode 100644 index 0000000000000000000000000000000000000000..f564aef11fbd5cc83136b4de3bd7c6f8e85fd31d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mean.py @@ -0,0 +1,47 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Mean(Base): + @staticmethod + def export() -> None: + data_0 = np.array([3, 0, 2]).astype(np.float32) + data_1 = np.array([1, 3, 4]).astype(np.float32) + data_2 = np.array([2, 6, 6]).astype(np.float32) + result = np.array([2, 3, 4]).astype(np.float32) + node = onnx.helper.make_node( + "Mean", + inputs=["data_0", "data_1", "data_2"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1, data_2], + outputs=[result], + name="test_mean_example", + ) + + node = onnx.helper.make_node( + "Mean", + inputs=["data_0"], + outputs=["result"], + ) + expect(node, inputs=[data_0], outputs=[data_0], name="test_mean_one_input") + + result = np.divide(np.add(data_0, data_1), 2.0) + node = onnx.helper.make_node( + "Mean", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, inputs=[data_0, data_1], outputs=[result], name="test_mean_two_inputs" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/meanvariancenormalization.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/meanvariancenormalization.py new file mode 100644 index 0000000000000000000000000000000000000000..690eb43ddde41fc468b43a939ac1f85f05859861 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/meanvariancenormalization.py @@ -0,0 +1,49 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MeanVarianceNormalization(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "MeanVarianceNormalization", inputs=["X"], outputs=["Y"] + ) + + input_data = np.array( + [ + [ + [[0.8439683], [0.5665144], [0.05836735]], + [[0.02916367], [0.12964272], [0.5060197]], + [[0.79538304], [0.9411346], [0.9546573]], + ], + [ + [[0.17730942], [0.46192095], [0.26480448]], + [[0.6746842], [0.01665257], [0.62473077]], + [[0.9240844], [0.9722341], [0.11965699]], + ], + [ + [[0.41356155], [0.9129373], [0.59330076]], + [[0.81929934], [0.7862604], [0.11799799]], + [[0.69248444], [0.54119414], [0.07513223]], + ], + ], + dtype=np.float32, + ) + + # Calculate expected output data + data_mean = np.mean(input_data, axis=(0, 2, 3), keepdims=1) + data_mean_squared = np.power(data_mean, 2) + data_squared = np.power(input_data, 2) + data_squared_mean = np.mean(data_squared, axis=(0, 2, 3), keepdims=1) + std = np.sqrt(data_squared_mean - data_mean_squared) + expected_output = (input_data - data_mean) / (std + 1e-9) + + expect(node, inputs=[input_data], outputs=[expected_output], name="test_mvn") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/melweightmatrix.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/melweightmatrix.py new file mode 100644 index 0000000000000000000000000000000000000000..22fb87afb684a7ca93315a19f322fea645fb7fff --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/melweightmatrix.py @@ -0,0 +1,90 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MelWeightMatrix(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "MelWeightMatrix", + inputs=[ + "num_mel_bins", + "dft_length", + "sample_rate", + "lower_edge_hertz", + "upper_edge_hertz", + ], + outputs=["output"], + ) + + num_mel_bins = np.int32(8) + dft_length = np.int32(16) + sample_rate = np.int32(8192) + lower_edge_hertz = np.float32(0) + upper_edge_hertz = np.float32(8192 / 2) + + num_spectrogram_bins = dft_length // 2 + 1 + frequency_bins = np.arange(0, num_mel_bins + 2) + + low_frequency_mel = 2595 * np.log10(1 + lower_edge_hertz / 700) + high_frequency_mel = 2595 * np.log10(1 + upper_edge_hertz / 700) + mel_step = (high_frequency_mel - low_frequency_mel) / frequency_bins.shape[0] + + frequency_bins = frequency_bins * mel_step + low_frequency_mel + frequency_bins = 700 * (np.power(10, (frequency_bins / 2595)) - 1) + frequency_bins = ((dft_length + 1) * frequency_bins) // sample_rate + frequency_bins = frequency_bins.astype(int) + + output = np.zeros((num_spectrogram_bins, num_mel_bins)) + output.flags.writeable = True + + for i in range(num_mel_bins): + lower_frequency_value = frequency_bins[i] # left + center_frequency_point = frequency_bins[i + 1] # center + higher_frequency_point = frequency_bins[i + 2] # right + low_to_center = center_frequency_point - lower_frequency_value + if low_to_center == 0: + output[center_frequency_point, i] = 1 + else: + for j in range(lower_frequency_value, center_frequency_point + 1): + output[j, i] = float(j - lower_frequency_value) / float( + low_to_center + ) + center_to_high = higher_frequency_point - center_frequency_point + if center_to_high > 0: + for j in range(center_frequency_point, higher_frequency_point): + output[j, i] = float(higher_frequency_point - j) / float( + center_to_high + ) + + # Expected output + # 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, + output = output.astype(np.float32) + expect( + node, + inputs=[ + num_mel_bins, + dft_length, + sample_rate, + lower_edge_hertz, + upper_edge_hertz, + ], + outputs=[output], + name="test_melweightmatrix", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/min.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/min.py new file mode 100644 index 0000000000000000000000000000000000000000..30afe004d4184988c32f045f77f9466a9c96b653 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/min.py @@ -0,0 +1,66 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.backend.test.case.utils import all_numeric_dtypes + + +class Min(Base): + @staticmethod + def export() -> None: + data_0 = np.array([3, 2, 1]).astype(np.float32) + data_1 = np.array([1, 4, 4]).astype(np.float32) + data_2 = np.array([2, 5, 0]).astype(np.float32) + result = np.array([1, 2, 0]).astype(np.float32) + node = onnx.helper.make_node( + "Min", + inputs=["data_0", "data_1", "data_2"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1, data_2], + outputs=[result], + name="test_min_example", + ) + + node = onnx.helper.make_node( + "Min", + inputs=["data_0"], + outputs=["result"], + ) + expect(node, inputs=[data_0], outputs=[data_0], name="test_min_one_input") + + result = np.minimum(data_0, data_1) + node = onnx.helper.make_node( + "Min", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, inputs=[data_0, data_1], outputs=[result], name="test_min_two_inputs" + ) + + @staticmethod + def export_min_all_numeric_types() -> None: + for op_dtype in all_numeric_dtypes: + data_0 = np.array([3, 2, 1]).astype(op_dtype) + data_1 = np.array([1, 4, 4]).astype(op_dtype) + result = np.array([1, 2, 1]).astype(op_dtype) + node = onnx.helper.make_node( + "Min", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1], + outputs=[result], + name=f"test_min_{np.dtype(op_dtype).name}", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mish.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mish.py new file mode 100644 index 0000000000000000000000000000000000000000..fafac6749606dba99922a001b1bcd842b507d631 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mish.py @@ -0,0 +1,23 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Mish(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("Mish", inputs=["X"], outputs=["Y"]) + + input_data = np.linspace(-10, 10, 10000, dtype=np.float32) + + # Calculate expected output data + expected_output = input_data * np.tanh(np.log1p(np.exp(input_data))) + + expect(node, inputs=[input_data], outputs=[expected_output], name="test_mish") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mod.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mod.py new file mode 100644 index 0000000000000000000000000000000000000000..580e2a004103cf5a911708867948ea23b3864243 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mod.py @@ -0,0 +1,177 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Mod(Base): + @staticmethod + def export_mod_mixed_sign_float64() -> None: + node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1) + + x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float64) + y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float64) + z = np.fmod(x, y) # expected output [-0.1, 0.4, 5. , 0.1, -0.4, 3.] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float64") + + @staticmethod + def export_mod_mixed_sign_float32() -> None: + node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1) + + x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float32) + y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float32) + z = np.fmod( + x, y + ) # expected output [-0.10000038, 0.39999962, 5. , 0.10000038, -0.39999962, 3.] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float32") + + @staticmethod + def export_mod_mixed_sign_float16() -> None: + node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1) + + x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float16) + y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float16) + z = np.fmod( + x, y + ) # expected output [-0.10156, 0.3984 , 5. , 0.10156, -0.3984 , 3.] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float16") + + @staticmethod + def export_mod_mixed_sign_int64() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64) + z = np.mod(x, y) # expected output [ 0, -2, 5, 0, 2, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int64") + + @staticmethod + def export_mod_mixed_sign_int32() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int32) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int32) + z = np.mod(x, y) # expected output [ 0, -2, 5, 0, 2, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int32") + + @staticmethod + def export_mod_mixed_sign_int16() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int16) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int16) + z = np.mod(x, y) # expected output [ 0, -2, 5, 0, 2, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int16") + + @staticmethod + def export_mod_mixed_sign_int8() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int8) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int8) + z = np.mod(x, y) # expected output [ 0, -2, 5, 0, 2, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int8") + + @staticmethod + def export_mod_uint8() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([4, 7, 5]).astype(np.uint8) + y = np.array([2, 3, 8]).astype(np.uint8) + z = np.mod(x, y) # expected output [0, 1, 5] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint8") + + @staticmethod + def export_mod_uint16() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([4, 7, 5]).astype(np.uint16) + y = np.array([2, 3, 8]).astype(np.uint16) + z = np.mod(x, y) # expected output [0, 1, 5] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint16") + + @staticmethod + def export_mod_uint32() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([4, 7, 5]).astype(np.uint32) + y = np.array([2, 3, 8]).astype(np.uint32) + z = np.mod(x, y) # expected output [0, 1, 5] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint32") + + @staticmethod + def export_mod_uint64() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([4, 7, 5]).astype(np.uint64) + y = np.array([2, 3, 8]).astype(np.uint64) + z = np.mod(x, y) # expected output [0, 1, 5] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint64") + + @staticmethod + def export_mod_int64_fmod() -> None: + node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64) + z = np.fmod(x, y) # expected output [ 0, 1, 5, 0, -1, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_int64_fmod") + + @staticmethod + def export_mod_broadcast() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.arange(0, 30).reshape([3, 2, 5]).astype(np.int32) + y = np.array([7]).astype(np.int32) + z = np.mod(x, y) + # array([[[0, 1, 2, 3, 4], + # [5, 6, 0, 1, 2]], + + # [[3, 4, 5, 6, 0], + # [1, 2, 3, 4, 5]], + + # [[6, 0, 1, 2, 3], + # [4, 5, 6, 0, 1]]], dtype=int32) + expect(node, inputs=[x, y], outputs=[z], name="test_mod_broadcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/momentum.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/momentum.py new file mode 100644 index 0000000000000000000000000000000000000000..266e87f539b9cb3d59fae8cb67bfb8f8e4955539 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/momentum.py @@ -0,0 +1,162 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN + + +def apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta): + # Add gradient of regularization term. + g_regularized = norm_coefficient * x + g + # Coefficient of gradient should be 1 at the first iteration. + beta_adjusted = beta if t > 0 else 1 + # Update momentum. + v_new = alpha * v + beta_adjusted * g_regularized + # Apply SG with momentum update rule. + x_new = x - r * v_new + return x_new, v_new + + +def apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta): + # Add gradient of regularization term. + g_regularized = norm_coefficient * x + g + # Coefficient of gradient should be 1 at the first iteration. + beta_adjusted = beta if t > 0 else 1 + # Update momentum. + v_new = alpha * v + beta_adjusted * g_regularized + # Apply Nesterov with momentum update rule. + x_new = x - r * (g_regularized + alpha * v_new) + return x_new, v_new + + +class Momentum(Base): + @staticmethod + def export_momentum() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + alpha = 0.95 + beta = 0.1 + + # Create operator. + node = onnx.helper.make_node( + "Momentum", + inputs=["R", "T", "X", "G", "V"], + outputs=["X_new", "V_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + mode="standard", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + x = np.array([1.2, 2.8], dtype=np.float32) + g = np.array([-0.94, -2.5], dtype=np.float32) + v = np.array([1.7, 3.6], dtype=np.float32) + + # Compute expected outputs of Momentum. + x_new, v_new = apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta) + + # Check results. + expect( + node, + inputs=[r, t, x, g, v], + outputs=[x_new, v_new], + name="test_momentum", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) + + @staticmethod + def export_nesterov_momentum() -> None: + # Define operator attributes. + norm_coefficient = 0.01 + alpha = 0.95 + beta = 1.0 + + # Create operator. + node = onnx.helper.make_node( + "Momentum", + inputs=["R", "T", "X", "G", "V"], + outputs=["X_new", "V_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + mode="nesterov", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + x = np.array([1.2, 2.8], dtype=np.float32) + g = np.array([-0.94, -2.5], dtype=np.float32) + v = np.array([1.7, 3.6], dtype=np.float32) + + # Compute expected outputs of Momentum. + x_new, v_new = apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta) + + # Check results. + expect( + node, + inputs=[r, t, x, g, v], + outputs=[x_new, v_new], + name="test_nesterov_momentum", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) + + @staticmethod + def export_momentum_multiple() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + alpha = 0.95 + beta = 0.85 + + node = onnx.helper.make_node( + "Momentum", + inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"], + outputs=["X1_new", "X2_new", "V1_new", "V2_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + mode="standard", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + + x1 = np.array([1.0], dtype=np.float32) + g1 = np.array([-1.0], dtype=np.float32) + v1 = np.array([2.0], dtype=np.float32) + + x2 = np.array([1.0, 2.0], dtype=np.float32) + g2 = np.array([-1.0, -3.0], dtype=np.float32) + v2 = np.array([4.0, 1.0], dtype=np.float32) + + # Compute expected outputs of Momentum. + x1_new, v1_new = apply_momentum(r, t, x1, g1, v1, norm_coefficient, alpha, beta) + x2_new, v2_new = apply_momentum(r, t, x2, g2, v2, norm_coefficient, alpha, beta) + + # Check results. + expect( + node, + inputs=[r, t, x1, x2, g1, g2, v1, v2], + outputs=[x1_new, x2_new, v1_new, v2_new], + name="test_momentum_multiple", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mul.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mul.py new file mode 100644 index 0000000000000000000000000000000000000000..6ae1f9cd518e5b3f364647e92662f20cc0e8fea5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/mul.py @@ -0,0 +1,73 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Mul(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Mul", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([1, 2, 3]).astype(np.float32) + y = np.array([4, 5, 6]).astype(np.float32) + z = x * y # expected output [4., 10., 18.] + expect(node, inputs=[x, y], outputs=[z], name="test_mul_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = x * y + expect(node, inputs=[x, y], outputs=[z], name="test_mul") + + x = np.random.randint(4, size=(3, 4, 5), dtype=np.int8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + z = x * y + expect(node, inputs=[x, y], outputs=[z], name="test_mul_int8") + + x = np.random.randint(4, size=(3, 4, 5), dtype=np.int16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + z = x * y + expect(node, inputs=[x, y], outputs=[z], name="test_mul_int16") + + x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + z = x * y + expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint8") + + x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + z = x * y + expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint16") + + x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + z = x * y + expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint32") + + x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + z = x * y + expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint64") + + @staticmethod + def export_mul_broadcast() -> None: + node = onnx.helper.make_node( + "Mul", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = x * y + expect(node, inputs=[x, y], outputs=[z], name="test_mul_bcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/neg.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/neg.py new file mode 100644 index 0000000000000000000000000000000000000000..1082d33f3c460abe1a67caa33b0c0a77678400e3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/neg.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Neg(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Neg", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-4, 2]).astype(np.float32) + y = np.negative(x) # expected output [4., -2.], + expect(node, inputs=[x], outputs=[y], name="test_neg_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.negative(x) + expect(node, inputs=[x], outputs=[y], name="test_neg") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/negativeloglikelihoodloss.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/negativeloglikelihoodloss.py new file mode 100644 index 0000000000000000000000000000000000000000..c5fcdd85ded676893a90524438f993afc914fd7f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/negativeloglikelihoodloss.py @@ -0,0 +1,585 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def compute_negative_log_likelihood_loss( + input, target, weight=None, reduction="mean", ignore_index=None +): + input_shape = input.shape + if len(input_shape) == 1: + raise RuntimeError("Unsupported shape") + + target_shape = target.shape + N = input_shape[0] + C = input_shape[1] + + # initialize the positional weights when required + gather_weight = None + if weight is not None: + # setting mode='clip' to deal with ignore_index > C or < 0 cases. + # when the target value is > C or < 0, it doesn't matter which value we are + # taking in gather_weight, since it will be set to 0 in the following if-block + # use np.int32 to make it compatible with x86 machines + gather_weight = np.take(weight, np.array(target, dtype=np.int32), mode="clip") + # set `ignore_index`'s loss weight to 0. + # The loss tensor will be multiplied by this weight tensor, + # so `ignore_index`'s loss value will be eliminated. + if ignore_index is not None: + gather_weight = np.where(target == ignore_index, 0, gather_weight).astype( + dtype=np.float32 + ) + elif ignore_index is not None: + gather_weight = np.where(target == ignore_index, 0, 1).astype(dtype=np.float32) + + # if input is 4-d and above, make it 3-d + if len(input_shape) != 3: + input = input.reshape((N, C, -1)) + target = target.reshape((N, -1)) + + # Get a dimension from the reshaped input. + # If the original input shape is [N, C, H, W], + # the D here should be H * W because we reshape + # [N, C, H, W] to [N, C, H * W]. + D = input.shape[2] + neg_gather_element_input = np.zeros((N, D), dtype=np.float32) + for i in range(N): + for d in range(D): + if target[i][d] != ignore_index: + neg_gather_element_input[i][d] = -input[i][target[i][d]][d] + + loss = neg_gather_element_input + + # if the input was 4-d or above reshape to the right shape + if len(input_shape) != 3: + loss = loss.reshape(target_shape) + + # apply the weights when required + if gather_weight is not None: + loss = gather_weight * loss + if reduction == "mean": + return loss.sum() / gather_weight.sum() + + if reduction == "mean": + loss = np.mean(loss) + elif reduction == "sum": + loss = np.sum(loss) + return loss + + +class NegativeLogLikelihoodLoss(Base): + @staticmethod + def export_input_shape_is_NC() -> None: + reduction = "none" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ) + + N, C = 3, 5 + np.random.seed(0) + input = np.random.rand(N, C).astype(np.float32) + target = np.random.randint(0, high=C, size=(N,)).astype(np.int64) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=None, reduction=reduction + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NC", + ) + + @staticmethod + def export_input_shape_is_NCd1d2() -> None: + reduction = "none" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, dim1, dim2 = 3, 5, 6, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=None, reduction=reduction + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2", + ) + + @staticmethod + def export_input_shape_is_NCd1d2_reduction_mean() -> None: + reduction = "mean" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, dim1, dim2 = 3, 5, 6, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=None, reduction=reduction + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2_reduction_mean", + ) + + @staticmethod + def export_input_shape_is_NCd1d2_reduction_sum() -> None: + reduction = "sum" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, dim1, dim2 = 3, 5, 6, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=None, reduction=reduction + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2_reduction_sum", + ) + + @staticmethod + def export_input_shape_is_NCd1d2_with_weight() -> None: + reduction = "none" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, dim1, dim2 = 3, 5, 6, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64) + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2_with_weight", + ) + + @staticmethod + def export_input_shape_is_NCd1d2_with_weight_reduction_mean() -> None: + reduction = "mean" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, dim1, dim2 = 3, 5, 6, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64) + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2_with_weight_reduction_mean", + ) + + @staticmethod + def export_input_shape_is_NCd1d2_with_weight_reduction_sum() -> None: + reduction = "sum" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, dim1, dim2 = 3, 5, 6, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64) + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2_with_weight_reduction_sum", + ) + + @staticmethod + def export_input_shape_is_NCd1d2_with_weight_reduction_sum_ii() -> None: + reduction = "sum" + ignore_index = np.int64(0) + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, dim1, dim2 = 3, 5, 6, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64) + target[0][0][0] = np.int64(0) + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2_with_weight_reduction_sum_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1d2_no_weight_reduction_mean_ii() -> None: + reduction = "mean" + ignore_index = np.int64(1) + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, dim1, dim2 = 3, 5, 6, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64) + target[0][0][0] = np.int64(1) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2_no_weight_reduction_mean_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1() -> None: + reduction = "mean" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, d1 = 3, 5, 2 + np.random.seed(0) + input = np.random.rand(N, C, d1).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=None, reduction=reduction + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1", + ) + + @staticmethod + def export_input_shape_is_NCd1_weight() -> None: + reduction = "mean" + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, d1 = 3, 5, 2 + np.random.seed(0) + input = np.random.rand(N, C, d1).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64) + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1_weight", + ) + + @staticmethod + def export_input_shape_is_NCd1_ii() -> None: + reduction = "mean" + ignore_index = np.int64(1) + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, d1 = 3, 5, 2 + np.random.seed(0) + input = np.random.rand(N, C, d1).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64) + target[0][0] = np.int64(1) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=None, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1_weight_ii() -> None: + reduction = "mean" + ignore_index = np.int64(1) + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, d1 = 3, 5, 2 + np.random.seed(0) + input = np.random.rand(N, C, d1).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64) + target[0][0] = np.int64(1) + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1_weight_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3d4d5_mean_weight() -> None: + reduction = "mean" + + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32) + target = np.random.randint( + 0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5) + ).astype(np.int64) + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2d3d4d5_mean_weight", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3d4d5_none_no_weight() -> None: + reduction = "none" + + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ) + + N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32) + target = np.random.randint( + 0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5) + ).astype(np.int64) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, reduction=reduction + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2d3d4d5_none_no_weight", + ) + + @staticmethod + def export_input_shape_is_NCd1_mean_weight_negative_ii() -> None: + reduction = "mean" + ignore_index = np.int64(-1) + + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, dim1 = 3, 5, 6 + np.random.seed(0) + input = np.random.rand(N, C, dim1).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64) + target[0][0] = -1 + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1_mean_weight_negative_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3_none_no_weight_negative_ii() -> None: + reduction = "none" + ignore_index = np.int64(-5) + + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target"], + outputs=["loss"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5 + np.random.seed(0) + input = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32) + target = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype( + np.int64 + ) + target[0][0][0][0] = -5 + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[input, target], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2d3_none_no_weight_negative_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3_sum_weight_high_ii() -> None: + reduction = "sum" + ignore_index = np.int64(10) + + node = onnx.helper.make_node( + "NegativeLogLikelihoodLoss", + inputs=["input", "target", "weight"], + outputs=["loss"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C = 3, 5 + np.random.seed(0) + input = np.random.rand(N, C).astype(np.float32) + target = np.random.randint(0, high=C, size=(N)).astype(np.int64) + target[0] = 10 + weight = np.random.rand(C).astype(np.float32) + + negative_log_likelihood_loss = compute_negative_log_likelihood_loss( + input, target, weight=weight, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[input, target, weight], + outputs=[negative_log_likelihood_loss], + name="test_nllloss_NCd1d2d3_sum_weight_high_ii", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/nonmaxsuppression.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/nonmaxsuppression.py new file mode 100644 index 0000000000000000000000000000000000000000..f1b9ed4264c9026f4b98f9c39ea3d1a021c3084c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/nonmaxsuppression.py @@ -0,0 +1,475 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class NonMaxSuppression(Base): + @staticmethod + def export_nonmaxsuppression_suppress_by_IOU() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + boxes = np.array( + [ + [ + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.1, 1.0, 1.1], + [0.0, -0.1, 1.0, 0.9], + [0.0, 10.0, 1.0, 11.0], + [0.0, 10.1, 1.0, 11.1], + [0.0, 100.0, 1.0, 101.0], + ] + ] + ).astype(np.float32) + scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32) + max_output_boxes_per_class = np.array([3]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_suppress_by_IOU", + ) + + @staticmethod + def export_nonmaxsuppression_suppress_by_IOU_and_scores() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + boxes = np.array( + [ + [ + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.1, 1.0, 1.1], + [0.0, -0.1, 1.0, 0.9], + [0.0, 10.0, 1.0, 11.0], + [0.0, 10.1, 1.0, 11.1], + [0.0, 100.0, 1.0, 101.0], + ] + ] + ).astype(np.float32) + scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32) + max_output_boxes_per_class = np.array([3]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.4]).astype(np.float32) + selected_indices = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_suppress_by_IOU_and_scores", + ) + + @staticmethod + def export_nonmaxsuppression_flipped_coordinates() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + boxes = np.array( + [ + [ + [1.0, 1.0, 0.0, 0.0], + [0.0, 0.1, 1.0, 1.1], + [0.0, 0.9, 1.0, -0.1], + [0.0, 10.0, 1.0, 11.0], + [1.0, 10.1, 0.0, 11.1], + [1.0, 101.0, 0.0, 100.0], + ] + ] + ).astype(np.float32) + scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32) + max_output_boxes_per_class = np.array([3]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_flipped_coordinates", + ) + + @staticmethod + def export_nonmaxsuppression_limit_output_size() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + boxes = np.array( + [ + [ + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.1, 1.0, 1.1], + [0.0, -0.1, 1.0, 0.9], + [0.0, 10.0, 1.0, 11.0], + [0.0, 10.1, 1.0, 11.1], + [0.0, 100.0, 1.0, 101.0], + ] + ] + ).astype(np.float32) + scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32) + max_output_boxes_per_class = np.array([2]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + selected_indices = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_limit_output_size", + ) + + @staticmethod + def export_nonmaxsuppression_single_box() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + boxes = np.array([[[0.0, 0.0, 1.0, 1.0]]]).astype(np.float32) + scores = np.array([[[0.9]]]).astype(np.float32) + max_output_boxes_per_class = np.array([3]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + selected_indices = np.array([[0, 0, 0]]).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_single_box", + ) + + @staticmethod + def export_nonmaxsuppression_identical_boxes() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + boxes = np.array( + [ + [ + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 1.0, 1.0], + ] + ] + ).astype(np.float32) + scores = np.array( + [[[0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9]]] + ).astype(np.float32) + max_output_boxes_per_class = np.array([3]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + selected_indices = np.array([[0, 0, 0]]).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_identical_boxes", + ) + + @staticmethod + def export_nonmaxsuppression_center_point_box_format() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + center_point_box=1, + ) + boxes = np.array( + [ + [ + [0.5, 0.5, 1.0, 1.0], + [0.5, 0.6, 1.0, 1.0], + [0.5, 0.4, 1.0, 1.0], + [0.5, 10.5, 1.0, 1.0], + [0.5, 10.6, 1.0, 1.0], + [0.5, 100.5, 1.0, 1.0], + ] + ] + ).astype(np.float32) + scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32) + max_output_boxes_per_class = np.array([3]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_center_point_box_format", + ) + + @staticmethod + def export_nonmaxsuppression_two_classes() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + boxes = np.array( + [ + [ + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.1, 1.0, 1.1], + [0.0, -0.1, 1.0, 0.9], + [0.0, 10.0, 1.0, 11.0], + [0.0, 10.1, 1.0, 11.1], + [0.0, 100.0, 1.0, 101.0], + ] + ] + ).astype(np.float32) + scores = np.array( + [[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3], [0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]] + ).astype(np.float32) + max_output_boxes_per_class = np.array([2]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + selected_indices = np.array( + [[0, 0, 3], [0, 0, 0], [0, 1, 3], [0, 1, 0]] + ).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_two_classes", + ) + + @staticmethod + def export_nonmaxsuppression_two_batches() -> None: + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + boxes = np.array( + [ + [ + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.1, 1.0, 1.1], + [0.0, -0.1, 1.0, 0.9], + [0.0, 10.0, 1.0, 11.0], + [0.0, 10.1, 1.0, 11.1], + [0.0, 100.0, 1.0, 101.0], + ], + [ + [0.0, 0.0, 1.0, 1.0], + [0.0, 0.1, 1.0, 1.1], + [0.0, -0.1, 1.0, 0.9], + [0.0, 10.0, 1.0, 11.0], + [0.0, 10.1, 1.0, 11.1], + [0.0, 100.0, 1.0, 101.0], + ], + ] + ).astype(np.float32) + scores = np.array( + [[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]], [[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]] + ).astype(np.float32) + max_output_boxes_per_class = np.array([2]).astype(np.int64) + iou_threshold = np.array([0.5]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + selected_indices = np.array( + [[0, 0, 3], [0, 0, 0], [1, 0, 3], [1, 0, 0]] + ).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_two_batches", + ) + + @staticmethod + def export_nonmaxsuppression_iou_threshold_boundary() -> None: + """Test boundary condition where IoU exactly equals threshold. + + This test verifies that the comparison is strict (>), not inclusive (>=). + When IoU exactly equals the threshold, boxes should be KEPT, not suppressed. + This follows PyTorch's NMS implementation. + """ + node = onnx.helper.make_node( + "NonMaxSuppression", + inputs=[ + "boxes", + "scores", + "max_output_boxes_per_class", + "iou_threshold", + "score_threshold", + ], + outputs=["selected_indices"], + ) + # Two boxes with 50% overlap in each dimension + # box1=[0,0,1,1], box2=[0.5,0.5,1.5,1.5] + # Intersection area = 0.5 * 0.5 = 0.25 + # Union area = 1.0 + 1.0 - 0.25 = 1.75 + # IoU = 0.25 / 1.75 (exact value computed below as float32) + boxes = np.array( + [ + [ + [0.0, 0.0, 1.0, 1.0], # box 0 + [0.5, 0.5, 1.5, 1.5], # box 1 - overlaps box 0 + ] + ] + ).astype(np.float32) + scores = np.array([[[0.9, 0.8]]]).astype(np.float32) + max_output_boxes_per_class = np.array([3]).astype(np.int64) + # Compute the exact IoU value and use it as threshold + # This ensures the threshold exactly equals the IoU + exact_iou = np.float32(0.25 / 1.75) + iou_threshold = np.array([exact_iou]).astype(np.float32) + score_threshold = np.array([0.0]).astype(np.float32) + # Both boxes should be selected because IoU == threshold (not > threshold) + selected_indices = np.array([[0, 0, 0], [0, 0, 1]]).astype(np.int64) + + expect( + node, + inputs=[ + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + ], + outputs=[selected_indices], + name="test_nonmaxsuppression_iou_threshold_boundary", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/nonzero.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/nonzero.py new file mode 100644 index 0000000000000000000000000000000000000000..03feeed8e714cc1df31c244fdfb7ee05da3a4af7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/nonzero.py @@ -0,0 +1,26 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class NonZero(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "NonZero", + inputs=["condition"], + outputs=["result"], + ) + + condition = np.array([[1, 0], [1, 1]], dtype=bool) + result = np.array( + np.nonzero(condition), dtype=np.int64 + ) # expected output [[0, 1, 1], [0, 0, 1]] + expect(node, inputs=[condition], outputs=[result], name="test_nonzero_example") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/not_.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/not_.py new file mode 100644 index 0000000000000000000000000000000000000000..b610dff0c3ee6d376ba8c337d8247b6d798aa0c2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/not_.py @@ -0,0 +1,32 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Not(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Not", + inputs=["x"], + outputs=["not"], + ) + + # 2d + x = (np.random.randn(3, 4) > 0).astype(bool) + expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_2d") + + # 3d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_3d") + + # 4d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_4d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/onehot.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/onehot.py new file mode 100644 index 0000000000000000000000000000000000000000..d4bc8297d2a9b7b90971a8bf7182d061fb73c6e0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/onehot.py @@ -0,0 +1,126 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def one_hot(indices, depth, axis=-1, dtype=np.float32): + """Compute one hot from indices at a specific axis""" + values = np.asarray(indices) + rank = len(values.shape) + depth_range = np.arange(depth) + if axis < 0: + axis += rank + 1 + ls = values.shape[0:axis] + rs = values.shape[axis:rank] + targets = np.reshape( + depth_range, (1,) * len(ls) + depth_range.shape + (1,) * len(rs) + ) + values = np.reshape(np.mod(values, depth), (*ls, 1, *rs)) + return np.asarray(targets == values, dtype=dtype) + + +class OneHot(Base): + @staticmethod + def export_without_axis() -> None: + on_value = 5 + off_value = 2 + output_type = np.int32 + node = onnx.helper.make_node( + "OneHot", inputs=["indices", "depth", "values"], outputs=["y"] + ) + indices = np.array([0, 7, 8], dtype=np.int64) + depth = np.float32(12) + values = np.array([off_value, on_value], dtype=output_type) + y = one_hot(indices, depth, dtype=output_type) + y = y * (on_value - off_value) + off_value + expect( + node, + inputs=[indices, depth, values], + outputs=[y], + name="test_onehot_without_axis", + ) + + @staticmethod + def export_with_axis() -> None: + axisValue = 1 + on_value = 3 + off_value = 1 + output_type = np.float32 + node = onnx.helper.make_node( + "OneHot", + inputs=["indices", "depth", "values"], + outputs=["y"], + axis=axisValue, + ) + indices = np.array([[1, 9], [2, 4]], dtype=np.float32) + depth = np.float32(10) + values = np.array([off_value, on_value], dtype=output_type) + y = one_hot(indices, depth, axis=axisValue, dtype=output_type) + y = y * (on_value - off_value) + off_value + expect( + node, + inputs=[indices, depth, values], + outputs=[y], + name="test_onehot_with_axis", + ) + + @staticmethod + def export_with_negative_indices() -> None: + axisValue = 1 + on_value = 3 + off_value = 1 + output_type = np.float32 + node = onnx.helper.make_node( + "OneHot", + inputs=["indices", "depth", "values"], + outputs=["y"], + axis=axisValue, + ) + indices = np.array([0, -7, -8], dtype=np.int64) + + # print(y) + # [[3. 1. 1. 1. 1. 1. 1. 1. 1. 1.] + # [1. 1. 1. 3. 1. 1. 1. 1. 1. 1.] + # [1. 1. 3. 1. 1. 1. 1. 1. 1. 1.]] + + depth = np.float32(10) + values = np.array([off_value, on_value], dtype=output_type) + y = one_hot(indices, depth, axis=axisValue, dtype=output_type) + y = y * (on_value - off_value) + off_value + expect( + node, + inputs=[indices, depth, values], + outputs=[y], + name="test_onehot_negative_indices", + ) + + @staticmethod + def export_with_negative_axis() -> None: + axisValue = -2 + on_value = 3 + off_value = 1 + output_type = np.float32 + node = onnx.helper.make_node( + "OneHot", + inputs=["indices", "depth", "values"], + outputs=["y"], + axis=axisValue, + ) + indices = np.array([[1, 9], [2, 4]], dtype=np.float32) + depth = np.float32(10) + values = np.array([off_value, on_value], dtype=output_type) + y = one_hot(indices, depth, axis=axisValue, dtype=output_type) + y = y * (on_value - off_value) + off_value + expect( + node, + inputs=[indices, depth, values], + outputs=[y], + name="test_onehot_with_negative_axis", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/optionalgetelement.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/optionalgetelement.py new file mode 100644 index 0000000000000000000000000000000000000000..c7f5efa961bc06629b58b700aa367fb17dabf4d7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/optionalgetelement.py @@ -0,0 +1,80 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def optional_get_element_reference_implementation(optional: Any | None) -> Any: + assert optional is not None + return optional + + +class OptionalHasElement(Base): + @staticmethod + def export_get_element_tensor() -> None: + optional = np.array([1, 2, 3, 4]).astype(np.float32) + tensor_type_proto = onnx.helper.make_tensor_type_proto( + elem_type=onnx.TensorProto.FLOAT, + shape=[ + 4, + ], + ) + optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto) + + node = onnx.helper.make_node( + "OptionalGetElement", inputs=["optional_input"], outputs=["output"] + ) + output = optional_get_element_reference_implementation(optional) + expect( + node, + inputs=[optional], + outputs=[output], + input_type_protos=[optional_type_proto], + name="test_optional_get_element_optional_tensor", + ) + expect( + node, + inputs=[optional], + outputs=[output], + input_type_protos=[tensor_type_proto], + name="test_optional_get_element_tensor", + ) + + @staticmethod + def export_get_element_sequence() -> None: + optional = [np.array([1, 2, 3, 4]).astype(np.int32)] + tensor_type_proto = onnx.helper.make_tensor_type_proto( + elem_type=onnx.TensorProto.INT32, + shape=[ + 4, + ], + ) + seq_type_proto = onnx.helper.make_sequence_type_proto(tensor_type_proto) + optional_type_proto = onnx.helper.make_optional_type_proto(seq_type_proto) + + node = onnx.helper.make_node( + "OptionalGetElement", inputs=["optional_input"], outputs=["output"] + ) + output = optional_get_element_reference_implementation(optional) + expect( + node, + inputs=[optional], + outputs=[output], + input_type_protos=[optional_type_proto], + name="test_optional_get_element_optional_sequence", + ) + expect( + node, + inputs=[optional], + outputs=[output], + input_type_protos=[seq_type_proto], + name="test_optional_get_element_sequence", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/optionalhaselement.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/optionalhaselement.py new file mode 100644 index 0000000000000000000000000000000000000000..e704cd3704421c5fe8ac8568beeb803d872da394 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/optionalhaselement.py @@ -0,0 +1,93 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def optional_has_element_reference_implementation( + optional: np.ndarray | None, +) -> np.ndarray: + if optional is None: + return np.array(False) + return np.array(True) + + +class OptionalHasElement(Base): + @staticmethod + def export() -> None: + optional = np.array([1, 2, 3, 4]).astype(np.float32) + tensor_type_proto = onnx.helper.make_tensor_type_proto( + elem_type=onnx.TensorProto.FLOAT, + shape=[ + 4, + ], + ) + optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto) + + # OptionalHasElement takes a tensor or optional as input + for input_type_protos in [tensor_type_proto, optional_type_proto]: + node = onnx.helper.make_node( + "OptionalHasElement", inputs=["optional_input"], outputs=["output"] + ) + output = optional_has_element_reference_implementation(optional) + test_name = "test_optional_has_element_" + ( + "optional_input" + if input_type_protos == optional_type_proto + else "tensor_input" + ) + expect( + node, + inputs=[optional], + outputs=[output], + input_type_protos=[optional_type_proto], + name=test_name, + ) + + @staticmethod + def export_empty() -> None: + optional = None + + tensor_type_proto = onnx.helper.make_tensor_type_proto( + elem_type=onnx.TensorProto.INT32, shape=[] + ) + optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto) + + # OptionalHasElement takes a tensor or optional as input + for input_type_proto in [tensor_type_proto, optional_type_proto]: + input_name_options = { + "empty": "optional_input", + "empty_no_input_name": "", + "empty_no_input": None, + } + for test_name_surfix, input_name in input_name_options.items(): + if input_type_proto == tensor_type_proto and input_name: + # the input tensor cannot be empty if input name is provided. + continue + node = onnx.helper.make_node( + "OptionalHasElement", + inputs=[] if input_name is None else [input_name], + outputs=["output"], + ) + output = optional_has_element_reference_implementation(optional) + test_name = ( + "test_optional_has_element_" + + test_name_surfix + + ( + "_optional_input" + if input_type_proto == optional_type_proto + else "_tensor_input" + ) + ) + expect( + node, + inputs=[optional] if input_name else [], + outputs=[output], + input_type_protos=[input_type_proto] if input_name else [], + name=test_name, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/or_.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/or_.py new file mode 100644 index 0000000000000000000000000000000000000000..ade9f57b595bd2f6c4a99dea4e69a2e7d44c8ffb --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/or_.py @@ -0,0 +1,76 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Or(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Or", + inputs=["x", "y"], + outputs=["or"], + ) + + # 2d + x = (np.random.randn(3, 4) > 0).astype(bool) + y = (np.random.randn(3, 4) > 0).astype(bool) + z = np.logical_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_or2d") + + # 3d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(3, 4, 5) > 0).astype(bool) + z = np.logical_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_or3d") + + # 4d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + z = np.logical_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_or4d") + + @staticmethod + def export_or_broadcast() -> None: + node = onnx.helper.make_node( + "Or", + inputs=["x", "y"], + outputs=["or"], + ) + + # 3d vs 1d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(5) > 0).astype(bool) + z = np.logical_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast3v1d") + + # 3d vs 2d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(4, 5) > 0).astype(bool) + z = np.logical_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast3v2d") + + # 4d vs 2d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(5, 6) > 0).astype(bool) + z = np.logical_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v2d") + + # 4d vs 3d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(4, 5, 6) > 0).astype(bool) + z = np.logical_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v3d") + + # 4d vs 4d + x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool) + y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool) + z = np.logical_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v4d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/pad.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/pad.py new file mode 100644 index 0000000000000000000000000000000000000000..5d1cdc31414c679f789d692a6a814c40d00d477e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/pad.py @@ -0,0 +1,129 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None): + input_rank = data.ndim + if axes is None: + axes = list(range(input_rank)) + else: + axes = [axis if axis >= 0 else axis + input_rank for axis in axes] + num_axes = len(axes) + + if num_axes * 2 != raw_pads.size: + raise ValueError("The number of elements in raw_pads should be 2 * num_axes") + + pad_width = [] + for _ in range(input_rank): + pad_width += [[0, 0]] # init to zero + + # re-order to np.pad accepted order ((x1_begin, x1_end), (x2_begin, x2_end), ...) + for i in range(num_axes): + axis = axes[i] + if axis < 0: + axis = input_rank + axis + pad_width[axis] = [raw_pads[i], raw_pads[i + num_axes]] + + if mode == "constant": + return np.pad( + data, + pad_width=pad_width, + mode=mode, + constant_values=constant_values, + ) + + return np.pad( + data, + pad_width=pad_width, + mode=mode, + ) + + +class Pad(Base): + @staticmethod + def export_constant_pad() -> None: + node = onnx.helper.make_node( + "Pad", inputs=["x", "pads", "value"], outputs=["y"], mode="constant" + ) + x = np.random.randn(1, 3, 4, 5).astype(np.float32) + pads = np.array([0, 0, 1, 3, 0, 0, 2, 4]).astype( + np.int64 + ) # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...] + value = np.float32(1.2) + y = pad_impl(x, pads, "constant", 1.2) + + expect(node, inputs=[x, pads, value], outputs=[y], name="test_constant_pad") + + @staticmethod + def export_reflection_edge_and_wrap_pad() -> None: + for mode in ("edge", "reflect", "wrap"): + node = onnx.helper.make_node( + "Pad", inputs=["x", "pads"], outputs=["y"], mode=mode + ) + x = np.random.randn(1, 3, 4, 5).astype(np.int32) + pads = np.array([0, 0, 1, 1, 0, 0, 1, 1]).astype( + np.int64 + ) # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...] + y = pad_impl(x, pads, mode) + + expect(node, inputs=[x, pads], outputs=[y], name=f"test_{mode}_pad") + + @staticmethod + def export_constant_pad_axes() -> None: + node = onnx.helper.make_node( + "Pad", inputs=["x", "pads", "value", "axes"], outputs=["y"], mode="constant" + ) + x = np.random.randn(1, 3, 4, 5).astype(np.float32) + pads = np.array([0, 3, 0, 4]).astype( + np.int64 + ) # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...] + value = np.float32(1.2) + axes = np.array([1, 3], dtype=np.int64) + y = pad_impl( + x, + pads, + "constant", + 1.2, + [1, 3], + ) + + expect( + node, + inputs=[x, pads, value, axes], + outputs=[y], + name="test_constant_pad_axes", + ) + + @staticmethod + def export_constant_pad_negative_axes() -> None: + node = onnx.helper.make_node( + "Pad", inputs=["x", "pads", "value", "axes"], outputs=["y"], mode="constant" + ) + x = np.random.randn(1, 3, 4, 5).astype(np.float32) + pads = np.array([0, 3, 0, 4]).astype( + np.int64 + ) # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...] + value = np.float32(1.2) + axes = np.array([-3, -1], dtype=np.int64) + y = pad_impl( + x, + pads, + "constant", + 1.2, + [-3, -1], + ) + + expect( + node, + inputs=[x, pads, value, axes], + outputs=[y], + name="test_constant_pad_negative_axes", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/pow.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/pow.py new file mode 100644 index 0000000000000000000000000000000000000000..412faf5af873042d338b473aa32c463d53c7dbf9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/pow.py @@ -0,0 +1,106 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def pow(x: np.ndarray, y: np.ndarray) -> np.ndarray: # noqa: A001 + return np.power(x, y).astype(x.dtype) + + +class Pow(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Pow", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([1, 2, 3]).astype(np.float32) + y = np.array([4, 5, 6]).astype(np.float32) + z = pow(x, y) # expected output [1., 32., 729.] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_example") + + x = np.arange(60).reshape(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = pow(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_pow") + + @staticmethod + def export_pow_broadcast() -> None: + node = onnx.helper.make_node( + "Pow", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([1, 2, 3]).astype(np.float32) + y = np.array(2).astype(np.float32) + z = pow(x, y) # expected output [1., 4., 9.] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_bcast_scalar") + + node = onnx.helper.make_node( + "Pow", + inputs=["x", "y"], + outputs=["z"], + ) + x = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32) + y = np.array([1, 2, 3]).astype(np.float32) + # expected output [[1, 4, 27], [4, 25, 216]] + z = pow(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_pow_bcast_array") + + @staticmethod + def export_types() -> None: + node = onnx.helper.make_node( + "Pow", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([1, 2, 3]).astype(np.float32) + y = np.array([4, 5, 6]).astype(np.int64) + z = pow(x, y) # expected output [1., 32., 729.] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_int64") + + x = np.array([1, 2, 3]).astype(np.int64) + y = np.array([4, 5, 6]).astype(np.float32) + z = pow(x, y) # expected output [1, 32, 729] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int64_float32") + + x = np.array([1, 2, 3]).astype(np.float32) + y = np.array([4, 5, 6]).astype(np.int32) + z = pow(x, y) # expected output [1., 32., 729.] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_int32") + + x = np.array([1, 2, 3]).astype(np.int32) + y = np.array([4, 5, 6]).astype(np.float32) + z = pow(x, y) # expected output [1, 32, 729] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int32_float32") + + x = np.array([1, 2, 3]).astype(np.float32) + y = np.array([4, 5, 6]).astype(np.uint64) + z = pow(x, y) # expected output [1., 32., 729.] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_uint64") + + x = np.array([1, 2, 3]).astype(np.float32) + y = np.array([4, 5, 6]).astype(np.uint32) + z = pow(x, y) # expected output [1., 32., 729.] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_uint32") + + x = np.array([1, 2, 3]).astype(np.int64) + y = np.array([4, 5, 6]).astype(np.int64) + z = pow(x, y) # expected output [1, 32, 729] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int64_int64") + + x = np.array([1, 2, 3]).astype(np.int32) + y = np.array([4, 5, 6]).astype(np.int32) + z = pow(x, y) # expected output [1, 32, 729] + expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int32_int32") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/prelu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/prelu.py new file mode 100644 index 0000000000000000000000000000000000000000..1c7ecfdc7786b6b9a013b3297d11fdf9caeebf12 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/prelu.py @@ -0,0 +1,40 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class PRelu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "PRelu", + inputs=["x", "slope"], + outputs=["y"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + slope = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * slope + + expect(node, inputs=[x, slope], outputs=[y], name="test_prelu_example") + + @staticmethod + def export_prelu_broadcast() -> None: + node = onnx.helper.make_node( + "PRelu", + inputs=["x", "slope"], + outputs=["y"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + slope = np.random.randn(5).astype(np.float32) + y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * slope + + expect(node, inputs=[x, slope], outputs=[y], name="test_prelu_broadcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/qlinearconv.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/qlinearconv.py new file mode 100644 index 0000000000000000000000000000000000000000..8c40facef136dd05be14bb78b5fefa771d3c18fe --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/qlinearconv.py @@ -0,0 +1,82 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class QLinearConv(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "QLinearConv", + inputs=[ + "x", + "x_scale", + "x_zero_point", + "w", + "w_scale", + "w_zero_point", + "y_scale", + "y_zero_point", + ], + outputs=["y"], + ) + + x = np.array( + [ + [255, 174, 162, 25, 203, 168, 58], + [15, 59, 237, 95, 129, 0, 64], + [56, 242, 153, 221, 168, 12, 166], + [232, 178, 186, 195, 237, 162, 237], + [188, 39, 124, 77, 80, 102, 43], + [127, 230, 21, 83, 41, 40, 134], + [255, 154, 92, 141, 42, 148, 247], + ], + dtype=np.uint8, + ).reshape((1, 1, 7, 7)) + + x_scale = np.float32(0.00369204697) + x_zero_point = np.uint8(132) + + w = np.array([0], dtype=np.uint8).reshape((1, 1, 1, 1)) + + w_scale = np.array([0.00172794575], dtype=np.float32) + w_zero_point = np.array([255], dtype=np.uint8) + + y_scale = np.float32(0.00162681262) + y_zero_point = np.uint8(123) + + output = np.array( + [ + [0, 81, 93, 230, 52, 87, 197], + [240, 196, 18, 160, 126, 255, 191], + [199, 13, 102, 34, 87, 243, 89], + [23, 77, 69, 60, 18, 93, 18], + [67, 216, 131, 178, 175, 153, 212], + [128, 25, 234, 172, 214, 215, 121], + [0, 101, 163, 114, 213, 107, 8], + ], + dtype=np.uint8, + ).reshape((1, 1, 7, 7)) + + expect( + node, + inputs=[ + x, + x_scale, + x_zero_point, + w, + w_scale, + w_zero_point, + y_scale, + y_zero_point, + ], + outputs=[output], + name="test_qlinearconv", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/qlinearmatmul.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/qlinearmatmul.py new file mode 100644 index 0000000000000000000000000000000000000000..6a92c1b02627eb9a414e586eee5808714b08ebf0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/qlinearmatmul.py @@ -0,0 +1,149 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class QLinearMatMul(Base): + @staticmethod + def export_int() -> None: + for quant_type_name in ["uint8", "int8"]: + quant_type = getattr(np, quant_type_name) + for dtype_name in ["float32", "float16"]: + dtype = getattr(np, dtype_name) + node = onnx.helper.make_node( + "QLinearMatMul", + inputs=[ + "a", + "a_scale", + "a_zero_point", + "b", + "b_scale", + "b_zero_point", + "y_scale", + "y_zero_point", + ], + outputs=["y"], + ) + + # 2D + a = np.array([[208, 236, 0, 238], [3, 214, 255, 29]]) + if quant_type == np.int8: + a -= 127 + a = a.astype(quant_type) + + a_scale = np.array([0.0066], dtype=dtype) + a_zero_point = np.array( + [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type + ) + + b = np.array( + [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]] + ) + if quant_type == np.int8: + b -= 127 + b = b.astype(quant_type) + + b_scale = np.array([0.00705], dtype=dtype) + b_zero_point = np.array( + [114 - 127] if quant_type == np.int8 else [114], dtype=quant_type + ) + + y_scale = np.array([0.0107], dtype=dtype) + y_zero_point = np.array( + [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type + ) + + if quant_type == np.int8: + output = np.array([[41, -12, -9], [1, -75, -128]]) + else: + output = np.array([[168, 115, 255], [1, 66, 151]]) + output = output.astype(quant_type) + + expect( + node, + inputs=[ + a, + a_scale, + a_zero_point, + b, + b_scale, + b_zero_point, + y_scale, + y_zero_point, + ], + outputs=[output], + name=f"test_qlinearmatmul_2D_{quant_type_name}_{dtype_name}", + ) + + # 3D + a = np.array( + [ + [[208, 236, 0, 238], [3, 214, 255, 29]], + [[208, 236, 0, 238], [3, 214, 255, 29]], + ], + ) + if quant_type == np.int8: + a -= 127 + a = a.astype(quant_type) + + a_scale = np.array([0.0066], dtype=dtype) + a_zero_point = np.array( + [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type + ) + + b = np.array( + [ + [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]], + [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]], + ], + ) + if quant_type == np.int8: + b -= 127 + b = b.astype(quant_type) + + b_scale = np.array([0.00705], dtype=dtype) + b_zero_point = np.array([114], dtype=quant_type) + + y_scale = np.array([0.0107], dtype=dtype) + y_zero_point = np.array( + [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type + ) + + if quant_type == np.int8: + output = np.array( + [ + [[-86, -128, -128], [115, 39, -121]], + [[-86, -128, -128], [115, 39, -121]], + ] + ) + else: + output = np.array( + [ + [[168, 115, 255], [1, 66, 151]], + [[168, 115, 255], [1, 66, 151]], + ] + ) + output = output.astype(quant_type) + + expect( + node, + inputs=[ + a, + a_scale, + a_zero_point, + b, + b_scale, + b_zero_point, + y_scale, + y_zero_point, + ], + outputs=[output], + name=f"test_qlinearmatmul_3D_{quant_type_name}_{dtype_name}", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/quantizelinear.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/quantizelinear.py new file mode 100644 index 0000000000000000000000000000000000000000..9f07b9a376e4d3a7fe791e9e27fcb1152417f20d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/quantizelinear.py @@ -0,0 +1,499 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx import TensorProto +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import make_tensor + + +class QuantizeLinear(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + ) + + x = np.array([0, 2, 3, 1000, -254, -1000]).astype(np.float32) + y_scale = np.float32(2) + y_zero_point = np.uint8(128) + y = np.array([128, 129, 130, 255, 1, 0]).astype(np.uint8) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear", + ) + + @staticmethod + def export_axis() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + ) + + x = np.array( + [ + [ + [[-162, 10], [-100, 232], [-20, -50]], + [[-76, 0], [0, 252], [32, -44]], + [[245, -485], [-960, -270], [-375, -470]], + ], + ], + dtype=np.float32, + ) + y_scale = np.array([2, 4, 5], dtype=np.float32) + y_zero_point = np.array([84, 24, 196], dtype=np.uint8) + y = (x / y_scale.reshape(1, 3, 1, 1) + y_zero_point.reshape(1, 3, 1, 1)).astype( + np.uint8 + ) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_axis", + ) + + @staticmethod + def export_e4m3fn() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + ) + + x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32) + y_scale = np.float32(2) + y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E4M3FN, [1], [0]) + y = make_tensor("y", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, 96]) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_e4m3fn", + ) + + @staticmethod + def export_e5m2() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + ) + + x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32) + y_scale = np.float32(2) + y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E5M2, [1], [0.0]) + y = make_tensor("y", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, 96]) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_e5m2", + ) + + @staticmethod + def export_uint16() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + ) + + x = np.array( + [ + 0.0, + -128.0, + 3.0, + -3.0, + 2.9, + -2.9, + 3.1, + -3.1, + 65536.0, + -65534.0, + 70000.0, + -70000.0, + ] + ).astype(np.float32) + y_scale = np.float32(2.0) + y_zero_point = np.uint16(32767) + y = np.array( + [ + 32767, + 32703, + 32769, + 32765, + 32768, + 32766, + 32769, + 32765, + 65535, + 0, + 65535, + 0, + ] + ).astype(np.uint16) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_uint16", + ) + + @staticmethod + def export_int16() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + ) + + x = np.array( + [ + 0.0, + -514.0, + 3.0, + -3.0, + 2.9, + -2.9, + 3.1, + -3.1, + 65022.0, + -66046.0, + 65023.0, + -66047.0, + 65024.0, + -66048.0, + 70000.0, + -70000.0, + ] + ).astype(np.float32) + y_scale = np.float32(2.0) + y_zero_point = np.int16(256) + y = np.array( + [ + 256, + -1, + 258, + 254, + 257, + 255, + 258, + 254, + 32767, + -32767, + 32767, + -32768, + 32767, + -32768, + 32767, + -32768, + ] + ).astype(np.int16) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_int16", + ) + + @staticmethod + def export_uint4() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + axis=0, + ) + + x = np.array( + [ + [0.0, 2.5, 4.8, 8.6], + [-30, -20, 6, 9], + [12, 15, 16, 40], + ] + ).astype(np.float32) + + y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32) + y_zero_point = make_tensor( + "y_zero_point", TensorProto.UINT4, y_scale.shape, np.ones_like(y_scale) + ) + y = make_tensor( + "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, 0, 0, 3, 4, 4, 5, 5, 11] + ) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_uint4", + ) + + @staticmethod + def export_int4() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + axis=0, + ) + + x = np.array( + [ + [0.0, 2.5, 4.8, 8.6], + [-30, -20, 6, 9], + [12, 15, 16, 40], + ] + ).astype(np.float32) + + y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32) + y_zero_point = make_tensor( + "y_zero_point", TensorProto.INT4, y_scale.shape, np.ones_like(y_scale) + ) + y = make_tensor( + "y", TensorProto.INT4, x.shape, [1, 2, 3, 5, -8, -6, 3, 4, 4, 5, 5, 7] + ) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_int4", + ) + + @staticmethod + def export_uint2() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + axis=0, + ) + + x = np.array( + [ + [0.0, 2.5, 4.8, 8.6], + [-2.0, -1.0, 1.0, 3.0], + [4.0, 5.0, 6.0, 7.0], + ], + dtype=np.float32, + ) + y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32) + y_zero_point = make_tensor( + "y_zero_point", TensorProto.UINT2, y_scale.shape, np.zeros_like(y_scale) + ) + y = make_tensor( + "y", TensorProto.UINT2, x.shape, [0, 1, 2, 3, 0, 0, 0, 1, 1, 1, 2, 2] + ) + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_uint2", + ) + + @staticmethod + def export_int2() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + axis=0, + ) + x = np.array( + [ + [0.0, 2.5, 4.8, 8.6], + [-4.0, -3.0, 1.0, 2.0], + [-0.0, -2.5, -4.8, -8.6], + ], + dtype=np.float32, + ) + y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32) + y_zero_point = make_tensor( + "y_zero_point", TensorProto.INT2, y_scale.shape, np.zeros_like(y_scale) + ) + y = make_tensor( + "y", TensorProto.INT2, x.shape, [0, 1, 1, 1, -1, -1, 0, 1, 0, -1, -1, -2] + ) + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_int2", + ) + + @staticmethod + def export_float4e2m1() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + axis=0, + ) + + x = np.array( + [ + [0.0, 2.5, 4.8, 8.6], + [-30, -20, 6, 9], + [-0.0, -2.5, -4.8, -8.6], + ] + ).astype(np.float32) + + y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32) + y_zero_point = make_tensor( + "y_zero_point", + TensorProto.FLOAT4E2M1, + y_scale.shape, + np.zeros_like(y_scale), + ) + y = make_tensor( + "y", + TensorProto.FLOAT4E2M1, + x.shape, + [0, 1, 2, 4, -6, -6, 2, 3, 0, -0.5, -1, -2], + ) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_float4e2m1", + ) + + @staticmethod + def export_blocked_asymmetric() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale", "y_zero_point"], + outputs=["y"], + axis=1, + block_size=2, + ) + + x = np.array( + [ + [6.0, 12.0, 50.0, 5.0], + [1.0, 8.0, 4.0, 5.0], + [0.0, 20.0, 10.0, 4.0], + ], + dtype=np.float32, + ) + y_scale = np.array( + [ + [1.5, 2.5], + [3.0, 4.9], + [5.1, 6.9], + ], + dtype=np.float32, + ) + y_zero_point = np.array( + [ + [0, 1], + [1, 0], + [2, 3], + ], + dtype=np.uint8, + ) + # x.shape = (3, 4) + # y_scale.shape = (3, 2) + assert y_scale.shape == y_zero_point.shape + block_axis = 1 + # The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2) + assert all( + x.shape[i] == y_scale.shape[i] + for i in range(len(x.shape)) + if i != block_axis + ) + assert x.shape[block_axis] % y_scale.shape[block_axis] == 0 + repeats = x.shape[block_axis] // y_scale.shape[block_axis] + + # Create element-wise scale and zero point + y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis) + y_zero_point_elementwise = np.repeat( + y_zero_point, repeats=repeats, axis=block_axis + ) + + y = np.rint(x / y_scale_elementwise + y_zero_point_elementwise).astype(np.uint8) + + expect( + node, + inputs=[x, y_scale, y_zero_point], + outputs=[y], + name="test_quantizelinear_blocked_asymmetric", + ) + + @staticmethod + def export_blocked_symmetric() -> None: + node = onnx.helper.make_node( + "QuantizeLinear", + inputs=["x", "y_scale"], + outputs=["y"], + axis=1, + block_size=2, + output_dtype=TensorProto.INT16, + ) + + x = np.array( + [ + [6.0, -8, -10, 5.0], + [1.0, 8.0, 4.0, 5.0], + [0.0, 20.0, 10.0, 4.0], + ], + dtype=np.float32, + ) + + y_scale = np.array( + [ + [1.5, 2.5], + [3.0, 4.9], + [5.1, 6.9], + ], + dtype=np.float32, + ) + + # x.shape = (3, 4) + # y_scale.shape = (3, 2) + + block_axis = 1 + # The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2) + assert all( + x.shape[i] == y_scale.shape[i] + for i in range(len(x.shape)) + if i != block_axis + ) + assert x.shape[block_axis] % y_scale.shape[block_axis] == 0 + repeats = x.shape[block_axis] // y_scale.shape[block_axis] + + # Create element-wise scale and zero point + y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis) + + y_val = np.clip( + np.rint(x / y_scale_elementwise), a_min=-32768, a_max=32767 + ).astype(np.int16) + y = make_tensor( + "y", + TensorProto.INT16, + x.shape, + y_val, + ) + expect( + node, + inputs=[x, y_scale], + outputs=[y], + name="test_quantizelinear_blocked_symmetric", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rangeop.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rangeop.py new file mode 100644 index 0000000000000000000000000000000000000000..88d005fb480e13a59934acff54d78f0fa6ac740e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rangeop.py @@ -0,0 +1,102 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import ml_dtypes +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Range(Base): + @staticmethod + def export_range_float_type_positive_delta() -> None: + node = onnx.helper.make_node( + "Range", + inputs=["start", "limit", "delta"], + outputs=["output"], + ) + + start = np.float32(1) + limit = np.float32(5) + delta = np.float32(2) + + output = np.arange( + start, limit, delta, dtype=np.float32 + ) # expected output [1.0, 3.0] + expect( + node, + inputs=[start, limit, delta], + outputs=[output], + name="test_range_float_type_positive_delta", + ) + + @staticmethod + def export_range_float16_type_positive_delta() -> None: + node = onnx.helper.make_node( + "Range", + inputs=["start", "limit", "delta"], + outputs=["output"], + ) + + start = np.float16(1) + limit = np.float16(5) + delta = np.float16(2) + + output = np.arange( + start, limit, delta, dtype=np.float16 + ) # expected output [1.0, 3.0] + expect( + node, + inputs=[start, limit, delta], + outputs=[output], + name="test_range_float16_type_positive_delta", + ) + + @staticmethod + def export_range_bfloat16_type_positive_delta() -> None: + node = onnx.helper.make_node( + "Range", + inputs=["start", "limit", "delta"], + outputs=["output"], + ) + + start = np.array(1.0, dtype=ml_dtypes.bfloat16) + limit = np.array(5.0, dtype=ml_dtypes.bfloat16) + delta = np.array(2.0, dtype=ml_dtypes.bfloat16) + + output = np.arange(1.0, 5.0, 2.0, dtype=np.float32).astype( + ml_dtypes.bfloat16 + ) # expected output [1.0, 3.0] as bfloat16 + + expect( + node, + inputs=[start, limit, delta], + outputs=[output], + name="test_range_bfloat16_type_positive_delta", + ) + + @staticmethod + def export_range_int32_type_negative_delta() -> None: + node = onnx.helper.make_node( + "Range", + inputs=["start", "limit", "delta"], + outputs=["output"], + ) + + start = np.int32(10) + limit = np.int32(6) + delta = np.int32(-3) + + output = np.arange( + start, limit, delta, dtype=np.int32 + ) # expected output [10, 7] + expect( + node, + inputs=[start, limit, delta], + outputs=[output], + name="test_range_int32_type_negative_delta", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reciprocal.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reciprocal.py new file mode 100644 index 0000000000000000000000000000000000000000..eea8f2cf5226f1fb500d89e40b56b26783ab8149 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reciprocal.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Reciprocal(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Reciprocal", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-4, 2]).astype(np.float32) + y = np.reciprocal(x) # expected output [-0.25, 0.5], + expect(node, inputs=[x], outputs=[y], name="test_reciprocal_example") + + x = np.random.rand(3, 4, 5).astype(np.float32) + 0.5 + y = np.reciprocal(x) + expect(node, inputs=[x], outputs=[y], name="test_reciprocal") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduce_log_sum.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduce_log_sum.py new file mode 100644 index 0000000000000000000000000000000000000000..8a99f71375fe6088f7caf1c843001d8f6f23ac13 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduce_log_sum.py @@ -0,0 +1,104 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceLogSum(Base): + @staticmethod + def export_nokeepdims() -> None: + shape = [3, 4, 5] + axes = np.array([2, 1], dtype=np.int64) + + node = onnx.helper.make_node( + "ReduceLogSum", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=0, + ) + data = np.random.ranf(shape).astype(np.float32) + reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=False)) + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_desc_axes", + ) + + axes = np.array([0, 1], dtype=np.int64) + node = onnx.helper.make_node( + "ReduceLogSum", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=0, + ) + data = np.random.ranf(shape).astype(np.float32) + reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=False)) + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_asc_axes", + ) + + @staticmethod + def export_keepdims() -> None: + node = onnx.helper.make_node( + "ReduceLogSum", inputs=["data", "axes"], outputs=["reduced"] + ) + data = np.random.ranf([3, 4, 5]).astype(np.float32) + reduced = np.log(np.sum(data, keepdims=True)) + axes = np.array([], dtype=np.int64) + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_default", + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + axes = np.array([-2], dtype=np.int64) + node = onnx.helper.make_node( + "ReduceLogSum", inputs=["data", "axes"], outputs=["reduced"] + ) + data = np.random.ranf([3, 4, 5]).astype(np.float32) + reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=True)) + # print(reduced) + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_negative_axes", + ) + + @staticmethod + def export_empty_set() -> None: + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceLogSum", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + zero = np.array(np.zeros(reduced_shape, dtype=np.float32)) + reduced = np.log(zero) # -inf + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_empty_set", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduce_log_sum_exp.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduce_log_sum_exp.py new file mode 100644 index 0000000000000000000000000000000000000000..30f7b5225635ec7f9a5bb802f2f7390df9b72f50 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduce_log_sum_exp.py @@ -0,0 +1,193 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceLogSumExp(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 0 + node = onnx.helper.make_node( + "ReduceLogSumExp", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double + ) + reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1)) + # print(reduced) + # [[20., 2.31326175] + # [40.00004578, 2.31326175] + # [60.00671387, 2.31326175]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_do_not_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.double) + reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1)) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_do_not_keepdims_random", + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 1 + node = onnx.helper.make_node( + "ReduceLogSumExp", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double + ) + reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1)) + # print(reduced) + # [[[20., 2.31326175]] + # [[40.00004578, 2.31326175]] + # [[60.00671387, 2.31326175]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.double) + reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1)) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_keepdims_random", + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceLogSumExp", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double + ) + reduced = np.log(np.sum(np.exp(data), axis=None, keepdims=keepdims == 1)) + # print(reduced) + # [[[60.00671387]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_default_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.double) + reduced = np.log(np.sum(np.exp(data), axis=None, keepdims=keepdims == 1)) + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_default_axes_keepdims_random", + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-2], dtype=np.int64) + keepdims = 1 + node = onnx.helper.make_node( + "ReduceLogSumExp", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double + ) + reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1)) + # print(reduced) + # [[[20., 2.31326175]] + # [[40.00004578, 2.31326175]] + # [[60.00671387, 2.31326175]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_negative_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.double) + reduced = np.log( + np.sum(np.exp(data), axis=tuple(axes.tolist()), keepdims=keepdims == 1) + ) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_negative_axes_keepdims_random", + ) + + @staticmethod + def export_empty_set() -> None: + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceLogSumExp", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + zero = np.array(np.zeros(reduced_shape, dtype=np.float32)) + reduced = np.log(zero) # -inf + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_log_sum_exp_empty_set", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducel1.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducel1.py new file mode 100644 index 0000000000000000000000000000000000000000..711c8b0000f550859c6e4dd54546a7af5dcb2fd3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducel1.py @@ -0,0 +1,189 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceL1(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([2], dtype=np.int64) + keepdims = 0 + + node = onnx.helper.make_node( + "ReduceL1", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]] + + reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[3., 7.], [11., 15.], [19., 23.]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_do_not_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_do_not_keepdims_random", + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([2], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceL1", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]] + + reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_keep_dims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_keep_dims_random", + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceL1", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]] + + reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1) + # print(reduced) + # [[[78.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_default_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_default_axes_keepdims_random", + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceL1", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]] + + reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_negative_axes_keep_dims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_negative_axes_keep_dims_random", + ) + + @staticmethod + def export_empty_set() -> None: + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceL1", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + reduced = np.array(np.zeros(reduced_shape, dtype=np.float32)) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l1_empty_set", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducel2.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducel2.py new file mode 100644 index 0000000000000000000000000000000000000000..9b440cc21e78c0ce500cf9e5c81be0dd40bb5712 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducel2.py @@ -0,0 +1,207 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceL2(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([2], dtype=np.int64) + keepdims = 0 + + node = onnx.helper.make_node( + "ReduceL2", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]] + + reduced = np.sqrt( + np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + ) + # print(reduced) + # [[2.23606798, 5.], + # [7.81024968, 10.63014581], + # [13.45362405, 16.2788206]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_do_not_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sqrt( + np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + ) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_do_not_keepdims_random", + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([2], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceL2", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]] + + reduced = np.sqrt( + np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + ) + # print(reduced) + # [[[2.23606798], [5.]] + # [[7.81024968], [10.63014581]] + # [[13.45362405], [16.2788206 ]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_keep_dims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sqrt( + np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + ) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_keep_dims_random", + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceL2", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]] + + reduced = np.sqrt(np.sum(a=np.square(data), axis=None, keepdims=keepdims == 1)) + # print(reduced) + # [[[25.49509757]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_default_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sqrt(np.sum(a=np.square(data), axis=None, keepdims=keepdims == 1)) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_default_axes_keepdims_random", + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceL2", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]] + + reduced = np.sqrt( + np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + ) + # print(reduced) + # [[[2.23606798], [5.]] + # [[7.81024968], [10.63014581]] + # [[13.45362405], [16.2788206 ]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_negative_axes_keep_dims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sqrt( + np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + ) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_negative_axes_keep_dims_random", + ) + + @staticmethod + def export_empty_set() -> None: + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceL2", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + reduced = np.array(np.zeros(reduced_shape, dtype=np.float32)) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_l2_empty_set", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemax.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemax.py new file mode 100644 index 0000000000000000000000000000000000000000..5da9d4894dff9f5755e87dfc6158f3913e5e8a0e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemax.py @@ -0,0 +1,231 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceMax(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 0 + + node = onnx.helper.make_node( + "ReduceMax", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[20., 2.] + # [40., 2.] + # [60., 2.]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_max_do_not_keepdims_example", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_max_do_not_keepdims_random", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMax", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[20., 2.]] + # [[40., 2.]] + # [[60., 2.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_max_keepdims_example", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_max_keepdims_random", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = None + keepdims = 1 + node = onnx.helper.make_node( + "ReduceMax", inputs=["data"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1) + + expect( + node, + inputs=[data], + outputs=[reduced], + name="test_reduce_max_default_axes_keepdim_example", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1) + + expect( + node, + inputs=[data], + outputs=[reduced], + name="test_reduce_max_default_axes_keepdims_random", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-2], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMax", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[20., 2.]] + # [[40., 2.]] + # [[60., 2.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_max_negative_axes_keepdims_example", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_max_negative_axes_keepdims_random", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + @staticmethod + def export_bool_inputs() -> None: + axes = np.array([1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMax", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[True, True], [True, False], [False, True], [False, False]], + ) + reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=bool(keepdims)) + # print(reduced) + # [[True], + # [True], + # [True], + # [False]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_max_bool_inputs", + ) + + @staticmethod + def export_empty_set() -> None: + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceMax", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + one = np.array(np.ones(reduced_shape, dtype=np.float32)) + zero = np.array(np.zeros(reduced_shape, dtype=np.float32)) + reduced = -(one / zero) # -inf + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_max_empty_set", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemean.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemean.py new file mode 100644 index 0000000000000000000000000000000000000000..fbd68c6972b1949144e5e71cabd0840876825f85 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemean.py @@ -0,0 +1,174 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceMean(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 0 + + node = onnx.helper.make_node( + "ReduceMean", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[12.5, 1.5] + # [35., 1.5] + # [57.5, 1.5]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_mean_do_not_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_mean_do_not_keepdims_random", + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMean", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[12.5, 1.5]] + # [[35., 1.5]] + # [[57.5, 1.5]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_mean_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_mean_keepdims_random", + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMean", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.mean(data, axis=None, keepdims=keepdims == 1) + # print(reduced) + # [[[18.25]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_mean_default_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.mean(data, axis=None, keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_mean_default_axes_keepdims_random", + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-2], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMean", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[12.5, 1.5]] + # [[35., 1.5]] + # [[57.5, 1.5]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_mean_negative_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_mean_negative_axes_keepdims_random", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemin.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemin.py new file mode 100644 index 0000000000000000000000000000000000000000..7bbc37a06a246f5b800ba05761b40e34582cff68 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducemin.py @@ -0,0 +1,234 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceMin(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 0 + + node = onnx.helper.make_node( + "ReduceMin", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[5., 1.] + # [30., 1.] + # [55., 1.]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_min_do_not_keepdims_example", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_min_do_not_keepdims_random", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMin", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[5., 1.]] + # [[30., 1.]] + # [[55., 1.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_min_keepdims_example", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_min_keepdims_random", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = None + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMin", inputs=["data"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1) + # print(reduced) + # [[[1.]]] + + expect( + node, + inputs=[data], + outputs=[reduced], + name="test_reduce_min_default_axes_keepdims_example", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1) + + expect( + node, + inputs=[data], + outputs=[reduced], + name="test_reduce_min_default_axes_keepdims_random", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-2], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMin", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], + dtype=np.float32, + ) + reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[5., 1.]] + # [[30., 1.]] + # [[55., 1.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_min_negative_axes_keepdims_example", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_min_negative_axes_keepdims_random", + opset_imports=[onnx.helper.make_opsetid("", 18)], + ) + + @staticmethod + def export_bool_inputs() -> None: + axes = np.array([1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceMin", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[True, True], [True, False], [False, True], [False, False]], + ) + reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=bool(keepdims)) + # print(reduced) + # [[ True], + # [False], + # [False], + # [False]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_min_bool_inputs", + ) + + @staticmethod + def export_empty_set() -> None: + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceMin", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + one = np.array(np.ones(reduced_shape, dtype=np.float32)) + zero = np.array(np.zeros(reduced_shape, dtype=np.float32)) + reduced = one / zero # inf + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_min_empty_set", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduceprod.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduceprod.py new file mode 100644 index 0000000000000000000000000000000000000000..079c19af1211c59acfa48f7634f2edf8cfc2de2f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reduceprod.py @@ -0,0 +1,187 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceProd(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 0 + + node = onnx.helper.make_node( + "ReduceProd", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[3., 8.] + # [35., 48.] + # [99., 120.]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_prod_do_not_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1) + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_prod_do_not_keepdims_random", + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceProd", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[3., 8.]] + # [[35., 48.]] + # [[99., 120.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_prod_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1) + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_prod_keepdims_random", + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = None + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceProd", inputs=["data"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.prod(data, axis=axes, keepdims=keepdims == 1) + # print(reduced) + # [[[4.790016e+08]]] + + expect( + node, + inputs=[data], + outputs=[reduced], + name="test_reduce_prod_default_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.prod(data, axis=axes, keepdims=keepdims == 1) + expect( + node, + inputs=[data], + outputs=[reduced], + name="test_reduce_prod_default_axes_keepdims_random", + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-2], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceProd", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[3., 8.]] + # [[35., 48.]] + # [[99., 120.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_prod_negative_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1) + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_prod_negative_axes_keepdims_random", + ) + + @staticmethod + def export_empty_set() -> None: + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceProd", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + reduced = np.array(np.ones(reduced_shape, dtype=np.float32)) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_prod_empty_set", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducesum.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducesum.py new file mode 100644 index 0000000000000000000000000000000000000000..e311b2c88d77e42da0598d8696f0c05fb2f22bb0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducesum.py @@ -0,0 +1,247 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceSum(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 0 + + node = onnx.helper.make_node( + "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1) + # print(reduced) + # [[4., 6.] + # [12., 14.] + # [20., 22.]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_do_not_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_do_not_keepdims_random", + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1) + # print(reduced) + # [[[4., 6.]] + # [[12., 14.]] + # [[20., 22.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_keepdims_random", + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.sum(data, axis=None, keepdims=keepdims == 1) + # print(reduced) + # [[[78.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_default_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(data, axis=None, keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_default_axes_keepdims_random", + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-2], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1) + # print(reduced) + # [[[4., 6.]] + # [[12., 14.]] + # [[20., 22.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_negative_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_negative_axes_keepdims_random", + ) + + @staticmethod + def export_empty_axes_input_noop() -> None: + shape = [3, 2, 2] + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceSum", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + noop_with_empty_axes=True, + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + axes = np.array([], dtype=np.int64) + reduced = np.array(data) + # print(reduced) + # [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_empty_axes_input_noop_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.array(data) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_empty_axes_input_noop", + ) + + @staticmethod + def export_empty_set() -> None: + """Test case with the reduced-axis of size zero.""" + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceSum", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + reduced = np.array(np.zeros(reduced_shape, dtype=np.float32)) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_empty_set", + ) + + @staticmethod + def export_non_reduced_axis_zero() -> None: + """Test case with the non-reduced-axis of size zero.""" + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 0, 1] + + node = onnx.helper.make_node( + "ReduceSum", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([2], dtype=np.int64) + reduced = np.array([], dtype=np.float32).reshape(reduced_shape) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_empty_set_non_reduced_axis_zero", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducesumsquare.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducesumsquare.py new file mode 100644 index 0000000000000000000000000000000000000000..a6c31287702c5fe5899673302ac384ed892e7dc5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reducesumsquare.py @@ -0,0 +1,194 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReduceSumSquare(Base): + @staticmethod + def export_do_not_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 0 + + node = onnx.helper.make_node( + "ReduceSumSquare", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[10., 20.] + # [74., 100.] + # [202., 244.]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_do_not_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_do_not_keepdims_random", + ) + + @staticmethod + def export_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([1], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceSumSquare", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[10., 20.]] + # [[74., 100.]] + # [[202., 244.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_keepdims_random", + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceSumSquare", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.sum(np.square(data), axis=None, keepdims=keepdims == 1) + # print(reduced) + # [[[650.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_default_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(np.square(data), axis=None, keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_default_axes_keepdims_random", + ) + + @staticmethod + def export_negative_axes_keepdims() -> None: + shape = [3, 2, 2] + axes = np.array([-2], dtype=np.int64) + keepdims = 1 + + node = onnx.helper.make_node( + "ReduceSumSquare", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32 + ) + reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + # print(reduced) + # [[[10., 20.s]] + # [[74., 100.]] + # [[202., 244.]]] + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_negative_axes_keepdims_example", + ) + + np.random.seed(0) + data = np.random.uniform(-10, 10, shape).astype(np.float32) + reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_negative_axes_keepdims_random", + ) + + @staticmethod + def export_empty_set() -> None: + shape = [2, 0, 4] + keepdims = 1 + reduced_shape = [2, 1, 4] + + node = onnx.helper.make_node( + "ReduceSumSquare", + inputs=["data", "axes"], + outputs=["reduced"], + keepdims=keepdims, + ) + + data = np.array([], dtype=np.float32).reshape(shape) + axes = np.array([1], dtype=np.int64) + reduced = np.array(np.zeros(reduced_shape, dtype=np.float32)) + + expect( + node, + inputs=[data, axes], + outputs=[reduced], + name="test_reduce_sum_square_empty_set", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/regex_full_match.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/regex_full_match.py new file mode 100644 index 0000000000000000000000000000000000000000..3fd7a905054902e444b300bc758d39ff3094c970 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/regex_full_match.py @@ -0,0 +1,68 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class RegexFullMatch(Base): + @staticmethod + def export_basic() -> None: + node = onnx.helper.make_node( + "RegexFullMatch", + inputs=["X"], + outputs=["Y"], + pattern=r"www\.[\w.-]+\.\bcom\b", + ) + + x = np.array(["www.google.com", "www.facebook.com", "www.bbc.co.uk"]).astype( + object + ) + result = np.array([True, True, False]) + expect(node, inputs=[x], outputs=[result], name="test_regex_full_match_basic") + + @staticmethod + def export_match_email_domain() -> None: + node = onnx.helper.make_node( + "RegexFullMatch", + inputs=["X"], + outputs=["Y"], + pattern=r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)", + ) + + x = np.array( + [ + ["account@gmail.com", "account@hotmail.com"], + ["not email", "account2@yahoo.com"], + ] + ).astype(object) + result = np.array([[True, False], [False, True]]) + expect( + node, + inputs=[x], + outputs=[result], + name="test_regex_full_match_email_domain", + ) + + @staticmethod + def export_match_empty() -> None: + node = onnx.helper.make_node( + "RegexFullMatch", + inputs=["X"], + outputs=["Y"], + pattern=r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)", + ) + + x = np.array([[], []]).astype(object) + result = np.array([[], []]).astype(bool) + expect( + node, + inputs=[x], + outputs=[result], + name="test_regex_full_match_empty", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/relu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/relu.py new file mode 100644 index 0000000000000000000000000000000000000000..3fbb181fe325ddf8fa474f39f1329d6320982301 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/relu.py @@ -0,0 +1,24 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Relu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Relu", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + + expect(node, inputs=[x], outputs=[y], name="test_relu") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reshape.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reshape.py new file mode 100644 index 0000000000000000000000000000000000000000..2c369ef786d4da07da0eeb0a4636d61a7a6d1924 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reshape.py @@ -0,0 +1,82 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def reshape_reference_implementation( + data: np.ndarray, shape: np.ndarray, allowzero: int = 0 +) -> np.ndarray: + # replace zeros with corresponding dim size + # we need to do this because np.reshape doesn't support 0 by default unless 'allowzero' is set + new_shape = np.copy(shape) + if allowzero == 0: + zeros_index = np.where(shape == 0) + new_shape[zeros_index] = np.array(data.shape)[zeros_index] + return np.reshape(data, new_shape) + + +class Reshape(Base): + @staticmethod + def export_reshape() -> None: + original_shape = [2, 3, 4] + test_cases = { + "reordered_all_dims": np.array([4, 2, 3], dtype=np.int64), + "reordered_last_dims": np.array([2, 4, 3], dtype=np.int64), + "reduced_dims": np.array([2, 12], dtype=np.int64), + "extended_dims": np.array([2, 3, 2, 2], dtype=np.int64), + "one_dim": np.array([24], dtype=np.int64), + "negative_dim": np.array([2, -1, 2], dtype=np.int64), + "negative_extended_dims": np.array([-1, 2, 3, 4], dtype=np.int64), + "zero_dim": np.array([2, 0, 4, 1], dtype=np.int64), + "zero_and_negative_dim": np.array([2, 0, 1, -1], dtype=np.int64), + } + data = np.random.random_sample(original_shape).astype(np.float32) + + for test_name, shape in test_cases.items(): + node = onnx.helper.make_node( + "Reshape", + inputs=["data", "shape"], + outputs=["reshaped"], + ) + + reshaped = reshape_reference_implementation(data, shape) + + expect( + node, + inputs=[data, shape], + outputs=[reshaped], + name="test_reshape_" + test_name, + ) + + @staticmethod + def export_allowzero() -> None: + original_shape = [0, 3, 4] + test_cases = { + "allowzero_reordered": np.array([3, 4, 0], dtype=np.int64), + } + data = np.random.random_sample(original_shape).astype(np.float32) + + for test_name, shape in test_cases.items(): + node = onnx.helper.make_node( + "Reshape", + inputs=["data", "shape"], + outputs=["reshaped"], + allowzero=1, # if allowzero=1, final shape = (3, 4, 0) + # if allowzero=0, final shape = (3, 4, 4) + ) + + reshaped = reshape_reference_implementation(data, shape, allowzero=1) + + expect( + node, + inputs=[data, shape], + outputs=[reshaped], + name="test_reshape_" + test_name, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/resize.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/resize.py new file mode 100644 index 0000000000000000000000000000000000000000..ac31ea4bb42cfffc6254e33ffd6720c8b228e958 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/resize.py @@ -0,0 +1,1714 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_resize import _cubic_coeffs as cubic_coeffs +from onnx.reference.ops.op_resize import ( + _cubic_coeffs_antialias as cubic_coeffs_antialias, +) +from onnx.reference.ops.op_resize import _interpolate_nd as interpolate_nd +from onnx.reference.ops.op_resize import _linear_coeffs as linear_coeffs +from onnx.reference.ops.op_resize import ( + _linear_coeffs_antialias as linear_coeffs_antialias, +) +from onnx.reference.ops.op_resize import _nearest_coeffs as nearest_coeffs + + +class Resize(Base): + @staticmethod + def export_resize_upsample_scales_nearest() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="nearest", + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32) + + # [[[[1. 1. 1. 2. 2. 2.] + # [1. 1. 1. 2. 2. 2.] + # [3. 3. 3. 4. 4. 4.] + # [3. 3. 3. 4. 4. 4.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x), scale_factors=scales + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_nearest", + ) + + @staticmethod + def export_resize_downsample_scales_nearest() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="nearest", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32) + + # [[[[1. 3.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x), scale_factors=scales + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_nearest", + ) + + @staticmethod + def export_resize_upsample_sizes_nearest() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 7, 8], dtype=np.int64) + + # [[[[1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [3. 3. 3. 3. 4. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4. 4.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x), output_size=sizes + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_nearest", + ) + + @staticmethod + def export_resize_downsample_sizes_nearest() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 1, 3], dtype=np.int64) + + # [[[[1. 2. 4.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x), output_size=sizes + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_downsample_sizes_nearest", + ) + + @staticmethod + def export_resize_upsample_scales_linear() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="linear", + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) + + # [[[[1. 1.25 1.75 2. ] + # [1.5 1.75 2.25 2.5 ] + # [2.5 2.75 3.25 3.5 ] + # [3. 3.25 3.75 4. ]]]] + output = interpolate_nd( + data, lambda x, _: linear_coeffs(x), scale_factors=scales + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_linear", + ) + + @staticmethod + def export_resize_upsample_scales_linear_align_corners() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="align_corners", + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) + + # [[[[1. 1.33333333 1.66666667 2. ] + # [1.66666667 2. 2.33333333 2.66666667] + # [2.33333333 2.66666667 3. 3.33333333] + # [3. 3.33333333 3.66666667 4. ]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + scale_factors=scales, + coordinate_transformation_mode="align_corners", + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_linear_align_corners", + ) + + @staticmethod + def export_resize_downsample_scales_linear() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="linear", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32) + + # [[[[2.6666665 4.3333331]]]] + output = interpolate_nd( + data, lambda x, _: linear_coeffs(x), scale_factors=scales + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_linear", + ) + + @staticmethod + def export_resize_downsample_scales_linear_align_corners() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="align_corners", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32) + + # [[[[1. 3.142857]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + scale_factors=scales, + coordinate_transformation_mode="align_corners", + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_linear_align_corners", + ) + + @staticmethod + def export_resize_upsample_scales_cubic() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="cubic", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) + + # [[[[ 0.47265625 0.76953125 1.24609375 1.875 2.28125 + # 2.91015625 3.38671875 3.68359375] + # [ 1.66015625 1.95703125 2.43359375 3.0625 3.46875 + # 4.09765625 4.57421875 4.87109375] + # [ 3.56640625 3.86328125 4.33984375 4.96875 5.375 + # 6.00390625 6.48046875 6.77734375] + # [ 6.08203125 6.37890625 6.85546875 7.484375 7.890625 + # 8.51953125 8.99609375 9.29296875] + # [ 7.70703125 8.00390625 8.48046875 9.109375 9.515625 + # 10.14453125 10.62109375 10.91796875] + # [10.22265625 10.51953125 10.99609375 11.625 12.03125 + # 12.66015625 13.13671875 13.43359375] + # [12.12890625 12.42578125 12.90234375 13.53125 13.9375 + # 14.56640625 15.04296875 15.33984375] + # [13.31640625 13.61328125 14.08984375 14.71875 15.125 + # 15.75390625 16.23046875 16.52734375]]]] + output = interpolate_nd( + data, lambda x, _: cubic_coeffs(x), scale_factors=scales + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_cubic", + ) + + @staticmethod + def export_resize_upsample_scales_cubic_align_corners() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="cubic", + coordinate_transformation_mode="align_corners", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) + + # [[[[ 1. 1.34110787 1.80029155 2.32944606 2.67055394 + # 3.19970845 3.65889213 4. ] + # [ 2.36443149 2.70553936 3.16472303 3.69387755 4.03498542 + # 4.56413994 5.02332362 5.36443149] + # [ 4.20116618 4.54227405 5.00145773 5.53061224 5.87172012 + # 6.40087464 6.86005831 7.20116618] + # [ 6.31778426 6.65889213 7.1180758 7.64723032 7.98833819 + # 8.51749271 8.97667638 9.31778426] + # [ 7.68221574 8.02332362 8.48250729 9.01166181 9.35276968 + # 9.8819242 10.34110787 10.68221574] + # [ 9.79883382 10.13994169 10.59912536 11.12827988 11.46938776 + # 11.99854227 12.45772595 12.79883382] + # [11.63556851 11.97667638 12.43586006 12.96501458 13.30612245 + # 13.83527697 14.29446064 14.63556851] + # [13. 13.34110787 13.80029155 14.32944606 14.67055394 + # 15.19970845 15.65889213 16. ]]]] + output = interpolate_nd( + data, + lambda x, _: cubic_coeffs(x), + scale_factors=scales, + coordinate_transformation_mode="align_corners", + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_cubic_align_corners", + ) + + @staticmethod + def export_resize_downsample_scales_cubic() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="cubic", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32) + + # [[[[ 1.47119141 2.78125 4.08251953] + # [ 6.71142578 8.02148438 9.32275391] + # [11.91650391 13.2265625 14.52783203]]]] + output = interpolate_nd( + data, lambda x, _: cubic_coeffs(x), scale_factors=scales + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_cubic", + ) + + @staticmethod + def export_resize_downsample_scales_cubic_align_corners() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="cubic", + coordinate_transformation_mode="align_corners", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32) + + # [[[[ 1. 2.39519159 3.79038317] + # [ 6.58076634 7.97595793 9.37114951] + # [12.16153268 13.55672427 14.95191585]]]] + output = interpolate_nd( + data, + lambda x, _: cubic_coeffs(x), + scale_factors=scales, + coordinate_transformation_mode="align_corners", + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_cubic_align_corners", + ) + + @staticmethod + def export_resize_upsample_sizes_cubic() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="cubic", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 9, 10], dtype=np.int64) + + # [[[[ 0.45507922 0.64057922 0.97157922 1.42257922 1.90732922 + # 2.22332922 2.70807922 3.15907922 3.49007922 3.67557922] + # [ 1.39437963 1.57987963 1.91087963 2.36187963 2.84662963 + # 3.16262963 3.64737963 4.09837963 4.42937963 4.61487963] + # [ 2.95130693 3.13680693 3.46780693 3.91880693 4.40355693 + # 4.71955693 5.20430693 5.65530693 5.98630693 6.17180693] + # [ 5.20525069 5.39075069 5.72175069 6.17275069 6.65750069 + # 6.97350069 7.45825069 7.90925069 8.24025069 8.42575069] + # [ 6.88975 7.07525 7.40625 7.85725 8.342 + # 8.658 9.14275 9.59375 9.92475 10.11025 ] + # [ 8.57424931 8.75974931 9.09074931 9.54174931 10.02649931 + # 10.34249931 10.82724931 11.27824931 11.60924931 11.79474931] + # [10.82819307 11.01369307 11.34469307 11.79569307 12.28044307 + # 12.59644307 13.08119307 13.53219307 13.86319307 14.04869307] + # [12.38512037 12.57062037 12.90162037 13.35262037 13.83737037 + # 14.15337037 14.63812037 15.08912037 15.42012037 15.60562037] + # [13.32442078 13.50992078 13.84092078 14.29192078 14.77667078 + # 15.09267078 15.57742078 16.02842078 16.35942078 16.54492078]]]] + output = interpolate_nd( + data, lambda x, _: cubic_coeffs(x), output_size=sizes + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_cubic", + ) + + @staticmethod + def export_resize_downsample_sizes_cubic() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="cubic", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 3, 3], dtype=np.int64) + + # [[[[ 1.63078704 3.00462963 4.37847222] + # [ 7.12615741 8.5 9.87384259] + # [12.62152778 13.99537037 15.36921296]]]] + output = interpolate_nd( + data, lambda x, _: cubic_coeffs(x), output_size=sizes + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_downsample_sizes_cubic", + ) + + # TensorFlow v1 bicubic with half_pixel_centers=True + @staticmethod + def export_resize_upsample_scales_cubic_A_n0p5_exclude_outside() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="cubic", + cubic_coeff_a=-0.5, + exclude_outside=True, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) + + # [[[[ 0.55882353 0.81494204 1.35698249 1.89705882 2.39705882 + # 2.93713516 3.47917561 3.73529412] + # [ 1.58329755 1.83941606 2.38145651 2.92153285 3.42153285 + # 3.96160918 4.50364964 4.75976814] + # [ 3.75145936 4.00757787 4.54961832 5.08969466 5.58969466 + # 6.12977099 6.67181144 6.92792995] + # [ 5.91176471 6.16788321 6.70992366 7.25 7.75 + # 8.29007634 8.83211679 9.08823529] + # [ 7.91176471 8.16788321 8.70992366 9.25 9.75 + # 10.29007634 10.83211679 11.08823529] + # [10.07207005 10.32818856 10.87022901 11.41030534 11.91030534 + # 12.45038168 12.99242213 13.24854064] + # [12.24023186 12.49635036 13.03839082 13.57846715 14.07846715 + # 14.61854349 15.16058394 15.41670245] + # [13.26470588 13.52082439 14.06286484 14.60294118 15.10294118 + # 15.64301751 16.18505796 16.44117647]]]] + output = interpolate_nd( + data, + lambda x, _: cubic_coeffs(x, A=-0.5), + scale_factors=scales, + exclude_outside=True, + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_cubic_A_n0p5_exclude_outside", + ) + + @staticmethod + def export_resize_downsample_scales_cubic_A_n0p5_exclude_outside() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="cubic", + cubic_coeff_a=-0.5, + exclude_outside=True, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32) + + # [[[[ 1.36812675 2.6695014 4.0133367 ] + # [ 6.57362535 7.875 9.2188353 ] + # [11.94896657 13.25034122 14.59417652]]]] + output = interpolate_nd( + data, + lambda x, _: cubic_coeffs(x, A=-0.5), + scale_factors=scales, + exclude_outside=True, + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_cubic_A_n0p5_exclude_outside", + ) + + # TensorFlow v1 bicubic with half_pixel_centers=False + @staticmethod + def export_resize_upsample_scales_cubic_asymmetric() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="cubic", + coordinate_transformation_mode="asymmetric", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32) + + # [[[[ 1. 1.40625 2. 2.5 3. 3.59375 4. + # 4.09375] + # [ 2.625 3.03125 3.625 4.125 4.625 5.21875 5.625 + # 5.71875] + # [ 5. 5.40625 6. 6.5 7. 7.59375 8. + # 8.09375] + # [ 7. 7.40625 8. 8.5 9. 9.59375 10. + # 10.09375] + # [ 9. 9.40625 10. 10.5 11. 11.59375 12. + # 12.09375] + # [11.375 11.78125 12.375 12.875 13.375 13.96875 14.375 + # 14.46875] + # [13. 13.40625 14. 14.5 15. 15.59375 16. + # 16.09375] + # [13.375 13.78125 14.375 14.875 15.375 15.96875 16.375 + # 16.46875]]]] + output = interpolate_nd( + data, + lambda x, _: cubic_coeffs(x, A=-0.75), + scale_factors=scales, + coordinate_transformation_mode="asymmetric", + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_cubic_asymmetric", + ) + + @staticmethod + def export_resize_tf_crop_and_resize() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "roi", "", "sizes"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="tf_crop_and_resize", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + # Note: for some rois, the result may be different with that of TF for inaccurate floating point + roi = np.array([0, 0, 0.4, 0.6, 1, 1, 0.6, 0.8], dtype=np.float32) + sizes = np.array([1, 1, 3, 3], dtype=np.int64) + + # [[[[ 7.6000004 7.9 8.2 ] + # [ 8.8 9.1 9.400001 ] + # [10. 10.3 10.6 ]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + output_size=sizes, + roi=roi, + coordinate_transformation_mode="tf_crop_and_resize", + ).astype(np.float32) + + expect( + node, + inputs=[data, roi, sizes], + outputs=[output], + name="test_resize_tf_crop_and_resize", + ) + + @staticmethod + def export_resize_tf_crop_and_resize_extrapolation_value() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "roi", "", "sizes"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="tf_crop_and_resize", + extrapolation_value=10.0, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + # Note: for some rois, the result may be different with that of TF for inaccurate floating point + roi = np.array([0, 0, 0.4, 0.6, 1, 1, 1.2, 1.7], dtype=np.float32) + sizes = np.array([1, 1, 3, 3], dtype=np.int64) + + # [[[[ 7.6000004 10. 10. ] + # [12.400001 10. 10. ] + # [10. 10. 10. ]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + output_size=sizes, + roi=roi, + coordinate_transformation_mode="tf_crop_and_resize", + extrapolation_value=10.0, + ).astype(np.float32) + + expect( + node, + inputs=[data, roi, sizes], + outputs=[output], + name="test_resize_tf_crop_and_resize_extrapolation_value", + ) + + @staticmethod + def export_resize_downsample_sizes_linear_pytorch_half_pixel() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="pytorch_half_pixel", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 3, 1], dtype=np.int64) + + # [[[[ 1.6666666] + # [ 7. ] + # [12.333333 ]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + output_size=sizes, + coordinate_transformation_mode="pytorch_half_pixel", + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_downsample_sizes_linear_pytorch_half_pixel", + ) + + @staticmethod + def export_resize_upsample_sizes_nearest_floor_align_corners() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + coordinate_transformation_mode="align_corners", + nearest_mode="floor", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 8, 8], dtype=np.int64) + + # [[[[ 1. 1. 1. 2. 2. 3. 3. 4.] + # [ 1. 1. 1. 2. 2. 3. 3. 4.] + # [ 1. 1. 1. 2. 2. 3. 3. 4.] + # [ 5. 5. 5. 6. 6. 7. 7. 8.] + # [ 5. 5. 5. 6. 6. 7. 7. 8.] + # [ 9. 9. 9. 10. 10. 11. 11. 12.] + # [ 9. 9. 9. 10. 10. 11. 11. 12.] + # [13. 13. 13. 14. 14. 15. 15. 16.]]]] + output = interpolate_nd( + data, + lambda x, _: nearest_coeffs(x, mode="floor"), + output_size=sizes, + coordinate_transformation_mode="align_corners", + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_nearest_floor_align_corners", + ) + + @staticmethod + def export_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + coordinate_transformation_mode="asymmetric", + nearest_mode="round_prefer_ceil", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 8, 8], dtype=np.int64) + + # [[[[ 1. 2. 2. 3. 3. 4. 4. 4.] + # [ 5. 6. 6. 7. 7. 8. 8. 8.] + # [ 5. 6. 6. 7. 7. 8. 8. 8.] + # [ 9. 10. 10. 11. 11. 12. 12. 12.] + # [ 9. 10. 10. 11. 11. 12. 12. 12.] + # [13. 14. 14. 15. 15. 16. 16. 16.] + # [13. 14. 14. 15. 15. 16. 16. 16.] + # [13. 14. 14. 15. 15. 16. 16. 16.]]]] + output = interpolate_nd( + data, + lambda x, _: nearest_coeffs(x, mode="round_prefer_ceil"), + output_size=sizes, + coordinate_transformation_mode="asymmetric", + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric", + ) + + @staticmethod + def export_resize_upsample_sizes_nearest_ceil_half_pixel() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + coordinate_transformation_mode="half_pixel", + nearest_mode="ceil", + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 8, 8], dtype=np.int64) + + # [[[[ 1. 2. 2. 3. 3. 4. 4. 4.] + # [ 5. 6. 6. 7. 7. 8. 8. 8.] + # [ 5. 6. 6. 7. 7. 8. 8. 8.] + # [ 9. 10. 10. 11. 11. 12. 12. 12.] + # [ 9. 10. 10. 11. 11. 12. 12. 12.] + # [13. 14. 14. 15. 15. 16. 16. 16.] + # [13. 14. 14. 15. 15. 16. 16. 16.] + # [13. 14. 14. 15. 15. 16. 16. 16.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x, mode="ceil"), output_size=sizes + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_nearest_ceil_half_pixel", + ) + + @staticmethod + def export_resize_downsample_scales_linear_antialias() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="linear", + antialias=1, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32) + + # [[[[ 2.875 4.5 ] + # [ 9.375 11. ]]]] + output = interpolate_nd( + data, linear_coeffs_antialias, scale_factors=scales + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_linear_antialias", + ) + + @staticmethod + def export_resize_downsample_sizes_linear_antialias() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="linear", + antialias=1, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 3, 3], dtype=np.int64) + + # [[[[ 2.3636363 3.590909 4.818182 ] + # [ 7.2727275 8.5 9.727273 ] + # [12.181818 13.409091 14.636364 ]]]] + output = interpolate_nd( + data, linear_coeffs_antialias, output_size=sizes + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_downsample_sizes_linear_antialias", + ) + + @staticmethod + def export_resize_downsample_scales_cubic_antialias() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="cubic", + antialias=1, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32) + + # [[[[ 2.5180721 4.2858863] + # [ 9.589329 11.357142 ]]]] + output = interpolate_nd( + data, cubic_coeffs_antialias, scale_factors=scales + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_cubic_antialias", + ) + + @staticmethod + def export_resize_downsample_sizes_cubic_antialias() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="cubic", + antialias=1, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 1, 3, 3], dtype=np.int64) + + # [[[[ 1.7750092 3.1200073 4.4650054] + # [ 7.1550016 8.5 9.844998 ] + # [12.534994 13.8799925 15.224991 ]]]] + output = interpolate_nd(data, cubic_coeffs_antialias, output_size=sizes).astype( + np.float32 + ) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_downsample_sizes_cubic_antialias", + ) + + @staticmethod + def export_resize_upsample_scales_nearest_axes_2_3() -> None: + axes = [2, 3] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="nearest", + axes=axes, + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([2.0, 3.0], dtype=np.float32) + + # [[[[1. 1. 1. 2. 2. 2.] + # [1. 1. 1. 2. 2. 2.] + # [3. 3. 3. 4. 4. 4.] + # [3. 3. 3. 4. 4. 4.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x), scale_factors=scales, axes=axes + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_nearest_axes_2_3", + ) + + @staticmethod + def export_resize_upsample_scales_nearest_axes_3_2() -> None: + axes = [3, 2] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="nearest", + axes=axes, + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([3.0, 2.0], dtype=np.float32) + + # [[[[1. 1. 1. 2. 2. 2.] + # [1. 1. 1. 2. 2. 2.] + # [3. 3. 3. 4. 4. 4.] + # [3. 3. 3. 4. 4. 4.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x), scale_factors=scales, axes=axes + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_nearest_axes_3_2", + ) + + @staticmethod + def export_resize_upsample_sizes_nearest_axes_2_3() -> None: + axes = [2, 3] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + axes=axes, + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([7, 8], dtype=np.int64) + + # [[[[1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [3. 3. 3. 3. 4. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4. 4.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x), output_size=sizes, axes=axes + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_nearest_axes_2_3", + ) + + @staticmethod + def export_resize_upsample_sizes_nearest_axes_3_2() -> None: + axes = [3, 2] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + axes=axes, + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([8, 7], dtype=np.int64) + + # [[[[1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [3. 3. 3. 3. 4. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4. 4.]]]] + output = interpolate_nd( + data, lambda x, _: nearest_coeffs(x), output_size=sizes, axes=axes + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_nearest_axes_3_2", + ) + + @staticmethod + def export_resize_tf_crop_and_resize_axes_2_3() -> None: + axes = [2, 3] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "roi", "", "sizes"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="tf_crop_and_resize", + axes=axes, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + # Note: for some rois, the result may be different with that of TF for inaccurate floating point + roi = np.array([0.4, 0.6, 0.6, 0.8], dtype=np.float32) + sizes = np.array([3, 3], dtype=np.int64) + + # [[[[ 7.6000004 7.9 8.2 ] + # [ 8.8 9.1 9.400001 ] + # [10. 10.3 10.6 ]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + output_size=sizes, + roi=roi, + axes=axes, + coordinate_transformation_mode="tf_crop_and_resize", + ).astype(np.float32) + + expect( + node, + inputs=[data, roi, sizes], + outputs=[output], + name="test_resize_tf_crop_and_resize_axes_2_3", + ) + + @staticmethod + def export_resize_tf_crop_and_resize_axes_3_2() -> None: + axes = [3, 2] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "roi", "", "sizes"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="tf_crop_and_resize", + axes=axes, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ], + dtype=np.float32, + ) + + # Note: for some rois, the result may be different with that of TF for inaccurate floating point + roi = np.array([0.6, 0.4, 0.8, 0.6], dtype=np.float32) + sizes = np.array([3, 3], dtype=np.int64) + + # [[[[ 7.6000004 7.9 8.2 ] + # [ 8.8 9.1 9.400001 ] + # [10. 10.3 10.6 ]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + output_size=sizes, + roi=roi, + axes=axes, + coordinate_transformation_mode="tf_crop_and_resize", + ).astype(np.float32) + + expect( + node, + inputs=[data, roi, sizes], + outputs=[output], + name="test_resize_tf_crop_and_resize_axes_3_2", + ) + + @staticmethod + def export_resize_upsample_sizes_nearest_not_larger() -> None: + keep_aspect_ratio_policy = "not_larger" + axes = [2, 3] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + axes=axes, + keep_aspect_ratio_policy=keep_aspect_ratio_policy, + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([7, 8], dtype=np.int64) # Results in 7x7 + + # [[[[1. 1. 1. 1. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2.] + # [3. 3. 3. 3. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4.]]]] + output = interpolate_nd( + data, + lambda x, _: nearest_coeffs(x), + output_size=sizes, + axes=axes, + keep_aspect_ratio_policy=keep_aspect_ratio_policy, + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_nearest_not_larger", + ) + + @staticmethod + def export_resize_upsample_sizes_nearest_not_smaller() -> None: + keep_aspect_ratio_policy = "not_smaller" + axes = [2, 3] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + axes=axes, + keep_aspect_ratio_policy=keep_aspect_ratio_policy, + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([7, 8], dtype=np.int64) # Results in 8x8 + + # [[[[1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [1. 1. 1. 1. 2. 2. 2. 2.] + # [3. 3. 3. 3. 4. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4. 4.] + # [3. 3. 3. 3. 4. 4. 4. 4.]]]] + output = interpolate_nd( + data, + lambda x, _: nearest_coeffs(x), + output_size=sizes, + axes=axes, + keep_aspect_ratio_policy=keep_aspect_ratio_policy, + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_upsample_sizes_nearest_not_smaller", + ) + + @staticmethod + def export_resize_downsample_sizes_nearest_not_larger() -> None: + keep_aspect_ratio_policy = "not_larger" + axes = [2, 3] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + axes=axes, + keep_aspect_ratio_policy=keep_aspect_ratio_policy, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 3], dtype=np.int64) # Results in 1x2 + + # [[[[1. 3.]]]] + output = interpolate_nd( + data, + lambda x, _: nearest_coeffs(x), + output_size=sizes, + axes=axes, + keep_aspect_ratio_policy=keep_aspect_ratio_policy, + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_downsample_sizes_nearest_not_larger", + ) + + @staticmethod + def export_resize_downsample_sizes_nearest_not_smaller() -> None: + keep_aspect_ratio_policy = "not_smaller" + axes = [2, 3] + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "", "sizes"], + outputs=["Y"], + mode="nearest", + axes=axes, + keep_aspect_ratio_policy=keep_aspect_ratio_policy, + ) + + data = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + ] + ] + ], + dtype=np.float32, + ) + + sizes = np.array([1, 3], dtype=np.int64) # Results in 2x3 + + # [[[[1. 2. 4.] + # [5. 6. 8.]]]] + output = interpolate_nd( + data, + lambda x, _: nearest_coeffs(x), + output_size=sizes, + axes=axes, + keep_aspect_ratio_policy=keep_aspect_ratio_policy, + ).astype(np.float32) + + expect( + node, + inputs=[data, sizes], + outputs=[output], + name="test_resize_downsample_sizes_nearest_not_smaller", + ) + + @staticmethod + def export_resize_downsample_scales_linear_half_pixel_symmetric() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="half_pixel_symmetric", + ) + + data = np.array([[[[1, 2, 3, 4]]]], dtype=np.float32) + scales = np.array([1.0, 1.0, 1.0, 0.6], dtype=np.float32) + + # [[[[1.6666667, 3.3333333]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + scale_factors=scales, + coordinate_transformation_mode="half_pixel_symmetric", + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_downsample_scales_linear_half_pixel_symmetric", + ) + + @staticmethod + def export_resize_upsample_scales_linear_half_pixel_symmetric() -> None: + node = onnx.helper.make_node( + "Resize", + inputs=["X", "", "scales"], + outputs=["Y"], + mode="linear", + coordinate_transformation_mode="half_pixel_symmetric", + ) + + data = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32) + scales = np.array([1.0, 1.0, 2.3, 2.94], dtype=np.float32) + + # [[[[1. , 1.15986395, 1.5 , 1.84013605, 2. ], + # [1.56521738, 1.72508133, 2.06521738, 2.40535343, 2.56521738], + # [2.43478262, 2.59464657, 2.93478262, 3.27491867, 3.43478262], + # [3. , 3.15986395, 3.5 , 3.84013605, 4. ]]]] + output = interpolate_nd( + data, + lambda x, _: linear_coeffs(x), + scale_factors=scales, + coordinate_transformation_mode="half_pixel_symmetric", + ).astype(np.float32) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_resize_upsample_scales_linear_half_pixel_symmetric", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reversesequence.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reversesequence.py new file mode 100644 index 0000000000000000000000000000000000000000..b5533cca80802765fd9c2b4c33c966f1832ac6a1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/reversesequence.py @@ -0,0 +1,86 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ReverseSequence(Base): + @staticmethod + def export_reversesequence_time() -> None: + node = onnx.helper.make_node( + "ReverseSequence", + inputs=["x", "sequence_lens"], + outputs=["y"], + time_axis=0, + batch_axis=1, + ) + x = np.array( + [ + [0.0, 4.0, 8.0, 12.0], + [1.0, 5.0, 9.0, 13.0], + [2.0, 6.0, 10.0, 14.0], + [3.0, 7.0, 11.0, 15.0], + ], + dtype=np.float32, + ) + sequence_lens = np.array([4, 3, 2, 1], dtype=np.int64) + + y = np.array( + [ + [3.0, 6.0, 9.0, 12.0], + [2.0, 5.0, 8.0, 13.0], + [1.0, 4.0, 10.0, 14.0], + [0.0, 7.0, 11.0, 15.0], + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[x, sequence_lens], + outputs=[y], + name="test_reversesequence_time", + ) + + @staticmethod + def export_reversesequence_batch() -> None: + node = onnx.helper.make_node( + "ReverseSequence", + inputs=["x", "sequence_lens"], + outputs=["y"], + time_axis=1, + batch_axis=0, + ) + x = np.array( + [ + [0.0, 1.0, 2.0, 3.0], + [4.0, 5.0, 6.0, 7.0], + [8.0, 9.0, 10.0, 11.0], + [12.0, 13.0, 14.0, 15.0], + ], + dtype=np.float32, + ) + sequence_lens = np.array([1, 2, 3, 4], dtype=np.int64) + + y = np.array( + [ + [0.0, 1.0, 2.0, 3.0], + [5.0, 4.0, 6.0, 7.0], + [10.0, 9.0, 8.0, 11.0], + [15.0, 14.0, 13.0, 12.0], + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[x, sequence_lens], + outputs=[y], + name="test_reversesequence_batch", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rmsnormalization.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rmsnormalization.py new file mode 100644 index 0000000000000000000000000000000000000000..3b24e4cc0acb6cacc68708abe2019d423e4a0222 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rmsnormalization.py @@ -0,0 +1,126 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_rms_normalization import _rms_normalization + + +def calculate_normalized_shape(x_shape, axis): + rank = len(x_shape) + if axis < 0: + axis = axis + rank + return x_shape[axis:] + + +class RMSNormalization(Base): + @staticmethod + def export() -> None: + X = np.random.randn(2, 3, 4, 5).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + Y = _rms_normalization(X, W, axis=axis) + + node = onnx.helper.make_node( + "RMSNormalization", + inputs=["X", "W"], + outputs=["Y"], + axis=axis, + ) + + if axis < 0: + name = f"test_rms_normalization_4d_axis_negative_{-axis}" + else: + name = f"test_rms_normalization_4d_axis{axis}" + + expect(node, inputs=[X, W], outputs=[Y], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) + + @staticmethod + def export_default_axis() -> None: + X = np.random.randn(2, 3, 4, 5).astype(np.float32) + + # Default axis in RMSNormalization is -1. + normalized_shape = calculate_normalized_shape(X.shape, -1) + W = np.random.randn(*normalized_shape).astype(np.float32) + # Axis is default to -1 in the reference implementation. + Y = _rms_normalization(X, W) + + # Not specifying axis attribute means -1. + node = onnx.helper.make_node( + "RMSNormalization", + inputs=["X", "W"], + outputs=["Y"], + ) + + expect( + node, + inputs=[X, W], + outputs=[Y], + name="test_rms_normalization_default_axis", + ) + + @staticmethod + def export2d() -> None: + X = np.random.randn(3, 4).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + Y = _rms_normalization(X, W, axis=axis) + + node = onnx.helper.make_node( + "RMSNormalization", + inputs=["X", "W"], + outputs=["Y"], + axis=axis, + ) + + if axis < 0: + name = f"test_rms_normalization_2d_axis_negative_{-axis}" + else: + name = f"test_rms_normalization_2d_axis{axis}" + + expect(node, inputs=[X, W], outputs=[Y], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) + + @staticmethod + def export3d_epsilon() -> None: + epsilon = 1e-1 + X = np.random.randn(2, 3, 5).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + Y = _rms_normalization(X, W, axis=axis, epsilon=epsilon) + node = onnx.helper.make_node( + "RMSNormalization", + inputs=["X", "W"], + outputs=["Y"], + axis=axis, + epsilon=epsilon, + ) + + if axis < 0: + name = f"test_rms_normalization_3d_axis_negative_{-axis}_epsilon" + else: + name = f"test_rms_normalization_3d_axis{axis}_epsilon" + + expect(node, inputs=[X, W], outputs=[Y], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rnn.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rnn.py new file mode 100644 index 0000000000000000000000000000000000000000..1c0dbfefe0ad542a41283ef7a80c62eb09c5d542 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rnn.py @@ -0,0 +1,220 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class RNNHelper: + def __init__(self, **params: Any) -> None: + # RNN Input Names + X = "X" + W = "W" + R = "R" + B = "B" + H_0 = "initial_h" + LAYOUT = "layout" + + required_inputs = [X, W, R] + for i in required_inputs: + assert i in params, f"Missing Required Input: {i}" + + self.num_directions = params[str(W)].shape[0] + + if self.num_directions == 1: + for k, v in params.items(): + if k != X: + params[k] = np.squeeze(v, axis=0) + + hidden_size = params[R].shape[-1] + batch_size = params[X].shape[1] + + layout = params.get(LAYOUT, 0) + x = params[X] + x = x if layout == 0 else np.swapaxes(x, 0, 1) + b = ( + params[B] + if B in params + else np.zeros(2 * hidden_size, dtype=np.float32) + ) + h_0 = ( + params[H_0] + if H_0 in params + else np.zeros((batch_size, hidden_size), dtype=np.float32) + ) + + self.X = x + self.W = params[W] + self.R = params[R] + self.B = b + self.H_0 = h_0 + self.LAYOUT = layout + + else: + raise NotImplementedError + + def f(self, x: np.ndarray) -> np.ndarray: + return np.tanh(x) + + def step(self) -> tuple[np.ndarray, np.ndarray]: + seq_length = self.X.shape[0] + hidden_size = self.H_0.shape[-1] + batch_size = self.X.shape[1] + + Y = np.empty([seq_length, self.num_directions, batch_size, hidden_size]) + h_list = [] + + H_t = self.H_0 + for x in np.split(self.X, self.X.shape[0], axis=0): + H = self.f( + np.dot(x, np.transpose(self.W)) + + np.dot(H_t, np.transpose(self.R)) + + np.add(*np.split(self.B, 2)) + ) + h_list.append(H) + H_t = H + + concatenated = np.concatenate(h_list) + if self.num_directions == 1: + Y[:, 0, :, :] = concatenated + + if self.LAYOUT == 0: + Y_h = Y[-1] + else: + Y = np.transpose(Y, [2, 0, 1, 3]) + Y_h = Y[:, :, -1, :] + + return Y, Y_h + + +class RNN(Base): + @staticmethod + def export_defaults() -> None: + input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 4 + weight_scale = 0.1 + + node = onnx.helper.make_node( + "RNN", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size + ) + + W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32) + R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32) + + rnn = RNNHelper(X=input, W=W, R=R) + _, Y_h = rnn.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y_h.astype(np.float32)], + name="test_simple_rnn_defaults", + ) + + @staticmethod + def export_initial_bias() -> None: + input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype( + np.float32 + ) + + input_size = 3 + hidden_size = 5 + custom_bias = 0.1 + weight_scale = 0.1 + + node = onnx.helper.make_node( + "RNN", + inputs=["X", "W", "R", "B"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32) + R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32) + + # Adding custom bias + W_B = custom_bias * np.ones((1, hidden_size)).astype(np.float32) + R_B = np.zeros((1, hidden_size)).astype(np.float32) + B = np.concatenate((W_B, R_B), axis=1) + + rnn = RNNHelper(X=input, W=W, R=R, B=B) + _, Y_h = rnn.step() + expect( + node, + inputs=[input, W, R, B], + outputs=[Y_h.astype(np.float32)], + name="test_simple_rnn_with_initial_bias", + ) + + @staticmethod + def export_seq_length() -> None: + input = np.array( + [ + [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], + [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]], + ] + ).astype(np.float32) + + input_size = 3 + hidden_size = 5 + + node = onnx.helper.make_node( + "RNN", + inputs=["X", "W", "R", "B"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + W = np.random.randn(1, hidden_size, input_size).astype(np.float32) + R = np.random.randn(1, hidden_size, hidden_size).astype(np.float32) + + # Adding custom bias + W_B = np.random.randn(1, hidden_size).astype(np.float32) + R_B = np.random.randn(1, hidden_size).astype(np.float32) + B = np.concatenate((W_B, R_B), axis=1) + + rnn = RNNHelper(X=input, W=W, R=R, B=B) + _, Y_h = rnn.step() + expect( + node, + inputs=[input, W, R, B], + outputs=[Y_h.astype(np.float32)], + name="test_rnn_seq_length", + ) + + @staticmethod + def export_batchwise() -> None: + input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 4 + weight_scale = 0.5 + layout = 1 + + node = onnx.helper.make_node( + "RNN", + inputs=["X", "W", "R"], + outputs=["Y", "Y_h"], + hidden_size=hidden_size, + layout=layout, + ) + + W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32) + R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32) + + rnn = RNNHelper(X=input, W=W, R=R, layout=layout) + Y, Y_h = rnn.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y.astype(np.float32), Y_h.astype(np.float32)], + name="test_simple_rnn_batchwise", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/roialign.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/roialign.py new file mode 100644 index 0000000000000000000000000000000000000000..888fa6e5dfeda4a362f84f9d2c2985fb20a81fe1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/roialign.py @@ -0,0 +1,446 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def get_roi_align_input_values(): + X = np.array( + [ + [ + [ + [ + 0.2764, + 0.7150, + 0.1958, + 0.3416, + 0.4638, + 0.0259, + 0.2963, + 0.6518, + 0.4856, + 0.7250, + ], + [ + 0.9637, + 0.0895, + 0.2919, + 0.6753, + 0.0234, + 0.6132, + 0.8085, + 0.5324, + 0.8992, + 0.4467, + ], + [ + 0.3265, + 0.8479, + 0.9698, + 0.2471, + 0.9336, + 0.1878, + 0.4766, + 0.4308, + 0.3400, + 0.2162, + ], + [ + 0.0206, + 0.1720, + 0.2155, + 0.4394, + 0.0653, + 0.3406, + 0.7724, + 0.3921, + 0.2541, + 0.5799, + ], + [ + 0.4062, + 0.2194, + 0.4473, + 0.4687, + 0.7109, + 0.9327, + 0.9815, + 0.6320, + 0.1728, + 0.6119, + ], + [ + 0.3097, + 0.1283, + 0.4984, + 0.5068, + 0.4279, + 0.0173, + 0.4388, + 0.0430, + 0.4671, + 0.7119, + ], + [ + 0.1011, + 0.8477, + 0.4726, + 0.1777, + 0.9923, + 0.4042, + 0.1869, + 0.7795, + 0.9946, + 0.9689, + ], + [ + 0.1366, + 0.3671, + 0.7011, + 0.6234, + 0.9867, + 0.5585, + 0.6985, + 0.5609, + 0.8788, + 0.9928, + ], + [ + 0.5697, + 0.8511, + 0.6711, + 0.9406, + 0.8751, + 0.7496, + 0.1650, + 0.1049, + 0.1559, + 0.2514, + ], + [ + 0.7012, + 0.4056, + 0.7879, + 0.3461, + 0.0415, + 0.2998, + 0.5094, + 0.3727, + 0.5482, + 0.0502, + ], + ] + ] + ], + dtype=np.float32, + ) + batch_indices = np.array([0, 0, 0], dtype=np.int64) + rois = np.array([[0, 0, 9, 9], [0, 5, 4, 9], [5, 5, 9, 9]], dtype=np.float32) + return X, batch_indices, rois + + +class RoiAlign(Base): + @staticmethod + def export_roialign_aligned_false() -> None: + node = onnx.helper.make_node( + "RoiAlign", + inputs=["X", "rois", "batch_indices"], + outputs=["Y"], + spatial_scale=1.0, + output_height=5, + output_width=5, + sampling_ratio=2, + coordinate_transformation_mode="output_half_pixel", + ) + + X, batch_indices, rois = get_roi_align_input_values() + # (num_rois, C, output_height, output_width) + Y = np.array( + [ + [ + [ + [0.4664, 0.4466, 0.3405, 0.5688, 0.6068], + [0.3714, 0.4296, 0.3835, 0.5562, 0.3510], + [0.2768, 0.4883, 0.5222, 0.5528, 0.4171], + [0.4713, 0.4844, 0.6904, 0.4920, 0.8774], + [0.6239, 0.7125, 0.6289, 0.3355, 0.3495], + ] + ], + [ + [ + [0.3022, 0.4305, 0.4696, 0.3978, 0.5423], + [0.3656, 0.7050, 0.5165, 0.3172, 0.7015], + [0.2912, 0.5059, 0.6476, 0.6235, 0.8299], + [0.5916, 0.7389, 0.7048, 0.8372, 0.8893], + [0.6227, 0.6153, 0.7097, 0.6154, 0.4585], + ] + ], + [ + [ + [0.2384, 0.3379, 0.3717, 0.6100, 0.7601], + [0.3767, 0.3785, 0.7147, 0.9243, 0.9727], + [0.5749, 0.5826, 0.5709, 0.7619, 0.8770], + [0.5355, 0.2566, 0.2141, 0.2796, 0.3600], + [0.4365, 0.3504, 0.2887, 0.3661, 0.2349], + ] + ], + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, rois, batch_indices], + outputs=[Y], + name="test_roialign_aligned_false", + ) + + @staticmethod + def export_roialign_aligned_true() -> None: + node = onnx.helper.make_node( + "RoiAlign", + inputs=["X", "rois", "batch_indices"], + outputs=["Y"], + spatial_scale=1.0, + output_height=5, + output_width=5, + sampling_ratio=2, + coordinate_transformation_mode="half_pixel", + ) + + X, batch_indices, rois = get_roi_align_input_values() + # (num_rois, C, output_height, output_width) + Y = np.array( + [ + [ + [ + [0.5178, 0.3434, 0.3229, 0.4474, 0.6344], + [0.4031, 0.5366, 0.4428, 0.4861, 0.4023], + [0.2512, 0.4002, 0.5155, 0.6954, 0.3465], + [0.3350, 0.4601, 0.5881, 0.3439, 0.6849], + [0.4932, 0.7141, 0.8217, 0.4719, 0.4039], + ] + ], + [ + [ + [0.3070, 0.2187, 0.3337, 0.4880, 0.4870], + [0.1871, 0.4914, 0.5561, 0.4192, 0.3686], + [0.1433, 0.4608, 0.5971, 0.5310, 0.4982], + [0.2788, 0.4386, 0.6022, 0.7000, 0.7524], + [0.5774, 0.7024, 0.7251, 0.7338, 0.8163], + ] + ], + [ + [ + [0.2393, 0.4075, 0.3379, 0.2525, 0.4743], + [0.3671, 0.2702, 0.4105, 0.6419, 0.8308], + [0.5556, 0.4543, 0.5564, 0.7502, 0.9300], + [0.6626, 0.5617, 0.4813, 0.4954, 0.6663], + [0.6636, 0.3721, 0.2056, 0.1928, 0.2478], + ] + ], + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, rois, batch_indices], + outputs=[Y], + name="test_roialign_aligned_true", + ) + + @staticmethod + def export_roialign_mode_max() -> None: + X = np.array( + [ + [ + [ + [ + 0.2764, + 0.715, + 0.1958, + 0.3416, + 0.4638, + 0.0259, + 0.2963, + 0.6518, + 0.4856, + 0.725, + ], + [ + 0.9637, + 0.0895, + 0.2919, + 0.6753, + 0.0234, + 0.6132, + 0.8085, + 0.5324, + 0.8992, + 0.4467, + ], + [ + 0.3265, + 0.8479, + 0.9698, + 0.2471, + 0.9336, + 0.1878, + 0.4766, + 0.4308, + 0.34, + 0.2162, + ], + [ + 0.0206, + 0.172, + 0.2155, + 0.4394, + 0.0653, + 0.3406, + 0.7724, + 0.3921, + 0.2541, + 0.5799, + ], + [ + 0.4062, + 0.2194, + 0.4473, + 0.4687, + 0.7109, + 0.9327, + 0.9815, + 0.632, + 0.1728, + 0.6119, + ], + [ + 0.3097, + 0.1283, + 0.4984, + 0.5068, + 0.4279, + 0.0173, + 0.4388, + 0.043, + 0.4671, + 0.7119, + ], + [ + 0.1011, + 0.8477, + 0.4726, + 0.1777, + 0.9923, + 0.4042, + 0.1869, + 0.7795, + 0.9946, + 0.9689, + ], + [ + 0.1366, + 0.3671, + 0.7011, + 0.6234, + 0.9867, + 0.5585, + 0.6985, + 0.5609, + 0.8788, + 0.9928, + ], + [ + 0.5697, + 0.8511, + 0.6711, + 0.9406, + 0.8751, + 0.7496, + 0.165, + 0.1049, + 0.1559, + 0.2514, + ], + [ + 0.7012, + 0.4056, + 0.7879, + 0.3461, + 0.0415, + 0.2998, + 0.5094, + 0.3727, + 0.5482, + 0.0502, + ], + ] + ] + ], + dtype=np.float32, + ) + rois = np.array( + [[0.0, 0.0, 9.0, 9.0], [0.0, 5.0, 4.0, 9.0], [5.0, 5.0, 9.0, 9.0]], + dtype=np.float32, + ) + batch_indices = np.array([0, 0, 0], dtype=np.int64) + + Y = np.array( + [ + [ + [ + [0.3445228, 0.37310338, 0.37865096, 0.446696, 0.37991184], + [0.4133513, 0.5455125, 0.6651902, 0.55805874, 0.27110294], + [0.21223956, 0.40924096, 0.8417618, 0.792561, 0.37196714], + [0.46835402, 0.39741728, 0.8012819, 0.4969306, 0.5495158], + [0.3595896, 0.5196813, 0.5403741, 0.23814403, 0.19992709], + ] + ], + [ + [ + [0.30517197, 0.5086199, 0.3189761, 0.4054401, 0.47630402], + [0.50862, 0.8477, 0.37808004, 0.24936005, 0.79384017], + [0.17620805, 0.29368007, 0.44870415, 0.4987201, 0.63148826], + [0.51066005, 0.8511, 0.5368801, 0.9406, 0.70008016], + [0.4487681, 0.51066035, 0.5042561, 0.5643603, 0.42004836], + ] + ], + [ + [ + [0.21062402, 0.3510401, 0.37416005, 0.5967599, 0.46507207], + [0.32336006, 0.31180006, 0.6236001, 0.9946, 0.7751202], + [0.35744014, 0.5588001, 0.35897616, 0.7030401, 0.6353923], + [0.5996801, 0.27940005, 0.17948808, 0.35152006, 0.31769615], + [0.3598083, 0.40752012, 0.2385281, 0.43856013, 0.26313624], + ] + ], + ], + dtype=np.float32, + ) + + node = onnx.helper.make_node( + "RoiAlign", + inputs=["X", "rois", "batch_indices"], + mode="max", + outputs=["Y"], + spatial_scale=1.0, + output_height=5, + output_width=5, + sampling_ratio=2, + coordinate_transformation_mode="output_half_pixel", + ) + + expect( + node, + inputs=[X, rois, batch_indices], + outputs=[Y], + name="test_roialign_mode_max", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rotaryembedding.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rotaryembedding.py new file mode 100644 index 0000000000000000000000000000000000000000..58f1ec6867865374863d84bbcb6a672cee396c09 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/rotaryembedding.py @@ -0,0 +1,231 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.op_rotary_embedding import rotary_embedding + + +class RotaryEmbedding(Base): + @staticmethod + def export_rotary_embedding() -> None: + node = onnx.helper.make_node( + "RotaryEmbedding", + inputs=["input", "cos_cache", "sin_cache", "position_ids"], + outputs=["output"], + ) + + input_data = np.random.rand(2, 4, 3, 8).astype(np.float32) + position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64) + sin_cache_data = np.random.rand(50, 4).astype(np.float32) + cos_cache_data = np.random.rand(50, 4).astype(np.float32) + + expected_output = rotary_embedding( + input_data, cos_cache_data, sin_cache_data, position_ids=position_ids_data + ) + + expect( + node, + inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data], + outputs=[expected_output], + name="test_rotary_embedding", + ) + + @staticmethod + def export_rotary_embedding_3d_input() -> None: + num_heads = 4 + node = onnx.helper.make_node( + "RotaryEmbedding", + inputs=["input", "cos_cache", "sin_cache", "position_ids"], + outputs=["output"], + num_heads=num_heads, + ) + + input_data = np.random.rand(2, 3, 32).astype(np.float32) + position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64) + sin_cache_data = np.random.rand(50, 4).astype(np.float32) + cos_cache_data = np.random.rand(50, 4).astype(np.float32) + + expected_output = rotary_embedding( + input_data, + cos_cache_data, + sin_cache_data, + position_ids=position_ids_data, + num_heads=num_heads, + ) + + expect( + node, + inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data], + outputs=[expected_output], + name="test_rotary_embedding_3d_input", + ) + + @staticmethod + def export_rotary_embedding_interleaved() -> None: + node = onnx.helper.make_node( + "RotaryEmbedding", + inputs=["input", "cos_cache", "sin_cache", "position_ids"], + outputs=["output"], + interleaved=1, + ) + + input_data = np.random.rand(2, 4, 3, 8).astype(np.float32) + position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64) + sin_cache_data = np.random.rand(50, 4).astype(np.float32) + cos_cache_data = np.random.rand(50, 4).astype(np.float32) + + expected_output = rotary_embedding( + input_data, + cos_cache_data, + sin_cache_data, + position_ids=position_ids_data, + interleaved=1, + ) + + expect( + node, + inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data], + outputs=[expected_output], + name="test_rotary_embedding_interleaved", + ) + + @staticmethod + def export_rotary_embedding_with_rotary_dim() -> None: + node = onnx.helper.make_node( + "RotaryEmbedding", + inputs=["input", "cos_cache", "sin_cache", "position_ids"], + outputs=["output"], + rotary_embedding_dim=4, + ) + + input_data = np.random.rand(2, 4, 3, 8).astype(np.float32) + position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64) + sin_cache_data = np.random.rand(50, 2).astype(np.float32) + cos_cache_data = np.random.rand(50, 2).astype(np.float32) + + expected_output = rotary_embedding( + input_data, + cos_cache_data, + sin_cache_data, + position_ids=position_ids_data, + rotary_embedding_dim=4, + ) + + expect( + node, + inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data], + outputs=[expected_output], + name="test_rotary_embedding_with_rotary_dim", + ) + + @staticmethod + def export_rotary_embedding_with_interleaved_rotary_dim() -> None: + node = onnx.helper.make_node( + "RotaryEmbedding", + inputs=["input", "cos_cache", "sin_cache", "position_ids"], + outputs=["output"], + rotary_embedding_dim=4, + interleaved=1, + ) + + input_data = np.random.rand(2, 4, 3, 8).astype(np.float32) + position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64) + sin_cache_data = np.random.rand(50, 2).astype(np.float32) + cos_cache_data = np.random.rand(50, 2).astype(np.float32) + + expected_output = rotary_embedding( + input_data, + cos_cache_data, + sin_cache_data, + position_ids=position_ids_data, + interleaved=1, + rotary_embedding_dim=4, + ) + + expect( + node, + inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data], + outputs=[expected_output], + name="test_rotary_embedding_with_interleaved_rotary_dim", + ) + + @staticmethod + def export_rotary_embedding_no_position_ids() -> None: + node = onnx.helper.make_node( + "RotaryEmbedding", + inputs=["input", "cos_cache", "sin_cache"], + outputs=["output"], + ) + + input_data = np.random.rand(2, 4, 3, 8).astype(np.float32) + sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32) + cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32) + + expected_output = rotary_embedding(input_data, cos_cache_data, sin_cache_data) + + expect( + node, + inputs=[input_data, cos_cache_data, sin_cache_data], + outputs=[expected_output], + name="test_rotary_embedding_no_position_ids", + ) + + @staticmethod + def export_rotary_embedding_no_position_ids_interleaved() -> None: + node = onnx.helper.make_node( + "RotaryEmbedding", + inputs=["input", "cos_cache", "sin_cache"], + outputs=["output"], + interleaved=1, + ) + + input_data = np.random.rand(2, 4, 3, 8).astype(np.float32) + sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32) + cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32) + + expected_output = rotary_embedding( + input_data, + cos_cache_data, + sin_cache_data, + interleaved=1, + ) + + expect( + node, + inputs=[input_data, cos_cache_data, sin_cache_data], + outputs=[expected_output], + name="test_rotary_embedding_no_position_ids_interleaved", + ) + + @staticmethod + def export_rotary_embedding_no_position_ids_rotary_dim() -> None: + node = onnx.helper.make_node( + "RotaryEmbedding", + inputs=["input", "cos_cache", "sin_cache"], + outputs=["output"], + rotary_embedding_dim=4, + ) + + input_data = np.random.rand(2, 4, 3, 8).astype(np.float32) + sin_cache_data = np.random.rand(2, 3, 2).astype(np.float32) + cos_cache_data = np.random.rand(2, 3, 2).astype(np.float32) + + expected_output = rotary_embedding( + input_data, + cos_cache_data, + sin_cache_data, + rotary_embedding_dim=4, + ) + + expect( + node, + inputs=[input_data, cos_cache_data, sin_cache_data], + outputs=[expected_output], + name="test_rotary_embedding_no_position_ids_rotary_dim", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/round.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/round.py new file mode 100644 index 0000000000000000000000000000000000000000..475ca3b2ec8bb82cad3d848053bd739019964a49 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/round.py @@ -0,0 +1,62 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Round(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Round", + inputs=["x"], + outputs=["y"], + ) + + x = np.array( + [ + 0.1, + 0.5, + 0.9, + 1.2, + 1.5, + 1.8, + 2.3, + 2.5, + 2.7, + -1.1, + -1.5, + -1.9, + -2.2, + -2.5, + -2.8, + ] + ).astype(np.float32) + + # expected output + y = np.array( + [ + 0.0, + 0.0, + 1.0, + 1.0, + 2.0, + 2.0, + 2.0, + 2.0, + 3.0, + -1.0, + -2.0, + -2.0, + -2.0, + -2.0, + -3.0, + ] + ).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_round") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scan.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scan.py new file mode 100644 index 0000000000000000000000000000000000000000..36dd44ec3117b3bd7cc3b444b4b8f3346bab55de --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scan.py @@ -0,0 +1,155 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +import onnx.parser +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Scan(Base): + @staticmethod + def export_scan_8() -> None: + # Given an input sequence [x1, ..., xN], sum up its elements using a scan + # returning the final state (x1+x2+...+xN) as well the scan_output + # [x1, x1+x2, ..., x1+x2+...+xN] + # Note: the first input (sequence_lens) is optional and omitted via "". + node = onnx.parser.parse_node( + """ + y, z = Scan ("", initial, x) < + num_scan_inputs = 1, + body = scan_body (float[2] sum_in, float[2] next) + => (float[2] sum_out, float[2] scan_out) + { + sum_out = Add(sum_in, next) + scan_out = Identity(sum_out) + } + > + """ + ) + # create inputs for batch-size 1, sequence-length 3, inner dimension 2 + initial = np.array([0, 0]).astype(np.float32).reshape((1, 2)) + x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((1, 3, 2)) + # final state computed = [1 + 3 + 5, 2 + 4 + 6] + y = np.array([9, 12]).astype(np.float32).reshape((1, 2)) + # scan-output computed + z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((1, 3, 2)) + + expect( + node, + inputs=[initial, x], + outputs=[y, z], + name="test_scan_sum", + opset_imports=[onnx.helper.make_opsetid("", 8)], + ) + + @staticmethod + def export_scan_9() -> None: + # Given an input sequence [x1, ..., xN], sum up its elements using a scan + # returning the final state (x1+x2+...+xN) as well the scan_output + # [x1, x1+x2, ..., x1+x2+...+xN] + node = onnx.parser.parse_node( + """ + y, z = Scan (initial, x) < + num_scan_inputs = 1, + body = scan_body (float[2] sum_in, float[2] next) + => (float[2] sum_out, float[2] scan_out) + { + sum_out = Add(sum_in, next) + scan_out = Identity(sum_out) + } + > + """ + ) + # create inputs for sequence-length 3, inner dimension 2 + initial = np.array([0, 0]).astype(np.float32).reshape((2,)) + x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2)) + # final state computed = [1 + 3 + 5, 2 + 4 + 6] + y = np.array([9, 12]).astype(np.float32).reshape((2,)) + # scan-output computed + z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((3, 2)) + + expect( + node, + inputs=[initial, x], + outputs=[y, z], + name="test_scan9_sum", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + + @staticmethod + def export_scan_9_multi_state() -> None: + # Scan with two state variables: running sum and running product. + # This exercises the case where num_loop_state_vars (2) differs from + # num_scan_inputs (1). + # + # Body inputs: sum_in (state), prod_in (state), next (scan) + # Body outputs: sum_out (state), prod_out (state), scan_out (scan) + node = onnx.parser.parse_node( + """ + y_sum, y_prod, z = Scan (initial_sum, initial_prod, x) < + num_scan_inputs = 1, + body = scan_body (float[2] sum_in, float[2] prod_in, float[2] next) + => (float[2] sum_out, float[2] prod_out, float[2] scan_out) + { + sum_out = Add(sum_in, next) + prod_out = Mul(prod_in, next) + scan_out = Identity(sum_out) + } + > + """ + ) + # x = [[1, 2], [3, 4], [5, 6]] + initial_sum = np.array([0, 0]).astype(np.float32) + initial_prod = np.array([1, 1]).astype(np.float32) + x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2)) + # final sum = [1+3+5, 2+4+6] = [9, 12] + y_sum = np.array([9, 12]).astype(np.float32) + # final product = [1*3*5, 2*4*6] = [15, 48] + y_prod = np.array([15, 48]).astype(np.float32) + # scan output (running sum) = [[1,2], [4,6], [9,12]] + z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((3, 2)) + + expect( + node, + inputs=[initial_sum, initial_prod, x], + outputs=[y_sum, y_prod, z], + name="test_scan9_multi_state", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + + @staticmethod + def export_scan_9_scalar() -> None: + # Scan with scalar state and scan output to verify that output + # shapes are not distorted (e.g. (T,) not (T, 1)). + node = onnx.parser.parse_node( + """ + y, z = Scan (initial, x) < + num_scan_inputs = 1, + body = scan_body (float sum_in, float next) + => (float sum_out, float scan_out) + { + sum_out = Add(sum_in, next) + scan_out = Identity(sum_out) + } + > + """ + ) + initial = np.float32(0.0) + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + # final state = 1+2+3+4+5 = 15 + y = np.float32(15.0) + # scan output = [1, 3, 6, 10, 15], shape (5,) + z = np.array([1, 3, 6, 10, 15]).astype(np.float32) + + expect( + node, + inputs=[initial, x], + outputs=[y, z], + name="test_scan9_scalar", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatter.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatter.py new file mode 100644 index 0000000000000000000000000000000000000000..b59e60871b00481d470f8c96f34761e6100e2494 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatter.py @@ -0,0 +1,109 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx import helper +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# The below Scatter's numpy implementation is from https://stackoverflow.com/a/46204790/11767360 +def scatter( + data: np.ndarray, indices: np.ndarray, updates: np.ndarray, axis: int = 0 +) -> np.ndarray: + if axis < 0: + axis = data.ndim + axis + + idx_xsection_shape = indices.shape[:axis] + indices.shape[axis + 1 :] + + def make_slice(arr: np.ndarray, axis: int, i: int) -> list[slice | int]: + slc: list[slice | int] = [slice(None)] * arr.ndim + slc[axis] = i + return slc + + def unpack(packed: Any) -> Any: + unpacked = packed[0] + for i in range(1, len(packed)): + unpacked = unpacked, packed[i] + return unpacked + + # We use indices and axis parameters to create idx + # idx is in a form that can be used as a NumPy advanced indices for scattering of updates param. in data + idx = [ + [ + unpack(np.indices(idx_xsection_shape).reshape(indices.ndim - 1, -1)), + indices[tuple(make_slice(indices, axis, i))].reshape(1, -1)[0], + ] + for i in range(indices.shape[axis]) + ] + idx = list(np.concatenate(idx, axis=1)) + idx.insert(axis, idx.pop()) + + # updates_idx is a NumPy advanced indices for indexing of elements in the updates + updates_idx = list(idx) + updates_idx.pop(axis) + updates_idx.insert( + axis, np.repeat(np.arange(indices.shape[axis]), np.prod(idx_xsection_shape)) + ) + + scattered = np.copy(data) + scattered[tuple(idx)] = updates[tuple(updates_idx)] + return scattered + + +class Scatter(Base): + @staticmethod + def export_scatter_without_axis() -> None: + node = onnx.helper.make_node( + "Scatter", + inputs=["data", "indices", "updates"], + outputs=["y"], + ) + data = np.zeros((3, 3), dtype=np.float32) + indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64) + updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32) + + y = scatter(data, indices, updates) + # print(y) produces + # [[2.0, 1.1, 0.0], + # [1.0, 0.0, 2.2], + # [0.0, 2.1, 1.2]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_without_axis", + opset_imports=[helper.make_opsetid("", 10)], + ) + + @staticmethod + def export_scatter_with_axis() -> None: + axis = 1 + node = onnx.helper.make_node( + "Scatter", + inputs=["data", "indices", "updates"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32) + indices = np.array([[1, 3]], dtype=np.int64) + updates = np.array([[1.1, 2.1]], dtype=np.float32) + + y = scatter(data, indices, updates, axis=axis) + # print(y) produces + # [[1.0, 1.1, 3.0, 2.1, 5.0]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_with_axis", + opset_imports=[helper.make_opsetid("", 10)], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatterelements.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatterelements.py new file mode 100644 index 0000000000000000000000000000000000000000..f693ccf678fa2c990e9d5403af335050d6dffcf2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatterelements.py @@ -0,0 +1,266 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from collections.abc import Sequence + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# The below ScatterElements' numpy implementation is from https://stackoverflow.com/a/46204790/11767360 +def scatter_elements( + data: np.ndarray, + indices: np.ndarray, + updates: np.ndarray, + axis: int = 0, + reduction: str = "none", +) -> np.ndarray: + if axis < 0: + axis = data.ndim + axis + + idx_xsection_shape = indices.shape[:axis] + indices.shape[axis + 1 :] + + def make_slice(arr: np.ndarray, axis: int, i: int) -> list[slice | int]: + slc: list[slice | int] = [slice(None)] * arr.ndim + slc[axis] = i + return slc + + def unpack(packed: Any) -> Any: + unpacked = packed[0] + for i in range(1, len(packed)): + unpacked = unpacked, packed[i] + return unpacked + + def make_indices_for_duplicate( + idx: Sequence[Sequence[Any]], + ) -> list[tuple[Any, ...]]: + final_idx = [] + for i in range(len(idx[0])): + final_idx.append( # noqa: PERF401 + tuple(idx_element[i] for idx_element in idx) + ) + return list(final_idx) + + # We use indices and axis parameters to create idx + # idx is in a form that can be used as a NumPy advanced indices for scattering of updates param. in data + idx = [ + [ + unpack(np.indices(idx_xsection_shape).reshape(indices.ndim - 1, -1)), + indices[tuple(make_slice(indices, axis, i))].reshape(1, -1)[0], + ] + for i in range(indices.shape[axis]) + ] + idx = list(np.concatenate(idx, axis=1)) + idx.insert(axis, idx.pop()) + + # updates_idx is a NumPy advanced indices for indexing of elements in the updates + updates_idx = list(idx) + updates_idx.pop(axis) + updates_idx.insert( + axis, np.repeat(np.arange(indices.shape[axis]), np.prod(idx_xsection_shape)) + ) + + scattered = np.copy(data) + if reduction == "none": + scattered[tuple(idx)] = updates[tuple(updates_idx)] + else: + idx, updates_idx = ( + make_indices_for_duplicate(idx), + make_indices_for_duplicate(updates_idx), + ) + for iter_, idx_set in enumerate(idx): + if reduction == "add": + scattered[idx_set] += updates[updates_idx[iter_]] + elif reduction == "mul": + scattered[idx_set] *= updates[updates_idx[iter_]] + elif reduction == "max": + scattered[idx_set] = np.maximum( + scattered[idx_set], updates[updates_idx[iter_]] + ) + elif reduction == "min": + scattered[idx_set] = np.minimum( + scattered[idx_set], updates[updates_idx[iter_]] + ) + return scattered + + +class ScatterElements(Base): + @staticmethod + def export_scatter_elements_without_axis() -> None: + node = onnx.helper.make_node( + "ScatterElements", + inputs=["data", "indices", "updates"], + outputs=["y"], + ) + data = np.zeros((3, 3), dtype=np.float32) + indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64) + updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32) + + y = scatter_elements(data, indices, updates) + # print(y) produces + # [[2.0, 1.1, 0.0], + # [1.0, 0.0, 2.2], + # [0.0, 2.1, 1.2]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_elements_without_axis", + ) + + @staticmethod + def export_scatter_elements_with_axis() -> None: + axis = 1 + node = onnx.helper.make_node( + "ScatterElements", + inputs=["data", "indices", "updates"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32) + indices = np.array([[1, 3]], dtype=np.int64) + updates = np.array([[1.1, 2.1]], dtype=np.float32) + + y = scatter_elements(data, indices, updates, axis) + # print(y) produces + # [[1.0, 1.1, 3.0, 2.1, 5.0]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_elements_with_axis", + ) + + @staticmethod + def export_scatter_elements_with_negative_indices() -> None: + axis = 1 + node = onnx.helper.make_node( + "ScatterElements", + inputs=["data", "indices", "updates"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32) + indices = np.array([[1, -3]], dtype=np.int64) + updates = np.array([[1.1, 2.1]], dtype=np.float32) + + y = scatter_elements(data, indices, updates, axis) + # print(y) produces + # [[1.0, 1.1, 2.1, 4.0, 5.0]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_elements_with_negative_indices", + ) + + @staticmethod + def export_scatter_elements_with_duplicate_indices() -> None: + axis = 1 + node = onnx.helper.make_node( + "ScatterElements", + inputs=["data", "indices", "updates"], + outputs=["y"], + axis=axis, + reduction="add", + ) + data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32) + indices = np.array([[1, 1]], dtype=np.int64) + updates = np.array([[1.1, 2.1]], dtype=np.float32) + + y = scatter_elements(data, indices, updates, axis, reduction="add") + # print(y) produces + # [[1.0, 5.2, 3.0, 4.0, 5.0]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_elements_with_duplicate_indices", + ) + + @staticmethod + def export_scatter_elements_with_reduction_mul() -> None: + axis = 1 + node = onnx.helper.make_node( + "ScatterElements", + inputs=["data", "indices", "updates"], + outputs=["y"], + axis=axis, + reduction="mul", + ) + data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32) + indices = np.array([[1, 1]], dtype=np.int64) + updates = np.array([[1.1, 2.1]], dtype=np.float32) + + y = scatter_elements(data, indices, updates, axis, reduction="mul") + # print(y) produces + # [[1.0, 4.62, 3.0, 4.0, 5.0]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_elements_with_reduction_mul", + ) + + @staticmethod + def export_scatter_elements_with_reduction_max() -> None: + axis = 1 + node = onnx.helper.make_node( + "ScatterElements", + inputs=["data", "indices", "updates"], + outputs=["y"], + axis=axis, + reduction="max", + ) + data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32) + indices = np.array([[1, 1]], dtype=np.int64) + updates = np.array([[1.1, 2.1]], dtype=np.float32) + + y = scatter_elements(data, indices, updates, axis, reduction="max") + # print(y) produces + # [[1.0, 2.1, 3.0, 4.0, 5.0]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_elements_with_reduction_max", + ) + + @staticmethod + def export_scatter_elements_with_reduction_min() -> None: + axis = 1 + node = onnx.helper.make_node( + "ScatterElements", + inputs=["data", "indices", "updates"], + outputs=["y"], + axis=axis, + reduction="min", + ) + data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32) + indices = np.array([[1, 1]], dtype=np.int64) + updates = np.array([[1.1, 2.1]], dtype=np.float32) + + y = scatter_elements(data, indices, updates, axis, reduction="min") + # print(y) produces + # [[1.0, 1.1, 3.0, 4.0, 5.0]] + + expect( + node, + inputs=[data, indices, updates], + outputs=[y], + name="test_scatter_elements_with_reduction_min", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatternd.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatternd.py new file mode 100644 index 0000000000000000000000000000000000000000..aa5843a2beb8842942cc076120293729a887ac00 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/scatternd.py @@ -0,0 +1,225 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def scatter_nd_impl( + data: np.ndarray, indices: np.ndarray, updates: np.ndarray, reduction: str = "none" +) -> np.ndarray: + # Check tensor shapes + assert indices.shape[-1] <= len(data.shape) + assert updates.shape == indices.shape[:-1] + data.shape[indices.shape[-1] :] + + # Compute output + output = np.copy(data) + for i in np.ndindex(indices.shape[:-1]): + # NOTE: The order of iteration in this loop is not specified. + if reduction == "add": + output[tuple(indices[i])] += updates[i] + elif reduction == "mul": + output[tuple(indices[i])] *= updates[i] + elif reduction == "max": + output[tuple(indices[i])] = np.maximum(output[indices[i]], updates[i]) + elif reduction == "min": + output[tuple(indices[i])] = np.minimum(output[indices[i]], updates[i]) + else: + output[tuple(indices[i])] = updates[i] + return output + + +class ScatterND(Base): + @staticmethod + def export_scatternd() -> None: + node = onnx.helper.make_node( + "ScatterND", + inputs=["data", "indices", "updates"], + outputs=["y"], + ) + data = np.array( + [ + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + ], + dtype=np.float32, + ) + indices = np.array([[0], [2]], dtype=np.int64) + updates = np.array( + [ + [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], + [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + ], + dtype=np.float32, + ) + # Expecting output as np.array( + # [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], + # [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + # [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + # [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32) + output = scatter_nd_impl(data, indices, updates) + expect( + node, + inputs=[data, indices, updates], + outputs=[output], + name="test_scatternd", + ) + + @staticmethod + def export_scatternd_add() -> None: + node = onnx.helper.make_node( + "ScatterND", + inputs=["data", "indices", "updates"], + outputs=["y"], + reduction="add", + ) + data = np.array( + [ + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + ], + dtype=np.float32, + ) + indices = np.array([[0], [0]], dtype=np.int64) + updates = np.array( + [ + [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], + [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + ], + dtype=np.float32, + ) + # Expecting output as np.array( + # [[[7, 8, 9, 10], [13, 14, 15, 16], [18, 17, 16, 15], [16, 15, 14, 13]], + # [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + # [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + # [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32) + output = scatter_nd_impl(data, indices, updates, reduction="add") + expect( + node, + inputs=[data, indices, updates], + outputs=[output], + name="test_scatternd_add", + ) + + @staticmethod + def export_scatternd_multiply() -> None: + node = onnx.helper.make_node( + "ScatterND", + inputs=["data", "indices", "updates"], + outputs=["y"], + reduction="mul", + ) + data = np.array( + [ + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + ], + dtype=np.float32, + ) + indices = np.array([[0], [0]], dtype=np.int64) + updates = np.array( + [ + [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], + [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + ], + dtype=np.float32, + ) + # Expecting output as np.array( + # [[[5, 10, 15, 20], [60, 72, 84, 96], [168, 147, 126, 105], [128, 96, 64, 32]], + # [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + # [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + # [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32) + output = scatter_nd_impl(data, indices, updates, reduction="mul") + expect( + node, + inputs=[data, indices, updates], + outputs=[output], + name="test_scatternd_multiply", + ) + + @staticmethod + def export_scatternd_max() -> None: + node = onnx.helper.make_node( + "ScatterND", + inputs=["data", "indices", "updates"], + outputs=["y"], + reduction="max", + ) + data = np.array( + [ + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + ], + dtype=np.float32, + ) + indices = np.array([[0], [0]], dtype=np.int64) + updates = np.array( + [ + [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], + [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + ], + dtype=np.float32, + ) + # Expecting output as np.array( + # [[[5, 5, 5, 5], [6, 6, 7, 8], [8, 7, 7, 7], [8, 8 ,8, 8]], + # [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + # [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + # [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32) + output = scatter_nd_impl(data, indices, updates, reduction="max") + expect( + node, + inputs=[data, indices, updates], + outputs=[output], + name="test_scatternd_max", + ) + + @staticmethod + def export_scatternd_min() -> None: + node = onnx.helper.make_node( + "ScatterND", + inputs=["data", "indices", "updates"], + outputs=["y"], + reduction="min", + ) + data = np.array( + [ + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]], + ], + dtype=np.float32, + ) + indices = np.array([[0], [0]], dtype=np.int64) + updates = np.array( + [ + [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], + [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + ], + dtype=np.float32, + ) + # Expecting output as np.array( + # [[[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 3, 2, 1]], + # [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]], + # [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], + # [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32) + output = scatter_nd_impl(data, indices, updates, reduction="min") + expect( + node, + inputs=[data, indices, updates], + outputs=[output], + name="test_scatternd_min", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/selu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/selu.py new file mode 100644 index 0000000000000000000000000000000000000000..025bd81746b2c1115399653bb5fea21dce4d2e6e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/selu.py @@ -0,0 +1,49 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Selu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Selu", inputs=["x"], outputs=["y"], alpha=2.0, gamma=3.0 + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + # expected output [-3.79272318, 0., 3.] + y = ( + np.clip(x, 0, np.inf) * 3.0 + + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 * 3.0 + ) + expect(node, inputs=[x], outputs=[y], name="test_selu_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = ( + np.clip(x, 0, np.inf) * 3.0 + + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 * 3.0 + ) + expect(node, inputs=[x], outputs=[y], name="test_selu") + + @staticmethod + def export_selu_default() -> None: + default_alpha = 1.67326319217681884765625 + default_gamma = 1.05070102214813232421875 + node = onnx.helper.make_node( + "Selu", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = ( + np.clip(x, 0, np.inf) * default_gamma + + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha * default_gamma + ) + expect(node, inputs=[x], outputs=[y], name="test_selu_default") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sequence_map.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sequence_map.py new file mode 100644 index 0000000000000000000000000000000000000000..4d2ab1c1956f000c09d251e0b669de67512fe47a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sequence_map.py @@ -0,0 +1,304 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class SequenceMap(Base): + @staticmethod + def export_sequence_map_identity_1_sequence(): # type: () -> None + body = onnx.helper.make_graph( + [onnx.helper.make_node("Identity", ["in0"], ["out0"])], + "seq_map_body", + [onnx.helper.make_tensor_value_info("in0", onnx.TensorProto.FLOAT, ["N"])], + [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["M"])], + ) + + node = onnx.helper.make_node( + "SequenceMap", inputs=["x"], outputs=["y"], body=body + ) + + x = [np.random.uniform(0.0, 1.0, 10).astype(np.float32) for _ in range(3)] + y = x + input_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + ] + output_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + ] + expect( + node, + inputs=[x], + outputs=[y], + input_type_protos=input_type_protos, + output_type_protos=output_type_protos, + name="test_sequence_map_identity_1_sequence", + ) + + @staticmethod + def export_sequence_map_identity_2_sequences(): # type: () -> None + body = onnx.helper.make_graph( + [ + onnx.helper.make_node("Identity", ["in0"], ["out0"]), + onnx.helper.make_node("Identity", ["in1"], ["out1"]), + ], + "seq_map_body", + [ + onnx.helper.make_tensor_value_info( + "in0", onnx.TensorProto.FLOAT, ["N"] + ), + onnx.helper.make_tensor_value_info( + "in1", onnx.TensorProto.FLOAT, ["M"] + ), + ], + [ + onnx.helper.make_tensor_value_info( + "out0", onnx.TensorProto.FLOAT, ["N"] + ), + onnx.helper.make_tensor_value_info( + "out1", onnx.TensorProto.FLOAT, ["M"] + ), + ], + ) + + node = onnx.helper.make_node( + "SequenceMap", inputs=["x0", "x1"], outputs=["y0", "y1"], body=body + ) + + x0 = [ + np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32) + for _ in range(3) + ] + x1 = [ + np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32) + for _ in range(3) + ] + y0 = x0 + y1 = x1 + input_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"]) + ), + ] + output_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"]) + ), + ] + expect( + node, + inputs=[x0, x1], + outputs=[y0, y1], + input_type_protos=input_type_protos, + output_type_protos=output_type_protos, + name="test_sequence_map_identity_2_sequences", + ) + + @staticmethod + def export_sequence_map_identity_1_sequence_1_tensor(): # type: () -> None + body = onnx.helper.make_graph( + [ + onnx.helper.make_node("Identity", ["in0"], ["out0"]), + onnx.helper.make_node("Identity", ["in1"], ["out1"]), + ], + "seq_map_body", + [ + onnx.helper.make_tensor_value_info( + "in0", onnx.TensorProto.FLOAT, ["N"] + ), + onnx.helper.make_tensor_value_info( + "in1", onnx.TensorProto.FLOAT, ["M"] + ), + ], + [ + onnx.helper.make_tensor_value_info( + "out0", onnx.TensorProto.FLOAT, ["N"] + ), + onnx.helper.make_tensor_value_info( + "out1", onnx.TensorProto.FLOAT, ["M"] + ), + ], + ) + + node = onnx.helper.make_node( + "SequenceMap", inputs=["x0", "x1"], outputs=["y0", "y1"], body=body + ) + + x0 = [ + np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32) + for _ in range(3) + ] + x1 = np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32) + y0 = x0 + y1 = [x1 for _ in range(3)] + input_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"]), + ] + output_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"]) + ), + ] + expect( + node, + inputs=[x0, x1], + outputs=[y0, y1], + input_type_protos=input_type_protos, + output_type_protos=output_type_protos, + name="test_sequence_map_identity_1_sequence_1_tensor", + ) + + @staticmethod + def export_sequence_map_add_2_sequences(): # type: () -> None + body = onnx.helper.make_graph( + [onnx.helper.make_node("Add", ["in0", "in1"], ["out0"])], + "seq_map_body", + [ + onnx.helper.make_tensor_value_info( + "in0", onnx.TensorProto.FLOAT, ["N"] + ), + onnx.helper.make_tensor_value_info( + "in1", onnx.TensorProto.FLOAT, ["N"] + ), + ], + [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["N"])], + ) + + node = onnx.helper.make_node( + "SequenceMap", inputs=["x0", "x1"], outputs=["y0"], body=body + ) + + N = [np.random.randint(1, 10) for _ in range(3)] + x0 = [np.random.uniform(0.0, 1.0, N[k]).astype(np.float32) for k in range(3)] + x1 = [np.random.uniform(0.0, 1.0, N[k]).astype(np.float32) for k in range(3)] + y0 = [x0[k] + x1[k] for k in range(3)] + input_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + ] + output_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + ] + expect( + node, + inputs=[x0, x1], + outputs=[y0], + input_type_protos=input_type_protos, + output_type_protos=output_type_protos, + name="test_sequence_map_add_2_sequences", + ) + + @staticmethod + def export_sequence_map_add_1_sequence_1_tensor(): # type: () -> None + body = onnx.helper.make_graph( + [onnx.helper.make_node("Add", ["in0", "in1"], ["out0"])], + "seq_map_body", + [ + onnx.helper.make_tensor_value_info( + "in0", onnx.TensorProto.FLOAT, ["N"] + ), + onnx.helper.make_tensor_value_info( + "in1", onnx.TensorProto.FLOAT, ["N"] + ), + ], + [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["N"])], + ) + + node = onnx.helper.make_node( + "SequenceMap", inputs=["x0", "x1"], outputs=["y0"], body=body + ) + + x0 = [np.random.uniform(0.0, 1.0, 10).astype(np.float32) for k in range(3)] + x1 = np.random.uniform(0.0, 1.0, 10).astype(np.float32) + y0 = [x0[i] + x1 for i in range(3)] + input_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]), + ] + output_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]) + ), + ] + expect( + node, + inputs=[x0, x1], + outputs=[y0], + input_type_protos=input_type_protos, + output_type_protos=output_type_protos, + name="test_sequence_map_add_1_sequence_1_tensor", + ) + + @staticmethod + def export_sequence_map_extract_shapes(): # type: () -> None + body = onnx.helper.make_graph( + [onnx.helper.make_node("Shape", ["x"], ["shape"])], + "seq_map_body", + [ + onnx.helper.make_tensor_value_info( + "x", onnx.TensorProto.FLOAT, ["H", "W", "C"] + ) + ], + [onnx.helper.make_tensor_value_info("shape", onnx.TensorProto.INT64, [3])], + ) + + node = onnx.helper.make_node( + "SequenceMap", inputs=["in_seq"], outputs=["shapes"], body=body + ) + + shapes = [ + np.array([40, 30, 3], dtype=np.int64), + np.array([20, 10, 3], dtype=np.int64), + np.array([10, 5, 3], dtype=np.int64), + ] + x0 = [np.zeros(shape, dtype=np.float32) for shape in shapes] + input_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, ["H", "W", "C"] + ) + ), + ] + output_type_protos = [ + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.INT64, [3]) + ), + ] + expect( + node, + inputs=[x0], + outputs=[shapes], + input_type_protos=input_type_protos, + output_type_protos=output_type_protos, + name="test_sequence_map_extract_shapes", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sequenceinsert.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sequenceinsert.py new file mode 100644 index 0000000000000000000000000000000000000000..b8b80b3036d5717b3b684842fd4fc8e2469593ea --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sequenceinsert.py @@ -0,0 +1,75 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def sequence_insert_reference_implementation( + sequence: list[Any], tensor: np.ndarray, position: np.ndarray = None +) -> list[Any]: + # make a copy of input sequence + seq = list(sequence) + if position is not None: + # In these cases, insert_position will be between [-len(sequence), len(sequence)] + # The position argument will be in the format np.array([pos_index]) + insert_position = position[0] + seq.insert(insert_position, tensor) + else: + # Default position of insertion is at the end of the sequence. + seq.append(tensor) + return seq + + +class SequenceInsert(Base): + @staticmethod + def export() -> None: + test_cases = { + "at_back": [np.array([10, 11, 12]).astype(np.int64)], + "at_front": [np.array([-2, -1, 0]), np.array([0]).astype(np.int64)], + } + sequence = [ + np.array([1, 2, 3, 4]).astype(np.int64), + np.array([5, 6, 7]).astype(np.int64), + np.array([8, 9]).astype(np.int64), + ] + + for test_name, test_inputs in test_cases.items(): + tensor = test_inputs[0].astype(np.int64) + + if len(test_inputs) > 1: + node = onnx.helper.make_node( + "SequenceInsert", + inputs=["sequence", "tensor", "position"], + outputs=["output_sequence"], + ) + position = test_inputs[1] + inserted = sequence_insert_reference_implementation( + sequence, tensor, position + ) + expect( + node, + inputs=[sequence, tensor, position], + outputs=[inserted], + name="test_sequence_insert_" + test_name, + ) + else: + node = onnx.helper.make_node( + "SequenceInsert", + inputs=["sequence", "tensor"], + outputs=["output_sequence"], + ) + inserted = sequence_insert_reference_implementation(sequence, tensor) + expect( + node, + inputs=[sequence, tensor], + outputs=[inserted], + name="test_sequence_insert_" + test_name, + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/shape.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/shape.py new file mode 100644 index 0000000000000000000000000000000000000000..8238214d597448ef3f1c6cc52351beb45cec9153 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/shape.py @@ -0,0 +1,64 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# Reference implementation of shape op +def shape_reference_impl( + x: np.ndarray, start: int | None = None, end: int | None = None +) -> np.ndarray: + dims = x.shape[start:end] + return np.array(dims).astype(np.int64) + + +def test_shape( + testname: str, xval: np.ndarray, start: int | None = None, end: int | None = None +) -> None: + node = onnx.helper.make_node( + "Shape", inputs=["x"], outputs=["y"], start=start, end=end + ) + + yval = shape_reference_impl(xval, start, end) + + expect(node, inputs=[xval], outputs=[yval], name="test_shape" + testname) + + +class Shape(Base): + @staticmethod + def export() -> None: + x = np.array( + [ + [1, 2, 3], + [4, 5, 6], + ] + ).astype(np.float32) + test_shape("_example", x) # preserve names of original test cases + + x = np.random.randn(3, 4, 5).astype(np.float32) + + test_shape("", x) # preserve names of original test cases + + test_shape("_start_1", x, start=1) + + test_shape("_end_1", x, end=1) + + test_shape("_start_negative_1", x, start=-1) + + test_shape("_end_negative_1", x, end=-1) + + test_shape("_start_1_end_negative_1", x, start=1, end=-1) + + test_shape("_start_1_end_2", x, start=1, end=2) + + test_shape("_clip_start", x, start=-10) + + test_shape("_clip_end", x, end=10) + + test_shape("_start_greater_than_end", x, start=2, end=1) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/shrink.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/shrink.py new file mode 100644 index 0000000000000000000000000000000000000000..d800ebac29ed6d110c2254d2e257d073cc171ce3 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/shrink.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Shrink(Base): + @staticmethod + def export_hard_shrink() -> None: + node = onnx.helper.make_node( + "Shrink", + inputs=["x"], + outputs=["y"], + lambd=1.5, + ) + X = np.arange(-2.0, 2.1, dtype=np.float32) + Y = np.array([-2, 0, 0, 0, 2], dtype=np.float32) + expect(node, inputs=[X], outputs=[Y], name="test_shrink_hard") + + @staticmethod + def export_soft_shrink() -> None: + node = onnx.helper.make_node( + "Shrink", + inputs=["x"], + outputs=["y"], + lambd=1.5, + bias=1.5, + ) + X = np.arange(-2.0, 2.1, dtype=np.float32) + Y = np.array([-0.5, 0, 0, 0, 0.5], dtype=np.float32) + expect(node, inputs=[X], outputs=[Y], name="test_shrink_soft") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sigmoid.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sigmoid.py new file mode 100644 index 0000000000000000000000000000000000000000..33e503ef4179b6e88cc0a5a82177b6e9e82d87ac --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sigmoid.py @@ -0,0 +1,30 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Sigmoid(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Sigmoid", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = 1.0 / ( + 1.0 + np.exp(np.negative(x)) + ) # expected output [0.26894143, 0.5, 0.7310586] + expect(node, inputs=[x], outputs=[y], name="test_sigmoid_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = 1.0 / (1.0 + np.exp(np.negative(x))) + expect(node, inputs=[x], outputs=[y], name="test_sigmoid") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sign.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sign.py new file mode 100644 index 0000000000000000000000000000000000000000..965345d5e25a6c935f078f5430e117da6e81dd4e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sign.py @@ -0,0 +1,24 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Sign(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Sign", + inputs=["x"], + outputs=["y"], + ) + + x = np.array(range(-5, 6)).astype(np.float32) + y = np.sign(x) + expect(node, inputs=[x], outputs=[y], name="test_sign") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sin.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sin.py new file mode 100644 index 0000000000000000000000000000000000000000..9f2ea24e660f7c62bb7007fd54e0d2d5af781f77 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sin.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Sin(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Sin", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.sin(x) + expect(node, inputs=[x], outputs=[y], name="test_sin_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.sin(x) + expect(node, inputs=[x], outputs=[y], name="test_sin") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sinh.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sinh.py new file mode 100644 index 0000000000000000000000000000000000000000..a5d97cd904848f6a4687629796519be3e987f442 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sinh.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Sinh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Sinh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.sinh(x) # expected output [-1.17520118, 0., 1.17520118] + expect(node, inputs=[x], outputs=[y], name="test_sinh_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.sinh(x) + expect(node, inputs=[x], outputs=[y], name="test_sinh") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/size.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/size.py new file mode 100644 index 0000000000000000000000000000000000000000..37acd516a5c85184face3ec7c311183e2a420d9c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/size.py @@ -0,0 +1,35 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Size(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Size", + inputs=["x"], + outputs=["y"], + ) + + x = np.array( + [ + [1, 2, 3], + [4, 5, 6], + ] + ).astype(np.float32) + y = np.array(6).astype(np.int64) + + expect(node, inputs=[x], outputs=[y], name="test_size_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.array(x.size).astype(np.int64) + + expect(node, inputs=[x], outputs=[y], name="test_size") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/slice.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/slice.py new file mode 100644 index 0000000000000000000000000000000000000000..5d4cb43d6c30c2d7ef913829d983eab2843332cd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/slice.py @@ -0,0 +1,178 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Slice(Base): + @staticmethod + def export_slice() -> None: + node = onnx.helper.make_node( + "Slice", + inputs=["x", "starts", "ends", "axes", "steps"], + outputs=["y"], + ) + + x = np.random.randn(20, 10, 5).astype(np.float32) + y = x[0:3, 0:10] + starts = np.array([0, 0], dtype=np.int64) + ends = np.array([3, 10], dtype=np.int64) + axes = np.array([0, 1], dtype=np.int64) + steps = np.array([1, 1], dtype=np.int64) + + expect( + node, inputs=[x, starts, ends, axes, steps], outputs=[y], name="test_slice" + ) + + @staticmethod + def export_slice_neg() -> None: + node = onnx.helper.make_node( + "Slice", + inputs=["x", "starts", "ends", "axes", "steps"], + outputs=["y"], + ) + + x = np.random.randn(20, 10, 5).astype(np.float32) + starts = np.array([0], dtype=np.int64) + ends = np.array([-1], dtype=np.int64) + axes = np.array([1], dtype=np.int64) + steps = np.array([1], dtype=np.int64) + y = x[:, 0:-1] + + expect( + node, + inputs=[x, starts, ends, axes, steps], + outputs=[y], + name="test_slice_neg", + ) + + @staticmethod + def export_slice_start_out_of_bounds() -> None: + node = onnx.helper.make_node( + "Slice", + inputs=["x", "starts", "ends", "axes", "steps"], + outputs=["y"], + ) + + x = np.random.randn(20, 10, 5).astype(np.float32) + starts = np.array([1000], dtype=np.int64) + ends = np.array([1000], dtype=np.int64) + axes = np.array([1], dtype=np.int64) + steps = np.array([1], dtype=np.int64) + y = x[:, 1000:1000] + + expect( + node, + inputs=[x, starts, ends, axes, steps], + outputs=[y], + name="test_slice_start_out_of_bounds", + ) + + @staticmethod + def export_slice_end_out_of_bounds() -> None: + node = onnx.helper.make_node( + "Slice", + inputs=["x", "starts", "ends", "axes", "steps"], + outputs=["y"], + ) + + x = np.random.randn(20, 10, 5).astype(np.float32) + starts = np.array([1], dtype=np.int64) + ends = np.array([1000], dtype=np.int64) + axes = np.array([1], dtype=np.int64) + steps = np.array([1], dtype=np.int64) + y = x[:, 1:1000] + + expect( + node, + inputs=[x, starts, ends, axes, steps], + outputs=[y], + name="test_slice_end_out_of_bounds", + ) + + @staticmethod + def export_slice_default_axes() -> None: + node = onnx.helper.make_node( + "Slice", + inputs=["x", "starts", "ends"], + outputs=["y"], + ) + + x = np.random.randn(20, 10, 5).astype(np.float32) + starts = np.array([0, 0, 3], dtype=np.int64) + ends = np.array([20, 10, 4], dtype=np.int64) + y = x[:, :, 3:4] + + expect( + node, inputs=[x, starts, ends], outputs=[y], name="test_slice_default_axes" + ) + + @staticmethod + def export_slice_default_steps() -> None: + node = onnx.helper.make_node( + "Slice", + inputs=["x", "starts", "ends", "axes"], + outputs=["y"], + ) + + x = np.random.randn(20, 10, 5).astype(np.float32) + starts = np.array([0, 0, 3], dtype=np.int64) + ends = np.array([20, 10, 4], dtype=np.int64) + axes = np.array([0, 1, 2], dtype=np.int64) + y = x[:, :, 3:4] + + expect( + node, + inputs=[x, starts, ends, axes], + outputs=[y], + name="test_slice_default_steps", + ) + + @staticmethod + def export_slice_neg_steps() -> None: + node = onnx.helper.make_node( + "Slice", + inputs=["x", "starts", "ends", "axes", "steps"], + outputs=["y"], + ) + + x = np.random.randn(20, 10, 5).astype(np.float32) + starts = np.array([20, 10, 4], dtype=np.int64) + ends = np.array([0, 0, 1], dtype=np.int64) + axes = np.array([0, 1, 2], dtype=np.int64) + steps = np.array([-1, -3, -2]).astype(np.int64) + y = x[20:0:-1, 10:0:-3, 4:1:-2] + + expect( + node, + inputs=[x, starts, ends, axes, steps], + outputs=[y], + name="test_slice_neg_steps", + ) + + @staticmethod + def export_slice_negative_axes() -> None: + node = onnx.helper.make_node( + "Slice", + inputs=["x", "starts", "ends", "axes"], + outputs=["y"], + ) + + x = np.random.randn(20, 10, 5).astype(np.float32) + starts = np.array([0, 0, 3], dtype=np.int64) + ends = np.array([20, 10, 4], dtype=np.int64) + axes = np.array([0, -2, -1], dtype=np.int64) + y = x[:, :, 3:4] + + expect( + node, + inputs=[x, starts, ends, axes], + outputs=[y], + name="test_slice_negative_axes", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softmax.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softmax.py new file mode 100644 index 0000000000000000000000000000000000000000..ae45f4068133a4e5b4de0a403e2e06ed4d4963c0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softmax.py @@ -0,0 +1,91 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def softmax(x: np.ndarray, axis: int = -1) -> np.ndarray: + x_max = np.max(x, axis=axis, keepdims=True) + tmp = np.exp(x - x_max) + s = np.sum(tmp, axis=axis, keepdims=True) + return tmp / s + + +class Softmax(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Softmax", + inputs=["x"], + outputs=["y"], + ) + x = np.array([[-1, 0, 1]]).astype(np.float32) + # expected output [[0.09003058, 0.24472848, 0.66524094]] + y = softmax(x, axis=1) + expect(node, inputs=[x], outputs=[y], name="test_softmax_example") + + @staticmethod + def export_softmax_axis() -> None: + x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32) + # expected output + # [[0.032058604 0.08714432 0.23688284 0.6439143 ] + # [0.032058604 0.08714432 0.23688284 0.6439143 ]] + y = softmax(x) + + node = onnx.helper.make_node( + "Softmax", + inputs=["x"], + outputs=["y"], + ) + expect(node, inputs=[x], outputs=[y], name="test_softmax_large_number") + + x = np.abs(np.random.randn(3, 4, 5).astype(np.float32)) + node = onnx.helper.make_node( + "Softmax", + inputs=["x"], + outputs=["y"], + axis=0, + ) + y = softmax(x, axis=0) + expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_0") + + node = onnx.helper.make_node( + "Softmax", + inputs=["x"], + outputs=["y"], + axis=1, + ) + y = softmax(x, axis=1) + expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_1") + + node = onnx.helper.make_node( + "Softmax", + inputs=["x"], + outputs=["y"], + axis=2, + ) + y = softmax(x, axis=2) + expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_2") + + node = onnx.helper.make_node( + "Softmax", + inputs=["x"], + outputs=["y"], + axis=-1, + ) + y = softmax(x, axis=-1) + expect(node, inputs=[x], outputs=[y], name="test_softmax_negative_axis") + + # default axis is -1 + node = onnx.helper.make_node( + "Softmax", + inputs=["x"], + outputs=["y"], + ) + expect(node, inputs=[x], outputs=[y], name="test_softmax_default_axis") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softmaxcrossentropy.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softmaxcrossentropy.py new file mode 100644 index 0000000000000000000000000000000000000000..dc6f8865dd527bfa9b9edf37f1c080a86637b8f8 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softmaxcrossentropy.py @@ -0,0 +1,1158 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def softmaxcrossentropy( + x: np.ndarray, + target: np.ndarray, + weight: np.ndarray | None = None, + reduction: str = "mean", + ignore_index: int | None = None, + get_log_prob: bool | None = None, +) -> Any: + input_shape = x.shape + if len(input_shape) == 1: + raise RuntimeError("Unsupported shape") + + target_shape = target.shape + N = input_shape[0] + C = input_shape[1] + + # compute log_softmax + max_x = np.max(x, axis=1, keepdims=True) + exp_x = np.exp(x - max_x) + p = exp_x / np.sum(exp_x, axis=1, keepdims=True) + inp = np.log(p) + log_prob = None + if get_log_prob is True: + log_prob = np.copy(inp) + + # initialize the positional weights when required + gather_weight = None + if weight is not None: + # setting mode='clip' to deal with ignore_index > C or < 0 cases. + # when the target value is > C or < 0, it doesn't matter which value we are + # taking in gather_weight, since it will be set to 0 in the following if-block + # use np.int32 to make it compatible with x86 machines + gather_weight = np.take(weight, np.array(target, dtype=np.int32), mode="clip") + # set `ignore_index`'s loss weight to 0. + # The loss tensor will be multiplied by this weight tensor, + # so `ignore_index`'s loss value will be eliminated. + if ignore_index is not None: + gather_weight = np.where(target == ignore_index, 0, gather_weight).astype( + dtype=np.float32 + ) + elif ignore_index is not None: + gather_weight = np.where(target == ignore_index, 0, 1).astype(dtype=np.float32) + + # if input is 4-d and above, make it 3-d + if len(input_shape) != 3: + inp = inp.reshape((N, C, -1)) + target = target.reshape((N, -1)) + + # Get a dimension from the reshaped input. + # If the original input shape is [N, C, H, W], + # the D here should be H * W because we reshape + # [N, C, H, W] to [N, C, H * W]. + D = inp.shape[2] + neg_gather_element_input = np.zeros((N, D), dtype=np.float32) + for i in range(N): + for d in range(D): + if target[i][d] != ignore_index: + neg_gather_element_input[i][d] = -inp[i][target[i][d]][d] + + loss = neg_gather_element_input + + # if the input was 4-d or above reshape to the right shape + if len(input_shape) != 3: + loss = loss.reshape(target_shape) + + # apply the weights when required + if gather_weight is not None: + loss = gather_weight * loss + if reduction == "mean": + loss = loss.sum() / gather_weight.sum() + if get_log_prob is True: + return loss, log_prob + return loss + + if reduction == "mean": + loss = np.mean(loss) + elif reduction == "sum": + loss = np.sum(loss) + + if get_log_prob: + return loss, log_prob + return loss + + +class SoftmaxCrossEntropyLoss(Base): + @staticmethod + def export_softmaxcrossentropy_none() -> None: + # Define operator attributes. + reduction = "none" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels, reduction="none") + + # Check results + expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_none") + + @staticmethod + def export_softmaxcrossentropy_none_log_prob() -> None: + # Define operator attributes. + reduction = "none" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, reduction="none", get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels], + outputs=[loss, log_prob], + name="test_sce_none_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_none_weights() -> None: + # Define operator attributes. + reduction = "none" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels, weight=weights, reduction="none") + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[sce], + name="test_sce_none_weights", + ) + + @staticmethod + def export_softmaxcrossentropy_none_weights_log_prob() -> None: + # Define operator attributes. + reduction = "none" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z", "log_prob"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, weight=weights, reduction="none", get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[loss, log_prob], + name="test_sce_none_weights_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_sum() -> None: + # Define operator attributes. + reduction = "sum" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels, reduction="sum") + + # Check results + expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_sum") + + @staticmethod + def export_softmaxcrossentropy_sum_log_prob() -> None: + # Define operator attributes. + reduction = "sum" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, reduction="sum", get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels], + outputs=[loss, log_prob], + name="test_sce_sum_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean() -> None: + # Define operator attributes. + reduction = "mean" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels) + + # Check results + expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_mean") + + @staticmethod + def export_softmaxcrossentropy_mean_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy(x, labels, get_log_prob=True) + + # Check results + expect( + node, + inputs=[x, labels], + outputs=[loss, log_prob], + name="test_sce_mean_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_3d() -> None: + # Define operator attributes. + reduction = "mean" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2).astype(np.float32) + y = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, y) + + # Check results + expect(node, inputs=[x, y], outputs=[sce], name="test_sce_mean_3d") + + @staticmethod + def export_softmaxcrossentropy_mean_3d_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2).astype(np.float32) + y = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy(x, y, get_log_prob=True) + + # Check results + expect( + node, + inputs=[x, y], + outputs=[loss, log_prob], + name="test_sce_mean_3d_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_weights() -> None: + # Define operator attributes. + reduction = "mean" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels, weight=weights) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[sce], + name="test_sce_mean_weight", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_weights_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z", "log_prob"], + reduction=reduction, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, weight=weights, get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[loss, log_prob], + name="test_sce_mean_weight_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_weights_ii() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(0) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + labels[0] = np.int64(0) + weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels, weight=weights, ignore_index=ignore_index) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[sce], + name="test_sce_mean_weight_ii", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_weights_ii_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(0) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + labels[0] = np.int64(0) + weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, weight=weights, ignore_index=ignore_index, get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[loss, log_prob], + name="test_sce_mean_weight_ii_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_no_weights_ii() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(2) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + labels[0] = np.int64(2) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels, ignore_index=ignore_index) + + # Check results + expect( + node, inputs=[x, labels], outputs=[sce], name="test_sce_mean_no_weight_ii" + ) + + @staticmethod + def export_softmaxcrossentropy_mean_no_weights_ii_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(2) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64) + labels[0] = np.int64(2) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, ignore_index=ignore_index, get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels], + outputs=[loss, log_prob], + name="test_sce_mean_no_weight_ii_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_weights_ii_3d() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(1) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64) + labels[0][0] = np.int64(1) + weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels, weight=weights, ignore_index=ignore_index) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[sce], + name="test_sce_mean_weight_ii_3d", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_weights_ii_3d_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(1) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64) + labels[0][0] = np.int64(1) + weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, weight=weights, ignore_index=ignore_index, get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[loss, log_prob], + name="test_sce_mean_weight_ii_3d_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_no_weights_ii_3d() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(2) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64) + labels[0][0] = np.int64(2) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy(x, labels, ignore_index=ignore_index) + + # Check results + expect( + node, + inputs=[x, labels], + outputs=[sce], + name="test_sce_mean_no_weight_ii_3d", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_no_weights_ii_3d_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(2) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64) + labels[0][0] = np.int64(2) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, ignore_index=ignore_index, get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels], + outputs=[loss, log_prob], + name="test_sce_mean_no_weight_ii_3d_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_weights_ii_4d() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(2) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2, 7).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64) + labels[0][0][0] = np.int64(2) + weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy( + x, labels, reduction=reduction, weight=weights, ignore_index=ignore_index + ) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[sce], + name="test_sce_mean_weight_ii_4d", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_weights_ii_4d_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(2) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2, 7).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64) + labels[0][0][0] = np.int64(2) + weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, + labels, + reduction=reduction, + weight=weights, + ignore_index=ignore_index, + get_log_prob=True, + ) + + # Check results + expect( + node, + inputs=[x, labels, weights], + outputs=[loss, log_prob], + name="test_sce_mean_weight_ii_4d_log_prob", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_no_weights_ii_4d() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(2) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2, 7).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64) + labels[0][0][0] = np.int64(2) + + # Compute SoftmaxCrossEntropyLoss + sce = softmaxcrossentropy( + x, labels, reduction=reduction, ignore_index=ignore_index + ) + + # Check results + expect( + node, + inputs=[x, labels], + outputs=[sce], + name="test_sce_mean_no_weight_ii_4d", + ) + + @staticmethod + def export_softmaxcrossentropy_mean_no_weights_ii_4d_log_prob() -> None: + # Define operator attributes. + reduction = "mean" + ignore_index = np.int64(2) + + # Create operator. + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + # Define operator inputs. + np.random.seed(0) + x = np.random.rand(3, 5, 2, 7).astype(np.float32) + labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64) + labels[0][0][0] = np.int64(2) + + # Compute SoftmaxCrossEntropyLoss + loss, log_prob = softmaxcrossentropy( + x, labels, reduction=reduction, ignore_index=ignore_index, get_log_prob=True + ) + + # Check results + expect( + node, + inputs=[x, labels], + outputs=[loss, log_prob], + name="test_sce_mean_no_weight_ii_4d_log_prob", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3d4d5_mean_weight() -> None: + reduction = "mean" + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z"], + reduction=reduction, + ) + + N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4 + np.random.seed(0) + x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32) + labels = np.random.randint( + 0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5) + ).astype(np.int64) + weight = np.random.rand(C).astype(np.float32) + + sce = softmaxcrossentropy(x, labels, weight=weight, reduction=reduction) + + expect( + node, + inputs=[x, labels, weight], + outputs=[sce], + name="test_sce_NCd1d2d3d4d5_mean_weight", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3d4d5_mean_weight_log_prob() -> None: + reduction = "mean" + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z", "log_prob"], + reduction=reduction, + ) + + N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4 + np.random.seed(0) + x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32) + labels = np.random.randint( + 0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5) + ).astype(np.int64) + weight = np.random.rand(C).astype(np.float32) + + loss, log_prob = softmaxcrossentropy( + x, labels, weight=weight, reduction=reduction, get_log_prob=True + ) + + expect( + node, + inputs=[x, labels, weight], + outputs=[loss, log_prob], + name="test_sce_NCd1d2d3d4d5_mean_weight_log_prob", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3d4d5_none_no_weight() -> None: + reduction = "none" + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ) + + N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4 + np.random.seed(0) + x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32) + labels = np.random.randint( + 0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5) + ).astype(np.int64) + + sce = softmaxcrossentropy(x, labels, reduction=reduction) + + expect( + node, + inputs=[x, labels], + outputs=[sce], + name="test_sce_NCd1d2d3d4d5_none_no_weight", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3d4d5_none_no_weight_log_prob() -> None: + reduction = "none" + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ) + + N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4 + np.random.seed(0) + x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32) + labels = np.random.randint( + 0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5) + ).astype(np.int64) + + loss, log_prob = softmaxcrossentropy( + x, labels, reduction=reduction, get_log_prob=True + ) + + expect( + node, + inputs=[x, labels], + outputs=[loss, log_prob], + name="test_sce_NCd1d2d3d4d5_none_no_weight_log_prob", + ) + + @staticmethod + def export_input_shape_is_NCd1_mean_weight_negative_ii() -> None: + reduction = "mean" + ignore_index = np.int64(-1) + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, dim1 = 3, 5, 6 + np.random.seed(0) + x = np.random.rand(N, C, dim1).astype(np.float32) + labels = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64) + labels[0][0] = -1 + weight = np.random.rand(C).astype(np.float32) + + sce = softmaxcrossentropy( + x, labels, weight=weight, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[x, labels, weight], + outputs=[sce], + name="test_sce_NCd1_mean_weight_negative_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1_mean_weight_negative_ii_log_prob() -> None: + reduction = "mean" + ignore_index = np.int64(-1) + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, dim1 = 3, 5, 6 + np.random.seed(0) + x = np.random.rand(N, C, dim1).astype(np.float32) + labels = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64) + labels[0][0] = -1 + weight = np.random.rand(C).astype(np.float32) + + loss, log_prob = softmaxcrossentropy( + x, + labels, + weight=weight, + reduction=reduction, + ignore_index=ignore_index, + get_log_prob=True, + ) + + expect( + node, + inputs=[x, labels, weight], + outputs=[loss, log_prob], + name="test_sce_NCd1_mean_weight_negative_ii_log_prob", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3_none_no_weight_negative_ii() -> None: + reduction = "none" + ignore_index = np.int64(-5) + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5 + np.random.seed(0) + x = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32) + labels = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype( + np.int64 + ) + labels[0][0][0][0] = -5 + + sce = softmaxcrossentropy( + x, labels, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[x, labels], + outputs=[sce], + name="test_sce_NCd1d2d3_none_no_weight_negative_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3_none_no_weight_negative_ii_log_prob() -> None: + reduction = "none" + ignore_index = np.int64(-5) + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5 + np.random.seed(0) + x = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32) + labels = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype( + np.int64 + ) + labels[0][0][0][0] = -5 + + loss, log_prob = softmaxcrossentropy( + x, labels, reduction=reduction, ignore_index=ignore_index, get_log_prob=True + ) + + expect( + node, + inputs=[x, labels], + outputs=[loss, log_prob], + name="test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3_sum_weight_high_ii() -> None: + reduction = "sum" + ignore_index = np.int64(10) + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C = 3, 5 + np.random.seed(0) + x = np.random.rand(N, C).astype(np.float32) + labels = np.random.randint(0, high=C, size=(N)).astype(np.int64) + labels[0] = 10 + weight = np.random.rand(C).astype(np.float32) + + sce = softmaxcrossentropy( + x, labels, weight=weight, reduction=reduction, ignore_index=ignore_index + ) + + expect( + node, + inputs=[x, labels, weight], + outputs=[sce], + name="test_sce_NCd1d2d3_sum_weight_high_ii", + ) + + @staticmethod + def export_input_shape_is_NCd1d2d3_sum_weight_high_ii_log_prob() -> None: + reduction = "sum" + ignore_index = np.int64(10) + + node = onnx.helper.make_node( + "SoftmaxCrossEntropyLoss", + inputs=["x", "y", "w"], + outputs=["z", "log_prob"], + reduction=reduction, + ignore_index=ignore_index, + ) + + N, C = 3, 5 + np.random.seed(0) + x = np.random.rand(N, C).astype(np.float32) + labels = np.random.randint(0, high=C, size=(N)).astype(np.int64) + labels[0] = 10 + weight = np.random.rand(C).astype(np.float32) + + loss, log_prob = softmaxcrossentropy( + x, + labels, + weight=weight, + reduction=reduction, + ignore_index=ignore_index, + get_log_prob=True, + ) + + expect( + node, + inputs=[x, labels, weight], + outputs=[loss, log_prob], + name="test_sce_NCd1d2d3_sum_weight_high_ii_log_prob", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softplus.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softplus.py new file mode 100644 index 0000000000000000000000000000000000000000..503a65343977a130fd4a82cf30781af02b8c4a1e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softplus.py @@ -0,0 +1,30 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Softplus(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Softplus", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.log( + np.exp(x) + 1 + ) # expected output [0.31326166, 0.69314718, 1.31326163] + expect(node, inputs=[x], outputs=[y], name="test_softplus_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.log(np.exp(x) + 1) + expect(node, inputs=[x], outputs=[y], name="test_softplus") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softsign.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softsign.py new file mode 100644 index 0000000000000000000000000000000000000000..476f55ddb711c9c4c43f4f121306dbd8bc9054cd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/softsign.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Softsign(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Softsign", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.array([-0.5, 0, 0.5]).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_softsign_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = x / (1 + np.abs(x)) + expect(node, inputs=[x], outputs=[y], name="test_softsign") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/spacetodepth.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/spacetodepth.py new file mode 100644 index 0000000000000000000000000000000000000000..157a6d392bbf0018928a888a27125b8a2be4930c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/spacetodepth.py @@ -0,0 +1,66 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class SpaceToDepth(Base): + @staticmethod + def export() -> None: + b, c, h, w = shape = (2, 2, 6, 6) + blocksize = 2 + node = onnx.helper.make_node( + "SpaceToDepth", + inputs=["x"], + outputs=["y"], + blocksize=blocksize, + ) + x = np.random.random_sample(shape).astype(np.float32) + tmp = np.reshape( + x, [b, c, h // blocksize, blocksize, w // blocksize, blocksize] + ) + tmp = np.transpose(tmp, [0, 3, 5, 1, 2, 4]) + y = np.reshape(tmp, [b, c * (blocksize**2), h // blocksize, w // blocksize]) + expect(node, inputs=[x], outputs=[y], name="test_spacetodepth") + + @staticmethod + def export_example() -> None: + node = onnx.helper.make_node( + "SpaceToDepth", + inputs=["x"], + outputs=["y"], + blocksize=2, + ) + + # (1, 1, 4, 6) input tensor + x = np.array( + [ + [ + [ + [0, 6, 1, 7, 2, 8], + [12, 18, 13, 19, 14, 20], + [3, 9, 4, 10, 5, 11], + [15, 21, 16, 22, 17, 23], + ] + ] + ] + ).astype(np.float32) + + # (1, 4, 2, 3) output tensor + y = np.array( + [ + [ + [[0, 1, 2], [3, 4, 5]], + [[6, 7, 8], [9, 10, 11]], + [[12, 13, 14], [15, 16, 17]], + [[18, 19, 20], [21, 22, 23]], + ] + ] + ).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_spacetodepth_example") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/split.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/split.py new file mode 100644 index 0000000000000000000000000000000000000000..f93d7cb8db0944b81c95ed34ccfa03af5abc4207 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/split.py @@ -0,0 +1,378 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Split(Base): + @staticmethod + def export_1d_opset13() -> None: + node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32) + + node = onnx.helper.make_node( + "Split", + inputs=["input"], + outputs=["output_1", "output_2", "output_3"], + axis=0, + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0]).astype(np.float32), + np.array([5.0, 6.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input], + outputs=expected_outputs, + name="test_split_equal_parts_1d_opset13", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + split = np.array([2, 4]).astype(np.int64) + node = onnx.helper.make_node( + "Split", + inputs=["input", "split"], + outputs=["output_1", "output_2"], + axis=0, + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input, split], + outputs=expected_outputs, + name="test_split_variable_parts_1d_opset13", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + @staticmethod + def export_2d_opset13() -> None: + node_input = np.array( + [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0, 11.0, 12.0]] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Split", inputs=["input"], outputs=["output_1", "output_2"], axis=1 + ) + + expected_outputs = [ + np.array([[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]).astype(np.float32), + np.array([[4.0, 5.0, 6.0], [10.0, 11.0, 12.0]]).astype(np.float32), + ] + + expect( + node, + inputs=[node_input], + outputs=expected_outputs, + name="test_split_equal_parts_2d_opset13", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + split = np.array([2, 4]).astype(np.int64) + node = onnx.helper.make_node( + "Split", + inputs=["input", "split"], + outputs=["output_1", "output_2"], + axis=1, + ) + + expected_outputs = [ + np.array([[1.0, 2.0], [7.0, 8.0]]).astype(np.float32), + np.array([[3.0, 4.0, 5.0, 6.0], [9.0, 10.0, 11.0, 12.0]]).astype( + np.float32 + ), + ] + + expect( + node, + inputs=[node_input, split], + outputs=expected_outputs, + name="test_split_variable_parts_2d_opset13", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + @staticmethod + def export_default_values_opset13() -> None: + node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32) + + # If axis is not specified, split is applied on default axis 0 + node = onnx.helper.make_node( + "Split", inputs=["input"], outputs=["output_1", "output_2", "output_3"] + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0]).astype(np.float32), + np.array([5.0, 6.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input], + outputs=expected_outputs, + name="test_split_equal_parts_default_axis_opset13", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + split = np.array([2, 4]).astype(np.int64) + node = onnx.helper.make_node( + "Split", inputs=["input", "split"], outputs=["output_1", "output_2"] + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input, split], + outputs=expected_outputs, + name="test_split_variable_parts_default_axis_opset13", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + @staticmethod + def export_zero_size_splits_opset13() -> None: + # 1-dimensional tensor with dimension_size=0 + node_input = np.array([]).astype(np.float32) + + # Split empty tensor to tensors of size zero + split = np.array([0, 0, 0]).astype(np.int64) + node = onnx.helper.make_node( + "Split", + inputs=["input", "split"], + outputs=["output_1", "output_2", "output_3"], + ) + + expected_outputs = [ + np.array([]).astype(np.float32), + np.array([]).astype(np.float32), + np.array([]).astype(np.float32), + ] + expect( + node, + inputs=[node_input, split], + outputs=expected_outputs, + name="test_split_zero_size_splits_opset13", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + @staticmethod + def export_1d_opset18() -> None: + node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32) + + node = onnx.helper.make_node( + "Split", + inputs=["input"], + outputs=["output_1", "output_2", "output_3"], + axis=0, + num_outputs=3, + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0]).astype(np.float32), + np.array([5.0, 6.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input], + outputs=expected_outputs, + name="test_split_equal_parts_1d_opset18", + ) + + split = np.array([2, 4]).astype(np.int64) + node = onnx.helper.make_node( + "Split", + inputs=["input", "split"], + outputs=["output_1", "output_2"], + axis=0, + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input, split], + outputs=expected_outputs, + name="test_split_variable_parts_1d_opset18", + ) + + @staticmethod + def export_2d_opset18() -> None: + node_input = np.array( + [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0, 11.0, 12.0]] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Split", + inputs=["input"], + outputs=["output_1", "output_2"], + axis=1, + num_outputs=2, + ) + + expected_outputs = [ + np.array([[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]).astype(np.float32), + np.array([[4.0, 5.0, 6.0], [10.0, 11.0, 12.0]]).astype(np.float32), + ] + + expect( + node, + inputs=[node_input], + outputs=expected_outputs, + name="test_split_equal_parts_2d", + ) + + split = np.array([2, 4]).astype(np.int64) + node = onnx.helper.make_node( + "Split", + inputs=["input", "split"], + outputs=["output_1", "output_2"], + axis=1, + ) + + expected_outputs = [ + np.array([[1.0, 2.0], [7.0, 8.0]]).astype(np.float32), + np.array([[3.0, 4.0, 5.0, 6.0], [9.0, 10.0, 11.0, 12.0]]).astype( + np.float32 + ), + ] + + expect( + node, + inputs=[node_input, split], + outputs=expected_outputs, + name="test_split_variable_parts_2d_opset18", + ) + + @staticmethod + def export_default_values_opset18() -> None: + node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32) + + # If axis is not specified, split is applied on default axis 0 + node = onnx.helper.make_node( + "Split", + inputs=["input"], + outputs=["output_1", "output_2", "output_3"], + num_outputs=3, + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0]).astype(np.float32), + np.array([5.0, 6.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input], + outputs=expected_outputs, + name="test_split_equal_parts_default_axis_opset18", + ) + + split = np.array([2, 4]).astype(np.int64) + node = onnx.helper.make_node( + "Split", inputs=["input", "split"], outputs=["output_1", "output_2"] + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input, split], + outputs=expected_outputs, + name="test_split_variable_parts_default_axis_opset18", + ) + + @staticmethod + def export_zero_size_splits_opset18() -> None: + # 1-dimensional tensor with dimension_size=0 + node_input = np.array([]).astype(np.float32) + + # Split empty tensor to tensors of size zero + split = np.array([0, 0, 0]).astype(np.int64) + node = onnx.helper.make_node( + "Split", + inputs=["input", "split"], + outputs=["output_1", "output_2", "output_3"], + ) + + expected_outputs = [ + np.array([]).astype(np.float32), + np.array([]).astype(np.float32), + np.array([]).astype(np.float32), + ] + expect( + node, + inputs=[node_input, split], + outputs=expected_outputs, + name="test_split_zero_size_splits_opset18", + ) + + @staticmethod + def export_1d_uneven_split_opset18() -> None: + node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]).astype(np.float32) + + # If axis is not specified, split is applied on default axis 0 + node = onnx.helper.make_node( + "Split", + inputs=["input"], + outputs=["output_1", "output_2", "output_3", "output_4"], + num_outputs=4, + ) + + expected_outputs = [ + np.array([1.0, 2.0]).astype(np.float32), + np.array([3.0, 4.0]).astype(np.float32), + np.array([5.0, 6.0]).astype(np.float32), + np.array([7.0]).astype(np.float32), + ] + expect( + node, + inputs=[node_input], + outputs=expected_outputs, + name="test_split_1d_uneven_split_opset18", + ) + + @staticmethod + def export_2d_uneven_split_opset18() -> None: + node_input = np.array( + [ + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], + [9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0], + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Split", + inputs=["input"], + outputs=["output_1", "output_2", "output_3"], + axis=1, + num_outputs=3, + ) + + expected_outputs = [ + np.array([[1.0, 2.0, 3.0], [9.0, 10.0, 11.0]]).astype(np.float32), + np.array([[4.0, 5.0, 6.0], [12.0, 13.0, 14.0]]).astype(np.float32), + np.array([[7.0, 8.0], [15.0, 16.0]]).astype(np.float32), + ] + + expect( + node, + inputs=[node_input], + outputs=expected_outputs, + name="test_split_2d_uneven_split_opset18", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/splittosequence.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/splittosequence.py new file mode 100644 index 0000000000000000000000000000000000000000..0ee6e60ce03375d3295a003abe233951b1be81d1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/splittosequence.py @@ -0,0 +1,80 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class SplitToSequence(Base): + @staticmethod + def export_with_split_1() -> None: + data = np.arange(18).reshape((3, 6)).astype(np.float32) + split = np.array(2, dtype=np.int64) + + node = onnx.helper.make_node( + "SplitToSequence", ["data", "split"], ["seq"], axis=1 + ) + + expected_outputs = [ + [ + np.array([[0.0, 1.0], [6.0, 7.0], [12.0, 13.0]], dtype=np.float32), + np.array([[2.0, 3.0], [8.0, 9.0], [14.0, 15.0]], dtype=np.float32), + np.array([[4.0, 5.0], [10.0, 11.0], [16.0, 17.0]], dtype=np.float32), + ] + ] + + expect( + node, + inputs=[data, split], + outputs=expected_outputs, + name="test_split_to_sequence_1", + ) + + @staticmethod + def export_with_split_2() -> None: + data = np.arange(18).reshape((3, 6)).astype(np.float32) + split = np.array([1, 2], dtype=np.int64) + + node = onnx.helper.make_node( + "SplitToSequence", ["data", "split"], ["seq"], axis=0 + ) + + expected_outputs = [ + [ + data[:1], + data[1:], + ] + ] + + expect( + node, + inputs=[data, split], + outputs=expected_outputs, + name="test_split_to_sequence_2", + ) + + @staticmethod + def export_nokeepdims() -> None: + data = np.arange(18).reshape((3, 6)).astype(np.float32) + + node = onnx.helper.make_node( + "SplitToSequence", + ["data"], + ["seq"], + axis=1, + keepdims=0, + ) + + expected_outputs = [[data[:, i] for i in range(data.shape[1])]] + + expect( + node, + inputs=[data], + outputs=expected_outputs, + name="test_split_to_sequence_nokeepdims", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sqrt.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sqrt.py new file mode 100644 index 0000000000000000000000000000000000000000..6469a593d12de9644d30b926e43d0352859cbf8a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sqrt.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Sqrt(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Sqrt", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([1, 4, 9]).astype(np.float32) + y = np.sqrt(x) # expected output [1., 2., 3.] + expect(node, inputs=[x], outputs=[y], name="test_sqrt_example") + + x = np.abs(np.random.randn(3, 4, 5).astype(np.float32)) + y = np.sqrt(x) + expect(node, inputs=[x], outputs=[y], name="test_sqrt") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/squeeze.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/squeeze.py new file mode 100644 index 0000000000000000000000000000000000000000..c6fe8edb7e0fb09c8ba06c094e0425147c1d55ba --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/squeeze.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Squeeze(Base): + @staticmethod + def export_squeeze() -> None: + node = onnx.helper.make_node( + "Squeeze", + inputs=["x", "axes"], + outputs=["y"], + ) + x = np.random.randn(1, 3, 4, 5).astype(np.float32) + axes = np.array([0], dtype=np.int64) + y = np.squeeze(x, axis=0) + + expect(node, inputs=[x, axes], outputs=[y], name="test_squeeze") + + @staticmethod + def export_squeeze_negative_axes() -> None: + node = onnx.helper.make_node( + "Squeeze", + inputs=["x", "axes"], + outputs=["y"], + ) + x = np.random.randn(1, 3, 1, 5).astype(np.float32) + axes = np.array([-2], dtype=np.int64) + y = np.squeeze(x, axis=-2) + expect(node, inputs=[x, axes], outputs=[y], name="test_squeeze_negative_axes") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/stft.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/stft.py new file mode 100644 index 0000000000000000000000000000000000000000..106366c231d94853b55f803f54d0b313a3dc44a9 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/stft.py @@ -0,0 +1,70 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class STFT(Base): + @staticmethod + def export() -> None: + signal = np.arange(0, 128, dtype=np.float32).reshape(1, 128, 1) + length = np.array(16).astype(np.int64) + onesided_length = (length >> 1) + 1 + step = np.array(8).astype(np.int64) + + no_window = "" # optional input, not supplied + node = onnx.helper.make_node( + "STFT", + inputs=["signal", "frame_step", no_window, "frame_length"], + outputs=["output"], + ) + + nstfts = ((signal.shape[1] - length) // step) + 1 + # [batch_size][frames][frame_length][2] + output = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32) + for i in range(nstfts): + start = i * step + stop = i * step + length + complex_out = np.fft.fft(signal[0, start:stop, 0])[0:onesided_length] + output[0, i] = np.stack((complex_out.real, complex_out.imag), axis=1) + + output = output.astype(signal.dtype) + expect(node, inputs=[signal, step, length], outputs=[output], name="test_stft") + + node = onnx.helper.make_node( + "STFT", + inputs=["signal", "frame_step", "window"], + outputs=["output"], + ) + + # Test with window + a0 = 0.5 + a1 = 0.5 + window = a0 + a1 * np.cos( + 2 * np.pi * np.arange(0, length, 1, dtype=np.float32) / length + ) + nstfts = 1 + (signal.shape[1] - window.shape[0]) // step + + # [batch_size][frames][frame_length][2] + output = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32) + for i in range(nstfts): + start = i * step + stop = i * step + length + complex_out = np.fft.fft(signal[0, start:stop, 0] * window)[ + 0:onesided_length + ] + output[0, i] = np.stack((complex_out.real, complex_out.imag), axis=1) + window = window.astype(signal.dtype) + output = output.astype(signal.dtype) + expect( + node, + inputs=[signal, step, window], + outputs=[output], + name="test_stft_with_window", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/string_concat.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/string_concat.py new file mode 100644 index 0000000000000000000000000000000000000000..23c78d09e13f3875349c964ef04870bc2aabb60b --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/string_concat.py @@ -0,0 +1,69 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class StringConcat(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "StringConcat", + inputs=["x", "y"], + outputs=["result"], + ) + x = np.array(["abc", "def"]).astype("object") + y = np.array([".com", ".net"]).astype("object") + result = np.array(["abc.com", "def.net"]).astype("object") + + expect(node, inputs=[x, y], outputs=[result], name="test_string_concat") + + x = np.array(["cat", "dog", "snake"]).astype("object") + y = np.array(["s"]).astype("object") + result = np.array(["cats", "dogs", "snakes"]).astype("object") + + expect( + node, + inputs=[x, y], + outputs=[result], + name="test_string_concat_broadcasting", + ) + + x = np.array("cat").astype("object") + y = np.array("s").astype("object") + result = np.array("cats").astype("object") + + expect( + node, + inputs=[x, y], + outputs=[result], + name="test_string_concat_zero_dimensional", + ) + + x = np.array(["abc", ""]).astype("object") + y = np.array(["", "abc"]).astype("object") + result = np.array(["abc", "abc"]).astype("object") + + expect( + node, + inputs=[x, y], + outputs=[result], + name="test_string_concat_empty_string", + ) + + x = np.array(["的", "中"]).astype("object") + y = np.array(["的", "中"]).astype("object") + result = np.array(["的的", "中中"]).astype("object") + + expect( + node, + inputs=[x, y], + outputs=[result], + name="test_string_concat_utf8", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/string_split.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/string_split.py new file mode 100644 index 0000000000000000000000000000000000000000..eebb7c1f977b3a2cc30a29d528c4c8a195f968ec --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/string_split.py @@ -0,0 +1,151 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class StringSplit(Base): + @staticmethod + def export_basic() -> None: + node = onnx.helper.make_node( + "StringSplit", + inputs=["x"], + outputs=["substrings", "length"], + delimiter=".", + maxsplit=None, + ) + + x = np.array(["abc.com", "def.net"]).astype(object) + + substrings = np.array([["abc", "com"], ["def", "net"]]).astype(object) + + length = np.array([2, 2], dtype=np.int64) + + expect( + node, + inputs=[x], + outputs=[substrings, length], + name="test_string_split_basic", + ) + + @staticmethod + def export_maxsplit() -> None: + node = onnx.helper.make_node( + "StringSplit", + inputs=["x"], + outputs=["substrings", "length"], + maxsplit=2, + ) + + x = np.array( + [["hello world", "def.net"], ["o n n x", "the quick brown fox"]] + ).astype(object) + + substrings = np.array( + [ + [["hello", "world", ""], ["def.net", "", ""]], + [["o", "n", "n x"], ["the", "quick", "brown fox"]], + ] + ).astype(object) + + length = np.array([[2, 1], [3, 3]], np.int64) + + expect( + node, + inputs=[x], + outputs=[substrings, length], + name="test_string_split_maxsplit", + ) + + @staticmethod + def export_consecutive_delimiters() -> None: + node = onnx.helper.make_node( + "StringSplit", + inputs=["x"], + outputs=["substrings", "length"], + delimiter="-", + maxsplit=None, + ) + + x = np.array(["o-n-n--x-", "o-n----nx"]).astype(object) + + substrings = np.array( + [["o", "n", "n", "", "x", ""], ["o", "n", "", "", "", "nx"]] + ).astype(object) + + length = np.array([6, 6], dtype=np.int64) + + expect( + node, + inputs=[x], + outputs=[substrings, length], + name="test_string_split_consecutive_delimiters", + ) + + @staticmethod + def export_empty_string_delimiter() -> None: + for delimiter, test_name in ( + ("", "test_string_split_empty_string_delimiter"), + (None, "test_string_split_no_delimiter"), + ): + node = onnx.helper.make_node( + "StringSplit", + inputs=["x"], + outputs=["substrings", "length"], + delimiter=delimiter, + maxsplit=None, + ) + + x = np.array( + ["hello world !", " hello world !", " hello world ! "] + ).astype(object) + + substrings = np.array( + [ + ["hello", "world", "!"], + ["hello", "world", "!"], + ["hello", "world", "!"], + ] + ).astype(object) + + length = np.array([3, 3, 3], dtype=np.int64) + + expect( + node, + inputs=[x], + outputs=[substrings, length], + name=test_name, + ) + + @staticmethod + def export_empty_string_split() -> None: + node = onnx.helper.make_node( + "StringSplit", + inputs=["x"], + outputs=["substrings", "length"], + delimiter=None, + maxsplit=None, + ) + + x = np.array([]).astype(object) + + substrings = np.array([]).astype(object).reshape(0, 0) + + length = np.array([], dtype=np.int64) + + expect( + node, + inputs=[x], + outputs=[substrings, length], + name="test_string_split_empty_tensor", + output_type_protos=[ + onnx.helper.make_tensor_type_proto(onnx.TensorProto.STRING, (0, None)), + None, + ], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/stringnormalizer.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/stringnormalizer.py new file mode 100644 index 0000000000000000000000000000000000000000..3eb9d7b6d306bddb8167b1a22eb82455e14b2209 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/stringnormalizer.py @@ -0,0 +1,148 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class StringNormalizer(Base): + @staticmethod + def export_nostopwords_nochangecase() -> None: + input = np.array(["monday", "tuesday"]).astype(object) + output = input + + # No stopwords. This is a NOOP + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + is_case_sensitive=1, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_strnormalizer_nostopwords_nochangecase", + ) + + @staticmethod + def export_monday_casesensintive_nochangecase() -> None: + input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + output = np.array(["tuesday", "wednesday", "thursday"]).astype(object) + stopwords = ["monday"] + + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + is_case_sensitive=1, + stopwords=stopwords, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_strnormalizer_export_monday_casesensintive_nochangecase", + ) + + @staticmethod + def export_monday_casesensintive_lower() -> None: + input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + output = np.array(["tuesday", "wednesday", "thursday"]).astype(object) + stopwords = ["monday"] + + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="LOWER", + is_case_sensitive=1, + stopwords=stopwords, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_strnormalizer_export_monday_casesensintive_lower", + ) + + @staticmethod + def export_monday_casesensintive_upper() -> None: + input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + output = np.array(["TUESDAY", "WEDNESDAY", "THURSDAY"]).astype(object) + stopwords = ["monday"] + + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + is_case_sensitive=1, + stopwords=stopwords, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_strnormalizer_export_monday_casesensintive_upper", + ) + + @staticmethod + def export_monday_empty_output() -> None: + input = np.array(["monday", "monday"]).astype(object) + output = np.array([""]).astype(object) + stopwords = ["monday"] + + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + is_case_sensitive=1, + stopwords=stopwords, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_strnormalizer_export_monday_empty_output", + ) + + @staticmethod + def export_monday_insensintive_upper_twodim() -> None: + input = ( + np.array( + ["Monday", "tuesday", "wednesday", "Monday", "tuesday", "wednesday"] + ) + .astype(object) + .reshape([1, 6]) + ) + + # It does upper case cecedille, accented E + # and german umlaut but fails + # with german eszett + output = ( + np.array(["TUESDAY", "WEDNESDAY", "TUESDAY", "WEDNESDAY"]) + .astype(object) + .reshape([1, 4]) + ) + stopwords = ["monday"] + + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + stopwords=stopwords, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_strnormalizer_export_monday_insensintive_upper_twodim", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sub.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sub.py new file mode 100644 index 0000000000000000000000000000000000000000..f4c966891b9efe69569184ef89b3cf4d3182e35f --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sub.py @@ -0,0 +1,73 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Sub(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Sub", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([1, 2, 3]).astype(np.float32) + y = np.array([3, 2, 1]).astype(np.float32) + z = x - y # expected output [-2., 0., 2.] + expect(node, inputs=[x, y], outputs=[z], name="test_sub_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = x - y + expect(node, inputs=[x, y], outputs=[z], name="test_sub") + + x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int8) + y = np.random.randint(12, size=(3, 4, 5), dtype=np.int8) + z = x - y + expect(node, inputs=[x, y], outputs=[z], name="test_sub_int8") + + x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int16) + y = np.random.randint(12, size=(3, 4, 5), dtype=np.int16) + z = x - y + expect(node, inputs=[x, y], outputs=[z], name="test_sub_int16") + + x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint8) + z = x - y + expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint8") + + x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint16) + y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint16) + z = x - y + expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint16") + + x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint32) + y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint32) + z = x - y + expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint32") + + x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint64) + y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint64) + z = x - y + expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint64") + + @staticmethod + def export_sub_broadcast() -> None: + node = onnx.helper.make_node( + "Sub", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = x - y + expect(node, inputs=[x, y], outputs=[z], name="test_sub_bcast") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sum.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sum.py new file mode 100644 index 0000000000000000000000000000000000000000..c2ac0a61308812487ae11249101ecc76d33cfddd --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/sum.py @@ -0,0 +1,47 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Sum(Base): + @staticmethod + def export() -> None: + data_0 = np.array([3, 0, 2]).astype(np.float32) + data_1 = np.array([1, 3, 4]).astype(np.float32) + data_2 = np.array([2, 6, 6]).astype(np.float32) + result = np.array([6, 9, 12]).astype(np.float32) + node = onnx.helper.make_node( + "Sum", + inputs=["data_0", "data_1", "data_2"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1, data_2], + outputs=[result], + name="test_sum_example", + ) + + node = onnx.helper.make_node( + "Sum", + inputs=["data_0"], + outputs=["result"], + ) + expect(node, inputs=[data_0], outputs=[data_0], name="test_sum_one_input") + + result = np.add(data_0, data_1) + node = onnx.helper.make_node( + "Sum", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, inputs=[data_0, data_1], outputs=[result], name="test_sum_two_inputs" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/swish.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/swish.py new file mode 100644 index 0000000000000000000000000000000000000000..49abb2f97dcac02a435fb6baeead627f391a64f0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/swish.py @@ -0,0 +1,36 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def swish(x: np.ndarray, alpha: float) -> np.ndarray: + return x * (1 / (1 + np.exp(-alpha * x))) + + +class Swish(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Swish", + inputs=["x"], + outputs=["y"], + alpha=1.0, # pass alpha as attribute + ) + + x = np.array([3, 4, 5], dtype=np.float32) + y = swish(x, alpha=1.0) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_swish", + opset_imports=[onnx.helper.make_opsetid("", 24)], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tan.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tan.py new file mode 100644 index 0000000000000000000000000000000000000000..6888f690a0aced5726979777812c8f413e4d47db --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tan.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Tan(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Tan", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.tan(x) + expect(node, inputs=[x], outputs=[y], name="test_tan_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.tan(x) + expect(node, inputs=[x], outputs=[y], name="test_tan") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tanh.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tanh.py new file mode 100644 index 0000000000000000000000000000000000000000..df180c75d41c4e53e9a20700995b47ef7ff03cb7 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tanh.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Tanh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Tanh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.tanh(x) # expected output [-0.76159418, 0., 0.76159418] + expect(node, inputs=[x], outputs=[y], name="test_tanh_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.tanh(x) + expect(node, inputs=[x], outputs=[y], name="test_tanh") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tensorscatter.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tensorscatter.py new file mode 100644 index 0000000000000000000000000000000000000000..8a264523953d8abbd8afc3c6835837259a403bed --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tensorscatter.py @@ -0,0 +1,174 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class TensorScatter(Base): + @staticmethod + def export_tensorscatter() -> None: + node = onnx.helper.make_node( + "TensorScatter", + inputs=["past_cache", "update", "write_indices"], + outputs=["present_cache"], + mode="linear", + ) + past_cache = np.array( + [ + [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]], + [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]], + ], + dtype=np.float32, + ) + update = np.array( + [ + [[[5, 5, 5, 5, 5]]], + [[[1, 1, 1, 1, 1]]], + ], + dtype=np.float32, + ) + write_indices = np.array([1, 2], dtype=np.int64) + present_cache = np.array( + [ + [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]], + [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [1, 1, 1, 1, 1], [4, 3, 2, 1, 0]]], + ], + dtype=np.float32, + ) + expect( + node, + inputs=[past_cache, update, write_indices], + outputs=[present_cache], + name="test_tensorscatter", + ) + + @staticmethod + def export_tensorscatter_circular() -> None: + node = onnx.helper.make_node( + "TensorScatter", + inputs=["past_cache", "update", "write_indices"], + outputs=["present_cache"], + mode="circular", + ) + past_cache = np.array( + [ + [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]], + [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]], + ], + dtype=np.float32, + ) + update = np.array( + [ + [ + [ + [5, 5, 5, 5, 5], + [6, 6, 6, 6, 6], + ] + ], + [ + [ + [1, 1, 1, 1, 1], + [2, 2, 2, 2, 2], + ] + ], + ], + dtype=np.float32, + ) + write_indices = np.array([1, 3], dtype=np.int64) + present_cache = np.array( + [ + [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [6, 6, 6, 6, 6], [4, 3, 2, 1, 0]]], + [[[2, 2, 2, 2, 2], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [1, 1, 1, 1, 1]]], + ], + dtype=np.float32, + ) + expect( + node, + inputs=[past_cache, update, write_indices], + outputs=[present_cache], + name="test_tensorscatter_circular", + ) + + @staticmethod + def export_tensorscatter_3d() -> None: + node = onnx.helper.make_node( + "TensorScatter", + inputs=["past_cache", "update", "write_indices"], + outputs=["present_cache"], + ) + past_cache = np.array( + [ + [ + [1, 2, 3, 4, 5], + [5, 6, 7, 8, 9], + [8, 7, 6, 5, 4], + [5, 4, 3, 2, 1], + ], + [ + [1, 2, 3, 4, 5], + [5, 6, 7, 8, 9], + [8, 7, 6, 5, 4], + [5, 4, 3, 2, 1], + ], + [ + [1, 2, 3, 4, 5], + [5, 6, 7, 8, 9], + [8, 7, 6, 5, 4], + [5, 4, 3, 2, 1], + ], + ], + dtype=np.float32, + ) + update = np.array( + [ + [ + [4, 4, 4, 4, 4], + [5, 5, 5, 5, 5], + ], + [ + [6, 6, 6, 6, 6], + [7, 7, 7, 7, 7], + ], + [ + [2, 2, 2, 2, 2], + [3, 3, 3, 3, 3], + ], + ], + dtype=np.float32, + ) + write_indices = np.array([1, 2, 0], dtype=np.int64) + present_cache = np.array( + [ + [ + [1, 2, 3, 4, 5], + [4, 4, 4, 4, 4], + [5, 5, 5, 5, 5], + [5, 4, 3, 2, 1], + ], + [ + [1, 2, 3, 4, 5], + [5, 6, 7, 8, 9], + [6, 6, 6, 6, 6], + [7, 7, 7, 7, 7], + ], + [ + [2, 2, 2, 2, 2], + [3, 3, 3, 3, 3], + [8, 7, 6, 5, 4], + [5, 4, 3, 2, 1], + ], + ], + dtype=np.float32, + ) + expect( + node, + inputs=[past_cache, update, write_indices], + outputs=[present_cache], + name="test_tensorscatter_3d", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tfidfvectorizer.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tfidfvectorizer.py new file mode 100644 index 0000000000000000000000000000000000000000..f17e68cccf80068e21f6aee62543fdf9616dc23c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tfidfvectorizer.py @@ -0,0 +1,264 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import Any + +import numpy as np + +import onnx +from onnx import NodeProto +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class TfIdfVectorizerHelper: + def __init__(self, **params: Any) -> None: + # Attr names + mode = "mode" + min_gram_length = "min_gram_length" + max_gram_length = "max_gram_length" + max_skip_count = "max_skip_count" + ngram_counts = "ngram_counts" + ngram_indexes = "ngram_indexes" + pool_int64s = "pool_int64s" + + required_attr = [ + mode, + min_gram_length, + max_gram_length, + max_skip_count, + ngram_counts, + ngram_indexes, + pool_int64s, + ] + + for i in required_attr: + assert i in params, f"Missing attribute: {i}" + + self.mode = params[mode] + self.min_gram_length = params[min_gram_length] + self.max_gram_length = params[max_gram_length] + self.max_skip_count = params[max_skip_count] + self.ngram_counts = params[ngram_counts] + self.ngram_indexes = params[ngram_indexes] + self.pool_int64s = params[pool_int64s] + + def make_node_noweights(self) -> NodeProto: + return onnx.helper.make_node( + "TfIdfVectorizer", + inputs=["X"], + outputs=["Y"], + mode=self.mode, + min_gram_length=self.min_gram_length, + max_gram_length=self.max_gram_length, + max_skip_count=self.max_skip_count, + ngram_counts=self.ngram_counts, + ngram_indexes=self.ngram_indexes, + pool_int64s=self.pool_int64s, + ) + + +class TfIdfVectorizer(Base): + @staticmethod + def export_tf_only_bigrams_skip0() -> None: + input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32) + output = np.array([0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]).astype(np.float32) + + ngram_counts = np.array([0, 4]).astype(np.int64) + ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64) + pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype( # unigrams + np.int64 + ) # bigrams + + helper = TfIdfVectorizerHelper( + mode="TF", + min_gram_length=2, + max_gram_length=2, + max_skip_count=0, + ngram_counts=ngram_counts, + ngram_indexes=ngram_indexes, + pool_int64s=pool_int64s, + ) + node = helper.make_node_noweights() + expect( + node, + inputs=[input], + outputs=[output], + name="test_tfidfvectorizer_tf_only_bigrams_skip0", + ) + + @staticmethod + def export_tf_batch_onlybigrams_skip0() -> None: + input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32) + output = np.array( + [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0]] + ).astype(np.float32) + + ngram_counts = np.array([0, 4]).astype(np.int64) + ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64) + pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype( # unigrams + np.int64 + ) # bigrams + + helper = TfIdfVectorizerHelper( + mode="TF", + min_gram_length=2, + max_gram_length=2, + max_skip_count=0, + ngram_counts=ngram_counts, + ngram_indexes=ngram_indexes, + pool_int64s=pool_int64s, + ) + node = helper.make_node_noweights() + expect( + node, + inputs=[input], + outputs=[output], + name="test_tfidfvectorizer_tf_batch_onlybigrams_skip0", + ) + + @staticmethod + def export_tf_onlybigrams_levelempty() -> None: + input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32) + output = np.array([1.0, 1.0, 1.0]).astype(np.float32) + + ngram_counts = np.array([0, 0]).astype(np.int64) + ngram_indexes = np.array([0, 1, 2]).astype(np.int64) + pool_int64s = np.array([5, 6, 7, 8, 6, 7]).astype( # unigrams none + np.int64 + ) # bigrams + + helper = TfIdfVectorizerHelper( + mode="TF", + min_gram_length=2, + max_gram_length=2, + max_skip_count=0, + ngram_counts=ngram_counts, + ngram_indexes=ngram_indexes, + pool_int64s=pool_int64s, + ) + node = helper.make_node_noweights() + expect( + node, + inputs=[input], + outputs=[output], + name="test_tfidfvectorizer_tf_onlybigrams_levelempty", + ) + + @staticmethod + def export_tf_onlybigrams_skip5() -> None: + input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32) + output = np.array([0.0, 0.0, 0.0, 0.0, 1.0, 3.0, 1.0]).astype(np.float32) + + ngram_counts = np.array([0, 4]).astype(np.int64) + ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64) + pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype( # unigrams + np.int64 + ) # bigrams + + helper = TfIdfVectorizerHelper( + mode="TF", + min_gram_length=2, + max_gram_length=2, + max_skip_count=5, + ngram_counts=ngram_counts, + ngram_indexes=ngram_indexes, + pool_int64s=pool_int64s, + ) + node = helper.make_node_noweights() + expect( + node, + inputs=[input], + outputs=[output], + name="test_tfidfvectorizer_tf_onlybigrams_skip5", + ) + + @staticmethod + def export_tf_batch_onlybigrams_skip5() -> None: + input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32) + output = np.array( + [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]] + ).astype(np.float32) + + ngram_counts = np.array([0, 4]).astype(np.int64) + ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64) + pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype( # unigrams + np.int64 + ) # bigrams + + helper = TfIdfVectorizerHelper( + mode="TF", + min_gram_length=2, + max_gram_length=2, + max_skip_count=5, + ngram_counts=ngram_counts, + ngram_indexes=ngram_indexes, + pool_int64s=pool_int64s, + ) + node = helper.make_node_noweights() + expect( + node, + inputs=[input], + outputs=[output], + name="test_tfidfvectorizer_tf_batch_onlybigrams_skip5", + ) + + @staticmethod + def export_tf_uniandbigrams_skip5() -> None: + input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32) + output = np.array([0.0, 3.0, 1.0, 0.0, 1.0, 3.0, 1.0]).astype(np.float32) + + ngram_counts = np.array([0, 4]).astype(np.int64) + ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64) + pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype( # unigrams + np.int64 + ) # bigrams + + helper = TfIdfVectorizerHelper( + mode="TF", + min_gram_length=1, + max_gram_length=2, + max_skip_count=5, + ngram_counts=ngram_counts, + ngram_indexes=ngram_indexes, + pool_int64s=pool_int64s, + ) + node = helper.make_node_noweights() + expect( + node, + inputs=[input], + outputs=[output], + name="test_tfidfvectorizer_tf_uniandbigrams_skip5", + ) + + @staticmethod + def export_tf_batch_uniandbigrams_skip5() -> None: + input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32) + output = np.array( + [[0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0]] + ).astype(np.float32) + + ngram_counts = np.array([0, 4]).astype(np.int64) + ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64) + pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype( # unigrams + np.int64 + ) # bigrams + + helper = TfIdfVectorizerHelper( + mode="TF", + min_gram_length=1, + max_gram_length=2, + max_skip_count=5, + ngram_counts=ngram_counts, + ngram_indexes=ngram_indexes, + pool_int64s=pool_int64s, + ) + node = helper.make_node_noweights() + expect( + node, + inputs=[input], + outputs=[output], + name="test_tfidfvectorizer_tf_batch_uniandbigrams_skip5", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/thresholdedrelu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/thresholdedrelu.py new file mode 100644 index 0000000000000000000000000000000000000000..ccbbc1b3e75a270e1995124ce31585fbdc2325df --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/thresholdedrelu.py @@ -0,0 +1,41 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ThresholdedRelu(Base): + @staticmethod + def export() -> None: + alpha = 2.0 + node = onnx.helper.make_node( + "ThresholdedRelu", inputs=["x"], outputs=["y"], alpha=alpha + ) + + x = np.array([-1.5, 0.0, 1.2, 2.0, 2.2]).astype(np.float32) + y = np.clip(x, alpha, np.inf) # expected output [0., 0., 0., 0., 2.2] + y[y == alpha] = 0 + + expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, alpha, np.inf) + y[y == alpha] = 0 + + expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu") + + @staticmethod + def export_default() -> None: + default_alpha = 1.0 + node = onnx.helper.make_node("ThresholdedRelu", inputs=["x"], outputs=["y"]) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, default_alpha, np.inf) + y[y == default_alpha] = 0 + + expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu_default") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tile.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tile.py new file mode 100644 index 0000000000000000000000000000000000000000..386e724fb87c573d09c3c70ddbef8aa5c9158907 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/tile.py @@ -0,0 +1,38 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Tile(Base): + @staticmethod + def export_tile() -> None: + node = onnx.helper.make_node("Tile", inputs=["x", "y"], outputs=["z"]) + + x = np.random.rand(2, 3, 4, 5).astype(np.float32) + + repeats = np.random.randint(low=1, high=10, size=(np.ndim(x),)).astype(np.int64) + + z = np.tile(x, repeats) + + expect(node, inputs=[x, repeats], outputs=[z], name="test_tile") + + @staticmethod + def export_tile_precomputed() -> None: + node = onnx.helper.make_node("Tile", inputs=["x", "y"], outputs=["z"]) + + x = np.array([[0, 1], [2, 3]], dtype=np.float32) + + repeats = np.array([2, 2], dtype=np.int64) + + z = np.array( + [[0, 1, 0, 1], [2, 3, 2, 3], [0, 1, 0, 1], [2, 3, 2, 3]], dtype=np.float32 + ) + + expect(node, inputs=[x, repeats], outputs=[z], name="test_tile_precomputed") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/topk.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/topk.py new file mode 100644 index 0000000000000000000000000000000000000000..4e93a721c12bec0e8bdbc43d9fd3cd75da44d3a0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/topk.py @@ -0,0 +1,262 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def topk_sorted_implementation(X, k, axis, largest): + ind_axis = np.indices(X.shape)[axis] + if largest: + ind_axis = -ind_axis + sorted_indices = np.lexsort((ind_axis, X), axis=axis) + sorted_values = np.sort(X, axis=axis) + if largest: + sorted_indices = np.flip(sorted_indices, axis=axis) + sorted_values = np.flip(sorted_values, axis=axis) + topk_sorted_indices = np.take(sorted_indices, np.arange(k), axis=axis) + topk_sorted_values = np.take(sorted_values, np.arange(k), axis=axis) + return topk_sorted_values, np.array(topk_sorted_indices, dtype=np.int64) + + +class TopK(Base): + @staticmethod + def export_top_k() -> None: + axis = 1 + largest = 1 + + k = 3 + node = onnx.helper.make_node( + "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis + ) + X = np.array( + [ + [0, 1, 2, 3], + [4, 5, 6, 7], + [8, 9, 10, 11], + ], + dtype=np.float32, + ) + K = np.array([k], dtype=np.int64) + values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest) + + # print(values_ref) + # [[ 3. 2. 1.] + # [ 7. 6. 5.] + # [11. 10. 9.]] + # print(indices_ref) + # [[3 2 1] + # [3 2 1] + # [3 2 1]] + + expect( + node, inputs=[X, K], outputs=[values_ref, indices_ref], name="test_top_k" + ) + + @staticmethod + def export_top_k_uint64() -> None: + axis = 1 + largest = 1 + + k = 3 + node = onnx.helper.make_node( + "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis + ) + X = np.array( + [ + [0, 1, 2, 3], + [4, 5, 6, 7], + [8, 9, 10, 11], + ], + dtype=np.uint64, + ) + K = np.array([k], dtype=np.int64) + values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest) + + # print(values_ref) + # [[ 3 2 1] + # [ 7 6 5] + # [11 10 9]] + # print(indices_ref) + # [[3 2 1] + # [3 2 1] + # [3 2 1]] + + expect( + node, + inputs=[X, K], + outputs=[values_ref, indices_ref], + name="test_top_k_uint64", + ) + + @staticmethod + def export_top_k_same_values() -> None: + axis = 0 + largest = 0 + + k = 3 + node = onnx.helper.make_node( + "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis + ) + X = np.array( + [0, 0, 0, 0], + dtype=np.int64, + ) + K = np.array([k], dtype=np.int64) + values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest) + + # (Pdb) print(values_ref) + # [0 0 0] + # (Pdb) print(indices_ref) + # [0 1 2] + + expect( + node, + inputs=[X, K], + outputs=[values_ref, indices_ref], + name="test_top_k_same_values", + ) + + @staticmethod + def export_top_k_same_values_largest() -> None: + axis = 0 + largest = 1 + + k = 3 + node = onnx.helper.make_node( + "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis + ) + X = np.array( + [0, 0, 0, 0], + dtype=np.int64, + ) + K = np.array([k], dtype=np.int64) + values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest) + + # print(values_ref) + # [0 0 0] + # print(indices_ref) + # [0 1 2] + + expect( + node, + inputs=[X, K], + outputs=[values_ref, indices_ref], + name="test_top_k_same_values_largest", + ) + + @staticmethod + def export_top_k_same_values_2d() -> None: + axis = 1 + largest = 1 + + k = 3 + node = onnx.helper.make_node( + "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis + ) + X = np.array( + [[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 1, 1]], + dtype=np.int64, + ) + K = np.array([k], dtype=np.int64) + values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest) + + # print(values_ref) + # [[0 0 0] + # [1 1 1] + # [1 1 2]] + # print(indices_ref) + # [[0 1 2] + # [0 1 2] + # [2 3 0]] + + expect( + node, + inputs=[X, K], + outputs=[values_ref, indices_ref], + name="test_top_k_same_values_2d", + ) + + @staticmethod + def export_top_k_smallest() -> None: + axis = 1 + largest = 0 + sorted_ = 1 + k = 3 + + node = onnx.helper.make_node( + "TopK", + inputs=["x", "k"], + outputs=["values", "indices"], + axis=axis, + largest=largest, + sorted=sorted_, + ) + + X = np.array( + [ + [0, 1, 2, 3], + [4, 5, 6, 7], + [11, 10, 9, 8], + ], + dtype=np.float32, + ) + K = np.array([k], dtype=np.int64) + values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest) + + # print(values_ref) + # [[ 0. 1. 2.] + # [ 4. 5. 6.] + # [ 8. 9. 10.]] + # print(indices_ref) + # [[0 1 2] + # [0 1 2] + # [3 2 1]] + + expect( + node, + inputs=[X, K], + outputs=[values_ref, indices_ref], + name="test_top_k_smallest", + ) + + @staticmethod + def export_top_k_negative_axis() -> None: + axis = -1 + largest = 1 + + k = 3 + node = onnx.helper.make_node( + "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis + ) + X = np.array( + [ + [0, 1, 2, 3], + [4, 5, 6, 7], + [8, 9, 10, 11], + ], + dtype=np.float32, + ) + K = np.array([k], dtype=np.int64) + values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest) + + # print(values_ref) + # [[ 3. 2. 1.] + # [ 7. 6. 5.] + # [11. 10. 9.]] + # print(indices_ref) + # [[3 2 1] + # [3 2 1] + # [3 2 1]] + + expect( + node, + inputs=[X, K], + outputs=[values_ref, indices_ref], + name="test_top_k_negative_axis", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/transpose.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/transpose.py new file mode 100644 index 0000000000000000000000000000000000000000..817df1f9bf17a2f98ee2549e0bd860705194e236 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/transpose.py @@ -0,0 +1,47 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import itertools + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Transpose(Base): + @staticmethod + def export_default() -> None: + shape = (2, 3, 4) + data = np.random.random_sample(shape).astype(np.float32) + + node = onnx.helper.make_node( + "Transpose", inputs=["data"], outputs=["transposed"] + ) + + transposed = np.transpose(data) + expect(node, inputs=[data], outputs=[transposed], name="test_transpose_default") + + @staticmethod + def export_all_permutations() -> None: + shape = (2, 3, 4) + data = np.random.random_sample(shape).astype(np.float32) + permutations = list(itertools.permutations(np.arange(len(shape)))) + + for i, permutation in enumerate(permutations): + node = onnx.helper.make_node( + "Transpose", + inputs=["data"], + outputs=["transposed"], + perm=permutation, + ) + transposed = np.transpose(data, permutation) + expect( + node, + inputs=[data], + outputs=[transposed], + name=f"test_transpose_all_permutations_{i}", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/trilu.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/trilu.py new file mode 100644 index 0000000000000000000000000000000000000000..a050fb423e0bed1f5c6b3f165e80d320cb8a3a33 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/trilu.py @@ -0,0 +1,453 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def triu_reference_implementation(x, k=0): + return np.triu(x, k) + + +def tril_reference_implementation(x, k=0): + return np.tril(x, k) + + +class Trilu(Base): + @staticmethod + def export_triu() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 0, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[4, 7, 3, 7, 9], + # [0, 2, 8, 6, 9], + # [0, 0, 0, 8, 7], + # [0, 0, 0, 2, 4]] + y = triu_reference_implementation(x) + expect(node, inputs=[x], outputs=[y], name="test_triu") + + @staticmethod + def export_triu_neg() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + k = np.array(-1).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 0, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [0, 4, 0, 8, 7], + # [0, 0, 4, 2, 4]] + y = triu_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_triu_neg") + + @staticmethod + def export_triu_out_neg_out() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + k = np.array(-7).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 0, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 0, 8, 7], + # [4, 3, 4, 2, 4]] + y = triu_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_triu_out_neg_out") + + @staticmethod + def export_triu_pos() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + k = np.array(2).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 0, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[0, 0, 3, 7, 9], + # [0, 0, 0, 6, 9], + # [0, 0, 0, 0, 7], + # [0, 0, 0, 0, 0]] + y = triu_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_triu_pos") + + @staticmethod + def export_triu_out_pos() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + k = np.array(6).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 0, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[0, 0, 0, 0, 0], + # [0, 0, 0, 0, 0], + # [0, 0, 0, 0, 0], + # [0, 0, 0, 0, 0]] + y = triu_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_triu_out_pos") + + @staticmethod + def export_triu_square() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64) + y = triu_reference_implementation(x) + # X: + # [[[4, 6, 9], + # [7, 5, 4], + # [8, 1, 2]], + # + # [[1, 4, 9], + # [9, 6, 3], + # [8, 9, 8]]] + # expect result: + # [[[4, 6, 9], + # [0, 5, 4], + # [0, 0, 2]], + # + # [[1, 4, 9], + # [0, 6, 3], + # [0, 0, 8]]] + expect(node, inputs=[x], outputs=[y], name="test_triu_square") + + @staticmethod + def export_triu_square_neg() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64) + k = np.array(-1).astype(np.int64) + # X: + # [[[4, 6, 9], + # [7, 5, 4], + # [8, 1, 2]], + # + # [[1, 4, 9], + # [9, 6, 3], + # [8, 9, 8]]] + # expect result: + # [[[4, 6, 9], + # [7, 5, 4], + # [0, 1, 2]], + # + # [[1, 4, 9], + # [9, 6, 3], + # [0, 9, 8]]] + y = triu_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_triu_square_neg") + + @staticmethod + def export_triu_one_row() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(3, 1, 5)).astype(np.int64) + k = np.array(1).astype(np.int64) + # X: + # [[[1, 4, 9, 7, 1]], + # + # [[9, 2, 8, 8, 4]], + # + # [[3, 9, 7, 4, 2]]] + # expect result: + # [[[0, 4, 9, 7, 1]], + # + # [[0, 2, 8, 8, 4]], + # + # [[0, 9, 7, 4, 2]]] + y = triu_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_triu_one_row") + + @staticmethod + def export_triu_zero() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + ) + + x = np.random.randint(10, size=(0, 5)).astype(np.int64) + k = np.array(6).astype(np.int64) + # X: + # [] + # expect result: + # [] + y = triu_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_triu_zero") + + @staticmethod + def export_tril() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x"], + outputs=["y"], + upper=0, + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 1, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[4, 0, 0, 0, 0], + # [1, 2, 0, 0, 0], + # [9, 4, 1, 0, 0], + # [4, 3, 4, 2, 0]] + y = tril_reference_implementation(x) + expect(node, inputs=[x], outputs=[y], name="test_tril") + + @staticmethod + def export_tril_neg() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + upper=0, + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + k = np.array(-1).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 1, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[0, 0, 0, 0, 0], + # [1, 0, 0, 0, 0], + # [9, 4, 0, 0, 0], + # [4, 3, 4, 0, 0]] + y = tril_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_tril_neg") + + @staticmethod + def export_tril_out_neg() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + upper=0, + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + k = np.array(-7).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 1, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[0, 0, 0, 0, 0], + # [0, 0, 0, 0, 0], + # [0, 0, 0, 0, 0], + # [0, 0, 0, 0, 0]] + y = tril_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_tril_out_neg") + + @staticmethod + def export_tril_pos() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + upper=0, + ) + + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + k = np.array(2).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 1, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[4, 7, 3, 0, 0], + # [1, 2, 8, 6, 0], + # [9, 4, 1, 8, 7], + # [4, 3, 4, 2, 4]] + y = tril_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_tril_pos") + + @staticmethod + def export_tril_out_pos() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + upper=0, + ) + x = np.random.randint(10, size=(4, 5)).astype(np.int64) + k = np.array(6).astype(np.int64) + # X: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 1, 8, 7], + # [4, 3, 4, 2, 4]] + # expect result: + # [[4, 7, 3, 7, 9], + # [1, 2, 8, 6, 9], + # [9, 4, 1, 8, 7], + # [4, 3, 4, 2, 4]] + y = tril_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_tril_out_pos") + + @staticmethod + def export_tril_square() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x"], + outputs=["y"], + upper=0, + ) + + x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64) + # X: + # [[[0, 4, 3], + # [2, 0, 9], + # [8, 2, 5]], + # + # [[2, 7, 2], + # [2, 6, 0], + # [2, 6, 5]]] + # expect result: + # [[[0, 0, 0], + # [2, 0, 0], + # [8, 2, 5]], + # + # [[2, 0, 0], + # [2, 6, 0], + # [2, 6, 5]]] + y = tril_reference_implementation(x) + expect(node, inputs=[x], outputs=[y], name="test_tril_square") + + @staticmethod + def export_tril_square_neg() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + upper=0, + ) + + x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64) + k = np.array(-1).astype(np.int64) + # X: + # [[[0, 4, 3], + # [2, 0, 9], + # [8, 2, 5]], + # + # [[2, 7, 2], + # [2, 6, 0], + # [2, 6, 5]]] + # expect result: + # [[[0, 0, 0], + # [2, 0, 0], + # [8, 2, 0]], + # + # [[0, 0, 0], + # [2, 0, 0], + # [2, 6, 0]]] + y = tril_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_tril_square_neg") + + @staticmethod + def export_tril_one_row() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x"], + outputs=["y"], + upper=0, + ) + + x = np.random.randint(10, size=(3, 1, 5)).astype(np.int64) + # X: + # [[[6, 2, 4, 1, 6]], + # + # [[8, 3, 8, 7, 0]], + # + # [[2, 2, 9, 5, 9]]] + # expect result: + # [[[6, 0, 0, 0, 0]], + # + # [[8, 0, 0, 0, 0]], + # + # [[2, 0, 0, 0, 0]]] + y = tril_reference_implementation(x) + expect(node, inputs=[x], outputs=[y], name="test_tril_one_row_neg") + + @staticmethod + def export_tril_zero() -> None: + node = onnx.helper.make_node( + "Trilu", + inputs=["x", "k"], + outputs=["y"], + upper=0, + ) + + x = np.random.randint(10, size=(3, 0, 5)).astype(np.int64) + k = np.array(6).astype(np.int64) + # X: + # [] + # expect result: + # [] + y = tril_reference_implementation(x, int(k)) + expect(node, inputs=[x, k], outputs=[y], name="test_tril_zero") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/unique.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/unique.py new file mode 100644 index 0000000000000000000000000000000000000000..4bd1241bf0b7b62a13f3d399e1e60658fa426d7c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/unique.py @@ -0,0 +1,229 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def specify_int64(indices, inverse_indices, counts): + return ( + np.array(indices, dtype=np.int64), + np.array(inverse_indices, dtype=np.int64), + np.array(counts, dtype=np.int64), + ) + + +class Unique(Base): + @staticmethod + def export_sorted_without_axis() -> None: + node_sorted = onnx.helper.make_node( + "Unique", + inputs=["X"], + outputs=["Y", "indices", "inverse_indices", "counts"], + ) + + x = np.array([2.0, 1.0, 1.0, 3.0, 4.0, 3.0], dtype=np.float32) + y, indices, inverse_indices, counts = np.unique(x, True, True, True) + indices, inverse_indices, counts = specify_int64( + indices, inverse_indices, counts + ) + expect( + node_sorted, + inputs=[x], + outputs=[y, indices, inverse_indices, counts], + name="test_unique_sorted_without_axis", + ) + + @staticmethod + def export_not_sorted_without_axis() -> None: + node_not_sorted = onnx.helper.make_node( + "Unique", + inputs=["X"], + outputs=["Y", "indices", "inverse_indices", "counts"], + sorted=0, + ) + # numpy unique does not retain original order (it sorts the output unique values) + # https://github.com/numpy/numpy/issues/8621 + # we need to recover unsorted output and indices + x = np.array([2.0, 1.0, 1.0, 3.0, 4.0, 3.0], dtype=np.float32) + y, indices, inverse_indices, counts = np.unique(x, True, True, True) + + # prepare index mapping from sorted to unsorted + argsorted_indices = np.argsort(indices) + inverse_indices_map = dict( + zip(argsorted_indices, np.arange(len(argsorted_indices)), strict=True) + ) + + indices = indices[argsorted_indices] + y = np.take(x, indices, axis=0) + inverse_indices = np.asarray( + [inverse_indices_map[i] for i in inverse_indices], dtype=np.int64 + ) + counts = counts[argsorted_indices] + indices, inverse_indices, counts = specify_int64( + indices, inverse_indices, counts + ) + # print(y) + # [2.0, 1.0, 3.0, 4.0] + # print(indices) + # [0 1 3 4] + # print(inverse_indices) + # [0, 1, 1, 2, 3, 2] + # print(counts) + # [1, 2, 2, 1] + + expect( + node_not_sorted, + inputs=[x], + outputs=[y, indices, inverse_indices, counts], + name="test_unique_not_sorted_without_axis", + ) + + @staticmethod + def export_sorted_with_axis() -> None: + node_sorted = onnx.helper.make_node( + "Unique", + inputs=["X"], + outputs=["Y", "indices", "inverse_indices", "counts"], + sorted=1, + axis=0, + ) + + x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]], dtype=np.float32) + y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=0) + indices, inverse_indices, counts = specify_int64( + indices, inverse_indices, counts + ) + # behavior changed with numpy >= 2.0 + inverse_indices = inverse_indices.reshape(-1) + # print(y) + # [[1. 0. 0.] + # [2. 3. 4.]] + # print(indices) + # [0 2] + # print(inverse_indices) + # [0 0 1] + # print(counts) + # [2 1] + + expect( + node_sorted, + inputs=[x], + outputs=[y, indices, inverse_indices, counts], + name="test_unique_sorted_with_axis", + ) + + @staticmethod + def export_sorted_with_axis_3d() -> None: + node_sorted = onnx.helper.make_node( + "Unique", + inputs=["X"], + outputs=["Y", "indices", "inverse_indices", "counts"], + sorted=1, + axis=1, + ) + + x = np.array( + [ + [[1.0, 1.0], [0.0, 1.0], [2.0, 1.0], [0.0, 1.0]], + [[1.0, 1.0], [0.0, 1.0], [2.0, 1.0], [0.0, 1.0]], + ], + dtype=np.float32, + ) + y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=1) + indices, inverse_indices, counts = specify_int64( + indices, inverse_indices, counts + ) + # behavior changed with numpy >= 2.0 + inverse_indices = inverse_indices.reshape(-1) + # print(y) + # [[[0. 1.] + # [1. 1.] + # [2. 1.]] + # [[0. 1.] + # [1. 1.] + # [2. 1.]]] + # print(indices) + # [1 0 2] + # print(inverse_indices) + # [1 0 2 0] + # print(counts) + # [2 1 1] + expect( + node_sorted, + inputs=[x], + outputs=[y, indices, inverse_indices, counts], + name="test_unique_sorted_with_axis_3d", + ) + + @staticmethod + def export_sorted_with_negative_axis() -> None: + node_sorted = onnx.helper.make_node( + "Unique", + inputs=["X"], + outputs=["Y", "indices", "inverse_indices", "counts"], + sorted=1, + axis=-1, + ) + + x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 3]], dtype=np.float32) + y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=-1) + indices, inverse_indices, counts = specify_int64( + indices, inverse_indices, counts + ) + # behavior changed with numpy >= 2.0 + inverse_indices = inverse_indices.reshape(-1) + # print(y) + # [[0. 1.] + # [0. 1.] + # [3. 2.]] + # print(indices) + # [1 0] + # print(inverse_indices) + # [1 0 0] + # print(counts) + # [2 1] + + expect( + node_sorted, + inputs=[x], + outputs=[y, indices, inverse_indices, counts], + name="test_unique_sorted_with_negative_axis", + ) + + @staticmethod + def export_length_1() -> None: + node_sorted = onnx.helper.make_node( + "Unique", + inputs=["X"], + outputs=["Y", "indices", "inverse_indices", "counts"], + sorted=1, + ) + + x = np.array([0], dtype=np.int64) + y, indices, inverse_indices, counts = np.unique(x, True, True, True) + indices, inverse_indices, counts = specify_int64( + indices, inverse_indices, counts + ) + # behavior changed with numpy >= 2.0 + inverse_indices = inverse_indices.reshape(-1) + # print(y) + # [0] + # print(indices) + # [0] + # print(inverse_indices) + # [0] + # print(counts) + # [1] + + expect( + node_sorted, + inputs=[x], + outputs=[y, indices, inverse_indices, counts], + name="test_unique_length_1", + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/unsqueeze.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/unsqueeze.py new file mode 100644 index 0000000000000000000000000000000000000000..6d517a05f9b5bb519bed9e7f59f7a022f3290cd6 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/unsqueeze.py @@ -0,0 +1,91 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Unsqueeze(Base): + @staticmethod + def export_unsqueeze_one_axis() -> None: + x = np.random.randn(3, 4, 5).astype(np.float32) + + for i in range(x.ndim): + axes = np.array([i]).astype(np.int64) + node = onnx.helper.make_node( + "Unsqueeze", + inputs=["x", "axes"], + outputs=["y"], + ) + y = np.expand_dims(x, axis=i) + + expect( + node, + inputs=[x, axes], + outputs=[y], + name="test_unsqueeze_axis_" + str(i), + ) + + @staticmethod + def export_unsqueeze_two_axes() -> None: + x = np.random.randn(3, 4, 5).astype(np.float32) + axes = np.array([1, 4]).astype(np.int64) + + node = onnx.helper.make_node( + "Unsqueeze", + inputs=["x", "axes"], + outputs=["y"], + ) + y = np.expand_dims(x, axis=1) + y = np.expand_dims(y, axis=4) + + expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_two_axes") + + @staticmethod + def export_unsqueeze_three_axes() -> None: + x = np.random.randn(3, 4, 5).astype(np.float32) + axes = np.array([2, 4, 5]).astype(np.int64) + + node = onnx.helper.make_node( + "Unsqueeze", + inputs=["x", "axes"], + outputs=["y"], + ) + y = np.expand_dims(x, axis=2) + y = np.expand_dims(y, axis=4) + y = np.expand_dims(y, axis=5) + + expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_three_axes") + + @staticmethod + def export_unsqueeze_unsorted_axes() -> None: + x = np.random.randn(3, 4, 5).astype(np.float32) + axes = np.array([5, 4, 2]).astype(np.int64) + + node = onnx.helper.make_node( + "Unsqueeze", + inputs=["x", "axes"], + outputs=["y"], + ) + y = np.expand_dims(x, axis=2) + y = np.expand_dims(y, axis=4) + y = np.expand_dims(y, axis=5) + + expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_unsorted_axes") + + @staticmethod + def export_unsqueeze_negative_axes() -> None: + node = onnx.helper.make_node( + "Unsqueeze", + inputs=["x", "axes"], + outputs=["y"], + ) + x = np.random.randn(1, 3, 1, 5).astype(np.float32) + axes = np.array([-2]).astype(np.int64) + y = np.expand_dims(x, axis=-2) + expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_negative_axes") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/upsample.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/upsample.py new file mode 100644 index 0000000000000000000000000000000000000000..6cc43f18f66d1b73738bdf12df9411fd7202b1f0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/upsample.py @@ -0,0 +1,58 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx import helper +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Upsample(Base): + @staticmethod + def export_nearest() -> None: + node = onnx.helper.make_node( + "Upsample", + inputs=["X", "scales"], + outputs=["Y"], + mode="nearest", + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32) + + output = np.array( + [ + [ + [ + [1, 1, 1, 2, 2, 2], + [1, 1, 1, 2, 2, 2], + [3, 3, 3, 4, 4, 4], + [3, 3, 3, 4, 4, 4], + ] + ] + ], + dtype=np.float32, + ) + + expect( + node, + inputs=[data, scales], + outputs=[output], + name="test_upsample_nearest", + opset_imports=[helper.make_opsetid("", 9)], + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/where.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/where.py new file mode 100644 index 0000000000000000000000000000000000000000..cb050ee7a82eb1c1458cb7064b691f636e593e87 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/where.py @@ -0,0 +1,42 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Where(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Where", + inputs=["condition", "x", "y"], + outputs=["z"], + ) + + condition = np.array([[1, 0], [1, 1]], dtype=bool) + x = np.array([[1, 2], [3, 4]], dtype=np.float32) + y = np.array([[9, 8], [7, 6]], dtype=np.float32) + z = np.where(condition, x, y) # expected output [[1, 8], [3, 4]] + expect(node, inputs=[condition, x, y], outputs=[z], name="test_where_example") + + @staticmethod + def export_long() -> None: + node = onnx.helper.make_node( + "Where", + inputs=["condition", "x", "y"], + outputs=["z"], + ) + + condition = np.array([[1, 0], [1, 1]], dtype=bool) + x = np.array([[1, 2], [3, 4]], dtype=np.int64) + y = np.array([[9, 8], [7, 6]], dtype=np.int64) + z = np.where(condition, x, y) # expected output [[1, 8], [3, 4]] + expect( + node, inputs=[condition, x, y], outputs=[z], name="test_where_long_example" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/xor.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/xor.py new file mode 100644 index 0000000000000000000000000000000000000000..ed895a7c4e97d90a3697305ced58417102800ee5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/node/xor.py @@ -0,0 +1,76 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Xor(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Xor", + inputs=["x", "y"], + outputs=["xor"], + ) + + # 2d + x = (np.random.randn(3, 4) > 0).astype(bool) + y = (np.random.randn(3, 4) > 0).astype(bool) + z = np.logical_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_xor2d") + + # 3d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(3, 4, 5) > 0).astype(bool) + z = np.logical_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_xor3d") + + # 4d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + z = np.logical_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_xor4d") + + @staticmethod + def export_xor_broadcast() -> None: + node = onnx.helper.make_node( + "Xor", + inputs=["x", "y"], + outputs=["xor"], + ) + + # 3d vs 1d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(5) > 0).astype(bool) + z = np.logical_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast3v1d") + + # 3d vs 2d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(4, 5) > 0).astype(bool) + z = np.logical_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast3v2d") + + # 4d vs 2d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(5, 6) > 0).astype(bool) + z = np.logical_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v2d") + + # 4d vs 3d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(4, 5, 6) > 0).astype(bool) + z = np.logical_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v3d") + + # 4d vs 4d + x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool) + y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool) + z = np.logical_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v4d") diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/test_case.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/test_case.py new file mode 100644 index 0000000000000000000000000000000000000000..628bf24959c37299c66829fc8d6e52f85b7e5b4a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/test_case.py @@ -0,0 +1,29 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from collections.abc import Sequence + + import numpy as np + + import onnx + + +@dataclass +class TestCase: + name: str + model_name: str + url: str | None + model_dir: str | None + model: onnx.ModelProto | None + data_sets: Sequence[tuple[Sequence[np.ndarray], Sequence[np.ndarray]]] | None + kind: str + rtol: float + atol: float + # Tell PyTest this isn't a real test. + __test__: bool = False diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/utils.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..54a0b27e1292add9127f22f51f303b9401f24788 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/case/utils.py @@ -0,0 +1,45 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import importlib +import pkgutil +from typing import TYPE_CHECKING + +import numpy as np + +from onnx import ONNX_ML + +if TYPE_CHECKING: + from types import ModuleType + +all_numeric_dtypes = [ + np.int8, + np.int16, + np.int32, + np.int64, + np.uint8, + np.uint16, + np.uint32, + np.uint64, + np.float16, + np.float32, + np.float64, +] + + +def import_recursive(package: ModuleType) -> None: + """Takes a package and imports all modules underneath it.""" + pkg_dir = package.__path__ + module_location = package.__name__ + for _module_loader, name, ispkg in pkgutil.iter_modules(pkg_dir): + module_name = f"{module_location}.{name}" # Module/package + if not ONNX_ML and module_name.startswith( + "onnx.backend.test.case.node.ai_onnx_ml" + ): + continue + + module = importlib.import_module(module_name) + if ispkg: + import_recursive(module) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/cmd_tools.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/cmd_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..4da788e82a3920a3f3462d2ac1399210ed68032a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/cmd_tools.py @@ -0,0 +1,190 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import argparse +import json +import os +import shutil +import warnings + +import onnx.backend.test.case.model as model_test +import onnx.backend.test.case.node as node_test +from onnx import ONNX_ML, TensorProto, numpy_helper + +TOP_DIR = os.path.realpath(os.path.dirname(__file__)) +DATA_DIR = os.path.join(TOP_DIR, "data") + + +def generate_data(args: argparse.Namespace) -> None: + def prepare_dir(path: str) -> None: + if os.path.exists(path): + shutil.rmtree(path) + os.makedirs(path) + + # Clean the output directory before generating data for node testcases + # It is used to check new generated data is correct in CIs + node_root = os.path.join(args.output, "node") + original_dir_number = len( + [name for name in os.listdir(node_root) if os.path.isfile(name)] + ) + if args.clean and os.path.exists(node_root): + for sub_dir in os.listdir(node_root): + if ONNX_ML or not sub_dir.startswith("test_ai_onnx_ml_"): + shutil.rmtree(os.path.join(node_root, sub_dir)) + + cases = model_test.collect_testcases() + # If op_type is specified, only include those testcases including the given operator + # Otherwise, include all of the testcases + if args.diff: + cases += node_test.collect_diff_testcases() + else: + cases += node_test.collect_testcases(args.op_type) + node_number = 0 + + for case in cases: + output_dir = os.path.join(args.output, case.kind, case.name) + prepare_dir(output_dir) + if case.kind == "node": + node_number += 1 + if case.kind == "real": + with open(os.path.join(output_dir, "data.json"), "w") as fi: + json.dump( + { + "url": case.url, + "model_name": case.model_name, + "rtol": case.rtol, + "atol": case.atol, + }, + fi, + sort_keys=True, + ) + else: + assert case.model + with open(os.path.join(output_dir, "model.onnx"), "wb") as f: + f.write(case.model.SerializeToString()) + assert case.data_sets + for i, (inputs, outputs) in enumerate(case.data_sets): + data_set_dir = os.path.join(output_dir, f"test_data_set_{i}") + prepare_dir(data_set_dir) + for j, input in enumerate(inputs): + with open(os.path.join(data_set_dir, f"input_{j}.pb"), "wb") as f: + if case.model.graph.input[j].type.HasField("map_type"): + f.write( + numpy_helper.from_dict( + input, case.model.graph.input[j].name + ).SerializeToString() + ) + elif case.model.graph.input[j].type.HasField("sequence_type"): + f.write( + numpy_helper.from_list( + input, case.model.graph.input[j].name + ).SerializeToString() + ) + elif case.model.graph.input[j].type.HasField("optional_type"): + f.write( + numpy_helper.from_optional( + input, case.model.graph.input[j].name + ).SerializeToString() + ) + else: + assert case.model.graph.input[j].type.HasField( + "tensor_type" + ) + if isinstance(input, TensorProto): + f.write(input.SerializeToString()) + else: + f.write( + numpy_helper.from_array( + input, case.model.graph.input[j].name + ).SerializeToString() + ) + for j, output in enumerate(outputs): + with open(os.path.join(data_set_dir, f"output_{j}.pb"), "wb") as f: + if case.model.graph.output[j].type.HasField("map_type"): + f.write( + numpy_helper.from_dict( + output, case.model.graph.output[j].name + ).SerializeToString() + ) + elif case.model.graph.output[j].type.HasField("sequence_type"): + f.write( + numpy_helper.from_list( + output, case.model.graph.output[j].name + ).SerializeToString() + ) + elif case.model.graph.output[j].type.HasField("optional_type"): + f.write( + numpy_helper.from_optional( + output, case.model.graph.output[j].name + ).SerializeToString() + ) + else: + assert case.model.graph.output[j].type.HasField( + "tensor_type" + ) + if isinstance(output, TensorProto): + f.write(output.SerializeToString()) + else: + f.write( + numpy_helper.from_array( + output, case.model.graph.output[j].name + ).SerializeToString() + ) + if not args.clean and node_number != original_dir_number: + warnings.warn( + "There are some models under 'onnx/backend/test/data/node' which cannot not" + " be generated by the script from 'onnx/backend/test/case/node'. Please add" + " '--clean' option for 'python onnx/backend/test/cmd_tools.py generate-data'" + " to cleanup the existing directories and regenerate them.", + Warning, + stacklevel=2, + ) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser("backend-test-tools") + subparsers = parser.add_subparsers() + + subparser = subparsers.add_parser( + "generate-data", help="convert testcases to test data." + ) + subparser.add_argument( + "-c", + "--clean", + default=False, + action="store_true", + help="Clean the output directory before generating data for node testcases.", + ) + subparser.add_argument( + "-o", + "--output", + default=DATA_DIR, + help="output directory (default: %(default)s)", + ) + subparser.add_argument( + "-t", + "--op_type", + default=None, + help="op_type for test case generation. (generates test data for the specified op_type only.)", + ) + subparser.add_argument( + "-d", + "--diff", + default=False, + action="store_true", + help="only generates test data for those changed files (compared to the main branch).", + ) + subparser.set_defaults(func=generate_data) + + return parser.parse_args() + + +def main() -> None: + args = parse_args() + args.func(args) + + +if __name__ == "__main__": + main() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_bvlc_alexnet/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_bvlc_alexnet/data.json new file mode 100644 index 0000000000000000000000000000000000000000..8172a83e232426f99dfdb8c82ef4d31f724999e0 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_bvlc_alexnet/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "bvlc_alexnet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_bvlc_alexnet.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_densenet121/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_densenet121/data.json new file mode 100644 index 0000000000000000000000000000000000000000..69bac6cd284a5e8cf3279587be659f49cecfc252 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_densenet121/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "densenet121", "rtol": 0.002, "url": "onnx/backend/test/data/light/light_densenet121.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_inception_v1/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_inception_v1/data.json new file mode 100644 index 0000000000000000000000000000000000000000..50272a3b542a351e6dc57ddca865c68d7a6c6ba1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_inception_v1/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "inception_v1", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_inception_v1.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_inception_v2/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_inception_v2/data.json new file mode 100644 index 0000000000000000000000000000000000000000..7c26928046f8b082445bf489cc9f68d1e0ac8b41 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_inception_v2/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "inception_v2", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_inception_v2.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_resnet50/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_resnet50/data.json new file mode 100644 index 0000000000000000000000000000000000000000..f5a100e528f0233e080012a7887bcdff648050ec --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_resnet50/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "resnet50", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_resnet50.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_shufflenet/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_shufflenet/data.json new file mode 100644 index 0000000000000000000000000000000000000000..6bb5a0b9d45eb520b93e23bfba869d49068e60bb --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_shufflenet/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "shufflenet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_shufflenet.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_squeezenet/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_squeezenet/data.json new file mode 100644 index 0000000000000000000000000000000000000000..fb0e7f252a18ed9c836c916f5ae076642fbac9bc --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_squeezenet/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "squeezenet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_squeezenet.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_vgg19/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_vgg19/data.json new file mode 100644 index 0000000000000000000000000000000000000000..2ad3c4f647dc6df6353b097e2a76e81de8f00565 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_vgg19/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "vgg19", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_vgg19.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_zfnet512/data.json b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_zfnet512/data.json new file mode 100644 index 0000000000000000000000000000000000000000..4fabcd5aa0d169f4e576925471ba08ade1c83e47 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/data/real/test_zfnet512/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "zfnet512", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_zfnet512.onnx"} \ No newline at end of file diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/loader/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/loader/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..530fdf15dd2dca8e314723208b5d983f9abdeafa --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/loader/__init__.py @@ -0,0 +1,66 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import json +import os + +from onnx.backend.test.case.test_case import TestCase + +DATA_DIR = os.path.join( + os.path.dirname(os.path.realpath(os.path.dirname(__file__))), "data" +) + + +def load_model_tests( + data_dir: str = DATA_DIR, + kind: str | None = None, +) -> list[TestCase]: + """Load model test cases from on-disk data files.""" + supported_kinds = os.listdir(data_dir) + if kind not in supported_kinds: + raise ValueError(f"kind must be one of {supported_kinds}") + + testcases = [] + + kind_dir = os.path.join(data_dir, kind) + for test_name in os.listdir(kind_dir): + case_dir = os.path.join(kind_dir, test_name) + # skip the non-dir files, such as generated __init__.py. + rtol = 1e-3 + atol = 1e-7 + if not os.path.isdir(case_dir): + continue + if os.path.exists(os.path.join(case_dir, "model.onnx")): + url = None + model_name = test_name[len("test_")] + model_dir: str | None = case_dir + if os.path.exists(os.path.join(case_dir, "data.json")): + with open(os.path.join(case_dir, "data.json")) as f: + data = json.load(f) + rtol = data.get("rtol", rtol) + atol = data.get("atol", atol) + else: + with open(os.path.join(case_dir, "data.json")) as f: + data = json.load(f) + url = data["url"] + model_name = data["model_name"] + rtol = data.get("rtol", rtol) + atol = data.get("atol", atol) + model_dir = None + testcases.append( + TestCase( + name=test_name, + url=url, + model_name=model_name, + model_dir=model_dir, + model=None, + data_sets=None, + kind=kind, + rtol=rtol, + atol=atol, + ) + ) + + return testcases diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b5ec9ed25402af8e95ee92a92ccd40c7105c0c1 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/__init__.py @@ -0,0 +1,50 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +import pytest + +from onnx.backend.test.report.coverage import Coverage + +if TYPE_CHECKING: + from collections.abc import Sequence + + import _pytest + +_coverage = Coverage() +_marks: dict[str, Sequence[Any]] = {} + + +def _add_mark(mark: Any, bucket: str) -> None: + proto = mark.args[0] + if isinstance(proto, list): + assert len(proto) == 1 + proto = proto[0] + if proto is not None: + _coverage.add_proto(proto, bucket, mark.args[1] == "RealModel") + + +def pytest_runtest_call(item: _pytest.nodes.Item) -> None: + mark = item.get_closest_marker("onnx_coverage") + if mark: + assert item.nodeid not in _marks + _marks[item.nodeid] = mark + + +def pytest_runtest_logreport(report: Any) -> None: + if report.when == "call" and report.outcome == "passed" and report.nodeid in _marks: + mark = _marks[report.nodeid] + _add_mark(mark, "passed") + + +@pytest.hookimpl(trylast=True) +def pytest_terminal_summary( + terminalreporter: _pytest.terminal.TerminalReporter, + exitstatus: int, # noqa: ARG001 +) -> None: + for mark in _marks.values(): + _add_mark(mark, "loaded") + _coverage.report_text(terminalreporter) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/base.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/base.py new file mode 100644 index 0000000000000000000000000000000000000000..7284f100193b86be7368bbd9925ffd62689c1a42 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/base.py @@ -0,0 +1,8 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + + +class ReporterBase: + pass diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/coverage.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/coverage.py new file mode 100644 index 0000000000000000000000000000000000000000..6d1765ff45bc67c9384a62963ea7aa9f24b8ee0e --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/report/coverage.py @@ -0,0 +1,266 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import csv +import datetime +import os +from collections import OrderedDict, defaultdict +from typing import IO, Any + +from tabulate import tabulate + +import onnx +from onnx import GraphProto, defs, helper + +_all_schemas = defs.get_all_schemas() + + +class AttrCoverage: + def __init__(self) -> None: + self.name: str | None = None + self.values: set[str] = set() + + def add(self, attr: onnx.AttributeProto) -> None: + assert self.name in {None, attr.name} + self.name = attr.name + value = helper.get_attribute_value(attr) + # Turn list into tuple so we can put it into set + # As value can be string, don't blindly turn `collections.Iterable` + # into tuple. + if isinstance(value, list): + value = tuple(value) + self.values.add(str(value)) + + +class NodeCoverage: + def __init__(self) -> None: + self.op_type: str | None = None + self.attr_coverages: dict[str, AttrCoverage] = defaultdict(AttrCoverage) + + def add(self, node: onnx.NodeProto) -> None: + assert self.op_type in [None, node.op_type] + + if self.op_type is None: + self.op_type = node.op_type + assert self.op_type is not None + self.schema = defs.get_schema(self.op_type, domain=node.domain) + + for attr in node.attribute: + self.attr_coverages[attr.name].add(attr) + + +class ModelCoverage: + def __init__(self) -> None: + self.name: str | None = None + self.graph: GraphProto | None = None + self.node_coverages: dict[str, NodeCoverage] = defaultdict(NodeCoverage) + + def add(self, model: onnx.ModelProto) -> None: + assert self.name in [None, model.graph.name] + + if self.name is None: + self.name = model.graph.name + assert self.name is not None + self.graph = model.graph + + for node in model.graph.node: + self.node_coverages[node.op_type].add(node) + + +class Coverage: + def __init__(self) -> None: + self.buckets: dict[str, dict[str, NodeCoverage]] = { + "loaded": defaultdict(NodeCoverage), + "passed": defaultdict(NodeCoverage), + } + self.models: dict[str, dict[str, ModelCoverage]] = { + "loaded": defaultdict(ModelCoverage), + "passed": defaultdict(ModelCoverage), + } + + def add_node(self, node: onnx.NodeProto, bucket: str) -> None: + self.buckets[bucket][node.op_type].add(node) + + def add_graph(self, graph: onnx.GraphProto, bucket: str) -> None: + for node in graph.node: + self.add_node(node, bucket) + + def add_model(self, model: onnx.ModelProto, bucket: str, is_model: bool) -> None: + self.add_graph(model.graph, bucket) + # Only add model if name does not start with test + if is_model: + self.models[bucket][model.graph.name].add(model) + + def add_proto(self, proto: onnx.ModelProto, bucket: str, is_model: bool) -> None: + assert isinstance(proto, onnx.ModelProto) + self.add_model(proto, bucket, is_model) + + def report_text(self, writer: IO[str]) -> None: + writer.write("---------- onnx coverage: ----------\n") + writer.write( + f"Operators (passed/loaded/total): {len(self.buckets['passed'])}/{len(self.buckets['loaded'])}/{len(_all_schemas)}\n" + ) + writer.write("------------------------------------\n") + + rows = [] + passed = [] + all_ops: list[str] = [] + experimental: list[str] = [] + for op_cov in self.buckets["passed"].values(): + covered_attrs = [ + f"{attr_cov.name}: {len(attr_cov.values)}" + for attr_cov in op_cov.attr_coverages.values() + ] + uncovered_attrs = [ + f"{attr}: 0" + for attr in op_cov.schema.attributes + if attr not in op_cov.attr_coverages + ] + attrs = sorted(covered_attrs) + sorted(uncovered_attrs) + if attrs: + attrs_column = os.linesep.join(attrs) + else: + attrs_column = "No attributes" + rows.append([op_cov.op_type, attrs_column]) + passed.append(op_cov.op_type) + writer.write( + tabulate( + rows, + headers=["Operator", "Attributes\n(name: #values)"], + tablefmt="plain", + ) + ) + writer.write("\n") + if os.environ.get("CSVDIR") is not None: + self.report_csv(all_ops, passed, experimental) + + # This function writes the coverage report to a set of CSV files for + # the Backend Scoreboard (onnx.ai/backend-scoreboard). To enable this + # feature, set a CSVDIR environment variable locally with the directory + # where you would like the files to be written, relative to the + # directory from which you're running pytest. The format of the CSV + # files is a column naming each op or model and columns for each + # backend with indications of whether the tests passed or failed for + # each row. + def report_csv( + self, all_ops: list[str], passed: list[str | None], experimental: list[str] + ) -> None: + for schema in _all_schemas: + if schema.domain in {"", "ai.onnx"}: + all_ops.append(schema.name) + if schema.support_level == defs.OpSchema.SupportType.EXPERIMENTAL: + experimental.append(schema.name) + all_ops.sort() + nodes_path = os.path.join(str(os.environ.get("CSVDIR")), "nodes.csv") + models_path = os.path.join(str(os.environ.get("CSVDIR")), "models.csv") + existing_nodes: OrderedDict[str, dict[str, str]] = OrderedDict() + existing_models: OrderedDict[str, dict[str, str]] = OrderedDict() + frameworks: list[str] = [] + if os.path.isfile(nodes_path): + with open(nodes_path) as nodes_file: + reader = csv.DictReader(nodes_file) + assert reader.fieldnames + frameworks = list(reader.fieldnames) + for row in reader: + op = row["Op"] + del row["Op"] + existing_nodes[str(op)] = row + if os.path.isfile(models_path): + with open(models_path) as models_file: + reader = csv.DictReader(models_file) + for row in reader: + model = row["Model"] + del row["Model"] + existing_models[str(model)] = row + backend = os.environ.get("BACKEND") + other_frameworks = frameworks[1:] + with open(nodes_path, "w") as nodes_file: + if "Op" not in frameworks: + frameworks.append("Op") + if backend not in frameworks: + frameworks.append(str(backend)) + else: + other_frameworks.remove(str(backend)) + node_writer = csv.DictWriter(nodes_file, fieldnames=frameworks) + node_writer.writeheader() + for node in all_ops: + node_name = node + if node in experimental: + node_name = node + " (Experimental)" + if node_name not in existing_nodes: + # Also add Skipped for other nodes + existing_nodes[node_name] = OrderedDict() + for other_framework in other_frameworks: + existing_nodes[node_name][other_framework] = "Skipped!" + if node in passed: + existing_nodes[node_name][str(backend)] = "Passed!" + else: + existing_nodes[node_name][str(backend)] = "Failed!" + summaries: dict[Any, Any] = {} + if "Summary" in existing_nodes: + summaries = existing_nodes["Summary"] + del existing_nodes["Summary"] + summaries[str(backend)] = f"{len(passed)}/{len(all_ops)} node tests passed" + summaries["Op"] = "Summary" + for node in existing_nodes: + existing_nodes[node]["Op"] = str(node) + node_writer.writerow(existing_nodes[node]) + node_writer.writerow(summaries) + with open(models_path, "w") as models_file: + frameworks[0] = "Model" + model_writer = csv.DictWriter(models_file, fieldnames=frameworks) + model_writer.writeheader() + # Consider both buckets + num_models = 0 + for bucket in self.models: + for model in self.models[bucket]: + # Both analyze and run the model on the backend + num_covered = 0 + for node in self.models[bucket][model].node_coverages: + if node in passed: + num_covered += 1 + # TODO: Identify if there are models that are being + # skipped/not loaded, but that are in other frameworks + msg = "Passed!" + if bucket == "loaded": + if model in self.models["passed"]: + continue + msg = "Failed!" + num_models += 1 + if model not in existing_models: + # Also add Skipped for other models + existing_models[model] = OrderedDict() + for other_framework in other_frameworks: + existing_models[model][other_framework] = "Skipped!" + existing_models[model][str(backend)] = str( + f"{num_covered}/{len(self.models[bucket][model].node_coverages)} nodes covered: {msg}" + ) + summaries.clear() + if "Summary" in existing_models: + summaries = existing_models["Summary"] + del existing_models["Summary"] + if str(backend) in summaries: + del summaries[str(backend)] + summaries[str(backend)] = ( + f"{len(self.models['passed'])}/{num_models} model tests passed" + ) + summaries["Model"] = "Summary" + for model in existing_models: + existing_models[model]["Model"] = model + model_writer.writerow(existing_models[model]) + model_writer.writerow(summaries) + with open( + os.path.join(str(os.environ.get("CSVDIR")), "metadata.csv"), + "w", + ) as metadata_file: + metadata_writer = csv.writer(metadata_file) + metadata_writer.writerow( + [ + "Latest Update", + datetime.datetime.now(tz=datetime.timezone.utc) + .isoformat() + .replace("T", " "), + ] + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/runner/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/runner/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d6b8d0ad062e4a7bd7e9d816bcdcab3202fd24c2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/runner/__init__.py @@ -0,0 +1,529 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import functools +import glob +import os +import re +import shutil +import sys +import tempfile +import time +import unittest +from collections import defaultdict +from re import Pattern +from typing import TYPE_CHECKING, Any +from urllib.request import urlretrieve + +import numpy as np + +import onnx +import onnx.reference +from onnx import ONNX_ML, ModelProto, NodeProto, TypeProto, ValueInfoProto, numpy_helper +from onnx.backend.test.loader import load_model_tests +from onnx.backend.test.runner.item import TestItem + +if TYPE_CHECKING: + from collections.abc import Callable, Iterable, Sequence + + from onnx.backend.base import Backend + from onnx.backend.test.case.test_case import TestCase + + +class BackendIsNotSupposedToImplementIt(unittest.SkipTest): + pass + + +def retry_execute(times: int) -> Callable[[Callable[..., Any]], Callable[..., Any]]: + assert times >= 1 + + def wrapper(func: Callable[..., Any]) -> Callable[..., Any]: + @functools.wraps(func) + def wrapped(*args: Any, **kwargs: Any) -> Any: + for i in range(1, times + 1): + try: + return func(*args, **kwargs) + except Exception: # noqa: PERF203 + print(f"{i} times tried") + if i == times: + raise + time.sleep(5 * i) + return None + + return wrapped + + return wrapper + + +class Runner: + def __init__( + self, + backend: type[Backend], + parent_module: str | None = None, + test_kwargs: dict | None = None, + ) -> None: + self.backend = backend + self._parent_module = parent_module + self._include_patterns: set[Pattern[str]] = set() + self._exclude_patterns: set[Pattern[str]] = set() + self._xfail_patterns: set[Pattern[str]] = set() + self._test_kwargs: dict = test_kwargs or {} + + # This is the source of the truth of all test functions. + # Properties `test_cases`, `test_suite` and `tests` will be + # derived from it. + # {category: {name: func}} + self._test_items: dict[str, dict[str, TestItem]] = defaultdict(dict) + + for rt in load_model_tests(kind="node"): + self._add_model_test(rt, "Node") + + for rt in load_model_tests(kind="real"): + self._add_model_test(rt, "Real") + + for rt in load_model_tests(kind="simple"): + self._add_model_test(rt, "Simple") + + for ct in load_model_tests(kind="pytorch-converted"): + self._add_model_test(ct, "PyTorchConverted") + + for test_case in load_model_tests(kind="pytorch-operator"): + self._add_model_test(test_case, "PyTorchOperator") + + def _get_test_case(self, name: str) -> type[unittest.TestCase]: + test_case = type(str(name), (unittest.TestCase,), {}) + if self._parent_module: + test_case.__module__ = self._parent_module + return test_case + + def include(self, pattern: str) -> Runner: + self._include_patterns.add(re.compile(pattern)) + return self + + def exclude(self, pattern: str) -> Runner: + self._exclude_patterns.add(re.compile(pattern)) + return self + + def xfail(self, pattern: str) -> Runner: + self._xfail_patterns.add(re.compile(pattern)) + return self + + def enable_report(self) -> Runner: + import pytest # noqa: PLC0415 + + for category, items_map in self._test_items.items(): + for item in items_map.values(): + item.func = pytest.mark.onnx_coverage(item.proto, category)(item.func) + return self + + @property + def _filtered_test_items(self) -> dict[str, dict[str, TestItem]]: + filtered: dict[str, dict[str, TestItem]] = {} + for category, items_map in self._test_items.items(): + filtered[category] = {} + for name, item in items_map.items(): + if self._include_patterns and ( + not any(include.search(name) for include in self._include_patterns) + ): + item.func = unittest.skip("no matched include pattern")(item.func) + for exclude in self._exclude_patterns: + if exclude.search(name): + item.func = unittest.skip( + f'matched exclude pattern "{exclude.pattern}"' + )(item.func) + for xfail in self._xfail_patterns: + if xfail.search(name): + item.func = unittest.expectedFailure(item.func) + filtered[category][name] = item + return filtered + + @property + def test_cases(self) -> dict[str, type[unittest.TestCase]]: + """List of test cases to be applied on the parent scope + Example usage: + globals().update(BackendTest(backend).test_cases) + """ + test_cases = {} + for category, items_map in self._filtered_test_items.items(): + test_case_name = f"OnnxBackend{category}Test" + test_case = self._get_test_case(test_case_name) + for name, item in sorted(items_map.items()): + setattr(test_case, name, item.func) + test_cases[test_case_name] = test_case + return test_cases + + @property + def test_suite(self) -> unittest.TestSuite: + """TestSuite that can be run by TestRunner + Example usage: + unittest.TextTestRunner().run(BackendTest(backend).test_suite) + """ + suite = unittest.TestSuite() + for case in sorted( + self.test_cases.values(), key=lambda cl: cl.__class__.__name__ + ): + suite.addTests(unittest.defaultTestLoader.loadTestsFromTestCase(case)) + return suite + + # For backward compatibility (we used to expose `.tests`) + @property + def tests(self) -> type[unittest.TestCase]: + """One single unittest.TestCase that hosts all the test functions + Example usage: + onnx_backend_tests = BackendTest(backend).tests + """ + tests = self._get_test_case("OnnxBackendTest") + for items_map in sorted( + self._filtered_test_items.values(), key=lambda cl: cl.__class__.__name__ + ): + for name, item in sorted(items_map.items()): + setattr(tests, name, item.func) + return tests + + @classmethod + def assert_similar_outputs( + cls, + ref_outputs: Sequence[Any], + outputs: Sequence[Any], + rtol: float, + atol: float, + model_dir: str | None = None, + ) -> None: + try: + np.testing.assert_equal(len(outputs), len(ref_outputs)) + except TypeError as e: + raise TypeError( + f"Unable to compare expected type {type(ref_outputs)} " + f"and runtime type {type(outputs)} (known test={model_dir or '?'!r})" + ) from e + for i in range(len(outputs)): + if isinstance(outputs[i], (list, tuple)): + if not isinstance(ref_outputs[i], (list, tuple)): + raise AssertionError( # noqa: TRY004 + f"Unexpected type {type(outputs[i])} for outputs[{i}]. Expected " + f"type is {type(ref_outputs[i])} (known test={model_dir or '?'!r})." + ) + for j in range(len(outputs[i])): + cls.assert_similar_outputs( + ref_outputs[i][j], + outputs[i][j], + rtol, + atol, + model_dir=model_dir, + ) + else: + np.testing.assert_array_equal( + outputs[i].shape, + ref_outputs[i].shape, + err_msg=f"Output {i} has incorrect shape", + ) + if ref_outputs[i].dtype == object: + # Strings + np.testing.assert_array_equal(outputs[i], ref_outputs[i]) + else: + np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype) + np.testing.assert_allclose( + outputs[i], ref_outputs[i], rtol=rtol, atol=atol + ) + + @classmethod + @retry_execute(3) + def download_model( + cls, + model_test: TestCase, + models_dir: str, + ) -> None: + with tempfile.TemporaryDirectory() as tmpdir: + try: + assert model_test.url + print( + f"Start downloading model {model_test.model_name} from {model_test.url}" + ) + filename = os.path.join(tmpdir, "file") + urlretrieve(model_test.url, filename) + print("Done") + onnx.utils._extract_model_safe(filename, models_dir) + except Exception as e: + print(f"Failed to prepare data for model {model_test.model_name}: {e}") + raise + + @classmethod + def prepare_model_data(cls, model_test: TestCase) -> str: + onnx_home = os.path.expanduser( + os.getenv("ONNX_HOME", os.path.join("~", ".onnx")) + ) + models_dir = os.getenv("ONNX_MODELS", os.path.join(onnx_home, "models")) + model_dir: str = os.path.join(models_dir, model_test.model_name) + if not os.path.exists(os.path.join(model_dir, "model.onnx")): + if os.path.exists(model_dir): + bi = 0 + while True: + dest = f"{model_dir}.old.{bi}" + if os.path.exists(dest): + bi += 1 + continue + shutil.move(model_dir, dest) + break + os.makedirs(model_dir) + + cls.download_model(model_test=model_test, models_dir=models_dir) + return model_dir + + def _add_test( + self, + category: str, + test_name: str, + test_func: Callable[..., Any], + report_item: list[ModelProto | NodeProto | None], + devices: Iterable[str] = ("CPU", "CUDA"), + **kwargs: Any, + ) -> None: + # We don't prepend the 'test_' prefix to improve greppability + if not test_name.startswith("test_"): + raise ValueError(f"Test name must start with test_: {test_name}") + + def add_device_test(device: str) -> None: + device_test_name = f"{test_name}_{device.lower()}" + if device_test_name in self._test_items[category]: + raise ValueError( + f'Duplicated test name "{device_test_name}" in category "{category}"' + ) + + @unittest.skipIf( + not self.backend.supports_device(device), + f"Backend doesn't support device {device}", + ) + @functools.wraps(test_func) + def device_test_func(*args: Any, **device_test_kwarg: Any) -> Any: + try: + merged_kwargs = {**kwargs, **device_test_kwarg} + return test_func(*args, device, **merged_kwargs) + except BackendIsNotSupposedToImplementIt as e: + # hacky verbose reporting + if "-v" in sys.argv or "--verbose" in sys.argv: + print(f"Test {device_test_name} is effectively skipped: {e}") + + self._test_items[category][device_test_name] = TestItem( + device_test_func, report_item + ) + + for device in devices: + add_device_test(device) + + @staticmethod + def generate_dummy_data( + x: ValueInfoProto, seed: int = 0, name: str = "", random: bool = False + ) -> np.ndarray: + """Generates a random tensor based on the input definition.""" + if not x.type.tensor_type: + raise NotImplementedError( + f"Input expected to have tensor type. " + f"Unable to generate random data for model {name!r} and input {x}." + ) + if x.type.tensor_type.elem_type != 1: + raise NotImplementedError( + f"Currently limited to float tensors. " + f"Unable to generate random data for model {name!r} and input {x}." + ) + shape = tuple( + d.dim_value if d.HasField("dim_value") else 1 + for d in x.type.tensor_type.shape.dim + ) + if random: + gen = np.random.default_rng(seed=seed) + return gen.random(shape, np.float32) + n = np.prod(shape) + return (np.arange(n).reshape(shape) / n).astype(np.float32) + + def _add_model_test(self, model_test: TestCase, kind: str) -> None: + # model is loaded at runtime, note sometimes it could even + # never loaded if the test skipped + model_marker: list[ModelProto | NodeProto | None] = [None] + + def run(test_self: Any, device: str, **kwargs) -> None: # noqa: ARG001 + if model_test.url is not None and model_test.url.startswith( + "onnx/backend/test/data/light/" + ): + # testing local files + model_pb_path = os.path.normpath( + os.path.join( + os.path.dirname(__file__), + "..", + "..", + "..", + "..", + model_test.url, + ) + ) + if not os.path.exists(model_pb_path): + raise FileNotFoundError(f"Unable to find model {model_pb_path!r}.") + onnx_home = os.path.expanduser( + os.getenv("ONNX_HOME", os.path.join("~", ".onnx")) + ) + models_dir = os.getenv( + "ONNX_MODELS", os.path.join(onnx_home, "models", "light") + ) + model_dir: str = os.path.join(models_dir, model_test.model_name) + if not os.path.exists(model_dir): + os.makedirs(model_dir) + use_dummy = True + else: + if model_test.model_dir is None: + model_dir = self.prepare_model_data(model_test) + else: + model_dir = model_test.model_dir + model_pb_path = os.path.join(model_dir, "model.onnx") + use_dummy = False + + if not ONNX_ML and "ai_onnx_ml" in model_dir: + return + + model = onnx.load(model_pb_path) + model_marker[0] = model + if ( + hasattr(self.backend, "is_compatible") + and callable(self.backend.is_compatible) + and not self.backend.is_compatible(model) + ): + raise unittest.SkipTest("Not compatible with backend") + + prepared_model = self.backend.prepare(model, device, **kwargs) + assert prepared_model is not None + + if use_dummy: + # When the backend test goes through a test involving a + # model stored in onnx/backend/test/data/light, + # this function generates expected output coming from + # from ReferenceEvaluator run with random inputs. + # A couple of models include many Conv operators and the + # python implementation is slow (such as test_bvlc_alexnet). + with open(model_pb_path, "rb") as f: + onx = onnx.load(f) + + test_data_set = os.path.join(model_dir, "test_data_set_0") + if not os.path.exists(test_data_set): + os.mkdir(test_data_set) + feeds = {} + inits = {i.name for i in onx.graph.initializer} + n_input = 0 + inputs = [] + for i in range(len(onx.graph.input)): + if onx.graph.input[i].name in inits: + continue + name = os.path.join(test_data_set, f"input_{n_input}.pb") + inputs.append(name) + n_input += 1 + x = onx.graph.input[i] + value = self.generate_dummy_data( + x, seed=0, name=model_test.model_name, random=False + ) + feeds[x.name] = value + with open(name, "wb") as f: + f.write(onnx.numpy_helper.from_array(value).SerializeToString()) + + # loads expected output if any available + prefix = os.path.splitext(model_pb_path)[0] + expected_outputs = [] + for i in range(len(onx.graph.output)): + name = f"{prefix}_output_{i}.pb" + if os.path.exists(name): + expected_outputs.append(name) + continue + expected_outputs = None + break + + if expected_outputs is None: + ref = onnx.reference.ReferenceEvaluator(onx) + outputs = ref.run(None, feeds) + for i, o in enumerate(outputs): + name = os.path.join(test_data_set, f"output_{i}.pb") + with open(name, "wb") as f: + f.write(onnx.numpy_helper.from_array(o).SerializeToString()) + else: + for i, o in enumerate(expected_outputs): + name = os.path.join(test_data_set, f"output_{i}.pb") + shutil.copy(o, name) + else: + # TODO after converting all npz files to protobuf, we can delete this. + for test_data_npz in glob.glob( + os.path.join(model_dir, "test_data_*.npz") + ): + test_data = np.load(test_data_npz, encoding="bytes") + inputs = list(test_data["inputs"]) + outputs = list(prepared_model.run(inputs)) + ref_outputs = tuple( + np.array(x) if not isinstance(x, (list, dict)) else x + for f in test_data["outputs"] + ) + self.assert_similar_outputs( + ref_outputs, + outputs, + rtol=kwargs.get("rtol", model_test.rtol), + atol=kwargs.get("atol", model_test.atol), + model_dir=model_dir, + ) + + for test_data_dir in glob.glob(os.path.join(model_dir, "test_data_set*")): + inputs = [] + inputs_num = len(glob.glob(os.path.join(test_data_dir, "input_*.pb"))) + for i in range(inputs_num): + input_file = os.path.join(test_data_dir, f"input_{i}.pb") + self._load_proto(input_file, inputs, model.graph.input[i].type) + ref_outputs = [] + ref_outputs_num = len( + glob.glob(os.path.join(test_data_dir, "output_*.pb")) + ) + for i in range(ref_outputs_num): + output_file = os.path.join(test_data_dir, f"output_{i}.pb") + self._load_proto( + output_file, ref_outputs, model.graph.output[i].type + ) + outputs = list(prepared_model.run(inputs)) + self.assert_similar_outputs( + ref_outputs, + outputs, + rtol=kwargs.get("rtol", model_test.rtol), + atol=kwargs.get("atol", model_test.atol), + model_dir=model_dir, + ) + + if model_test.name in self._test_kwargs: + self._add_test( + kind + "Model", + model_test.name, + run, + model_marker, + **self._test_kwargs[model_test.name], + ) + else: + self._add_test(kind + "Model", model_test.name, run, model_marker) + + def _load_proto( + self, + proto_filename: str, + target_list: list[np.ndarray | list[Any]], + model_type_proto: TypeProto, + ) -> None: + with open(proto_filename, "rb") as f: + protobuf_content = f.read() + if model_type_proto.HasField("sequence_type"): + sequence = onnx.SequenceProto() + sequence.ParseFromString(protobuf_content) + target_list.append(numpy_helper.to_list(sequence)) + elif model_type_proto.HasField("tensor_type"): + tensor = onnx.TensorProto() + tensor.ParseFromString(protobuf_content) + t = numpy_helper.to_array(tensor) + assert isinstance(t, np.ndarray) + target_list.append(t) + elif model_type_proto.HasField("optional_type"): + optional = onnx.OptionalProto() + optional.ParseFromString(protobuf_content) + target_list.append(numpy_helper.to_optional(optional)) # type: ignore[arg-type] + else: + print( + "Loading proto of that specific type (Map/Sparse Tensor) is currently not supported" + ) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/runner/item.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/runner/item.py new file mode 100644 index 0000000000000000000000000000000000000000..205ded93c4e128f1f344dadb655d38c42597e76c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/runner/item.py @@ -0,0 +1,21 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import dataclasses +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from collections.abc import Callable + + from onnx import ModelProto, NodeProto + +# A container that hosts the test function and the associated +# test item (ModelProto) + + +@dataclasses.dataclass +class TestItem: + func: Callable[..., Any] + proto: list[ModelProto | NodeProto | None] diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/stat_coverage.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/stat_coverage.py new file mode 100644 index 0000000000000000000000000000000000000000..33abdcead3856bcd9be7c80b822d3b0669dd9506 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/backend/test/stat_coverage.py @@ -0,0 +1,299 @@ +#!/usr/bin/env python + +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import os +from typing import IO, TYPE_CHECKING, Any + +from onnx import AttributeProto, defs, load +from onnx.backend.test.case import collect_snippets +from onnx.backend.test.loader import load_model_tests +from onnx.backend.test.runner import Runner + +if TYPE_CHECKING: + from collections.abc import Sequence + + +def is_ml(schemas: Sequence[defs.OpSchema]) -> bool: + return any(s.domain == "ai.onnx.ml" for s in schemas) + + +def gen_outlines(f: IO[Any], ml: bool) -> None: + f.write("# Test Coverage Report") + if ml: + f.write(" (ONNX-ML Operators)\n") + else: + f.write(" (ONNX Core Operators)\n") + f.write("## Outlines\n") + f.write("* [Node Test Coverage](#node-test-coverage)\n") + f.write("* [Model Test Coverage](#model-test-coverage)\n") + f.write("* [Overall Test Coverage](#overall-test-coverage)\n") + + +common_covered: Sequence[str] = [] +experimental_covered: Sequence[str] = [] + + +def gen_node_test_coverage( + schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool +) -> None: + global common_covered # noqa: PLW0603 + global experimental_covered # noqa: PLW0603 + generators = set( + { + "Multinomial", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + } + ) + node_tests = collect_snippets() + common_covered = sorted( + s.name + for s in schemas + if s.name in node_tests + and s.support_level == defs.OpSchema.SupportType.COMMON + and (s.domain == "ai.onnx.ml") == ml + ) + common_no_cover = sorted( + s.name + for s in schemas + if s.name not in node_tests + and s.support_level == defs.OpSchema.SupportType.COMMON + and (s.domain == "ai.onnx.ml") == ml + ) + common_generator = sorted(name for name in common_no_cover if name in generators) + experimental_covered = sorted( + s.name + for s in schemas + if s.name in node_tests + and s.support_level == defs.OpSchema.SupportType.EXPERIMENTAL + and (s.domain == "ai.onnx.ml") == ml + ) + experimental_no_cover = sorted( + s.name + for s in schemas + if s.name not in node_tests + and s.support_level == defs.OpSchema.SupportType.EXPERIMENTAL + and (s.domain == "ai.onnx.ml") == ml + ) + experimental_generator = sorted( + name for name in experimental_no_cover if name in generators + ) + num_common = len(common_covered) + len(common_no_cover) - len(common_generator) + num_experimental = ( + len(experimental_covered) + + len(experimental_no_cover) + - len(experimental_generator) + ) + f.write("# Node Test Coverage\n") + f.write("## Summary\n") + if num_common: + f.write( + f"Node tests have covered {len(common_covered)}/{num_common} " + f"({len(common_covered) / float(num_common) * 100:.2f}%, {len(common_generator)} " + f"generators excluded) common operators.\n\n" + ) + else: + f.write("Node tests have covered 0/0 (N/A) common operators. \n\n") + if num_experimental: + f.write( + "Node tests have covered {}/{} ({:.2f}%, {} generators excluded) " # noqa: UP032 + "experimental operators.\n\n".format( + len(experimental_covered), + num_experimental, + (len(experimental_covered) / float(num_experimental) * 100), + len(experimental_generator), + ) + ) + else: + f.write("Node tests have covered 0/0 (N/A) experimental operators.\n\n") + titles = [ + "💚Covered Common Operators", + "💔No Cover Common Operators", + "💚Covered Experimental Operators", + "💔No Cover Experimental Operators", + ] + all_lists = [ + common_covered, + common_no_cover, + experimental_covered, + experimental_no_cover, + ] + for t in titles: + f.write(f"* [{t[9:]}](#{t[9:].lower().replace(' ', '-')})\n") + f.write("\n") + for t, l in zip(titles, all_lists, strict=False): # noqa: E741 + f.write(f"## {t}\n") + for s in l: + f.write(f"### {s}") + if s in node_tests: + f.write( + f"\nThere are {len(node_tests[s])} test cases, listed as following:\n" + ) + for summary, code in sorted(node_tests[s]): + f.write("
\n") + f.write(f"{summary}\n\n") + f.write(f"```python\n{code}\n```\n\n") + f.write("
\n") + else: # noqa: PLR5501 + if s in generators: + f.write(" (random generator operator)\n") + else: + f.write(" (call for test cases)\n") + f.write("\n\n") + f.write("
\n\n") + + +def gen_model_test_coverage( + schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool +) -> None: + f.write("# Model Test Coverage\n") + # Process schemas + schema_dict = {} + for schema in schemas: + schema_dict[schema.name] = schema + # Load models from each model test using Runner.prepare_model_data + # Need to grab associated nodes + attrs: dict[str, dict[str, list[Any]]] = {} + model_paths: list[Any] = [] + for rt in load_model_tests(kind="real"): + if rt.url.startswith("onnx/backend/test/data/light/"): + # testing local files + model_name = os.path.normpath( + os.path.join(os.path.dirname(__file__), "..", "..", "..", rt.url) + ) + if not os.path.exists(model_name): + raise FileNotFoundError(f"Unable to find model {model_name!r}.") + model_paths.append(model_name) + else: + model_dir = Runner.prepare_model_data(rt) + model_paths.append(os.path.join(model_dir, "model.onnx")) + model_paths.sort() + model_written = False + for model_pb_path in model_paths: + model = load(model_pb_path) + if ml: + ml_present = False + for opset in model.opset_import: + if opset.domain == "ai.onnx.ml": + ml_present = True + if not ml_present: + continue + model_written = True + f.write(f"## {model.graph.name}\n") + # Deconstruct model + num_covered = 0 + for node in model.graph.node: + if node.op_type in common_covered or node.op_type in experimental_covered: + num_covered += 1 + # Add details of which nodes are/aren't covered + # Iterate through and store each node's attributes + for attr in node.attribute: + if node.op_type not in attrs: + attrs[node.op_type] = {} + if attr.name not in attrs[node.op_type]: + attrs[node.op_type][attr.name] = [] + if attr.type == AttributeProto.FLOAT: + if attr.f not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.f) + elif attr.type == AttributeProto.INT: + if attr.i not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.i) + elif attr.type == AttributeProto.STRING: + if attr.s not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.s) + elif attr.type == AttributeProto.TENSOR: + if attr.t not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.t) + elif attr.type == AttributeProto.GRAPH: + if attr.g not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.g) + elif attr.type == AttributeProto.FLOATS: + if attr.floats not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.floats) + elif attr.type == AttributeProto.INTS: + if attr.ints not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.ints) + elif attr.type == AttributeProto.STRINGS: + if attr.strings not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.strings) + elif attr.type == AttributeProto.TENSORS: + if attr.tensors not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.tensors) + elif attr.type == AttributeProto.GRAPHS: + if attr.graphs not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.graphs) + f.write( + f"\n{model.graph.name} has {num_covered} nodes. " + f"Of these, {len(model.graph.node)} are covered by node tests " + f"({100.0 * float(num_covered) / float(len(model.graph.node))}%)\n\n\n" + ) + # Iterate through attrs, print + f.write("
\n") + f.write("nodes\n\n") + for op in sorted(attrs): + f.write("
\n") + # Get total number of attributes for node schema + f.write( + f"{op}: {len(attrs[op])} out of {len(schema_dict[op].attributes)} attributes covered\n\n" + ) + for attribute in sorted(schema_dict[op].attributes): + if attribute in attrs[op]: + f.write(f"{attribute}: {len(attrs[op][attribute])}\n") + else: + f.write(f"{attribute}: 0\n") + f.write("
\n") + f.write("
\n\n\n") + if not model_written and ml: + f.write("No model tests present for selected domain\n") + + +def gen_overall_test_coverage( + f: IO[Any], +) -> None: + f.write("# Overall Test Coverage\n") + f.write("## To be filled.\n") + + +def gen_spdx(f: IO[Any]) -> None: + # REUSE-IgnoreStart + # This source file intentionally writes an SPDX header into the generated + # output file. The literal string would confuse the REUSE linter when + # scanning this source file; ignore this region for REUSE. + f.write("\n") + # REUSE-IgnoreEnd + + +def main() -> None: + base_dir = os.path.dirname( + os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) + ) + docs_dir = os.path.join(base_dir, "docs") + schemas = defs.get_all_schemas() + + has_ml = is_ml(schemas) + fname = os.path.join(docs_dir, "TestCoverage.md") + with open(fname, "w+", newline="", encoding="utf-8") as f: # type: ignore[assignment] + gen_spdx(f) + gen_outlines(f, False) + gen_node_test_coverage(schemas, f, False) + gen_model_test_coverage(schemas, f, False) + gen_overall_test_coverage(f) + + if has_ml: + fname = os.path.join(docs_dir, "TestCoverage-ml.md") + with open(fname, "w+", newline="", encoding="utf-8") as f: # type: ignore[assignment] + gen_spdx(f) + gen_outlines(f, True) + gen_node_test_coverage(schemas, f, True) + gen_model_test_coverage(schemas, f, True) + gen_overall_test_coverage(f) + + +if __name__ == "__main__": + main() diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/bin/__init__.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/bin/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c974dafd7dddc454b4c0208797d4e35a6c7b1ab2 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/bin/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/bin/checker.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/bin/checker.py new file mode 100644 index 0000000000000000000000000000000000000000..26f337e3c619d8ccec66747a0d64bc2fb14acb7d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/bin/checker.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + +import argparse + +from onnx import NodeProto, checker, load + + +def check_model() -> None: + parser = argparse.ArgumentParser("check-model") + parser.add_argument("model_pb", type=argparse.FileType("rb")) + args = parser.parse_args() + + model = load(args.model_pb) + checker.check_model(model) + + +def check_node() -> None: + parser = argparse.ArgumentParser("check-node") + parser.add_argument("node_pb", type=argparse.FileType("rb")) + args = parser.parse_args() + + node = NodeProto() + node.ParseFromString(args.node_pb.read()) + checker.check_node(node) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.cc b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.cc new file mode 100644 index 0000000000000000000000000000000000000000..e5c7c595ca4fe27fa4b3ca5949b3667790386a25 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.cc @@ -0,0 +1,1522 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +#include "onnx/checker.h" + +#include +#include +#include // NOLINT(build/c++17) +#include +#include +#include +#include +#include + +#include "onnx/common/file_utils.h" +#include "onnx/common/path.h" +#include "onnx/common/proto_util.h" +#include "onnx/common/safe_math.h" +#include "onnx/common/scoped_resource.h" +#include "onnx/defs/tensor_proto_util.h" +#include "onnx/shape_inference/implementation.h" + +#ifdef _WIN32 +#include +#include +#include +#else +#include +#include +#include + +// Kernel-level path containment: prefer openat2 (Linux 5.6+) or +// O_RESOLVE_BENEATH (FreeBSD 13+, macOS 15+) when available. +#ifdef __linux__ +#include +#ifdef SYS_openat2 +#define ONNX_HAS_OPENAT2 +#if __has_include() +#include +#else +struct open_how { + uint64_t flags; + uint64_t mode; + uint64_t resolve; +}; +#define RESOLVE_NO_SYMLINKS 0x04 +#define RESOLVE_BENEATH 0x08 +#endif +#endif // SYS_openat2 +#endif // __linux__ + +#ifdef O_RESOLVE_BENEATH +#define ONNX_HAS_RESOLVE_BENEATH +#endif + +#endif // _WIN32 + +namespace ONNX_NAMESPACE { +namespace checker { + +#define enforce_has_field(proto, field) \ + do { \ + if (!proto.has_##field()) { \ + fail_check("Field '", #field, "' of '", #proto, "' is required but missing."); \ + } \ + } while (0) + +#define enforce_non_empty_field(proto, field) \ + do { \ + if (proto.field().empty()) { \ + fail_check("Field '", #field, "' of '", #proto, "' is required to be non-empty."); \ + } \ + } while (0) + +void check_value_info(const ValueInfoProto& value_info, const CheckerContext& ctx) { + enforce_non_empty_field(value_info, name); + // Relax constraint for subgraph input/output. + if (!ctx.is_main_graph()) + return; + enforce_has_field(value_info, type); + const auto value_case = value_info.type().value_case(); + switch (value_case) { + case TypeProto::kTensorType: { + const auto& type = value_info.type().tensor_type(); + enforce_has_field(type, elem_type); + enforce_has_field(type, shape); + } break; + case TypeProto::kOptionalType: { + const auto& type = value_info.type().optional_type(); + enforce_has_field(type, elem_type); + } break; + case TypeProto::kSequenceType: { + const auto& type = value_info.type().sequence_type(); + enforce_has_field(type, elem_type); + } break; + case TypeProto::kMapType: { + const auto& type = value_info.type().map_type(); + enforce_has_field(type, key_type); + enforce_has_field(type, value_type); + } break; +#ifdef ONNX_ML + case TypeProto::kOpaqueType: + break; +#endif + case TypeProto::kSparseTensorType: { + const auto& type = value_info.type().sparse_tensor_type(); + enforce_has_field(type, elem_type); + enforce_has_field(type, shape); + } break; + + default: + fail_check("Unrecognized type value case (value_info name: ", value_info.name(), "): ", value_case); + } +} + +void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) { + enforce_has_field(tensor, data_type); + if (tensor.data_type() == TensorProto::UNDEFINED) { + fail_check("setting data_type field (tensor name: ", tensor.name(), ") to UNDEFINED is not allowed"); + } + + int num_value_fields = 0; + + const char* value_field = nullptr; + +#define check_data_field(field) \ + bool has_##field = !tensor.field().empty(); \ + if (has_##field) { \ + ++num_value_fields; \ + value_field = #field; \ + } + + check_data_field(float_data); + check_data_field(int32_data); + check_data_field(string_data); + check_data_field(int64_data); + check_data_field(raw_data); + check_data_field(double_data); + check_data_field(uint64_data); + +#undef check_data_field + + bool stored_externally = tensor.has_data_location() && tensor.data_location() == TensorProto::EXTERNAL; + if (stored_externally) { + if (num_value_fields != 0) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor.name(), + ") is stored externally and should not have data field.", + value_field); + } + + bool has_location = false; + for (const StringStringEntryProto& entry : tensor.external_data()) { + if (entry.has_key() && entry.has_value() && entry.key() == "location") { + has_location = true; + resolve_external_data_location(ctx.get_model_dir(), entry.value(), tensor.name()); + } + } + if (!has_location) { + fail_check("TensorProto ( tensor name: ", tensor.name(), ") is stored externally but doesn't have a location."); + } + return; + } + int64_t nelem = + safe_dim_product(tensor.dims(), [&](const char* msg) { fail_check(msg, " (tensor name: ", tensor.name(), ")"); }); + if (nelem == 0 && num_value_fields != 0) { + fail_check("TensorProto (tensor name: ", tensor.name(), ") is 0-element but contains data!"); + } + if (nelem != 0 && num_value_fields != 1) { + fail_check("TensorProto (tensor name: ", tensor.name(), ") should contain one and only one value field."); + } + if (has_raw_data) { + if (tensor.data_type() == TensorProto::STRING) { + fail_check("STRING data (tensor name: ", tensor.name(), ") should not be stored in raw_data field"); + } + // Validate that raw_data is large enough for the declared packed sub-byte type and shape. + int64_t expected_bytes = 0; + switch (tensor.data_type()) { + case TensorProto::UINT4: + case TensorProto::INT4: + case TensorProto::FLOAT4E2M1: + expected_bytes = (nelem + 1) / 2; // 2 elements per byte, ceiling division + break; + case TensorProto::UINT2: + case TensorProto::INT2: + expected_bytes = (nelem + 3) / 4; // 4 elements per byte, ceiling division + break; + default: + break; + } + if (expected_bytes > 0 && static_cast(tensor.raw_data().size()) < expected_bytes) { + fail_check( + "TensorProto (tensor name: ", + tensor.name(), + ") raw_data size (", + tensor.raw_data().size(), + " bytes) is too small for the declared shape and packed type (", + expected_bytes, + " bytes required)."); + } + return; + } else { +#define check_field(field) \ + if (nelem != 0 && !has_##field) { \ + fail_check( \ + "values of data_type '", \ + tensor.data_type(), \ + "' should be stored in field '", \ + #field, \ + "' instead of '", \ + value_field, \ + "'"); \ + } + + switch (tensor.data_type()) { + case TensorProto::FLOAT: + case TensorProto::COMPLEX64: + check_field(float_data); + break; + + case TensorProto::DOUBLE: + case TensorProto::COMPLEX128: + check_field(double_data); + break; + + case TensorProto::INT32: + case TensorProto::UINT8: + case TensorProto::INT8: + case TensorProto::UINT16: + case TensorProto::INT16: + case TensorProto::BOOL: + case TensorProto::FLOAT16: + case TensorProto::BFLOAT16: + case TensorProto::FLOAT8E4M3FN: + case TensorProto::FLOAT8E4M3FNUZ: + case TensorProto::FLOAT8E5M2: + case TensorProto::FLOAT8E5M2FNUZ: + case TensorProto::FLOAT8E8M0: + case TensorProto::UINT4: + case TensorProto::INT4: + case TensorProto::FLOAT4E2M1: + check_field(int32_data); + if (nelem > 0) { + // Each int32 stores 4 bytes = 8 4-bit elements. + const int64_t expected_int32s = (nelem + 7) / 8; + if (static_cast(tensor.int32_data().size()) < expected_int32s) { + fail_check( + "TensorProto (tensor name: ", + tensor.name(), + ") int32_data size (", + tensor.int32_data().size(), + ") is too small for the declared shape and packed type (", + expected_int32s, + " int32 values required)."); + } + } + break; + case TensorProto::UINT2: + case TensorProto::INT2: + check_field(int32_data); + if (nelem > 0) { + // Each int32 stores 4 bytes = 16 2-bit elements. + const int64_t expected_int32s = (nelem + 15) / 16; + if (static_cast(tensor.int32_data().size()) < expected_int32s) { + fail_check( + "TensorProto (tensor name: ", + tensor.name(), + ") int32_data size (", + tensor.int32_data().size(), + ") is too small for the declared shape and packed type (", + expected_int32s, + " int32 values required)."); + } + } + break; + + case TensorProto::INT64: + check_field(int64_data); + break; + + case TensorProto::UINT32: + case TensorProto::UINT64: + check_field(uint64_data); + break; + + case TensorProto::STRING: + check_field(string_data); + break; + + default: + fail_check("Unrecognized data_type (tensor name: ", tensor.name(), "): ", tensor.data_type()); + } + } + +#undef check_field +} + +void check_sequence(const SequenceProto& sequence, const CheckerContext& ctx) { + enforce_has_field(sequence, elem_type); + if (sequence.elem_type() == SequenceProto::TENSOR) { + for (const TensorProto& tensor : sequence.tensor_values()) { + check_tensor(tensor, ctx); + } + } else if (sequence.elem_type() == SequenceProto::SPARSE_TENSOR) { + for (const SparseTensorProto& sparse_tensor : sequence.sparse_tensor_values()) { + check_sparse_tensor(sparse_tensor, ctx); + } + } else if (sequence.elem_type() == SequenceProto::SEQUENCE) { + for (const SequenceProto& seq : sequence.sequence_values()) { + check_sequence(seq, ctx); + } + } else if (sequence.elem_type() == SequenceProto::MAP) { + for (const MapProto& map : sequence.map_values()) { + check_map(map, ctx); + } + } else { + fail_check( + "Sequence ( Structure name: ", + sequence.name(), + ", elem_type: ", + sequence.elem_type(), + ") is not have a valid element type."); + } +} + +void check_optional(const OptionalProto& optional, const CheckerContext& ctx) { + enforce_has_field(optional, elem_type); + if (optional.elem_type() == OptionalProto::UNDEFINED) { + return; + } else if (optional.elem_type() == OptionalProto::TENSOR) { + if (optional.has_tensor_value()) + check_tensor(optional.tensor_value(), ctx); + } else if (optional.elem_type() == OptionalProto::SPARSE_TENSOR) { + if (optional.has_sparse_tensor_value()) + check_sparse_tensor(optional.sparse_tensor_value(), ctx); + } else if (optional.elem_type() == OptionalProto::SEQUENCE) { + if (optional.has_sequence_value()) + check_sequence(optional.sequence_value(), ctx); + } else if (optional.elem_type() == OptionalProto::MAP) { + if (optional.has_map_value()) + check_map(optional.map_value(), ctx); + } else { + fail_check( + "Optional ( Structure name: ", + optional.name(), + ", elem_type: ", + optional.elem_type(), + ") is not have a valid element type."); + } +} + +void check_map(const MapProto& map, const CheckerContext& ctx) { + enforce_has_field(map, key_type); + if (map.key_type() == TensorProto::UNDEFINED) { + fail_check("setting key_type field (map name: ", map.name(), ") to UNDEFINED is not allowed"); + } + // Check if key is a valid type, specifically INT8, INT16, INT32, INT64, + // UINT8, UINT16, UINT32, UINT64, or STRING. + if ((map.key_type() == TensorProto::FLOAT) || (map.key_type() == TensorProto::BOOL) || + (map.key_type() == TensorProto::FLOAT16) || (map.key_type() == TensorProto::COMPLEX64) || + (map.key_type() == TensorProto::COMPLEX128)) { + fail_check( + "setting key_type field (map name: ", + map.name(), + ") to invalid TensorProto key_type ", + map.key_type(), + " is not allowed"); + } + + // MapProto will use either keys or string_keys, so only one should be > 0. + if ((map.keys_size() > 0) && (map.string_keys_size() > 0)) { + fail_check("Map (name: ", map.name(), ") should not contain more than one keys field."); + } + + int num_keys = map.keys_size() + map.string_keys_size(); + int num_values = 0; + + enforce_has_field(map, values); + check_sequence(map.values(), ctx); + + if (map.values().elem_type() == SequenceProto::TENSOR) { + num_values = map.values().tensor_values_size(); + } else if (map.values().elem_type() == SequenceProto::SPARSE_TENSOR) { + num_values = map.values().sparse_tensor_values_size(); + } else if (map.values().elem_type() == SequenceProto::SEQUENCE) { + num_values = map.values().sequence_values_size(); + } else if (map.values().elem_type() == SequenceProto::MAP) { + num_values = map.values().map_values_size(); + } + + if (num_keys != num_values) { + fail_check("Length of map keys and map values are not the same (map name: ", map.name(), ")"); + } +} + +// Check that the index data stored in a SparseTensorProto is valid. +// indices: a 1-dimensional tensor; indices[i] represents the +// linearized index value for the i-th nonzero value. +static void +check_sparse_tensor_indices_1(const TensorProto& indices, const SparseTensorProto& sparse_tensor_proto, size_t nnz) { + int dense_rank = sparse_tensor_proto.dims_size(); + int64_t dense_size = 1; + for (int i = 0; i < dense_rank; ++i) + dense_size *= sparse_tensor_proto.dims(i); + if (static_cast(indices.dims(0)) != nnz) { + fail_check("Sparse tensor indices (", indices.name(), ") has ", indices.dims(0), " values, but NNZ is ", nnz); + } + + // Check if indices appear in ascending order, and if they have valid + // values. The i-th value in index_data is the linear index of the i-th + // non-zero value. + const std::vector index_data = ParseData(&indices); + + int64_t prev_index = -1; + for (size_t i = 0; i < nnz; ++i) { + int64_t curr_index = index_data[i]; // linearized index of i-th value + if (curr_index < 0 || curr_index >= dense_size) { + fail_check( + "Sparse tensor (", + indices.name(), + ") index value at position [", + i, + "] out of range [0, ", + dense_size - 1, + "]"); + } + if (curr_index <= prev_index) { + fail_check("Sparse tensor (", indices.name(), ") index value at position [", i, "] not in sorted order."); + } + prev_index = curr_index; + } +} + +// Check that the index data stored in a SparseTensorProto is valid. +// indices: a 2-dimensional tensor; indices[i,j] represents the j-th +// index value for the i-th nonzero value. +static void +check_sparse_tensor_indices_2(const TensorProto& indices, const SparseTensorProto& sparse_tensor_proto, size_t nnz) { + int dense_rank = sparse_tensor_proto.dims_size(); + if (static_cast(indices.dims(0)) != nnz) { + fail_check("Sparse tensor indices (", indices.name(), ") first dimension size does not equal NNZ."); + } + if (indices.dims(1) != dense_rank) { + fail_check("Sparse tensor indices (", indices.name(), ") second dimension size does not match rank of tensor."); + } + + // Check if indices appear in ascending order, and if they have valid + // values. + const std::vector index_data = ParseData(&indices); + int64_t prev_index = -1; + for (size_t i = 0; i < nnz; ++i) { + int64_t curr_index = 0; // linearized index of i-th value + for (int j = 0; j < dense_rank; ++j) { + auto index_ij = index_data[i * dense_rank + j]; + if ((index_ij < 0) || (index_ij >= sparse_tensor_proto.dims(j))) { + fail_check("Sparse tensor (", indices.name(), ") index value at position [", i, ",", j, "] out of range."); + } + curr_index = curr_index * sparse_tensor_proto.dims(j) + index_ij; + } + if (curr_index <= prev_index) { + fail_check( + "Sparse tensor (", indices.name(), ") index value at position [", i, "] not in lexicographic sorted order."); + } + prev_index = curr_index; + } +} + +void check_sparse_tensor(const SparseTensorProto& sparse_tensor_proto, const CheckerContext& ctx) { + enforce_has_field(sparse_tensor_proto, values); + + const TensorProto& values = sparse_tensor_proto.values(); + check_tensor(values, ctx); + + // values must be a tensor of shape [NNZ] + // Currently we restrict the value associated with a particular index-tuple + // to be a single value. In the future, if there is a requirement, + // we may extend this to permit the value to be a "sub-tensor", in which + // case values will have dimension > 1. + if (values.dims_size() != 1) { + fail_check("Sparse tensor values (", values.name(), ") must have rank 1."); + } + size_t nnz = static_cast(values.dims(0)); + int dense_rank = sparse_tensor_proto.dims_size(); + if (dense_rank == 0) { + fail_check("Sparse tensor (", values.name(), ") must have a dense-rank > 0"); + } + for (int i = 0; i < dense_rank; ++i) { + if (sparse_tensor_proto.dims(i) <= 0) { + fail_check("Sparse tensor (", values.name(), ") dimensions are not positive."); + } + } + + if (sparse_tensor_proto.has_indices()) { + const TensorProto& indices = sparse_tensor_proto.indices(); + check_tensor(indices, ctx); + if (indices.data_type() != TensorProto::INT64) { + fail_check("Sparse tensor indices (", indices.name(), ") must have INT64 type."); + } + switch (indices.dims().size()) { + case 1: + // Indices in linearized format + check_sparse_tensor_indices_1(indices, sparse_tensor_proto, nnz); + return; + case 2: + // Check COO-style index. E.g., an index for a 3D tensor is a 3-tuple. + check_sparse_tensor_indices_2(indices, sparse_tensor_proto, nnz); + return; + default: + fail_check("Sparse tensor indices (", indices.name(), ") must have rank 1 or 2."); + } + } else if (nnz != 0) { + fail_check("Sparse tensor (", values.name(), ") has no index values."); + } +} + +// NB: This is a generic "attribute well-formedness" check, it doesn't +// actually test if an attribute is valid per a schema +void check_attribute(const AttributeProto& attr, const CheckerContext& ctx, const LexicalScopeContext& lex_ctx) { + enforce_non_empty_field(attr, name); + + if (ctx.get_ir_version() >= 0x00000002) { + enforce_has_field(attr, type); + } + + int used_fields = 0; + +#define check_type(expected_type) \ + if (attr.has_type() && attr.type() != expected_type) { \ + fail_check("type field and data field mismatch in attribute ", attr.name(), "."); \ + } + +#define check_singular_field(field, type) \ + if (attr.has_##field()) { \ + ++used_fields; \ + check_type(type); \ + } + +#define check_repeated_field(field, type) \ + if (attr.field##_size() > 0) { \ + ++used_fields; \ + check_type(type); \ + } + + check_singular_field(f, AttributeProto::FLOAT); + check_singular_field(i, AttributeProto::INT); + check_singular_field(s, AttributeProto::STRING); + check_singular_field(t, AttributeProto::TENSOR); + check_singular_field(g, AttributeProto::GRAPH); + check_singular_field(tp, AttributeProto::TYPE_PROTO); + check_singular_field(sparse_tensor, AttributeProto::SPARSE_TENSOR); + check_repeated_field(floats, AttributeProto::FLOATS); + check_repeated_field(ints, AttributeProto::INTS); + check_repeated_field(strings, AttributeProto::STRINGS); + check_repeated_field(tensors, AttributeProto::TENSORS); + check_repeated_field(graphs, AttributeProto::GRAPHS); + check_repeated_field(sparse_tensors, AttributeProto::SPARSE_TENSORS); + check_repeated_field(type_protos, AttributeProto::TYPE_PROTOS); + +#undef check_type +#undef check_singular_field +#undef check_repeated_field + + // Normally, used_fields is expected to be 1. + // In proto3, when the value to be set is type default value (say 0 for + // int), used_fields may be 0. + if (used_fields > 1) { + fail_check("Attribute (name: ", attr.name(), ") should not contain more than one value field."); + } + + if (!ctx.is_main_graph()) { + // It's an attribute of a node in function body. + if (attr.has_ref_attr_name() && used_fields != 0) { + // The attribute proto is supposed to refer to data outside and does not + // have its own value field set. + fail_check("Attribute (name: ", attr.name(), ") should refer to attribute in parent node."); + } + } + + if (attr.has_t()) { + check_tensor(attr.t(), ctx); + } + + if (attr.has_sparse_tensor()) { + check_sparse_tensor(attr.sparse_tensor(), ctx); + } + + if (attr.has_g()) { + CheckerContext subgraph_ctx(ctx); + subgraph_ctx.set_is_main_graph(false); + check_graph(attr.g(), subgraph_ctx, lex_ctx); + } + + for (const auto& tensor : attr.tensors()) { + check_tensor(tensor, ctx); + } + for (const auto& sparse_tensor : attr.sparse_tensors()) { + check_sparse_tensor(sparse_tensor, ctx); + } + if (!attr.graphs().empty()) { + CheckerContext subgraph_ctx(ctx); + subgraph_ctx.set_is_main_graph(false); + for (const auto& graph : attr.graphs()) { + check_graph(graph, subgraph_ctx, lex_ctx); + } + } +} + +static void print_warning_if_has_experimental(const std::unordered_set& used_experimental_ops) { + if (!used_experimental_ops.empty()) { + std::string all_experimental_ops; + for (const auto& op : used_experimental_ops) { + all_experimental_ops += " " + op + ","; + } + // Remove the last comma which is unnecessary + all_experimental_ops.pop_back(); + std::cout << "Warning: Model contains experimental ops:" + all_experimental_ops << '\n'; + } +} + +void check_node(const NodeProto& node, const CheckerContext& ctx, const LexicalScopeContext& lex_ctx) { + enforce_non_empty_field(node, op_type); + + if (node.input().empty() && node.output().empty()) { + fail_check("NodeProto (name: ", node.name(), ", type: ", node.op_type(), ") has zero input and zero output."); + } + + // Resolve domain for node + const auto& opset_imports = ctx.get_opset_imports(); + auto dit = opset_imports.find(node.domain()); + if (dit == opset_imports.end()) { + fail_check("No opset import for domain '" + node.domain() + "'"); + } + auto domain_version = dit->second; + + // for ops referencing local functions, there is no schema to verify it. + // will add a check to verify consistency between these ops and local functions. + std::unordered_set seen_attr_names{}; + for (const auto& attr : node.attribute()) { + if (!seen_attr_names.insert(attr.name()).second) { + fail_check("Attribute '", attr.name(), "' appeared multiple times."); + } + + check_attribute(attr, ctx, lex_ctx); + } + + // This issue will be caught by check_graph instead + if (check_is_experimental_op(node)) { + return; + } + + const auto* const schema = ctx.get_schema_registry()->GetSchema(node.op_type(), domain_version, node.domain()); + if (!schema) { + if (node.domain() == ONNX_DOMAIN || node.domain() == AI_ONNX_ML_DOMAIN || node.domain() == "ai.onnx" || + node.domain() == AI_ONNX_TRAINING_DOMAIN || ctx.check_custom_domain()) { + // fail the checker if op is in built-in domains or if it has no schema when `check_custom_domain` is true + fail_check( + "No Op registered for " + node.op_type() + " with domain_version of " + + ONNX_NAMESPACE::to_string(domain_version)); + } + } else if (schema->Deprecated()) { + fail_check( + "Op registered for " + node.op_type() + " is deprecated in domain_version of " + + ONNX_NAMESPACE::to_string(domain_version)); + } else { + schema->Verify(node); + } +} + +void check_graph(const GraphProto& graph, const CheckerContext& ctx, const LexicalScopeContext& parent_lex) { + enforce_non_empty_field(graph, name); + + for (const auto& value_info : graph.input()) { + check_value_info(value_info, ctx); + } + for (const auto& value_info : graph.output()) { + check_value_info(value_info, ctx); + } + + // Inherit values available in outer scope + // Note that we do not allow shadowing, so the presence of an already-defined + // name is always an error. + LexicalScopeContext lex_ctx{parent_lex}; + + for (const auto& value_info : graph.input()) { + // TODO(ONNX): If shadowing isn't allowed, this should maybe use + // this_or_ancestor_graph_has + if (lex_ctx.this_graph_has(value_info.name())) { + fail_check( + "Graph must be in single static assignment (SSA) form, however '", + value_info.name(), + "' has been used as graph input names multiple times."); + } + lex_ctx.add(value_info.name()); + } + + std::unordered_set initializer_name_checker; + + for (const auto& init : graph.initializer()) { + enforce_has_field(init, name); + const auto& name = init.name(); + if (name.empty()) { + fail_check("Tensor initializers must have a non-empty name"); + } + + if (!initializer_name_checker.emplace(name).second) { + fail_check(name + " initializer name is not unique"); + } + + check_tensor(init, ctx); + + if (ctx.get_ir_version() <= 0x00000003) { + // Initializers are a subset of graph inputs for IR_VERSION <= 3 + if (!lex_ctx.this_graph_has(name)) { + fail_check(name + " in initializer but not in graph input"); + } + } else { + // An initializer is allowed to have the same name as an input, + // but is not required to (for IR_VERSION >= 4) + lex_ctx.add(name); + } + } + + for (const auto& sparse_init : graph.sparse_initializer()) { + const auto& values = sparse_init.values(); + enforce_has_field(values, name); + const auto& name = values.name(); + if (name.empty()) { + fail_check("Sparse tensor initializers must have a non-empty name"); + } + if (!initializer_name_checker.insert(name).second) { + fail_check(name + " sparse initializer name is not unique across initializers and sparse_initializers"); + } + check_sparse_tensor(sparse_init, ctx); + lex_ctx.add(name); + } + std::unordered_set used_experimental_ops; + for (const auto& node : graph.node()) { + // nodes must be in topologically sorted order + for (const auto& input : node.input()) { + // explicit optional input + if (input.empty()) { + continue; + } + if (!lex_ctx.this_or_ancestor_graph_has(input)) { + fail_check( + "Nodes in a graph must be topologically sorted, however input '", + input, + "' of node: \n", + "name: ", + node.name(), + " OpType: ", + node.op_type(), + "\n is not output of any previous nodes."); + } + } + + if (check_is_experimental_op(node)) { + used_experimental_ops.insert(node.op_type()); + } + + // This needs to happen before SSA check since we don't want to recurse and + // find that outputs from control flow ops are colliding with names in the + // inner block + + ONNX_TRY { + check_node(node, ctx, lex_ctx); + } + ONNX_CATCH(ValidationError & ex) { + ONNX_HANDLE_EXCEPTION([&]() { + ex.AppendContext("Bad node spec for node. Name: " + node.name() + " OpType: " + node.op_type()); + // Rethrow without copying to avoid triggering + // bugprone-exception-copy-constructor-throws. + // The in-place AppendContext modification is preserved because + // `ex` is a reference to the active exception object. + throw; + }); + } + // check for SSA form + for (const auto& output : node.output()) { + // optional output + if (output.empty()) { + continue; + } + + if (lex_ctx.this_or_ancestor_graph_has(output)) { + fail_check( + "Graph must be in single static assignment (SSA) form, however '", + output, + "' has been used as output names multiple times."); + } + lex_ctx.add(output); + } + } + for (const auto& value_info : graph.output()) { + if (!lex_ctx.this_graph_has(value_info.name())) { + fail_check("Graph output '", value_info.name(), "' is not an output of any node in graph."); + } + } + + print_warning_if_has_experimental(used_experimental_ops); +} + +// Utilify function to get the imported version of domain from opset imports +// Returns -1 if requested domain is not found in the opset_imports +static int get_version_for_domain( + const std::string& domain, + const std::unordered_map& opset_imports) { + auto it = opset_imports.find(domain); + if (it == opset_imports.end()) { + return -1; + } + + return it->second; +} + +void check_opset_compatibility( + const NodeProto& node, + const CheckerContext& ctx, + const std::unordered_map& func_opset_imports, + const std::unordered_map& model_opset_imports) { + auto func_opset_version = get_version_for_domain(node.domain(), func_opset_imports); + auto model_opset_version = get_version_for_domain(node.domain(), model_opset_imports); + + if (func_opset_version == -1) { + fail_check("No Opset registered for domain " + node.domain()); + } + + if (model_opset_version == -1) { + // model does not include opset import for a node present in function body. + // This is ok as along as the opset import is present in function level opset imports. + return; + } + + if (func_opset_version == model_opset_version) { + // both versions are same, no need to verify schema. + return; + } + + const auto* const schema_for_model_import = + ctx.get_schema_registry()->GetSchema(node.op_type(), model_opset_version, node.domain()); + + const auto* const schema_for_function_import = + ctx.get_schema_registry()->GetSchema(node.op_type(), func_opset_version, node.domain()); + + if (!schema_for_model_import && !schema_for_function_import) { + // the op belongs to a custom domain so we cannot verify schema + return; + } + + // if schema is present for 1 but not other or the schema since versions do not match then raise an error + if (!schema_for_model_import || !schema_for_function_import || + schema_for_function_import->since_version() != schema_for_model_import->since_version()) { + fail_check( + "Opset import for domain " + node.domain() + " in function op " + node.op_type() + + "is not compatible with the version imported by model. FunctionOp imports version " + + ONNX_NAMESPACE::to_string(func_opset_version) + " whereas model imports version " + + ONNX_NAMESPACE::to_string(model_opset_version)); + } +} + +namespace { + +using FuncPtr = const FunctionProto*; +using CallGraph = std::unordered_map>; + +// Limits to reject obviously malicious models early. +constexpr int kMaxModelLocalFunctions = 10000; +constexpr size_t kMaxFunctionCallDepth = 100; + +enum class VisitState : uint8_t { Unvisited, InPath, Done }; + +// Iterative DFS to detect cycles in the function call graph. +// Uses an explicit stack to avoid stack overflow on deeply-chained models. +void DetectCycleDFS( + FuncPtr root, + const CallGraph& call_graph, + std::unordered_map& state, + std::vector& path) { + // Each frame tracks the current function and an iterator into its callees. + using Iter = std::unordered_set::const_iterator; + struct Frame { + FuncPtr func; + Iter cur; + Iter end; + }; + std::vector stack; + + auto push = [&](FuncPtr func) { + state[func] = VisitState::InPath; + path.push_back(func); + if (path.size() > kMaxFunctionCallDepth) { + fail_check( + "Function call chain depth exceeds limit (", + kMaxFunctionCallDepth, + "). The model may be malformed or malicious."); + } + auto it = call_graph.find(func); + if (it != call_graph.end()) { + stack.push_back({func, it->second.begin(), it->second.end()}); + } else { + stack.push_back({func, {}, {}}); + } + }; + + push(root); + + while (!stack.empty()) { + auto& frame = stack.back(); + + if (frame.cur == frame.end) { + // All callees processed — backtrack. + path.pop_back(); + state[frame.func] = VisitState::Done; + stack.pop_back(); + continue; + } + + FuncPtr callee = *frame.cur; + ++frame.cur; + + auto s = state[callee]; + if (s == VisitState::InPath) { + auto start = std::find(path.begin(), path.end(), callee); + std::string cycle; + for (auto cit = start; cit != path.end(); ++cit) + cycle += (cit == start ? "" : " -> ") + GetFunctionImplId(**cit); + fail_check( + "Cycle detected in model-local function references: ", + cycle, + " -> ", + GetFunctionImplId(*callee), + ". Self-referencing or cyclically-referencing functions would cause infinite recursion."); + } else if (s == VisitState::Unvisited) { + push(callee); + } + } +} + +} // namespace + +void check_function_call_cycles(const ModelProto& model) { + if (model.functions_size() > kMaxModelLocalFunctions) { + fail_check( + "Model contains ", + model.functions_size(), + " local functions, exceeding the limit of ", + kMaxModelLocalFunctions, + ". The model may be malformed or malicious."); + } + + // Build function map: callee key -> FunctionProto pointer. + // Duplicate keys could mask cycles, so reject them here. + std::unordered_map func_by_key; + for (const auto& f : model.functions()) { + const auto function_impl_id = GetFunctionImplId(f); + const bool inserted = func_by_key.emplace(function_impl_id, &f).second; + if (!inserted) { + fail_check("Model contains multiple local functions with the same implementation id '", function_impl_id, "'."); + } + } + + // Build adjacency list using pointers directly + CallGraph call_graph; + for (const auto& entry : func_by_key) { + const auto* func = entry.second; + auto& callees = call_graph[func]; + for (const auto& node : func->node()) { + auto it = func_by_key.find(GetCalleeId(node)); + if (it != func_by_key.end()) { + callees.insert(it->second); + } + } + } + + std::unordered_map state; + std::vector path; + for (const auto& entry : func_by_key) { + if (state[entry.second] == VisitState::Unvisited) { + DetectCycleDFS(entry.second, call_graph, state, path); + } + } +} + +void check_model_local_functions( + const ModelProto& model, + const CheckerContext& ctx, + const LexicalScopeContext& parent_lex) { + // make a copy of model opset imports to maintain a main copy of opset imports across the model and + // all model local functions to verify opset compatibility + std::unordered_map model_opset_imports(ctx.get_opset_imports()); + + // merge the opset imports from every function in model_opset_imports + // only add the opset import if an entry for it does not exist in model_opset_imports + // if there is an entry then the compatibility will be checked later on in check_opset_compatibility + // called by check_function. + for (const auto& function_proto : model.functions()) { + for (const auto& opset_import : function_proto.opset_import()) { + if (get_version_for_domain(opset_import.domain(), model_opset_imports) == -1) { + model_opset_imports[opset_import.domain()] = opset_import.version(); + } + } + } + + check_function_call_cycles(model); + + CheckerContext ctx_copy = ctx; + ctx_copy.set_opset_imports(model_opset_imports); + + for (const auto& function_proto : model.functions()) { + check_function(function_proto, ctx_copy, parent_lex); + } +} + +void check_function(const FunctionProto& function, const CheckerContext& ctx, const LexicalScopeContext& parent_lex) { + enforce_non_empty_field(function, name); + + if (ctx.get_ir_version() >= 0x00000008) { + enforce_has_field(function, domain); + } + + const auto& model_opset_imports = ctx.get_opset_imports(); + CheckerContext ctx_copy = ctx; + + std::unordered_map func_opset_imports; + for (const auto& relied_opset : function.opset_import()) { + func_opset_imports[relied_opset.domain()] = static_cast(relied_opset.version()); + } + + ctx_copy.set_opset_imports(func_opset_imports); + + LexicalScopeContext lex_ctx{parent_lex}; + + for (const auto& input : function.input()) { + // TODO(ONNX): If shadowing isn't allowed, this should maybe use + // this_or_ancestor_graph_has + if (lex_ctx.this_graph_has(input)) { + fail_check( + "Graph must be in single static assignment (SSA) form, however '", input, "' has been used multiple times."); + } + lex_ctx.add(input); + } + + std::unordered_set outputs; + for (const auto& output : function.output()) { + if (!outputs.insert(output).second) { + fail_check("function (", function.name(), ") should not have duplicate outputs specified."); + } + } + + std::unordered_set attrs; + for (const auto& attr : function.attribute()) { + if (!attrs.insert(attr).second) { + fail_check("function (", function.name(), ") should not have duplicate attributes specified."); + } + } + std::unordered_set used_experimental_ops; + for (const auto& node : function.node()) { + // nodes must be in topologically sorted order + for (const auto& input : node.input()) { + // explicit optional input + if (input.empty()) { + continue; + } + if (!lex_ctx.this_graph_has(input)) { + fail_check( + "Nodes in a function must be topologically sorted, however input '", + input, + "' of node: \n", + "Name: ", + node.name(), + " OpType: ", + node.op_type(), + "\n is neither output of any previous nodes nor input of the function."); + } + } + + // check whether the opset version imported for a domain by function and model are + // compatible + if (!ctx_copy.skip_opset_compatibility_check()) + check_opset_compatibility(node, ctx_copy, func_opset_imports, model_opset_imports); + if (check_is_experimental_op(node)) { + used_experimental_ops.insert(node.op_type()); + } + check_node(node, ctx_copy, lex_ctx); + + // check for SSA form + for (const auto& output : node.output()) { + // optional output + if (output.empty()) { + continue; + } + if (lex_ctx.this_or_ancestor_graph_has(output)) { + fail_check( + "Function must be in single static assignment (SSA) form, however '", + output, + "' has been used as output names multiple times."); + } + lex_ctx.add(output); + } + } + print_warning_if_has_experimental(used_experimental_ops); +} + +static void check_model(const ModelProto& model, CheckerContext& ctx) { + if (!model.ir_version()) { + fail_check("The model does not have an ir_version set properly."); + } + if (model.ir_version() > IR_VERSION) { + fail_check("Your model ir_version ", model.ir_version(), " is higher than the checker's (", IR_VERSION, ")."); + } + if (model.metadata_props_size() > 1) { + std::unordered_set keys; + for (const StringStringEntryProto& entry : model.metadata_props()) { + auto i = keys.insert(entry.key()); + if (!i.second) { + fail_check("Your model has duplicate keys in metadata_props."); + } + } + } + ctx.set_ir_version(static_cast(model.ir_version())); + std::unordered_map opset_imports; + for (const auto& opset_import : model.opset_import()) { + opset_imports[opset_import.domain()] = static_cast(opset_import.version()); + } + if (model.ir_version() >= 3) { + if (opset_imports.empty()) { + fail_check("model with IR version >= 3 must specify opset_import for ONNX"); + } + } else { + if (opset_imports.empty()) { + opset_imports[ONNX_DOMAIN] = 1; + } else { + fail_check("model with IR version < 3 cannot have opset_import specified"); + } + } + ctx.set_opset_imports(opset_imports); + LexicalScopeContext lex_ctx; + check_graph(model.graph(), ctx, lex_ctx); + + if (ctx.get_ir_version() >= 0x00000008) { + check_model_local_functions(model, ctx, lex_ctx); + // TODO(ONNX): check consistency between local functions and ops referencing it. + } +} + +void check_model( + const std::string& model_path, + bool full_check, + bool skip_opset_compatibility_check, + bool check_custom_domain) { + ModelProto model; + LoadProtoFromPath(model_path, model); + + CheckerContext ctx; + std::string model_dir; + size_t pos = model_path.find_last_of("\\/"); + if (pos != std::string::npos) { + model_dir = model_path.substr(0, pos + 1); + } + ctx.set_model_dir(model_dir); + ctx.set_skip_opset_compatibility_check(skip_opset_compatibility_check); + ctx.set_check_custom_domain(check_custom_domain); + check_model(model, ctx); + + if (full_check) { + ShapeInferenceOptions options{true, 1, false}; + ONNX_NAMESPACE::shape_inference::InferShapes(model, ctx.get_schema_registry(), options); + } +} + +void check_model( + const ModelProto& model, + bool full_check, + bool skip_opset_compatibility_check, + bool check_custom_domain) { + CheckerContext ctx; + ctx.set_skip_opset_compatibility_check(skip_opset_compatibility_check); + ctx.set_check_custom_domain(check_custom_domain); + check_model(model, ctx); + if (full_check) { + ShapeInferenceOptions options{true, 1, false}; + // Do not update the model in place by the check from shape inference + // because checker should not modify the original model + ModelProto copy = model; + ONNX_NAMESPACE::shape_inference::InferShapes(copy, ctx.get_schema_registry(), options); + } +} + +using ONNX_NAMESPACE::ScopedFd; +using ONNX_NAMESPACE::utf8_to_path; +#ifdef _WIN32 +using ONNX_NAMESPACE::ScopedHandle; +#endif + +#ifdef _WIN32 +// Compare two BY_HANDLE_FILE_INFORMATION structs by volume + file index (inode equivalent). +static bool same_file(const BY_HANDLE_FILE_INFORMATION& a, const BY_HANDLE_FILE_INFORMATION& b) { + return a.dwVolumeSerialNumber == b.dwVolumeSerialNumber && a.nFileIndexHigh == b.nFileIndexHigh && + a.nFileIndexLow == b.nFileIndexLow; +} +#endif + +// Canonicalize data_path, verify containment within base_dir. +static std::filesystem::path verify_path_containment( + const std::filesystem::path& data_path, + const std::string& base_dir, + const std::string& tensor_name) { + std::error_code ec; + auto canonical_data = std::filesystem::weakly_canonical(data_path, ec); + if (ec) { + fail_check("Tensor ", tensor_name, " external data path could not be canonicalized: ", ec.message()); + } + auto canonical_base = std::filesystem::weakly_canonical(utf8_to_path(base_dir), ec); + if (ec) { + fail_check("Tensor ", tensor_name, " base directory could not be canonicalized: ", ec.message()); + } + auto base_str = canonical_base.native(); + if (!base_str.empty() && base_str.back() != std::filesystem::path::preferred_separator) { + base_str += std::filesystem::path::preferred_separator; + } + if (canonical_data.native().find(base_str) != 0 && canonical_data != canonical_base) { // NOSONAR + fail_check("Tensor ", tensor_name, " external data resolves outside model directory."); + } + return canonical_data; +} + +std::filesystem::path resolve_external_data_location( + const std::string& base_dir, + const std::string& location, + const std::string& tensor_name) { + auto base_dir_path = utf8_to_path(base_dir); + auto file_path = utf8_to_path(location); + if (file_path.empty()) { + fail_check("Location of external TensorProto ( tensor name: ", tensor_name, ") should not be empty."); + } + if (file_path.is_absolute()) { + fail_check( + "Location of external TensorProto ( tensor name: ", + tensor_name, + ") should be a relative path, but it is an absolute path: ", + location); + } + auto relative_path = file_path.lexically_normal().make_preferred(); + if (relative_path.native().find(std::filesystem::path("..").native()) != std::filesystem::path::string_type::npos) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor_name, + ") should be file inside '", + base_dir, + "', but '", + location, + "' points outside the directory."); + } + auto data_path = base_dir_path / relative_path; + auto data_path_str = path_to_utf8(data_path); + // Do not allow symlinks or directories. + if (data_path.empty() || std::filesystem::is_symlink(data_path)) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor_name, + ") should be stored in ", + data_path_str, + ", but it is a symbolic link."); + } + // Verify canonical containment (catches parent-dir symlinks). + if (data_path_str[0] != '#') { + verify_path_containment(data_path, base_dir, tensor_name); + } + if (data_path_str[0] != '#' && !std::filesystem::is_regular_file(data_path)) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor_name, + ") should be stored in ", + data_path_str, + ", but it is not regular file."); + } + // Do not allow hardlinks, as they can be used to read arbitrary files. + if (data_path_str[0] != '#' && std::filesystem::hard_link_count(data_path) > 1) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor_name, + ") should be stored in ", + data_path_str, + ", but it has multiple hard links, indicating a potential hardlink attack."); + } + return data_path; +} + +static std::filesystem::path +validate_write_location(const std::string& base_dir, const std::string& location, const std::string& tensor_name) { + auto file_path = utf8_to_path(location); + if (file_path.empty() || file_path.is_absolute()) { + fail_check("External data location for tensor ", tensor_name, " is empty or absolute: ", location); + } + auto rel = file_path.lexically_normal().make_preferred(); + if (rel == std::filesystem::path(".")) { + fail_check("External data location for tensor ", tensor_name, " is invalid: ", location); + } + if (rel.native().find(std::filesystem::path("..").native()) != + std::filesystem::path::string_type::npos) { // NOSONAR — C++17, no contains + fail_check("External data location for tensor ", tensor_name, " contains '..': ", location); + } + return utf8_to_path(base_dir) / rel; +} + +#ifdef _WIN32 + +int64_t open_external_data( + const std::string& base_dir, + const std::string& location, + const std::string& tensor_name, + bool read_only) { + std::filesystem::path data_path; + if (read_only) { + data_path = resolve_external_data_location(base_dir, location, tensor_name); + } else { + data_path = validate_write_location(base_dir, location, tensor_name); + // Pre-open parent-dir check (final-component-only flags don't protect parents). + verify_path_containment(data_path.parent_path(), base_dir, tensor_name); + } + + // CreateFileW with FILE_FLAG_OPEN_REPARSE_POINT: opens reparse point itself + // (symlink/junction) without following, and returns CRT-independent HANDLE. + DWORD access = read_only ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE); + DWORD creation = read_only ? OPEN_EXISTING : OPEN_ALWAYS; + HANDLE h = CreateFileW( + data_path.native().c_str(), + access, + FILE_SHARE_READ, + nullptr, + creation, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OPEN_REPARSE_POINT, + nullptr); + if (h == INVALID_HANDLE_VALUE) { + fail_check("Cannot open external data for tensor ", tensor_name); + } + ScopedHandle guard(h); + + // Reject symlinks/junctions. + BY_HANDLE_FILE_INFORMATION file_info; + if (!GetFileInformationByHandle(h, &file_info)) { + fail_check("Tensor ", tensor_name, " external data: cannot query file information."); + } + if (file_info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { + fail_check("Tensor ", tensor_name, " external data is a reparse point (symlink/junction)."); + } + + // Inode comparison: open canonical path, compare volume + file index. + auto canonical_data = verify_path_containment(data_path, base_dir, tensor_name); + HANDLE h2 = CreateFileW( + canonical_data.native().c_str(), + 0, + FILE_SHARE_READ | FILE_SHARE_WRITE, + nullptr, + OPEN_EXISTING, + FILE_FLAG_OPEN_REPARSE_POINT, + nullptr); + if (h2 == INVALID_HANDLE_VALUE) { + fail_check("Tensor ", tensor_name, " external data: cannot open canonical path for verification."); + } + ScopedHandle guard2(h2); + BY_HANDLE_FILE_INFORMATION canon_info; + if (!GetFileInformationByHandle(h2, &canon_info)) { + fail_check("Tensor ", tensor_name, " external data: cannot query canonical path file information."); + } + if (!same_file(file_info, canon_info)) { + fail_check("Tensor ", tensor_name, " external data: fd/path mismatch (possible TOCTOU attack)."); + } + + // Hardlink check (fail closed). + if (file_info.nNumberOfLinks > 1) { + fail_check("Tensor ", tensor_name, " external data has multiple hard links (possible hardlink attack)."); + } + + // Convert HANDLE → CRT fd so callers get a uniform fd on all platforms. + HANDLE h_released = guard.release(); + int flags = read_only ? (_O_RDONLY | _O_BINARY) : (_O_RDWR | _O_BINARY); + int fd = _open_osfhandle(reinterpret_cast(h_released), flags); + if (fd < 0) { + CloseHandle(h_released); + fail_check("Cannot convert handle to fd for tensor ", tensor_name); + } + return static_cast(fd); +} + +#else // POSIX + +// Try kernel-level contained open. +// Returns fd >= 0 on success, -1 if feature unavailable (fall through to legacy). +// Calls fail_check on kernel rejection (symlink, escape) — does NOT fall through. +static int try_kernel_contained_open( + const std::string& base_dir, + const std::string& location, + [[maybe_unused]] const std::string& tensor_name, + [[maybe_unused]] bool read_only) { + int raw_dirfd = open(base_dir.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC); + if (raw_dirfd < 0) { + return -1; + } + ScopedFd dirfd_guard(raw_dirfd); + auto rel = std::filesystem::path(location).lexically_normal().string(); + int fd = -1; + +#ifdef ONNX_HAS_OPENAT2 + static thread_local bool openat2_supported = true; + if (openat2_supported) { + struct open_how how = {}; + how.flags = + read_only ? static_cast(O_RDONLY | O_CLOEXEC) : static_cast(O_CREAT | O_RDWR | O_CLOEXEC); + how.mode = read_only ? 0 : 0600; + how.resolve = RESOLVE_BENEATH | RESOLVE_NO_SYMLINKS; + fd = static_cast(syscall(SYS_openat2, raw_dirfd, rel.c_str(), &how, sizeof(how))); + if (fd < 0) { + if (errno == ENOSYS) { + openat2_supported = false; // kernel too old, fall through + } else { + fail_check("Cannot open external data for tensor ", tensor_name, " (kernel rejected path)"); + } + } + } +#elif defined(ONNX_HAS_RESOLVE_BENEATH) + int flags = O_RESOLVE_BENEATH | O_CLOEXEC; +#ifdef O_NOFOLLOW + flags |= O_NOFOLLOW; +#endif + if (read_only) { + fd = openat(raw_dirfd, rel.c_str(), flags | O_RDONLY); + } else { + fd = openat(raw_dirfd, rel.c_str(), flags | O_CREAT | O_RDWR, 0600); + } + if (fd < 0) { + fail_check("Cannot open external data for tensor ", tensor_name); + } +#endif + + return fd; +} + +int64_t open_external_data( + const std::string& base_dir, + const std::string& location, + const std::string& tensor_name, + bool read_only) { + // Pre-open validation (defense-in-depth). + std::filesystem::path data_path; + if (read_only) { + data_path = resolve_external_data_location(base_dir, location, tensor_name); + } else { + data_path = validate_write_location(base_dir, location, tensor_name); + // Pre-open parent-dir check (final-component-only flags don't protect parents). + verify_path_containment(data_path.parent_path(), base_dir, tensor_name); + } + + // Try kernel-level contained open (openat2 or O_RESOLVE_BENEATH). + int fd = try_kernel_contained_open(base_dir, location, tensor_name, read_only); + bool kernel_verified = (fd >= 0); + + // Fallback: open() + O_NOFOLLOW + post-open inode verification. + if (fd < 0) { + int flags = read_only ? O_RDONLY : (O_CREAT | O_RDWR); +#ifdef O_CLOEXEC + flags |= O_CLOEXEC; +#endif +#ifdef O_NOFOLLOW + flags |= O_NOFOLLOW; +#endif + fd = read_only ? open(data_path.c_str(), flags) : open(data_path.c_str(), flags, 0600); + if (fd == -1) { + fail_check("Cannot open external data for tensor ", tensor_name); + } + } + ScopedFd guard(fd); + + // Post-open checks (fail closed). + struct stat fd_stat{}; + if (fstat(fd, &fd_stat) != 0) { + fail_check("Tensor ", tensor_name, " external data: fstat failed."); + } + if (!kernel_verified) { + // Verify containment via canonical path + inode comparison. + auto canonical_data = verify_path_containment(data_path, base_dir, tensor_name); + struct stat path_stat{}; + if (stat(canonical_data.c_str(), &path_stat) != 0) { + fail_check("Tensor ", tensor_name, " external data: cannot stat canonical path."); + } + if (path_stat.st_dev != fd_stat.st_dev || path_stat.st_ino != fd_stat.st_ino) { + fail_check("Tensor ", tensor_name, " external data: fd/path mismatch (possible TOCTOU attack)."); + } + } + if (fd_stat.st_nlink > 1) { + fail_check("Tensor ", tensor_name, " external data has multiple hard links (possible hardlink attack)."); + } + + return guard.release(); +} + +#endif + +static std::unordered_set experimental_ops = { + "ATen", + "Affine", + "ConstantFill", + "Crop", + "DynamicSlice", + "GRUUnit", + "GivenTensorFill", + "ImageScaler", + "ParametricSoftplus", + "Scale", + "ScaledTanh"}; + +bool check_is_experimental_op(const NodeProto& node) { + return (node.domain() == ONNX_DOMAIN || node.domain() == "ai.onnx") && experimental_ops.count(node.op_type()); +} + +#undef enforce_has_field +#undef enforce_non_empty_field + +} // namespace checker +} // namespace ONNX_NAMESPACE diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.h new file mode 100644 index 0000000000000000000000000000000000000000..bb281a9867a25180e5008f0583c1ce81e2dfec58 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.h @@ -0,0 +1,204 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "onnx/defs/schema.h" +#include "onnx/onnx-data.pb.h" +#include "onnx/string_utils.h" + +namespace ONNX_NAMESPACE { +namespace checker { +// std::string member means copy may throw when allocation fails +// NOLINTNEXTLINE(bugprone-exception-copy-constructor-throws) +class ValidationError final : public std::runtime_error { + public: + using std::runtime_error::runtime_error; + const char* what() const noexcept override { + if (!expanded_message_.empty()) { + return expanded_message_.c_str(); + } + return std::runtime_error::what(); + } + void AppendContext(const std::string& context) { + expanded_message_ = ONNX_NAMESPACE::MakeString(std::runtime_error::what(), "\n\n==> Context: ", context); + } + + private: + std::string expanded_message_; +}; + +#define fail_check(...) ONNX_THROW_EX(ONNX_NAMESPACE::checker::ValidationError(ONNX_NAMESPACE::MakeString(__VA_ARGS__))) + +class CheckerContext final { + public: + int get_ir_version() const { + return ir_version_; + } + void set_ir_version(int v) { + ir_version_ = v; + } + const std::unordered_map& get_opset_imports() const { + return opset_imports_; + } + void set_opset_imports(std::unordered_map imps) { + opset_imports_ = std::move(imps); + } + bool is_main_graph() const { + return is_main_graph_; + } + void set_is_main_graph(bool is_main_graph) { + is_main_graph_ = is_main_graph; + } + + void set_schema_registry(const ISchemaRegistry* schema_registry) { + schema_registry_ = schema_registry; + } + + const ISchemaRegistry* get_schema_registry() const { + return schema_registry_; + } + + void set_model_dir(const std::string& model_dir) { + model_dir_ = model_dir; + } + + std::string get_model_dir() const { + return model_dir_; + } + + bool skip_opset_compatibility_check() const { + return skip_opset_compatibility_check_; + } + + void set_skip_opset_compatibility_check(bool value) { + skip_opset_compatibility_check_ = value; + } + + bool check_custom_domain() const { + return check_custom_domain_; + } + + void set_check_custom_domain(bool value) { + check_custom_domain_ = value; + } + + explicit CheckerContext() = default; + + private: + int ir_version_{-1}; + std::unordered_map opset_imports_; + bool is_main_graph_ = true; + const ISchemaRegistry* schema_registry_ = OpSchemaRegistry::Instance(); + std::string model_dir_; + bool skip_opset_compatibility_check_ = false; + bool check_custom_domain_ = false; +}; + +class LexicalScopeContext final { + public: + LexicalScopeContext() = default; + ~LexicalScopeContext() = default; + + // Construct an instance with the lexical scope from the parent graph to allow + // lookup of names from that scope via this_or_ancestor_graph_has. + // The caller must ensure parent_context remains valid for the entire lifetime + // of the new instance. Alternatively, if that cannot be guaranteed, create an + // instance with the default constructor and populate output_names with the + // values from the parent scope so the values are copied instead. + LexicalScopeContext(const LexicalScopeContext& parent_context) : parent_context_{&parent_context} {} + LexicalScopeContext& operator=(const LexicalScopeContext& parent_context) { + if (this == &parent_context) { + return *this; + } + parent_context_ = &parent_context; + return *this; + } + LexicalScopeContext(LexicalScopeContext&&) = delete; + LexicalScopeContext& operator=(LexicalScopeContext&&) = delete; + + void add(const std::string& name) { + output_names.insert(name); + } + + bool this_graph_has(const std::string& name) const { + return output_names.count(name) > 0; + } + + bool this_or_ancestor_graph_has(const std::string& name) const { + return this_graph_has(name) || (parent_context_ && parent_context_->this_or_ancestor_graph_has(name)); + } + + // public for backwards compatibility. please prefer the public interface of + // this class over directly changing output_names + std::unordered_set output_names; + + private: + const LexicalScopeContext* parent_context_{nullptr}; +}; + +using IR_VERSION_TYPE = decltype(Version::IR_VERSION); +void check_value_info(const ValueInfoProto& value_info, const CheckerContext& /*ctx*/); +void check_tensor(const TensorProto& tensor, const CheckerContext& /*ctx*/); +void check_sparse_tensor(const SparseTensorProto& sparse_tensor, const CheckerContext& /*ctx*/); +void check_sequence(const SequenceProto& sequence, const CheckerContext& /*ctx*/); +void check_map(const MapProto& map, const CheckerContext& /*ctx*/); +void check_optional(const OptionalProto& opt, const CheckerContext& /*ctx*/); +void check_attribute(const AttributeProto& attr, const CheckerContext& /*ctx*/, const LexicalScopeContext& /*lex_ctx*/); +void check_node(const NodeProto& node, const CheckerContext& /*ctx*/, const LexicalScopeContext& /*lex_ctx*/); +void check_graph(const GraphProto& graph, const CheckerContext& /*ctx*/, const LexicalScopeContext& /*parent_lex*/); +void check_function( + const FunctionProto& function, + const CheckerContext& /*ctx*/, + const LexicalScopeContext& /*parent_lex*/); + +// Check schema compatibility for 2 opset versions for a given node. +// Checks whether the schema for 2 versions is same, this is true when the opschema +// does not change between versions. +ONNX_API void check_opset_compatibility( + const NodeProto& node, + const CheckerContext& ctx, + const std::unordered_map& func_opset_imports, + const std::unordered_map& model_opset_imports); + +// Checks all model local functions present in ModelProto +ONNX_API void +check_model_local_functions(const ModelProto& model, const CheckerContext& ctx, const LexicalScopeContext& parent_lex); + +// Checks for cycles in model-local function call graph. +// Throws ValidationError if any function directly or indirectly references itself. +ONNX_API void check_function_call_cycles(const ModelProto& model); + +ONNX_API void check_model( + const ModelProto& model, + bool full_check = false, + bool skip_opset_compatibility_check = false, + bool check_custom_domain = false); +ONNX_API void check_model( + const std::string& model_path, + bool full_check = false, + bool skip_opset_compatibility_check = false, + bool check_custom_domain = false); +std::filesystem::path resolve_external_data_location( + const std::string& base_dir, + const std::string& location, + const std::string& tensor_name); +// Returns a CRT file descriptor on all platforms. +// The caller owns the fd and must close it. +int64_t open_external_data( + const std::string& base_dir, + const std::string& location, + const std::string& tensor_name, + bool read_only); +ONNX_API bool check_is_experimental_op(const NodeProto& node); + +} // namespace checker +} // namespace ONNX_NAMESPACE diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.py b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.py new file mode 100644 index 0000000000000000000000000000000000000000..520c117b460d0809a3635c6806da2bf7a69f1b59 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/checker.py @@ -0,0 +1,171 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +"""Graph utilities for checking whether an ONNX proto message is legal.""" + +from __future__ import annotations + +__all__ = [ + "check_attribute", + "check_function", + "check_graph", + "check_model", + "check_node", + "check_sparse_tensor", + "check_tensor", + "check_value_info", + "DEFAULT_CONTEXT", + "LEXICAL_SCOPE_CONTEXT", + "ValidationError", + "C", + "MAXIMUM_PROTOBUF", +] + +import os +from typing import TYPE_CHECKING + +import onnx.defs +import onnx.onnx_cpp2py_export.checker as C # noqa: N812 +from onnx.onnx_pb import IR_VERSION + +if TYPE_CHECKING: + from google.protobuf.message import Message + +# Limitation of single protobuf file is 2GiB +MAXIMUM_PROTOBUF = 2147483648 + + +# NB: Please don't edit this context! +DEFAULT_CONTEXT = C.CheckerContext() +DEFAULT_CONTEXT.ir_version = IR_VERSION +# TODO: Maybe ONNX-ML should also be defaulted? +DEFAULT_CONTEXT.opset_imports = {"": onnx.defs.onnx_opset_version()} + +LEXICAL_SCOPE_CONTEXT = C.LexicalScopeContext() + + +def _ensure_proto_type(proto: Message, proto_type: type[Message]) -> None: + if not isinstance(proto, proto_type): + raise TypeError( + f"The proto message needs to be of type '{proto_type.__name__}'" + ) + + +def check_value_info( + value_info: onnx.ValueInfoProto, ctx: C.CheckerContext = DEFAULT_CONTEXT +) -> None: + _ensure_proto_type(value_info, onnx.ValueInfoProto) + return C.check_value_info(value_info.SerializeToString(), ctx) + + +def check_tensor( + tensor: onnx.TensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT +) -> None: + _ensure_proto_type(tensor, onnx.TensorProto) + return C.check_tensor(tensor.SerializeToString(), ctx) + + +def check_attribute( + attr: onnx.AttributeProto, + ctx: C.CheckerContext = DEFAULT_CONTEXT, + lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT, +) -> None: + _ensure_proto_type(attr, onnx.AttributeProto) + return C.check_attribute(attr.SerializeToString(), ctx, lexical_scope_ctx) + + +def check_node( + node: onnx.NodeProto, + ctx: C.CheckerContext = DEFAULT_CONTEXT, + lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT, +) -> None: + _ensure_proto_type(node, onnx.NodeProto) + return C.check_node(node.SerializeToString(), ctx, lexical_scope_ctx) + + +def check_function( + function: onnx.FunctionProto, + ctx: C.CheckerContext | None = None, + lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT, +) -> None: + _ensure_proto_type(function, onnx.FunctionProto) + if ctx is None: + ctx = C.CheckerContext() + ctx.ir_version = onnx.helper.find_min_ir_version_for( + function.opset_import, ignore_unknown=True + ) + ctx.opset_imports = { + domain_version.domain: domain_version.version + for domain_version in function.opset_import + } + C.check_function(function.SerializeToString(), ctx, lexical_scope_ctx) + + +def check_graph( + graph: onnx.GraphProto, + ctx: C.CheckerContext = DEFAULT_CONTEXT, + lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT, +) -> None: + _ensure_proto_type(graph, onnx.GraphProto) + return C.check_graph(graph.SerializeToString(), ctx, lexical_scope_ctx) + + +def check_sparse_tensor( + sparse: onnx.SparseTensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT +) -> None: + _ensure_proto_type(sparse, onnx.SparseTensorProto) + C.check_sparse_tensor(sparse.SerializeToString(), ctx) + + +def check_model( + model: onnx.ModelProto | str | bytes | os.PathLike, + full_check: bool = False, + skip_opset_compatibility_check: bool = False, + check_custom_domain: bool = False, +) -> None: + """Check the consistency of a model. + + An exception will be raised if the model's ir_version is not set + properly or is higher than checker's ir_version, or if the model + has duplicate keys in metadata_props. + + If IR version >= 3, the model must specify opset_import. + If IR version < 3, the model cannot have any opset_import specified. + + Args: + model: Model to check. If model is a path, the function checks model + path first. If the model bytes size is larger than 2GB, function + should be called using model path. + full_check: If True, the function also runs shape inference check. + skip_opset_compatibility_check: If True, the function skips the check for + opset compatibility. + check_custom_domain: If True, the function will check all domains. Otherwise + only check built-in domains. + """ + # If model is a path instead of ModelProto + if isinstance(model, (str, os.PathLike)): + C.check_model_path( + os.fspath(model), + full_check, + skip_opset_compatibility_check, + check_custom_domain, + ) + else: + protobuf_string = ( + model if isinstance(model, bytes) else model.SerializeToString() + ) + # If the protobuf is larger than 2GiB, + # remind users should use the model path to check + if len(protobuf_string) > MAXIMUM_PROTOBUF: + raise ValueError( + "This protobuf of onnx model is too large (>2GiB). Call check_model with model path instead." + ) + C.check_model( + protobuf_string, + full_check, + skip_opset_compatibility_check, + check_custom_domain, + ) + + +ValidationError = C.ValidationError diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/array_ref.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/array_ref.h new file mode 100644 index 0000000000000000000000000000000000000000..c9604c5a9bc2cee28ff1851e148eccbfb8e75c99 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/array_ref.h @@ -0,0 +1,201 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +//===--- ArrayRef.h - Array Reference Wrapper -------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// ONNX: modified from llvm::ArrayRef. +// removed llvm-specific functionality +// removed some implicit const -> non-const conversions that rely on +// complicated std::enable_if meta-programming +// removed a bunch of slice variants for simplicity... + +#pragma once +#include +#include +#include + +namespace ONNX_NAMESPACE { +/// ArrayRef - Represent a constant reference to an array (0 or more elements +/// consecutively in memory), i.e. a start pointer and a length. It allows +/// various APIs to take consecutive elements easily and conveniently. +/// +/// This class does not own the underlying data, it is expected to be used in +/// situations where the data resides in some other buffer, whose lifetime +/// extends past that of the ArrayRef. For this reason, it is not in general +/// safe to store an ArrayRef. +/// +/// This is intended to be trivially copyable, so it should be passed by +/// value. +template +class ArrayRef { + public: + using iterator = const T*; + using const_iterator = const T*; + using size_type = size_t; + + using reverse_iterator = std::reverse_iterator; + + private: + /// The start of the array, in an external buffer. + const T* Data; + + /// The number of elements. + size_type Length; + + public: + /// @name Constructors + /// @{ + + /// Construct an empty ArrayRef. + /*implicit*/ ArrayRef() : Data(nullptr), Length(0) {} + + /// Construct an ArrayRef from a single element. + // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit) + /*implicit*/ ArrayRef(const T& OneElt) : Data(&OneElt), Length(1) {} + + /// Construct an ArrayRef from a pointer and length. + /*implicit*/ ArrayRef(const T* data, size_t length) : Data(data), Length(length) {} + + /// Construct an ArrayRef from a range. + ArrayRef(const T* begin, const T* end) : Data(begin), Length(end - begin) {} + + /// Construct an ArrayRef from a std::vector. + template + // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit) + /*implicit*/ ArrayRef(const std::vector& Vec) : Data(Vec.data()), Length(Vec.size()) {} + + /// Construct an ArrayRef from a std::array + template + // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit) + /*implicit*/ constexpr ArrayRef(const std::array& Arr) : Data(Arr.data()), Length(N) {} + + /// Construct an ArrayRef from a C array. + template + // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit) + /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {} + + /// Construct an ArrayRef from a std::initializer_list. + /*implicit*/ ArrayRef(const std::initializer_list& Vec) + : Data(Vec.begin() == Vec.end() ? static_cast(nullptr) : Vec.begin()), Length(Vec.size()) {} + + /// @} + /// @name Simple Operations + /// @{ + + iterator begin() const { + return Data; + } + iterator end() const { + return Data + Length; + } + + reverse_iterator rbegin() const { + return reverse_iterator(end()); + } + reverse_iterator rend() const { + return reverse_iterator(begin()); + } + + /// empty - Check if the array is empty. + bool empty() const { + return Length == 0; + } + + const T* data() const { + return Data; + } + + /// size - Get the array size. + size_t size() const { + return Length; + } + + /// front - Get the first element. + const T& front() const { + assert(!empty()); + return Data[0]; + } + + /// back - Get the last element. + const T& back() const { + assert(!empty()); + return Data[Length - 1]; + } + + /// equals - Check for element-wise equality. + bool equals(ArrayRef RHS) const { + if (Length != RHS.Length) + return false; + return std::equal(begin(), end(), RHS.begin()); + } + + /// slice(n, m) - Chop off the first N elements of the array, and keep M + /// elements in the array. + ArrayRef slice(size_t N, size_t M) const { + assert(N + M <= size() && "Invalid specifier"); + return ArrayRef(data() + N, M); + } + + /// slice(n) - Chop off the first N elements of the array. + ArrayRef slice(size_t N) const { + return slice(N, size() - N); + } + + /// @} + /// @name Operator Overloads + /// @{ + const T& operator[](size_t Index) const { + assert(Index < Length && "Invalid index!"); + return Data[Index]; + } + + /// Vector compatibility + const T& at(size_t Index) const { + assert(Index < Length && "Invalid index!"); + return Data[Index]; + } + + /// Disallow accidental assignment from a temporary. + /// + /// The declaration here is extra complicated so that "arrayRef = {}" + /// continues to select the move assignment operator. + template + std::enable_if_t, ArrayRef>& operator=(U&& Temporary) = delete; + + /// Disallow accidental assignment from a temporary. + /// + /// The declaration here is extra complicated so that "arrayRef = {}" + /// continues to select the move assignment operator. + template + std::enable_if_t, ArrayRef>& operator=(std::initializer_list) = delete; + + /// @} + /// @name Expensive Operations + /// @{ + std::vector vec() const { + return std::vector(Data, Data + Length); + } + + /// @} + /// @name Conversion operators + /// @{ + /// NOLINTNEXTLINE(google-explicit-constructor) + operator std::vector() const { + return std::vector(Data, Data + Length); + } + + /// @} +}; + +} // namespace ONNX_NAMESPACE diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/assertions.cc b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/assertions.cc new file mode 100644 index 0000000000000000000000000000000000000000..0ee039a2515be00227b35453c2d076a9ac035cd5 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/assertions.cc @@ -0,0 +1,53 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#include "onnx/common/assertions.h" + +#include +#include +#include +#include + +#include "onnx/common/common.h" + +namespace ONNX_NAMESPACE { + +std::string barf(const char* fmt, ...) { // NOLINT(modernize-avoid-variadic-functions) + constexpr size_t buffer_size = 2048; + std::array msg{}; + va_list args; + + va_start(args, fmt); + +// use fixed length for buffer "msg" to avoid buffer overflow +// Suppress -Wformat-nonliteral: fmt comes from the variadic parameter, +// and call sites are checked via the format attribute on the declaration. +#if defined(__clang__) || defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wformat-nonliteral" +#endif + vsnprintf(static_cast(msg.data()), msg.size() - 1, fmt, args); +#if defined(__clang__) || defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + + // ensure null-terminated string to avoid out of bounds read + msg.back() = '\0'; + va_end(args); + + return std::string(msg.data()); +} + +void throw_assert_error(std::string& msg) { + ONNX_THROW_EX(assert_error(msg)); +} + +void throw_tensor_error(std::string& msg) { + ONNX_THROW_EX(tensor_error(msg)); +} + +} // namespace ONNX_NAMESPACE diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/assertions.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/assertions.h new file mode 100644 index 0000000000000000000000000000000000000000..0b77d3fbf035d31821b8bdae78b8bb08be468c12 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/assertions.h @@ -0,0 +1,69 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#pragma once + +#include +#include + +namespace ONNX_NAMESPACE { + +struct assert_error : public std::runtime_error { + public: + explicit assert_error(const std::string& msg) : runtime_error(msg) {} +}; + +struct tensor_error : public assert_error { + public: + explicit tensor_error(const std::string& msg) : assert_error(msg) {} +}; + +#if defined(__GNUC__) || defined(__clang__) +__attribute__((format(printf, 1, 2))) +#endif +std::string barf(const char* fmt, ...); + +[[noreturn]] void throw_assert_error(std::string& /*msg*/); + +[[noreturn]] void throw_tensor_error(std::string& /*msg*/); + +} // namespace ONNX_NAMESPACE + +#if defined(__GNUC__) || defined(__ICL) || defined(__clang__) +#define _ONNX_EXPECT(x, y) (__builtin_expect((x), (y))) +#else +#define _ONNX_EXPECT(x, y) (x) +#endif + +#define ONNX_ASSERT(cond) \ + if (_ONNX_EXPECT(!(cond), 0)) { /* NOLINT(readability-simplify-boolean-expr) */ \ + std::string error_msg = \ + ::ONNX_NAMESPACE::barf("%s:%u: %s: Assertion `%s` failed.", __FILE__, __LINE__, __func__, #cond); \ + throw_assert_error(error_msg); \ + } + +// The following is used to prevent MSVC from passing the whole __VA_ARGS__ list +// as the first parameter value to a macro call. +#define ONNX_EXPAND(x) x + +// Note: msg must be a string literal +// The ##__VA_ARGS__ extension removes the trailing comma when __VA_ARGS__ is empty. +// This is supported by GCC, Clang, and MSVC (since VS 2019 16.6). +#define ONNX_ASSERTM(cond, msg, ...) \ + /* NOLINTNEXTLINE */ \ + if (_ONNX_EXPECT(!(cond), 0)) { \ + std::string error_msg = ::ONNX_NAMESPACE::barf( \ + "%s:%u: %s: Assertion `%s` failed: " msg, __FILE__, __LINE__, __func__, #cond, ##__VA_ARGS__); \ + throw_assert_error(error_msg); \ + } + +#define TENSOR_ASSERTM(cond, msg, ...) \ + if (_ONNX_EXPECT(!(cond), 0)) { \ + std::string error_msg = ::ONNX_NAMESPACE::barf( \ + "%s:%u: %s: Assertion `%s` failed: " msg, __FILE__, __LINE__, __func__, #cond, ##__VA_ARGS__); \ + throw_tensor_error(error_msg); \ + } diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/common.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/common.h new file mode 100644 index 0000000000000000000000000000000000000000..50c7be8bedd707fc029a148e6e5c3618c592408d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/common.h @@ -0,0 +1,52 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 +#pragma once + +#define ONNX_UNUSED_PARAMETER(x) (void)(x) + +#ifdef ONNX_NO_EXCEPTIONS +#include +#define ONNX_THROW(...) \ + do { \ + std::cerr << ONNX_NAMESPACE::MakeString(__VA_ARGS__); \ + abort(); \ + } while (false) + +#define ONNX_THROW_EX(ex) \ + do { \ + std::cerr << ex.what() << std::endl; /* NOLINT */ \ + abort(); \ + } while (false) + +#define ONNX_TRY if (true) +#define ONNX_CATCH(x) else if (false) +#define ONNX_HANDLE_EXCEPTION(func) + +#else +#define ONNX_THROW(...) throw std::runtime_error(ONNX_NAMESPACE::MakeString(__VA_ARGS__)) +#define ONNX_THROW_EX(ex) throw ex + +#define ONNX_TRY try +#define ONNX_CATCH(x) catch (x) +#define ONNX_HANDLE_EXCEPTION(func) func() +#endif + +// Macros to disable the copy and/or assignment methods +// These are usually placed in the private: declarations for a class. + +#define ONNX_DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete + +#define ONNX_DISALLOW_ASSIGNMENT(TypeName) TypeName& operator=(const TypeName&) = delete + +#define ONNX_DISALLOW_COPY_AND_ASSIGNMENT(TypeName) \ + ONNX_DISALLOW_COPY(TypeName); \ + ONNX_DISALLOW_ASSIGNMENT(TypeName) + +#define ONNX_DISALLOW_MOVE(TypeName) \ + TypeName(TypeName&&) = delete; \ + TypeName& operator=(TypeName&&) = delete + +#define ONNX_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(TypeName) \ + ONNX_DISALLOW_COPY_AND_ASSIGNMENT(TypeName); \ + ONNX_DISALLOW_MOVE(TypeName) diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/constants.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/constants.h new file mode 100644 index 0000000000000000000000000000000000000000..272b5c2be868218e1a9a81773a618df0ced57470 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/constants.h @@ -0,0 +1,46 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +namespace ONNX_NAMESPACE { +// For ONNX op/function registration. + +// ONNX domains. +constexpr const char* AI_ONNX_ML_DOMAIN = "ai.onnx.ml"; +constexpr const char* AI_ONNX_TRAINING_DOMAIN = "ai.onnx.training"; +constexpr const char* AI_ONNX_PREVIEW_DOMAIN = "ai.onnx.preview"; +constexpr const char* AI_ONNX_PREVIEW_TRAINING_DOMAIN = "ai.onnx.preview.training"; +// The following two are equivalent in an onnx proto representation. +constexpr const char* ONNX_DOMAIN = ""; +constexpr const char* AI_ONNX_DOMAIN = "ai.onnx"; + +inline std::string NormalizeDomain(const std::string& domain) { + return (domain == AI_ONNX_DOMAIN) ? ONNX_DOMAIN : domain; +} + +inline bool IsOnnxDomain(const std::string& domain) { + return (domain == AI_ONNX_DOMAIN) || (domain == ONNX_DOMAIN); +} + +constexpr bool OPTIONAL_VALUE = false; + +// For dimension denotation. +constexpr const char* DATA_BATCH = "DATA_BATCH"; +constexpr const char* DATA_CHANNEL = "DATA_CHANNEL"; +constexpr const char* DATA_TIME = "DATA_TIME"; +constexpr const char* DATA_FEATURE = "DATA_FEATURE"; +constexpr const char* FILTER_IN_CHANNEL = "FILTER_IN_CHANNEL"; +constexpr const char* FILTER_OUT_CHANNEL = "FILTER_OUT_CHANNEL"; +constexpr const char* FILTER_SPATIAL = "FILTER_SPATIAL"; + +// For type denotation. +constexpr const char* TENSOR = "TENSOR"; +constexpr const char* IMAGE = "IMAGE"; +constexpr const char* AUDIO = "AUDIO"; +constexpr const char* TEXT = "TEXT"; + +} // namespace ONNX_NAMESPACE diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/file_utils.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/file_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..50d545418670066be207a4812a6572c92f3a79af --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/file_utils.h @@ -0,0 +1,38 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include // NOLINT(build/c++17) +#include +#include + +#ifdef _WIN32 +#include "onnx/common/path.h" +#endif +#include "onnx/checker.h" + +namespace ONNX_NAMESPACE { + +template +void LoadProtoFromPath(const std::string& proto_path, T& proto) { +#ifdef _WIN32 + std::filesystem::path proto_u8_path(utf8str_to_wstring(proto_path)); +#else + std::filesystem::path proto_u8_path(proto_path); +#endif + std::fstream proto_stream(proto_u8_path, std::ios::in | std::ios::binary); + if (!proto_stream.good()) { + fail_check("Unable to open proto file: ", proto_path, ". Please check if it is a valid proto. "); + } + std::string data{std::istreambuf_iterator{proto_stream}, std::istreambuf_iterator{}}; + if (!proto_stream.good()) { + fail_check("Unable to read proto file: ", proto_path, ". Please check if it is a valid proto. "); + } + if (!ParseProtoFromBytes(&proto, data.c_str(), data.size())) { + fail_check( + "Unable to parse proto from file: ", proto_path, ". Please check if it is a valid protobuf file of proto. "); + } +} +} // namespace ONNX_NAMESPACE diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/graph_node_list.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/graph_node_list.h new file mode 100644 index 0000000000000000000000000000000000000000..c30e83864bb6bef85e734447c810ea1af637a17d --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/graph_node_list.h @@ -0,0 +1,170 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +#ifndef ONNX_COMMON_GRAPH_NODE_LIST_H_ +#define ONNX_COMMON_GRAPH_NODE_LIST_H_ + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#include "onnx/common/assertions.h" + +namespace ONNX_NAMESPACE { + +// Intrusive doubly linked lists with sane reverse iterators. +// The header file is named graph_node_list.h because it is ONLY +// used for Graph's Node lists, and if you want to use it for other +// things, you will have to do some refactoring. +// +// At the moment, the templated type T must support a few operations: +// +// - It must have a field: T* next_in_graph[2] = { nullptr, nullptr }; +// which are used for the intrusive linked list pointers. +// +// - It must have a method 'destroy()', which removes T from the +// list and frees a T. +// +// In practice, we are only using it with Node and const Node. 'destroy()' +// needs to be renegotiated if you want to use this somewhere else. +// +// Besides the benefits of being intrusive, unlike std::list, these lists handle +// forward and backward iteration uniformly because we require a +// "before-first-element" sentinel. This means that reverse iterators +// physically point to the element they logically point to, rather than +// the off-by-one behavior for all standard library reverse iterators. + +static constexpr size_t kNextDirection = 0; +static constexpr size_t kPrevDirection = 1; + +template +struct generic_graph_node_list; + +template +struct generic_graph_node_list_iterator; + +struct Node; +using graph_node_list = generic_graph_node_list; +using const_graph_node_list = generic_graph_node_list; +using graph_node_list_iterator = generic_graph_node_list_iterator; +using const_graph_node_list_iterator = generic_graph_node_list_iterator; + +template +struct generic_graph_node_list_iterator final { + generic_graph_node_list_iterator() : cur(nullptr), d(kNextDirection) {} + generic_graph_node_list_iterator(T* cur, size_t d) : cur(cur), d(d) {} + T* operator*() const { + return cur; + } + T* operator->() const { + return cur; + } + generic_graph_node_list_iterator& operator++() { + ONNX_ASSERT(cur) + cur = cur->next_in_graph[d]; + return *this; + } + generic_graph_node_list_iterator operator++(int) { + generic_graph_node_list_iterator old = *this; + ++(*this); + return old; + } + generic_graph_node_list_iterator& operator--() { + ONNX_ASSERT(cur) + cur = cur->next_in_graph[reverseDir()]; + return *this; + } + generic_graph_node_list_iterator operator--(int) { + generic_graph_node_list_iterator old = *this; + --(*this); + return old; + } + + // erase cur without invalidating this iterator + // named differently from destroy so that ->/. bugs do not + // silently cause the wrong one to be called. + // iterator will point to the previous entry after call + void destroyCurrent() { + T* n = cur; + cur = cur->next_in_graph[reverseDir()]; + n->destroy(); + } + generic_graph_node_list_iterator reverse() { + return generic_graph_node_list_iterator(cur, reverseDir()); + } + + private: + size_t reverseDir() { + return d == kNextDirection ? kPrevDirection : kNextDirection; + } + T* cur; + size_t d; // direction 0 is forward 1 is reverse, see next_in_graph +}; + +template +struct generic_graph_node_list final { + using iterator = generic_graph_node_list_iterator; + using const_iterator = generic_graph_node_list_iterator; + generic_graph_node_list_iterator begin() { + return generic_graph_node_list_iterator(head->next_in_graph[d], d); + } + generic_graph_node_list_iterator begin() const { + return generic_graph_node_list_iterator(head->next_in_graph[d], d); + } + generic_graph_node_list_iterator end() { + return generic_graph_node_list_iterator(head, d); + } + generic_graph_node_list_iterator end() const { + return generic_graph_node_list_iterator(head, d); + } + generic_graph_node_list_iterator rbegin() { + return reverse().begin(); + } + generic_graph_node_list_iterator rbegin() const { + return reverse().begin(); + } + generic_graph_node_list_iterator rend() { + return reverse().end(); + } + generic_graph_node_list_iterator rend() const { + return reverse().end(); + } + generic_graph_node_list reverse() { + return generic_graph_node_list(head, d == kNextDirection ? kPrevDirection : kNextDirection); + } + generic_graph_node_list reverse() const { + return generic_graph_node_list(head, d == kNextDirection ? kPrevDirection : kNextDirection); + } + generic_graph_node_list(T* head, size_t d) : head(head), d(d) {} + + private: + T* head; + size_t d; +}; + +template +static inline bool operator==(generic_graph_node_list_iterator a, generic_graph_node_list_iterator b) { + return *a == *b; +} + +template +static inline bool operator!=(generic_graph_node_list_iterator a, generic_graph_node_list_iterator b) { + return *a != *b; +} + +} // namespace ONNX_NAMESPACE + +namespace std { + +template +struct iterator_traits> { + using difference_type = int64_t; + using value_type = T*; + using pointer = T**; + using reference = T*&; + using iterator_category = bidirectional_iterator_tag; +}; + +} // namespace std + +#endif // ONNX_COMMON_GRAPH_NODE_LIST_H_ diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/interned_strings.cc b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/interned_strings.cc new file mode 100644 index 0000000000000000000000000000000000000000..c2e672138e0a2b5cf4aecb58d0d149752b74ac26 --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/interned_strings.cc @@ -0,0 +1,80 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#include "onnx/common/interned_strings.h" + +#include +#include +#include +#include + +#include "onnx/common/assertions.h" + +namespace ONNX_NAMESPACE { +namespace { + +struct InternedStrings { + InternedStrings() { +#define REGISTER_SYMBOL(s) \ + string_to_sym_[#s] = k##s; \ + sym_to_string_[k##s] = #s; + FORALL_BUILTIN_SYMBOLS(REGISTER_SYMBOL) +#undef REGISTER_SYMBOL + } + uint32_t symbol(const std::string& s) { + std::lock_guard guard(mutex_); + auto it = string_to_sym_.find(s); + if (it != string_to_sym_.end()) + return it->second; + uint32_t k = next_sym++; + string_to_sym_[s] = k; + sym_to_string_[k] = s; + return k; + } + const char* string(Symbol sym) { + // Builtin Symbols are also in the maps, but + // we can bypass the need to acquire a lock + // to read the map for Builtins because we already + // know their string value + switch (sym) { +#define DEFINE_CASE(s) \ + case k##s: \ + return #s; + FORALL_BUILTIN_SYMBOLS(DEFINE_CASE) +#undef DEFINE_CASE + default: + return customString(sym); + } + } + + private: + const char* customString(Symbol sym) { + std::lock_guard guard(mutex_); + auto it = sym_to_string_.find(sym); + ONNX_ASSERT(it != sym_to_string_.end()) + return it->second.c_str(); + } + std::unordered_map string_to_sym_; + std::unordered_map sym_to_string_; + uint32_t next_sym{kLastSymbol}; + std::mutex mutex_; +}; + +InternedStrings& globalStrings() { + static InternedStrings s; + return s; +} + +} // namespace + +const char* Symbol::toString() const { + return globalStrings().string(*this); +} + +Symbol::Symbol(const std::string& s) : value(globalStrings().symbol(s)) {} + +} // namespace ONNX_NAMESPACE diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/interned_strings.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/interned_strings.h new file mode 100644 index 0000000000000000000000000000000000000000..67e1031417113d37dc70641f5988775bc49dae1c --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/interned_strings.h @@ -0,0 +1,247 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#pragma once +#include +#include + +namespace ONNX_NAMESPACE { + +#define FORALL_BUILTIN_SYMBOLS(_) \ + _(spatial) \ + _(select_last_index) \ + _(coordinate_transformation_mode) \ + _(PythonOp) \ + _(CppOp) \ + _(Param) \ + _(Select) \ + _(Return) \ + _(Eval) \ + _(add) \ + _(Add) \ + _(Div) \ + _(Mul) \ + _(Neg) \ + _(Sub) \ + _(Pow) \ + _(Sigmoid) \ + _(ArgMax) \ + _(Concat) \ + _(Softmax) \ + _(LogSoftmax) \ + _(Dropout) \ + _(Tanh) \ + _(mul) \ + _(neg) \ + _(sigmoid) \ + _(tanh) \ + _(Constant) \ + _(cat) \ + _(Slice) \ + _(Squeeze) \ + _(Undefined) \ + _(FusionGroup) \ + _(MatMul) \ + _(Gemm) \ + _(Tile) \ + _(SubConstant) \ + _(Scale) \ + _(Transpose) \ + _(Pad) \ + _(Reshape) \ + _(split) \ + _(chunk) \ + _(Offset) \ + _(value) \ + _(Subgraph) \ + _(BatchNormalization) \ + _(Conv) \ + _(ConvTranspose) \ + _(is_test) \ + _(epsilon) \ + _(expand) \ + _(Expand) \ + _(order) \ + _(momentum) \ + _(consumed_inputs) \ + _(kernels) \ + _(kernel_shape) \ + _(kernel) \ + _(scale) \ + _(strides) \ + _(stride) \ + _(pads) \ + _(pad) \ + _(beta) \ + _(alpha) \ + _(dilations) \ + _(dilation) \ + _(broadcast) \ + _(axis) \ + _(ratio) \ + _(size) \ + _(dim) \ + _(keepdims) \ + _(perm) \ + _(shape) \ + _(axes) \ + _(group) \ + _(inplace) \ + _(transA) \ + _(transB) \ + _(other) \ + _(__and__) \ + _(__lshift__) \ + _(__or__) \ + _(__rshift__) \ + _(__xor__) \ + _(abs) \ + _(acos) \ + _(asin) \ + _(atan) \ + _(atan2) \ + _(ceil) \ + _(clamp) \ + _(cos) \ + _(cosh) \ + _(div) \ + _(eq) \ + _(equal) \ + _(Exp) \ + _(ends) \ + _(expm1) \ + _(floor) \ + _(fmod) \ + _(frac) \ + _(ge) \ + _(gt) \ + _(le) \ + _(lerp) \ + _(lgamma) \ + _(Log) \ + _(log1p) \ + _(lt) \ + _(max) \ + _(min) \ + _(ne) \ + _(ones) \ + _(pow) \ + _(reciprocal) \ + _(remainder) \ + _(round) \ + _(rsqrt) \ + _(sin) \ + _(sinh) \ + _(Sqrt) \ + _(sub) \ + _(starts) \ + _(tan) \ + _(trunc) \ + _(zeros) \ + _(exponent) \ + _(device) \ + _(mode) \ + _(Identity) \ + _(Loop) \ + _(If) \ + _(body) \ + _(then_branch) \ + _(else_branch) \ + _(Captured) \ + _(__control_inputs) \ + _(count_include_pad) \ + _(storage_order) \ + _(Unsqueeze) \ + _(ReduceL1) \ + _(ReduceL2) \ + _(ReduceLogSum) \ + _(ReduceLogSumExp) \ + _(ReduceMax) \ + _(ReduceMean) \ + _(ReduceMin) \ + _(ReduceProd) \ + _(ReduceSum) \ + _(ReduceSumSquare) \ + _(Cast) \ + _(to) \ + _(PRelu) \ + _(Greater) \ + _(Less) \ + _(scales) \ + _(Upsample) \ + _(RNN) \ + _(layout) \ + _(k) \ + _(Flatten) \ + _(ScatterElements) \ + _(Resize) \ + _(ceil_mode) \ + _(num_outputs) \ + _(start) \ + _(end) \ + _(num_groups) \ + _(stash_type) \ + _(block_size) \ + _(output_dtype) + +enum BuiltinSymbol : std::uint8_t { +#define DEFINE_SYMBOL(s) k##s, + FORALL_BUILTIN_SYMBOLS(DEFINE_SYMBOL) +#undef DEFINE_SYMBOL + kLastSymbol, // where we start counting for new symbols +}; + +struct Symbol { + Symbol() = default; + // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit) + /*implicit*/ Symbol(BuiltinSymbol value) : value(value) {} + explicit Symbol(const std::string& s); + explicit Symbol(uint32_t value) : value(value) {} + + // NOLINTNEXTLINE(google-explicit-constructor) + operator uint32_t() const { + return value; + } + const char* toString() const; + + private: + uint32_t value{0}; +}; + +static inline bool operator==(Symbol lhs, Symbol rhs) { + return static_cast(lhs) == static_cast(rhs); +} +// necessary to prevent ambiguous overload resolutions +static inline bool operator==(BuiltinSymbol lhs, Symbol rhs) { + return static_cast(lhs) == static_cast(rhs); +} +static inline bool operator==(Symbol lhs, BuiltinSymbol rhs) { + return static_cast(lhs) == static_cast(rhs); +} + +inline Symbol +#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 5 +operator"" _sym // gcc 4.8.5 insists on having a space (hard error). +#else +operator""_sym // clang 17 generates a deprecation warning if there is a space. +#endif + (const char* s, size_t /*unused*/) { + return Symbol(s); +} + +} // namespace ONNX_NAMESPACE + +// make symbol behave like an integer in hash tables +namespace std { +template <> +struct hash { + std::size_t operator()(ONNX_NAMESPACE::Symbol s) const { + return std::hash()(static_cast(s)); + } +}; + +} // namespace std diff --git a/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/ir.h b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/ir.h new file mode 100644 index 0000000000000000000000000000000000000000..3882a278a4f715050f02050781f0144c8ea1554a --- /dev/null +++ b/ScaleDF_rebuttal/python_dedup_pkgs/onnx/common/ir.h @@ -0,0 +1,1450 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "onnx/common/array_ref.h" +#include "onnx/common/assertions.h" +#include "onnx/common/common.h" +#include "onnx/common/graph_node_list.h" +#include "onnx/common/interned_strings.h" +#include "onnx/common/tensor.h" +#include "onnx/string_utils.h" + +#define ONNX_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&) = delete; \ + TypeName& operator=(const TypeName&) = delete + +namespace ONNX_NAMESPACE { + +// internal/private API +static inline std::string toVarName(size_t i) { + std::ostringstream oss; + oss << "_v_" << i; + return oss.str(); +} + +// Graph represents one "function" of computation. +// It uses a simple ownership model where the graph owns all the nodes inside it. +// All references inside the graph are raw pointers. +// Destroying the Graph will invalidate any pointers to nodes in the graph. +struct Graph; + +// Node is the base class of the IR graph. It represents one computation +// and dependencies on a list of Values. The "prim-ops", so to speak. +struct Node; + +// A Value represents an input or output to node that is either a +// Tensor or an opaque Handle object, as determined by type(). +struct Value; + +class ResourceGuard final { + std::function destructor_; + + public: + ONNX_DISALLOW_COPY_AND_ASSIGN(ResourceGuard); + ResourceGuard(ResourceGuard&&) = delete; + ResourceGuard& operator=(ResourceGuard&&) = delete; + + explicit ResourceGuard(std::function destructor) : destructor_(std::move(destructor)) {} + + ~ResourceGuard() { + destructor_(); + } +}; + +struct Dimension final { + Dimension() : is_unknown(true), is_int(false), dim(-1) {} + explicit Dimension(std::string param) : is_unknown(false), is_int(false), dim(-1), param(std::move(param)) {} + explicit Dimension(int64_t dim) : is_unknown(false), is_int(true), dim(dim) {} + + bool is_unknown; + bool is_int; + int64_t dim; + std::string param; +}; + +enum class AttributeKind : uint8_t { + // float, float list, int, int list, string, string list, + // tensor, tensor list, subgraph, subgraph list. type proto, type proto list + f, + fs, + i, + is, + s, + ss, + t, + ts, + g, + gs, + tp, + tps +}; + +static inline const char* toString(AttributeKind kind) { + // NOLINTNEXTLINE(modernize-avoid-c-arrays) + static constexpr const char* names[] = {"f", "fs", "i", "is", "s", "ss", "t", "ts", "g", "gs", "tp", "tps"}; + ONNX_ASSERT(size_t(kind) < std::size(names)) + return names[static_cast(kind)]; +} + +struct AttributeValue { + explicit AttributeValue(Symbol name) : name(name) {} + using Ptr = std::unique_ptr; + Symbol name; + virtual AttributeKind kind() const = 0; + virtual Ptr clone() const = 0; + virtual ~AttributeValue() = default; +}; + +template +struct ScalarAttributeValue final : public AttributeValue { + using ConstructorType = const T&; + using ValueType = T; + ScalarAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(std::move(value_)) {} + ValueType& value() { + return value_; + } + Ptr clone() const override { + return std::make_unique(name, value_); + } + AttributeKind kind() const override { + return Kind; + } + + private: + ValueType value_; +}; + +template +struct VectorAttributeValue final : public AttributeValue { + using ConstructorType = const std::vector&&; + using ValueType = std::vector; + VectorAttributeValue(Symbol name, ValueType value_) : AttributeValue(name), value_(std::move(value_)) {} + ValueType& value() { + return value_; + } + AttributeKind kind() const override { + return Kind; + } + std::unique_ptr clone() const override { + return std::make_unique(name, ValueType(value_)); + } + + private: + ValueType value_; +}; + +using FloatAttr = ScalarAttributeValue; +using FloatsAttr = VectorAttributeValue; +using IntAttr = ScalarAttributeValue; +using IntsAttr = VectorAttributeValue; +using StringAttr = ScalarAttributeValue; +using StringsAttr = VectorAttributeValue; +using TensorAttr = ScalarAttributeValue; +using TensorsAttr = VectorAttributeValue; +using GraphAttr = ScalarAttributeValue, AttributeKind::g>; +using GraphsAttr = VectorAttributeValue, AttributeKind::gs>; +using TypeProtoAttr = ScalarAttributeValue; +using TypeProtosAttr = VectorAttributeValue; + +// CRTP so that Node which inherits Attributes can be return for +// method chaining e.g: +// Node * n = g->create(kSelect)->set_i(kOffset,3)->set_f(kValue,3.5); +// we return Derived* pointers because Nodes are normally held as pointers. +template +struct Attributes { + // NOLINTNEXTLINE(bugprone-crtp-constructor-accessibility) + Attributes() = default; + + void copyAttributes(const Attributes& rhs) { + values_.clear(); + values_.reserve(rhs.values_.size()); + for (const auto& i : rhs.values_) { + values_.push_back(i->clone()); + } + } + bool hasAttribute(Symbol name) const { + return find(name, false) != values_.end(); + } + AttributeKind kindOf(Symbol name) const { + return (*find(name, true))->kind(); + } + Derived* removeAttribute(Symbol name) { + values_.erase(find(name, true)); + return This(); + } + bool hasAttributes() const { + return !values_.empty(); + } + // The names are returned in order, since name actually is the index. + std::vector attributeNames() const { + std::vector names; + names.reserve(values_.size()); + for (const auto& a : values_) + names.push_back(a->name); + return names; + } + +#define CREATE_ACCESSOR(Kind, method) \ + Derived* method##_(Symbol name, Kind##Attr::ConstructorType v) { \ + return set(name, std::forward(v)); \ + } \ + const Kind##Attr::ValueType& method(Symbol name) const { \ + return get(name); \ + } + CREATE_ACCESSOR(Float, f) + CREATE_ACCESSOR(Floats, fs) + CREATE_ACCESSOR(String, s) + CREATE_ACCESSOR(Strings, ss) + CREATE_ACCESSOR(Int, i) + CREATE_ACCESSOR(Ints, is) + CREATE_ACCESSOR(Tensor, t) + CREATE_ACCESSOR(Tensors, ts) + CREATE_ACCESSOR(Graph, g) + CREATE_ACCESSOR(Graphs, gs) + CREATE_ACCESSOR(TypeProto, tp) + CREATE_ACCESSOR(TypeProtos, tps) + +#undef CREATE_ACCESSOR + + private: + Derived* This() { + return static_cast(this); + } + template + Derived* set(Symbol name, typename T::ConstructorType v) { + auto it = find(name, false); + auto nv = std::make_unique(name, std::forward(v)); + if (it == values_.end()) { + values_.push_back(std::move(nv)); + } else { + *it = std::move(nv); + } + return This(); + } + template + typename T::ValueType& get(Symbol name) const { + auto it = find(name, true); + T* child = static_cast(it->get()); + return child->value(); + } + using AVPtr = AttributeValue::Ptr; + // NB: For determinism, we use a vector rather than a hash map. This does + // mean that lookups are O(n), so you shouldn't use Attributes to store + // a big pile of messages. + std::vector values_; + using iterator = std::vector::iterator; + iterator find(Symbol name, bool required) { + auto it = std::find_if(values_.begin(), values_.end(), [&](const AVPtr& v) { return v->name == name; }); + ONNX_ASSERT(!required || it != values_.end()) + return it; + } + using const_iterator = std::vector::const_iterator; + const_iterator find(Symbol name, bool required) const { + auto it = std::find_if(values_.begin(), values_.end(), [&](const AVPtr& v) { return v->name == name; }); + ONNX_ASSERTM( + !required || it != values_.end(), + "%s:%u: %s: required undefined attribute '%s'", + __FILE__, + __LINE__, + __func__, + name.toString()) + return it; + } +}; + +// Each use is represented by this type, see Node::uses() +// 'user' is the consumer of the value, offset is the index into +// 'user's input this where the produces will be found. +struct Use final { + Use(Node* user, size_t offset) : user(user), offset(offset) {} + Node* user; + size_t offset; +}; + +static inline bool operator==(const Use& a, const Use& b) { + return a.user == b.user && a.offset == b.offset; +} + +// the list types are intentionally simple, but we type-def +// them here so if we need to change them, refactoring will be easier +using node_list = std::vector; +using value_list = std::vector; +using use_list = std::vector; +using NodeKind = Symbol; + +struct Value final { + ONNX_DISALLOW_COPY_AND_ASSIGN(Value); + Value(Node* node_, size_t offset_); + Value(Value&&) = default; + Value& operator=(Value&&) = default; + ~Value() = default; + + private: + friend struct Node; + friend struct Graph; + Node* node_; + size_t offset_; + size_t unique_ = 0; // unique id + size_t stage_ = 0; // 0-forward, 1-backward, 2-double-backward,... + use_list uses_in_current_graph_; + bool has_unique_name_{false}; + std::string unique_name_; + int32_t elem_type_{ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED}; + bool has_sizes_{false}; + std::vector sizes_; + std::unique_ptr type_; + + public: + Value* setElemType(int32_t elem_type) { + elem_type_ = elem_type; + return this; + } + int32_t elemType() const { + return elem_type_; + } + bool has_sizes() const { + return has_sizes_; + } + Value* setSizes(std::vector sizes) { + has_sizes_ = true; + sizes_ = std::move(sizes); + return this; + } + Value* wipeSizes() { + has_sizes_ = false; + sizes_ = std::vector(); + return this; + } + const std::vector& sizes() const { + return sizes_; + } + size_t unique() const { + return unique_; + } + bool has_unique_name() const { + return has_unique_name_; + } + std::string uniqueName() const { + if (has_unique_name()) + return unique_name_; + return toVarName(unique()); + } + Value* setUniqueName(const std::string& name, bool update_related_names = true); + Value* setStage(size_t s) { + stage_ = s; + return this; + } + size_t stage() const { + return stage_; + } + Node* node() { + return node_; + } + size_t offset() const { + return offset_; + } + const Node* node() const { + return node_; + } + Graph* owningGraph(); + const Graph* owningGraph() const; + use_list uses() const; + + // Replaces all uses of this node with 'newValue'. + // + // Given: %3 = f(%1, %2) + // %4 = g(%3) + // %5 = h(%3, %3) + // Execute: %3.replaceAllUsesWith(%6) + // Result: %3 = f(%1, %2) + // %4 = g(%6) + // %5 = h(%6, %6) + void replaceAllUsesWith(Value* newValue); + + Value* copyMetadata(const Value* from) { + setElemType(from->elemType()); + setSizes(from->sizes()); + if (from->has_unique_name()) { + setUniqueName(from->uniqueName()); + } + return this; + } + + std::unique_ptr& type() { + return type_; + } +}; + +struct Node : public Attributes { + ONNX_DISALLOW_COPY_AND_ASSIGN(Node); + friend struct Graph; + friend struct Value; + friend graph_node_list; + friend const_graph_node_list; + friend graph_node_list_iterator; + friend const_graph_node_list_iterator; + + private: + // each node but Return/Param + // is associated with exactly one place in the node list... + // of the graph_ + // this circular is a doubly-linked list, the Return node is used as the sentinel for the beginning and end of the + // list such that the list never has null pointers next_in_graph[0] is next pointer next_in_graph[1] is prev pointer + // using an array to allow the same iterator class for forward and reverse node lists + // This list represents a topological sort + + std::array next_in_graph{nullptr, nullptr}; + Node*& next() { + return next_in_graph[kNextDirection]; + } + Node*& prev() { + return next_in_graph[kPrevDirection]; + } + Node* const& next() const { + return next_in_graph[kNextDirection]; + } + Node* const& prev() const { + return next_in_graph[kPrevDirection]; + } + + const NodeKind kind_; + std::vector inputs_; + std::vector outputs_; + Graph* graph_; + size_t stage_; + bool has_name_{false}; + std::string name_; + bool has_domain_{false}; + std::string domain_; + bool has_doc_string_{false}; + std::string doc_string_; + bool has_overload_{false}; + std::string overload_; + + protected: + Node(Graph* graph_, NodeKind kind_); // defined after graph + + public: + bool has_name() const { + return has_name_; + } + const std::string& name() const { + return name_; + } + void setName(std::string name) { + has_name_ = true; + name_ = std::move(name); + } + bool has_domain() const { + return has_domain_; + } + const std::string& domain() const { + return domain_; + } + void setDomain(std::string domain) { + has_domain_ = true; + domain_ = std::move(domain); + } + bool has_overload() const { + return has_overload_; + } + const std::string& overload() const { + return overload_; + } + void setOverload(std::string overload) { + has_overload_ = true; + overload_ = std::move(overload); + } + bool has_doc_string() const { + return has_doc_string_; + } + const std::string& docString() const { + return doc_string_; + } + void setDocString(std::string doc_string) { + has_doc_string_ = true; + doc_string_ = std::move(doc_string); + } + NodeKind kind() const { + return kind_; + } + Graph* owningGraph() { + return graph_; + } + const Graph* owningGraph() const { + return graph_; + } + size_t stage() const { + return stage_; + } + Node* setStage(size_t s) { + stage_ = s; + return this; + } + // NB: This returns an ArrayRef; that means that it will + // get invalidated if you resize inputs (e.g., using addInput) + // We can't return a std::vector& because there's no + // way to soundly cast to std::vector (an insane + // implementation of std::vector could make this representationally + // different.) + ArrayRef inputs() { + return inputs_; + } + ArrayRef inputs() const { + // Vectors are not convertible in const-ness of elements, but + // raw pointers are. + return {inputs_.data(), inputs_.size()}; + } + // NB: This returns an ArrayRef; that means that it will + // get invalidated if you resize inputs (e.g., using addInput) + // We can't return a std::vector& because there's no + // way to soundly cast to std::vector (an insane + // implementation of std::vector could make this representationally + // different.) + ArrayRef outputs() { + return outputs_; + } + ArrayRef outputs() const { + // Vectors are not convertible in const-ness of elements, but + // raw pointers are. + return {outputs_.data(), outputs_.size()}; + } + bool hasUses() const { + for (const auto* o : outputs()) { + if (!o->uses().empty()) + return true; + } + return false; + } + void replaceAllUsesWith(Node* n) { + ONNX_ASSERT(outputs().size() == n->outputs().size()) + size_t nOutputs = outputs().size(); + for (size_t i = 0; i < nOutputs; i++) { + outputs()[i]->replaceAllUsesWith(n->outputs()[i]); + } + } + // lots of things like chunk have a single input or single output, so we have a + // helper to make accessing it easier + Value* input() { + ONNX_ASSERT(inputs_.size() == 1) + return inputs_.at(0); + } + Value* output() { + ONNX_ASSERT(outputs_.size() == 1) + return outputs_.at(0); + } + const Value* input() const { + ONNX_ASSERT(inputs_.size() == 1) + return inputs_.at(0); + } + const Value* output() const { + ONNX_ASSERT(outputs_.size() == 1) + return outputs_.at(0); + } + // Access a particular input. This is a checked index. + Value* input(size_t i) { + return inputs_.at(i); + } + const Value* input(size_t i) const { + return inputs_.at(i); + } + + // Graphs + + // Note [Topological invariant] + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // We always maintain an up-to-date topological ordering of all nodes via + // the next()/prev() links. All transformations to graphs must preserve + // this topological ordering: for example, it is only valid to 'addInput' + // with an input which is topologically before the current node. + // + // Usually, it is obvious whether or not topological order is maintained; + // for example, if you are adding nodes to the end of the topsort, it's + // impossible for them to refer to inputs that are not in the topsort. + // If it is not obvious, please comment accordingly. + + // Add 'node' as an input to 'this' at the end of existing + // arguments. Returns the added node for ease of chaining. + // + // Given: %3 = f(%1, %2) + // Execute: %3.addInput(%4) + // Result: %3 = f(%1, %2, %4) + Value* addInput(Value* node) { + ONNX_ASSERT(graph_ == node->owningGraph()) + node->uses_in_current_graph_.emplace_back(this, inputs_.size()); + inputs_.push_back(node); + return node; + } + + // Replace the input of 'this' at position 'i' with + // 'newValue', returning the old node. + // + // Given: %3 = f(%1, %2) + // Execute: %3.replaceInput(1, %4) + // Result: %3 = f(%1, %4) + Value* replaceInput(size_t i, Value* newValue) { + ONNX_ASSERT(newValue->owningGraph() == graph_) + Value* old = dropInput(i); + inputs_[i] = newValue; + newValue->uses_in_current_graph_.emplace_back(this, i); + return old; + } + + // Replace all occurrences of 'from' in the inputs of this + // node with 'to'. Corresponds to llvm's replaceUsesOfWith. + // + // Given: %3 = f(%1, %2, %1) + // Execute: %3.replaceInputWith(%1, %4) + // Result: %3 = f(%4, %2, %4) + void replaceInputWith(Value* from, Value* to) { + ONNX_ASSERT(from->owningGraph() == graph_) + ONNX_ASSERT(to->owningGraph() == graph_) + size_t i = 0; + for (const auto* input : inputs()) { + if (input == from) + replaceInput(i, to); + i++; + } + } + + Value* addOutput() { + outputs_.push_back(new Value(this, outputs_.size())); + return outputs_.back(); + } + + void eraseOutput(size_t i); + + // Insert unattached 'this' node after 'n' in the topological order. + // Returns this (for chaining). + // + // Given: %3 = f(%1, %2) + // %4 = g(%3) + // and unattached: %5 = h(%1) + // Execute: %5.insertBefore(%4) + // Result: %3 = f(%1, %2) + // %5 = h(%1) + // %4 = g(%3) + Node* insertBefore(Node* n) { + ONNX_ASSERT(n->inGraphList()) + insertAfter(n->prev()); + return this; + } + + // Insert unattached 'this' node after 'n' in the topological order. + // Returns this (for chaining). + // + // Given: %3 = f(%1, %2) + // %4 = g(%3) + // and unattached: %5 = h(%1) + // Execute: %5.insertAfter(%4) + // Result: %3 = f(%1, %2) + // %4 = g(%3) + // %5 = h(%1) + Node* insertAfter(Node* n) { + ONNX_ASSERT(!inGraphList() && n->inGraphList()) + Node* next = n->next(); + n->next() = this; + this->prev() = n; + this->next() = next; + next->prev() = this; + return this; + } + + // Move 'this' (already in the graph) after 'n' in the topological order. + // + // Given: %2 = f(%1) + // %3 = g(%1) + // Execute: %2.moveAfter(%3) + // Result: %3 = g(%1) + // %2 = f(%1) + // + void moveAfter(Node* n) { + removeFromList(); + insertAfter(n); + } + + // Move a node 'n' (already in the graph) before 'this' in the topological order. + // + // Given: %2 = f(%1) + // %3 = g(%1) + // Execute: %3.moveBefore(%2) + // Result: %3 = g(%1) + // %2 = f(%1) + void moveBefore(Node* n) { + removeFromList(); + insertBefore(n); + } + + // Remove the input at 'i' from this node. + // + // WARNING: This is O(n) in the number of inputs, so avoid repeatedly calling + // removeInput. + // + // Given: %3 = f(%1, %2) + // Execute: %3.removeInput(1) + // Result: %3 = f(%1) + void removeInput(size_t i) { + dropInput(i); + // everything after this input shifts left, + // so we need to update their use offsets to match + for (size_t j = i + 1; j < inputs_.size(); j++) { + auto it = findUseForInput(j); + it->offset--; + } + inputs_.erase(inputs_.begin() + i); + } + + // Remove all inputs from a node. + // + // Given: %3 = f(%1, %2) + // Execute: %3.removeAllInputs() + // Result: %3 = f() + void removeAllInputs() { + for (size_t i = 0; i < inputs().size(); ++i) + dropInput(i); + inputs_.clear(); + } + + // Check whether this node is before node n in the graph. + bool isBefore(const Node* n); + + // iterators of the node list starting at this node + // useful for resuming a search starting at this node + graph_node_list_iterator iterator(); + graph_node_list_iterator reverseIterator(); + const_graph_node_list_iterator iterator() const; + const_graph_node_list_iterator reverseIterator() const; + + // Remove 'this' from the instruction list and deallocate it. + // + // Invariant: no outputs of 'this' may have any uses. + // + // Given: %2 = f(%1) + // %3 = g(%1) + // Execute: %2.destroy() + // Result: %3 = g(%1) + void destroy(); + + // Dynamically cast this node to the subclass indicated by the + // template variable, returning nullptr if the cast is invalid.. + // + // Example usage: if(auto s = n.cast