J'ai vectorisé l'accord de la chanson avec word2vec et je l'ai visualisé avec t-SNE

C'est donc un processus compliqué, mais jetons un coup d'œil au code.

scraping.py

import csv
import glob
import collections
import re
import os

artist = "aiko"
#Répertoire des données
fdir = "chord_data/" + artist + "/"
os.makedirs(fdir,exist_ok=True)
#Type de clé
key_list = ["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"]
#Chiffres romains
rome_list = ["Ⅰ","#I","Ⅱ","#Ⅱ","Ⅲ","Ⅳ","#Ⅳ","Ⅴ","#Ⅴ","Ⅵ","#Ⅵ","Ⅶ"]
#Code diatonique
dtnc_chord_list_num = ["Ⅰ","Ⅱm","Ⅲm","Ⅳ","Ⅴ","Ⅵm","Ⅶm7-5"]
#Tous tous à moitié tous à moitié
dtnc_step = [2,2,1,2,2,2,1]
#♭#Convertir en
r_dict = {'D♭':'C#', 'E♭':'D#', 'G♭':'F#','A♭':'G#','B♭':'A#'}
#Progression du code de chargement
flist = glob.glob(fdir+"*")

dtnc_chord_list_arr = []

for idx,key in enumerate(key_list):
    pos = idx
    dtnc_chord_list = []
    for num,step in enumerate(dtnc_step):
        #son racine + majeur ou mineur
        dtnc_chord_list.append(key_list[pos]+dtnc_chord_list_num[num][1:])
        pos += step
        #Positions express sous forme de nombre de 12 ou moins
        if pos >= len(key_list):
            pos -= len(key_list)
    #Stocke une liste de codes diatoniques pour 12 touches différentes
    dtnc_chord_list_arr.append(dtnc_chord_list)


for fname in flist:
    with open(fname,encoding='cp932',mode='r+') as f:
        f.readline().rstrip('\n')
        chord_list = f.readline().rstrip('\n')
        f.readline().rstrip('\n')
        lyric_list = f.readline().rstrip('\n')
        #♭#Convertir en
        chord_list = re.sub('({})'.format('|'.join(map(re.escape, r_dict.keys()))), lambda m: r_dict[m.group()], chord_list)
        chord_list = chord_list.split(',')
        chord_list_origin = chord_list.copy()
        # N.C.Se débarrasser de
        chord_list = [chord for chord in chord_list if "N" not in chord]
        #Triade uniquement
        def get_triad(chord):
            split_chord = list(chord)
            triad = split_chord[0]
            if len(split_chord )>=2 and split_chord[1]=='#':
                triad += split_chord[1]
                if len(split_chord )>=3 and split_chord[2]=='m':
                    triad += split_chord[2]
                    if len(split_chord )>=5 and split_chord[4]=='-':
                        triad += split_chord[3]
                        triad += split_chord[4]
                        triad += split_chord[5]

            elif len(split_chord )>=2 and split_chord[1]=='m':
                triad += split_chord[1]
                if len(split_chord )>=4 and split_chord[3]=='-':
                        triad += split_chord[2]
                        triad += split_chord[3]
                        triad += split_chord[4]
            else:
                pass

            return triad
        #Changer en triade
        chord_list_triad = [get_triad(chord) for chord in chord_list]
        length = len(chord_list)
        #Nombre unique de code
        chord_unique = collections.Counter(chord_list_triad)
        #print(chord_unique)

        #################
        ###Déterminez la clé###
        #################

        match_cnt_arr = []
        #Calculez le nombre de correspondances avec 12 types de clés
        for dtnc_chord_list in dtnc_chord_list_arr:
            match_cnt = 0
            #Accordez chacun des 7 codes diatoniques_Comparez avec la valeur de clé unique,
            #S'il y a une correspondance, faites correspondre_Ajouter à cnt
            for dtnc_chord in dtnc_chord_list:
                if dtnc_chord in chord_unique.keys():
                    match_cnt += chord_unique[dtnc_chord]
            match_cnt_arr.append(match_cnt)
        #Nombre maximum de correspondances parmi 12 types
        max_cnt = max(match_cnt_arr)
        #Nombre de codes correspondants/Nombre total de codes(%)
        match_prb = int((max_cnt/length)*100)

        #Détermination clé
        key_pos = match_cnt_arr.index(max_cnt)
        key = key_list[key_pos]
        dtnc_chord_list = dtnc_chord_list_arr[key_pos]
        file_name = os.path.basename(fname).replace('.csv','')
        print('Titre de la chanson:{0} , key:{1} , prob:{2}'.format(file_name,key,match_prb))
        print(dtnc_chord_list)
        key_list_chromatic = key_list[key_pos:] + key_list[:key_pos]
        # key_list_chromatic.extend(key_list[key_pos:])
        # key_list_chromatic.extend(key_list[:key_pos])
        print(key_list_chromatic)

        #Convertir le code en nombres romains et écrire dans un fichier
        #Fonction à convertir
        def convert_num_chord(chord_list):
            s_list = []
            n_list = []
            for idx, root in enumerate(key_list_chromatic):
                #Séparez les racines selon la présence ou l'absence d'affûtage pour remplacer celles à affûter en premier.
                if '#' in root:
                    s_list.append([idx,root])
                else:
                    n_list.append([idx,root])
            chord_list = ['*' if "N" in chord else chord for chord in chord_list]
            for idx,root in s_list:
                chord_list = [chord.replace(root,rome_list[idx]) if root in chord else chord for chord in chord_list]
            for idx,root in n_list:
                chord_list = [chord.replace(root,rome_list[idx]) if root in chord else chord for chord in chord_list]
            chord_list = ['N.C.' if "*" in chord else chord for chord in chord_list]
            
            return chord_list

        chord_list_converted = convert_num_chord(chord_list_origin)
        print(chord_list_origin)
        print(chord_list_converted)
    with open(fname, "w", encoding="cp932") as f:
        writer = csv.writer(f)
        writer.writerow('key:{0},prob:{1}'.format(key,match_prb).split(','))
        writer.writerow(chord_list_origin)
        writer.writerow(chord_list_converted)
        writer.writerow(lyric_list.split(','))

Comment était-ce. Il est long et difficile de comprendre ce que vous faites, mais vous pouvez reconnaître que vous l'avez standardisé. Ce n'est pas un gros problème, donc c'est fait en un instant. Lorsque j'exécute ce code, j'obtiens les résultats suivants:

Vous pouvez voir que key = D # sur la première ligne, la probabilité d'appartenance est de 67% et la progression du code des nombres romains normalisés est ajoutée sur la troisième ligne. (Puisque le code de l'aiko est assez compliqué et que de nombreux codes non diatoniques apparaissent, la probabilité d'appartenir à diatonique est de 67%. Même avec cela, la clé peut être estimée correctement, donc l'exactitude de ce processus est correcte. Je pense que vous pouvez le prouver.)

Maintenant, dans le dernier chapitre, vectorisons et dessinons ce code standardisé.

Chapitre 3: Vectoriser le code avec word2vec et le montrer avec t-SNE

Maintenant, mettons les données d'environ 200 chansons d'aiko dans word2vec et vectorisons-les. Le nombre de dimensions est défini sur 10 car il existe au maximum 100 types de code de sortie. De plus, pour window, le rôle du code peut être suffisamment jugé avec 4 codes avant et après, donc je l'ai spécifié comme 4. De plus, sg = 0 a été défini afin d'adopter CBOW (Continuous Bag-of-Words) qui estime le mot central à partir de la périphérie. Cela transforme chaque code en un vecteur à 10 dimensions. Afin de voir ce résultat sous forme de figure, il a été compressé en deux dimensions à l'aide de t-SNE et illustré sur la figure. Le paramètre de perplexité ici est un endroit difficile, mais je l'ai mis à 3 car le plus petit est plus facile à séparer pour chaque cluster.

S'il s'agit de compresser les dimensions, pourquoi ne pas rendre la dimension de représentation du code bidimensionnelle? Je suis sûr qu'il y a des gens qui pensent cela, mais il n'y a presque aucune différence dans le code, alors je l'ai fait en 10 dimensions pour le mettre sur l'expressivité.

Regardons maintenant le code.

analyze.py

from gensim.models import Word2Vec
import glob
import itertools
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

artist = "aiko"
#Répertoire des données
fdir = "chord_data/" + artist + "/"
#Progression du code de chargement
flist = glob.glob(fdir+"*")
music_list = []
for fname in flist:
    with open(fname,encoding='cp932',mode='r+') as f:
        f.readline().rstrip('\n')
        f.readline().rstrip('\n')
        chord_list = f.readline().rstrip('\n').split(',')
        f.readline().rstrip('\n')
        lyric_list = f.readline()
        chord_list = [chord for chord in chord_list if "N" not in chord]
        music_list.append(chord_list)

#Vectoriser le code
model = Word2Vec(music_list,sg=0,window=4,min_count=0,iter=100,size=10)
chord_unique = list(set(itertools.chain.from_iterable(music_list)))
data = [model[chord] for chord in chord_unique]
print(model.most_similar('Ⅱ'))


#Compresser en 2 dimensions et dessiner
tsne = TSNE(n_components=2, random_state = 0, perplexity = 3, n_iter = 1000)
data_tsne = tsne.fit_transform(data)

fig=plt.figure(figsize=(50,25),facecolor='w')

plt.rcParams["font.size"] = 10

for i,chord in enumerate(data_tsne):
    #Tracé de points
    plt.plot(data_tsne[i][0], data_tsne[i][1], ms=5.0, zorder=2, marker="x",color="red")
    plt.annotate(chord_unique[i],(data_tsne[i][0], data_tsne[i][1]), size=10)
    i += 1

#plt.show()
plt.savefig("chord_data/" + artist + ".jpg ")
 

Le résultat obtenu avec ce code est le suivant.

aiko a de nombreux types de code et il est difficile de trouver un cluster, Par exemple, dans le cercle en bas à gauche du centre, les triades I, IV et V sont alignées à proximité. Ceci est également correct dans la théorie musicale, et cette liste de combinaisons d'accords est l'accord le plus fréquemment apparu, et en raison de sa pertinence, les vecteurs sont probablement plus proches. Dans le même cercle, il y a un code appelé II, mais bien que ce soit un code non diatonique, je pense qu'il était probable qu'il existait à proximité en tant que doppel dominant avant le code V. Il y a aussi # V et # VI, qui sont souvent utilisés dans la fameuse progression de # V → # VI → I, et on pense que ces deux codes sont proches l'un de l'autre. De plus, il y a un ensemble de codes avec 7ème dans le cercle supérieur, donc je pense que c'était un résultat intéressant à voir.

Comme c'est un gros problème, je publierai également les résultats d'autres artistes. Tout d'abord, ce qui suit est Official Beard Man dism.

Et l'autre est un artiste appelé andymori. Cela peut être plus facile à lire car il utilise moins de code.

Conclusion et perspectives d'avenir

En conclusion, j'ai trouvé que mettre le code dans word2vec conduit à des données significatives.

Comme perspective d'avenir, rappelons à l'avance la fameuse progression d'accords, et pour cela, divisons la chanson par environ 4 progressions d'accords. Il peut être intéressant de créer une matrice clairsemée en tant que progression d'accords, de créer un sujet dans LDA et de déterminer la similitude des chansons au sein d'un artiste. De plus, ce serait encore mieux si nous pouvions faire des recommandations aux artistes. Aussi, pour ceux qui ne s'intéressent qu'à la musique, j'aimerais avoir un outil qui permette de voir facilement où les changements sont apportés par le travail du chapitre 2.

Si vous écrivez un article qui combine musique et programmation, faites-vous des amis. ..

Merci pour la lecture.