Die Vision eines intelligenten Mediaplayers...

[DIET3RIX]

Nach dem Schreiben hatte ich auch eine ähnliche Idee
Ggfs. eine ID als Hash aus Pfad inkl. Dateinamen erstellen? Wird die Datei umbenannt ist die ID pfutsch. Dies kommt aber bestimmt nicht so oft vor, wie das erneute einlesen

Den Player hatte ich mal vor ca. einem Jahr installiert. Soweit ich das noch in Erinnerung habe, hat es mich gestört dass der Player so langsam war und die DB so oft gecrash ist (lag evtl. am Rechner). Außerdem haben die Multimedia Tasten nicht funktioniert.

[Mithrandir]

Zitat von DIET3RIX:

Ggfs. eine ID als Hash aus Pfad inkl. Dateinamen erstellen?

Könnte man machen. Ich würde aber nicht den kompletten Pfad nutzen. Wenn ich die Datei verschiebe, dann ist der Aufwand auch hinfällig. Vielleicht eher eine Kombination aus Künstler/Titel/Dateiname..

[DIET3RIX]

Ist an dieser Stelle etwas schwierig....
Was ist wenn du die Daten nicht auslesen kannst oder wenn diese nicht vorhanden sind

[stahli]

Habe gerade Werbung von magix bekommen.
Vielleicht interessiert das ja in irgend einer Form...

[Mithrandir]

Danke, mufin und dessen "Klanguniversum" kenne ich. Für meinen Player plane ich etwas ähnliches, allerdings nicht dreidimensional. Soll ja Menschen geben, die ein Problem damit haben, sich im dreidimensionalen Raum zu bewegen.

[Mithrandir]

Sodila, da ich nun ein Ergebnis vorzuweisen habe, ist jetzt Brainstorming gefragt. Der Fingerprint eines Liedes sieht wie folgt aus:

Code:

    [Serializable]
    public class SCMS
    {
        public Vector mean = null;
        public CovarianceMatrix cov = null;
        public CovarianceMatrix icov = null;
    }

Dabei werden noch folgende Klassen genutzt:

Code:

    [Serializable]
    public class CovarianceMatrix
    {
        public float[] d;
        public int dim;
    }

    public class Vector : Matrix
    {
        /// <summary>
        /// Constructor for this Class.
        /// </summary>
        /// <param name="rows"></param>
        public Vector(int rows) : base(rows, 1)
        {
        }
    }

    [Serializable]
    public class Matrix
    {
        #region Properties
        public float[,] d;                 //2-dimensional array with the values for the matrix      
        public int columns;                 //count of columns
        public int rows;                    //count of rows
        #endregion
    }

Wie ich die Daten speichern kann, ist klar. Dank .NET kann man Klassen super serialisieren. Aber die Berechnung der Abstände muss ich imho immernoch in C# machen. Oder? Im Programm mache ich das über eine Kullback - Leibler - Divergenz.

Code:

    /** Utility class storing a cache and Configuration variables for the Scms
     *  distance computation.
     */

    public class ScmsConfiguration
    {
        private int dim;
        private int covlen;
        private float[] mdiff;
        private float[] aicov;

        public ScmsConfiguration (int dimension)
        {
            dim = dimension;
            covlen = (dim*dim + dim)/2;
            mdiff = new float[dim];
            aicov = new float[covlen];
        }

        public int Dimension {
            get { return dim; }
        }

        public int CovarianceLength {
            get { return covlen; }
        }

        public float [] AddInverseCovariance {
            get { return aicov;  }
        }

        public float[] MeanDiff {
            get {  return mdiff; }
        }
    }

       /** Function to compute the spectral distance between two song models.
         *  This is a fast implementation of the symmetrized Kullback Leibler
         *  Divergence.
         */
        public static float Distance(ref SCMS s1, ref SCMS s2, ScmsConfiguration c)
        {
            float val = 0;

            unsafe
            {
                int i;
                int k;
                int idx = 0;
                int dim = c.Dimension;
                int covlen = (dim * (dim + 1)) / 2;
                float tmp1;

                fixed (float* s1cov = s1.cov.d, s2icov = s2.icov.d,
                        s1icov = s1.icov.d, s2cov = s2.cov.d,
                        s1mean = s1.mean.d, s2mean = s2.mean.d,
                        mdiff = c.MeanDiff, aicov = c.AddInverseCovariance)
                {

                    for (i = 0; i < covlen; i++)
                    {
                        val += s1cov[i] * s2icov[i] + s2cov[i] * s1icov[i];
                        aicov[i] = s1icov[i] + s2icov[i];
                    }

                    for (i = 0; i < dim; i++)
                    {
                        mdiff[i] = s1mean[i] - s2mean[i];
                    }

                    for (i = 0; i < dim; i++)
                    {
                        idx = i - dim;
                        tmp1 = 0;

                        for (k = 0; k <= i; k++)
                        {
                            idx += dim - k;
                            tmp1 += aicov[idx] * mdiff[k];
                        }
                        for (k = i + 1; k < dim; k++)
                        {
                            idx++;
                            tmp1 += aicov[idx] * mdiff[k];
                        }
                        val += tmp1 * mdiff[i];
                    }
                }
            }

            // FIXME: fix the negative return values
            //val = Math.Max(0.0f, (val/2 - s1.cov.dim));
            val = val / 2 - s1.cov.dim;

            return val;
        }

Als Ergebnis erhalte ich dabei einen Float-Wert.
Der Code stammt aus dem Mirage-Plugin für Banshee und steht unter GPL, nicht, dass sich da einer wundern tut.

Ideen sind jederzeit willkommen.

[Mithrandir]

Ok, ich habe jetzt konkrete Vorstellungen und auch schon teilweise so umgesetzt.

Ich speichere zu jedem Lied die folgenden Werte:

• Laut
• Leise
• Fröhlich
• Traurig
• Tanzbarkeit

Wie ich die Referenzen ermittel, erkläre ich, sobald das Programm fertig ist. Gleichzeitig setze ich auch die Idee um, die ich mit der Shuffle-Funktion hatte. Mir ist noch nicht ganz klar, wie ich die Relationen der Lieder untereinander am effektivsten Abbilde bzw. wie ich die SQL-Datenbank dazu bringe, die Relationen abzubilden.

Für die Shufflefunktion muss ich die Gewichtung der Verbindung zwischen zwei Liedern sowie deren letzte Änderung speichern. In einer normalen SQLite-Datenbank habe ich ein Tabellenschema nach Schema F erstellt. Wie wir bereits im Laufe des Threads festgestellt haben, kommen bei 5000 Liedern ungefähr 12,5 Mio Zeilen raus. Das Anlegen der Daten dauert ungefähr 20 Minuten. Die Datenbank wird 600 MB groß.

Olli, du schlägst vor, SQLite die Relationen abbilden zu lassen. Wie würde das funktionieren? Irgendwie fehlt mir noch ein greifbarer Anstoß.

Alternativen gehen von der Datenbank weg und schlagen ein natives Datenformat vor. Allerdings mache ich mir hier über die Performance sorgen. Ich werde ich aber nochmal selbst genauer nachforschen...

[BUG]

Zitat von Mithrandir:

Wie würde das funktionieren? Irgendwie fehlt mir noch ein greifbarer Anstoß.

Vielleicht so (ist ja ne n:m-Relation). Oder meintest du das mit Schema F?

Code:

Tabelle: Lied
-------------
ID
Dateiname
Laut
Leise
Fröhlich
Traurig
Tanzbarkeit

Code:

Tabelle: Relation
-------------
ID1 -> Lied
ID2 -> Lied
Verbindung
letzteÄnderung

Ich habe immer noch die Hoffnung, dass du eventuell gar nicht alle Relationen speichern brauchst. Vielleicht könntest du sie unter einem bestimmten Schwellenwert wegschmeißen.

Nur zur Versicherung: die Relationen berechnest du nicht aus Eigenschaften der Lieder?

EDIT:

Zitat von Mithrandir:

Ich muss aber den Fingerprint pro Lied nur einmal berechnen. Die eigentliche Rechenoperation, die zwei Lieder miteinander vergleicht, braucht gerade mal 0,002 Sekunden. Da dauert das Laden der Daten aus der DB fast länger.

Wenn du die Relationen nur aus den Fingerprints erzeugst, bräuchtest du sie eigentlich nicht zu speichern (wenn ich das richtig verstanden habe).

[QuickAndDirty]

Zitat von Mithrandir:

Ich hab mal einen kleinen Test gemacht, und ich glaube, ich weiß, warum dieses Feature noch kein Player implementiert hat.

Gehen wir davon aus, dass wir 5000 Lieder auf der Festplatte haben (jahrzehntelange Sammelwut). Baut man für die Initialisierung einen Graphen auf, bei dem jedes Lied mit jedem eine Verknüpfung hat, so kommt man auf die niedliche Datenmenge von insgesamt 25.000.000 Verbindungen. Das bedeutet, dass ich, halte ich diese Menge im Speicher vor, einen Speicherverbrauch von über eine Gigabyte habe. Serialisiere ich meine Liste in eine XML-Datei, ist diese 2,8 Gigabyte groß. Das Hauptproblem ist also weniger die Rechenleistung, sondern eher die riesigen Datenmengen, die anfallen.

Freiwillige bitte zuerst melden, die hier einen Lösungsvorschlag hätten.

hilft dir das hier
http://en.wikipedia.org/wiki/Music_Genome_Project

attribute
http://en.wikipedia.org/wiki/List_of...ect_attributes

dieser link geht nur durch einen US- Proxy
http://www.pandora.com

Habe es damals als es noch in Deutschland ging intesiv genutzt...du nimmst eine Band oder einen Song und er spielt immer so ähnliche lieder von Stil her. Dabei entdeckt man auch mal neue bands &c.

[Mithrandir]

Zitat von BUG:

Nur zur Versicherung: die Relationen berechnest du nicht aus Eigenschaften der Lieder?

Nein, prinzipiell nicht. Der Wert dieser Relationen richtet sich danach, wie oft das Lied im Verhältnis zu anderen Liedern gehört wird, in welcher Reihenfolge, wie oft welche Paare auftreten etc. Gleichzeitig wollte ich aber auch schon eine Vorgewichtung vornehmen, um Lieder mit ähnlichen Eigenschaften (Laut, Leise, Fröhlich, Traurig, Tanzbarkeit) möglichst nah beieinander zu haben. Wobei ich das eigentlich auch dynamisch machen kann, sprich berechnen. Geht ja recht schnell. Und eigentlich brauche ich ja auch nur die Relationen abspeichern, die auch wirklich benutzt werden. Zwar besteht dann immer noch die theoretische Möglichkeit, dass der Nutzer bei 5000 Liedern wirklich alle 12,5 Millionen Kombinationen durchgehört hat, aber... naja, wirklich wahrscheinlich ist das nicht.

@QuickAndDirty: Danke, Pandora ist mir schon geläufig, allerdings nicht die Seite mit den Attributen. Danke für den Hinweis...