MORTM 1.2__tar.gz → 2.0b3__tar.gz

{mortm-1.2 → mortm-2.0b3}/MORTM.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MORTM
-Version: 1.2
+Version: 2.0b3
 Summary: 音楽の旋律生成を実現したシステム
 Home-page: https://github.com/Ayato964
 Author: Nagoshi Takaaki

{mortm-1.2 → mortm-2.0b3}/MORTM.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ MORTM.egg-info/top_level.txt
 mortm/PositionalEncoding.py
 mortm/RelativePositionalRepresentations.py
 mortm/__init__.py
-mortm/aya_node.py
 mortm/constants.py
 mortm/convert.py
 mortm/datasets.py
@@ -23,5 +22,6 @@ mortm/noam.py
 mortm/progress.py
 mortm/reinforcement.py
 mortm/rpr.py
+mortm/token.py
 mortm/tokenizer.py
 mortm/train.py

{mortm-1.2 → mortm-2.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MORTM
-Version: 1.2
+Version: 2.0b3
 Summary: 音楽の旋律生成を実現したシステム
 Home-page: https://github.com/Ayato964
 Author: Nagoshi Takaaki

{mortm-1.2 → mortm-2.0b3}/mortm/convert.py

@@ -2,12 +2,12 @@ from typing import List, Any
 
 import mido
 import numpy as np
+from numpy import ndarray
 from AGSM.convert import ConvTempo
 from pretty_midi.pretty_midi import PrettyMIDI, Instrument, Note, TimeSignature
 from abc import abstractmethod, ABC
 from typing import TypeVar, Generic
-from . import constants
-from .aya_node import Token
+from .token import Token
 from .tokenizer import Tokenizer
 
 T = TypeVar("T")
@@ -19,10 +19,9 @@ class _AbstractMidiToAyaNode(ABC):
         self.file_name = file_name
         self.is_error = False
         self.instance = instance
-        self.token_converter: List[Token] = tokenizer.token_list
+        self.token_converter: List[Token] = tokenizer.music_token_list
         self.error_reason: str = "不明なエラー"
         self.tokenizer = tokenizer
-
         if midi_data is not None:
             self.midi_data: PrettyMIDI = midi_data
         else:
@@ -99,10 +98,10 @@ class _AbstractMidiToAyaNode(ABC):
     def convert(self):
         pass
 
-class MidiToAyaNode(_AbstractMidiToAyaNode):
+class MIDIToSequence(_AbstractMidiToAyaNode):
 
     def __init__(self, tokenizer: Tokenizer, directory: str, file_name: str, program_list, midi_data=None):
-        super().__init__(MidiToAyaNode, tokenizer, directory, file_name, program_list, midi_data)
+        super().__init__(MIDIToSequence, tokenizer, directory, file_name, program_list, midi_data)
         self.aya_node = [0]
 
     def convert(self):
@@ -134,7 +133,6 @@ class MidiToAyaNode(_AbstractMidiToAyaNode):
                 inst: Instrument = inst
                 if not inst.is_drum and inst.program in self.program_list:
                     aya_node_inst = self.ct_aya_node(inst)
-
                     self.aya_node = self.aya_node + aya_node_inst
                     program_count += 1
 
@@ -159,8 +157,7 @@ class MidiToAyaNode(_AbstractMidiToAyaNode):
         aya_node_inst = []
         back_note = None
 
-        clip_time: float = 0
-        split_count: int = 1
+        clip_count = 0
 
         sorted_notes = sorted(inst.notes, key=lambda notes: notes.start)
 
@@ -168,36 +165,31 @@ class MidiToAyaNode(_AbstractMidiToAyaNode):
             note: Note = note
 
             tempo = self.get_tempo(note.start)
-            measure_time = (60 / tempo) * 4
-
-            if clip_time >= measure_time * 8 * split_count:
-                aya_node_inst = self.marge_clip(clip, aya_node_inst)
-
-                clip = np.array([], dtype=int)
-                back_note = None
-                split_count += 1
-
-            if back_note is None:
-                clip = np.append(clip, self.tokenizer.get(constants.START_SEQ_TOKEN))
 
             for conv in self.token_converter:
                 conv: Token = conv
 
-                token = conv(back_notes=back_note, note=note, tempo=tempo)
+                token = conv(inst=inst, back_notes=back_note, note=note, tempo=tempo)
+
                 if token is not None:
+                    if conv.token_type == "<SME>":
+                        clip_count += 1
+                    if clip_count >= 8:
+                        aya_node_inst = self.marge_clip(clip, aya_node_inst)
+                        clip = np.array([], dtype=int)
+                        back_note = None
+                        clip_count = 0
+
                     token_id = self.tokenizer.get(token)
                     clip = np.append(clip, token_id)
 
             back_note = note
-            clip_time = note.start
 
-        if len(clip) > 50:
-            clip = np.append(clip, self.tokenizer.get(constants.END_SEQ_TOKEN))
+        if len(clip) > 4:
             aya_node_inst = self.marge_clip(clip, aya_node_inst)
         return aya_node_inst
 
     def marge_clip(self, clip, aya_node_inst):
-        #clip = np.append(clip, self.tokenizer.get(constants.END_SEQ_TOKEN))
         aya_node_inst.append(clip)
 
         return aya_node_inst
@@ -214,34 +206,28 @@ class MidiToAyaNode(_AbstractMidiToAyaNode):
         else:
             return False, self.error_reason
 
-    def ct_tempo(self):
-        try:
-            ct = ConvTempo(directory=self.directory + "/" + self.file_name, midi_data=self.midi_data, change_tempo=120)
-            ct.convert()
-            self.midi_data = ct.midi_data
-        except OSError or IndexError or ValueError or mido.midifiles.meta.KeySignatureError or EOFError or KeyError or ZeroDivisionError:
-            self.error_reason = f"{self.directory}/{self.file_name}でテンポ変換中にエラーが発生。処理を中断します。"
-            self.is_error = True
 
+class MidiToSequece(_AbstractMidiToAyaNode):
+    def __init__(self, tokenizer: Tokenizer, directory: str, file_name: str, program_list):
+        super().__init__(MidiToSequece, tokenizer, directory, file_name, program_list)
+        self.sequence_dict: dict = dict()
+        self.sequence_count = 0
+        self.context = 8
 
-class MidiToAyaNode_TGT(_AbstractMidiToAyaNode):
+    def add_sequence(self, seq_pare: dict):
+        self.sequence_dict[f'array_{self.sequence_count}'] = seq_pare
+        self.sequence_count += 1
 
     def save(self, save_directory: str) -> [bool, str]:
         if not self.is_error:
-
-            array_dict = {f'array{i}': arr for i, arr in enumerate(self.aya_node)}
-            if len(array_dict) > 1:
-                np.savez(save_directory + "/" + self.file_name, **array_dict)
-                return True, "処理が正常に終了しました。"
+            if len(self.sequence_dict) > 2:
+                np.savez(save_directory + self.file_name, **self.sequence_dict)
+                return True, "正常に終了しました。"
             else:
                 return False, "オブジェクトが何らかの理由で見つかりませんでした。"
         else:
             return False, self.error_reason
 
-    def __init__(self, tokenizer: Tokenizer, directory: str, file_name: str, program_list, midi_data=None):
-        super().__init__(MidiToAyaNode_TGT, tokenizer, directory, file_name, program_list, midi_data)
-        self.aya_node: List[dict] = []
-
     def convert(self):
         if not self.is_error:
             program_count = 0
@@ -249,76 +235,72 @@ class MidiToAyaNode_TGT(_AbstractMidiToAyaNode):
             for inst in self.midi_data.instruments:
                 inst: Instrument = inst
                 if not inst.is_drum and inst.program in self.program_list:
-                    aya_node_inst = self.ct_aya_node(inst)
-
-                    self.aya_node = self.aya_node + aya_node_inst
+                    self.ct_aya_node(inst)
                     program_count += 1
 
             if program_count == 0:
                 self.is_error = True
                 self.error_reason = f"{self.directory}/{self.file_name}に、欲しい楽器がありませんでした。"
 
-    def ct_aya_node(self, inst: Instrument) -> list:
-
-        """
-            Instrumentsから1音ずつ取り出し、Tokenizerで変換する。
-            clip = [<START>, S, P, V, D, H, S, P, V, D, H ...<END>]
-            さらに60秒ごとにスプリットし、以下のような配列構造を作る。
-            aya_node_inst = [clip_1, clip_2 ... clip_n]
-
-            よって、二次元配列のndarrayを返す。
-            :param inst: インストゥルメント
-            :return: 60秒にクリッピングされた旋律の配列(2次元)
-            """
-
-        clip = np.array([], dtype=int)
-        clip_dict: dict = dict()
-        aya_node_inst = np.array([], dtype=object)
-        is_seq = True
-        back_note = None
-
-        clip_time: float = 0
-        split_count: int = 1
-
+    def ct_aya_node(self, inst: Instrument):
+        back_note: Note | None = None
+        key = np.array([], dtype=int)
+        value = np.array([], dtype=int)
         sorted_notes = sorted(inst.notes, key=lambda notes: notes.start)
 
         for note in sorted_notes:
             note: Note = note
 
-            tempo = self.get_tempo(note.start)
-            measure_time = (60 / tempo) * 4
-
-            if clip_time >= measure_time * 4 * split_count:
-                if is_seq:
-                    clip_dict['src'] = clip.tolist()
-                else:
-                    clip_dict['tgt'] = clip.tolist()
-                    aya_node_inst = np.append(aya_node_inst, clip_dict)
-
-                clip_dict = dict()
-                clip = np.array([], dtype=int)
-                is_seq = not is_seq
-                split_count += 1
-
-            if back_note is None:
-                clip = np.append(clip, self.tokenizer.get(constants.START_SEQ_TOKEN))
-
             for conv in self.token_converter:
-                conv: Token = conv
-
-                token = conv(back_notes=back_note, note=note, tempo=tempo)
+                token: str = conv(inst=inst, back_notes=back_note, note=note, tempo=self.get_tempo(note.start))
                 if token is not None:
-                    token_id = self.tokenizer.get(token)
-                    clip = np.append(clip, token_id)
+                    if token == "<BLANK>":
+                        token_id = self.tokenizer.get(token)
+                        value = np.append(value, token_id)
+                        self.step(key, value)
+                        key = np.array([], dtype=int)
+                        value = np.array([self.tokenizer.get("<SME>")], dtype=int)
+                        back_note = None
+                    elif token == "<SME>":
+                        new_key, new_value = self.step(key, value)
+                        key = new_key
+                        value = new_value
+                        token_id = self.tokenizer.get(token)
+                        value = np.append(value, token_id)
+                    else:
+                        token_id = self.tokenizer.get(token)
+                        value = np.append(value, token_id)
 
             back_note = note
-            clip_time = note.start
-
-
-        return aya_node_inst.tolist()
-
-    def marge_clip(self, clip, aya_node_inst):
-        #clip = np.append(clip, self.tokenizer.get(constants.END_SEQ_TOKEN))
-        aya_node_inst.append(clip)
-
-        return aya_node_inst
+        if len(value) >= 10:
+            self.step(key, value)
+
+
+    def step(self, key:ndarray, value:ndarray):
+        if np.isin(1, value):
+            key = value
+            value = np.array([], dtype=int)
+        elif np.sum(key==3) > self.context - 1:
+            new_value = np.append(value, self.tokenizer.get("<ESEQ>"))
+            new_value = np.insert(new_value, 0, self.tokenizer.get("<CONTINUE>"))
+            clip = {
+                'key': key.copy(),
+                'value': new_value.copy()
+            }
+            self.add_sequence(clip)
+            indices = np.where(key==3)[0][1]
+            key = key[indices:]
+            key = np.concatenate((key, value))
+            value = np.array([], dtype=int)
+        else:
+            new_value = np.append(value, self.tokenizer.get("<ESEQ>"))
+            new_value = np.insert(new_value, 0, self.tokenizer.get("<CONTINUE>"))
+            clip = {
+                'key': key.copy(),
+                'value': new_value.copy()
+            }
+            self.add_sequence(clip)
+            key = np.concatenate((key, value))
+            value = np.array([], dtype=int)
+
+        return key, value

mortm-2.0b3/mortm/datasets.py

@@ -0,0 +1,36 @@
+'''
+Tokenizerで変換したシーケンスを全て保管します。
+'''
+import random
+import time
+
+import torch
+from torch.utils.data import Dataset
+import numpy as np
+from .progress import LearningProgress
+
+
+class MORTM_DataSets(Dataset):
+    def __init__(self, progress: LearningProgress, positional_length):
+        self.key: list = list()
+        self.value: list = list()
+        self.progress = progress
+        self.positional_length = positional_length
+
+    def __len__(self):
+        return len(self.key)
+
+    def __getitem__(self, item):
+        return (torch.tensor(self.key[item], dtype=torch.long, device=self.progress.get_device()),
+                torch.tensor(self.value[item], dtype=torch.long, device=self.progress.get_device()))
+
+    def add_data(self, music_seq: np.ndarray):
+        suc_count = 0
+        for i in range(len(music_seq) - 1):
+            seq = music_seq[f'array_{i + 1}'].tolist()
+            if (100 < len(seq['key']) < self.positional_length) or 4 in seq['key']:
+                self.key.append(seq['key'].tolist())
+                self.value.append(seq['value'].tolist())
+                suc_count += 1
+
+        return suc_count

{mortm-1.2 → mortm-2.0b3}/mortm/de_convert.py

@@ -3,27 +3,33 @@ from pretty_midi import Instrument, Note, PrettyMIDI
 from typing import List
 
 from .tokenizer import Tokenizer, PITCH_TYPE, START_TYPE, SHIFT_TYPE, VELOCITY_TYPE, DURATION_TYPE
-from .aya_node import Token
+from .token import Token, ShiftTimeContainer
 
 
-def ct_token_to_midi(tokenizer: Tokenizer, seq: Tensor, save_directory:str, program=1):
+
+
+def ct_token_to_midi(tokenizer: Tokenizer, seq: Tensor, save_directory:str, program=1, tempo=120):
     seq = seq[1:]
     midi = PrettyMIDI()
     inst: Instrument = Instrument(program=program)
     note = Note(pitch=0, velocity=100, start=0, end=0)
     back_note = None
-    token_converter_list = tokenizer.token_list
+    token_converter_list = tokenizer.music_token_list
+    container = ShiftTimeContainer(0, tempo)
     for token_id in seq:
         token = tokenizer.rev_get(token_id.item())
-        if token_id == 2:
+        if token_id == 392:
             break
+        if token_id == 3:
+            container.shift()
+
         for con in token_converter_list:
-            token_type = con(token=token, back_notes=back_note, note=note)
+            token_type = con(token=token, back_notes=back_note, note=note, container=container, tempo=tempo)
             if token_type == DURATION_TYPE:
                 inst.notes.append(note)
                 back_note = note
                 note = Note(pitch=0, velocity=100, start=0, end=0)
     midi.instruments.append(inst)
-
+    print(inst.notes)
     midi.write(save_directory)
     return midi