miding 3.1.4__py3-none-any.whl → 3.1.6__py3-none-any.whl

miding/__init__.py

@@ -0,0 +1,4 @@
+from prediction import Predict
+from preparation1 import *
+
+name = 'miding'

miding/distribution.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+
+class RandomDistributionReform:
+    def __init__(self, array, args: tuple):
+        self.array = array
+        self.args = args
+        if len(self.array.shape) > 1:
+            self.shape = (self.array.shape[1], self.array.shape[1])
+        else:
+            self.shape = self.array.shape
+
+    def beta_distribution(self):
+        beta = np.random.beta(a=self.args[0], b=self.args[1], size=self.shape)
+        return np.dot(self.array, beta)
+
+    def gamma_distribution(self):
+        gamma = np.random.gamma(shape=self.args[0], scale=self.args[1], size=self.shape)
+        return np.dot(self.array,gamma)

miding/model.py

@@ -0,0 +1,62 @@
+from os import environ
+
+environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+from time import time
+import matplotlib.pyplot as plt
+
+from keras.models import Sequential
+from keras.layers import Dense, Input, GRU
+from keras.optimizers import Adam
+from keras.losses import MeanSquaredError
+from keras.callbacks import EarlyStopping, ModelCheckpoint
+
+from preparation1 import create_databases
+
+
+superparameters = {'batch_size': 256, 'train_length': 8}
+structure = {'GRU1':20, 'GRU2': 16, 'Dense': 4, 'optimizer':'Adam', 'lr': 0.0156}
+train_x, train_y, validate_x, validate_y = create_databases(midi_path='midi', train_length=superparameters['train_length'], step=1)
+
+epochs = 1024
+version = int(time())
+
+model = Sequential([
+    Input(shape=(superparameters['train_length'], structure['Dense']), batch_size=superparameters['batch_size']),
+    GRU(units=structure['GRU1'], return_sequences=True),
+    GRU(units=structure['GRU2'], return_sequences=False),
+    Dense(units=structure['Dense'], activation='softmax'),
+])
+
+optimizer = Adam(learning_rate=structure['lr'])
+model.compile(optimizer=optimizer, loss=MeanSquaredError(), metrics=['accuracy'])
+callbacks_list = [
+EarlyStopping(monitor='val_accuracy', patience=128, mode='max'),
+ModelCheckpoint(filepath=f'model_{version}_best.keras', monitor='val_accuracy', save_best_only=True)
+]
+model.summary()
+
+history = model.fit(
+                    x=train_x,
+                    y=train_y,
+                    batch_size=superparameters['batch_size'],
+                    epochs=epochs,
+                    callbacks=callbacks_list,
+                    validation_data=(validate_x, validate_y)
+                    )
+
+accuracy = history.history['accuracy']
+val_accuracy = history.history['val_accuracy']
+
+
+plt.plot(range(0, len(accuracy)), accuracy, 'b--',label='Train Accuracy')
+plt.plot(range(0, len(val_accuracy)), val_accuracy, label='Validation Accuracy')
+plt.suptitle(f'Effect of GRU Model:{version}')
+plt.xlabel('Epochs')
+plt.ylabel('Accuracy')
+plt.title(f'Parameters: {str(structure)}')
+plt.legend()
+plt.savefig(fname=f'Model_{version}_Analysis.png', dpi=1980)
+plt.show()
+
+model.save(filepath=f'Model_{version}_ep{len(val_accuracy)}_va{round(max(val_accuracy), 3)}.keras')

miding/prediction.py

@@ -0,0 +1,128 @@
+import numpy as np
+from time import time
+from os import environ
+from mido import Message, MidiFile, MidiTrack, MetaMessage, bpm2tempo
+environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+
+from distribution import RandomDistributionReform
+from preparation1 import read_model, load_midi_file, get_seed
+
+
+class FormateError(TypeError):
+    pass
+
+
+class Predict:
+    def __init__(self,
+                 seed,
+                 epoch: int,
+                 model_version,
+                 instrument_code: int = 0,
+                 result_save_path: str = 'result',
+                 ):
+        """
+        The main class, called to predict scores.
+        :param seed: the start score, need an array in size (1, 8, 4)
+        :param epoch: the total length of the generated score will be 8(seed length) + epoch
+        """
+        self.save_path = result_save_path
+        self.model = read_model(version=model_version)
+        self.seed = seed
+        self.epoch = epoch
+        self.instrument = instrument_code
+        self.prediction = None
+        self.sequence = []
+        self.save_file_name = f'{int(time())}-ß'
+        self.mid = MidiFile()
+        self.track0 = MidiTrack()
+        self.track1 = MidiTrack()
+        self.mid.tracks.append(self.track0)
+        self.mid.tracks.append(self.track1)
+        self.cycle()
+        self.save_track0()
+        self.save_track1()
+        self.mid.save(f'{self.save_path}/{self.save_file_name}.mid')
+
+    def cycle(self):
+        for i in range(0, self.epoch):
+            self.prediction = self.model.predict(self.seed)
+            print(self.seed[0, -1, :])
+            self.prediction = RandomDistributionReform(self.prediction, args=(5, 5))
+            self.prediction = self.prediction.beta_distribution()
+            for j in range(0, 7):
+                self.seed[0, j, :] = self.seed[0, j + 1, :]
+            self.seed[0, 7, :] = self.prediction[0, :]
+            self.sequence.append(self.prediction[0])
+
+    def save_track0(self):
+        self.track0.append(MetaMessage('time_signature', numerator=4, denominator=4, time=0))
+        self.track0.append(MetaMessage('key_signature', key='C', time=0))
+        self.track0.append(MetaMessage('set_tempo', tempo=bpm2tempo(80), time=0))
+        self.track0.append(MetaMessage('track_name', name=self.save_file_name, time=0))
+        self.track0.append(MetaMessage('end_of_track', time=1))
+
+    def save_track1(self):
+        self.track1.append(MetaMessage('track_name', name='Instrument', time=0))
+        self.track1.append(Message(type='program_change', program=self.instrument, time=0))
+        middle = []
+        for i in self.sequence:
+            if i[0] < 0.5:
+                i[0] = 0
+            else:
+                i[0] = 1
+            args = (int(i[0]), int(i[1] * 128), int(i[2] * 128), int(i[3] * 128))
+            if args[1] > 127 or args[2] > 127:
+                continue
+            elif args[3] > 1000:
+                continue
+            middle.append(args)
+        middle = np.array(middle).T
+        a, b= middle[0].T, middle[1].T
+        count = 0
+        for i, j in enumerate(b):
+            if a[i] == 1:
+                c = middle.T[i + 1:]
+                if np.array([0, j]) not in c[:, :2]:
+                    middle_f = np.delete(middle, obj=i, axis=1)
+                    middle = middle_f
+                    print(middle_f)
+                    continue
+            count += 1
+        middle = middle.T
+        for i in middle:
+            if i[0] < 0.5:
+               event_flag = 'note_off'
+            else:
+               event_flag = 'note_on'
+            self.track1.append(Message(type=event_flag, note=i[1], velocity=i[2], time=i[3]))
+        self.track1.append(MetaMessage('end_of_track', time=1))
+
+
+class Seed:
+    def __init__(self, midi_file: str):
+        self.midi = midi_file
+        self.check_formate()
+        self.seed = np.zeros(shape=(1, 8, 4))
+        self.score = load_midi_file(self.midi)
+        self.form_seed_array(self.score)
+
+    def check_formate(self):
+        if '.mid' not in self.midi:
+            fe = FormateError()
+            fe.add_note(f'{self.midi} is not a correct input formate.')
+            raise fe
+
+    def form_seed_array(self, score: list):
+        for i in range(0, 8):
+            for j in range(0, 4):
+                self.seed[0, i, j] = score[i][j]
+
+    def get_seed(self):
+        return self.seed
+
+
+if __name__ == '__main__':
+    # Predict(seed=get_seed(), epoch=256, model_version=1751770203)
+    s = Seed(midi_file='example_seed.mid')
+    Predict(seed=s.get_seed(),epoch=128, model_version=1751770203)

miding/preparation1.py

@@ -0,0 +1,88 @@
+import numpy as np
+from mido import Message, MidiFile
+from random import randint
+
+from os import listdir, environ
+environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+
+from keras.models import load_model
+
+
+def load_midi_file(file: str):
+    score = []
+    midi = MidiFile(file)
+    for t, track in enumerate(midi.tracks):
+        if t > 0:
+            for msg in track:
+                if type(msg) == Message:
+                    msg = msg.copy()
+                    if msg.type == 'note_on':
+                        flag = 1
+                    elif msg.type == 'note_off':
+                        flag = 0
+                    else:
+                        continue
+                    unit = (flag, msg.note, msg.velocity, msg.time)
+                    score.append(unit)
+    return score
+
+
+def create_midi_data(midi_path: str):
+    database_list = []
+    for file in listdir(path=midi_path):
+        if '.mid' in file:
+            file_name = f'{midi_path}/{file}'
+            score = load_midi_file(file_name)
+            for unit in score:
+                database_list.append(unit)
+
+    database_list += database_list[::-1]
+
+    return database_list
+
+def create_databases(midi_path: str, train_length: int, step: int):
+    database_list = create_midi_data(midi_path=midi_path)
+    x_list = []
+    y_list = []
+
+    for i in range(0, len(database_list) - train_length, step):
+        x_list.append(database_list[i: i + train_length])
+        y_list.append(database_list[i + train_length])
+
+    x = np.zeros(shape=(len(x_list), train_length, 4))
+    y = np.zeros(shape=(len(y_list), 4))
+
+    for i, pair in enumerate(x_list):
+        for j, unit in enumerate(pair):
+            for k, note in enumerate(unit):
+                x[i, j, k] = int(note) / 128
+    for i, unit in enumerate(y_list):
+        for j, note in enumerate(unit):
+            y[i, j] = int(note) / 128
+
+    validate_size = int(len(x_list) * 0.9)
+    validate_x = x[validate_size:]
+    validate_y = y[validate_size:]
+    train_x = x[:validate_size]
+    train_y = y[:validate_size]
+
+    return train_x, train_y, validate_x, validate_y
+
+def read_model(version: int):
+    model = load_model(filepath=f'model_{version}_best.keras')
+    return model
+
+def get_seed():
+    a, b, c, d = create_databases(midi_path='midi', train_length=8, step=1)
+    seed = np.zeros(shape=(1, 8, 4))
+    split_position = randint(16, 256)
+    for i in range(0, 8):
+        seed[0, :, :] = a[split_position, :, :]
+    print(split_position)
+    print(seed)
+    return seed
+
+if __name__ == '__main__':
+    get_seed()
+

{miding-3.1.4.dist-info → miding-3.1.6.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: miding
-Version: 3.1.4
+Version: 3.1.6
 Summary: A generator of midi score based on GRU.
 Author-email: Jerry_Skywolf <jerryskywolf@outlook.com>
-License-Expression: GPL-2.0
+License-Expression: GPL-3.0
 Project-URL: Homepage, https://github.com/JerrySkywolf/miding
 Project-URL: Issues, https://github.com/JerrySkywolf/miding/issues
 Project-URL: DOWNLOAD, https://github.com/JerrySkywolf/miding/releases

miding-3.1.6.dist-info/RECORD

@@ -0,0 +1,11 @@
+miding/__init__.py,sha256=iMh6ucfGUnEF3lMvVLI_wizGpoMFj_ln0k-kifqCOws,77
+miding/distribution.py,sha256=xoHE4GMTFiS6Fld-2em21r87zc7waehtvmgEAhQFfNE,647
+miding/model.py,sha256=B5bVHCjKZCA56N5pktlVBfpW73-JSvQ3sQalahI5hT0,2306
+miding/prediction.py,sha256=0Zi2U1LhVBEM6diAke5XL5MugK-ae9vdVEfh62hHB6U,4750
+miding/preparation1.py,sha256=0POCRHtePWNYAZjasbAjoNA6xv6OE0i76zBKDM4WFrY,2673
+miding-3.1.6.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+miding-3.1.6.dist-info/METADATA,sha256=2QfkCWRDHNADuXri-P2kl9Ve6dvP2lGEq_JytHVpKZk,1706
+miding-3.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+miding-3.1.6.dist-info/entry_points.txt,sha256=x20XsdgK_5BjEIaoggcmSR1xFLBdrvcQSi6oI3f9f7w,45
+miding-3.1.6.dist-info/top_level.txt,sha256=wOjSKSx1Fwtcm2G2fTlXklPxK8bkPIQZI_ff25Upm_w,7
+miding-3.1.6.dist-info/RECORD,,

miding-3.1.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+miding

miding-3.1.4.dist-info/RECORD

@@ -1,6 +0,0 @@
-miding-3.1.4.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-miding-3.1.4.dist-info/METADATA,sha256=ZQAD-jRaDaWOa7QStUXLZVj0S5XROy5Yr288sMmNQ9g,1706
-miding-3.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-miding-3.1.4.dist-info/entry_points.txt,sha256=x20XsdgK_5BjEIaoggcmSR1xFLBdrvcQSi6oI3f9f7w,45
-miding-3.1.4.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-miding-3.1.4.dist-info/RECORD,,

miding-3.1.4.dist-info/top_level.txt

@@ -1 +0,0 @@
-