content stringlengths 42 6.51k |
|---|
def dict_minus(d, *keys):
"""Delete key(s) from dict if exists, returning resulting dict"""
# make shallow copy
d = dict(d)
for key in keys:
try:
del d[key]
except:
pass
return d |
def formatUs(time):
"""Format human readable time (input in us)."""
if time < 1000:
return f"{time:.2f} us"
time = time / 1000
if time < 1000:
return f"{time:.2f} ms"
time = time / 1000
return f"{time:.2f} s" |
def rectCenter(rect0):
"""Return the center of the rectangle as an (x, y) coordinate."""
(xMin, yMin, xMax, yMax) = rect0
return (xMin+xMax)/2, (yMin+yMax)/2 |
def NeededPaddingForAlignment(value, alignment=8):
"""Returns the padding necessary to align value with the given alignment."""
if value % alignment:
return alignment - (value % alignment)
return 0 |
def as_pairs_seq(iterable):
"""
Return the given Python iterable as a sequence of nested (item,
next) pairs. No iteration!
"""
itr = iter(iterable)
# Use a sentinel object to indicate the end of iteration rather than
# exception handling because that is more functional in style.
# Since... |
def avgprecision(results):
"""
:param results: List of True/False values
"""
total_points = 0.0
correct = 0.0
for i, p in enumerate(results):
position = i + 1
if p:
correct += 1
points = correct / position
total_points += points
return tot... |
def marginal_coalitions(player, order):
"""
:param player:
:type player: str
:param order:
:type order: list
:return:
:rtype (set, set)
"""
pos_player = order.index(player)
return set(order[:pos_player]), set(order[:pos_player + 1]) |
def _parallelogram_alpha_beta(px, ax, bx, idetidx, idet):
"""
check point is in parallelogram;
please convinced that this point is in the plane of this parallelogram.
p = x + alpha (a-x) + beta (b-x)
p - x = alpha (a-x) + beta (b-x)
px[0] = alpha ax[0] + beta bx[0]
px[1] = alpha ax[1] + be... |
def _ext_id(id):
"""
Extends id with / symbol if necessary
:param id: id to extend
:return: extended id
"""
if id[-1:] != "/":
return id + "/"
return id |
def build_risk_curves(years):
"""Creating lines/curves for risk thresholds on risk assessment graph for critical, moderate, substantial and safe zones
Notes:
Safe zone is categorised as under moderate risk
Args:
years (int): No. of years for analysis
Returns:
... |
def divisibility_by_7(number: int) -> bool:
"""
:type number: int
"""
num = list(map(int, list(str(number))))
num1 = int("".join(list(map(str, num[:-1]))))
num2 = int(num[-1])
return ((num1 - (num2 * 2)) % 7) == 0 |
def scanlist(testlist):
""" Process a testlist file """
tests = [t.strip() for t in testlist if not t.startswith('#')]
return [t for t in tests if t] |
def get_path_to_surface_density_dir(name: str, data_directory: str) -> str:
"""Get the path to the directory where the star formation data should be stored
Args:
name (str): Name of the galaxy
data_directory (str): dr2 data directory
Returns:
str: Path to h1 dir
"""
return ... |
def use_storage(storage_conf: str) -> bool:
"""Evaluates if the storage_conf is defined.
The storage will be used if storage_conf is not None nor "null".
:param storage_conf: Storage configuration file.
:return: True if defined. False on the contrary.
"""
return storage_conf != "" and not stora... |
def get_mismatched_bundles(base, other):
"""
Compares the bundles of two instances and returns the differences as list of dictionary.
"""
result = list()
other_bundles = other[2]
for key, value in base[2].items():
if key in other_bundles:
if not value == other_bundles[key]:
... |
def parse_requirements(requirements):
"""
Returns the list of requirements found in the requirements file
"""
with open(requirements, "r") as req_file:
return [l.strip('\n') for l in req_file if l.strip('\n')
and not l.startswith('#')] |
def calculate_results(sample_data, analysis, mass, dilution_factor=10, correction_factor=10000):
"""Calculate percentage results given raw results,
dilution factor, and analysis type.
Args:
sample_data (dict): A dictionary of sample data.
analysis (str): An analysis to calculate results for ... |
def get_standard_format(seg):
"""
Receives a period of time in seconds, and return a string with time standard format.
HH:MM:SS
"""
# hours
h = int(seg // 3600)
if h > 24:
dias = seg // 86400
seg = seg % 86400
h = int(seg // 3600)
seg = seg % 3600
# mi... |
def decorated_test_task(**kwargs):
"""
Test task, echos back all arguments that it receives.
This one is registered using a decorator
"""
print(f"The decorated test task is being run with kwargs {kwargs} and will echo them back")
return kwargs |
def match(line,keyword):
"""If the first part of line (modulo blanks) matches keyword,
returns the end of that line. Otherwise returns None"""
line=line.lstrip()
length=len(keyword)
if line[:length] == keyword:
return line[length:]
else:
return None |
def h(a, b):
"""Return distance between 2 points"""
return (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2 |
def get_asset_dict(
source_location,
source_name,
target_location="",
target_name=None,
copy_method="copy",
):
"""Helper function to generate asset for a particular file
Args:
source_location (str): path to directory containing source file
source_name (str): filename of sour... |
def unicode_subscript(num):
"""Converts an integer to the unicode subscript representation of that
integer.
Reference
"""
n = str(num)
subscript_dict = {
'0': u'\u2080',
'1': u'\u2081',
'2': u'\u2082',
'3': u'\u2083',
'4': u'\u2084',
... |
def key(data, key_name):
"""
Returns the value in the given key_name of a dict.
"""
return data.get(key_name) |
def check_tx_type(tx: dict, kind: str) -> bool:
"""
:param tx: transaction dictionary
:param kind: string containing tx type
:return: boolean
"""
if tx["events"][0]["kind"] == kind:
return True
return False |
def reverse(in_list1: list) -> list:
"""
Reverse a list
:param in_list1: The input list
:return: the reversed version
"""
if len(in_list1) == 0:
return []
_list = reverse(in_list1[1:])
return _list + [in_list1[0]] |
def parse_phone_numbers(phone_number_string):
"""
Arguments:
phone_number_string {String} -- Phone number or numbers, as input by
the user at registration. Commas separate phone numbers.
Returns:
phone_numbers {List} -- One string element per user phone number.
"""
... |
def merge_parallel_outputs(data):
"""
parallel outputs returns an array of dicts, one from each parallel output. This method combines the dicts into
a single dict.
Args:
data(list(dists): List of dicts
Returns:
(dict) merged dict
"""
merge = {}
for items in data:
... |
def retrieve_file(filename):
"""
Opens a file and returns its contents as a string after
encoding to UTF-8
:param filename:
:return:
"""
with open(filename, 'rb') as f:
original_contents = f.read()
decoded_contents = original_contents.decode('utf-8-sig').encode('utf-8')
retu... |
def split_query(query):
"""
Generate a list of all of the partial
queries for a given complete query
"""
return [query[:i] for i in range(3, len(query) + 1)] |
def _load_method_arguments(name, argtypes, args):
"""Preload argument values to avoid freeing any intermediate data."""
if not argtypes:
return args
if len(args) != len(argtypes):
raise ValueError(f"{name}: Arguments length does not match argtypes length")
return [
arg if hasattr... |
def exponential_1(x,x0,A,tau, offset):
"""
exponential function with one exponent
"""
from numpy import exp
func = A*exp(-(x-x0)/tau)+offset
return func |
def unescape(string: str) -> str:
"""
Remove escaping symbols RediSearch stores for literal tokens.
A SiteConfiguration configures "literal tokens" that indexing and
querying should special-case to support searching with punctuation.
These are tokens like "active-active".
"""
return string.... |
def make_edges(nodes, directed=True):
"""
Create an edge tuple from two nodes either directed
(first to second) or undirected (two edges, both ways).
:param nodes: nodes to create edges for
:type nodes: :py:list, py:tuple
:param directed: create directed edge or not
:type directe... |
def check_file_isvid(filename):
"""
checks if a file has a video extension, accepted files are: '.mp4', '.mpg', '.avi'
:param filename: (str) name of the file
:return: (bool)
"""
list_extensions = ['.mpg', '.MPG', '.mp4', '.MP4', '.AVI', '.avi']
if filename[-4:] in list_extensions:
r... |
def threshold (x):
"""Function to apply to a pixel value to make a threshold operation
args : int
returns int equal to 0 or 255
"""
threshold_1=0
if (x <threshold_1):
return 0
else:
return 255 |
def search(graph, start, target, avoiding=None):
"""Depth-first search through graph for path from start to target avoiding visited nodes"""
# Initialize the set of visited nodes to avoid in the search if not passed as argument
avoiding = {start} if not avoiding else avoiding
for child in graph[start]:
... |
def list_roles(*args):
"""DEPRECATED: Use list"""
return list(*args) |
def shellsplit(text):
"""Very simple shell-like line splitting.
:param text: Text to split.
:return: List with parts of the line as strings.
"""
ret = list()
inquotes = False
current = ""
for c in text:
if c == "\"":
inquotes = not inquotes
elif c in ("\t... |
def parse_idna_test_table(inputstream):
"""Parse IdnaTest.txt and return a list of tuples."""
tests = []
for lineno, line in enumerate(inputstream):
line = line.decode("utf8").strip()
if "#" in line:
line = line.split("#", 1)[0]
if not line:
continue
... |
def strtobool(str_val):
"""Convert a string representation of truth to true (1) or false (0).
True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
are 'n', 'no', 'f', 'false', 'off', and '0'. Raises ValueError if
'val' is anything else.
"""
str_val = str_val.lower()
if str_v... |
def _update_curr_pos(curr_pos, cmd, start_of_path):
"""Calculate the position of the pen after cmd is applied."""
if cmd[0] in 'ml':
curr_pos = [curr_pos[0] + float(cmd[1]), curr_pos[1] + float(cmd[2])]
if cmd[0] == 'm':
start_of_path = curr_pos
elif cmd[0] in 'z':
curr_pos = start_of_path
eli... |
def seq(fr,to,by):
"""An analogous function to 'seq' in R
Parameters:
1. fr: from
2. to: to
3. by: by (interval)
"""
if fr<to:
return range(fr,to+abs(by),abs(by))
elif fr>to:
if by>0:
aseq = range(fr,to-by,-1*by)
else:
aseq = range(fr,... |
def _equals(a, b):
"""Checks recursively if two dictionaries are equal"""
if isinstance(a, dict):
for key in a:
if key not in b or not _equals(a[key], b[key]):
return False
return True
else:
if isinstance(a, bytes):
a = a.decode()
if is... |
def replace_keyword(src: str, rpls: list) -> str:
"""
Replace keyword ::r:: in `src` with provided text in rpls.
"""
replace_count = src.count("::r::")
if replace_count == 0:
return src
length = len(rpls)
replaced = "".join(src) # Make a copy
for text in rpls:
replaced = replaced.replace("::r::", text, 1)
... |
def _le_unpack(byte):
"""Converts little-endian byte string to integer."""
return sum([ b << (8 * i) for i, b in enumerate(byte) ]) |
def transpuesta_matriz_vec(mat):
"""
Funcion que realiza la transpuesta de una matriz o vector complejo.
:param mat: lista que representa la matriz o vector complejo.
:return: Lista que representa la transpues de la matriz o vector complejo.
"""
fila = len(mat)
columnas = len(mat[0])
... |
def _convert_block_indexers_to_array_indexers(block_indexers, chunks):
"""Convert a dict of dask block indexers to array indexers.
Parameters
----------
block_indexers : dict
Dictionary mapping dimension names to slices. The slices
represent slices in dask block space.
chunks : dic... |
def count_keys_less(equal, m):
"""
Supporting function for counting_sort.
"""
less = [0] * m
for j in range(1, m):
less[j] = less[j - 1] + equal[j - 1]
return less |
def shortenFEN(fen):
"""Reduce FEN to shortest form (ex. '111p11Q' becomes '3p2Q')"""
return fen.replace('11111111','8').replace('1111111','7') \
.replace('111111','6').replace('11111','5') \
.replace('1111','4').replace('111','3').replace('11','2') |
def labels_to_generate(epitope_files, ppi_files):
"""
Takes 2 lists of files and extracts the chains for which to generate labels.
"""
all_files = epitope_files + ppi_files
chains = []
for f in all_files:
chain = f.split('.')[0].split('_')[-1]
if not chain in chains:
... |
def aio_s3_key(aio_s3_key_path, aio_s3_key_file) -> str:
"""A valid S3 key composed of a key_path and a key_file
The key component of 's3://{bucket}/{key}' that is composed of '{key_path}/{key_file}';
the key does not begin or end with any delimiters (e.g. '/')
:return: str for the key component of 's3:... |
def get_ids(items):
""" id fields from sorted list-of-dicts """
return tuple(x['id'] for x in items) |
def get_ngrams(sequence, n):
"""
Given a sequence, this function should return a list of n-grams, where each n-gram is a Python tuple.
"""
ngrams = []
# When unigram, manually add START, as algorithm below skips it
if n is 1:
ngrams.append(('START',))
# Loop through corpus
end... |
def position_to_index(v, nelx, nely):
"""
Convert a position vector to the index of the element containing it
"""
return int(v[0]) + int(v[1])*nelx |
def float_or_null(v):
"""Return a value coerced to a float, unless it's a None.
"""
if v is not None:
v = float(v)
return v |
def Devices_field_data(dataArray, deviceIds, inputField):
"""
#Retrieve device stats per device
"""
#get length of retrieved data
dataLength = len(dataArray)
deviceIdsLength = len(deviceIds)
#initalize plotData
plotData = []
#loop through deviceIds and append plotData
for j in... |
def update_active_output_renditions_metric(ml_channel_id, ml_channel_name, ml_channelgroup_names):
"""Update the metrics of the "Active Output Renditions (avg)" dashboard dashboard widget"""
results = []
for groupname in ml_channelgroup_names:
entry = ["MediaLive", "ActiveOutputs", "OutputGroupN... |
def remove_words(text:str, set_of_words):
"""
Removes any words present in the text that are included in the set_of_words
"""
words = text.strip().split()
words = [word for word in words if word not in set_of_words]
return ' '.join(words) |
def basename(file_name):
"""
Extract base name from file_name.
basename("test.e") -> "test"
"""
fileParts = file_name.split(".")
base_name = ".".join(fileParts[:-1])
return base_name |
def m_range(l):
"""
Routine to get magnetic quantum numbers in Orca format
"""
m = [0]
for i in range(l):
m += [(i + 1), -(i + 1)]
return m |
def removeDuplicates(li: list) -> list:
"""
Removes Duplicates from bookmark file
Args:
li(list): list of bookmark entries
Returns:
list: filtered bookmark entries
"""
visited = set()
output = []
for a, b in li:
if a not in visited:
visited.add(a)
... |
def bubbleSort3(nums):
"""
Advanced version, cache the index of swaped element and stop at this index
in the next loop, because the elements behind that are already sorted
:type nums: List[int]
:rtype: List[int]
"""
res = list(nums) # I don't want to change the input list
flag = len(re... |
def toHex(version):
"""Converts a semantic version string to a hex string"""
split = version.split(".")
fullversion = ""
for i, v in enumerate(split, start=0):
fullversion += v.rjust(3, "0")
return hex(int(fullversion)) |
def convert_path(url_rule: str) -> str:
"""
convert "/api/items/<int:id>/" to "/api/items/{id}/"
"""
subs = []
for sub in str(url_rule).split("/"):
if "<" in sub:
if ":" in sub:
start = sub.index(":") + 1
else:
start = 1
sub... |
def get_C(s, i):
"""
get number of smaller letters than s[i].
equiv. first occurence of s[i] in sorted s.
"""
c = s[i]
s = list(sorted(s))
return s.index(c) |
def stateful_flags(rep_restart_wait=None, quorum_loss_wait=None,
standby_replica_keep=None):
"""Calculate an integer representation of flag arguments for stateful
services"""
flag_sum = 0
if rep_restart_wait is not None:
flag_sum += 1
if quorum_loss_wait is not None:
... |
def is_param_constraint_broken(params, const_params):
"""Check param value for breaking constraints: Skip to next if so.
Parameters
----------
params : dict
Dictionary of parameters str identifiers to their values (Not tensors).
const_params : dict
Returns
-------
bool
... |
def need_edit_content(content: str):
""" check need edit by content """
# skip REDIRECT page
if content.startswith("#REDIRECT"):
return False
# skip disambiguation page
if content.find("{{Disambiguation}}") > -1:
return False
if content.find("{{disambiguation}}") > -1:
r... |
def hflip_augment(aug=None, is_training=True, **kwargs):
"""Horizontal flip augmentation."""
del kwargs
if aug is None:
aug = []
if is_training:
return aug + [('hflip', {})]
return aug |
def vehicle_type_and_mav_sys_id(vehicle_id, vehicle_color):
"""Get the vehicle_type and mav_sys_id from the vehicle's id and color."""
# valid MAV_SYS_IDs 1 to 250
# the first 25 vehicles per team are iris
# the second 25 vehicles per team are plane (delta_wing)
vehicle_type = 'iris' if vehicle_id ... |
def theveninTheorem(Vth, Rth, Rl):
"""
In practice that a particular element in a circuit is variable
(usually called the load) while other elements are fixed.
Each time the variable element
is changed, the entire circuit has to be analyzed all over again.
Thevenin's theorem states that a l... |
def endpoint_name(endpoint, interface):
"""Create a single key from an endpoint, interface pair
Args:
endpoint (str): The name of an endpoint
interface (str): The interface on the given endpoint
Returns:
str: A single key combining endpoint and interface
"""
return "%s:%s" ... |
def get_site_url(site):
"""Get a ``site`` URL
:param str site: the site to get URL for
:return: a valid site URL
:raise ValueError: when site is empty, or isn't well formatted
The ``site`` argument is checked: its scheme must be ``http`` or ``https``,
or a :exc:`ValueError` is raised.
If ... |
def mlp_check_dimensions(x, y, ws, bs):
"""
Return True if the dimensions in double_u and beta agree.
:param x: a list of lists representing the x matrix.
:param y: a list output values.
:param ws: a list of weight matrices (one for each layer)
:param bs: a list of biases (one for each lay... |
def absVal(num):
"""
Find the absolute value of a number.
>>absVal(-5)
5
>>absVal(0)
0
"""
if num < 0:
return -num
else:
return num |
def fake_legal_name(vasp):
"""
Given a string representing a VASP's name, return a valid
dictionary for the faked name identifiers
"""
return {
"name_identifiers": [
{
"legal_person_name": vasp,
"legal_person_name_identifier_type": "LEGAL_PERSON_NA... |
def calcOptimalStopLoss(M: float, gain: float, loss: float, chanceCorrect: float) -> float:
"""Calculates the optimal stop loss amount.
Parameters
----------
M : float
The larges OL (Open minus Low) or HO (Hight minus Open) in the history of the data.
gain : float
The average gain ... |
def merge_dicts(dict1, dict2):
"""
Merges all the dictionaries, so in result bag of words can be created.
"""
if len(dict1) < len(dict2):
dict1, dict2 = dict2, dict1
for key, value in dict2.items():
dict1[key] = dict1.get(key, 0) + value
return dict1 |
def bfs(graph, start):
"""
Breadth first search
Args:
graph (dict): graph
start (node): some key of the graph
Time: O(|V| + |E|)
"""
seen = set()
path = []
queue = [start]
while queue:
current = queue.pop(0)
if current not in seen:
seen.ad... |
def parse_variable_char(packed):
""" Map a 6-bit packed char to ASCII """
packed_char = packed
if packed_char == 0:
return ""
if 1 <= packed_char <= 10:
return chr(ord('0') - 1 + packed_char)
elif 11 <= packed_char <= 36:
return chr(ord('A') - 11 + packed_char)
elif 37 <=... |
def flip_case(phrase, to_swap):
"""Flip [to_swap] case each time it appears in phrase.
>>> flip_case('Aaaahhh', 'a')
'aAAAhhh'
>>> flip_case('Aaaahhh', 'A')
'aAAAhhh'
>>> flip_case('Aaaahhh', 'h')
'AaaaHHH'
"""
return ''.join(letter.lower() if letter.lower... |
def mcd(a, b):
"""Restituisce il Massimo Comune Divisore tra a e b"""
if a * b == 0: return 1
if a == b:
return a
elif a > b:
return mcd(a - b, b)
else:
return mcd(b - a, a) |
def selection_sort(seq):
"""Returns a tuple if got a tuple. Otherwise returns a list.
>>> t = (3, 1, 1, 4, -1, 6, 2, 9, 8, 2)
>>> selection_sort(t)
(-1, 1, 1, 2, 2, 3, 4, 6, 8, 9)
>>> l = [9, 9, 3, -1, 14, 67, 1]
>>> selection_sort(l)
[-1, 1, 3, 9, 9, 14, 67]
"""
alist = list(seq)
... |
def isServerAlive(server_ip, active_server_list):
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((server_ip, 22))
return True
except socket.error as e:
return False
"""
if not server_ip:
return False
for server in active_serve... |
def IsMissing(argument):
"""Check if an argument was omitted from a function call
Missing arguments default to the VBMissingArgument class so
we just check if the argument is an instance of this type and
return true if this is the case.
"""
try:
return argument._missing
except Attr... |
def get_starting_points(graph):
""" Use the points with non-zero out degree and don't hang during execution. """
if graph == "testGraph":
return ["1","2"]
elif graph != "friendster":
return ["17", "38", "47", "52", "53", "58", "59", "69", "94", "96"]
else:
# friendster takes a l... |
def check_item_relational(actual, expected):
"""Checks for acceptable lesser or greather values."""
if expected[:1] == '>' and int(actual) >= int(expected[1:]):
return True
elif expected[:1] == '<' and int(actual) <= int(expected[1:]):
return True
elif actual == expected:
return ... |
def bits_list(number):
"""return list of bits in number
Keyword arguments:
number -- an integer >= 0
"""
# https://wiki.python.org/moin/BitManipulation
if number == 0:
return [0]
else:
# binary_literal string e.g. '0b101'
binary_literal = bin(number)
bit... |
def convert_chemformula(string: str) -> str:
"""
Convert a chemical formula string to a matplotlib parsable format (latex).
Parameters
----------
string or Adsorbate: str
String to process.
Returns
-------
str
Processed string.
"""
result = getattr(string, 'form... |
def time2num(year):
"""
Convert year 2 labels
:param year:
:return:
"""
# time1 = [1948, 1952, 1956, 1960, 1964]
# time2 = [1968, 1972, 1976, 1980, 1984, ]
# time3 = [1988, 1992, 1996, 2000, 2004]
# time4 = [2008, 2012, 2016]
time1 = [1948, 1952, 1956] # Eisenhower and truman: mi... |
def add_plus(split_fields):
"""Insert delimiters to convert the list (or pandas Series, etc.)
into a suitable format to be used
Accepted delimiters include a comma (,), a space ( ) or a plus (+).
The default set by cimr is a plus (+).
"""
return '+'.join(map(str, split_fields)) |
def isCharOrDigit(ch: str) -> bool:
"""test if ch is letter or digit or - or _
this is for the gramparser, which can contain words for the recogniser
"""
return ch.isalpha() or ch.isdigit() |
def double_number_with_hint(number: int) -> int:
"""Multiply given number by 2
:param number:
:return:
"""
print("Inside double_number_with_hint()")
return number * 2 |
def naiveFib(n):
"""
Naive implementation of nth Fibonacci number generator
Time complexity - O(1.6^n)
:param n: The nth term
:return: The nth fibonnaci number
"""
if n == 0:
return 0
elif n == 1:
return 1
else:
return naiveFib(n-1) + naiveFib(n-2) |
def is_hashable(object_):
"""
Returns whether the object is hashable.
Parameters
----------
object_ : `Any`
The object to check.
Returns
-------
is_iterable : `bool`
"""
try:
hasher_function = getattr(type(object_), '__hash__')
except AttributeError:... |
def is_metadata(message):
"""Returns true iff the Shadow data stream message contains metadata rather
than a measurement sample
"""
return message.startswith(b'<?xml') |
def GetPatchDeploymentUriPath(project, patch_deployment):
"""Returns the URI path of an osconfig patch deployment."""
return '/'.join(['projects', project, 'patchDeployments', patch_deployment]) |
def remove_typedefs(signature: str) -> str:
"""
Strips typedef info from a function signature
:param signature:
function signature
:return:
string that can be used to construct function calls with the same
variable names and ordering as in the function signature
"""
# r... |
def empty_results(num_classes, num_images):
"""Return empty results lists for boxes, masks, and keypoints.
Box detections are collected into:
all_boxes[cls][image] = N x 5 array with columns (x1, y1, x2, y2, score)
Instance mask predictions are collected into:
all_segms[cls][image] = [...] list ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.