La précision moyenne est supérieure à la discrimination par le code le plus fréquent. La valeur maximale du taux de réponse correcte est d'environ 70%, ce qui est à peu près la même pour les deux méthodes, mais il existe une différence considérable dans la valeur minimale. Le taux de réponse correcte le plus bas pour le code le plus fréquent était de 38%, mais cette méthode est de 50%. De plus, comme auparavant, la précision de classification des chansons en mineur est élevée.

Jetons un coup d'œil à la matrice de confusion ici. Curieusement, certaines clés sont mal classées d'environ 20% pour chaque clé. Ceci est parallèle, qui est une clé avec presque le même code utilisé. Puisque cette méthode de discrimination utilise le nombre de fois où le code a été utilisé, je pense qu'il est naturel de le classer à tort comme une clé parallèle.

Le taux de réponse correcte pour les données fp a considérablement augmenté par rapport à la fois précédente, mais il est d'environ 60%. J'ai examiné les données de classification erronée, mais la plupart d'entre elles ont été mal classées en parallèle. Il s'avère que cette méthode ne fonctionne pas pour la classification des tons parallèles.

2. Classification par apprentissage automatique

Maintenant que vous connaissez la précision basée sur des règles, il est temps d'essayer l'apprentissage automatique. J'essaierai ici aussi quelques méthodes. 2-1. [Discriminate as 24 class classification](## 2-1.24 Class classification) 2-2. [Utiliser la connaissance du domaine pour modifier la conception du problème](## 2-2. Utiliser la connaissance du domaine pour modifier la conception du problème)

Classement 2-1. 24

Il est traité comme un problème de classification de 24 classes avec obéissance. La méthode est la ** régression logistique ** en tant que représentant de l'algorithme de séparation linéaire classique, ** la machine vectorielle de support ** en tant que représentant de l'algorithme de séparation non linéaire, et est la plus puissante en termes de haute précision, de vitesse d'apprentissage élevée et de peu de prétraitement. Utilisez le ** LightGBM ** haut de gamme. Je veux comparer les méthodes, je m'abstiendrai donc d'ajuster les paramètres flashy.

Divisez les données avec train_test_split et plongez-les dans le modèle tel quel. Il n'ajuste pas les hyper paramètres, mais il est défini sur class_weight = balancé. En faisant cela, il sera pondéré par «nombre d'échantillons de la classe correspondante / (nombre de classes * nombre total d'échantillons)».

Retour logistique

Pour le moment, j'ai essayé de jouer avec les paramètres du terme de régularisation, mais comme il n'y avait pas de grande différence, je m'entraîne par défaut. <détails>

for seed in [1, 4, 9, 16, 25]:
    X_train, X_test, y_train, y_test = train_test_split(df[num_cols], df['target_key'], random_state=seed)
    lr = LogisticRegression(class_weight='balanced')
    lr.fit(X_train, y_train)
    y_pred = lr.predict(X_test)

from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import StandardScaler

#1 vs autre classification
svc = SVC(kernel='rbf', class_weight='balanced', verbose=True)
ovr = OneVsRestClassifier(svc)
#Standardisation
sc = StandardScaler()

for seed in [1, 4, 9, 16, 25]:
    X_train, X_test, y_train, y_test = train_test_split(sc.fit_transform(X), y, random_state=seed)
    ovr.fit(X_train, y_train)
    y_pred = ovr.predict(X_test)

import lightgbm as lgbm

for seed in [1, 4, 9, 16, 25]:
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=seed)
    clf = lgbm.LGBMClassifier(class_weight='balanced')
    clf.fit(X_train, y_train)
    y_pred = clf.predict(X_test)

model_1 = lgbm.LGBMClassifier(class_weight='balanced')
model_2 = lgbm.LGBMClassifier(class_weight='balanced')

key_answer = df['key']
diatonic_answer = df['diatonic_type']
type_answer = df['key_type']
X = df[num_cols]
y1 = df['diatonic_type_int']

for seed in [1, 4, 9, 16, 25]:
    #Classification en 12 classes (classification parallèle)
    X_train, X_test, y1_train, y1_test = train_test_split(X, y1, random_state=seed)
    model_1.fit(X_train, y1_train)
    y1_pred = model_1.predict(X_test)
    #Chaîne de caractères (C_Major@A_retour au mineur)
    y1_pred_str = le_d.inverse_transform(y1_pred)
    
    #Classification binaire avec les mêmes données (majeures ou mineures)
    train_index = y1_train.index
    test_index = y1_test.index
    
    y2_train = type_answer[train_index]
    y2_test = type_answer[test_index]
    
    model_2.fit(X_train, y2_train)
    y2_pred = model_2.predict(X_test)
    
    #Intégrer les résultats de la classification en 12 classes et de la classification binaire
    y_pred = []
    for y1_, y2_ in zip(y1_pred_str, y2_pred):
        if y2_ == 1:
            ans = y1_.split('@')[0]
        else:
            ans = y1_.split('@')[1]
        y_pred.append(ans)
    
    y_test = key_answer[test_index]