Kombinatorik 1 bis 1 Mapping für Leistungsgruppen ⇐ Python

[Anonymous]

Problembeschreibung
Ich arbeite daran, eine Funktion zu erstellen, die mir eine Definition für eine bestimmte Kombination mehrerer Deskriptoren basiert, die auf einem einzelnen Index basieren.

Code: Select all

X = [feat0,feat1,feat2,feat3,feat4]
< /code>
Eine Liste der zu verwendenden Befugnisse < /p>
pow = [1,2,3]
< /code>
und eine Liste von Gruppengrößen < /p>
sizes = [1,3,5]
< /code>
Eine gültige Ausgabe könnte wie Folgendes aussehen: < /p>
  feat0^2 * feat4^3 * feat1^1

Diese Ausgabe ist gültig, weil feat0 , feat4 und feat1 in x existieren, ihre Befugnisse in POW existieren, und die Anzahl der kombinierten Funktionen beträgt in den Größen . Befugnisse nicht in pow und Kombinationsgrößen nicht in Größen
[*] Kombinationen, die mit einem anderen identisch sind: feat0^2 * feat1^3 und feat1^3 * feat0^2 sind die gleichen
[*] -Kombinationen, die Multiples der gleichen Features enthalten: LED0^1 reichen. feat2^2 ist ungültig

Unter der Haube codiere ich diese Gruppierungen als Listen von Tupeln. So feat0^2 * feat4^3 * feat1^1 würde als [(0,2), (4,3), (1,1)] dargestellt, wobei das erste Element im Tuple der Merkmalsindex ist, und der zweite ist die Macht. i ? Ich möchte die Anzahl möglicher Kombinationen erhalten und in der Lage sein, eine Ganzzahl I an eine Funktion anzuschließen und diese Funktion eine bestimmte Kombination zu generieren.

Code: Select all

X = [0.123, 0.111, 11, -5]
pow = [1,2,3]
sizes = [1,3]

#getting total number of combinations
numCombos = get_num_combos(X,pow,sizes)

#getting a random index corresponding to a grouping
i = random.randint(0, numCombos)

#getting grouping
grouping = generate_grouping(i, X, pow, sizes)

print(grouping)
< /code>
Dies führt zu so etwas wie < /p>
[(0,1), (1,2), (3,1)]
< /code>
Bisher war es nicht zu schwer, die Erzeugung zu ermitteln, wenn es nicht zu schwierig war, die verschiedenen Randfälle zu berücksichtigen, aber ich bin nicht mehr verliert, wie die Randfälle 2 und 3 berücksichtigt werden sollen. Es ist garantiert, dass kein Wert von i 

algebraisch einem anderen Wert von i äquivalent entspricht und dass dieselbe Funktion in einer Gruppierung nicht mehrmals mehrmals angezeigt wird.

Code: Select all

#computes the n choose k of a list and a size
def get_num_groupings(n, k):
return int(math.factorial(n)/(math.factorial(k)*math.factorial(n-k)))

import numpy as np
import bisect

i = 150

n = 5
m = 3
sizes = [1, 3, 5]

#computing the number of elements in each group length
numElements = [m**k * get_num_groupings(n, k) for k in sizes]

#index bins for each group size
bins = list(np.cumsum(numElements))[:-1]

#getting the current group size
binIdx = bisect.bisect_left(bins,i)
curSize = sizes[binIdx]

#adding idx 0 to bins
bins = [0]+bins

#getting the location of i in the bin
z = i - bins[binIdx]

#getting the product index and combination rank
pi = z // m**k
ci = z % m**k

#getting the indexes of the powers
pidx = [(pi // m**(curSize - (num+1)))%m for num in range(curSize)]

#getting the indexes of the features
#TODO cidx = unrank(i, range(n))

Dies basiert auf der Antwort des MAD Physicist . Obwohl ich noch nicht herausgefunden habe, wie ich CIDX erhalten kann. Einige der variablen Namen werden für mein eigenes Verständnis umgeschrieben. Meines Wissens funktioniert diese Implementierung, indem sie die Kombinationen von Variablen logisch trennen und welche Befugnisse sie jeweils haben. Bisher kann ich die Befugnisse aus einem Index i erhalten, und sobald Unrank ausgebügelt ist, sollte ich in der Lage sein, die Indizes zu erhalten, für die Funktionen verwendet werden.