Das deutsche Python-Forum

def x(s):
  c=0
  for i in s:
    if i == '1': c+=1
  return c

print "\n".join( [hint for hint in hints] )

rayo hat geschrieben:Hi

Du könntest einfach nach der Anzahl Einsen sortieren:

Code: Alles auswählen

def einser_cmd(this, other):
    return cmp(this.count('1'), other.count('1'))

liste.sort(einser_cmd)
print liste

Gruss

*edit*
mh wenn ich das ja genauer anschaue: '01101010' > '01101110', nach welchem Kriterium ist der erste grösser als der zweite?

def calc(s):
  for i in range(len(s)/2):
    v+=int( potenzial(s[i],i )
  for i in range(len(s)/2):
    v+=int( potenzial(reverse(s)[i],i )
  return v
def cmp(s1,s2):
  return calc(s2) - calc(s1)

Panke hat geschrieben:Was genau ist jetzt das Kriterium, wonach sortiert wird?

Panke hat geschrieben:Was genau ist jetzt das Kriterium, wonach sortiert wird?

~= image[i+1]..usw, und damit die Liste sehr schnell kürzer werden würde.
Dabei ist klar, daß der pearsonnr-Koeffizient von '000010000' zu '000101000' ist als zu '111111111'.

Aber vielleicht liege ich ja bereits mit der Überlegung völlig falsch

BlackJack hat geschrieben:Mal davon abgesehen, dass das wieder mal nach einer Hausaufgabe aussieht, wo liegt das Problem wenn MAX_INT überschritten wird? Eine Binärzahl mit 1024 Einsen ist letztendlich gar nicht sooo gross:

Code: Alles auswählen

In [78]: int('1' * 1024, 2)
Out[78]: 17976931348623159077293051907890247336179769789423065727343008115773267
58055009631327084773224075360211201138798713933576587897688144166224928474306394
74124377767893424865485276302219601246094119453082952085005768838150682342462881
473913110540827237163350510684586298239947245938479716304835356329624224137215L

Da kommt Python prima mit klar.

Ansonsten schliesse ich mich der Frage von rayo an.

def reorder_images(images,reverse=False):
    images.sort(key=lambda x: (len(x[1].strip('0')), x[1].count('1')))
    return images

birkenfeld hat geschrieben:Um mal bei der gestellten Aufgabe zu bleiben (ohne zu beurteilen, ob die Anwendung sinnvoll ist):

Code: Alles auswählen

x.sort(key=lambda x: (len(x.strip('0')), x.count('1')))

sollte das gewünschte ergeben, wobei `x` eine Liste mit den einzelnen Zeilen ist.

syracus hat geschrieben: Aber vielleicht liege ich ja bereits mit der Überlegung völlig falsch

def fp(file,threshold=128):
  return list(Image.open(file).resize((160,160),ANTIALIAS).
  filter(ImageFilter.BLUR).convert('L').
  point( lambda p: int(p/threshold) ).
  resize( (16,16) ).getdata() )

- Warum vorher sortieren? Der Algorithmus wird dadurch nur schneller, wenn Du die als "ähnlich" eingeordneten Bilder wegläßt. Ansonsten brauchst Du immer noch alle Permutationen, wenn Du eine akkurate Klassifizierung machen möchtest.

i=0
while i < len(images):
  j=i+1
  while j < len(images):
    cor = compare(images[i],images[j])
    if cor >= threshold:
      # similar found
      del images[j]
    else:
      j+=1
  del images[i]

def compare(i1,i2):
  l=len(i1.data)
  c="".join( map(chr, [ operator.xor( ord(i1.data[i]), ord(i2.data[i]) ) for i in range(l) ]) ).count('1')
  return float(c)/l

syracus hat geschrieben: also der FP wird egtl ganz einfach erstellt.

Code: Alles auswählen

def fp(file,threshold=128):
  return list(Image.open(file).resize((160,160),ANTIALIAS).
  filter(ImageFilter.BLUR).convert('L').
  point( lambda p: int(p/threshold) ).
  resize( (16,16) ).getdata() )

syracus hat geschrieben: Nicht wirklich ein guter Algorithmus, liefert für meine Bilder-Datenbank aber ganz ansehnliche Resultate mit dem pearsonr().

syracus hat geschrieben: Was Kompression und Auflösung angeht, so gebe ich dir recht. allerdings ist der Informationsgehalt der Bilder nach dem obigen convert ausreichend, da diese von meiner Digitcam immer mit dem gleichen Werten skaliert und komprimiert wurden.

syracus hat geschrieben: Die Idee war nun (aber ich denke immer mehr das es wohl eine Schnappsidee war ). Die Liste so um zu sortieren, daß operator.xor möglichst früh hohe Werte für cor ermittelt. Ich habe angenommen, das cor somit immer mehr abnehmen würde und bei unterschreiten eines bestimmten Schwellenwertes von cor hätte ich die innere Schleife abgebrochen.

Langsam sehe ich aber, daß dies wohl nicht sonderlich sinnvoll ist

syracus hat geschrieben: Ich bin mir natürlich auch bewusst, daß es bereits einige fertiger Programme gibt, die diese Aufgabe gut erledigen. Allerdings haben diese einfach eine Problem mit der schieren Menge an Bildern die ich scannen müsste (~ 200000). Zum anderen hat mich das Problem interessiert einen Weg zu finden einen guten Kompromiss zwischen der Qualität des Vergleichs und der Laufzeit zu finden der auf meine Anforderungen zugeschnitten ist

CM hat geschrieben:Hoi syracus,

syracus hat geschrieben: also der FP wird egtl ganz einfach erstellt.

Code: Alles auswählen

def fp(file,threshold=128):
  return list(Image.open(file).resize((160,160),ANTIALIAS).
  filter(ImageFilter.BLUR).convert('L').
  point( lambda p: int(p/threshold) ).
  resize( (16,16) ).getdata() )

Das verstehe ich schon nicht: Du schreibst return bevor der Rest der Funktion abgeschlossen ist? Glaube ich habe einen Blackout.

def fp(file, threshold=128):
  return list(Image.open(file)
              .resize((160, 160), ANTIALIAS)
              .filter(ImageFilter.BLUR)
              .convert('L')
              .point(lambda p: int(p / threshold))
              .resize((16, 16))
              .getdata())