def __init__(self):
# 1.从sqlite中读取common_melody_pattern
common_pattern_cls = CommonMusicPatterns(
COMMON_MELODY_PAT_NUM) # 这个类可以获取常见的主旋律组合
common_pattern_cls.restore('melody') # 直接从sqlite文件中读取
self.common_melody_pats = common_pattern_cls.common_pattern_list # 常见的旋律组合列表
self.melody_pats_num_list = common_pattern_cls.pattern_number_list # 这些旋律组合出现的次数列表
# 2.从sqlite中读取所有按键组合数据
keyperss_pattern_cls = BaseMusicPatterns()
keyperss_pattern_cls.restore('keypress')
self.all_keypress_pats = keyperss_pattern_cls.common_pattern_list # 常见的旋律组合列表
self.keypress_pat_count = keyperss_pattern_cls.pattern_number_list # 这些旋律组合出现的次数列表
# 3.从sqlite中读取常见的骨干音组合数据
core_note_pattern_cls = CommonMusicPatterns(
COMMON_CORE_NOTE_PAT_NUM) # 这个类可以获取常见的骨干音组合
core_note_pattern_cls.restore('core_note') # 直接从sqlite文件中读取
self.common_corenote_pats = core_note_pattern_cls.common_pattern_list # 常见的旋律组合列表
# 4.从sqlite中读取每首歌的相邻两小节的音高变化情况，和每个段落的前半部分与后半部分的差异的合理的阈值
self.ShiftConfidence = ShiftConfidenceCheck() # 计算训练集中所有歌曲相邻两小节的音高变化情况
self.DiffNoteConfidence = DiffNoteConfidenceCheck()
self.ShiftConfidence.restore('melody_shift')
self.DiffNoteConfidence.restore('melody_diffnote')
# 5.获取主旋律模型的输入数据，用于和生成结果进行比对
self.input_data = np.load(
os.path.join(PATH_PATTERNLOG, 'MelodyInputData.npy')).tolist()
DiaryLog.warn('Restoring of melody associated data has finished!')
def restore(self):
"""读取加花的组合数据"""
for type_it in range(3):
fill_pattern_cls = BaseMusicPatterns(store_count=False)
fill_pattern_cls.restore('Fill%d' % type_it)
self.classified_fill_pats[
type_it] = fill_pattern_cls.common_pattern_list
def __init__(self):
# 1.从sqlite中读取common_string_pattern
common_pattern_cls = CommonMusicPatterns(COMMON_STRING_PAT_NUM) # 这个类可以获取常见的string组合
common_pattern_cls.restore('String') # 直接从sqlite文件中读取
self.common_string_pats = common_pattern_cls.common_pattern_list # 常见的string组合列表
# 2.获取和弦的根音组合
self.string_avr_root = get_nearest_number_multiple(STRING_AVR_NOTE, 12)
rc_pattern_cls = BaseMusicPatterns()
rc_pattern_cls.restore('StringRC')
self.all_rc_pats = rc_pattern_cls.common_pattern_list
self.rc_pat_num = len(self.all_rc_pats)
# 3.从sqlite中读取每首歌的string的前后段差异，以及string与同时期和弦的差异的合理的阈值
string_confidence_config = StringConfidenceCheckConfig()
self.StringConfidence = AccompanyConfidenceCheck(string_confidence_config)
self.StringConfidence.restore('string')
DiaryLog.warn('Restoring of string associated data has finished!')
def __init__(self):
# 1.获取和弦的根音组合
cc_pattern_cls = BaseMusicPatterns()
cc_pattern_cls.restore('ChordChord')
self.all_cc_pats = cc_pattern_cls.common_pattern_list
self.cc_pat_num = len(self.all_cc_pats)
# 2.获取主旋律与同时期和弦的状态转移矩阵
self.transfer_count = np.load(
os.path.join(PATH_PATTERNLOG, 'ChordTransferCount.npy'))
self.real_transfer_count = np.load(
os.path.join(PATH_PATTERNLOG, 'ChordTransferCountReal.npy'))
assert self.transfer_count.shape[0] == COMMON_CORE_NOTE_PAT_NUM * 2 + 2
assert self.transfer_count.shape[1] == len(CHORD_LIST) + 1
assert self.real_transfer_count.shape[
0] == COMMON_CORE_NOTE_PAT_NUM * 2 + 2
assert self.real_transfer_count.shape[1] == len(CHORD_LIST) + 1
DiaryLog.warn('Restoring of chord associated data has finished!')
def __init__(self, all_keypress_pats):
# 1.从sqlite中读取common_bass_pattern
common_pattern_cls = CommonMusicPatterns(
COMMON_BASS_PAT_NUM) # 这个类可以获取常见的bass组合
common_pattern_cls.restore('Bass') # 直接从sqlite文件中读取
self.common_bass_pats = common_pattern_cls.common_pattern_list # 常见的bass组合列表
# 2.获取和弦的根音组合
self.bass_avr_root = get_nearest_number_multiple(BASS_AVR_NOTE, 12)
rc_pattern_cls = BaseMusicPatterns()
rc_pattern_cls.restore('BassRC')
self.all_rc_pats = rc_pattern_cls.common_pattern_list
self.rc_pat_num = len(self.all_rc_pats)
self.keypress_pat_num = len(all_keypress_pats) # 一共有多少种按键组合数据（步长为2拍）
# 3.从sqlite中读取每首歌的bass的前后段差异，以及bass与同时期和弦的差异的合理的阈值
bass_confidence_config = BassConfidenceCheckConfig()
self.BassConfidence = AccompanyConfidenceCheck(bass_confidence_config)
self.BassConfidence.restore('bass')
DiaryLog.warn('Restoring of bass associated data has finished!')
def __init__(self, all_keypress_pats):
# 1.从sqlite中读取common_piano_guitar_pattern
common_pattern_cls = CommonMusicPatterns(
COMMON_PG_PAT_NUM) # 这个类可以获取常见的piano_guitar组合
common_pattern_cls.restore('PianoGuitar') # 直接从sqlite文件中读取
self.common_pg_pats = common_pattern_cls.common_pattern_list # 常见的bass组合列表
# 2.获取和弦的根音组合
self.pg_avr_root = get_nearest_number_multiple(PG_AVR_NOTE, 12)
rc_pattern_cls = BaseMusicPatterns()
rc_pattern_cls.restore('PGRC')
self.all_rc_pats = rc_pattern_cls.common_pattern_list
self.rc_pat_num = len(self.all_rc_pats)
self.keypress_pat_num = len(all_keypress_pats) # 一共有多少种按键组合数据（步长为2拍）
# 3.从sqlite中读取每首歌的piano_guitar的前后段差异，以及piano_guitar与同时期和弦的差异的合理的阈值
pg_confidence_config = PgConfidenceCheckConfig()
self.PgConfidence = AccompanyConfidenceCheck(pg_confidence_config)
self.PgConfidence.restore('piano_guitar')
DiaryLog.warn(
'Restoring of piano_guitar associated data has finished!')
def __init__(self, tone_restrict=None):
self.input_data = [] # 输入model的数据
self.output_data = [] # 从model输出的数据
self.continuous_bar_data = [[] for t in range(TRAIN_FILE_NUMBERS)
] # 每一首歌连续的小节计数
self.continuous_bar_data_nres = [[] for t in range(TRAIN_FILE_NUMBERS)
] # 每一首歌无限制的小节计数
self.keypress_pat_data = [[] for t in range(TRAIN_FILE_NUMBERS)
] # 二维数组 第一维是歌曲列表 第二维是按键的组合（步长是2拍）
self.all_keypress_pats = [[0 for t in range(16)]] # 主旋律按键组合的对照表
self.keypress_pat_count = [0] # 各种按键组合的计数
self.core_note_ary_nres = [[] for t in range(TRAIN_FILE_NUMBERS)
] # 每一首歌每一拍的骨干音列表
self.core_note_pat_nres = [[] for t in range(TRAIN_FILE_NUMBERS)
] # 骨干音组合数据
self.melody_pat_data = [[] for t in range(TRAIN_FILE_NUMBERS)
] # 有调式限制的旋律组合数据
self.melody_pat_data_nres = [[] for t in range(TRAIN_FILE_NUMBERS)
] # 无调式限制的旋律组合数据
self.ShiftConfidence = ShiftConfidenceCheck() # 计算训练集中所有歌曲相邻两小节的音高变化情况
self.DiffNoteConfidence = DiffNoteConfidenceCheck(
) # 计算训练集中所有歌曲所有段落前半段和后半段的按键和音高上的差异
# 1.从数据集中读取所有歌曲的主旋律数据，并变更为以音符步长为单位的列表
self.raw_train_data = get_raw_song_data_from_dataset(
'main', tone_restrict)
self.raw_melody_data = get_raw_song_data_from_dataset(
'main', None) # 没有旋律限制的主旋律数据 用于训练其他数据
self.section_data = get_section_data_from_dataset()
for song_it in range(TRAIN_FILE_NUMBERS):
if self.raw_train_data[song_it] != dict():
self.raw_train_data[song_it] = flat_array(
self.raw_train_data[song_it])
else:
self.raw_train_data[song_it] = [] # 对于没有主旋律的歌曲，将格式转化为list格式
if self.raw_melody_data[song_it] != dict():
self.raw_melody_data[song_it] = flat_array(
self.raw_melody_data[song_it])
else:
self.raw_train_data[song_it] = []
raw_melody_data_nres = copy.deepcopy(self.raw_melody_data)
# 2.获取最常见的主旋律组合
common_pattern_cls = CommonMusicPatterns(
COMMON_MELODY_PAT_NUM) # 这个类可以获取常见的主旋律组合
common_pattern_cls.train(self.raw_train_data, 0.125, 1, False)
common_pattern_cls.store('melody') # 存储在sqlite文件中
self.common_melody_pats = common_pattern_cls.common_pattern_list # 常见的旋律组合列表
self.melody_pats_num_list = common_pattern_cls.pattern_number_list # 这些旋律组合出现的次数列表
# 3.逐歌曲获取连续不为空的小节列表/按键数据/骨干音数据/
for song_it in range(TRAIN_FILE_NUMBERS):
# 3.1.获取没有调式限制的旋律数据
if raw_melody_data_nres[song_it]: # 获取相关没有调式限制的相关数据
# 3.1.1.获取旋律的按键数据
self.get_keypress_data(
song_it,
raw_melody_data_nres[song_it]) # 获取按键数据 当前有按键记为1 没有按键记为0
# 3.1.3.将它的主旋律编码为常见的旋律组合。如果该旋律组合不常见，则记为COMMON_MELODY_PAT_NUM+1
self.continuous_bar_data_nres[
song_it] = get_continuous_bar_cnt(
raw_melody_data_nres[song_it])
# 3.1.2.获取骨干音及骨干音的常见组合列表
self.core_note_ary_nres[song_it] = melody_core_note(
raw_melody_data_nres[song_it],
self.continuous_bar_data_nres[song_it],
self.section_data[song_it])
# 3.2.获取有调式限制的旋律数据
if self.raw_train_data[song_it]:
# 3.2.1.获取歌曲的连续不为空的小节序号列表
self.continuous_bar_data[song_it] = get_continuous_bar_cnt(
self.raw_train_data[song_it])
# 3.3.存储按键数据的组合列表
keyperss_pattern_cls = BaseMusicPatterns()
keyperss_pattern_cls.common_pattern_list = self.all_keypress_pats
keyperss_pattern_cls.pattern_number_list = self.keypress_pat_count
keyperss_pattern_cls.store('keypress')
# 4.获取无调式限制的常见骨干音组合列表
core_note_pattern_cls = CommonMusicPatterns(COMMON_CORE_NOTE_PAT_NUM)
core_note_pattern_cls.train(self.core_note_ary_nres, 0.125, 2)
core_note_pattern_cls.store('core_note') # 存储在sqlite文件中
self.common_corenote_pats = core_note_pattern_cls.common_pattern_list # 常见的旋律组合列表
# 5.根据常见的音符组合，对原始的旋律音符和骨干音列表进行编码
for song_it in range(TRAIN_FILE_NUMBERS):
# 5.1.编码无调式限制的主旋律及其骨干音
if raw_melody_data_nres[song_it]: # 没有调式限制的相关数据
self.melody_pat_data_nres[song_it] = MelodyPatternEncode(
self.common_melody_pats, raw_melody_data_nres[song_it],
0.125, 1).music_pattern_list
self.core_note_pat_nres[song_it] = CoreNotePatternEncode(
self.common_corenote_pats,
self.core_note_ary_nres[song_it], 0.125,
2).music_pattern_list
# 5.2.编码有调式限制的主旋律。如果该旋律组合不常见，则记为COMMON_MELODY_PAT_NUM+1
if self.raw_train_data[song_it]:
self.melody_pat_data[song_it] = MelodyPatternEncode(
self.common_melody_pats, self.raw_train_data[song_it],
0.125, 1).music_pattern_list
# 6.生成每首歌的旋律变化累积幅度的数据
# 6.1.生成每首歌的相邻两小节的音高变化情况，和每个段落的前半部分与后半部分的差异
for song_it in range(TRAIN_FILE_NUMBERS):
if raw_melody_data_nres[song_it]:
self.ShiftConfidence.train_1song(
raw_melody_data=raw_melody_data_nres[song_it],
section_data=self.section_data[song_it])
self.DiffNoteConfidence.train_1song(
raw_melody_data=raw_melody_data_nres[song_it],
section_data=self.section_data[song_it])
# 6.2.找出旋律变化和段落内差异前95%所在位置
self.ShiftConfidence.calc_confidence_level(0.95)
self.DiffNoteConfidence.calc_confidence_level(0.95)
self.ShiftConfidence.store(
'melody_shift') # 把shift_confidence_level和diff_note保存到sqlite中
self.DiffNoteConfidence.store('melody_diffnote')
# 7.生成每首歌的训练数据
for song_it in range(TRAIN_FILE_NUMBERS):
if self.raw_train_data[song_it]:
self.get_model_io_data(self.melody_pat_data[song_it],
self.continuous_bar_data[song_it])
np.save(os.path.join(PATH_PATTERNLOG, 'MelodyInputData.npy'),
self.input_data) # 在generate的时候要比较生成数据和训练集是否雷同，因此这个也要存储
DiaryLog.warn('Generation of melody train data has finished!')
def __init__(self, melody_pat_data, continuous_bar_data, corenote_pat_data, common_corenote_pats, chord_cls):
"""
:param melody_pat_data: 主旋律组合的数据
:param continuous_bar_data: 连续小节的计数数据
:param corenote_pat_data: 主旋律骨干音的组合数据
:param common_corenote_pats: 主旋律骨干音组合的对照表
:param chord_cls: 0.95开始这个参数变成和弦的类而不只是最后的和弦数据 因为需要用到和弦类的方法
"""
self.input_data = [] # 输入model的数据
self.output_data = [] # 从model输出的数据
# 1.从数据集中读取歌的string数据
raw_string_data = [] # 四维数组 第一维是string的编号 第二维是歌曲id 第三维是小节列表(dict) 第四维是小节内容
part_count = 1
while True:
string_part_data = get_raw_song_data_from_dataset('string' + str(part_count), None) # 从sqlite文件中读取的数据。三维数组，第一维是歌的id，第二维是小节的id，第三维是小节内容
if string_part_data == [dict() for t in range(TRAIN_FILE_NUMBERS)]:
break
raw_string_data.append(string_part_data)
part_count += 1
del part_count
for part_it in range(len(raw_string_data)):
for song_it in range(TRAIN_FILE_NUMBERS):
if raw_string_data[part_it][song_it] != dict():
raw_string_data[part_it][song_it] = flat_array(raw_string_data[part_it][song_it])
else:
raw_string_data[part_it][song_it] = [] # 对于没有和弦的歌曲，将格式转化为list格式
# 2.获取根音组合及根音-和弦配对组合
self.string_avr_root = get_nearest_number_multiple(STRING_AVR_NOTE, 12)
self.root_data, self.rc_pat_data, self.all_rc_pats, rc_pat_count = chord_cls.get_root_data(self.string_avr_root)
self.rc_pat_num = len(self.all_rc_pats)
rc_pattern_cls = BaseMusicPatterns()
rc_pattern_cls.common_pattern_list = self.all_rc_pats
rc_pattern_cls.pattern_number_list = rc_pat_count
rc_pattern_cls.store('StringRC')
# 3.将原数据转化成相对音高形式
rel_note_list = [[[] for t0 in range(TRAIN_FILE_NUMBERS)] for t in range(len(raw_string_data))]
for part_it in range(len(raw_string_data)):
for song_it in range(TRAIN_FILE_NUMBERS):
if raw_string_data[part_it][song_it] and melody_pat_data[song_it]:
rel_note_list[part_it][song_it] = one_song_rel_notelist_chord(raw_string_data[part_it][song_it], self.root_data[song_it], chord_cls.chord_data[song_it])
# 4.获取最常见的弦乐组合
common_pattern_cls = CommonMusicPatterns(COMMON_STRING_PAT_NUM) # 这个类可以获取常见的弦乐组合
common_pattern_cls.train(rel_note_list, 0.25, 2, multipart=True)
common_pattern_cls.store('String') # 存储在sqlite文件中
self.common_string_pats = common_pattern_cls.common_pattern_list # 常见的旋律组合列表
# 5.获取用于验证的数据
# 5.1.生成每首歌的piano_guitar的前后段差异，以及piano_guitar与同时期和弦的差异
string_confidence_config = StringConfidenceCheckConfig()
self.StringConfidence = AccompanyConfidenceCheck(string_confidence_config)
for part_it in range(len(raw_string_data)):
for song_it in range(TRAIN_FILE_NUMBERS):
if chord_cls.chord_data[song_it] and raw_string_data[part_it][song_it]:
self.StringConfidence.train_1song(raw_data=raw_string_data[part_it][song_it], chord_data=chord_cls.chord_data[song_it])
# 5.2.找出前90%所在位置
self.StringConfidence.calc_confidence_level(0.9)
self.StringConfidence.store('string')
# 6.将其编码为组合并获取模型的输入输出数据
for part_it in range(len(raw_string_data)):
for song_it in range(TRAIN_FILE_NUMBERS):
if raw_string_data[part_it][song_it] and melody_pat_data[song_it]:
string_pat_data = StringPatternEncode(self.common_string_pats, rel_note_list[part_it][song_it], 0.25, 2).music_pattern_list
self.get_model_io_data(string_pat_data, melody_pat_data[song_it], continuous_bar_data[song_it], corenote_pat_data[song_it], self.rc_pat_data[song_it])
DiaryLog.warn('Generation of string train data has finished!')
def __init__(self, melody_pat_data, continuous_bar_data, keypress_pat_data,
all_keypress_pats, chord_cls):
"""
:param melody_pat_data: 主旋律组合的数据
:param continuous_bar_data: 连续小节的计数数据
:param keypress_pat_data: 主旋律按键的组合数据
:param all_keypress_pats: 主旋律组合的按键对照表
:param chord_cls: 0.95开始这个参数变成和弦的类而不只是最后的和弦数据 因为需要用到和弦类的方法
"""
self.input_data = [] # 输入model的数据
self.output_data = [] # 从model输出的数据
# 1.从数据集中读取bass信息，并变更为以音符步长为单位的列表
raw_bass_data = get_raw_song_data_from_dataset('bass', None)
for song_it in range(TRAIN_FILE_NUMBERS):
if raw_bass_data[song_it] != dict():
raw_bass_data[song_it] = flat_array(raw_bass_data[song_it])
else:
raw_bass_data[song_it] = [] # 对于没有bass的歌曲，将格式转化为list格式
# 2.获取和弦的根音组合 预期的根音平均值为36（即比中央C低2个八度）
self.bass_avr_root = get_nearest_number_multiple(BASS_AVR_NOTE, 12)
self.root_data, self.rc_pat_data, self.all_rc_pats, rc_pat_count = chord_cls.get_root_data(
self.bass_avr_root)
self.keypress_pat_num = len(all_keypress_pats) # 一共有多少种按键组合数据（步长为2拍）
self.rc_pat_num = len(self.all_rc_pats)
rc_pattern_cls = BaseMusicPatterns()
rc_pattern_cls.common_pattern_list = self.all_rc_pats
rc_pattern_cls.pattern_number_list = rc_pat_count
rc_pattern_cls.store('BassRC')
# 3.将原bass数据转化成相对音高形式
rel_note_list = [[] for t in range(TRAIN_FILE_NUMBERS)]
for song_it in range(TRAIN_FILE_NUMBERS):
if raw_bass_data[song_it]:
rel_note_list[song_it] = one_song_rel_notelist_chord(
raw_bass_data[song_it],
self.root_data[song_it],
chord_cls.chord_data[song_it],
note_time_step=0.125)
# 4.获取最常见的Bass组合
common_pattern_cls = CommonMusicPatterns(
COMMON_BASS_PAT_NUM) # 这个类可以获取常见的bass组合
common_pattern_cls.train(rel_note_list, 0.125, 2, multipart=False)
common_pattern_cls.store('Bass') # 存储在sqlite文件中
self.common_bass_pats = common_pattern_cls.common_pattern_list # 常见的bass组合列表
# 5.获取用于验证的数据
# 5.1.生成每首歌的bass的前后段差异，以及bass与同时期和弦的差异
bass_confidence_config = BassConfidenceCheckConfig()
self.BassConfidence = AccompanyConfidenceCheck(bass_confidence_config)
for song_it in range(TRAIN_FILE_NUMBERS):
if chord_cls.chord_data[song_it] and raw_bass_data[song_it]:
self.BassConfidence.train_1song(
raw_data=raw_bass_data[song_it],
chord_data=chord_cls.chord_data[song_it])
# 5.2.找出前90%所在位置
self.BassConfidence.calc_confidence_level(0.9)
self.BassConfidence.store('bass')
# 6.获取模型的输入输出数据
for song_it in range(TRAIN_FILE_NUMBERS):
if rel_note_list[song_it] and melody_pat_data[song_it]:
bass_pat_data = BassPatternEncode(self.common_bass_pats,
rel_note_list[song_it],
0.125, 2).music_pattern_list
self.get_model_io_data(bass_pat_data, melody_pat_data[song_it],
continuous_bar_data[song_it],
keypress_pat_data[song_it],
self.rc_pat_data[song_it])
DiaryLog.warn('Generation of bass train data has finished!')
def __init__(self, melody_pat_data, raw_melody_data, continuous_bar_data,
core_note_pat_data):
self.input_data = [] # 输入model的数据
self.output_data = [] # 从model输出的数据
self.transfer_count = np.zeros(
[COMMON_CORE_NOTE_PAT_NUM * 2 + 2,
len(CHORD_LIST) + 1],
dtype=np.float32
) + np.e**(
-3
) # 主旋律/调式与同时期和弦的转移矩阵 0是空主旋律 1-400是大调对应的主旋律 401-800是小调对应的主旋律 801对应的是罕见主旋律
self.real_transfer_count = np.zeros(
[COMMON_CORE_NOTE_PAT_NUM * 2 + 2,
len(CHORD_LIST) + 1],
dtype=np.float32) # 主旋律/调式与同时期和弦的转移矩阵 与上个变量的区别是不添加e**(-3)
self.transfer = np.zeros(
[COMMON_CORE_NOTE_PAT_NUM * 2 + 2,
len(CHORD_LIST) + 1],
dtype=np.float32
) # 主旋律/调式与同时期和弦 概率取对数后的转移矩阵 这个转移矩阵的数字精度必须是float32的
# 1.从数据集中读取所有歌曲的和弦数据，并变更为以音符步长为单位的列表
self.chord_data = get_raw_song_data_from_dataset(
'chord', None) # 从sqlite文件中读取的数据。三维数组，第一维是歌的id，第二维是小节的id，第三维是小节内容
for song_it in range(TRAIN_FILE_NUMBERS):
if self.chord_data[song_it] != dict():
self.chord_data[song_it] = flat_array(self.chord_data[song_it])
else:
self.chord_data[song_it] = [] # 对于没有和弦的歌曲，将格式转化为list格式
# 2.和弦数据以1拍为单位存储，但在训练时以2拍为单位。因此逐两拍生成和弦-和弦组合
cc_pat_data, self.all_cc_pats, cc_pat_count = get_chord_chord_pattern(
self.chord_data) # 和弦-和弦组合
self.cc_pat_num = len(self.all_cc_pats)
cc_pattern_cls = BaseMusicPatterns()
cc_pattern_cls.common_pattern_list = self.all_cc_pats
cc_pattern_cls.pattern_number_list = cc_pat_count
cc_pattern_cls.store('ChordChord')
# 3.获取并保存主旋律与同时期和弦的状态转移矩阵
# 3.1.获取和弦的状态转移矩阵
tone_list = get_tone_list() # 获取训练用曲的旋律列表
for song_it in range(TRAIN_FILE_NUMBERS):
if self.chord_data[song_it] and melody_pat_data[song_it]:
self.freq_count(self.chord_data[song_it],
core_note_pat_data[song_it],
tone_list[song_it])
# 3.2.保存和弦的状态转移矩阵
np.save(os.path.join(PATH_PATTERNLOG, 'ChordTransferCount.npy'),
self.transfer_count)
np.save(os.path.join(PATH_PATTERNLOG, 'ChordTransferCountReal.npy'),
self.real_transfer_count)
# 4.生成输入输出数据
for song_it in range(TRAIN_FILE_NUMBERS):
if self.chord_data[song_it] and melody_pat_data[song_it]:
self.get_model_io_data(cc_pat_data[song_it],
melody_pat_data[song_it],
continuous_bar_data[song_it])
DiaryLog.warn('Generation of chord train data has finished!')