KaneAI - World’s First E2E Software Testing Agent.Book a Demo 
How to use note_event method in hypothesis
Best Python code snippet using hypothesis
data_utils.py
Source:data_utils.py 
1# -*- coding: utf-8 -*-2"""3Created on Sat Aug 28 17:32:32 20214@author: user5"""6import guitarpro as gp7import os8import numpy as np9import matplotlib.pyplot as plt10from sklearn.utils import shuffle11import librosa12import copy13# binary tab -----------------------------------------------------------------14def tabFrame2binary(t):15 b = np.zeros(5*6)16 for i in range(6):17 s = np.binary_repr( t[i].astype(int) , width=5 )18 b[i*5:i*5+5] = np.array(list(s), dtype=np.float32)19 return b20def tablature2binary(tablature):21 b = np.zeros( (5*6 , tablature.shape[1]) )22 for i in range(tablature.shape[1]):23 b[:, i] = tabFrame2binary(tablature[:, i])24 return b25def bool2int(x):26 y = 027 for i,j in enumerate(np.flip(x)):28 y += j<<i29 return y30def binary2tablature(b):31 t = np.zeros( (6, b.shape[1]) )32 for i in range(b.shape[1]):33 for j in range(6):34 t[j,i] = bool2int( b[j*5:j*5+5, i].astype(int) )35 t[ t==31 ] = -136 return t37# flat tab -------------------------------------------------------------------38def tabFrame2flatFretboard(t, frets_num=24):39 f = np.zeros( (6, frets_num+1) ) # 0-th fret is counted40 for i in range(len(t)):41 if t[i] >= 0 and t[i] <= frets_num:42 f[i, t[i].astype(int)] = 143 # print('before flat: ', f.shape)44 # print('after flat: ', f.flatten().shape)45 return f.flatten()46def tablature2flatFretboard(tablature, frets_num=24):47 f = np.zeros( ( 6*(frets_num+1) , tablature.shape[1] ) )48 for i in range( tablature.shape[1] ):49 f[:,i] = tabFrame2flatFretboard( tablature[:, i], frets_num=frets_num )50 return f51# full tab 3D ----------------------------------------------------------------52def tabFrame2Fretboard(t, frets_num=24):53 f = np.zeros( (6, frets_num+1) ) # 0-th fret is counted54 for i in range(len(t)):55 if t[i] >= 0 and t[i] <= frets_num:56 f[i, t[i].astype(int)] = 157 # print('before flat: ', f.shape)58 # print('after flat: ', f.flatten().shape)59 return f60# pianoroll column 2 tokens -------------------------------------------------61def pianorollFrame2tokens(c, compount=True):62 nz = np.where( c != 0 )[0]63 s = []64 for i in nz:65 if compount:66 s.append( 'note_' + str( i ) )67 else:68 s.append( 'note' )69 s.append( str( i ) )70 return s71# pianoroll 2 tokens ---------------------------------------------------------72def pianoroll2tokens(p, compount=True):73 s = ['<SOS>']74 for i in range( p.shape[1] ):75 c = pianorollFrame2tokens( p[:,i], compount )76 if len( c ) > 0:77 s.append( 'new_frame' )78 s.extend( c )79 s.append('<EOS>')80 return s81# tablature string 2 tokens ---------------------------------------------------------82string_names = ['E', 'A', 'D', 'G', 'B', 'E']83def tablatureFrame2tokens(c, compount=True):84 nz = np.where( c != -1 )[0]85 s = []86 for i in nz:87 if compount:88 s.append('string_' + string_names[ i ])89 s.append('fret_' + str(c[i].astype(int)))90 else:91 s.append('string')92 s.append( string_names[ i ] )93 s.append('fret')94 s.append(str(c[i].astype(int)))95 return s96# tablature 2 tokens ---------------------------------------------------------97def tablature2tokens(p, compount=True):98 s = ['<SOS>']99 for i in range( p.shape[1] ):100 c = tablatureFrame2tokens( p[:,i], compount )101 if len( c ) > 0:102 s.append( 'new_frame' )103 s.extend( c )104 s.append('<EOS>')105 return s106# event 2 full tab ---------------------------------------------------------107def event2fulltab(e):108 t = np.zeros( (6,25) )109 for p in e['pitches']:110 if p['fret'] < 25:111 t[ p['string']-1 , p['fret'] ] = 1112 return t113# end event2fulltab114def plotEvent(e):115 t = event2fulltab(e)116 plt.imshow(t, cmap='gray_r')117 return t118# end plotEvent119def patternOf2DTab(t):120 p = copy.deepcopy(t)121 if np.sum(p) != 0:122 while np.sum(p[:,0]) == 0:123 p = np.roll( p, [0,-1], axis=1 )124 return p125# end patternOf2DTab126def plotTab(t):127 plt.imshow(t, cmap='gray_r')128# end plotEvent129 130# %% plottings131def plot_full_tabs(t, titles=None):132 for i in range(t.shape[0]):133 plt.subplot( 4, (t.shape[0]-1)//4+1, i+1 )134 plt.imshow(t[i,:,:], cmap='gray_r')135 if titles is not None:136 if len(titles) == t.shape[0]:137 plt.title( titles[i] )138 else:139 if i == t.shape[0]-1:140 plt.title(titles)141 else:142 plt.title(str( i ))143def plot_flat_tabs(t, titles=None):144 for i in range(t.shape[1]):145 plt.subplot( 4, (t.shape[1]-1)//4+1, i+1 )146 plt.imshow( np.reshape( t[:,i], [6,25] ), cmap='gray_r')147 if titles is not None:148 if len(titles) == t.shape[1]:149 plt.title( titles[i] )150 else:151 if i == t.shape[1]-1:152 plt.title(titles)153 else:154 plt.title(str( i ))155def tablature2Fretboard(tablature, frets_num=24):156 f = np.zeros( ( tablature.shape[1] , 6, frets_num+1 ) )157 for i in range( tablature.shape[1] ):158 f[i,:,:] = tabFrame2Fretboard( tablature[:, i], frets_num=frets_num )159 return f160class Constants:161 def __init__(self, sample_rate=16000, analysis_samples=8000, ticks_per_quarter=960):162 self.sample_rate = sample_rate163 self.analysis_samples = analysis_samples164 self.ticks_per_quarter = ticks_per_quarter165 # end init166 167 def secs2samples(self, secs):168 return np.floor( secs*self.sample_rate ).astype(int)169 # end secs2samples170# end Constants171class GuitarSamples:172 def __init__(self, name, constants=None):173 self.name = name174 self.samples = {}175 if constants is None:176 self.constants = Constants()177 else:178 self.constants = constants179 # end init180 181 def append_sample(self, string, fret, audio_path, onset_path):182 # load audio183 s, _ = librosa.load( audio_path , sr=self.constants.sample_rate )184 # load onset info185 with open(onset_path, 'r') as f:186 onsetsec = float(f.read())187 onsetidx = np.floor(onsetsec*self.constants.sample_rate).astype(int)188 # minus25idx = int(0.025*self.constants.sample_rate)189 if str(string) in self.samples.keys():190 if str(fret) in self.samples[str(string)].keys():191 self.samples[str(string)][str(fret)].append( s[onsetidx:] )192 else:193 self.samples[str(string)][str(fret)] = [ s[onsetidx:] ]194 else:195 self.samples[str(string)] = {}196 self.samples[str(string)][str(fret)] = [ s[onsetidx:] ]197 # end append_sample198 199 def augment_octaves(self):200 for sidx in range(1, 7, 1):201 for fidx in range(1, 13, 1):202 self.samples[ str(sidx) ][ str(fidx+12) ] = []203 for sidx in range(1, 7, 1):204 for fidx in range(1, 13, 1):205 for s in self.samples[ str(sidx) ][ str(fidx) ]:206 self.samples[ str(sidx) ][ str(fidx+12) ].append( librosa.effects.pitch_shift(s, sr=self.constants.sample_rate, n_steps=4) )207 # end augment_octaves208 209 def get_random_sample(self, string, fret, duration_samples=None, duration_secs=None):210 samples = self.samples[str(string)][str(fret)]211 idx = np.random.randint( len(samples) )212 s = samples[idx]213 # fix duration214 if duration_samples is None:215 d = self.constants.secs2samples(duration_secs)216 else:217 d = duration_samples218 # s_out = librosa.effects.time_stretch(s, rate=len(s)/d)219 pad_length = d - s.size220 if pad_length <= 0:221 # print('s.size1: ', s.size)222 s = s[:pad_length]223 # print('s.size2: ', s.size)224 # fade out225 fade_length = 100226 while fade_length > s.size:227 fade_length -= 1228 s[-fade_length:] = s[-fade_length:]*np.linspace(1,0,fade_length)229 # print('s.size3: ', s.size)230 else:231 # print('s.size4: ', s.size)232 s = np.pad( s, [0,pad_length] )233 # print('s.size5: ', s.size)234 # s_out = librosa.effects.time_stretch(s, rate=len(s)/d)235 s_out = s236 return s_out237 # end get_sample238# end GuitarSamples239class GPAudioPieceEvents:240 def __init__(self, file_path, constants=None):241 if constants is None:242 constants = Constants()243 song = gp.parse( file_path )244 self.name = file_path.split( os.sep )[-1]245 self.track_events = []246 self.tempo = song.tempo247 tracks = song.tracks248 aborted = False249 self.max_pitch = -1250 self.min_pitch = 1000251 for track in tracks:252 strings = track.strings253 # check if proper guitar tunning254 proper_guitar = True255 proper_tunning = [64, 59, 55, 50, 45, 40] # make static256 for i, s in enumerate(strings):257 if i >= len(proper_tunning) or s.value != proper_tunning[i]:258 # print( file_path + ' - ' + str(s.value) + ': tunning not proper - ABORTING')259 proper_guitar = False260 aborted = True261 break262 if proper_guitar:263 measures = track.measures264 note_events = []265 for measure in measures:266 voices = measure.voices267 for voice in voices:268 beats = voice.beats269 for beat in beats:270 if beat.effect.mixTableChange:271 pass272 # print( file_path + ': mixTableChange - ABORTING beat')273 # aborted = True274 else:275 if beat.status.name != 'normal':276 pass277 # print( file_path + ': not normal - ABORTING beat')278 # aborted = True279 else:280 note_event = {}281 note_event['beat_duration'] = beat.duration.time/constants.ticks_per_quarter282 note_event['beat_onset_piece'] = beat.start/constants.ticks_per_quarter283 note_event['beat_onset_measure'] = beat.startInMeasure/constants.ticks_per_quarter284 note_event['secs_duration'] = note_event['beat_duration']*60/self.tempo285 note_event['secs_onset_piece'] = note_event['beat_onset_piece']*60/self.tempo286 note_event['secs_onset_measure'] = note_event['beat_onset_measure']*60/self.tempo287 note_event['samples_duration'] = np.floor(note_event['secs_duration']*constants.sample_rate).astype(int)288 note_event['samples_onset_piece'] = np.floor(note_event['secs_onset_piece']*constants.sample_rate).astype(int)289 note_event['samples_onset_measure'] = np.floor(note_event['secs_onset_measure']*constants.sample_rate).astype(int)290 note_event['pitches'] = []291 # only normal notes appended292 for n in beat.notes:293 if n.type.value == 1:294 pitch_event = {}295 pitch_event['string'] = n.string296 pitch_event['fret'] = n.value297 pitch_event['pitch'] = n.realValue298 if pitch_event['pitch'] > self.max_pitch:299 self.max_pitch = pitch_event['pitch']300 if pitch_event['pitch'] < self.min_pitch:301 self.min_pitch = pitch_event['pitch']302 pitch_event['midi_velocity'] = n.velocity303 pitch_event['velocity_ratio'] = n.velocity/127304 pitch_event['duration_percentage'] = n.durationPercent305 pitch_event['secs_duration_percentage'] = n.durationPercent*note_event['secs_duration']306 note_event['pitches'].append( pitch_event )307 note_events.append( note_event )308 else:309 pass310 # print(file_path + 'note type NOT 1 - ABORTING event')311 if not aborted:312 if len( note_events ) > 0:313 self.track_events.append(note_events)314# end class GPAudioPieceEvents315class GPPieceEvents:316 def __init__(self, file_path):317 song = gp.parse( file_path )318 self.name = file_path.split( os.sep )[-1]319 self.track_events = []320 self.tempo = song.tempo321 tracks = song.tracks322 aborted = False323 self.max_pitch = -1324 self.min_pitch = 1000325 for track in tracks:326 strings = track.strings327 # check if proper guitar tunning328 proper_guitar = True329 proper_tunning = [64, 59, 55, 50, 45, 40] # make static330 for i, s in enumerate(strings):331 if i >= len(proper_tunning) or s.value != proper_tunning[i]:332 # print( file_path + ' - ' + str(s.value) + ': tunning not proper - ABORTING')333 proper_guitar = False334 aborted = True335 break336 if proper_guitar:337 measures = track.measures338 note_events = []339 for measure in measures:340 voices = measure.voices341 for voice in voices:342 beats = voice.beats343 for beat in beats:344 if beat.effect.mixTableChange:345 pass346 # print( file_path + ': mixTableChange - ABORTING beat')347 # aborted = True348 else:349 if beat.status.name != 'normal':350 pass351 # print( file_path + ': not normal - ABORTING beat')352 # aborted = True353 else:354 note_event = {}355 note_event['duration'] = beat.duration.time356 note_event['onset_piece'] = beat.start357 note_event['onset_measure'] = beat.startInMeasure358 note_event['pitches'] = []359 # only normal notes appended360 for n in beat.notes:361 if n.type.value == 1:362 pitch_event = {}363 pitch_event['string'] = n.string364 pitch_event['fret'] = n.value365 pitch_event['pitch'] = n.realValue366 if pitch_event['pitch'] > self.max_pitch:367 self.max_pitch = pitch_event['pitch']368 if pitch_event['pitch'] < self.min_pitch:369 self.min_pitch = pitch_event['pitch']370 pitch_event['velocity'] = n.velocity371 pitch_event['duration_percentage'] = n.durationPercent372 note_event['pitches'].append( pitch_event )373 note_events.append( note_event )374 else:375 pass376 # print(file_path + 'note type NOT 1 - ABORTING event')377 if not aborted:378 if len( note_events ) > 0:379 self.track_events.append(note_events)380# end class GPPieceEvents381class TrackRepresentation():382 def __init__(self, track, piece_name='undefined', track_number=-1, keep_full=False, keep_events=False, random_pr=None):383 self.piece_name = piece_name384 self.track_number = track_number385 self.keep_full= keep_full386 self.keep_events= keep_events387 if self.keep_events:388 self.events = track389 onsets = np.array( [ t['onset_piece'] for t in track ] )390 onsets -= onsets[0]391 g = np.gcd.reduce(onsets)392 if g > 0:393 onsets = (onsets/g).astype('int')394 else:395 onsets = onsets.astype('int')396 397 durations = np.array( [ t['duration'] for t in track ] )398 if g > 0:399 durations = np.floor( durations/g ).astype( 'int' )400 else:401 durations = np.floor( durations ).astype('int')402 durations[durations==0] = 1403 404 self.pianoroll = np.zeros( ( 128 , onsets[-1]+durations[-1] ), dtype=np.float32)405 self.onsetsroll = np.zeros( ( 128 , onsets[-1]+durations[-1] ), dtype=np.float32 )406 407 for i, t in enumerate(track):408 pitches = t['pitches']409 for p in pitches:410 tmp_duration = np.max( [np.floor( durations[i]/p['duration_percentage'] ), 1])411 tmp_velocity = p['velocity']412 for d in range(tmp_duration.astype('int')):413 # check if random components need to be added in the pianoroll414 random_pitch = -1415 if random_pr is not None:416 if np.random.rand() <= random_pr:417 random_pitch = p['pitch'] + [-12, -5, -4, -3, 3, 4, 7, 12][np.random.randint(8)]418 if d == 0:419 self.onsetsroll[ p['pitch'] , onsets[i]+d ] = tmp_velocity420 if random_pitch >= 0:421 self.onsetsroll[ random_pitch , onsets[i]+d ] = tmp_velocity422 self.pianoroll[ p['pitch'] , onsets[i]+d ] = tmp_velocity423 if random_pitch >= 0:424 self.pianoroll[ random_pitch , onsets[i]+d ] = tmp_velocity425 426 # keep only active range of notes427 # self.pianoroll = self.pianoroll[40:95, :]428 # self.onsetsroll = self.onsetsroll[40:95, :]429 430 self.tablature = -1*np.ones( ( 6 , onsets[-1]+durations[-1] ), dtype=np.float32 )431 self.string_activation = np.zeros( ( 6 , onsets[-1]+durations[-1] ), dtype=np.float32 )432 433 for i, t in enumerate(track):434 pitches = t['pitches']435 for p in pitches:436 self.tablature[ p['string']-1 , onsets[i] ] = p['fret']437 self.string_activation[ p['string']-1 , onsets[i] ] = 1438 439 # remove zeros440 nz_idxs = np.sum(self.pianoroll, axis=0)!=0441 p0 = self.pianoroll[:, nz_idxs]442 # get difference idxs443 d = np.diff(p0, axis=1)444 dsum = np.sum( np.abs(d), axis=0)445 idx2keep = np.append(0, np.where( dsum != 0 )[0] + 1 )446 if self.keep_events:447 tmp_all_idxs = np.arange( onsets[-1]+durations[-1] ).astype(int)448 tmp_nz_idxs = tmp_all_idxs[nz_idxs]449 self.event_onsets_kept = tmp_nz_idxs[ np.array(idx2keep, dtype=int) ]*g450 451 self.pianoroll_changes = p0[:, idx2keep]452 t0 = self.tablature[:, nz_idxs]453 self.tablature_changes = t0[:, idx2keep]454 s0 = self.string_activation[:, nz_idxs]455 self.string_activation_changes = s0[:, idx2keep]456 if not self.keep_full:457 del self.pianoroll458 del self.onsetsroll459 del self.tablature460 del self.string_activation461 # end constructor462 463 def plot_pianoroll_part(self, start_idx=0, end_idx=50):464 plt.imshow( self.pianoroll_changes[:,start_idx:end_idx], cmap='gray_r', origin='lower' )465 # end plot_pianoroll_part466 467 def plot_tab_part(self, start_idx=0, end_idx=50):468 tablature_part = self.tablature_changes[:,start_idx:end_idx]469 x = np.arange(tablature_part.shape[1])470 x_length = len(x)471 y_height = x_length/5.472 473 y_offset = y_height/10.474 y_room = y_height - 2*y_offset475 476 plt.clf()477 for string in range(6):478 # plot string479 string_height = y_offset + (6-string)*y_room/6480 plt.plot( [x[0], x[-1]] , [string_height ,string_height], 'gray' )481 for i, f in enumerate(tablature_part[string,:]):482 if f > -1:483 plt.text(i, string_height, str(f.astype(int)))484 plt.axis('equal')485 # end plot_tab_part486 def tab2events(self):487 if not self.keep_events:488 print('ERROR: events should have been kept')489 return490 # start reading midi and tab changes491 i = 0492 for ev in self.events:493 # get pitches of event494 p = [ n['pitch'] for n in ev.pitches ]495 # end tab2events496# end TrackRepresentation497class GuitarTabDataset():498 def __init__(self, history=2, task='string_activation',499 output_representation='binary_tab',):500 self.history = history501 self.task = task502 self.output_representation = output_representation503 # collections of matrices504 self.pianoroll_changes = []505 self.tablature_changes = []506 self.string_activation_changes = []507 # final matrices508 self.x_train = None509 self.y_train = None510 self.x_valid = None511 self.y_valid = None512 self.x_test = None513 self.y_test = None514 # end constructor515 def add_matrices_old(self, r):516 # add from TrackRepresentation object517 tmp_all_x = np.concatenate( (np.zeros((r.pianoroll_changes.shape[0], self.history)), r.pianoroll_changes ), axis=1)518 tmp_x = tmp_all_x[:, self.history:]519 for i in range(1, self.history+1, 1):520 tmp_x = np.vstack( (tmp_x , tmp_all_x[:, self.history-i:-i]) )521 self.pianoroll_changes.append( tmp_x )522 if self.output_representation == 'binary_tab':523 self.tablature_changes.append( tablature2binary(r.tablature_changes) )524 elif self.output_representation == 'flat_tablature':525 self.tablature_changes.append( tablature2flatFretboard(r.tablature_changes) )526 elif self.output_representation == 'full_tablature':527 self.tablature_changes.append( tablature2Fretboard(r.tablature_changes) )528 else:529 print('unknown output_representation')530 self.string_activation_changes.append( r.string_activation_changes )531 # self.tablature_changes.append( np.concatenate( (np.zeros((r.tablature_changes.shape[0], self.history)), r.tablature_changes ), axis=1) )532 # self.string_activation_changes.append( np.concatenate( (np.zeros((r.string_activation_changes.shape[0], self.history)), r.string_activation_changes ), axis=1) )533 # end add_matrices_old534 def add_matrices(self, r):535 # add from TrackRepresentation object536 # tmp_all_x = np.concatenate( (np.zeros((r.pianoroll_changes.shape[0], self.history)), r.pianoroll_changes ), axis=1)537 if self.output_representation == 'binary_tab':538 # TODO: put binary tab history539 tmp_all_x = np.concatenate( (np.zeros((r.pianoroll_changes.shape[0], self.history)), r.pianoroll_changes ), axis=1)540 tmp_x = tmp_all_x[:, self.history:]541 elif self.output_representation == 'flat_tablature':542 tmp_flat_tab = tablature2flatFretboard(r.tablature_changes)543 tmp_all_x = np.concatenate( (np.zeros((tmp_flat_tab.shape[0], self.history)), tmp_flat_tab ), axis=1)544 tmp_x = r.pianoroll_changes545 if self.output_representation == 'flat_tablature' or self.output_representation == 'binary_tab':546 for i in range(1, self.history+1, 1):547 tmp_x = np.vstack( (tmp_x , tmp_all_x[:, self.history-i:-i]) )548 self.pianoroll_changes.append( tmp_x.astype(bool) )549 if self.output_representation == 'binary_tab':550 self.tablature_changes.append( tablature2binary(r.tablature_changes) )551 elif self.output_representation == 'flat_tablature':552 self.tablature_changes.append( tablature2flatFretboard(r.tablature_changes).astype(bool) )553 elif self.output_representation == 'full_tablature':554 self.tablature_changes.append( tablature2Fretboard(r.tablature_changes) )555 else:556 print('unknown output_representation')557 # self.string_activation_changes.append( r.string_activation_changes )558 # self.tablature_changes.append( np.concatenate( (np.zeros((r.tablature_changes.shape[0], self.history)), r.tablature_changes ), axis=1) )559 # self.string_activation_changes.append( np.concatenate( (np.zeros((r.string_activation_changes.shape[0], self.history)), r.string_activation_changes ), axis=1) )560 # end add_matrices561 def load_data(self, train_ratio=0.8, validation=True, validation_ratio=0.2):562 self.validation = validation563 # shuffled_idxs = np.arange( len( self.pianoroll_changes ) )564 # np.random.shuffle( shuffled_idxs )565 # self.pianoroll_changes, self.tablature_changes, self.string_activation_changes = shuffle( self.pianoroll_changes,566 # self.tablature_changes,567 # self.string_activation_changes)568 self.pianoroll_changes, self.tablature_changes= shuffle( self.pianoroll_changes,569 self.tablature_changes)570 train_idx = np.floor( len( self.pianoroll_changes )*train_ratio ).astype(int)571 valid_idx = 0572 if self.validation:573 valid_idx = np.floor( train_idx*validation_ratio ).astype(int)574 x_valid = self.pianoroll_changes[train_idx-valid_idx:train_idx]575 x_train = self.pianoroll_changes[:train_idx-valid_idx]576 x_test = self.pianoroll_changes[train_idx:]577 578 self.x_train = np.concatenate( x_train , axis=1 )579 self.x_test = np.concatenate( x_test , axis=1 )580 581 if self.validation:582 self.x_valid = np.concatenate( x_valid , axis=1 )583 if self.task == 'string_activation':584 y = self.string_activation_changes585 else:586 y = self.tablature_changes587 if self.validation:588 y_valid = y[train_idx-valid_idx:train_idx]589 # self.y1 = y590 y_train = y[:train_idx-valid_idx]591 y_test = y[train_idx:]592 self.y_train = np.concatenate( y_train , axis=1 )593 self.y_test = np.concatenate( y_test , axis=1 )594 if self.validation:595 self.y_valid = np.concatenate( y_valid , axis=1 )596 if self.validation:597 return [self.x_train, self.y_train, self.x_valid, self.y_valid, self.x_test, self.y_test]598 else:599 return [self.x_train, self.y_train, self.x_test, self.y_test]600 # end load_data601 def load_full_tabs(self, train_ratio=0.8, validation=True, validation_ratio=0.2):602 self.validation = validation603 self.tablature_changes = shuffle( self.tablature_changes )604 train_idx = np.floor( len( self.tablature_changes )*train_ratio ).astype(int)605 valid_idx = 0606 if self.validation:607 valid_idx = np.floor( train_idx*validation_ratio ).astype(int)608 x_valid = self.tablature_changes[train_idx-valid_idx:train_idx]609 x_train = self.tablature_changes[:train_idx-valid_idx]610 x_test = self.tablature_changes[train_idx:]611 612 self.x_train = np.concatenate( x_train , axis=0 )613 self.x_test = np.concatenate( x_test , axis=0 )614 615 if self.validation:616 self.x_valid = np.concatenate( x_valid , axis=0 )617 618 if self.validation:619 return [self.x_train, self.y_train, self.x_valid, self.y_valid, self.x_test, self.y_test]620 else:621 return [self.x_train, self.y_train, self.x_test, self.y_test]622 # end load_full_tabs...
wjd.py
Source:wjd.py
1import os2import sys3import numpy as np4from sqlalchemy import Column, ForeignKey, Integer, Float, String5from sqlalchemy.ext.declarative import declarative_base6from sqlalchemy.orm import relationship7from sqlalchemy import create_engine8from sqlalchemy.orm import sessionmaker9import csv10import settings11from base import ImporterBase12Base = declarative_base()13class Song(Base):14 __tablename__ = 'song'15 songid = Column(Integer, primary_key=True)16 title = Column(String, nullable=False)17 filename_track = Column(String, nullable=False)18 solos = relationship('Solo')19class Solo(Base):20 __tablename__ = 'solo_info'21 melid = Column(Integer, primary_key=True)22 songid = Column(Integer, ForeignKey('song.songid'))23 melodies = relationship('Melody', backref='solo_info')24 beats = relationship('Beat', backref='solo_info')25 performer = Column(String)26 title = Column(String)27 instrument = Column(String)28 key = Column(String)29 signature = Column(String)30class Beat(Base):31 __tablename__ = 'beats'32 beatid = Column(Integer, primary_key=True)33 melid = Column(Integer, ForeignKey('solo_info.melid'))34 onset = Column(Float)35# class Section(Base):36# __tablename__ = 'sections'37# melid = Column(Integer, ForeignKey('solo_info.melid'))38# type = Column(String)39# start = Column(Integer)40# end = Column(Integer)41# value = Column(String)42class Melody(Base):43 __tablename__ = 'melody'44 eventid = Column(Integer, primary_key=True)45 melid = Column(Integer, ForeignKey('solo_info.melid'))46 onset = Column(Float)47 pitch = Column(Float)48 duration = Column(Float)49 period = Column(Integer)50 division = Column(Integer)51 bar = Column(Integer)52 beat = Column(Integer)53 tatum = Column(Integer)54 subtatum = Column(Integer)55 num = Column(Integer)56 denom = Column(Integer)57def get_melids():58 engine = create_engine('sqlite:///../data/wjazzd_new.db')59 db_session = sessionmaker(bind=engine)60 session = db_session()61 melids_query_gen = session.query(Solo.melid).distinct()62 melids = []63 for cur_melid in melids_query_gen:64 melids.append(cur_melid)65 return melids66def get_solo(melid):67 engine = create_engine('sqlite:///../data/wjazzd_new.db')68 db_session = sessionmaker(bind=engine)69 session = db_session()70 solo = session.query(Solo).get(melid)71 return solo72def get_solo_activity(melid, frame_times):73 solo = get_solo(melid)74 solo_length = solo.melodies[-1].onset + solo.melodies[-1].duration75 solo_activity = np.zeros_like(frame_times)76 for note_event in solo.melodies:77 idx_start = np.argmin(np.abs(frame_times-note_event.onset))78 idx_end = np.argmin(np.abs(frame_times-(note_event.onset+note_event.duration)))79 solo_activity[idx_start:idx_end] = 1.080 return solo_activity81def get_solo_beats(solo, subdivisions=0):82 """83 Parameter84 ---------85 melid : integer86 subdivisions : integer, optional87 Defaults to 0.88 Return89 ------90 beats : ndarray91 """92 # include first and second note93 subdivisions_mod = subdivisions + 194 beats = np.zeros(1)95 for cur_beat, note_event in enumerate(solo.beats):96 if subdivisions == 0:97 beats[cur_beat] = note_event.onset98 else:99 if cur_beat == 0:100 beats[0] = note_event.onset101 else:102 last_onset = beats[-1]103 cur_onset = note_event.onset104 # fill with subdivisions105 subdivsions_onsets = np.linspace(last_onset, cur_onset, subdivisions_mod)106 beats = np.r_[beats, subdivsions_onsets]107 return beats108def get_transposition_offset(solo):109 # define musical pitch classes110 pitch_classes_sharp = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'A', 'A#', 'B']111 pitch_classes_flat = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'A', 'Bb', 'B']112 # split the string113 cur_key = solo.key.split('-')[0]114 transp_offset = None115 # find it116 try:117 transp_offset = pitch_classes_sharp.index(cur_key)118 except ValueError:119 pass120 try:121 transp_offset = pitch_classes_flat.index(cur_key)122 except ValueError:123 pass124 # this means there was no annotation in the database125 if not transp_offset:126 transp_offset = 0127 return transp_offset128def visualize_piano_roll(piano_roll):129 import matplotlib.pyplot as plt130 plt.imshow(piano_roll, cmap=plt.get_cmap('gray_r'))131class ImporterWJD(ImporterBase):132 """Base Class for the dataset import.133 """134 def __init__(self, beats_per_measure, melody_range, harmony_range, continuation_range, metric_range, path='../data/rock_corpus_v2-1/rs200_melody_nlt'):135 self.output = []136 super(ImporterWJD, self).__init__(beats_per_measure, melody_range, harmony_range, continuation_range, metric_range)137 self.path = path138 self.output = []139 #'pr' stands for piano roll140 self.pr_n_pitches = melody_range[1] - melody_range[0]141 self.pr_width = self.metric_range[1]142 self.pr_bar_division = beats_per_measure143 melids = get_melids()144 for cur_melid in melids:145 self.output.append(self.import_piano_roll(cur_melid))146 def get_solo_pitch_shape(self, solo, frame_times, n_pitch_classes, transposition_offset):147 if n_pitch_classes:148 n_pitches = n_pitch_classes149 else:150 n_pitches = 120151 solo_length = solo.melodies[-1].onset + solo.melodies[-1].duration152 solo_piano_roll = np.zeros((self.pr_width, len(frame_times)))153 pitch_range_start = np.min([mel.pitch for mel in solo.melodies])154 pitch_range_end = np.max([mel.pitch for mel in solo.melodies])155 lowest_octave = int((pitch_range_start - transposition_offset) / 12) * 12156 for note_event in solo.melodies:157 note_metric_index = (note_event.beat - 1) * 4 + note_event.tatum - 1158 idx_start = np.argmin(np.abs(frame_times-note_event.onset))159 idx_end = np.argmin(np.abs(frame_times-(note_event.onset+note_event.duration)))160 cur_metric_level = self.get_metric_level_from_num_divisions(note_metric_index, self.pr_bar_division)161 if n_pitch_classes:162 cur_pitch = (note_event.pitch-transposition_offset - lowest_octave) % n_pitch_classes163 else:164 cur_pitch = note_event.pitch-transposition_offset - lowest_octave165 cur_pitch_vector = np.zeros((self.pr_width, 1))166 cur_pitch_vector[cur_pitch] = 1.0167 solo_piano_roll[:, idx_start:idx_end] = cur_pitch_vector168 solo_piano_roll[self.metric_range[0] + cur_metric_level, idx_start] = 1.0169 #import matplotlib.pyplot as plt170 #plt.imshow(solo_piano_roll, cmap=plt.get_cmap('gray_r'))171 #plt.show()172 return solo_piano_roll173 def import_piano_roll(self, cur_melid):174 solo = get_solo(cur_melid)175 transp_offset = get_transposition_offset(solo)176 beats = get_solo_beats(solo, 4)177 solo_piano_roll = self.get_solo_pitch_shape(solo, beats, self.num_pitches, transp_offset)178 return solo_piano_roll179 def add_beat_flags(self):180 pass181if __name__ == '__main__':182 importer = ImporterWJD(settings.BEATS_PER_MEASURE, settings.MELODY_INDICES_RANGE, settings.HARMONY_INDICES_RANGE, settings.CONTINUATION_FLAG_RANGE, settings.METRIC_FLAGS_RANGE)...
message_processing.py
Source:message_processing.py
1import re2from regex import time_regex, note_regex3from metadata import get_encoding4from encoding import decode5def parse_time(note_event):6 return round(float(re.search(time_regex, note_event).group(1)), 3)7def parse_note(note_event):8 # TODO: are these registers an octave higher than I expect?9 pitches = re.search(note_regex, note_event).group(0)10 encoding = get_encoding()...
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run hypothesis automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
