def __init__(self, punto, pnt_ref, metadata=None):
try:
# Metadata
self.metadata = metadata
# Se guardan las coordenadas originales
self.Coords = punto[0:2]
except:
pass
# p.ClusterId = UNCLASSIFIED;
self.ClusterId = "UNCLASSIFIED"
# p.dist = Distance(p,r)
self.dist = Distance(punto[0:2], pnt_ref[0:2])
# p.NeighborsNo = 1
self.NeighborsNo = 1
# p.Border = vacio
self.Border = []
def TI_Backward_Neighborhood(conj_puntos, pto, Eps):
seeds = {}
backwardThreshold = pto.dist - Eps
# Hay que declarar la lista a recorrer.
# Primero se encuentra el indice donde esta el elemento "p"
# Se seleccionan los elementos desde el inicio hasta el elemento "p"
# Y finalmente se da vuelta
try:
q = conj_puntos[pto.previous]
while q.dist > backwardThreshold:
if Distance(q.Coords, pto.Coords) <= Eps:
seeds[q] = None
q = conj_puntos[q.previous]
except KeyError:
pass
# Se devuelve el listado con las semillas.
return seeds
def build_config(args, nfeat: int, nclass: int) -> cf.LossConfig:
"""Create a configuration object for a given loss with
a given configuration of hyper-parameters.
:param args: script argument object
:param nfeat: number of features
:param nclass: number of classes
:return: a `LossConfig` for the appropriate loss and hyper-parameters
"""
distance = Distance.from_name(args.distance)
if args.loss == 'softmax':
return cf.SoftmaxConfig(nfeat, nclass)
elif args.loss == 'contrastive':
print(f"[Margin: {args.margin}]")
return cf.ContrastiveConfig(margin=args.margin,
distance=distance,
size_average=args.size_average,
online=True)
elif args.loss == 'triplet':
sampling = build_triplet_strategy(args.triplet_strategy,
args.semihard_negatives)
return cf.TripletConfig(scaling=args.loss_scale,
distance=distance,
size_average=args.size_average,
online=True,
sampling=sampling)
elif args.loss == 'arcface':
print(f"[Margin: {args.margin}]")
return cf.ArcFaceConfig(nfeat,
nclass,
margin=args.margin,
s=args.loss_scale)
elif args.loss == 'center':
return cf.CenterConfig(nfeat,
nclass,
lweight=args.loss_scale,
distance=distance)
elif args.loss == 'coco':
return cf.CocoConfig(nfeat, nclass, alpha=args.loss_scale)
else:
raise ValueError(
f"Loss function should be one of: {constants.LOSS_OPTIONS_STR}")
def TI_Forward_Neighborhood(conj_puntos, p, Eps):
""" ."""
seeds = []
forwardThreshold = p.dist + Eps
# Hay que declarar la lista a recorrer.
# Primero se encuentra el indice donde esta el elemento "p"
# Se seleccionan los elementos desde el inicio hasta el elemento "p"
# Y finalmente se da vuelta
indice = conj_puntos.index(p)
listado_a_recorrer = conj_puntos[indice + 1:]
# Se recorre el listado recien calculado
for q in listado_a_recorrer:
if q.dist > forwardThreshold:
break
if Distance(q.Coords, p.Coords) <= Eps:
seeds.append(q)
# Se devuelve el listado con las semillas.
return seeds
def TI_Backward_Neighborhood(conj_puntos, pto, Eps):
seeds = []
backwardThreshold = pto.dist - Eps
# Hay que declarar la lista a recorrer.
# Primero se encuentra el indice donde esta el elemento "p"
# Se seleccionan los elementos desde el inicio hasta el elemento "p"
# Y finalmente se da vuelta
indice = conj_puntos.index(pto)
listado_a_recorrer = conj_puntos[:indice]
listado_a_recorrer.reverse()
# Se recorre el listado recien calculado
for q in listado_a_recorrer:
if q.dist < backwardThreshold:
break
if Distance(q.Coords, pto.Coords) <= Eps:
seeds.append(q)
# Se devuelve el listado con las semillas.
return seeds
def TI_Forward_Neighborhood(conj_puntos, p, Eps):
"""
conj_puntos (dict): the key is the order of the instance respect
with the attribute instance, and the value is the instance.
p (instance class clase_punto):
Eps (float): episilon, the parameter given to the algorithm."""
seeds = {}
forwardThreshold = p.dist + Eps
# Hay que declarar la lista a recorrer.
# Primero se encuentra el indice donde esta el elemento "p"
# Se seleccionan los elementos desde el inicio hasta el elemento "p"
# Y finalmente se da vuelta
try:
q = conj_puntos[p.following]
# Se recorre el listado recien calculado
while q.dist < forwardThreshold:
if Distance(q.Coords, p.Coords) <= Eps:
seeds[q] = None
q = conj_puntos[q.following]
except KeyError:
pass
# Se devuelve el listado con las semillas.
return seeds