MORTM 3.1__tar.gz → 3.2__tar.gz

{mortm-3.1 → mortm-3.2}/MORTM.egg-info/PKG-INFO

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

{mortm-3.1 → mortm-3.2}/MORTM.egg-info/SOURCES.txt

@@ -5,21 +5,14 @@ MORTM.egg-info/SOURCES.txt
 MORTM.egg-info/dependency_links.txt
 MORTM.egg-info/top_level.txt
 mortm/__init__.py
-mortm/_epoch.py
 mortm/constants.py
 mortm/convert.py
 mortm/custom_token.py
-mortm/datasets.py
 mortm/de_convert.py
-mortm/epoch.py
 mortm/eval.py
 mortm/generate.py
 mortm/gmail_messanger.py
 mortm/messager.py
-mortm/noam.py
-mortm/reinforcement.py
-mortm/tokenizer.py
-mortm/train.py
 mortm/models/__init__.py
 mortm/models/bertm.py
 mortm/models/mortm.py
@@ -28,4 +21,13 @@ mortm/models/modules/__init__.py
 mortm/models/modules/attention.py
 mortm/models/modules/config.py
 mortm/models/modules/layers.py
-mortm/models/modules/progress.py
+mortm/models/modules/progress.py
+mortm/re/RLDF.py
+mortm/re/__init__.py
+mortm/train/__init__.py
+mortm/train/datasets.py
+mortm/train/epoch.py
+mortm/train/noam.py
+mortm/train/re_train.py
+mortm/train/tokenizer.py
+mortm/train/train.py

{mortm-3.1 → mortm-3.2}/PKG-INFO

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

{mortm-3.1 → mortm-3.2}/mortm/convert.py

@@ -1,18 +1,25 @@
 from typing import List, Any
 
-import mido
 import numpy as np
-from numpy import ndarray
 from pretty_midi.pretty_midi import PrettyMIDI, Instrument, Note, TimeSignature
 from abc import abstractmethod, ABC
 from typing import TypeVar, Generic
 from .custom_token import Token, ShiftTimeContainer
-from .tokenizer import Tokenizer
+from mortm.train.tokenizer import Tokenizer
 
 T = TypeVar("T")
 class _AbstractMidiToAyaNode(ABC):
 
     def __init__(self, instance: Generic[T],  tokenizer: Tokenizer, directory: str, file_name: str, program_list, midi_data=None,):
+        '''
+        MIDIをトークンのシーケンスに変換するクラスの抽象クラス
+        :param instance: 子クラスのインスタンス
+        :param tokenizer: 変換するトークナイザー
+        :param directory: MIDIのディレクトリパス
+        :param file_name: ディレクトリにあるMIDIのファイル名
+        :param program_list: MIDIの楽器のプログラムリスト
+        :param midi_data: PrettyMIDIのインスタンス(Optinal)
+        '''
         self.program_list = program_list
         self.directory = directory
         self.file_name = file_name
@@ -44,6 +51,11 @@ class _AbstractMidiToAyaNode(ABC):
         self.convert()
 
     def get_midi_change_scale(self, scale_up_key):
+        '''
+        MIDIの音程を変更する。
+        :param scale_up_key: いくつ音程を上げるか
+        :return:
+        '''
         midi = PrettyMIDI()
 
         for ins in self.midi_data.instruments:
@@ -68,6 +80,11 @@ class _AbstractMidiToAyaNode(ABC):
         return midi
 
     def expansion_midi(self) -> List[Any]:
+        '''
+        データ拡張する関数。
+        MIDIデータを全スケール分に拡張する。
+        :return: MIDIのリスト
+        '''
         converts = []
         key = 5
         if not self.is_error:
@@ -82,6 +99,11 @@ class _AbstractMidiToAyaNode(ABC):
         return converts
 
     def get_tempo(self, start: float):
+        '''
+        MIDIのテンポを取得する関数
+        :param start:
+        :return:
+        '''
         tempo = 0
         for i in range(len(self.tempo_change_time)):
             if start >= self.tempo_change_time[i]:
@@ -98,32 +120,22 @@ class _AbstractMidiToAyaNode(ABC):
         pass
 
 class MIDI2Seq(_AbstractMidiToAyaNode):
+    '''
+    MIDIをトークンのシーケンスに変換するクラス
+    '''
 
-    def __init__(self, tokenizer: Tokenizer, directory: str, file_name: str, program_list, midi_data=None):
+    def __init__(self, tokenizer: Tokenizer, directory: str, file_name: str, program_list, midi_data=None, split_measure=12):
         super().__init__(MIDI2Seq, tokenizer, directory, file_name, program_list, midi_data)
         self.aya_node = [0]
+        self.split_measure = split_measure
 
     def convert(self):
         """
         以下のステップでMidiが変換される
-        1. テンポ固定
-            120テンポに変換される。
-        2. 指定した楽器があるかを検索する
-            インスタンス化した際に、指定したprogram_listに乗っ取り、該当する楽器があるかを検索する
-        3. ノートを変換する。
-            self.ct_aya_nodeにインストを渡すことで、MORTMに適した形に変換する。
-
-        また、変換したインストゥルメントは以下のような配列構造になる。
-
-        1_music = [
-                    [1 inst's 60s clip],
-                        ...
-                    [1 inst's 60s clip],
-                    [2 inst's 60s clip],
-                        ...
-                    [n inst's 60s clip]
-                    ]
-        :return:なし。
+        1. Instrumentsから楽器を取り出す。
+        2. 楽器の音を1音ずつ取り出し、Tokenizerで変換する。
+        3. clip = [<START>, S, P, D, S, P, D, ...<END>]
+        :return:なし
         """
         if not self.is_error:
             program_count = 0
@@ -141,17 +153,6 @@ class MIDI2Seq(_AbstractMidiToAyaNode):
 
     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)
         aya_node_inst = []
         back_note = None
@@ -175,7 +176,7 @@ class MIDI2Seq(_AbstractMidiToAyaNode):
                 if token is not None:
                     if conv.token_type == "<SME>":
                         clip_count += 1
-                    if clip_count >= 12:
+                    if clip_count >= self.split_measure:
                         clip = np.append(clip, self.tokenizer.get("<ESEQ>"))
                         aya_node_inst = self.marge_clip(clip, aya_node_inst)
                         clip = np.array([], dtype=int)

{mortm-3.1 → mortm-3.2}/mortm/custom_token.py

@@ -1,29 +1,45 @@
 from pretty_midi import Note, Instrument
 from abc import abstractmethod
 
-
 def ct_time_to_beat(time: float, tempo: int) -> int:
+    '''
+    Convert time to beat.
+    :param time:
+    :param tempo:
+    :return:
+    '''
     b4 = 60 / tempo
-    b8 = b4 / 2
-    b16 = b8 / 2
-    b32 = b16 / 2
-    b64 = b32 / 2
+    measure = b4 * 4
+    # 96 subdivisions per measure
+    b96 = measure / 96
 
-    beat, sub = calc_time_to_beat(time, b64)
+    beat, sub = calc_time_to_beat(time, b96)
 
     return beat
 
 
 def ct_beat_to_time(beat: float, tempo: int) -> float:
+    '''
+    Convert beat to time.
+    :param beat:
+    :param tempo:
+    :return:
+    '''
     b4 = 60 / tempo
-    b8 = b4 / 2
-    b16 = b8 / 2
-    b32 = b16 / 2
-    b64 = b32 / 2
-    return float(beat) * b64
+    measure = b4 * 4
+    # 96 subdivisions per measure
+    b96 = measure / 96
+
+    return float(beat) * b96
 
 
 def calc_time_to_beat(time, beat_time) -> (int, int):
+    '''
+    Convert time to beat.
+    :param time:
+    :param beat_time:
+    :return:
+    '''
     main_beat: int = time // beat_time
     sub_time: int = time % beat_time
     return main_beat, sub_time
@@ -230,7 +246,7 @@ class CLS(SpecialToken):
 class StartRE(MusicToken):
 
     def _set_tokens(self, tokens: dict):
-        max_length = 64
+        max_length = 96
         tokens_length = len(tokens)
         for i in range(max_length + 1):
             tokens[f's_{i}'] = tokens_length + i
@@ -253,8 +269,7 @@ class StartRE(MusicToken):
                 shift = int(now_start)
                 if shift < 0:
                     container.is_error = True
-                #print(shift % 64)
-                return shift % 64
+                return shift % 96
             else:
                 back_start = ct_time_to_beat(back_notes.start, tempo)
                 shift = int(now_start - back_start)
@@ -266,32 +281,14 @@ class StartRE(MusicToken):
             container.shift_measure = False
             if shift < 0:
                 container.is_error = True
-            return shift % 64
-
-
-class Pitch(MusicToken):
-
-    def is_my_token(self, seq):
-        pass
-
-    def _set_tokens(self, tokens: dict):
-        max_length = 127
-        tokens_length = len(tokens)
-        for i in range(max_length + 1):
-            tokens[f'p_{i}'] = tokens_length + i
-
-    def de_convert(self, number: int, back_note, note: Note, tempo, container: ShiftTimeContainer):
-        note.pitch = int(number)
-
-    def get_token(self, inst: Instrument, back_notes: Note, note: Note, tempo, container: ShiftTimeContainer) -> int:
-        p: int = note.pitch
-        return p
+            return shift % 96
 
 
 class Duration(MusicToken):
 
     def _set_tokens(self, tokens: dict):
-        max_length = 192
+        # allow up to 3 measures (96 * 3)
+        max_length = 96 * 3
         tokens_length = len(tokens)
         for i in range(max_length + 1):
             tokens[f'd_{i}'] = tokens_length + i
@@ -305,7 +302,28 @@ class Duration(MusicToken):
         end = ct_time_to_beat(note.end, tempo)
         d = int(max(abs(end - start), 1))
 
-        if 192 < d:
-            d = 191
+        if 96 * 3 < d:
+            d = 96 * 3 - 1
 
         return d
+
+
+
+class Pitch(MusicToken):
+
+    def is_my_token(self, seq):
+        pass
+
+    def _set_tokens(self, tokens: dict):
+        max_length = 127
+        tokens_length = len(tokens)
+        for i in range(max_length + 1):
+            tokens[f'p_{i}'] = tokens_length + i
+
+    def de_convert(self, number: int, back_note, note: Note, tempo, container: ShiftTimeContainer):
+        note.pitch = int(number)
+
+    def get_token(self, inst: Instrument, back_notes: Note, note: Note, tempo, container: ShiftTimeContainer) -> int:
+        p: int = note.pitch
+        return p
+

{mortm-3.1 → mortm-3.2}/mortm/de_convert.py

@@ -1,9 +1,8 @@
 from torch import Tensor
 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 .custom_token import Token, ShiftTimeContainer
+from mortm.train.tokenizer import Tokenizer, DURATION_TYPE
+from .custom_token import ShiftTimeContainer
 
 
 

{mortm-3.1 → mortm-3.2}/mortm/eval.py

@@ -11,7 +11,7 @@ from numpy import ndarray
 import numpy as np
 import matplotlib.pyplot as plt
 from mortm.models.mortm import MORTM
-from .tokenizer import Tokenizer
+from mortm.train.tokenizer import Tokenizer
 from abc import abstractmethod
 
 

mortm-3.2/mortm/models/bertm.py

@@ -0,0 +1,92 @@
+import torch
+from torch import nn
+from torch import Tensor
+import torch.nn.functional as F
+from .modules.layers import MORTMEncoder
+from .modules.config import MORTMArgs
+
+
+class MeanPoolingWithMask(nn.Module):
+    """
+    Applies mean pooling to the input tensor, considering an optional attention mask.
+
+    This module calculates the mean of the token embeddings along the sequence dimension,
+    ignoring positions marked as padding in the attention mask.
+    """
+    def __init__(self):
+        """Initializes the MeanPoolingWithMask module."""
+        super().__init__()
+
+    def forward(self, last_hidden_state: Tensor, attention_mask: torch.Tensor = None) -> torch.Tensor:
+        """
+        Performs the mean pooling operation.
+
+        Args:
+            last_hidden_state (torch.Tensor): The tensor containing the hidden states from the encoder.
+                                               Expected shape: [batch_size, sequence_length, hidden_size] (B, S, D).
+            attention_mask (torch.Tensor, optional): The mask indicating which tokens are valid (1) and which are padding (0).
+                                                     Expected shape: [batch_size, sequence_length] (B, S).
+                                                     If None, all tokens are considered valid. Defaults to None.
+
+        Returns:
+            torch.Tensor: The pooled output tensor.
+                          Shape: [batch_size, hidden_size] (B, D).
+        """
+        if attention_mask is None:
+            # If no mask is provided, perform simple mean pooling over the sequence dimension.
+            pooled_output = torch.mean(last_hidden_state, dim=1)
+        else:
+            # --- Padding-aware Mean Pooling ---
+            # 1. Expand attention mask to match the hidden state dimensions: [B, S] -> [B, S, D]
+            #    We need to ensure the mask is float for multiplication.
+            input_mask_expanded = attention_mask.unsqueeze(-1).expand(last_hidden_state.size()).float()
+
+            # 2. Sum the embeddings for non-padding tokens.
+            #    Multiply hidden states by the expanded mask (padding tokens become zero vectors).
+            #    Then sum across the sequence dimension (dim=1).
+            sum_embeddings = torch.sum(last_hidden_state * input_mask_expanded, dim=1)
+
+            # 3. Calculate the number of valid (non-padding) tokens for each sequence.
+            #    Sum the expanded mask across the sequence dimension.
+            #    Clamp the sum to a minimum value of 1e-9 to avoid division by zero if a sequence has only padding (edge case).
+            sum_mask = torch.clamp(input_mask_expanded.sum(dim=1), min=1e-9)
+
+            # 4. Compute the mean by dividing the sum of embeddings by the number of valid tokens.
+            pooled_output = sum_embeddings / sum_mask
+
+        return pooled_output
+
+
+class BERTM(nn.Module):
+
+    def __init__(self, args: MORTMArgs, progress):
+        super(BERTM, self).__init__()
+        self.encoder = MORTMEncoder(args=args,
+                                     layer_norm_eps=1e-5,
+                                     progress=progress)
+        self.embedding = nn.Embedding(args.vocab_size, args.d_model)
+
+        self.pooling = MeanPoolingWithMask()
+
+        self.norm = nn.LayerNorm(args.d_model, eps=1e-5)
+        self.linear = nn.Linear(args.d_model, args.d_model)
+
+        self.Wout = nn.Linear(args.d_model, 2)
+
+    def forward(self, src: Tensor, input_padding_mask=None):
+        """
+        src: 入力テンソル (バッチサイズ, シーケンス長, 特徴量次元)
+        input_padding_mask: パディングマスク (バッチサイズ, シーケンス長)
+        """
+        src = self.embedding(src)
+        # Encoderのforwardメソッドを呼び出す
+        out = self.encoder(src=src, mask=None,
+                           src_key_padding_mask=input_padding_mask,
+                           is_causal=False)
+        out = self.pooling(out, input_padding_mask)
+        out = self.norm(out)
+        out = self.linear(out)
+        out = F.gelu(out)
+        out = self.Wout(out)
+
+        return out

mortm-3.2/mortm/models/modules/PositionalEncoding.py

@@ -0,0 +1,27 @@
+import torch
+import torch.nn as nn
+import math
+
+from .progress import LearningProgress
+
+
+class PositionalEncoding(nn.Module):
+
+    def __init__(self, d_model, progress: LearningProgress, 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, device=progress.get_device())
+        position = torch.arange(0, max_len, dtype=torch.float, device=progress.get_device()).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)).to(progress.get_device())
+
+        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-3.1 → mortm-3.2}/mortm/models/modules/layers.py

@@ -30,13 +30,12 @@ class DummyDecoder(nn.Module):
 
 
 class MORTMEncoder(nn.Module):
-    def __init__(self, d_model, dim_ff, num_head, num_layer, dropout, batch_first, bias, layer_norm_eps, progress):
+    def __init__(self, args: MORTMArgs, layer_norm_eps, progress):
         super(MORTMEncoder, self).__init__()
-        self.num_layer = num_layer
-        self.layers = _get_clones(MORTMEncoderLayer(d_model=d_model, dim_ff=dim_ff, num_head=num_head, dropout=dropout, batch_first=batch_first,
-                                                    bias=bias, layer_norm_eps=layer_norm_eps, progress=progress), self.num_layer)
+        self.num_layer = args.e_layer
+        self.layers = _get_clones(MORTMEncoderLayer(args, layer_norm_eps=layer_norm_eps, progress=progress), self.num_layer)
 
-        self.norm = LayerNorm(d_model, eps=1e-5, bias=True, dtype=torch.float32)
+        self.norm = LayerNorm(args.d_model, eps=1e-5, bias=True, dtype=torch.float32)
 
     def forward(self, src, mask, src_key_padding_mask, is_causal):
         memory = src
@@ -53,27 +52,22 @@ class MORTMEncoder(nn.Module):
 
 
 class MORTMEncoderLayer(nn.Module):
-    def __init__(self, d_model, dim_ff, num_head, dropout, batch_first, bias, layer_norm_eps, progress):
+    def __init__(self, args: MORTMArgs, layer_norm_eps, progress):
         super(MORTMEncoderLayer, self).__init__()
 
-        self.d_model = d_model
-        self.dim_ff = dim_ff
-        self.dropout = dropout
-
-
-        self.self_attn =FlashSelfAttentionM(d_model, num_head, dropout, progress=progress)
-
-        self.norm1 = LayerNorm(d_model, eps=layer_norm_eps, bias=True, dtype=torch.float32)
-        self.norm2 = LayerNorm(d_model, eps=layer_norm_eps, bias=True, dtype=torch.float32)
+        self.d_model = args.d_model
+        self.dim_ff = args.dim_feedforward
+        self.dropout = args.dropout
 
 
-        self.dropout1 = nn.Dropout(dropout)
-        self.dropout2 = nn.Dropout(dropout)
+        self.self_attn =FlashSelfAttentionM(args.d_model, args.num_heads, args.dropout, progress=progress)
+        self.ffn = MoE(args.d_model, args.dim_feedforward, args.num_experts, args.topk_experts, args.num_groups, args.topk_groups)
 
+        self.norm1 = LayerNorm(args.d_model, eps=layer_norm_eps, bias=True, dtype=torch.float32)
+        self.norm2 = LayerNorm(args.d_model, eps=layer_norm_eps, bias=True, dtype=torch.float32)
 
-        self.f_linear = nn.Linear(self.d_model, self.dim_ff)
-        self.f_drop = nn.Dropout(dropout)
-        self.ff_linear = nn.Linear(self.dim_ff, self.d_model)
+        self.dropout1 = nn.Dropout(args.dropout)
+        self.dropout2 = nn.Dropout(args.dropout)
 
     def forward(self, memory, mask, src_key_padding_mask, is_causal):
         y = memory
@@ -92,11 +86,7 @@ class MORTMEncoderLayer(nn.Module):
         return self.dropout1(y)
 
     def ff_block(self, y: Tensor):
-        y = self.f_linear(y)
-        y = F.relu(y)
-        y = self.f_drop(y)
-        y = self.ff_linear(y)
-        return self.dropout2(y)
+        return self.dropout2(self.ffn(y))
 
 
 class MORTMDecoder(nn.Module):
@@ -202,9 +192,6 @@ class MORTMDecoderLayer(nn.Module):
                     ):
         y, _ = self.cross_attention(y, mem, memory_key_padding_mask=memory_key_padding_mask, tgt_key_padding_mask=tgt_key_padding_mask,
                                     attn_mask=attn_mask, is_causal=is_causal)
-
-        #y, _ = self.cross_attention(y, mem, mem, key_padding_mask=memory_key_padding_mask,
-        #                            is_causal=is_causal)
         return self.dropout2(y)
 
     def ff_block(self, y: Tensor):

{mortm-3.1 → mortm-3.2}/mortm/models/mortm.py

@@ -19,15 +19,11 @@ class MORTM(nn.Module):
         self.d_model = args.d_model
         self.dim_feedforward = args.dim_feedforward
         self.dropout = args.dropout
-        self.positional: PositionalEncoding = PositionalEncoding(self.d_model, progress, args.dropout, args.position_length * 10).to(
-            self.progress.get_device())
         self.decoder = MORTMDecoder(args,
                                batch_first=True, bias=True,
                                layer_norm_eps=1e-5, progress=progress)
 
-        self.encoder = MORTMEncoder(d_model=args.d_model, dim_ff=args.dim_feedforward, num_layer=args.e_layer,
-                                    num_head=args.num_heads, dropout=args.dropout,
-                                    batch_first=True, bias=True,
+        self.encoder = MORTMEncoder(args,
                                     layer_norm_eps=1e-5,
                                     progress=progress)
 
@@ -40,14 +36,9 @@ class MORTM(nn.Module):
 
     def forward(self, src, tgt=None, src_mask=None, tgt_mask=None, input_padding_mask=None,
                 tgt_padding_mask=None, src_is_causal=False, tgt_is_causal=False):
-        sec_e: Tensor = self.embedding(src)
-        sec_e = sec_e.permute(1, 0, 2)
+        src_e: Tensor = self.embedding(src)
 
-        src_p: Tensor = self.positional(sec_e)
-        src_p = src_p.permute(1, 0, 2)
-
-
-        out = self.decoder(tgt=src_p, memory=None, tgt_mask=tgt_mask,
+        out = self.decoder(tgt=src_e, memory=None, tgt_mask=tgt_mask,
                            memory_key_padding_mask=input_padding_mask,
                            tgt_key_padding_mask=input_padding_mask, memory_is_causal=src_is_causal, tgt_is_causal=src_is_causal)
 

{mortm-3.1/mortm → mortm-3.2/mortm/train}/datasets.py

@@ -1,6 +1,7 @@
 '''
 Tokenizerで変換したシーケンスを全て保管します。
 '''
+import random
 
 import torch
 from torch.utils.data import Dataset
@@ -29,7 +30,7 @@ class MORTM_SEQDataset(Dataset):
         return torch.tensor(self.seq[item], dtype=torch.long, device=self.progress.get_device())
 
 
-class MORTM_DataSets(Dataset):
+class ClassDataSets(Dataset):
     def __init__(self, progress: LearningProgress, positional_length):
         self.key: list = list()
         self.value: list = list()
@@ -40,17 +41,26 @@ class MORTM_DataSets(Dataset):
         return len(self.key)
 
     def __getitem__(self, item):
-        return (torch.tensor(self.key[item], dtype=torch.long, device=self.progress.get_device()),
+        if self.value[item] == 0:
+            ind = [i for i, v in enumerate(self.key[item]) if v == 3]
+            r = 4 + random.randint(0, 8)
+            if r != 12 and r < len(ind):
+                v = self.key[item][:ind[r]]
+            else:
+                v = self.key[item]
+        else:
+            v = self.key[item]
+        return (torch.tensor(v, 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):
+    def add_data(self, music_seq: np.ndarray, value):
         suc_count = 0
         for i in range(len(music_seq) - 1):
-            seq = music_seq[f'array_{i + 1}'].tolist()
-            if (90 < len(seq['key']) < self.positional_length) or (4 in seq['key'] and len(seq['key']) < 90):
-                if len(seq['value']) < self.positional_length:
-                    self.key.append(seq['key'].tolist())
-                    self.value.append(seq['value'].tolist())
-                    suc_count += 1
-
-        return suc_count
+            seq = music_seq[f'array{i + 1}'].tolist()
+            if 90 < len(seq) < self.positional_length and seq.count(4) < 3:
+                self.key.append(seq)
+                self.value.append(value)
+                suc_count += 1
+
+        return suc_count
+

mortm-3.2/mortm/train/re_train.py

@@ -0,0 +1,214 @@
+import datetime
+import json
+import time
+
+from torch import Tensor
+import torch
+from torch.nn.utils.rnn import pad_sequence
+from torch.utils.tensorboard import SummaryWriter
+
+from .train import find_npz_files
+from .datasets import ClassDataSets
+from .train import  _get_padding_mask, _send_prediction_end_time, progress_bar, update_log
+from mortm.models.modules.progress import LearningProgress, _DefaultLearningProgress
+from mortm.models.bertm import BERTM
+from torch.utils.data.dataset import random_split
+from torch.nn import CrossEntropyLoss
+from mortm.models.mortm import MORTMArgs
+from .noam import noam_lr
+from torch.optim.lr_scheduler import LambdaLR
+from torch.utils.data import DataLoader
+from .epoch import EpochObserver
+import numpy as np
+
+# デバイスを取得
+def _set_train_data(directory, datasets, mortm_datasets, v):
+    print("Starting load....")
+    loss_count = 0
+    count = 0
+    dataset_length = 0
+    loss_data = 0
+    print(len(datasets))
+    for i in range(len(datasets)):
+        count += 1
+        np_load_data = np.load(f"{directory[i]}/{datasets[i]}", allow_pickle=True)
+
+        if len(np_load_data) > loss_data:
+            dataset_length += mortm_datasets.add_data(np_load_data, v)
+            print(f"\r {count}/{len(datasets)} | Dataset Length:{dataset_length} | Load[{directory[i]}/{datasets[i]}]", end="")
+        else:
+            loss_count += 1
+    print("load Successful!!")
+    print(f"データセットの規模（曲数）：{len(datasets) - loss_count}")
+    print("---------------------------------------")
+
+    return mortm_datasets
+
+
+def collate_fn(batch):
+
+    src_list = [item[0] for item in batch]  # 各タプルのsrcを抽出
+    tgt_list = [item[1] for item in batch]  # 各タプルのtgtを抽出
+
+    tgt_list = torch.tensor(tgt_list)
+    src = pad_sequence(src_list, batch_first=True, padding_value=0)
+    return src, tgt_list
+
+def get_verification_loss(model: BERTM, val_loader: DataLoader, criterion: CrossEntropyLoss, progress: LearningProgress):
+    model.eval()
+    val_loss = 0.0
+    with torch.no_grad():
+        for src, tgt in val_loader:
+
+            tgt: Tensor = tgt.to(progress.get_device())
+            #src = torch.cat([torch.full((src.size(0), 1), 399, dtype=src.dtype, device=src.device), src], dim=1)
+
+            padding_mask_in: Tensor = _get_padding_mask(src, progress)
+
+            out = model(src, input_padding_mask=padding_mask_in)
+
+            outputs = out.view(-1, out.size(-1)).to(progress.get_device())
+
+            loss = criterion(outputs, tgt)  # 損失を計算
+            val_loss += loss.item()
+    model.train()
+    return val_loss / len(val_loader)
+
+def train_epoch(epoch, batch, args: MORTMArgs, train_dataset, val_dataset, message, save_directory, writer,
+                progress: LearningProgress, lr_param, warmup_steps,  accumulation_steps, is_save_training_progress):
+
+    model = BERTM(args=args, progress=progress).to(progress.get_device())
+    criterion = CrossEntropyLoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=1e-1 if lr_param is None else lr_param, betas=(0.9, 0.98))  # オプティマイザを定義
+
+    train_loader = DataLoader(train_dataset, batch_size=batch, shuffle=True, collate_fn=collate_fn)
+    val_loader = DataLoader(val_dataset, batch_size=batch, shuffle=True, collate_fn=collate_fn)
+
+    if lr_param is None:
+        scheduler = LambdaLR(optimizer=optimizer, lr_lambda=noam_lr(d_model=args.d_model, warmup_steps=warmup_steps))
+    else:
+        scheduler = None
+
+    loss_val = None
+    mail_bool = True
+    all_count = 1
+    for ep in range(epoch):
+        try:
+            print(f"epoch {ep + 1} start....")
+            count = 1
+            epoch_loss = EpochObserver(1000)
+            verification_loss = 0.0
+
+            model.train()
+            optimizer.zero_grad()
+            for src, tgt in train_loader:
+                begin_time = time.time()
+                tgt: Tensor = tgt.to(progress.get_device())
+                src = src.to(progress.get_device())
+    #            src = torch.cat([torch.full((src.size(0), 1), 399, dtype=src.dtype, device=src.device), src], dim=1)
+                src_pad = _get_padding_mask(src, progress)
+
+                out = model(src, input_padding_mask=src_pad)
+
+
+                outputs = out.view(-1, out.size(-1)).to(progress.get_device())
+                loss = criterion(outputs, tgt)  # 損失を計算
+                epoch_loss.add(loss.item())
+
+                loss = loss / accumulation_steps
+                loss.backward()  # 逆伝播
+
+
+                if count % accumulation_steps == 0:  #実質バッチサイズは64である
+                    progress.step_optimizer(optimizer, model, accumulation_steps)
+                    if lr_param is None:
+                        scheduler.step()
+                    torch.cuda.empty_cache()
+
+                count += 1
+                end_time = time.time()
+
+                if mail_bool and message is not None:
+                    _send_prediction_end_time(message, len(train_loader), begin_time, end_time, args.vocab_size, epoch,
+                                              args.e_layer, args.num_heads, args.d_model, args.dim_feedforward, args.dropout,
+                                              args.position_length)
+                    mail_bool = False
+
+                if (count + 1) % message.step_by_message_count == 0:
+                    message.send_message("機械学習の途中経過について", f"Epoch {ep + 1}/{epoch}の"
+                                                                       f"learning sequence {count}結果は、\n {epoch_loss.get():.4f}でした。\n"
+                                                                       f"また、検証データの損失は{verification_loss:.4f}となっています。\n以上です。")
+                    #f"損失関数スケジューラーは{criterion.cs}です。")
+                writer.flush()
+
+                progress_bar(ep, epoch, count, len(train_loader), epoch_loss.get(), scheduler.get_last_lr() if lr_param is None else lr_param, verification_loss)
+                if (count + 1) % int(100000 / batch) == 0:
+                    torch.save(model.state_dict(), f"{save_directory}/MORTM.train.{ep}.{verification_loss:.4f}_{count}.pth")
+                    print("途中経過を保存しました。")
+
+                if (count + 1) % int(10000 / batch) == 0:
+                    print("検証損失を求めています")
+                    torch.cuda.empty_cache()
+                    verification_loss = get_verification_loss(model, val_loader, criterion, progress)
+                    writer.add_scalars("Train/Verification Loss", {"Train": epoch_loss.get(),
+                                                                   "Verification": verification_loss}, all_count)
+                update_log(model, writer, all_count)
+                all_count += 1
+
+            message.send_message("機械学習の途中経過について",
+                                 f"Epoch {ep + 1}/{epoch}の結果は、{epoch_loss.get():.4f}でした。\n"
+                                 f"また、検証データの損失は{verification_loss:.4f}となっています。\n以上です。")
+            writer.add_scalar('EpochLoss', epoch_loss.get(), epoch)  # 損失値を記録
+
+            if is_save_training_progress:
+                torch.save(model.state_dict(), f"{save_directory}/BERTM.train.{ep}.{verification_loss:.4f}.pth") #エポック終了時に途中経過を保存
+                print("途中経過を保存しました。")
+        except torch.cuda.OutOfMemoryError or RuntimeError:
+            torch.save(model.state_dict(), f"{save_directory}/MORTM.error_end.{epoch}.pth")
+            message.send_message("オーバーフローしました・。", f"{epoch}エポック中にオーバーフローが発生しました。\n"
+                                                              f"次のエポックに移行します。\n")
+        writer.close()
+    return model, loss_val
+
+
+
+
+
+
+def train_bertm(human_dir, ai_dir, args_dir, save_directory, epoch, batch_size, warmup_steps, message,
+                accumlation_steps, version,
+                train_split, lr_param=None, is_save_training_progress=False,  progress = _DefaultLearningProgress()):
+
+    args = MORTMArgs(args_dir)
+    today_date = datetime.date.today().strftime('%Y%m%d')
+    datasets = ClassDataSets(progress=progress, positional_length=args.position_length)
+
+    directory_human, file_name_human = find_npz_files(human_dir)
+    directory_ai, file_name_ai = find_npz_files(ai_dir)
+
+    datasets = _set_train_data(directory_human, file_name_human, datasets, 0)
+    datasets = _set_train_data(directory_ai, file_name_ai, datasets, 1)
+
+    print(f"検証データを抽出しています。")
+    train_size = int(train_split * len(datasets))
+    val_size = len(datasets) - train_size
+    train_dataset, val_dataset = random_split(datasets, [train_size, val_size])
+
+    writer = SummaryWriter(save_directory + f"/runs/{version}_{today_date}/")
+    print(len(train_dataset))
+    model, val_loss = train_epoch(epoch=epoch, batch=batch_size, args=args,
+                                  train_dataset=train_dataset, val_dataset=val_dataset,
+                                  message=message, save_directory=save_directory, writer=writer,
+                                  progress=progress, lr_param=lr_param, warmup_steps=warmup_steps,
+                                  accumulation_steps=accumlation_steps,
+                                  is_save_training_progress=is_save_training_progress)
+    message.send_message("機械学習終了のお知らせ",
+                         f"BERTM.{version}の機械学習が終了しました。 \n 結果の報告です。\n 損失関数: {val_loss}")
+
+
+    torch.save(model.state_dict(), f"{save_directory}/BERTM.{version}_{val_loss}.pth")  # できたモデルをセーブする
+
+    return model
+
+
+

{mortm-3.1/mortm → mortm-3.2/mortm/train}/tokenizer.py

@@ -3,8 +3,8 @@ from typing import List
 from numpy import ndarray
 
 import re
-from . import constants
-from .custom_token import Token, Pitch, Duration, StartRE, MeasureToken, TrackStart, TrackEnd, Blank, SequenceEnd, Gen, CLS
+from mortm import constants
+from mortm.custom_token import Token, Pitch, Duration, StartRE, MeasureToken, TrackStart, TrackEnd, Blank, SequenceEnd, Gen, CLS
 
 '''旋律トークン'''
 PITCH_TYPE = 'p'

{mortm-3.1/mortm → mortm-3.2/mortm/train}/train.py

@@ -19,7 +19,7 @@ from torch.optim.lr_scheduler import LambdaLR
 from torch.nn.utils.rnn import pad_sequence
 from torch.utils.tensorboard import SummaryWriter
 
-from .messager import Messenger, _DefaultMessenger
+from mortm.messager import Messenger, _DefaultMessenger
 from mortm.models.modules.progress import LearningProgress, _DefaultLearningProgress
 from .datasets import MORTM_SEQDataset
 from mortm.models.mortm import MORTM, MORTMArgs
@@ -91,19 +91,17 @@ def _get_padding_mask(input_ids, progress: LearningProgress):
 
 def collate_fn(batch):
     # バッチ内のテンソルの長さを揃える（パディングする）
-    #src_list = [item[0] for item in batch]  # 各タプルのsrcを抽出
-    #tgt_list = [item[1] for item in batch]  # 各タプルのtgtを抽出
     src = pad_sequence(batch, batch_first=True, padding_value=0)
-    #tgt = pad_sequence(tgt_list, batch_first=True, padding_value=0)
     return src
 
 
 def update_log(model, writer, global_step):
     for name, param in model.named_parameters():
-        writer.add_scalar(f"params_mean/{name}", param.mean(), global_step)
-        writer.add_scalar(f"params_std/{name}", param.std(), global_step)
+        if param.grad is not None:
+            writer.add_scalar(f"params_mean/{name}", param.grad.mean(), global_step)
+            writer.add_scalar(f"params_std/{name}", param.grad.std(), global_step)
 
-        writer.add_scalar(f"Parameter Value/{name}", param.norm(), global_step)
+            writer.add_scalar(f"Parameter Norm/{name}", param.grad.norm(), global_step)
 
 
 def progress_bar(epoch, sum_epoch, sequence, batch_size, loss, lr, verif_loss):

{mortm-3.1 → mortm-3.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='MORTM',
-    version='3.1',
+    version='3.2',
     author='Nagoshi Takaaki',
     author_email='nagoshi@kthrlab.jp',
     description='音楽の旋律生成を実現したシステム',

mortm-3.1/mortm/_epoch.py

@@ -1,3 +0,0 @@
-
-def epoch():
-    pass

mortm-3.1/mortm/models/bertm.py

@@ -1,52 +0,0 @@
-import torch
-from torch import nn
-from torch import Tensor
-from .modules.layers import MORTMEncoder
-from .modules.PositionalEncoding import PositionalEncoding
-
-
-class AttentionPooling(nn.Module):
-    def __init__(self, d_model):
-        super().__init__()
-        self.attn = nn.Linear(d_model, 1)
-
-    def forward(self, x):
-        # x: (B, T, D)
-        weights = self.attn(x)  # (B, T, 1)
-        weights = torch.softmax(weights, dim=1)  # 各トークンに重み付け
-        pooled = (weights * x).sum(dim=1)  # 重み付き平均 → (B, D)
-        return pooled
-
-
-class BERTM(nn.Module):
-
-    def __init__(self, vocab_size, d_model, dim_ff, num_head, num_layer,
-                 dropout, batch_first, bias, layer_norm_eps, progress):
-        super(BERTM, self).__init__()
-        self.encoder = MORTMEncoder(d_model=d_model, dim_ff=dim_ff, num_layer=num_layer,
-                                     num_head=num_head, dropout=dropout,
-                                     batch_first=batch_first, bias=bias,
-                                     layer_norm_eps=layer_norm_eps,
-                                     progress=progress)
-        self.embedding = nn.Embedding(vocab_size, d_model)
-        self.positional = PositionalEncoding(d_model, progress, dropout, max_len=5000)
-        self.Wout = nn.Linear(d_model, 2)
-
-    def forward(self, src: Tensor, input_padding_mask=None):
-        """
-        src: 入力テンソル (バッチサイズ, シーケンス長, 特徴量次元)
-        input_padding_mask: パディングマスク (バッチサイズ, シーケンス長)
-        """
-        src = self.embedding(src)
-        src = src.permute(1, 0, 2)
-        src = self.positional(src)
-        src = src.permute(1, 0, 2)
-
-        # Encoderのforwardメソッドを呼び出す
-        out = self.encoder(src=src, src_mask=None,
-                           src_key_padding_mask=input_padding_mask,
-                           src_is_causal=False)
-        out = out[:, 0, :]
-        out = self.Wout(out)
-
-        return out

mortm-3.1/mortm/models/modules/PositionalEncoding.py

@@ -1,77 +0,0 @@
-import torch
-import torch.nn as nn
-import math
-
-from .progress import LearningProgress
-
-class RelativePositionalEncoding(nn.Module):
-
-    def __init__(self, n_head, d_model, progress: LearningProgress, dropout=0.1, max_len=8000):
-        super(RelativePositionalEncoding, self).__init__()
-        self.dropout = nn.Dropout(p=dropout)
-
-        # Relative Positional Encodingのテンソルを生成
-        self.relative_position_bias_table = nn.Parameter(
-            torch.zeros((2 * max_len - 1, d_model), device=progress.get_device())
-        )
-        self.register_buffer(
-            "relative_position_index", self._generate_relative_position_index(max_len)
-        )
-        self.n_head = n_head  # ヘッドの数を設定
-        self._reset_parameters()
-
-    def forward(self, x):
-        # Relative Positional Encodingを適用
-        batch_size, seq_len, d_model = x.size()
-        relative_position_bias = self.relative_position_bias_table[
-            self.relative_position_index[:seq_len, :seq_len]
-        ].permute(2, 0, 1).unsqueeze(0)
-        relative_position_bias = relative_position_bias.repeat(batch_size, 1, 1, 1)
-
-        # ヘッドの数に合わせて形状を変更
-        num_heads = self.n_head  # ヘッドの数を修正
-        head_dim = d_model // num_heads
-        relative_position_bias = relative_position_bias.reshape(batch_size, num_heads, seq_len, seq_len)  # 要素数を調整
-
-        x = x + relative_position_bias
-
-        return self.dropout(x)
-
-    def _generate_relative_position_index(self, max_len):
-        """
-        相対位置インデックスを生成する関数
-        """
-        range_vec = torch.arange(max_len)
-        range_mat = range_vec.unsqueeze(0).repeat(max_len, 1)
-        distance_mat = range_mat - range_mat.transpose(0, 1)
-        distance_mat_clipped = torch.clamp(distance_mat, -max_len + 1, max_len - 1)
-        relative_position_index = distance_mat_clipped + max_len - 1
-        return relative_position_index
-
-    def _reset_parameters(self):
-        """
-        学習可能なパラメータを初期化する関数
-        """
-        nn.init.trunc_normal_(self.relative_position_bias_table, std=.02)
-
-
-class PositionalEncoding(nn.Module):
-
-    def __init__(self, d_model, progress: LearningProgress, 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, device=progress.get_device())
-        position = torch.arange(0, max_len, dtype=torch.float, device=progress.get_device()).unsqueeze(1)
-        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)).to(progress.get_device())
-
-        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-3.1/mortm/reinforcement.py

@@ -1,120 +0,0 @@
-import math
-
-import torch
-from typing import List
-from torch import Tensor
-from .tokenizer import Tokenizer, PITCH_TYPE
-
-from .custom_token import Token, _get_symbol
-
-
-def remove_subsequence_tensor(a, b):
-    len_b = b.shape[0]
-    for i in range(a.shape[0] - len_b + 1):
-        if torch.equal(a[i:i+len_b], b):
-            return torch.cat((a[:i], a[i+len_b:]))
-    return a
-
-
-def get_convert_measure_list(sequence):
-    '''
-    シーケンスから小節の区切り目のトークンを境目にスプリットし、その配列を返します。
-    :param sequence:  小節ごとに区切られたシーケンスの配列
-    :return: sequence
-    '''
-    segments = []
-    start_idx = None
-    for i, val in enumerate(sequence):
-        #print(i, val)
-        if val == 3:
-            if start_idx is not None and i > start_idx:
-                segments.append(sequence[start_idx:i])
-            start_idx = i + 1
-    return segments
-
-
-def compose_sequence_reward(sequence: Tensor, tokenizer: Tokenizer):
-    '''
-    シーケンスを受け取り、正しい生成の順番であるかを評価します。
-    通常は S -> P -> Dで生成されるはずです.
-
-
-    :param sequence: 一小節分のシーケンス
-    :param tokenizer: MORTMのトークナイザー
-    :return: 報酬
-    '''
-
-    reward_count = 0
-    token_list: List[Token] = tokenizer.music_token_list[1:]
-    token_count = 0
-    for seq in enumerate(sequence):
-        if not token_list[token_count].is_my_token(seq):
-            reward_count += 1
-
-        token_count += 1
-        if len(token_list) <= token_count:
-            token_count = 0
-
-    reward = _calc_loss(reward_count if token_count == 0 else 10, 0, 1e-4)
-
-    return reward
-
-
-
-
-def compose_measure_reward(measure, tokenizer: Tokenizer, last_duration):
-    pitch_token: Token = tokenizer.get_token_converter(PITCH_TYPE)
-
-    measure = measure[(pitch_token.start <= measure) | (measure >= pitch_token.end)]
-    i = 0
-    duration = 0
-    ld = 0
-    while i < len(measure):
-        if i == 0:
-            if last_duration is None:
-                duration += _get_symbol(tokenizer.rev_get(measure[i].item()))
-            else:
-                duration += _get_symbol(tokenizer.rev_get(measure[i].item())) - last_duration
-        elif i == len(measure) - 1:
-            ld = _get_symbol(tokenizer.rev_get(measure[i].item()))
-            if duration < 64 < duration + ld:
-                duration = 64
-            else:
-                duration += ld
-        elif i % 2 == 0:
-            duration += _get_symbol(tokenizer.rev_get(measure[i].item())) - _get_symbol(tokenizer.rev_get(measure[i - 1].item()))
-        else:
-            duration += _get_symbol(tokenizer.rev_get(measure[i].item()))
-
-        i += 1
-    reward = _calc_loss(duration, 64, 1e-5)
-
-    return reward, ld
-
-
-def _calc_loss(x, n:int, k:float):
-    return math.e ** (k * abs(x - n)) - 1
-
-
-def _reward_function(base_seq, sequence, tokenizer: Tokenizer):
-    if base_seq is not None:
-        seq = remove_subsequence_tensor(sequence, base_seq)
-    else:
-        seq = sequence
-    measure_list = get_convert_measure_list(seq)
-    reward = 100 if len(measure_list) is 0 else 0
-    last_duration = None
-    for measure in measure_list:
-        cmr, ld = compose_measure_reward(measure, tokenizer, last_duration)
-        cmr /= len(measure_list)
-        last_duration = ld
-        csr = compose_sequence_reward(measure, tokenizer) / len(measure_list)
-        reward += (csr + cmr)
-
-    return reward
-
-
-def calc_mortm_loss(probs: Tensor, reward):
-    loss = -(reward * probs.sum()) / 200
-    return loss
-