MORTM 0.11.0__tar.gz

mortm-0.11.0/MORTM.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: MORTM
+Version: 0.11.0
+Summary: 音楽の旋律生成を実現したシステム
+Home-page: https://github.com/Ayato964
+Author: Nagoshi Takaaki
+Author-email: nagoshi@kthrlab.jp
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.0
+Description-Content-Type: text/markdown
+
+pip install lxml

mortm-0.11.0/MORTM.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+setup.py
+MORTM.egg-info/PKG-INFO
+MORTM.egg-info/SOURCES.txt
+MORTM.egg-info/dependency_links.txt
+MORTM.egg-info/top_level.txt
+mortm/ConvertMidi.py
+mortm/PositionalEncoding.py
+mortm/__init__.py
+mortm/constants.py
+mortm/datasets.py
+mortm/gmail_messanger.py
+mortm/messager.py
+mortm/mortm.py
+mortm/tokenizer.py
+mortm/train.py

mortm-0.11.0/MORTM.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mortm-0.11.0/MORTM.egg-info/top_level.txt

@@ -0,0 +1 @@
+mortm

mortm-0.11.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: MORTM
+Version: 0.11.0
+Summary: 音楽の旋律生成を実現したシステム
+Home-page: https://github.com/Ayato964
+Author: Nagoshi Takaaki
+Author-email: nagoshi@kthrlab.jp
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.0
+Description-Content-Type: text/markdown
+
+pip install lxml

mortm-0.11.0/README.md

@@ -0,0 +1 @@
+pip install lxml

mortm-0.11.0/mortm/ConvertMidi.py

@@ -0,0 +1,277 @@
+'''
+Midiデータを tokenizerで変換し、数値の配列にしたものをnumpyに変換し、指定されたディレクトリに保存します。
+'''
+
+from typing import Any
+
+import mido.midifiles.meta
+from numpy import ndarray, dtype
+from pretty_midi import PrettyMIDI, Instrument, Note
+import numpy as np
+
+from . import constants
+from AGSM.convert import ConvTempo, ConvKey
+from .tokenizer import Tokenizer
+from . import tokenizer as tr
+
+PITCH = 0
+VELOCITY = 1
+DURATION_INT = 2
+DURATION_FEW = 3
+BEGIN_TIME_INT = 4
+BEGIN_TIME_FEW = 5
+START_SEQ = np.array([[0, 0, 0, 0]], dtype=int)
+END_SEQ = np.array([[5, 5, 5, 5]], dtype=int)
+''''
+規則：
+    AyaNode:
+        Aya_node = [音高, 強さ, 始まりの拍(16), 終わりの拍までの長さ(16)]
+    TOKEN:
+        <S_SEQ>: [0, 0, 0, 0]
+        <E_SEQ>: [5, 5, 5, 5]
+'''
+
+def convert_tolist(target: list):
+    new_target = None
+    for t in target:
+        t: ndarray
+        cul = []
+        for c in t:
+            cul.append(c)
+        if new_target is not None:
+            new_target = new_target + [cul]
+        else:
+            new_target = [cul]
+
+    return new_target
+
+
+class ConvertMidi:
+
+    def __init__(self, tokenizer: Tokenizer, directory: str, program_list: list, tempo: int, midi_data: PrettyMIDI = None):
+        self.directory = directory
+        self.midi_data = midi_data
+        self.program_list = program_list
+        self.tempo = tempo
+        self.aya_node = None
+        self.is_error = False
+        self.tokenizer = tokenizer
+
+    def convert(self):
+        self._ct_tempo()
+        #self._ct_key()
+        if not self.is_error:
+            convert_notes: np = None
+            program_count = 0
+            for inst in self.midi_data.instruments:
+                inst: Instrument = inst
+                if not inst.is_drum and inst.program in self.program_list:
+                    cn = self.ct_aya_node(inst.notes)
+
+                    if len(cn) >= 1000:
+                        new_array = np.array_split(cn, np.arange(1000, len(cn), 1000))
+                        new_array = convert_tolist(new_array)
+                        cn: ndarray = np.array(self._padding(new_array))
+                        print(cn.shape)
+                    else:
+                        cn: ndarray = np.array(self._padding([cn.tolist()], 1000))
+
+                    if convert_notes is None:
+                        convert_notes = cn
+                    else:
+                        #pad_convert_notes, pad_cn = self.padding(convert_notes, cn)
+                        convert_notes = np.vstack((convert_notes, cn), dtype=int)
+                    program_count += 1
+
+            if program_count == 0:
+                print(f"{self.directory}には欲しい楽曲がありませんでした")
+                self.is_error = True
+            elif np.min(convert_notes) < 0:
+                print(f"{self.directory}の値の中に0以下の値が格納されていたため、中断します。")
+                self.is_error = True
+
+            self.aya_node = convert_notes
+            return convert_notes
+
+
+    def split_seq_data(self, target: ndarray):
+
+        if len(target.shape) == 1:
+            musics_seq = [target.tolist()]
+        else:
+            musics_seq = target.tolist()
+
+        new_music_seq = [[]]
+        for i in range(len(musics_seq)):
+            result = []
+            current_sublist = []
+            for value in musics_seq[i]:
+                current_sublist.append(value)
+                if value == 2:
+                    result.append(current_sublist)
+                    current_sublist = []
+            new_music_seq = new_music_seq + result
+
+        return np.array(self._padding(new_music_seq))
+
+        pass
+
+    def _padding(self, target: list, max_length: int = None):
+        if max_length is None:
+            max_lengths = []
+            for t in target:
+                max_lengths.append(len(t))
+            max_length = max(max_lengths)
+
+        print(f"Max length is {max_length}")
+        for t in target:
+            if len(t) < max_length:
+                for _ in range(max_length - len(t)):
+                    t.append(0)
+        return target
+        pass
+
+    def save(self, save_directory: str) -> bool:
+        if not self.is_error:
+            print(f"Result shape is:{self.aya_node.shape}")
+
+            split_direc = self.directory.split("\\")
+
+            filename = split_direc[-1].split(".")[0]
+
+            np.savez(save_directory + "/" + filename, self.aya_node)
+            print("処理が正常に終了しました。")
+            return True
+        else:
+            print("Transformerが望むデータ形式ではないため、保存ができませんでした。")
+            return False
+
+    def ct_aya_node(self, notes: list) -> ndarray[Any, dtype[Any]]:
+        node = np.array([self.tokenizer.get(-1, constants.START_SEQ_TOKEN)])
+
+        back_start = None
+        for note in notes:
+
+            note: Note = note
+            start = self.ct_time_to_beat(note.start)
+            end = self.ct_time_to_beat(note.end)
+
+            if back_start is not None:
+                shift = abs((back_start // 32) - (start // 32))
+                if 4 > shift:
+                    #if shift > 0:
+                    node = np.append(node, self.tokenizer.get(shift, tr.SHIFT_TYPE)) #何小節のブランクができたかを計算
+                else:
+                    node = np.append(node, self.tokenizer.get(-1, constants.END_SEQ_TOKEN))
+                    node = np.append(node, self.tokenizer.get(-1, constants.START_SEQ_TOKEN))
+
+            pitch_token = self.tokenizer.get(note.pitch, tr.PITCH_TYPE)
+            velocity_token = self.tokenizer.get(note.velocity, tr.VELOCITY_TYPE)
+            duration_token = self.tokenizer.get(min(abs(end - start), 99), tr.DURATION_TYPE)
+            start_token = self.tokenizer.get(start % 32, tr.START_TYPE)
+            note_token = np.array([start_token, pitch_token, velocity_token, duration_token])
+            node = np.concatenate((node, note_token))
+            back_start = start
+
+        node = np.append(node, self.tokenizer.get(-1, constants.END_SEQ_TOKEN))
+        return node
+
+    def _ct_key(self):
+        try:
+            if self.midi_data is None:
+                ct = ConvKey(self.directory, "C")
+                ct.convert()
+                self.midi_data = ct.midi_data
+                if ct.is_Error:
+                    self.is_error = ct.is_Error
+            else:
+                ct = ConvKey(directory=self.directory, midi_data=self.midi_data, key="C")
+                ct.convert()
+                self.midi_data = ct.midi_data
+        except OSError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+        except IndexError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+        except mido.midifiles.meta.KeySignatureError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+        except ValueError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+
+
+
+    def _ct_tempo(self):
+        try:
+            if self.midi_data is None:
+                ct = ConvTempo(self.directory, self.tempo)
+                ct.convert()
+                self.midi_data = ct.midi_data
+                if ct.is_Error:
+                    self.is_error = ct.is_Error
+            else:
+                ct = ConvTempo(directory=self.directory, midi_data=self.midi_data, change_tempo=120)
+                ct.convert()
+                self.midi_data = ct.midi_data
+        except OSError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+        except IndexError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+        except ValueError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+
+        except mido.midifiles.meta.KeySignatureError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+
+        except EOFError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+
+        except KeyError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+        except ZeroDivisionError:
+            print(f"{self.directory}でエラーが発生。処理を中断します。")
+            self.is_error = True
+
+
+
+    def ct_time_to_beat(self, time: float) -> int:
+        b4 = 60 / self.tempo
+        b8 = b4 / 2
+        b16 = b8 / 2
+        b32 = b16 / 2
+
+        beat, sub = self.calc_time_to_beat(time, b32)
+
+        return beat
+
+    def calc_time_to_beat(self, time, beat_time) -> (int, int):
+        main_beat: int = time // beat_time
+        sub_time: int = time % beat_time
+        return main_beat, sub_time
+
+    def padding(self, array1: ndarray, array2: ndarray):
+        print(f"a:{array1.shape[-1]}  b:{array2.shape[-1]}")
+
+        max_len = max(array1.shape[-1], array2.shape[-1])
+
+        # 0でパディングして同じ長さに揃える
+        if len(array1.shape) > 1:
+            padded_array1 = np.array([np.pad(row, (0, max_len - len(row)), mode='constant') for row in array1])
+        else:
+            padded_array1 = np.pad(array1, (0, max_len - len(array1)), mode='constant')
+
+        if len(array2.shape) > 1:
+            padded_array2 = np.array([np.pad(row, (0, max_len - len(row)), mode='constant') for row in array2])
+        else:
+            padded_array2 = np.pad(array2, (0, max_len - len(array2)), mode='constant')
+
+        return padded_array1, padded_array2
+

mortm-0.11.0/mortm/PositionalEncoding.py

@@ -0,0 +1,25 @@
+import torch
+import torch.nn as nn
+import math
+
+
+class PositionalEncoding(nn.Module):
+
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        # Positional Encodingのテンソルを生成
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0).transpose(0, 1)
+
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        x = x + self.pe[:x.size(0), :]
+        return self.dropout(x)

mortm-0.11.0/mortm/constants.py

@@ -0,0 +1,19 @@
+import torch
+
+PITCH_MAX = 128
+VELO = 128
+LENGTH = 999
+LENGTH_HALF = 999
+BEGIN = 999
+BEGIN_HALF = 999
+ROOT = 99
+START_SEQ_TOKEN = "<S_SEQ>"
+END_SEQ_TOKEN = "<E_SEQ>"
+PADDING_TOKEN = "<PAD>"
+
+
+def get_device():
+    if torch.cuda.is_available():
+        return torch.device('cuda')
+    else:
+        return torch.device('cpu')

mortm-0.11.0/mortm/datasets.py

@@ -0,0 +1,98 @@
+'''
+Tokenizerで変換したシーケンスを全て保管します。
+'''
+import random
+import time
+
+import torch
+from torch.utils.data import Dataset
+import numpy as np
+from .constants import get_device
+
+
+class MORTM_DataSets(Dataset):
+    def __init__(self):
+        self.musics_seq = None
+        self.tgt_seq = None
+
+    def __len__(self):
+        return len(self.musics_seq)
+
+    def __getitem__(self, item):
+        return torch.tensor(self.musics_seq[item], dtype=torch.int).to(get_device()), torch.tensor(self.tgt_seq[item], dtype=torch.int).to(get_device())
+
+    def add_data(self, music_seq: np.ndarray):
+        if self.musics_seq is None:
+            if len(music_seq.shape) == 1:
+                self.musics_seq = [music_seq.tolist()]
+            else:
+                self.musics_seq = music_seq.tolist()
+        else:
+            if len(music_seq.shape) == 1:
+                music_seq: list = [music_seq.tolist()]
+                self.musics_seq = self.musics_seq + music_seq
+            else:
+                self.musics_seq = self.musics_seq + music_seq.tolist()
+
+        print(self._get_shape(self.musics_seq))
+        pass
+
+    def split_seq_data(self):
+        new_music_seq = [[]]
+        for i in range(len(self.musics_seq)):
+            result = []
+            current_sublist = []
+            for value in self.musics_seq[i]:
+                current_sublist.append(value)
+                if value == 2:
+                    result.append(current_sublist)
+                    current_sublist = []
+            new_music_seq = new_music_seq + result
+
+        self.musics_seq = new_music_seq
+
+        pass
+
+    def set_train_data(self):
+        print(f"Set train data....{self._get_shape(self.musics_seq)}")
+        for music_seq in self.musics_seq:
+            tgt_data = []
+            for i in range(len(music_seq) - 1):
+                tgt_data.append(music_seq[i + 1])
+            if self.tgt_seq is None:
+                self.tgt_seq = [tgt_data]
+            else:
+                self.tgt_seq = self.tgt_seq + [tgt_data]
+
+
+        print(f"clear! train shape is:{self._get_shape(self.tgt_seq)}")
+
+    def _get_shape(self, lst):
+        if isinstance(lst, list):
+            return [len(lst)] + self._get_shape(lst[0]) if lst else []
+        return []
+
+    def set_padding(self):
+        #        self._padding(self.tgt_seq)
+        self._padding(self.musics_seq)
+
+        pass
+
+    def get_max_length(self, target):
+        max_lengths = []
+        for t in target:
+            max_lengths.append(len(t))
+        max_length = max(max_lengths)
+        return max_length
+
+    def _padding(self, target: list):
+        max_lengths = []
+        for t in target:
+            max_lengths.append(len(t))
+        max_length = max(max_lengths)
+        print(f"Max length is {max_length}")
+        for t in target:
+            if len(t) < max_length:
+                for _ in range(max_length - len(t)):
+                    t.append(0)
+        pass

mortm-0.11.0/mortm/gmail_messanger.py

@@ -0,0 +1,66 @@
+import os
+import base64
+
+from mortm.messager import Messenger
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from email.mime.text import MIMEText
+
+
+# Gmail APIのスコープを設定
+SCOPES = ['https://www.googleapis.com/auth/gmail.send']
+
+
+class GmailMessanger(Messenger):
+
+    def __init__(self, token_file: str, client_secret_file: str, send_address):
+        super().__init__()
+        self.token_file = token_file
+        self.client_secret_file = client_secret_file
+        self.send_address = send_address
+        self.creds = self.authenticate_gmail()
+
+    def authenticate_gmail(self):
+        creds = None
+        if os.path.exists(self.token_file):
+            creds = Credentials.from_authorized_user_file(self.token_file, SCOPES)
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_secrets_file(self.client_secret_file, SCOPES)
+                creds = flow.run_local_server(port=0)
+            # 認証情報を保存
+            with open(self.token_file, 'w') as token:
+                token.write(creds.to_json())
+        return creds
+
+
+    def create_message(self, to, subject, message_text):
+        message = MIMEText(message_text)
+        message['to'] = to
+        message['subject'] = subject
+        return {'raw': base64.urlsafe_b64encode(message.as_bytes()).decode()}
+
+
+    def _send_email(self, service, user_id, message):
+        try:
+            message = service.users().messages().send(userId=user_id, body=message).execute()
+            print(f'Message Id: {message["id"]}')
+            return message
+        except HttpError as error:
+            print(f'An error occurred: {error}')
+            return None
+
+
+    def send_message(self, subject: str, body: str):
+        # 認証を実行してGmail APIサービスを取得
+        service = build('gmail', 'v1', credentials=self.creds)
+
+        message = self.create_message(self.send_address, subject, body)
+
+        # メールを送信
+        self._send_email(service, 'me', message)

mortm-0.11.0/mortm/messager.py

@@ -0,0 +1,11 @@
+from abc import abstractmethod
+
+
+class Messenger:
+
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def send_message(self, subject: str, body: str):
+        pass

mortm-0.11.0/mortm/mortm.py

@@ -0,0 +1,155 @@
+import torch
+from torch import Tensor
+import torch.nn as nn
+from .PositionalEncoding import PositionalEncoding
+
+from .constants import get_device
+
+device = get_device()
+
+
+class MORTM(nn.Module):
+    token_dict = {
+        0: "600_633",
+        1: "10_139",
+        2: "300_429",
+        3: "500_600",
+        4: "600_605"
+    }
+
+    def __init__(self, vocab_size, trans_layer=6, num_heads=8, d_model=512, dim_feedforward=1024, dropout=0.1,
+                 position_length=2048):
+        super(MORTM, self).__init__()
+
+        self.trans_layer = trans_layer
+        self.num_heads = num_heads
+        self.d_model = d_model
+        self.dim_feedforward = dim_feedforward
+        self.dropout = dropout
+
+        #位置エンコーディングを作成
+        self.positional: PositionalEncoding = PositionalEncoding(self.d_model, dropout, position_length).to(device)
+        #Transformerの設定
+        self.transformer: nn.Transformer = nn.Transformer(d_model=self.d_model, nhead=num_heads,  #各種パラメーターの設計
+                                                          num_encoder_layers=self.trans_layer,
+                                                          num_decoder_layers=self.trans_layer,
+                                                          dropout=self.dropout, dim_feedforward=dim_feedforward,
+                                                          ).to(device)
+        print(f"Input Vocab Size:{vocab_size}")
+        self.Wout = nn.Linear(self.d_model, vocab_size).to(device)
+
+        self.embedding: nn.Embedding = nn.Embedding(vocab_size, self.d_model).to(device)
+        self.softmax: nn.Softmax = nn.Softmax(dim=-1).to(device)
+
+    def forward(self, inputs_seq, tgt_seq, input_mask, tgt_mask, input_padding_mask, tgt_padding_mask):
+
+        inputs_em: Tensor = self.embedding(inputs_seq)
+        inputs_em = inputs_em.permute(1, 0, 2)
+        inputs_pos: Tensor = self.positional(inputs_em)
+
+        if tgt_seq is None:
+            tgt_pos = inputs_pos
+        else:
+            tgt_em: Tensor = self.embedding(tgt_seq)
+            tgt_em = tgt_em.permute(1, 0, 2)
+            tgt_pos: Tensor = self.positional(tgt_em)
+
+        #print(inputs_pos.shape, tgt_pos.shape)
+        out: Tensor = self.transformer(inputs_pos, tgt_pos, input_mask, tgt_mask,
+                                       src_key_padding_mask=input_padding_mask, tgt_key_padding_mask=tgt_padding_mask)
+
+        out.permute(1, 0, 2)
+
+        score = self.Wout(out)
+        return score
+
+    def generate_by_length(self, input_seq, max_length, p=0.9, temperature=0.1):
+        self.eval()
+        output = torch.tensor([input_seq], dtype=torch.long).unsqueeze(1).to(device)
+        for _ in range(max_length):
+            with torch.no_grad():
+                output = self._next_note_token(output)
+
+        return output
+
+    def _next_note_token(self, output, p=0.9, temperature=0.1):
+        isEnd = False
+        token_count = 0
+        while not isEnd:
+            mask = self.transformer.generate_square_subsequent_mask(output.shape[1]).to(device)
+            outputs = self(output, output, mask, mask, None, None)
+            logits = outputs[:, -1, :]
+
+            str_token_duration = self.token_dict[token_count]
+            parts = str_token_duration.split("_")
+            token_duration = [int(part) for part in parts]
+            if token_count != 4:
+                token = self._next_token(logits[:, token_duration[0]:token_duration[1]])
+                token += token_duration[0]
+            else:
+                token = self._next_token(logits)
+                isEnd = True
+            token_count += 1
+
+            output = torch.cat((output.flatten(), token.unsqueeze(0))).unsqueeze(0).to(device)
+
+        return output
+
+    def _next_token(self, end_logit_score: Tensor, p=0.9, temperature=0.1):
+        end_logit_score = end_logit_score / temperature
+
+        sorted_logits, sorted_indices = torch.sort(end_logit_score, descending=True)
+        cumulative_probs = torch.cumsum(self.softmax(sorted_logits), dim=-1)
+        sorted_indices_to_remove = cumulative_probs > p
+        sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+        sorted_indices_to_remove[..., 0] = 0
+        indices_to_remove = sorted_indices[sorted_indices_to_remove]
+        end_logit_score[:, indices_to_remove] = -float('Inf')
+
+        score = self.softmax(end_logit_score)[-1]
+        dis = torch.distributions.categorical.Categorical(probs=score)
+        next_token = dis.sample()
+
+        #print(next_token)
+        return next_token
+
+
+    def top_p_sampling(self, input_ids, tokenizer, p=0.9, max_length=20, temperature=0.2):
+        self.eval()
+        output = torch.tensor([input_ids], dtype=torch.long).unsqueeze(1).to(device)
+        for _ in range(max_length):
+            with torch.no_grad():
+                mask = self.transformer.generate_square_subsequent_mask(output.shape[1]).to(device)
+                outputs = self(output, output, mask, mask, None, None)
+                logits = outputs[:, -1, :]
+
+                print(logits[-1, 10:138])
+
+                logits = logits / temperature
+
+                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                cumulative_probs = torch.cumsum(self.softmax(sorted_logits), dim=-1)
+                sorted_indices_to_remove = cumulative_probs > p
+                sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                sorted_indices_to_remove[..., 0] = 0
+                indices_to_remove = sorted_indices[sorted_indices_to_remove]
+                logits[:, indices_to_remove] = -float('Inf')
+
+                probabilities = self.softmax(logits)[-1]
+                dis = torch.distributions.categorical.Categorical(probs=probabilities)
+                next_token = dis.sample()
+                # バッチサイズを一致させるために次元を調整
+                next_token = next_token.unsqueeze(0)
+                output = torch.cat((output.flatten(), next_token)).unsqueeze(0).to(device)
+                #print(output)
+        return output.tolist()
+
+
+
+
+class DummyDecoder(nn.Module):
+    def __init__(self):
+        super(DummyDecoder, self).__init__()
+
+    def forward(self, tgt, memory, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask, **kwargs):
+        return memory

mortm-0.11.0/mortm/tokenizer.py

@@ -0,0 +1,92 @@
+import json
+
+from . import constants
+
+'''旋律トークン'''
+PITCH_TYPE = 'p'
+VELOCITY_TYPE = 'v'
+DURATION_TYPE = 'd'
+
+'''指示トークン'''
+START_TYPE = 's'
+SHIFT_TYPE = 'h'
+
+
+class Tokenizer:
+    def __init__(self, save_directory: str, load_data: str = None):
+        self.save_directory = save_directory
+        if load_data is None:
+            # 特殊トークン
+            self.special_token_position = 3
+            #旋律トークン
+            self.pitch_position = 10
+            self.velocity_position = 300
+            self.duration_position = 500
+            #指示トークン
+            self.instruction_start_position = 600
+            self.instruction_shift_position = 650
+
+            self.tokens: dict = dict()
+            self.token_max: dict = self._init_mx_dict()
+            self.tokens[constants.PADDING_TOKEN] = 0
+            self.tokens[constants.START_SEQ_TOKEN] = 1
+            self.tokens[constants.END_SEQ_TOKEN] = 2
+        else:
+            with open(load_data, 'r') as file:
+                self.tokens: dict = json.load(file)
+                self.rev_tokens: dict = {v: k for k, v in self.tokens.items()}
+
+    def _init_mx_dict(self) -> dict:
+        my_dict = dict()
+        for i in range(0, 654):
+            my_dict[i] = 0
+        return my_dict
+
+    def rev_get(self, a):
+        return self.rev_tokens[a]
+
+    def get(self, a: int, token_type: str, b = False):
+        if a == -1:
+            b = True
+            my_token = token_type
+        else:
+            my_token = f"{token_type}_{a}"
+
+        if my_token in self.tokens:
+            if not b:
+                self.token_max[self.tokens[my_token]] += 1
+            return self.tokens[my_token]
+        else:
+            if token_type is PITCH_TYPE:
+                self.tokens[my_token] = self.pitch_position
+                self.pitch_position += 1
+
+            elif token_type is VELOCITY_TYPE:
+                self.tokens[my_token] = self.velocity_position
+                self.velocity_position += 1
+
+            elif token_type is DURATION_TYPE:
+                self.tokens[my_token] = self.duration_position
+                self.duration_position += 1
+
+            elif token_type is START_TYPE:
+                self.tokens[my_token] = self.instruction_start_position
+                self.instruction_start_position += 1
+
+            elif token_type is SHIFT_TYPE:
+                self.tokens[my_token] = self.instruction_shift_position
+                self.instruction_shift_position += 1
+
+            self.token_max[self.tokens[my_token]] = 1
+            return self.tokens[my_token]
+
+    def save(self):
+        json_string = json.dumps(self.tokens)
+        with open(self.save_directory + "/vocab_list.json", 'w') as file:
+            file.write(json_string)
+
+        json_s = json.dumps(self.token_max)
+        with open(self.save_directory + "/vocab_max.json", 'w') as file:
+            file.write(json_s)
+
+    pass

mortm-0.11.0/mortm/train.py

@@ -0,0 +1,219 @@
+'''
+MORTMの学習を行う際にこのモジュールを使います。
+train_mortmメソッドを呼び出し、引数の型に合ったオブジェクトを代入してください。
+最低でも、「データセット(Tokenizerで変換したもの)のディレクトリ」、「モデルの出力先のディレクトリ」,
+「モデルのバージョン」,「ボキャブラリーサイズ」,「エポック回数」、「各トークンの出現回数のリスト」が必要です。
+'''
+
+import datetime
+import json
+import os
+import time
+
+import torch
+from torch import Tensor
+from torch.utils.data import DataLoader
+import torch.nn as nn
+import numpy as np
+from .messager import Messenger
+
+from .datasets import MORTM_DataSets
+from .mortm import MORTM
+from .constants import get_device
+
+IS_DEBUG = False
+
+
+def _send_prediction_end_time(message, loader_len, begin_time, end_time,
+                              vocab_size: int, num_epochs: int, trans_layer, num_heads, d_model,
+                              dim_feedforward, dropout, position_length):
+    t = end_time - begin_time
+    end_time_progress = (t * loader_len * num_epochs) / 3600
+    message.send_message("終了見込みについて",
+                      f"現在学習が進行しています。\n"
+                      f"今回設定したパラメータに基づいて終了時刻を計算しました。\n"
+                      f"ボキャブラリーサイズ:{vocab_size}\n"
+                      f"エポック回数:{num_epochs}\n"
+                      f"Transformerのレイヤー層:{trans_layer}\n"
+                      f"Modelの次元数:{d_model}\n"
+                      f"シーケンスの長さ:{dim_feedforward}\n"
+                      f"ドロップアウト:{dropout}\n"
+                      f"\n\n シーケンスの1回目の処理が終了しました。かかった時間は{t:.1f}秒でした。\n"
+                      f"終了見込み時間は{end_time_progress:.2f}時間です"
+                         )
+
+
+# デバイスを取得
+def _set_train_data(directory, datasets):
+    if not IS_DEBUG:
+        print("Generating TrainData.....")
+        t_data = MORTM_DataSets()
+        for dataset in datasets:
+            print(f"Load [{directory + dataset}]")
+            np_load_data = np.load(directory + dataset)
+            train_data = None
+            for i in range(len(np_load_data)):
+
+                np_data = np.expand_dims(np_load_data[f'arr_{i}'], axis=0)[0]
+                print(np_data.shape)
+
+                if train_data is None:
+                    train_data = np_data
+                else:
+                    train_data = np.concatenate((train_data, np_data), axis=0)
+            print(f"最初の５音:{train_data[-1][0:25]}")
+            t_data.add_data(train_data)
+        print(f"Token size: {sum(len(sub) for sub in t_data.musics_seq)} ")
+        print("----------------------------------")
+        #t_data.split_seq_data()
+        #t_data.set_padding()
+        t_data.set_train_data()
+
+        return t_data
+    else:
+        np_load_data = np.load(directory + datasets[0])
+        print(np_load_data[f'arr_{3}'])
+    return None
+
+
+def _get_padding_mask(input_ids):
+    pad_id = None
+    for inputs in input_ids:
+        pad = []
+        for token in inputs:
+            if token == 0:
+                pad.append(0)
+            else:
+                pad.append(1)
+        if pad_id is None:
+            pad_id = [pad]
+        else:
+            pad_id = pad_id + [pad]
+    padding_mask = torch.tensor(pad_id, dtype=torch.float).to(get_device())
+    return padding_mask
+
+
+def _train(ayato_dataset, message: Messenger, vocab_size: int, num_epochs: int, weight: Tensor, trans_layer=6,
+           num_heads=8, d_model=512, dim_feedforward=1024, dropout=0.1,
+           position_length=2048, accumulation_steps=4, batch_size=16):
+    loader = DataLoader(ayato_dataset, batch_size=batch_size, shuffle=True, pin_memory=False)
+    print("Creating Model....")
+    model = MORTM(vocab_size=vocab_size, trans_layer=trans_layer, num_heads=num_heads,
+                  d_model=d_model, dim_feedforward=dim_feedforward,
+                  dropout=dropout, position_length=position_length).to(get_device())
+
+    criterion = nn.CrossEntropyLoss(ignore_index=0, weight=weight.to(get_device()))  # 損失関数を定義
+    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4, weight_decay=0.01)  # オプティマイザを定義
+
+    print("Start training...")
+
+    loss_val = None
+    mail_bool = True
+    for epoch in range(num_epochs):
+        print(f"epoch {epoch + 1} start....")
+        print(f"batch size :{len(loader)}")
+        count = 1
+        epoch_loss = 0.0
+
+        model.train()
+        optimizer.zero_grad()
+
+        for input_ids, targets in loader:  # seqにはbatch_size分の楽曲が入っている
+            print(f"learning sequence {count}")
+            begin_time = time.time()
+            input_ids.to(get_device())
+            #inputs_mask = model.mortm_X.generate_square_subsequent_mask(input_ids.shape[1]).to(device)
+            targets_mask = model.transformer.generate_square_subsequent_mask(targets.shape[1]).to(get_device())
+            padding_mask_in: Tensor = _get_padding_mask(input_ids)
+            padding_mask_tgt: Tensor = _get_padding_mask(targets)
+
+            output = model(input_ids, targets, None, targets_mask, padding_mask_in, padding_mask_tgt)
+
+            outputs = output.view(-1, output.size(-1))
+            targets = targets.view(-1).long()
+
+            loss = criterion(outputs, targets)  # 損失を計算
+            loss.backward()  # 逆伝播
+
+            if count % accumulation_steps == 0:  #実質バッチサイズは64である
+                optimizer.step()  # オプティマイザを更新
+                optimizer.zero_grad()
+                print("Optimizerを更新しました。")
+
+            epoch_loss += loss.item()
+            count += 1
+            end_time = time.time()
+
+            if mail_bool and message is not None:
+                _send_prediction_end_time(message, len(loader), begin_time, end_time, vocab_size, num_epochs,
+                                          trans_layer, num_heads, d_model, dim_feedforward, dropout, position_length)
+                mail_bool = False
+
+            if (count + 1) % 100 == 0 and message is not None:
+                message.send_message("機械学習の途中経過について", f"Epoch {epoch + 1}/{num_epochs}の"
+                                                                f"learning sequence {count}結果は、\n {epoch_loss / count:.4f}でした。")
+            print(epoch_loss)
+
+        print(f"Epoch [{epoch + 1}/{num_epochs}],  Loss: {epoch_loss:.4f}")
+        if message is not None:
+            message.send_message("機械学習の途中経過について",
+                              f"Epoch {epoch + 1}/{num_epochs}の結果は、{epoch_loss / count:.4f}でした。")
+        loss_val = epoch_loss / count
+    return model, loss_val
+
+
+def train_mortm(dataset_directory, save_directory, version: str, vocab_size: int, num_epochs: int, weight_directory,
+                message: Messenger = None,
+                trans_layer=12, num_heads=8, d_model=1024,
+                dim_feedforward=2048, dropout=0.2, position_length=2048,
+                accumulation_steps=4, batch_size=16):
+    os.environ['CUDA_LAUNCH_BLOCKING'] = '1'
+    today_date = datetime.date.today().strftime('%Y%m%d')
+
+    print(f"ToDay is{datetime.date.today()}! start generating MORTEM_Model.{version}_{today_date}")
+
+    datasets = os.listdir(dataset_directory)
+    train_data = _set_train_data(dataset_directory, datasets)
+
+    try:
+        with open(weight_directory, 'r') as file:
+            freq_dict = json.load(file)
+            # 逆数を取り、頻出度が0の場合は小さい値に設定
+            epsilon = 1e-10  # 非ゼロの小さい値を設定しておく
+            weights = []
+
+            for i in range(len(freq_dict)):
+                freq = freq_dict[str(i)]  # JSONのキーは文字列なのでstrに変換
+                if freq == 0:
+                    weights.append(epsilon)
+                else:
+                    weights.append(1.0 / freq)
+            # テンソルに変換
+            weight_tensor = torch.tensor(weights)
+            weight_tensor = weight_tensor / weight_tensor.sum()
+            print(weight_tensor[650:653])
+        model, loss = _train(train_data, message, vocab_size, num_epochs, weight_tensor,
+                             d_model=d_model,
+                             dim_feedforward=dim_feedforward,
+                             trans_layer=trans_layer,
+                             num_heads=num_heads,
+                             position_length=position_length,
+                             dropout=dropout,
+                             accumulation_steps=accumulation_steps,
+                             batch_size=batch_size
+                             )  # 20エポック分機械学習を行う。
+
+        if message is not None:
+            message.send_message("機械学習終了のお知らせ",
+                              f"MORTM.{version}の機械学習が終了しました。 \n 結果の報告です。\n 損失関数: {loss}")
+
+        torch.save(model.state_dict(), f"{save_directory}/MORTM.{version}_{loss}.pth")  # できたモデルをセーブする
+
+        return model
+
+    except torch.cuda.OutOfMemoryError:
+        if message is not None:
+            message.send_message("エラーが発生し、処理を中断しました",
+                              "学習中にモデルがこのPCのメモリーの理論値を超えました。\nバッチサイズを調整してください")
+
+    pass

mortm-0.11.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mortm-0.11.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='MORTM',
+    version='0.11.0',
+    author='Nagoshi Takaaki',
+    author_email='nagoshi@kthrlab.jp',
+    description='音楽の旋律生成を実現したシステム',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/Ayato964',
+    packages=['mortm'],
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.0',
+)