Upload 14 files

Monster-MIDI-Dataset-main.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9a16ad46342c4cdafbedabc9606f06c7a934737888e213afc6f021098302a055
-size 5811367
+oid sha256:8e021400efc79006c854784a2739f31686373d42c916589169f1351b92f86a85
+size 5812266

TMELODIES.py

@@ -0,0 +1,932 @@
+#! /usr/bin/python3
+
+r'''############################################################################
+################################################################################
+#
+#
+#	      Tegridy MELODIES Python Module (TMELODIES)
+#	      Version 1.0
+#
+#	      Project Los Angeles
+#
+#	      Tegridy Code 2024
+#
+#       https://github.com/asigalov61/tegridy-tools
+#
+#
+################################################################################
+#
+#       All melodies in this module are licensed CC BY-NC-SA
+#
+################################################################################
+#
+#       Copyright 2024 Project Los Angeles / Tegridy Code
+#
+#       Licensed under the Apache License, Version 2.0 (the "License");
+#       you may not use this file except in compliance with the License.
+#       You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#       Unless required by applicable law or agreed to in writing, software
+#       distributed under the License is distributed on an "AS IS" BASIS,
+#       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#       See the License for the specific language governing permissions and
+#       limitations under the License.
+#
+################################################################################
+################################################################################
+#
+# You can decode all melodies easily with TMIDIX Python Module like so...
+#
+################################################################################
+
+import random
+import TMELODIES
+import TMIDIX
+
+melody = random.choice(TMELODIES.ALL_MELODIES)
+
+mel_chords = TMELODIES.harmonize_melody(melody)
+
+name, part, key, output_score = TMELODIES.melody_to_enhanced_score_notes(melody, 
+                                                                        harmonized_tones_chords=mel_chords
+                                                                        )
+
+print('=' * 70)
+print('Song:', name+' '+part+' in '+key) 
+print('=' * 70)
+
+midi_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(output_score,
+                                                      output_signature = name+' '+part+' in '+key,
+                                                      output_file_name = name+' '+part+' in '+key,
+                                                      track_name='Project Los Angeles',
+                                                      timings_multiplier=16
+                                                      )
+
+print('=' * 70)
+
+################################################################################
+'''
+
+ALL_MELODIES = [['Arabian Nights', 'Verse', 'A', 'Minor',
+                [[0, 13, 48], [13, 13, 50], [14, 27, 52], [28, 13, 48], [13, 13, 50],
+                [14, 27, 52], [28, 13, 48], [13, 13, 52], [14, 19, 51], [20, 14, 47],
+                [15, 19, 49], [19, 28, 51], [29, 13, 47], [14, 13, 51], [14, 20, 50],
+                [20, 19, 50], [20, 18, 50], [18, 24, 50], [24, 27, 52], [28, 68, 48],
+                [82, 13, 52], [14, 13, 53], [14, 20, 55], [20, 20, 51], [21, 14, 53],
+                [14, 20, 55], [21, 20, 51], [20, 13, 55], [14, 20, 54], [21, 20, 50],
+                [20, 13, 52], [14, 27, 54], [28, 13, 50], [14, 13, 54], [13, 20, 53],
+                [21, 20, 53], [21, 13, 53], [13, 27, 53], [42, 13, 55], [14, 68, 52],
+                [82, 13, 57], [14, 13, 59], [14, 27, 60], [27, 13, 57], [14, 13, 59],
+                [14, 27, 60], [28, 13, 57], [13, 13, 59], [14, 27, 60], [28, 13, 57],
+                [13, 13, 59], [14, 27, 60], [28, 13, 57], [14, 13, 59], [14, 27, 60],
+                [27, 13, 57], [13, 13, 59], [14, 27, 60], [28, 27, 57], [28, 82, 52],
+                [82, 13, 48], [14, 13, 50], [14, 27, 52], [28, 13, 48], [13, 13, 50],
+                [14, 27, 52], [27, 13, 48], [14, 13, 52], [14, 19, 51], [19, 14, 47],
+                [15, 19, 49], [20, 28, 51], [29, 13, 47], [14, 13, 51], [14, 20, 52],
+                [20, 19, 52], [19, 18, 52], [19, 17, 60], [17, 20, 59], [21, 20, 57],
+                [20, 62, 57]]],
+              ['Beard Barb', 'Chorus', 'F', 'Major',
+                [[0, 35, 81], [41, 42, 81], [42, 20, 83], [18, 20, 81], [19, 20, 79],
+                [20, 21, 81], [20, 61, 79], [61, 12, 76], [10, 11, 74], [11, 65, 72],
+                [82, 31, 81], [37, 43, 81], [42, 23, 83], [22, 20, 81], [20, 18, 79],
+                [17, 22, 81], [22, 94, 79], [163, 32, 81], [39, 40, 81], [39, 23, 83],
+                [21, 20, 81], [21, 20, 79], [18, 21, 81], [21, 82, 79], [83, 60, 72],
+                [81, 30, 77], [29, 11, 76], [10, 21, 77], [22, 18, 81], [19, 22, 79],
+                [21, 35, 81], [41, 11, 76], [9, 10, 74], [9, 77, 72]]],
+              ['Beard Barb', 'Verse', 'A', 'Major',
+                [[0, 27, 76], [39, 28, 74], [40, 28, 72], [39, 21, 69], [20, 10, 72],
+                [12, 35, 67], [132, 20, 69], [19, 10, 72], [12, 29, 67], [49, 20, 69],
+                [20, 10, 72], [9, 32, 67], [72, 20, 76], [19, 25, 77], [125, 35, 77],
+                [42, 35, 74], [41, 34, 71], [40, 18, 76], [20, 11, 71], [11, 57, 72],
+                [69, 18, 76], [20, 12, 69], [22, 11, 69], [12, 8, 71], [8, 11, 72],
+                [13, 7, 71], [6, 11, 72], [13, 10, 69], [9, 17, 67], [17, 35, 76],
+                [82, 12, 69], [13, 7, 71], [7, 13, 72], [12, 8, 71], [8, 11, 72],
+                [12, 10, 69], [9, 16, 67], [18, 30, 76], [83, 13, 69], [13, 7, 71],
+                [8, 10, 72], [10, 8, 71], [8, 10, 72], [11, 10, 69], [10, 17, 67],
+                [19, 32, 76], [81, 5, 76], [13, 3, 76], [9, 5, 76], [13, 6, 76], [8, 5, 74],
+                [14, 7, 74], [6, 13, 72]]],
+              ['Blue Railcart', 'Chorus', 'B-', 'Minor',
+                [[0, 23, 70], [26, 10, 65], [13, 10, 70], [13, 12, 68], [14, 12, 66],
+                [13, 25, 63], [26, 16, 66], [13, 13, 65], [15, 24, 60], [25, 13, 66],
+                [14, 13, 65], [14, 12, 61], [40, 12, 70], [12, 15, 69], [14, 13, 70],
+                [13, 14, 72], [14, 12, 70], [13, 23, 66], [27, 13, 65], [13, 12, 73],
+                [13, 12, 72], [13, 13, 73], [15, 34, 70], [56, 23, 70], [27, 13, 65],
+                [13, 13, 70], [12, 14, 68], [13, 15, 66], [14, 26, 63], [26, 16, 66],
+                [14, 13, 65], [14, 27, 60], [27, 14, 66], [12, 12, 65], [15, 13, 61],
+                [25, 24, 70], [27, 15, 69], [13, 13, 70], [13, 14, 72], [14, 13, 70],
+                [14, 24, 66], [26, 13, 65], [13, 11, 73], [13, 14, 72], [13, 12, 73],
+                [14, 38, 70]]],
+              ['Blue Railcart', 'Verse', 'E-', 'Minor',
+                [[0, 11, 65], [13, 13, 70], [12, 13, 69], [13, 13, 70], [15, 14, 72],
+                [12, 13, 70], [14, 13, 68], [13, 13, 70], [14, 24, 68], [26, 23, 66],
+                [27, 36, 66], [56, 12, 63], [12, 13, 68], [13, 13, 67], [12, 13, 68],
+                [15, 13, 70], [12, 12, 68], [14, 13, 63], [13, 14, 66], [15, 46, 65],
+                [107, 11, 65], [12, 14, 70], [15, 14, 69], [12, 13, 70], [14, 15, 72],
+                [13, 12, 70], [13, 14, 68], [13, 14, 66], [15, 29, 65], [27, 24, 63],
+                [26, 14, 70], [55, 13, 65], [12, 13, 73], [13, 13, 72], [13, 12, 70],
+                [13, 15, 69], [14, 13, 70], [14, 12, 72], [13, 13, 69], [14, 57, 70]]],
+              ['Bremen Musicians', 'Verse', 'C', 'Major',
+                [[0, 15, 60], [16, 15, 60], [15, 15, 60], [15, 15, 62], [15, 15, 64],
+                [16, 15, 64], [15, 15, 60], [15, 15, 64], [16, 30, 67], [30, 30, 64],
+                [31, 60, 67], [60, 15, 65], [16, 15, 65], [15, 15, 65], [15, 15, 64],
+                [15, 15, 62], [16, 15, 62], [15, 15, 65], [15, 15, 69], [15, 30, 67],
+                [31, 30, 65], [30, 61, 67], [61, 45, 64], [46, 15, 64], [15, 30, 67],
+                [31, 30, 64], [31, 15, 69], [15, 15, 69], [15, 15, 69], [15, 15, 71],
+                [16, 30, 72], [30, 30, 69], [31, 15, 74], [15, 15, 74], [15, 15, 74],
+                [15, 15, 72], [16, 15, 71], [15, 15, 67], [15, 15, 71], [15, 15, 74],
+                [16, 30, 72], [30, 30, 71], [31, 61, 69], [61, 45, 65], [45, 15, 65],
+                [16, 30, 69], [30, 30, 72], [31, 30, 71], [30, 30, 69], [30, 30, 71],
+                [31, 30, 74], [30, 15, 76], [16, 15, 74], [15, 45, 72]]],
+              ['Chunga Changa', 'Chorus', 'G', 'Major',
+                [[0, 7, 67], [16, 6, 72], [16, 15, 71], [20, 7, 69], [9, 7, 67], [17, 6, 69],
+                [14, 19, 71], [24, 6, 69], [6, 6, 67], [16, 6, 69], [15, 21, 69],
+                [22, 5, 67], [9, 6, 67], [14, 6, 69], [15, 21, 69], [23, 5, 67], [9, 6, 67],
+                [15, 5, 69], [15, 21, 69], [23, 4, 67], [7, 6, 67], [15, 6, 69],
+                [15, 21, 69], [22, 5, 67], [8, 5, 69], [15, 7, 71], [16, 19, 69],
+                [22, 7, 67], [70, 7, 67], [15, 6, 72], [15, 20, 71], [21, 6, 69], [8, 5, 67],
+                [16, 6, 69], [16, 21, 71], [23, 6, 69], [7, 5, 67], [14, 6, 69],
+                [16, 21, 69], [24, 4, 67], [6, 6, 67], [15, 6, 69], [16, 19, 69],
+                [22, 3, 67], [8, 6, 67], [15, 6, 69], [15, 22, 69], [24, 5, 67], [9, 7, 67],
+                [15, 5, 69], [13, 22, 69], [23, 6, 67], [7, 7, 65], [17, 7, 64],
+                [14, 20, 62], [24, 8, 60]]],
+              ['Chunga Changa', 'Verse', 'C', 'Minor',
+                [[0, 4, 60], [15, 5, 63], [14, 6, 67], [16, 5, 67], [46, 20, 67], [23, 6, 65],
+                [6, 6, 67], [16, 7, 68], [14, 14, 67], [77, 23, 72], [30, 6, 63],
+                [15, 6, 62], [16, 6, 62], [47, 16, 62], [20, 6, 63], [7, 7, 65], [17, 6, 67],
+                [15, 13, 63], [91, 6, 60], [16, 6, 63], [14, 6, 67], [16, 6, 67],
+                [47, 17, 67], [21, 6, 65], [7, 6, 67], [16, 7, 68], [17, 28, 67],
+                [71, 22, 72], [32, 7, 63], [15, 7, 62], [16, 7, 62], [47, 15, 62],
+                [22, 6, 63], [6, 9, 65], [17, 7, 67], [16, 12, 60]]],
+              ['Clouds', 'Chorus', 'E', 'Minor',
+                [[0, 15, 71], [13, 7, 76], [17, 6, 79], [15, 110, 83], [162, 5, 83],
+                [17, 15, 83], [13, 16, 84], [15, 17, 83], [16, 14, 81], [14, 13, 79],
+                [15, 45, 83], [45, 51, 78], [137, 16, 71], [14, 5, 75], [15, 6, 78],
+                [17, 123, 81], [165, 16, 83], [15, 6, 81], [15, 15, 83], [15, 6, 84],
+                [15, 5, 83], [15, 5, 81], [15, 38, 84], [45, 72, 83], [105, 16, 84],
+                [15, 16, 83], [15, 16, 84], [15, 15, 83], [15, 16, 81], [15, 15, 80],
+                [15, 30, 83], [30, 15, 81], [15, 76, 72], [135, 29, 83], [30, 30, 78],
+                [30, 60, 81], [60, 59, 79], [90, 12, 81], [15, 18, 79], [15, 17, 81],
+                [15, 17, 79], [15, 16, 78], [15, 16, 76], [15, 31, 83], [30, 15, 79],
+                [15, 72, 76], [135, 31, 79], [30, 28, 75], [30, 85, 76]]],
+              ['Clouds', 'Verse', 'E', 'Minor',
+                [[0, 16, 71], [15, 15, 76], [15, 30, 79], [31, 16, 78], [14, 15, 76],
+                [14, 15, 75], [14, 17, 76], [15, 18, 78], [17, 15, 75], [14, 71, 76],
+                [89, 15, 71], [15, 17, 72], [17, 23, 74], [30, 5, 74], [14, 13, 74],
+                [13, 15, 76], [15, 15, 74], [16, 16, 72], [15, 17, 74], [15, 31, 72],
+                [32, 43, 71], [57, 17, 72], [17, 13, 71], [15, 27, 69], [28, 15, 72],
+                [17, 15, 76], [15, 16, 81], [15, 17, 79], [15, 16, 78], [14, 14, 76],
+                [15, 55, 79], [92, 17, 78], [15, 13, 76], [15, 30, 71], [30, 14, 76],
+                [13, 17, 78], [16, 13, 79], [13, 16, 78], [16, 14, 81], [14, 17, 79],
+                [16, 33, 78], [31, 20, 76]]],
+              ['Daddys Song', 'Chorus', 'A-', 'Major',
+                [[0, 7, 73], [15, 6, 68], [14, 15, 70], [14, 5, 68], [15, 7, 73], [14, 5, 68],
+                [15, 14, 70], [14, 7, 68], [14, 15, 72], [29, 9, 72], [14, 4, 68],
+                [15, 27, 70], [29, 13, 68], [28, 6, 72], [15, 5, 68], [14, 14, 70],
+                [14, 6, 68], [15, 6, 72], [14, 5, 68], [15, 15, 70], [14, 6, 68],
+                [29, 15, 70], [14, 14, 68], [14, 14, 66], [15, 29, 65], [29, 19, 68],
+                [28, 6, 73], [15, 5, 68], [14, 16, 70], [14, 4, 68], [15, 5, 73],
+                [14, 5, 68], [14, 14, 70], [15, 8, 68], [14, 18, 73], [29, 15, 73],
+                [14, 14, 72], [15, 27, 75], [28, 19, 70], [29, 6, 73], [14, 16, 73],
+                [15, 17, 72], [14, 17, 70], [14, 6, 72], [15, 18, 72], [14, 20, 70],
+                [15, 11, 68], [28, 13, 66], [15, 15, 65], [14, 17, 63], [14, 34, 68],
+                [58, 4, 73], [14, 16, 73], [14, 15, 72], [15, 15, 70], [14, 7, 72],
+                [15, 16, 72], [14, 18, 70], [14, 13, 68], [29, 17, 68], [15, 17, 70],
+                [14, 20, 72], [14, 16, 73]]],
+              ['Daddys Song', 'Verse', 'C#', 'Minor',
+                [[0, 23, 68], [29, 28, 68], [29, 30, 73], [29, 17, 68], [14, 13, 66],
+                [14, 30, 64], [29, 27, 66], [29, 31, 64], [28, 29, 63], [29, 29, 66],
+                [29, 31, 69], [29, 27, 68], [29, 13, 63], [14, 17, 64], [14, 31, 66],
+                [29, 31, 68], [29, 35, 64], [57, 20, 68], [29, 24, 68], [29, 31, 73],
+                [29, 10, 68], [14, 15, 69], [14, 27, 71], [29, 27, 73], [29, 28, 69],
+                [29, 18, 66], [28, 27, 73], [29, 29, 69], [29, 28, 68], [28, 12, 66],
+                [15, 13, 64], [14, 31, 66], [29, 27, 68], [29, 20, 61]]],
+              ['Dreidel', 'Chorus', 'C', 'Major',
+                [[0, 6, 64], [14, 8, 67], [17, 6, 64], [14, 7, 67], [15, 6, 64], [14, 7, 67],
+                [17, 22, 64], [32, 6, 64], [15, 6, 67], [16, 6, 67], [14, 8, 65],
+                [16, 6, 64], [16, 35, 62], [49, 6, 62], [14, 7, 65], [16, 6, 62],
+                [14, 6, 65], [17, 6, 62], [15, 6, 65], [17, 20, 62], [30, 6, 62],
+                [15, 7, 67], [15, 7, 65], [16, 7, 64], [15, 7, 62], [15, 26, 60]]],
+              ['Dreidel', 'Verse', 'C', 'Major',
+                [[0, 22, 55], [32, 6, 60], [15, 8, 60], [14, 8, 62], [15, 8, 62],
+                [15, 12, 64], [17, 25, 60], [31, 8, 64], [15, 7, 67], [15, 8, 67],
+                [15, 9, 65], [15, 8, 64], [17, 36, 62], [50, 6, 62], [14, 7, 62],
+                [15, 7, 62], [15, 6, 64], [16, 6, 64], [15, 7, 65], [15, 21, 62],
+                [32, 7, 62], [16, 7, 67], [16, 8, 65], [15, 8, 64], [15, 8, 62],
+                [16, 41, 60]]],
+              ['Duck Tales', 'Chorus', 'A', 'Major',
+                [[0, 12, 68], [20, 11, 68], [31, 8, 59], [7, 22, 71], [21, 11, 68],
+                [75, 25, 64], [28, 12, 62], [21, 14, 60], [19, 13, 62], [21, 14, 64],
+                [20, 14, 62], [20, 14, 60], [20, 10, 62], [20, 13, 68], [22, 12, 68],
+                [32, 8, 59], [7, 23, 71], [24, 13, 68], [73, 25, 64], [29, 13, 62],
+                [19, 14, 60], [19, 12, 62], [20, 15, 64], [21, 12, 62], [20, 13, 60],
+                [20, 12, 62], [22, 12, 68], [21, 12, 68]]],
+              ['Duck Tales', 'Verse', 'F#', 'Major',
+                [[0, 12, 52], [20, 13, 56], [22, 13, 59], [19, 11, 61], [20, 8, 62],
+                [14, 10, 61], [20, 23, 61], [29, 10, 59], [20, 24, 57], [31, 30, 56],
+                [51, 23, 57], [32, 24, 56], [48, 15, 52], [21, 17, 56], [21, 14, 59],
+                [20, 14, 61], [20, 9, 62], [14, 12, 61], [19, 16, 61], [22, 16, 59],
+                [28, 24, 62], [30, 28, 61], [49, 26, 62], [34, 26, 61], [69, 16, 54],
+                [21, 13, 57], [21, 12, 61], [20, 26, 61], [34, 28, 59], [67, 15, 61],
+                [21, 14, 64], [20, 13, 66], [21, 26, 68], [32, 7, 66], [12, 15, 66]]],
+              ['Eagles Learn to Fly', 'Verse', 'F#', 'Minor',
+                [[0, 28, 68], [29, 17, 73], [14, 15, 68], [43, 12, 66], [21, 9, 66],
+                [8, 16, 64], [14, 14, 63], [14, 33, 61], [73, 14, 61], [14, 15, 64],
+                [14, 17, 68], [14, 40, 73], [44, 14, 68], [14, 48, 73], [43, 14, 68],
+                [15, 27, 71], [28, 36, 66], [43, 16, 59], [15, 15, 62], [14, 5, 66],
+                [15, 41, 71], [43, 14, 66], [14, 27, 71], [29, 29, 73], [29, 29, 69],
+                [28, 34, 64], [44, 7, 73], [14, 8, 73], [14, 15, 73], [15, 67, 71],
+                [72, 15, 71], [14, 14, 69], [14, 14, 68], [15, 13, 66], [28, 26, 68],
+                [29, 14, 69], [29, 26, 68], [29, 15, 73], [14, 20, 68], [43, 14, 66],
+                [22, 8, 66], [7, 14, 64], [14, 15, 63], [15, 28, 61]]],
+              ['Freak', 'Chorus', 'D', 'Minor',
+                [[0, 17, 76], [19, 6, 81], [19, 20, 81], [37, 4, 69], [8, 9, 69],
+                [11, 23, 77], [28, 14, 74], [28, 17, 74], [19, 6, 79], [17, 18, 79],
+                [20, 18, 74], [19, 21, 77], [19, 37, 76], [39, 6, 73], [17, 20, 79],
+                [18, 19, 77], [18, 12, 74], [59, 17, 76], [19, 14, 72], [56, 17, 76],
+                [16, 6, 74], [19, 6, 71], [20, 18, 72], [17, 25, 69]]],
+              ['Freak', 'Verse', 'C', 'Minor',
+                [[0, 19, 76], [18, 20, 77], [19, 21, 76], [21, 17, 72], [17, 18, 69],
+                [20, 33, 72], [35, 19, 71], [20, 21, 74], [19, 20, 76], [19, 20, 74],
+                [20, 17, 71], [17, 20, 74], [20, 35, 77], [36, 17, 76], [18, 19, 79],
+                [19, 18, 81], [18, 20, 79], [21, 19, 76], [20, 17, 72], [18, 34, 76],
+                [37, 6, 74], [17, 18, 74], [20, 19, 76], [19, 18, 74], [20, 17, 76],
+                [17, 20, 77], [19, 37, 79]]],
+              ['Friend Song', 'Chorus', 'A', 'Minor',
+                [[0, 14, 71], [13, 15, 69], [14, 18, 62], [28, 15, 62], [13, 11, 65],
+                [14, 27, 69], [28, 14, 67], [14, 11, 65], [14, 6, 64], [13, 6, 64],
+                [14, 16, 64], [14, 14, 69], [14, 29, 72], [41, 15, 72], [14, 5, 71],
+                [14, 3, 71], [13, 12, 71], [14, 12, 67], [14, 27, 69], [28, 26, 71],
+                [27, 40, 72], [56, 26, 71], [27, 27, 69], [28, 16, 62], [27, 12, 62],
+                [14, 12, 65], [14, 27, 69], [28, 14, 67], [13, 13, 65], [14, 6, 64],
+                [14, 6, 64], [14, 14, 64], [14, 12, 69], [14, 27, 72], [41, 13, 72],
+                [14, 4, 71], [14, 3, 71], [14, 13, 71], [14, 12, 74], [13, 17, 72],
+                [28, 24, 71], [28, 11, 69]]],
+              ['Friend Song', 'Verse', 'A', 'Minor',
+                [[0, 3, 69], [14, 3, 71], [14, 13, 72], [13, 4, 74], [14, 4, 72], [14, 4, 71],
+                [14, 4, 69], [55, 54, 64], [55, 23, 60], [27, 4, 69], [14, 4, 71],
+                [14, 54, 72], [55, 51, 74], [56, 24, 72], [27, 31, 71], [28, 25, 59],
+                [27, 5, 67], [14, 4, 69], [14, 13, 71], [14, 3, 72], [14, 5, 71],
+                [13, 5, 69], [14, 6, 68], [55, 55, 65], [55, 18, 64], [28, 3, 68],
+                [14, 4, 69], [13, 52, 71], [56, 52, 72], [55, 22, 71], [27, 26, 69],
+                [28, 26, 57]]],
+              ['Gang Dance', 'Chorus', 'D', 'Minor',
+                [[0, 11, 64], [21, 23, 64], [25, 7, 70], [49, 6, 69], [23, 23, 69],
+                [24, 12, 64], [68, 43, 65], [45, 6, 64], [23, 8, 65], [14, 7, 64],
+                [10, 6, 65], [11, 8, 67], [12, 13, 69], [50, 7, 67], [24, 25, 67],
+                [22, 11, 74], [48, 6, 73], [23, 25, 73], [24, 10, 69], [47, 6, 74],
+                [23, 54, 74]]],
+              ['Gang Dance', 'Verse', 'D', 'Minor',
+                [[0, 27, 69], [35, 5, 68], [10, 27, 69], [35, 6, 68], [10, 9, 69],
+                [24, 11, 65], [24, 12, 64], [22, 11, 62], [49, 43, 67], [47, 6, 62],
+                [25, 5, 67], [11, 5, 67], [12, 6, 67], [10, 7, 69], [12, 13, 67],
+                [72, 43, 67], [46, 7, 60], [24, 7, 67], [20, 23, 70], [25, 11, 69],
+                [22, 15, 67], [24, 9, 65], [24, 8, 65], [48, 4, 65], [11, 4, 65],
+                [11, 5, 65], [12, 5, 65], [11, 6, 65], [12, 9, 67], [13, 12, 65]]],
+              ['Gang Song', 'Chorus', 'C', 'Minor',
+                [[0, 24, 62], [38, 22, 62], [38, 25, 62], [38, 23, 63], [37, 24, 60],
+                [38, 24, 55], [38, 9, 63], [19, 11, 63], [19, 12, 62], [19, 9, 63],
+                [19, 30, 65], [38, 25, 65], [38, 32, 65], [38, 27, 65], [38, 28, 67],
+                [37, 14, 55], [39, 6, 67], [18, 12, 67], [19, 14, 65], [19, 10, 67],
+                [19, 31, 68], [38, 10, 70], [19, 22, 72], [38, 13, 72], [19, 9, 70],
+                [19, 9, 68], [19, 30, 67], [38, 10, 68], [19, 22, 70], [37, 11, 70],
+                [19, 10, 68], [20, 11, 67], [18, 20, 65], [19, 10, 64], [19, 12, 65],
+                [19, 11, 68], [19, 30, 67], [38, 13, 67], [19, 11, 67], [19, 34, 65],
+                [38, 71, 63]]],
+              ['Gang Song', 'Verse', 'C', 'Minor',
+                [[0, 9, 55], [19, 13, 60], [19, 12, 62], [19, 12, 63], [19, 10, 60],
+                [19, 15, 59], [19, 10, 60], [19, 11, 62], [19, 11, 59], [19, 32, 60],
+                [95, 11, 60], [18, 11, 63], [19, 10, 67], [20, 41, 72], [56, 12, 72],
+                [19, 13, 70], [19, 14, 68], [19, 12, 67], [19, 13, 65], [19, 19, 68],
+                [19, 41, 67], [114, 9, 67], [19, 14, 70], [18, 10, 68], [19, 11, 65],
+                [20, 13, 62], [18, 12, 60], [19, 10, 59], [19, 14, 67], [19, 13, 65],
+                [19, 27, 63], [133, 13, 60], [19, 14, 62], [19, 9, 62], [19, 15, 62],
+                [56, 8, 62], [20, 14, 62], [18, 11, 63], [19, 13, 62], [19, 17, 60]]],
+              ['Gang Stop', 'Chorus', 'F', 'Minor',
+                [[0, 13, 72], [25, 3, 67], [13, 13, 63], [25, 2, 62], [13, 14, 60],
+                [27, 14, 72], [25, 2, 67], [12, 12, 63], [26, 3, 62], [12, 14, 60],
+                [26, 4, 72], [13, 2, 72], [5, 2, 72], [6, 2, 72], [13, 3, 72], [13, 24, 73],
+                [26, 19, 72], [27, 12, 73], [14, 4, 72], [13, 3, 68], [12, 3, 67],
+                [12, 46, 65], [54, 23, 68], [25, 2, 65], [14, 24, 68], [27, 2, 65],
+                [12, 9, 68], [11, 3, 65], [12, 24, 68], [27, 2, 65], [14, 22, 68],
+                [25, 3, 65], [13, 10, 68], [12, 2, 65], [13, 3, 67], [13, 1, 67], [6, 2, 67],
+                [5, 2, 67], [14, 2, 67], [12, 24, 68], [27, 17, 67], [27, 24, 63],
+                [27, 21, 62], [26, 32, 60]]],
+              ['Gang Stop', 'Verse', 'F', 'Minor',
+                [[0, 14, 66], [26, 3, 67], [14, 12, 68], [25, 3, 67], [13, 3, 66],
+                [14, 2, 67], [12, 12, 70], [24, 4, 69], [15, 13, 68], [26, 3, 67],
+                [13, 2, 66], [13, 2, 67], [11, 22, 70], [26, 2, 69], [13, 12, 68],
+                [26, 3, 67], [11, 2, 66], [13, 2, 67], [12, 18, 67], [28, 22, 60],
+                [25, 42, 59], [54, 21, 68], [25, 3, 65], [14, 13, 68], [25, 9, 65],
+                [12, 9, 68], [12, 3, 65], [13, 22, 68], [26, 2, 65], [15, 12, 68],
+                [24, 8, 65], [12, 11, 68], [14, 3, 65], [12, 23, 68], [25, 3, 65],
+                [14, 23, 68], [25, 11, 65], [14, 10, 68], [11, 10, 65], [12, 24, 62],
+                [27, 22, 67], [26, 23, 63], [26, 16, 60]]],
+              ['Grasshopper', 'Chorus', 'B-', 'Minor',
+                [[0, 6, 70], [19, 6, 72], [19, 4, 72], [9, 5, 72], [10, 6, 72], [18, 5, 72],
+                [19, 6, 73], [19, 4, 73], [9, 5, 73], [10, 6, 73], [18, 6, 73], [19, 10, 73],
+                [19, 7, 72], [19, 7, 70], [18, 7, 69], [19, 7, 70], [19, 9, 70], [37, 6, 70],
+                [19, 6, 72], [19, 4, 72], [9, 6, 72], [10, 7, 72], [18, 6, 72], [19, 6, 73],
+                [19, 4, 73], [9, 5, 73], [10, 7, 73], [18, 5, 73], [19, 8, 73], [19, 7, 72],
+                [19, 7, 70], [18, 7, 69], [19, 9, 70]]],
+              ['Grasshopper', 'Verse', 'F', 'Minor',
+                [[0, 8, 70], [19, 10, 65], [19, 9, 70], [19, 9, 65], [18, 7, 70], [19, 9, 69],
+                [19, 10, 69], [37, 8, 69], [19, 11, 65], [19, 9, 69], [19, 9, 65],
+                [18, 9, 69], [19, 9, 70], [19, 10, 70], [37, 7, 70], [19, 11, 65],
+                [19, 8, 70], [19, 9, 65], [18, 8, 70], [19, 9, 69], [19, 9, 69], [37, 8, 69],
+                [19, 9, 65], [19, 8, 69], [19, 9, 65], [18, 8, 69], [19, 14, 70]]],
+              ['Gummy Bears', 'Chorus', 'B-', 'Major',
+                [[0, 18, 74], [24, 8, 75], [14, 36, 77], [40, 26, 77], [35, 9, 77],
+                [15, 8, 77], [13, 7, 77], [13, 10, 77], [13, 8, 75], [13, 7, 74],
+                [13, 8, 72], [13, 20, 74], [23, 10, 77], [14, 33, 70], [38, 11, 70],
+                [26, 4, 70], [14, 7, 77], [12, 7, 77], [13, 7, 77], [14, 9, 77], [13, 8, 75],
+                [13, 8, 74], [12, 10, 72], [12, 5, 70], [26, 5, 77], [18, 8, 74], [8, 5, 70],
+                [25, 4, 74], [26, 4, 70], [14, 10, 75], [13, 11, 74], [15, 22, 72],
+                [27, 23, 74], [35, 10, 70], [27, 9, 70], [23, 10, 70], [26, 10, 70],
+                [26, 9, 70], [26, 10, 70], [25, 11, 70], [26, 11, 70]]],
+              ['Gummy Bears', 'Verse', 'B-', 'Major',
+                [[0, 12, 62], [19, 12, 58], [18, 10, 62], [16, 12, 65], [18, 11, 62],
+                [16, 10, 65], [16, 14, 67], [17, 12, 69], [17, 11, 70], [17, 21, 65],
+                [26, 9, 62], [25, 12, 67], [18, 14, 65], [19, 10, 63], [16, 12, 65],
+                [18, 12, 63], [17, 8, 62], [16, 12, 63], [18, 10, 62], [17, 10, 60],
+                [16, 27, 65], [50, 14, 62], [21, 12, 58], [17, 11, 62], [16, 13, 65],
+                [18, 11, 62], [17, 12, 65], [16, 14, 67], [17, 16, 69], [16, 13, 70],
+                [17, 13, 65], [18, 12, 62], [16, 10, 58], [17, 13, 67], [18, 13, 65],
+                [17, 14, 63], [18, 11, 65], [16, 11, 62], [19, 11, 65], [16, 13, 67],
+                [17, 12, 69], [16, 11, 70], [17, 32, 72]]],
+              ['Hava Nagilah', 'Chorus', 'C', 'Minor',
+                [[0, 9, 66], [24, 35, 66], [50, 10, 63], [24, 10, 62], [25, 8, 62],
+                [25, 46, 62], [49, 7, 63], [25, 35, 63], [49, 12, 62], [12, 10, 63],
+                [13, 10, 60], [24, 5, 60], [25, 29, 60], [49, 41, 60], [50, 30, 63],
+                [37, 8, 62], [12, 9, 60], [23, 12, 60], [23, 34, 67], [46, 42, 66],
+                [46, 8, 63], [11, 9, 66], [11, 9, 63], [12, 11, 62], [11, 69, 66]]],
+              ['Hava Nagilah', 'Verse', 'D', 'Minor',
+                [[0, 34, 62], [49, 69, 62], [74, 18, 66], [25, 18, 63], [25, 17, 62],
+                [24, 36, 66], [50, 66, 66], [74, 22, 69], [24, 14, 67], [25, 17, 66],
+                [25, 36, 67], [49, 69, 67], [74, 21, 70], [25, 20, 69], [25, 17, 67],
+                [24, 48, 66], [50, 10, 63], [12, 8, 66], [12, 11, 63], [25, 83, 62]]],
+              ['It Too Shall Pass', 'Verse', 'C', 'Minor',
+                [[0, 4, 75], [18, 4, 72], [18, 4, 79], [36, 4, 75], [18, 4, 72], [18, 6, 79],
+                [36, 4, 72], [18, 4, 74], [18, 3, 75], [18, 4, 77], [18, 4, 75], [36, 4, 74],
+                [36, 4, 74], [18, 4, 71], [18, 4, 79], [36, 4, 74], [18, 6, 71], [18, 4, 79],
+                [36, 4, 74], [18, 3, 75], [18, 4, 77], [18, 4, 79], [18, 4, 77], [36, 3, 75],
+                [36, 4, 79], [18, 6, 76], [18, 4, 84], [36, 4, 79], [18, 6, 76], [18, 4, 84],
+                [36, 6, 79], [18, 4, 80], [18, 4, 82], [18, 4, 84], [18, 4, 82],
+                [36, 12, 80], [36, 4, 80], [18, 6, 84], [1, 12, 84], [17, 6, 82],
+                [18, 4, 80], [19, 3, 80], [35, 6, 79], [36, 4, 77], [1, 17, 77], [17, 5, 80],
+                [18, 9, 79], [18, 6, 74], [18, 4, 75], [72, 4, 80], [18, 6, 84], [18, 4, 82],
+                [18, 4, 80], [18, 4, 80], [36, 4, 79], [36, 4, 77], [18, 6, 80], [18, 4, 79],
+                [18, 4, 71], [18, 3, 72]]],
+              ['Learn at School', 'Chorus', 'E', 'Minor',
+                [[0, 14, 64], [14, 8, 74], [15, 15, 74], [14, 7, 72], [15, 17, 72],
+                [15, 9, 71], [14, 24, 71], [29, 12, 64], [15, 9, 72], [14, 18, 72],
+                [15, 8, 71], [14, 16, 71], [15, 6, 69], [15, 30, 69], [29, 16, 67],
+                [14, 18, 69], [15, 14, 72], [14, 17, 71], [15, 13, 67], [14, 14, 64],
+                [15, 16, 67], [15, 16, 66], [14, 18, 71], [15, 16, 63], [14, 29, 66],
+                [29, 36, 64]]],
+              ['Learn at School', 'Verse', 'E', 'Minor',
+                [[0, 15, 59], [15, 9, 67], [14, 18, 67], [15, 8, 66], [14, 16, 66],
+                [15, 7, 64], [14, 19, 64], [29, 14, 59], [15, 8, 67], [15, 15, 67],
+                [14, 8, 66], [15, 17, 66], [14, 7, 64], [15, 19, 64], [29, 14, 64],
+                [15, 15, 67], [14, 8, 71], [15, 13, 71], [14, 17, 69], [15, 18, 67],
+                [14, 8, 71], [15, 17, 71], [15, 14, 69], [14, 18, 67], [15, 31, 69],
+                [29, 46, 71]]],
+              ['Let Them Run', 'Chorus', 'E', 'Minor',
+                [[0, 7, 61], [15, 11, 61], [17, 9, 64], [15, 30, 64], [32, 28, 63],
+                [59, 10, 63], [14, 8, 66], [15, 26, 66], [31, 32, 64], [61, 12, 64],
+                [14, 8, 68], [15, 30, 68], [33, 28, 66], [60, 12, 69], [14, 12, 68],
+                [17, 45, 71], [90, 11, 68], [14, 10, 71], [18, 30, 71], [33, 24, 69],
+                [59, 11, 66], [16, 8, 69], [16, 29, 69], [31, 23, 68], [62, 11, 64],
+                [13, 10, 68], [15, 54, 66], [61, 56, 68], [62, 14, 61]]],
+              ['Let Them Run', 'Verse', 'C#', 'Minor',
+                [[0, 7, 68], [15, 7, 69], [16, 13, 68], [30, 9, 61], [14, 7, 63], [16, 9, 64],
+                [15, 6, 61], [16, 8, 68], [15, 7, 69], [14, 17, 68], [29, 8, 63],
+                [14, 8, 64], [18, 10, 66], [15, 5, 63], [16, 8, 68], [15, 9, 69],
+                [15, 20, 68], [31, 8, 63], [15, 6, 64], [16, 18, 66], [30, 7, 68],
+                [13, 10, 69], [16, 38, 68], [93, 7, 73], [14, 9, 74], [17, 19, 73],
+                [31, 8, 68], [14, 9, 69], [16, 11, 71], [15, 7, 68], [16, 8, 73],
+                [15, 8, 74], [15, 19, 73], [32, 10, 66], [14, 8, 68], [14, 10, 69],
+                [17, 10, 73], [16, 11, 71], [16, 8, 69], [16, 19, 73], [29, 10, 68],
+                [16, 8, 64], [15, 20, 63], [30, 10, 66], [16, 10, 64], [15, 60, 61]]],
+              ['Lullaby', 'Chorus', 'E-', 'Major',
+                [[0, 22, 70], [30, 31, 70], [30, 30, 72], [30, 29, 70], [30, 25, 75],
+                [29, 32, 75], [31, 31, 72], [30, 25, 70], [44, 21, 63], [30, 16, 63],
+                [16, 27, 68], [29, 31, 70], [30, 25, 72], [29, 32, 72], [31, 30, 70],
+                [30, 30, 68], [32, 20, 67], [29, 32, 67], [30, 30, 68], [30, 33, 67],
+                [31, 87, 70], [120, 59, 68], [59, 57, 65], [60, 80, 63]]],
+              ['Lullaby', 'Verse', 'E-', 'Major',
+                [[0, 27, 70], [25, 19, 67], [16, 45, 70], [44, 16, 67], [15, 26, 70],
+                [30, 32, 70], [31, 28, 68], [29, 31, 67], [32, 30, 65], [30, 30, 67],
+                [30, 67, 70], [180, 46, 70], [45, 15, 65], [14, 45, 70], [46, 16, 65],
+                [14, 32, 70], [32, 30, 68], [29, 29, 67], [28, 31, 65], [30, 29, 63],
+                [30, 32, 67], [31, 66, 70]]],
+              ['Mamonthy Song', 'Chorus', 'F', 'Minor',
+                [[0, 15, 72], [14, 15, 77], [14, 7, 79], [15, 5, 80], [14, 25, 79],
+                [28, 14, 77], [29, 15, 72], [14, 15, 77], [14, 5, 79], [15, 5, 80],
+                [14, 30, 79], [28, 11, 77], [29, 14, 72], [14, 15, 77], [14, 5, 79],
+                [14, 7, 80], [15, 29, 79], [28, 24, 77], [29, 15, 72], [14, 16, 75],
+                [14, 11, 73], [14, 8, 72], [14, 27, 75], [29, 19, 73], [28, 14, 73],
+                [15, 16, 82], [14, 15, 80], [14, 16, 82], [14, 30, 80], [29, 26, 79],
+                [28, 7, 77], [14, 29, 77], [29, 24, 72], [71, 6, 72], [14, 17, 72],
+                [15, 15, 76], [14, 15, 79], [14, 30, 82], [29, 26, 80], [29, 15, 79],
+                [15, 15, 80], [16, 12, 79], [12, 31, 77]]],
+              ['Mamonthy Song', 'Verse', 'A-', 'Major',
+                [[0, 15, 72], [14, 4, 75], [14, 4, 75], [14, 3, 75], [15, 28, 75],
+                [28, 30, 77], [29, 15, 72], [14, 5, 75], [14, 4, 75], [14, 4, 75],
+                [15, 29, 75], [57, 13, 68], [14, 9, 77], [14, 4, 77], [14, 4, 77],
+                [14, 27, 77], [29, 28, 80], [28, 14, 79], [15, 16, 77], [14, 5, 75],
+                [14, 3, 75], [14, 20, 75], [57, 16, 75], [15, 16, 80], [14, 15, 79],
+                [14, 11, 80], [14, 30, 79], [29, 30, 77], [28, 16, 79], [15, 30, 77],
+                [28, 27, 75], [71, 13, 75], [14, 15, 80], [15, 14, 70], [14, 15, 72],
+                [14, 30, 73], [29, 28, 77], [28, 16, 75], [14, 27, 73], [29, 34, 72]]],
+              ['New Year Song', 'Verse', 'C', 'Major',
+                [[0, 49, 79], [53, 8, 76], [27, 25, 76], [27, 50, 79], [53, 7, 76],
+                [27, 13, 76], [27, 23, 79], [26, 26, 77], [27, 22, 76], [27, 25, 74],
+                [27, 80, 72], [107, 45, 81], [53, 19, 84], [27, 18, 81], [26, 45, 79],
+                [54, 8, 76], [27, 17, 76], [26, 27, 79], [27, 26, 77], [27, 23, 76],
+                [26, 28, 74], [27, 87, 72], [108, 46, 81], [53, 16, 84], [27, 17, 81],
+                [27, 46, 79], [53, 7, 76], [27, 16, 76], [26, 28, 79], [27, 27, 77],
+                [27, 29, 76], [27, 28, 74], [26, 52, 72]]],
+              ['Open Secret', 'Chorus', 'G', 'Minor',
+                [[0, 4, 79], [12, 3, 84], [13, 13, 83], [26, 4, 77], [13, 4, 80],
+                [13, 11, 79], [25, 4, 79], [13, 4, 84], [13, 13, 83], [26, 4, 77],
+                [12, 3, 80], [13, 14, 79], [25, 5, 79], [14, 4, 84], [13, 4, 83],
+                [13, 4, 83], [13, 4, 79], [12, 3, 83], [13, 2, 84], [11, 4, 84], [13, 4, 84],
+                [13, 6, 86], [13, 10, 87], [12, 6, 86], [9, 4, 86], [3, 7, 84], [15, 4, 83],
+                [13, 8, 84]]],
+              ['Open Secret', 'Verse', 'E-', 'Minor',
+                [[0, 15, 79], [51, 13, 79], [52, 4, 79], [12, 4, 79], [13, 14, 80],
+                [13, 3, 75], [13, 14, 79], [13, 3, 77], [13, 12, 77], [26, 15, 77],
+                [51, 15, 77], [52, 4, 77], [13, 5, 80], [13, 12, 79], [13, 5, 74],
+                [12, 12, 77], [13, 3, 75], [13, 11, 75], [26, 15, 75], [52, 15, 75],
+                [51, 3, 75], [13, 4, 75], [13, 12, 77], [13, 4, 75], [13, 4, 74],
+                [13, 4, 72], [12, 51, 82], [52, 14, 80], [39, 5, 84], [13, 3, 82],
+                [13, 4, 80], [13, 10, 79], [13, 4, 77], [13, 3, 75], [13, 5, 74],
+                [12, 7, 72]]],
+              ['Righteous Road', 'Chorus', 'E-', 'Minor',
+                [[0, 20, 67], [18, 23, 68], [19, 19, 70], [17, 36, 71], [35, 37, 68],
+                [35, 23, 64], [20, 38, 65], [36, 19, 71], [19, 4, 70], [18, 5, 70],
+                [16, 4, 66], [19, 5, 66], [18, 9, 63], [17, 28, 63], [38, 6, 63],
+                [17, 21, 63], [18, 17, 62], [16, 21, 63], [18, 22, 65], [18, 21, 66],
+                [18, 20, 68], [18, 23, 70], [18, 22, 68], [18, 7, 66], [19, 6, 66],
+                [19, 5, 58], [19, 18, 58], [17, 9, 63]]],
+              ['Righteous Road', 'Verse', 'E-', 'Minor',
+                [[0, 5, 66], [18, 21, 66], [20, 6, 65], [17, 5, 65], [18, 5, 65],
+                [18, 22, 65], [19, 19, 66], [35, 21, 66], [20, 20, 68], [16, 20, 66],
+                [18, 21, 65], [18, 6, 63], [18, 24, 63], [20, 21, 58], [36, 19, 58],
+                [18, 19, 63], [18, 18, 62], [17, 20, 63], [17, 21, 65], [19, 21, 66],
+                [19, 20, 65], [16, 21, 66], [19, 20, 68], [18, 20, 70], [18, 21, 71],
+                [17, 19, 70], [16, 22, 68], [20, 23, 70]]],
+              ['Snow Maiden', 'Chorus', 'G', 'Major',
+                [[0, 17, 62], [26, 26, 62], [27, 10, 70], [54, 25, 67], [29, 21, 60],
+                [24, 12, 69], [54, 22, 65], [23, 25, 58], [30, 12, 67], [13, 11, 65],
+                [27, 10, 64], [13, 26, 67], [14, 12, 65], [13, 15, 65], [105, 14, 60],
+                [27, 6, 58], [13, 6, 58], [13, 18, 58], [54, 16, 62], [26, 6, 60],
+                [14, 9, 60], [13, 17, 60], [54, 19, 64], [26, 6, 62], [14, 13, 62],
+                [13, 21, 61], [26, 12, 59], [14, 10, 61], [13, 12, 62]]],
+              ['Snow Maiden', 'Verse', 'D', 'Major',
+                [[0, 6, 66], [13, 5, 66], [14, 4, 69], [13, 5, 69], [13, 28, 69], [25, 5, 67],
+                [15, 5, 67], [12, 17, 71], [27, 27, 71], [28, 26, 69], [53, 9, 66],
+                [14, 8, 66], [13, 3, 69], [12, 6, 69], [14, 25, 69], [27, 6, 67],
+                [14, 6, 67], [13, 19, 71], [27, 15, 71], [13, 29, 69], [67, 5, 66],
+                [14, 4, 66], [13, 4, 66], [13, 4, 66], [13, 23, 66], [27, 5, 62],
+                [14, 4, 62], [13, 12, 64], [27, 22, 64], [26, 15, 62], [53, 4, 62],
+                [13, 4, 62], [14, 5, 62], [13, 7, 64], [13, 20, 66], [27, 5, 62],
+                [13, 5, 62], [14, 17, 62], [26, 20, 61], [27, 12, 62]]],
+              ['Sun Circle', 'Chorus', 'G', 'Major',
+                [[0, 17, 62], [30, 16, 62], [29, 51, 67], [60, 20, 69], [30, 21, 71],
+                [30, 21, 69], [30, 12, 67], [30, 14, 62], [29, 16, 62], [30, 51, 67],
+                [60, 21, 69], [30, 21, 71], [29, 19, 71], [30, 14, 69], [30, 18, 62],
+                [30, 20, 62], [30, 51, 69], [59, 21, 71], [30, 20, 72], [30, 22, 74],
+                [30, 18, 69], [30, 19, 69], [30, 18, 71], [30, 54, 72], [59, 20, 67],
+                [30, 18, 69], [30, 49, 71]]],
+              ['Sun Circle', 'Verse', 'G', 'Minor',
+                [[0, 29, 62], [29, 20, 63], [20, 9, 62], [9, 58, 67], [59, 31, 69],
+                [31, 22, 70], [21, 8, 69], [8, 44, 62], [60, 27, 62], [29, 17, 70],
+                [21, 4, 70], [7, 31, 70], [30, 21, 69], [22, 2, 69], [8, 30, 67],
+                [32, 67, 66], [91, 28, 65], [29, 21, 67], [21, 7, 65], [8, 55, 70],
+                [60, 30, 72], [29, 23, 74], [22, 6, 72], [7, 48, 65], [62, 28, 65],
+                [29, 17, 69], [18, 8, 70], [10, 30, 72], [31, 15, 70], [17, 13, 72],
+                [15, 45, 74]]],
+              ['Sunbath', 'Verse', 'F', 'Major',
+                [[0, 11, 72], [19, 10, 70], [11, 9, 69], [31, 8, 65], [31, 7, 62],
+                [29, 7, 64], [19, 105, 65], [106, 12, 72], [20, 12, 70], [10, 11, 69],
+                [32, 9, 65], [30, 10, 62], [32, 8, 64], [19, 95, 65], [105, 9, 69],
+                [18, 13, 72], [12, 87, 67], [96, 10, 69], [18, 11, 72], [10, 86, 65],
+                [94, 11, 67], [20, 8, 69], [11, 8, 70], [32, 9, 67], [30, 10, 64],
+                [31, 10, 67], [17, 101, 65], [107, 10, 69], [22, 11, 72], [13, 86, 67],
+                [91, 10, 69], [21, 12, 72], [11, 80, 65], [91, 9, 67], [20, 8, 69],
+                [11, 7, 70], [32, 7, 67], [31, 9, 64], [31, 9, 67], [18, 79, 65]]],
+              ['Tail Spin', 'Chorus', 'G', 'Major',
+                [[0, 6, 67], [16, 8, 71], [16, 6, 62], [16, 5, 65], [8, 5, 67], [15, 4, 67],
+                [8, 6, 71], [16, 5, 62], [16, 5, 65], [16, 5, 67], [16, 7, 71], [16, 5, 62],
+                [15, 5, 65], [8, 6, 67], [19, 7, 67], [16, 7, 67], [15, 14, 67], [21, 6, 67],
+                [16, 7, 71], [16, 6, 62], [16, 5, 65], [8, 5, 67], [16, 3, 67], [8, 6, 71],
+                [15, 5, 62], [16, 5, 65], [16, 5, 67], [16, 7, 71], [16, 5, 62], [15, 5, 65],
+                [8, 6, 67]]],
+              ['Tail Spin', 'Verse', 'C', 'Major',
+                [[0, 14, 62], [14, 17, 67], [16, 17, 64], [32, 3, 64], [8, 6, 64],
+                [16, 25, 66], [41, 15, 60], [15, 17, 64], [15, 17, 62], [30, 2, 62],
+                [10, 6, 62], [16, 22, 64], [71, 4, 60], [8, 5, 60], [15, 7, 60], [16, 6, 64],
+                [17, 7, 64], [17, 6, 62], [16, 7, 62], [21, 2, 62], [8, 3, 62], [8, 7, 64],
+                [14, 3, 64], [10, 6, 66], [13, 5, 66], [9, 13, 67]]],
+              ['Thirty Three Cows', 'Chorus', 'A', 'Major',
+                [[0, 8, 76], [20, 6, 76], [9, 8, 76], [20, 5, 76], [10, 18, 76], [20, 28, 72],
+                [39, 8, 74], [19, 4, 74], [10, 8, 74], [20, 6, 74], [10, 17, 74],
+                [19, 26, 71], [40, 7, 72], [19, 4, 72], [10, 8, 72], [19, 5, 72],
+                [10, 16, 72], [20, 29, 69], [39, 18, 70], [20, 12, 72], [10, 20, 70],
+                [19, 13, 69], [10, 23, 67], [59, 19, 69], [19, 4, 72], [10, 17, 72],
+                [20, 11, 69], [10, 19, 72], [19, 28, 74], [40, 8, 67], [20, 13, 67],
+                [9, 18, 69], [20, 11, 68], [10, 17, 67], [19, 23, 76], [40, 7, 76],
+                [19, 5, 76], [10, 8, 76], [20, 4, 76], [10, 15, 76], [19, 5, 72],
+                [10, 18, 72], [20, 12, 76], [10, 17, 74]]],
+              ['Thirty Three Cows', 'Verse', 'A', 'Major',
+                [[0, 9, 64], [19, 8, 62], [10, 12, 60], [28, 17, 60], [31, 13, 64],
+                [28, 16, 67], [17, 18, 72], [31, 14, 72], [72, 11, 71], [19, 13, 69],
+                [11, 12, 67], [26, 12, 69], [30, 11, 67], [30, 16, 64], [17, 14, 62],
+                [102, 11, 64], [19, 10, 62], [11, 13, 60], [27, 13, 60], [31, 11, 64],
+                [28, 16, 67], [17, 17, 72], [31, 16, 72], [72, 11, 71], [18, 11, 72],
+                [10, 15, 74], [29, 12, 71], [28, 13, 69], [31, 17, 71], [17, 17, 67],
+                [100, 18, 64], [19, 10, 62], [10, 13, 60], [29, 15, 60], [30, 12, 64],
+                [29, 17, 67], [18, 18, 72], [30, 16, 72], [71, 9, 71], [20, 13, 69],
+                [12, 13, 67], [27, 12, 69], [28, 13, 67], [30, 19, 64], [18, 19, 62],
+                [101, 11, 64], [18, 10, 62], [10, 15, 60], [28, 13, 60], [29, 13, 64],
+                [31, 18, 72], [17, 19, 71], [31, 18, 69], [71, 12, 64], [18, 12, 62],
+                [10, 14, 60], [29, 15, 60], [30, 12, 64], [29, 18, 72], [19, 17, 71],
+                [29, 17, 69], [69, 19, 69], [18, 12, 69], [12, 13, 74], [30, 12, 74],
+                [29, 14, 74], [31, 16, 76], [15, 59, 77]]],
+              ['USSR Anthem', 'Chorus', 'C', 'Major',
+                [[0, 23, 67], [23, 46, 76], [47, 35, 74], [35, 11, 72], [12, 46, 74],
+                [47, 23, 71], [23, 23, 67], [24, 46, 72], [46, 35, 71], [36, 11, 69],
+                [11, 46, 71], [47, 23, 64], [24, 23, 64], [23, 46, 69], [47, 23, 67],
+                [23, 23, 65], [24, 46, 67], [47, 23, 60], [23, 23, 60], [24, 46, 72],
+                [46, 35, 71], [36, 11, 69], [11, 93, 67]]],
+              ['USSR Anthem', 'Verse', 'C', 'Major',
+                [[0, 23, 67], [23, 46, 72], [47, 35, 67], [35, 11, 69], [12, 46, 71],
+                [47, 23, 64], [23, 23, 64], [24, 46, 69], [46, 35, 67], [36, 11, 65],
+                [11, 46, 67], [47, 23, 60], [24, 23, 60], [23, 46, 62], [47, 23, 62],
+                [23, 23, 64], [24, 46, 65], [47, 23, 65], [23, 23, 67], [24, 46, 69],
+                [46, 23, 71], [24, 23, 72], [23, 70, 74]]],
+              ['White Ships', 'Chorus', 'G', 'Minor',
+                [[0, 9, 81], [18, 9, 81], [19, 9, 81], [19, 9, 83], [19, 9, 81], [9, 9, 83],
+                [9, 9, 81], [19, 18, 80], [19, 9, 76], [19, 9, 79], [18, 9, 79], [19, 9, 79],
+                [19, 9, 81], [19, 9, 79], [9, 9, 81], [9, 9, 79], [19, 18, 78], [19, 9, 74],
+                [19, 18, 74], [37, 28, 74], [38, 9, 73], [18, 9, 74], [19, 9, 76],
+                [19, 9, 78], [19, 75, 71]]],
+              ['White Ships', 'Verse', 'B', 'Minor',
+                [[0, 18, 71], [28, 9, 71], [9, 9, 71], [19, 9, 74], [19, 28, 78],
+                [37, 18, 76], [19, 9, 74], [19, 18, 76], [28, 9, 76], [9, 9, 76],
+                [19, 9, 78], [19, 28, 76], [37, 18, 74], [19, 9, 73], [19, 28, 74],
+                [37, 28, 71], [38, 28, 79], [37, 28, 76], [38, 112, 78]]],
+              ['Winged Swing', 'Chorus', 'D', 'Major',
+                [[0, 27, 57], [22, 37, 66], [43, 70, 66], [86, 25, 66], [22, 23, 67],
+                [21, 46, 66], [43, 79, 64], [108, 21, 64], [22, 95, 71], [107, 25, 71],
+                [22, 20, 69], [22, 23, 68], [21, 91, 69], [130, 54, 62], [43, 89, 74],
+                [107, 20, 74], [22, 23, 72], [22, 14, 70], [21, 42, 70], [43, 88, 69],
+                [108, 23, 69], [22, 23, 71], [21, 22, 69], [22, 83, 71], [84, 42, 73],
+                [43, 106, 74]]],
+              ['Winged Swing', 'Verse', 'D', 'Minor',
+                [[0, 27, 69], [32, 8, 70], [11, 7, 69], [11, 11, 65], [10, 9, 64],
+                [11, 14, 62], [11, 20, 65], [22, 36, 64], [64, 30, 69], [33, 11, 70],
+                [10, 7, 69], [11, 10, 65], [11, 10, 64], [11, 16, 62], [10, 59, 64],
+                [86, 29, 66], [33, 12, 67], [11, 3, 69], [10, 12, 69], [11, 11, 70],
+                [11, 5, 72], [11, 23, 72], [21, 28, 70], [43, 12, 70], [11, 5, 69],
+                [11, 18, 69], [21, 29, 67], [43, 12, 62], [11, 5, 64], [11, 68, 64]]],
+              ['With a Smile', 'Chorus', 'C#', 'Minor',
+                [[0, 14, 61], [17, 7, 64], [17, 7, 68], [17, 7, 68], [17, 7, 68], [17, 7, 68],
+                [17, 20, 68], [35, 17, 73], [17, 17, 61], [17, 17, 64], [17, 8, 63],
+                [17, 10, 63], [17, 10, 63], [17, 21, 63], [34, 18, 63], [17, 17, 64],
+                [17, 20, 68], [17, 18, 66], [17, 16, 68], [18, 18, 69], [17, 17, 68],
+                [17, 18, 66], [17, 17, 68], [17, 18, 69], [17, 34, 73], [34, 49, 71],
+                [68, 15, 73], [17, 18, 68], [17, 18, 71], [17, 7, 69], [17, 5, 69],
+                [17, 7, 69], [18, 23, 69], [34, 17, 73], [17, 17, 66], [17, 17, 69],
+                [17, 8, 68], [17, 7, 68], [17, 7, 68], [17, 25, 68], [34, 15, 73],
+                [17, 19, 64], [17, 17, 63], [17, 19, 64], [17, 18, 66], [17, 17, 69],
+                [17, 15, 68], [18, 18, 66], [17, 17, 64], [17, 17, 66], [17, 37, 69],
+                [34, 51, 68]]],
+              ['With a Smile', 'Verse', 'B-', 'Major',
+                [[0, 20, 68], [17, 20, 65], [18, 32, 70], [34, 33, 68], [34, 20, 63],
+                [17, 18, 66], [17, 19, 65], [17, 19, 63], [17, 72, 61], [102, 21, 65],
+                [17, 20, 68], [17, 13, 70], [18, 11, 70], [17, 18, 70], [17, 18, 72],
+                [17, 20, 75], [17, 19, 73], [17, 21, 72], [17, 20, 70], [17, 38, 73],
+                [34, 51, 68], [68, 19, 70], [17, 19, 72], [17, 51, 73], [51, 20, 72],
+                [17, 18, 70], [17, 20, 65], [18, 19, 68], [17, 20, 66], [17, 82, 70],
+                [102, 20, 72], [17, 19, 70], [17, 18, 73], [17, 18, 68], [17, 19, 72],
+                [17, 10, 70], [17, 23, 70], [17, 18, 68], [17, 19, 63], [18, 19, 65],
+                [17, 37, 63], [34, 41, 61]]],
+              ['Wizard of Oz', 'Verse', 'F', 'Major',
+                [[0, 25, 69], [30, 6, 72], [17, 5, 72], [15, 5, 77], [16, 9, 77],
+                [16, 28, 81], [30, 6, 79], [16, 6, 79], [16, 15, 81], [17, 5, 79],
+                [16, 5, 76], [16, 7, 72], [15, 29, 79], [31, 13, 77], [15, 14, 69],
+                [17, 5, 72], [15, 6, 72], [14, 6, 77], [17, 6, 77], [16, 28, 81],
+                [32, 5, 79], [15, 6, 79], [15, 12, 81], [15, 6, 79], [17, 5, 76],
+                [15, 10, 72], [14, 37, 77], [48, 10, 81], [16, 24, 84], [31, 24, 84],
+                [31, 24, 84], [32, 24, 84], [31, 21, 77], [28, 12, 77], [17, 62, 77],
+                [62, 12, 82], [18, 22, 86], [31, 23, 86], [31, 25, 86], [31, 22, 86],
+                [31, 30, 86], [33, 38, 84], [76, 8, 81], [16, 9, 84], [14, 8, 82],
+                [15, 8, 77], [16, 8, 74], [15, 27, 82], [32, 27, 81], [141, 7, 72],
+                [16, 19, 79], [31, 21, 79], [30, 44, 79], [48, 5, 77], [16, 63, 77]]]]
+
+################################################################################
+
+FILTERED_CHORDS = [[0], [0, 3], [0, 3, 5], [0, 3, 5, 8], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 7],
+                  [0, 3, 7, 10], [0, 3, 8], [0, 3, 9], [0, 3, 10], [0, 4], [0, 4, 6],
+                  [0, 4, 6, 9], [0, 4, 6, 10], [0, 4, 7], [0, 4, 7, 10], [0, 4, 8], [0, 4, 9],
+                  [0, 4, 10], [0, 5], [0, 5, 8], [0, 5, 9], [0, 5, 10], [0, 6], [0, 6, 9],
+                  [0, 6, 10], [0, 7], [0, 7, 10], [0, 8], [0, 9], [0, 10], [1], [1, 4],
+                  [1, 4, 6], [1, 4, 6, 9], [1, 4, 6, 10], [1, 4, 6, 11], [1, 4, 7],
+                  [1, 4, 7, 10], [1, 4, 7, 11], [1, 4, 8], [1, 4, 8, 11], [1, 4, 9], [1, 4, 10],
+                  [1, 4, 11], [1, 5], [1, 5, 8], [1, 5, 8, 11], [1, 5, 9], [1, 5, 10],
+                  [1, 5, 11], [1, 6], [1, 6, 9], [1, 6, 10], [1, 6, 11], [1, 7], [1, 7, 10],
+                  [1, 7, 11], [1, 8], [1, 8, 11], [1, 9], [1, 10], [1, 11], [2], [2, 5],
+                  [2, 5, 8], [2, 5, 8, 11], [2, 5, 9], [2, 5, 10], [2, 5, 11], [2, 6], [2, 6, 9],
+                  [2, 6, 10], [2, 6, 11], [2, 7], [2, 7, 10], [2, 7, 11], [2, 8], [2, 8, 11],
+                  [2, 9], [2, 10], [2, 11], [3], [3, 5], [3, 5, 8], [3, 5, 8, 11], [3, 5, 9],
+                  [3, 5, 10], [3, 5, 11], [3, 7], [3, 7, 10], [3, 7, 11], [3, 8], [3, 8, 11],
+                  [3, 9], [3, 10], [3, 11], [4], [4, 6], [4, 6, 9], [4, 6, 10], [4, 6, 11],
+                  [4, 7], [4, 7, 10], [4, 7, 11], [4, 8], [4, 8, 11], [4, 9], [4, 10], [4, 11],
+                  [5], [5, 8], [5, 8, 11], [5, 9], [5, 10], [5, 11], [6], [6, 9], [6, 10],
+                  [6, 11], [7], [7, 10], [7, 11], [8], [8, 11], [9], [10], [11]]
+
+################################################################################
+
+import copy
+from collections import Counter
+from itertools import groupby
+
+################################################################################
+
+def ordered_set(seq):
+  dic = {}
+  return [k for k, v in dic.fromkeys(seq).items()]
+
+################################################################################
+
+def grouped_set(seq):
+  return [k for k, v in groupby(seq)]
+
+################################################################################
+
+def melody_pitches(melody):
+  return [p[2] for p in melody[4]]
+
+################################################################################
+
+def melody_tones(melody):
+  return [t[2] % 12 for t in melody[4]]
+
+################################################################################
+
+def melody_pitches_counts(melody):
+  return [list(c) for c in Counter(melody_pitches(melody)).most_common()]
+
+################################################################################
+
+def melody_tones_counts(melody):
+  return [list(c) for c in Counter(melody_tones(melody)).most_common()]
+
+################################################################################
+
+def transpose_melody(melody, transpose_value):
+
+  mel = copy.deepcopy(melody)
+
+  score = mel[4]
+
+  for note in score:
+    note[2] += transpose_value
+
+  return mel[:4] + [score]
+
+################################################################################
+
+def adjust_melody_average_timings(melody, average_time):
+
+  mel = copy.deepcopy(melody)
+
+  score = mel[4]
+
+  dtimes = [d[1] for d in score]
+  old_avg_dtime = sum(dtimes) / len(dtimes)
+
+  tadjk = old_avg_dtime / average_time
+
+  for note in score:
+    note[1] = int(note[1] / tadjk)
+    note[2] = int(note[2] / tadjk)
+
+  dtimes = [d[1] for d in score]
+  new_avg_dtime = sum(dtimes) / len(dtimes)
+
+  return [mel[:4] + [score], new_avg_dtime, old_avg_dtime]
+
+################################################################################
+
+def most_common_melody_pitch_and_tone(melody):
+
+  mel_pitches = melody_pitches(melody)
+  mel_tones = [t % 12 for t in mel_pitches]
+
+  return [list(Counter(mel_pitches).most_common()[0]), list(Counter(mel_tones).most_common()[0])]
+
+################################################################################
+
+def melody_dtimes_counts(melody):
+  return [list(c) for c in Counter([n[0] for n in melody[4]]).most_common()]
+
+################################################################################
+
+def melody_durations_counts(melody):
+  return [list(c) for c in Counter([n[1] for n in melody[4]]).most_common()]
+
+################################################################################
+
+def melody_notes_count(melody):
+  return len(melody[4])
+
+################################################################################
+
+def most_common_melody_dtime_and_duration(melody):
+  return [melody_dtimes_counts(melody)[0], melody_durations_counts(melody)[0]]
+
+################################################################################
+
+def melody_run_time(melody):
+  dtimes = [n[0] for n in melody[4]]
+  last_dur = melody[4][-1][1]
+
+  rel_run_time = sum(dtimes)+last_dur
+  ms_run_time = rel_run_time * 16
+  sec_run_time = ms_run_time / 1000
+  min_run_time = sec_run_time / 60
+
+  return [rel_run_time, ms_run_time, sec_run_time, min_run_time]
+
+################################################################################
+
+def harmonize_melody(melody):
+  
+  mel_tones = melody_tones(melody)
+
+  cur_chord = []
+
+  harmonized_chords = []
+
+  for i, m in enumerate(mel_tones):
+    cur_chord.append(m)
+    cc = sorted(set(cur_chord))
+
+    if cc in FILTERED_CHORDS:
+      harmonized_chords.append(cc)
+
+    else:
+      while sorted(set(cur_chord)) not in FILTERED_CHORDS:
+        cur_chord.pop(0)
+      cc = sorted(set(cur_chord))
+      harmonized_chords.append(cc)
+
+  return harmonized_chords
+
+################################################################################
+
+def melody_range(melody):
+
+  mel_pitches = melody_pitches(melody)
+
+  max_pitch = max(mel_pitches)
+  avg_pitch = sum(mel_pitches) / len(mel_pitches)
+  min_pitch = min(mel_pitches)
+
+  pitch_range = max_pitch - min_pitch
+
+  return [max_pitch, avg_pitch, min_pitch, pitch_range]
+
+################################################################################
+
+def melody_octave(melody):
+  return int(melody_range(melody)[1] // 12)
+
+################################################################################
+
+def melody_to_enhanced_score_notes(melody, 
+                                   melody_channel=3, 
+                                   melody_velocity=-1,
+                                   melody_patch=40,
+                                   harmonized_tones_chords=[],
+                                   harmonized_tones_chords_base_octave=-1,
+                                   harmonized_tones_chords_channel=0,
+                                   harmonized_tones_chords_velocity=-1,
+                                   harmonized_tones_chords_patch=0              
+                                   ):
+
+  name = melody[0]
+  part = melody[1]
+  key1 = melody[2]
+  key2 = melody[3]
+
+  if harmonized_tones_chords_base_octave > -1:
+    mel_base_octave = harmonized_tones_chords_base_octave
+  
+  else:
+    mel_base_octave = melody_octave(melody) - 1
+
+  escore_notes = []
+
+  time = 0
+
+  for i, note in enumerate(melody[4]):
+    
+    time += note[0]
+    dur = note[1]
+    ptc = note[2]
+
+    if melody_velocity == -1:
+      vel = int(110 + ((ptc % 12) * 1.5))
+    else:
+      vel = melody_velocity
+
+    escore_notes.append(['note', time, dur, melody_channel, ptc, vel, melody_patch])
+
+    if harmonized_tones_chords and i < len(harmonized_tones_chords):
+
+      for t in harmonized_tones_chords[i]:
+
+        ptc = (mel_base_octave * 12) + t
+
+        if harmonized_tones_chords_velocity == -1:
+          vel = int(80 + ((ptc % 12) * 1.5))
+        else:
+          vel = harmonized_tones_chords_velocity
+
+        escore_notes.append(['note', time, dur, harmonized_tones_chords_channel, ptc, vel, harmonized_tones_chords_patch])
+
+  return [name, part, key1 + ' ' + key2, escore_notes]
+
+################################################################################
+
+def flip_melody(melody):
+
+  mel = copy.deepcopy(melody)
+
+  old_mel_range = melody_range(melody)
+
+  for note in mel[4]:
+    note[2] = 127 - note[2]
+
+  new_mel_range = melody_range(mel)
+
+  transpose_value = int(old_mel_range[1] - new_mel_range[1])
+
+  new_melody = transpose_melody(mel, transpose_value)
+
+  return melody[:4] + [new_melody[4]]
+
+################################################################################
+
+def reverse_melody(melody, full_reverse=True):
+
+  mel = copy.deepcopy(melody)
+
+  if full_reverse:
+    
+    abs_times = []
+
+    atime = 0
+
+    for t in mel[4]:
+      atime += t[0]
+      abs_times.append(atime)
+
+    abs_dtimes = []
+
+    for i, t in enumerate(mel[4]):
+      abs_dtimes.append(abs_times[i]+t[1])
+
+    new_dtimes = []
+    pt = abs_dtimes[-1]
+
+    for t in abs_dtimes[::-1]:
+      new_dtimes.append(pt-t)
+      pt = t
+
+    new_mel = copy.deepcopy(mel[4][::-1])
+
+    for i, t in enumerate(new_mel):
+      t[0] = new_dtimes[i]
+
+    return melody[:4] + [new_mel]
+
+  else:
+    mel_pitches = melody_pitches(melody)[::-1]
+
+    for i, note in enumerate(mel[4]):
+      note[2] = mel_pitches[i]
+
+    return melody[:4] + [mel[4]]
+    
+################################################################################
+#
+# This is the end of TMELODIES Python module
+#
+################################################################################

TMIDIX.py

@@ -9381,6 +9381,150 @@ def advanced_add_drums_to_escore_notes(escore_notes,
     
     return delta_score_to_abs_score(drums_score)
 
+###################################################################################
+
+MIDI_TEXT_EVENTS = ['text_event',
+                    'copyright_text_event',
+                    'track_name',
+                    'instrument_name',
+                    'lyric',
+                    'marker',
+                    'cue_point',
+                    'text_event_08',
+                    'text_event_09',
+                    'text_event_0a',
+                    'text_event_0b',
+                    'text_event_0c',
+                    'text_event_0d',
+                    'text_event_0e',
+                    'text_event_0f'
+                  ]
+
+###################################################################################
+
+import hashlib
+import re
+
+###################################################################################
+
+def get_md5_hash(data):
+    return hashlib.md5(data).hexdigest()
+
+###################################################################################
+
+def is_valid_md5_hash(string):
+    return bool(re.match(r'^[a-fA-F0-9]{32}$', string))
+
+###################################################################################
+
+def clean_string(original_string,
+                 regex=r'[^a-zA-Z0-9 ]',
+                 remove_duplicate_spaces=True,
+                 title=False
+                ):
+    
+    cstr1 = re.sub(regex, '', original_string)
+
+    if title:
+        cstr1 = cstr1.title()
+
+    if remove_duplicate_spaces:
+        return re.sub(r'\s+', ' ', cstr1).strip()
+
+    else:
+        return cstr1
+    
+###################################################################################
+    
+def encode_to_ord(text, chars_range=[], sub_char='', chars_shift=0):
+
+    if not chars_range:
+        chars_range = [32] + list(range(65, 91)) + list(range(97, 123))
+
+    if sub_char:
+        chars_range.append(ord(sub_char))
+
+    chars_range = sorted(set(chars_range))
+
+    encoded = []
+    
+    for char in text:
+        if ord(char) in chars_range:
+            encoded.append(chars_range.index(ord(char)) + chars_shift)
+            
+        else:
+            if sub_char:
+                encoded.append(chars_range.index(ord(sub_char)) + chars_shift)
+        
+    
+    return [encoded, chars_range]
+
+###################################################################################
+
+def decode_from_ord(ord_list, chars_range=[], sub_char='', chars_shift=0):
+
+    if not chars_range:
+        chars_range = [32] + list(range(65, 91)) + list(range(97, 123))
+
+    if sub_char:
+        chars_range.append(ord(sub_char))
+
+    chars_range = sorted(set(chars_range))
+        
+    return ''.join(chr(chars_range[num-chars_shift]) if 0 <= num-chars_shift < len(chars_range) else sub_char for num in ord_list)
+
+###################################################################################
+
+def lists_similarity(list1, list2, by_elements=True, by_sum=True):
+    
+    if len(list1) != len(list2) or len(list1) % 2 != 0:
+        return -1
+    
+    element_ratios = []
+    total_counts1 = sum(list1)
+    total_counts2 = sum(list2)
+
+    for a, b in zip(list1, list2):
+        if a == 0 and b == 0:
+            element_ratios.append(1)
+        elif a == 0 or b == 0:
+            element_ratios.append(0)
+        else:
+            element_ratios.append(min(a, b) / max(a, b))
+
+    average_element_ratio = sum(element_ratios) / len(element_ratios)
+
+    total_counts_ratio = min(total_counts1, total_counts2) / max(total_counts1, total_counts2)
+
+    if by_elements and by_sum:
+        return (average_element_ratio + total_counts_ratio) / 2
+
+    elif by_elements and not by_sum:
+        return average_element_ratio
+
+    elif not by_elements and by_sum:
+        return total_counts_ratio
+
+    else:
+        return -1
+
+###################################################################################
+
+def find_indexes(lst, value, mode='equal', dual_mode=True):
+
+    indexes = []
+
+    if mode == 'equal' or dual_mode:    
+        indexes.extend([index for index, elem in enumerate(lst) if elem == value])
+
+    if mode == 'smaller':
+        indexes.extend([index for index, elem in enumerate(lst) if elem < value])
+
+    if mode == 'larger':
+        indexes.extend([index for index, elem in enumerate(lst) if elem > value])
+
+    return sorted(set(indexes))
+
 ###################################################################################
 #  
 # This is the end of the TMIDI X Python module

TPLOTS.py

@@ -0,0 +1,1369 @@
+#! /usr/bin/python3
+
+r'''############################################################################
+################################################################################
+#
+#
+#	      Tegridy Plots Python Module (TPLOTS)
+#	      Version 1.0
+#
+#	      Project Los Angeles
+#
+#	      Tegridy Code 2024
+#
+#       https://github.com/asigalov61/tegridy-tools
+#
+#
+################################################################################
+#
+#       Copyright 2024 Project Los Angeles / Tegridy Code
+#
+#       Licensed under the Apache License, Version 2.0 (the "License");
+#       you may not use this file except in compliance with the License.
+#       You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#       Unless required by applicable law or agreed to in writing, software
+#       distributed under the License is distributed on an "AS IS" BASIS,
+#       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#       See the License for the specific language governing permissions and
+#       limitations under the License.
+#
+################################################################################
+################################################################################
+#
+# Critical dependencies
+#
+# !pip install numpy
+# !pip install scipy
+# !pip install matplotlib
+# !pip install networkx
+# !pip3 install scikit-learn
+#
+################################################################################
+#
+# Future critical dependencies
+#
+# !pip install umap-learn
+# !pip install alphashape
+#
+################################################################################
+'''
+
+################################################################################
+# Modules imports
+################################################################################
+
+import os
+from collections import Counter
+from itertools import groupby
+
+import numpy as np
+
+import networkx as nx
+
+from sklearn.manifold import TSNE
+from sklearn import metrics
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.decomposition import PCA
+
+from scipy.ndimage import zoom
+from scipy.spatial import distance_matrix
+from scipy.sparse.csgraph import minimum_spanning_tree
+from scipy.stats import zscore
+
+import matplotlib.pyplot as plt
+from PIL import Image
+
+################################################################################
+# Constants
+################################################################################
+
+ALL_CHORDS_FULL = [[0], [0, 3], [0, 3, 5], [0, 3, 5, 8], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 6],
+                  [0, 3, 6, 9], [0, 3, 6, 10], [0, 3, 7], [0, 3, 7, 10], [0, 3, 8], [0, 3, 9],
+                  [0, 3, 10], [0, 4], [0, 4, 6], [0, 4, 6, 9], [0, 4, 6, 10], [0, 4, 7],
+                  [0, 4, 7, 10], [0, 4, 8], [0, 4, 9], [0, 4, 10], [0, 5], [0, 5, 8], [0, 5, 9],
+                  [0, 5, 10], [0, 6], [0, 6, 9], [0, 6, 10], [0, 7], [0, 7, 10], [0, 8], [0, 9],
+                  [0, 10], [1], [1, 4], [1, 4, 6], [1, 4, 6, 9], [1, 4, 6, 10], [1, 4, 6, 11],
+                  [1, 4, 7], [1, 4, 7, 10], [1, 4, 7, 11], [1, 4, 8], [1, 4, 8, 11], [1, 4, 9],
+                  [1, 4, 10], [1, 4, 11], [1, 5], [1, 5, 8], [1, 5, 8, 11], [1, 5, 9],
+                  [1, 5, 10], [1, 5, 11], [1, 6], [1, 6, 9], [1, 6, 10], [1, 6, 11], [1, 7],
+                  [1, 7, 10], [1, 7, 11], [1, 8], [1, 8, 11], [1, 9], [1, 10], [1, 11], [2],
+                  [2, 5], [2, 5, 8], [2, 5, 8, 11], [2, 5, 9], [2, 5, 10], [2, 5, 11], [2, 6],
+                  [2, 6, 9], [2, 6, 10], [2, 6, 11], [2, 7], [2, 7, 10], [2, 7, 11], [2, 8],
+                  [2, 8, 11], [2, 9], [2, 10], [2, 11], [3], [3, 5], [3, 5, 8], [3, 5, 8, 11],
+                  [3, 5, 9], [3, 5, 10], [3, 5, 11], [3, 6], [3, 6, 9], [3, 6, 10], [3, 6, 11],
+                  [3, 7], [3, 7, 10], [3, 7, 11], [3, 8], [3, 8, 11], [3, 9], [3, 10], [3, 11],
+                  [4], [4, 6], [4, 6, 9], [4, 6, 10], [4, 6, 11], [4, 7], [4, 7, 10], [4, 7, 11],
+                  [4, 8], [4, 8, 11], [4, 9], [4, 10], [4, 11], [5], [5, 8], [5, 8, 11], [5, 9],
+                  [5, 10], [5, 11], [6], [6, 9], [6, 10], [6, 11], [7], [7, 10], [7, 11], [8],
+                  [8, 11], [9], [10], [11]]
+
+################################################################################
+
+CHORDS_TYPES = ['WHITE', 'BLACK', 'UNKNOWN', 'MIXED WHITE', 'MIXED BLACK', 'MIXED GRAY']
+
+################################################################################
+
+WHITE_NOTES = [0, 2, 4, 5, 7, 9, 11]
+
+################################################################################
+
+BLACK_NOTES = [1, 3, 6, 8, 10]
+
+################################################################################
+# Helper functions
+################################################################################
+
+def tones_chord_type(tones_chord, 
+                     return_chord_type_index=True,
+                     ):
+
+  """
+  Returns tones chord type
+  """
+
+  WN = WHITE_NOTES
+  BN = BLACK_NOTES
+  MX = WHITE_NOTES + BLACK_NOTES
+
+
+  CHORDS = ALL_CHORDS_FULL
+
+  tones_chord = sorted(tones_chord)
+
+  ctype = 'UNKNOWN'
+
+  if tones_chord in CHORDS:
+
+    if sorted(set(tones_chord) & set(WN)) == tones_chord:
+      ctype = 'WHITE'
+
+    elif sorted(set(tones_chord) & set(BN)) == tones_chord:
+      ctype = 'BLACK'
+
+    if len(tones_chord) > 1 and sorted(set(tones_chord) & set(MX)) == tones_chord:
+
+      if len(sorted(set(tones_chord) & set(WN))) == len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED GRAY'
+
+      elif len(sorted(set(tones_chord) & set(WN))) > len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED WHITE'
+
+      elif len(sorted(set(tones_chord) & set(WN))) < len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED BLACK'
+
+  if return_chord_type_index:
+    return CHORDS_TYPES.index(ctype)
+
+  else:
+    return ctype
+
+###################################################################################
+
+def tone_type(tone, 
+              return_tone_type_index=True
+              ):
+
+  """
+  Returns tone type
+  """
+
+  tone = tone % 12
+
+  if tone in BLACK_NOTES:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('BLACK')
+    else:
+      return "BLACK"
+
+  else:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('WHITE')
+    else:
+      return "WHITE"
+
+###################################################################################
+
+def find_closest_points(points, return_points=True):
+
+  """
+  Find closest 2D points
+  """
+
+  coords = np.array(points)
+
+  num_points = coords.shape[0]
+  closest_matches = np.zeros(num_points, dtype=int)
+  distances = np.zeros((num_points, num_points))
+
+  for i in range(num_points):
+      for j in range(num_points):
+          if i != j:
+              distances[i, j] = np.linalg.norm(coords[i] - coords[j])
+          else:
+              distances[i, j] = np.inf
+
+  closest_matches = np.argmin(distances, axis=1)
+  
+  if return_points:
+    points_matches = coords[closest_matches].tolist()
+    return points_matches
+  
+  else:
+    return closest_matches.tolist()
+
+################################################################################
+
+def reduce_dimensionality_tsne(list_of_valies,
+                                n_comp=2,
+                                n_iter=5000,
+                                verbose=True
+                              ):
+
+  """
+  Reduces the dimensionality of the values using t-SNE.
+  """
+
+  vals = np.array(list_of_valies)
+
+  tsne = TSNE(n_components=n_comp,
+              n_iter=n_iter,
+              verbose=verbose)
+
+  reduced_vals = tsne.fit_transform(vals)
+
+  return reduced_vals.tolist()
+
+################################################################################
+
+def compute_mst_edges(similarity_scores_list):
+
+  """
+  Computes the Minimum Spanning Tree (MST) edges based on the similarity scores.
+  """
+  
+  num_tokens = len(similarity_scores_list[0])
+
+  graph = nx.Graph()
+
+  for i in range(num_tokens):
+      for j in range(i + 1, num_tokens):
+          weight = 1 - similarity_scores_list[i][j]
+          graph.add_edge(i, j, weight=weight)
+
+  mst = nx.minimum_spanning_tree(graph)
+
+  mst_edges = list(mst.edges(data=False))
+
+  return mst_edges
+
+################################################################################
+
+def square_binary_matrix(binary_matrix, 
+                         matrix_size=128,
+                         interpolation_order=5,
+                         return_square_matrix_points=False
+                         ):
+
+  """
+  Reduces an arbitrary binary matrix to a square binary matrix
+  """
+
+  zoom_factors = (matrix_size / len(binary_matrix), 1)
+
+  resized_matrix = zoom(binary_matrix, zoom_factors, order=interpolation_order)
+
+  resized_matrix = (resized_matrix > 0.5).astype(int)
+
+  final_matrix = np.zeros((matrix_size, matrix_size), dtype=int)
+  final_matrix[:, :resized_matrix.shape[1]] = resized_matrix
+
+  points = np.column_stack(np.where(final_matrix == 1)).tolist()
+
+  if return_square_matrix_points:
+    return points
+
+  else:
+    return resized_matrix
+
+################################################################################
+
+def square_matrix_points_colors(square_matrix_points):
+
+  """
+  Returns colors for square matrix points
+  """
+
+  cmap = generate_colors(12)
+
+  chords = []
+  chords_dict = set()
+  counts = []
+
+  for k, v in groupby(square_matrix_points, key=lambda x: x[0]):
+    pgroup = [vv[1] for vv in v]
+    chord = sorted(set(pgroup))
+    tchord = sorted(set([p % 12 for p in chord]))
+    chords_dict.add(tuple(tchord))
+    chords.append(tuple(tchord))
+    counts.append(len(pgroup))
+
+  chords_dict = sorted(chords_dict)
+
+  colors = []
+
+  for i, c in enumerate(chords):
+    colors.extend([cmap[round(sum(c) / len(c))]] * counts[i])
+
+  return colors
+
+################################################################################
+
+def hsv_to_rgb(h, s, v):
+
+  if s == 0.0:
+      return v, v, v
+
+  i = int(h*6.0)
+  f = (h*6.0) - i
+  p = v*(1.0 - s)
+  q = v*(1.0 - s*f)
+  t = v*(1.0 - s*(1.0-f))
+  i = i%6
+  
+  return [(v, t, p), (q, v, p), (p, v, t), (p, q, v), (t, p, v), (v, p, q)][i]
+
+################################################################################
+
+def generate_colors(n):
+  return [hsv_to_rgb(i/n, 1, 1) for i in range(n)]
+
+################################################################################
+
+def add_arrays(a, b):
+  return [sum(pair) for pair in zip(a, b)]
+
+################################################################################
+
+def calculate_similarities(lists_of_values, metric='cosine'):
+  return metrics.pairwise_distances(lists_of_values, metric=metric).tolist()
+
+################################################################################
+
+def get_tokens_embeddings(x_transformer_model):
+  return x_transformer_model.net.token_emb.emb.weight.detach().cpu().tolist()
+
+################################################################################
+
+def minkowski_distance_matrix(X, p=3):
+
+  X = np.array(X)
+
+  n = X.shape[0]
+  dist_matrix = np.zeros((n, n))
+
+  for i in range(n):
+      for j in range(n):
+          dist_matrix[i, j] = np.sum(np.abs(X[i] - X[j])**p)**(1/p)
+
+  return dist_matrix.tolist()
+
+################################################################################
+
+def robust_normalize(values):
+
+  values = np.array(values)
+  q1 = np.percentile(values, 25)
+  q3 = np.percentile(values, 75)
+  iqr = q3 - q1
+
+  filtered_values = values[(values >= q1 - 1.5 * iqr) & (values <= q3 + 1.5 * iqr)]
+
+  min_val = np.min(filtered_values)
+  max_val = np.max(filtered_values)
+  normalized_values = (values - min_val) / (max_val - min_val)
+
+  normalized_values = np.clip(normalized_values, 0, 1)
+
+  return normalized_values.tolist()
+
+################################################################################
+
+def min_max_normalize(values):
+
+  scaler = MinMaxScaler()
+
+  return scaler.fit_transform(values).tolist()
+
+################################################################################
+
+def remove_points_outliers(points, z_score_threshold=3):
+
+  points = np.array(points)
+
+  z_scores = np.abs(zscore(points, axis=0))
+
+  return points[(z_scores < z_score_threshold).all(axis=1)].tolist()
+
+################################################################################
+
+def generate_labels(lists_of_values, 
+                    return_indices_labels=False
+                    ):
+
+  ordered_indices = list(range(len(lists_of_values)))
+  ordered_indices_labels = [str(i) for i in ordered_indices]
+  ordered_values_labels = [str(lists_of_values[i]) for i in ordered_indices]
+
+  if return_indices_labels:
+    return ordered_indices_labels
+  
+  else:
+    return ordered_values_labels
+
+################################################################################
+
+def reduce_dimensionality_pca(list_of_values, n_components=2):
+
+  """
+  Reduces the dimensionality of the values using PCA.
+  """
+
+  pca = PCA(n_components=n_components)
+  pca_data = pca.fit_transform(list_of_values)
+  
+  return pca_data.tolist()
+
+def reduce_dimensionality_simple(list_of_values, 
+                                 return_means=True,
+                                 return_std_devs=True,
+                                 return_medians=False,
+                                 return_vars=False
+                                 ):
+  
+  '''
+  Reduces dimensionality of the values in a simple way
+  '''
+
+  array = np.array(list_of_values)
+  results = []
+
+  if return_means:
+      means = np.mean(array, axis=1)
+      results.append(means)
+
+  if return_std_devs:
+      std_devs = np.std(array, axis=1)
+      results.append(std_devs)
+
+  if return_medians:
+      medians = np.median(array, axis=1)
+      results.append(medians)
+
+  if return_vars:
+      vars = np.var(array, axis=1)
+      results.append(vars)
+
+  merged_results = np.column_stack(results)
+  
+  return merged_results.tolist()
+
+################################################################################
+
+def reduce_dimensionality_2d_distance(list_of_values, p=5):
+
+  '''
+  Reduces the dimensionality of the values using 2d distance
+  '''
+
+  values = np.array(list_of_values)
+
+  dist_matrix = distance_matrix(values, values, p=p)
+
+  mst = minimum_spanning_tree(dist_matrix).toarray()
+
+  points = []
+
+  for i in range(len(values)):
+      for j in range(len(values)):
+          if mst[i, j] > 0:
+              points.append([i, j])
+
+  return points
+
+################################################################################
+
+def normalize_to_range(values, n):
+    
+  min_val = min(values)
+  max_val = max(values)
+  
+  range_val = max_val - min_val
+  
+  normalized_values = [((value - min_val) / range_val * 2 * n) - n for value in values]
+  
+  return normalized_values
+
+################################################################################
+
+def reduce_dimensionality_simple_pca(list_of_values, n_components=2):
+
+  '''
+  Reduces the dimensionality of the values using simple PCA
+  '''
+
+  reduced_values = []
+
+  for l in list_of_values:
+
+    norm_values = [round(v * len(l)) for v in normalize_to_range(l, (n_components+1) // 2)]
+
+    pca_values = Counter(norm_values).most_common()
+    pca_values = [vv[0] / len(l) for vv in pca_values]
+    pca_values = pca_values[:n_components]
+    pca_values = pca_values + [0] * (n_components - len(pca_values))
+
+    reduced_values.append(pca_values)
+
+  return reduced_values
+
+################################################################################
+
+def filter_and_replace_values(list_of_values, 
+                              threshold, 
+                              replace_value, 
+                              replace_above_threshold=False
+                              ):
+
+  array = np.array(list_of_values)
+
+  modified_array = np.copy(array)
+  
+  if replace_above_threshold:
+    modified_array[modified_array > threshold] = replace_value
+  
+  else:
+    modified_array[modified_array < threshold] = replace_value
+  
+  return modified_array.tolist()
+
+################################################################################
+
+def find_shortest_constellation_path(points, 
+                                     start_point_idx, 
+                                     end_point_idx,
+                                     p=5,
+                                     return_path_length=False,
+                                     return_path_points=False,
+                                     ):
+
+    """
+    Finds the shortest path between two points of the points constellation
+    """
+
+    points = np.array(points)
+
+    dist_matrix = distance_matrix(points, points, p=p)
+
+    mst = minimum_spanning_tree(dist_matrix).toarray()
+
+    G = nx.Graph()
+
+    for i in range(len(points)):
+        for j in range(len(points)):
+            if mst[i, j] > 0:
+                G.add_edge(i, j, weight=mst[i, j])
+
+    path = nx.shortest_path(G, 
+                            source=start_point_idx, 
+                            target=end_point_idx, 
+                            weight='weight'
+                            )
+    
+    path_length = nx.shortest_path_length(G, 
+                                          source=start_point_idx, 
+                                          target=end_point_idx, 
+                                          weight='weight')
+        
+    path_points = points[np.array(path)].tolist()
+
+
+    if return_path_points:
+      return path_points
+
+    if return_path_length:
+      return path_length
+
+    return path
+
+################################################################################
+# Core functions
+################################################################################
+
+def plot_ms_SONG(ms_song,
+                  preview_length_in_notes=0,
+                  block_lines_times_list = None,
+                  plot_title='ms Song',
+                  max_num_colors=129, 
+                  drums_color_num=128, 
+                  plot_size=(11,4), 
+                  note_height = 0.75,
+                  show_grid_lines=False,
+                  return_plt = False,
+                  timings_multiplier=1,
+                  save_plt='',
+                  save_only_plt_image=True,
+                  save_transparent=False
+                  ):
+
+  '''ms SONG plot'''
+
+  notes = [s for s in ms_song if s[0] == 'note']
+
+  if (len(max(notes, key=len)) != 7) and (len(min(notes, key=len)) != 7):
+    print('The song notes do not have patches information')
+    print('Ploease add patches to the notes in the song')
+
+  else:
+
+    start_times = [(s[1] * timings_multiplier) / 1000 for s in notes]
+    durations = [(s[2]  * timings_multiplier) / 1000 for s in notes]
+    pitches = [s[4] for s in notes]
+    patches = [s[6] for s in notes]
+
+    colors = generate_colors(max_num_colors)
+    colors[drums_color_num] = (1, 1, 1)
+
+    pbl = (notes[preview_length_in_notes][1] * timings_multiplier) / 1000
+
+    fig, ax = plt.subplots(figsize=plot_size)
+
+    for start, duration, pitch, patch in zip(start_times, durations, pitches, patches):
+        rect = plt.Rectangle((start, pitch), duration, note_height, facecolor=colors[patch])
+        ax.add_patch(rect)
+
+    ax.set_xlim([min(start_times), max(add_arrays(start_times, durations))])
+    ax.set_ylim([min(pitches)-1, max(pitches)+1])
+
+    ax.set_facecolor('black')
+    fig.patch.set_facecolor('white')
+
+    if preview_length_in_notes > 0:
+      ax.axvline(x=pbl, c='white')
+
+    if block_lines_times_list:
+      for bl in block_lines_times_list:
+        ax.axvline(x=bl, c='white')
+           
+    if show_grid_lines:
+      ax.grid(color='white')
+
+    plt.xlabel('Time (s)', c='black')
+    plt.ylabel('MIDI Pitch', c='black')
+
+    plt.title(plot_title)
+
+    if save_plt != '':
+      if save_only_plt_image:
+        plt.axis('off')
+        plt.title('')
+        plt.savefig(save_plt, 
+                    transparent=save_transparent, 
+                    bbox_inches='tight', 
+                    pad_inches=0, 
+                    facecolor='black'
+                    )
+        plt.close()
+      
+      else:
+        plt.savefig(save_plt)
+        plt.close()
+
+    if return_plt:
+      return fig
+
+    plt.show()
+    plt.close()
+
+################################################################################
+
+def plot_square_matrix_points(list_of_points,
+                              list_of_points_colors,
+                              plot_size=(7, 7),
+                              point_size = 10,
+                              show_grid_lines=False,
+                              plot_title = 'Square Matrix Points Plot',
+                              return_plt=False,
+                              save_plt='',
+                              save_only_plt_image=True,
+                              save_transparent=False
+                              ):
+
+  '''Square matrix points plot'''
+
+  fig, ax = plt.subplots(figsize=plot_size)
+
+  ax.set_facecolor('black')
+
+  if show_grid_lines:
+    ax.grid(color='white')
+
+  plt.xlabel('Time Step', c='black')
+  plt.ylabel('MIDI Pitch', c='black')
+
+  plt.title(plot_title)
+
+  plt.scatter([p[0] for p in list_of_points], 
+              [p[1] for p in list_of_points], 
+              c=list_of_points_colors, 
+              s=point_size
+              )
+
+  if save_plt != '':
+    if save_only_plt_image:
+      plt.axis('off')
+      plt.title('')
+      plt.savefig(save_plt, 
+                  transparent=save_transparent, 
+                  bbox_inches='tight', 
+                  pad_inches=0, 
+                  facecolor='black'
+                  )
+      plt.close()
+    
+    else:
+      plt.savefig(save_plt)
+      plt.close()
+
+  if return_plt:
+    return fig
+
+  plt.show()
+  plt.close()
+
+################################################################################
+
+def plot_cosine_similarities(lists_of_values,
+                             plot_size=(7, 7),
+                             save_plot=''
+                            ):
+
+  """
+  Cosine similarities plot
+  """
+
+  cos_sim = metrics.pairwise_distances(lists_of_values, metric='cosine')
+
+  plt.figure(figsize=plot_size)
+
+  plt.imshow(cos_sim, cmap="inferno", interpolation="nearest")
+
+  im_ratio = cos_sim.shape[0] / cos_sim.shape[1]
+
+  plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)
+
+  plt.xlabel("Index")
+  plt.ylabel("Index")
+
+  plt.tight_layout()
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+  plt.close()
+
+################################################################################
+
+def plot_points_with_mst_lines(points, 
+                               points_labels, 
+                               points_mst_edges,
+                               plot_size=(20, 20),
+                               labels_size=24,
+                               save_plot=''
+                               ):
+
+  """
+  Plots 2D points with labels and MST lines.
+  """
+
+  plt.figure(figsize=plot_size)
+
+  for i, label in enumerate(points_labels):
+      plt.scatter(points[i][0], points[i][1])
+      plt.annotate(label, (points[i][0], points[i][1]), fontsize=labels_size)
+
+  for edge in points_mst_edges:
+      i, j = edge
+      plt.plot([points[i][0], points[j][0]], [points[i][1], points[j][1]], 'k-', alpha=0.5)
+
+  plt.title('Points Map with MST Lines', fontsize=labels_size)
+  plt.xlabel('X-axis', fontsize=labels_size)
+  plt.ylabel('Y-axis', fontsize=labels_size)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+
+################################################################################
+
+def plot_points_constellation(points, 
+                              points_labels,
+                              p=5,                              
+                              plot_size=(15, 15),
+                              labels_size=12,
+                              show_grid=False,
+                              save_plot=''
+                              ):
+
+  """
+  Plots 2D points constellation
+  """
+
+  points = np.array(points)
+
+  dist_matrix = distance_matrix(points, points, p=p)
+
+  mst = minimum_spanning_tree(dist_matrix).toarray()
+
+  plt.figure(figsize=plot_size)
+
+  plt.scatter(points[:, 0], points[:, 1], color='blue')
+
+  for i, label in enumerate(points_labels):
+      plt.annotate(label, (points[i, 0], points[i, 1]), 
+                   textcoords="offset points", 
+                   xytext=(0, 10), 
+                   ha='center',
+                   fontsize=labels_size
+                   )
+
+  for i in range(len(points)):
+      for j in range(len(points)):
+          if mst[i, j] > 0:
+              plt.plot([points[i, 0], points[j, 0]], [points[i, 1], points[j, 1]], 'k--')
+
+  plt.xlabel('X-axis', fontsize=labels_size)
+  plt.ylabel('Y-axis', fontsize=labels_size)
+  plt.title('2D Coordinates with Minimum Spanning Tree', fontsize=labels_size)
+
+  plt.grid(show_grid)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+
+################################################################################
+
+def binary_matrix_to_images(matrix, 
+                            step,
+                            overlap,
+                            output_folder='./Dataset/', 
+                            output_img_prefix='image', 
+                            output_img_ext='.png',
+                            save_to_array=False,
+                            verbose=True
+                            ):
+
+    if not save_to_array:
+
+      if verbose:
+        print('=' * 70)
+        print('Checking output folder dir...')
+
+      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
+
+      if verbose:
+        print('Done!')
+
+    if verbose:
+      print('=' * 70)
+      print('Writing images...')
+
+    matrix = np.array(matrix, dtype=np.uint8)
+    
+    image_array = []
+    
+    for i in range(0, max(1, matrix.shape[0]), overlap):
+       
+        submatrix = matrix[i:i+step, :]
+
+        if submatrix.shape[0] < 128:
+          zeros_array = np.zeros((128-submatrix.shape[0], 128))
+          submatrix = np.vstack((submatrix, zeros_array))
+
+        img = Image.fromarray(submatrix * 255).convert('1')
+        
+        if save_to_array:
+          image_array.append(np.array(img))
+
+        else:
+          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
+  
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
+      print('=' * 70)
+
+    if save_to_array:
+        return np.array(image_array).tolist()
+
+################################################################################
+
+def images_to_binary_matrix(list_of_images):
+
+    image_array = np.array(list_of_images)
+   
+    original_matrix = []
+    
+    for img in image_array:
+
+        submatrix = np.array(img)
+        original_matrix.extend(submatrix.tolist())
+    
+    return original_matrix
+
+################################################################################
+
+def square_image_matrix(image_matrix,
+                        matrix_size=128,
+                        num_pca_components=5,
+                        filter_out_zero_rows=False,
+                        return_square_matrix_points=False
+                        ):
+
+  """
+  Reduces an arbitrary image matrix to a square image matrix
+  """
+
+  matrix = np.array(image_matrix)
+
+  if filter_out_zero_rows:
+    matrix = matrix[~np.all(matrix == 0, axis=1)]
+
+  target_rows = matrix_size
+
+  rows_per_group = matrix.shape[0] // target_rows
+
+  compressed_matrix = np.zeros((target_rows, matrix.shape[1]), dtype=np.int32)
+
+  for i in range(target_rows):
+      start_row = i * rows_per_group
+      end_row = (i + 1) * rows_per_group
+      group = matrix[start_row:end_row, :]
+      
+      pca = PCA(n_components=num_pca_components)
+      pca.fit(group)
+      
+      principal_component = np.mean(pca.components_, axis=0)
+      contributions = np.dot(group, principal_component)
+      selected_row_index = np.argmax(contributions)
+      
+      compressed_matrix[i, :] = group[selected_row_index, :]
+
+  if return_square_matrix_points:
+    filtered_matrix = compressed_matrix[~np.all(compressed_matrix == 0, axis=1)]
+
+    row_indexes, col_indexes = np.where(filtered_matrix != 0)
+    points = np.column_stack((row_indexes, filtered_matrix[row_indexes, col_indexes])).tolist()
+
+    return points
+
+  else:
+    return compressed_matrix.tolist()
+
+################################################################################
+
+def image_matrix_to_images(image_matrix,
+                           step,
+                           overlap,
+                           num_img_channels=3,
+                           output_folder='./Dataset/',
+                           output_img_prefix='image',
+                           output_img_ext='.png',
+                           save_to_array=False,
+                           verbose=True
+                           ):
+
+    if num_img_channels > 1:
+      n_mat_channels = 3
+
+    else:
+      n_mat_channels = 1
+
+    if not save_to_array:
+
+      if verbose:
+        print('=' * 70)
+        print('Checking output folder dir...')
+
+      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
+
+      if verbose:
+        print('Done!')
+
+    if verbose:
+      print('=' * 70)
+      print('Writing images...')
+
+    matrix = np.array(image_matrix)
+
+    image_array = []
+
+    for i in range(0, max(1, matrix.shape[0]), overlap):
+
+        submatrix = matrix[i:i+step, :]
+
+        if submatrix.shape[0] < 128:
+          zeros_array = np.zeros((128-submatrix.shape[0], 128))
+          submatrix = np.vstack((submatrix, zeros_array))
+
+        if n_mat_channels == 3:
+
+          r = (submatrix // (256*256)) % 256
+          g = (submatrix // 256) % 256
+          b = submatrix % 256
+
+          rgb_image = np.stack((r, g, b), axis=-1).astype(np.uint8)
+          img = Image.fromarray(rgb_image, 'RGB')
+
+        else:
+          grayscale_image = submatrix.astype(np.uint8)
+          img = Image.fromarray(grayscale_image, 'L')
+
+        if save_to_array:
+          image_array.append(np.array(img))
+
+        else:
+          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
+
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
+      print('=' * 70)
+
+    if save_to_array:
+        return np.array(image_array).tolist()
+
+################################################################################
+
+def images_to_image_matrix(list_of_images,
+                           num_img_channels=3
+                           ):
+
+    if num_img_channels > 1:
+      n_mat_channels = 3
+
+    else:
+      n_mat_channels = 1
+
+    image_array = np.array(list_of_images)
+
+    original_matrix = []
+
+    for img in image_array:
+
+      if num_img_channels == 3:
+
+        rgb_array = np.array(img)
+
+        matrix = (rgb_array[..., 0].astype(np.int64) * 256*256 +
+                  rgb_array[..., 1].astype(np.int64) * 256 +
+                  rgb_array[..., 2].astype(np.int64))
+
+      else:
+        matrix = np.array(img)
+
+      original_matrix.extend(matrix)
+
+    return original_matrix
+
+################################################################################
+
+def square_matrix_to_RGB_matrix(square_matrix):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  r = (sq_matrix // (256 ** 2)) % 256
+  g = (sq_matrix // 256) % 256
+  b = sq_matrix % 256
+
+  rgb_array = np.stack((r, g, b), axis=-1)
+
+  return rgb_array.tolist()
+
+################################################################################
+
+def upsample_square_matrix(square_matrix, upsampling_factor=4):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  scaling_array = np.ones((upsampling_factor, upsampling_factor))
+  scaled_array = np.kron(sq_matrix, scaling_array)
+  scaled_array = scaled_array.astype('int')
+
+  return scaled_array.tolist()
+
+################################################################################
+
+def downsample_square_matrix(square_matrix, downsampling_factor=4):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  dmatrix = sq_matrix[::downsampling_factor, ::downsampling_factor]
+  dmatrix = dmatrix.astype('int')
+
+  return dmatrix.tolist()
+
+################################################################################
+
+def plot_parsons_code(parsons_code, 
+                      start_pitch=60, 
+                      return_plot_dict=False, 
+                      return_plot_string=False,
+                      plot_size=(10, 10),
+                      labels_size=16,
+                      save_plot=''
+                      ):
+  
+  '''
+  Plot parsons code string
+  '''
+
+  if parsons_code[0] != "*":
+      return None
+
+  contour_dict = {}
+  pitch = 0
+  index = 0
+
+  maxp = 0
+  minp = 0
+
+  contour_dict[(pitch, index)] = "*"
+
+  for point in parsons_code:
+      if point == "R":
+          index += 1
+          contour_dict[(pitch, index)] = "-"
+
+          index += 1
+          contour_dict[(pitch, index)] = "*"
+          
+      elif point == "U":
+          index += 1
+          pitch -= 1
+          contour_dict[(pitch, index)] = "/"
+
+          index += 1
+          pitch -= 1
+          contour_dict[(pitch, index)] = "*"
+
+          if pitch < maxp:
+              maxp = pitch
+
+      elif point == "D":
+          index += 1
+          pitch += 1
+          contour_dict[(pitch, index)] = "\\"
+
+          index += 1
+          pitch += 1
+          contour_dict[(pitch, index)] = "*"
+
+          if pitch > minp:
+              minp = pitch
+
+  if return_plot_dict:
+    return contour_dict
+  
+  if return_plot_string:
+
+    plot_string = ''
+
+    for pitch in range(maxp, minp+1):
+        line = [" " for _ in range(index + 1)]
+        for pos in range(index + 1):
+            if (pitch, pos) in contour_dict:
+                line[pos] = contour_dict[(pitch, pos)]
+
+        plot_string = "".join(line)
+
+    return plot_string
+
+  labels = []
+  pitches = []
+  positions = []
+  cur_pitch = start_pitch
+  pitch_idx = 0
+
+  for k, v in contour_dict.items():
+
+    if v != '*':
+
+      pitches.append(cur_pitch)
+      positions.append(pitch_idx)
+
+      if v == '/':
+        cur_pitch += 1
+        labels.append('U')
+      
+      elif v == '\\':
+        cur_pitch -= 1
+        labels.append('D')
+
+      elif v == '-':
+        labels.append('R')
+
+      pitch_idx += 1
+
+  plt.figure(figsize=plot_size)
+
+  
+  plt.plot(pitches)
+
+  for i, point in enumerate(zip(positions, pitches)):
+    plt.annotate(labels[i], point, fontsize=labels_size)
+  
+
+  plt.title('Parsons Code with Labels', fontsize=labels_size)
+  plt.xlabel('Position', fontsize=labels_size)
+  plt.ylabel('Pitch', fontsize=labels_size)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+  
+################################################################################
+# [WIP] Future dev functions
+################################################################################
+
+'''
+import umap
+
+def reduce_dimensionality_umap(list_of_values,
+                               n_comp=2,
+                               n_neighbors=15,
+                               ):
+
+  """
+  Reduces the dimensionality of the values using UMAP.
+  """
+
+  vals = np.array(list_of_values)
+
+  umap_reducer = umap.UMAP(n_components=n_comp,
+                           n_neighbors=n_neighbors,
+                           n_epochs=5000,
+                           verbose=True
+                           )
+
+  reduced_vals = umap_reducer.fit_transform(vals)
+
+  return reduced_vals.tolist()
+'''
+
+################################################################################
+
+'''
+import alphashape
+from shapely.geometry import Point
+from matplotlib.tri import Triangulation, LinearTriInterpolator
+from scipy.stats import zscore
+
+#===============================================================================
+
+coordinates = points
+
+dist_matrix = minkowski_distance_matrix(coordinates, p=3)  # You can change the value of p as needed
+
+# Centering matrix
+n = dist_matrix.shape[0]
+H = np.eye(n) - np.ones((n, n)) / n
+
+# Apply double centering
+B = -0.5 * H @ dist_matrix**2 @ H
+
+# Eigen decomposition
+eigvals, eigvecs = np.linalg.eigh(B)
+
+# Sort eigenvalues and eigenvectors
+idx = np.argsort(eigvals)[::-1]
+eigvals = eigvals[idx]
+eigvecs = eigvecs[:, idx]
+
+# Select the top 2 eigenvectors
+X_transformed = eigvecs[:, :2] * np.sqrt(eigvals[:2])
+
+#===============================================================================
+
+src_points = X_transformed
+src_values = np.array([[p[1]] for p in points]) #np.random.rand(X_transformed.shape[0])
+
+#===============================================================================
+
+# Normalize the points to the range [0, 1]
+scaler = MinMaxScaler()
+points_normalized = scaler.fit_transform(src_points)
+
+values_normalized = custom_normalize(src_values)
+
+# Remove outliers based on z-score
+z_scores = np.abs(zscore(points_normalized, axis=0))
+filtered_points = points_normalized[(z_scores < 3).all(axis=1)]
+filtered_values = values_normalized[(z_scores < 3).all(axis=1)]
+
+# Compute the concave hull (alpha shape)
+alpha = 8  # Adjust alpha as needed
+hull = alphashape.alphashape(filtered_points, alpha)
+
+# Create a triangulation
+tri = Triangulation(filtered_points[:, 0], filtered_points[:, 1])
+
+# Interpolate the values on the triangulation
+interpolator = LinearTriInterpolator(tri, filtered_values[:, 0])
+xi, yi = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100))
+zi = interpolator(xi, yi)
+
+# Mask out points outside the concave hull
+mask = np.array([hull.contains(Point(x, y)) for x, y in zip(xi.flatten(), yi.flatten())])
+zi = np.ma.array(zi, mask=~mask.reshape(zi.shape))
+
+# Plot the filled contour based on the interpolated values
+plt.contourf(xi, yi, zi, levels=50, cmap='viridis')
+
+# Plot the original points
+#plt.scatter(filtered_points[:, 0], filtered_points[:, 1], c=filtered_values, edgecolors='k')
+
+plt.title('Filled Contour Plot with Original Values')
+plt.xlabel('X-axis')
+plt.ylabel('Y-axis')
+plt.colorbar(label='Value')
+plt.show()
+'''
+
+################################################################################
+#
+# This is the end of TPLOTS Python modules
+#
+################################################################################

tegridy-tools-main.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86cec8475a0e0cd4ec7ddaf3dee37b892611afb6d3f17dac7f3411f64ae79960
+size 108223519

x_transformer_1_23_2.py

@@ -0,0 +1,2481 @@
+#===================================================================================================================
+#
+# X Trasformer Module
+#
+# Partial x-transformers code With useful modifications
+#
+# Version 1.0
+#
+# Original source code courtesy of lucidrains
+# https://github.com/lucidrains/x-transformers
+#
+# Original source code retrieved on 10/10/2023
+#
+# Project Los Angeles
+# Tegridy Code 2023
+
+#===================================================================================================================
+
+# Critical dependencies
+#
+# !pip install torch
+# !pip install einops
+
+#===================================================================================================================
+
+from functools import partial
+from typing import Optional, Tuple
+
+import os
+os.environ['USE_FLASH_ATTENTION'] = '1'
+
+import torch
+from torch import nn, einsum, Tensor
+import torch.nn.functional as F
+
+# Flash attention
+from torch.nn.attention import SDPBackend, sdpa_kernel
+torch.backends.cuda.enable_flash_sdp(True)
+
+from collections import namedtuple
+from functools import wraps
+from packaging import version
+from dataclasses import dataclass
+
+from einops import rearrange, repeat
+
+# constants
+
+EfficientAttentionConfig = namedtuple('EfficientAttentionConfig', ['enable_flash', 'enable_math', 'enable_mem_efficient'])
+
+@dataclass
+class Intermediates:
+    qk_similarities: Optional[Tensor] = None
+    pre_softmax_attn: Optional[Tensor] = None
+    post_softmax_attn: Optional[Tensor] = None
+    cached_kv: Optional[Tuple[Tensor, Tensor]] = None
+
+    def to_tuple(self):
+        return (self.qk_similarities, self.pre_softmax_attn, self.post_softmax_attn)
+
+# helpers
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    return val if exists(val) else d
+
+def compact(arr):
+    return [*filter(exists, arr)]
+
+def once(fn):
+    called = False
+    @wraps(fn)
+    def inner(x):
+        nonlocal called
+        if called:
+            return
+        called = True
+        return fn(x)
+    return inner
+
+print_once = once(print)
+
+# functions for creating causal mask
+# need a special one for onnx cpu (no support for .triu)
+
+def create_causal_mask(i, j, device):
+    return torch.ones((i, j), device = device, dtype = torch.bool).triu(j - i + 1)
+
+def onnx_create_causal_mask(i, j, device):
+    r = torch.arange(i, device = device)
+    causal_mask = rearrange(r, 'i -> i 1') < rearrange(r, 'j -> 1 j')
+    causal_mask = F.pad(causal_mask, (j - i, 0), value = False)
+    return causal_mask
+
+# main class
+
+class Attend(nn.Module):
+    def __init__(
+        self,
+        *,
+        dropout = 0.,
+        causal = False,
+        heads = None,
+        talking_heads = False,
+        sparse_topk = None,
+        scale = None,
+        qk_norm = False,
+        flash = False,
+        add_zero_kv = False,
+        onnxable = False
+    ):
+        super().__init__()
+        self.scale = scale
+        self.qk_norm = qk_norm
+
+        self.causal = causal
+        self.create_causal_mask = onnx_create_causal_mask if onnxable else create_causal_mask
+
+        self.attn_fn = partial(F.softmax, dtype = torch.float32) if not qk_norm else F.softmax
+
+        self.dropout = dropout
+        self.attn_dropout = nn.Dropout(dropout)
+
+        # talking heads
+
+        assert not (flash and talking_heads), 'talking heads not compatible with flash attention'
+
+        self.talking_heads = talking_heads
+        if talking_heads:
+            self.pre_softmax_talking_heads = nn.Conv2d(heads, heads, 1, bias = False)
+            self.post_softmax_talking_heads = nn.Conv2d(heads, heads, 1, bias = False)
+
+        # sparse topk
+
+        assert not (flash and sparse_topk), 'sparse topk not compatible with flash attention'
+        self.sparse_topk = sparse_topk
+
+        # add a key / value token composed of zeros
+        # in case this helps controlling outliers, proposed by https://www.evanmiller.org/attention-is-off-by-one.html
+
+        self.add_zero_kv = add_zero_kv
+
+        # flash attention
+
+        self.flash = flash
+        assert not (flash and version.parse(torch.__version__) < version.parse('2.0.0')), 'in order to use flash attention, you must be using pytorch 2.0 or above'
+
+        # determine efficient attention configs for cuda and cpu
+
+        self.cpu_config = EfficientAttentionConfig(True, True, True)
+        self.cuda_config = None
+
+        if not torch.cuda.is_available() or not flash:
+            return
+
+        device_properties = torch.cuda.get_device_properties(torch.device('cuda'))
+
+        major, minor = device_properties.major, device_properties.minor
+
+        if (major, minor) == (8, 0):
+            print_once('A100 GPU detected, using flash attention if input tensor is on cuda')
+            self.cuda_config = EfficientAttentionConfig(True, False, False)
+        elif (major, minor) == (9, 0):
+            print_once('H100 GPU detected, using flash attention')
+            self.cuda_config = EfficientAttentionConfig(True, False, False)
+        else:
+            print_once('Non-A100 GPU detected, using math or mem efficient attention if input tensor is on cuda')
+            self.cuda_config = EfficientAttentionConfig(False, True, True)
+
+    def flash_attn(
+        self,
+        q, k, v,
+        mask = None,
+        attn_bias = None
+    ):
+        batch, heads, q_len, _, k_len, is_cuda, device = *q.shape, k.shape[-2], q.is_cuda, q.device
+
+        # Recommended for multi-query single-key-value attention by Tri Dao
+        # kv shape torch.Size([1, 512, 64]) -> torch.Size([1, 8, 512, 64])
+
+        if k.ndim == 3:
+            k = rearrange(k, 'b ... -> b 1 ...').expand_as(q)
+
+        if v.ndim == 3:
+            v = rearrange(v, 'b ... -> b 1 ...').expand_as(q)
+
+        # handle scale - by default they scale by dim_head ** -0.5, but need to take care if using cosine sim attention
+
+        if self.qk_norm:
+            default_scale = q.shape[-1] ** -0.5
+            q = q * (self.scale / default_scale)
+
+        # Check if mask exists and expand to compatible shape
+        # The mask is B L, so it would have to be expanded to B H N L
+
+        causal = self.causal
+
+        # in the case of kv caching with one token (q_len == 1), just turn off causal masking
+        # in speculative decoding, this may go up to 5-6, so right aligned causal mask will be needed there
+
+        if q_len == 1 and causal:
+            causal = False
+
+        # expand key padding mask
+
+        if exists(mask):
+            assert mask.ndim == 4
+            mask = mask.expand(batch, heads, q_len, k_len)
+
+        # handle kv cache - this should be bypassable in updated flash attention 2
+
+        if k_len > q_len and causal:
+            causal_mask = self.create_causal_mask(q_len, k_len, device = device)
+            if not exists(mask):
+                mask = ~causal_mask
+            else:
+                mask = mask & ~causal_mask
+            causal = False
+
+        # manually handle causal mask, if another mask was given
+
+        row_is_entirely_masked = None
+
+        if exists(mask) and causal:
+            causal_mask = self.create_causal_mask(q_len, k_len, device = device)
+            mask = mask & ~causal_mask
+
+            # protect against an entire row being masked out
+
+            row_is_entirely_masked = ~mask.any(dim = -1)
+            mask[..., 0] = mask[..., 0] | row_is_entirely_masked
+
+            causal = False
+
+        # handle alibi positional bias
+        # convert from bool to float
+
+        if exists(attn_bias):
+            attn_bias = rearrange(attn_bias, 'h i j -> 1 h i j').expand(batch, heads, -1, -1)
+
+            # if mask given, the mask would already contain the causal mask from above logic
+            # otherwise, if no mask given but still causal, mask out alibi positional bias to a large negative number
+
+            mask_value = -torch.finfo(q.dtype).max
+
+            if exists(mask):
+                attn_bias = attn_bias.masked_fill(~mask, mask_value // 2)
+            elif causal:
+                causal_mask = self.create_causal_mask(q_len, k_len, device = device)
+                attn_bias = attn_bias.masked_fill(causal_mask, mask_value // 2)
+                causal = False
+
+            # scaled_dot_product_attention handles attn_mask either as bool or additive bias
+            # make it an additive bias here
+
+            mask = attn_bias
+
+        # Check if there is a compatible device for flash attention
+
+        config = self.cuda_config if is_cuda else self.cpu_config
+
+        # pytorch 2.0 flash attn: q, k, v, mask, dropout, causal, softmax_scale
+        
+        # Legacy code...
+        # with torch.backends.cuda.sdp_kernel(enable_math=True, enable_mem_efficient=True):
+        # with sdpa_kernel([SDPBackend.MATH, SDPBackend.EFFICIENT_ATTENTION]):
+
+        # PyTorch 2.3-2.4 SDPA backend code...
+        with sdpa_kernel([SDPBackend.MATH, SDPBackend.EFFICIENT_ATTENTION, SDPBackend.FLASH_ATTENTION, SDPBackend.CUDNN_ATTENTION]):
+        # with sdpa_kernel([SDPBackend.FLASH_ATTENTION]):
+
+        # New PyTorch 2.5 SDPA backend code:
+        # with sdpa_kernel(SDPBackend.CUDNN_ATTENTION):
+            
+            out = F.scaled_dot_product_attention(
+                q, k, v,
+                attn_mask = mask,
+                dropout_p = self.dropout if self.training else 0., 
+                is_causal = causal
+            )
+
+        # for a row that is entirely masked out, should zero out the output of that row token
+
+        if exists(row_is_entirely_masked):
+            out = out.masked_fill(row_is_entirely_masked[..., None], 0.)
+
+        return out, Intermediates()
+
+    def forward(
+        self,
+        q, k, v,
+        mask = None,
+        attn_bias = None,
+        prev_attn = None
+    ):
+        """
+        einstein notation
+        b - batch
+        h - heads
+        n, i, j - sequence length (base sequence length, source, target)
+        d - feature dimension
+        """
+
+        n, heads, kv_heads, device = q.shape[-2], q.shape[1], k.shape[1], q.device
+
+        scale = default(self.scale, q.shape[-1] ** -0.5)
+
+        causal = self.causal
+
+        # handle kv cached decoding
+
+        if n == 1 and causal:
+            causal = False
+
+        # handle grouped multi-query attention
+
+        if kv_heads == 1:
+            k, v = map(lambda t: rearrange(t, 'b 1 n d -> b n d'), (k, v))
+        elif kv_heads < heads:
+            k, v = map(lambda t: repeat(t, 'b kvh n d -> b (r kvh) n d', r = heads // kv_heads), (k, v))
+
+        # handle zero kv, as means for allowing network to attend to nothing
+
+        if self.add_zero_kv:
+            k, v = map(lambda t: F.pad(t, (0, 0, 1, 0), value = 0.), (k, v))
+
+            if exists(mask):
+                mask = F.pad(mask, (1, 0), value = True)
+
+            if exists(attn_bias):
+                attn_bias = F.pad(attn_bias, (1, 0), value = 0.)
+
+        if self.flash:
+            assert not exists(prev_attn), 'residual attention not compatible with flash attention'
+            return self.flash_attn(q, k, v, mask = mask, attn_bias = attn_bias)
+
+        kv_einsum_eq = 'b j d' if k.ndim == 3 else 'b h j d'
+
+        dots = einsum(f'b h i d, {kv_einsum_eq} -> b h i j', q, k) * scale
+
+        if exists(prev_attn):
+            dots = dots + prev_attn
+
+        qk_similarities = dots.clone()
+
+        if self.talking_heads:
+            dots = self.pre_softmax_talking_heads(dots)
+
+        if exists(attn_bias):
+            dots = dots + attn_bias
+
+        i, j, dtype = *dots.shape[-2:], dots.dtype
+
+        mask_value = -torch.finfo(dots.dtype).max
+
+        if exists(self.sparse_topk) and self.sparse_topk < j:
+            top_values, _ = dots.topk(self.sparse_topk, dim = -1)
+            sparse_topk_mask = dots < top_values[..., -1:]
+            mask = (mask & sparse_topk_mask) if exists(mask) else sparse_topk_mask
+
+        if exists(mask):
+            dots = dots.masked_fill(~mask, mask_value)
+
+        if causal:
+            causal_mask = self.create_causal_mask(i, j, device = device)
+            dots = dots.masked_fill(causal_mask, mask_value)
+
+        pre_softmax_attn = dots.clone()
+
+        attn = self.attn_fn(dots, dim = -1)
+        attn = attn.type(dtype)
+
+        post_softmax_attn = attn.clone()
+
+        attn = self.attn_dropout(attn)
+
+        if self.talking_heads:
+            attn = self.post_softmax_talking_heads(attn)
+
+        out = einsum(f'b h i j, {kv_einsum_eq} -> b h i d', attn, v)
+
+        intermediates = Intermediates(
+            qk_similarities = qk_similarities,
+            pre_softmax_attn = pre_softmax_attn,
+            post_softmax_attn = post_softmax_attn
+        )
+
+        return out, intermediates
+
+#===================================================================================================================
+
+from math import ceil, log
+from typing import Optional, Union, Tuple, Callable
+
+import torch
+from torch import nn, Tensor
+from torch.nn import Module
+import torch.nn.functional as F
+
+from einops import rearrange, pack, unpack
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    return val if exists(val) else d
+
+def identity(t, *args, **kwargs):
+    return t
+
+def cast_tuple(t, length = 1):
+    return t if isinstance(t, tuple) else (t,) * length
+
+def eval_decorator(fn):
+    def inner(self, *args, **kwargs):
+        was_training = self.training
+        self.eval()
+        out = fn(self, *args, **kwargs)
+        self.train(was_training)
+        return out
+    return inner
+
+# for variable lengthed prefixes
+
+def align_right(t, lens, pad_id = 0):
+    batch, seq_len, device, dtype = *t.shape, t.device, t.dtype
+
+    assert lens.ndim == 1 and lens.shape[0] == batch
+    assert lens.amax() <= seq_len
+
+    pad_lens = seq_len - lens
+    max_pad_len = pad_lens.amax()
+
+    batch_arange = torch.arange(batch, device = device, dtype = torch.long)[..., None]
+    prompt_len_arange = torch.arange(seq_len, device = device, dtype = torch.long)
+
+    t = F.pad(t, (max_pad_len, 0), value = 0)
+    offset = max_pad_len - pad_lens
+
+    aligned = t[batch_arange, prompt_len_arange + offset[..., None]]
+    return aligned
+
+# nucleus
+
+def top_p(logits, thres = 0.9):
+    sorted_logits, sorted_indices = torch.sort(logits, descending = True)
+    cum_probs = torch.cumsum(F.softmax(sorted_logits, dim = -1), dim = -1)
+
+    sorted_indices_to_remove = cum_probs > thres
+    sorted_indices_to_remove = F.pad(sorted_indices_to_remove, (1, -1), value = False)
+
+    sorted_logits[sorted_indices_to_remove] = float('-inf')
+    return sorted_logits.scatter(1, sorted_indices, sorted_logits)
+
+# topk
+
+def top_k(logits, frac_num_tokens = 0.1, k = None):
+    num_tokens = logits.shape[-1]
+
+    k = default(k, ceil(frac_num_tokens * num_tokens))
+    k = min(k, num_tokens)
+
+    val, ind = torch.topk(logits, k)
+    probs = torch.full_like(logits, float('-inf'))
+    probs.scatter_(1, ind, val)
+    return probs
+
+# top_a
+
+def top_a(logits, min_p_pow = 2.0, min_p_ratio = 0.02):
+    probs = F.softmax(logits, dim = -1)
+    max_probs = torch.amax(probs, dim = -1, keepdim = True)
+    limit = torch.pow(max_probs, min_p_pow) * min_p_ratio
+    return torch.where(probs < limit, float('-inf'), logits)
+
+# contrastive decoding function
+
+def contrastive_decode_fn(
+    expert_logits,
+    amateur_logits,
+    alpha = 0.1,
+    beta = 0.5
+):
+    """
+    Appendix A Algorithm 2
+    https://arxiv.org/abs/2309.09117
+    """
+
+    cutoff = log(alpha) + expert_logits.amax(dim = -1, keepdim = True)
+    diffs = (1 + beta) * expert_logits - beta * amateur_logits
+    contrastive_decode_logits = diffs.masked_fill(expert_logits < cutoff, -torch.finfo(expert_logits.dtype).max)
+    return contrastive_decode_logits
+
+# autoregressive wrapper class
+
+class AutoregressiveWrapper(Module):
+    def __init__(
+        self,
+        net,
+        ignore_index = -100,
+        pad_value = 0,
+        mask_prob = 0.,
+        add_attn_z_loss = False,
+        return_cache=False
+    ):
+        super().__init__()
+        self.pad_value = pad_value
+        self.ignore_index = ignore_index
+
+        self.net = net
+        self.max_seq_len = net.max_seq_len
+
+        # paper shows masking (MLM) in conjunction with autoregressive decoder-only training leads to big improvements https://arxiv.org/abs/2210.13432
+        assert mask_prob < 1.
+        self.mask_prob = mask_prob
+
+        # whether to add router z-loss
+        self.add_attn_z_loss = add_attn_z_loss
+        self.return_cache = return_cache
+
+    @torch.inference_mode()
+    @eval_decorator
+    def generate(
+        self,
+        prompts,
+        seq_len,
+        eos_token = None,
+        temperature = 1.,
+        prompt_lens: Optional[Tensor] = None,
+        filter_logits_fn: Callable = top_k,
+        restrict_to_max_seq_len = True,
+        amateur_model: Optional[Union[Module, Tuple[Module]]] = None,
+        filter_kwargs: dict = dict(),
+        contrastive_decode_kwargs: Union[dict, Tuple[dict]] = dict(
+            beta = 0.5,
+            alpha = 0.1
+        ),
+        cache_kv = True,
+        verbose=True,
+        return_prime=False,
+        **kwargs
+    ):
+        max_seq_len, device = self.max_seq_len, prompts.device
+
+        prompts, ps = pack([prompts], '* n')
+
+        b, t = prompts.shape
+
+        # handle variable lengthed prompts (prefixes)
+
+        seq_start_pos = None
+        if exists(prompt_lens):
+            prompts = align_right(prompts, prompt_lens, pad_id = self.pad_value)
+            seq_start_pos = t - prompt_lens
+
+        # output from which sampled tokens appended to
+
+        out = prompts
+
+        if verbose:
+          print("Generating sequence of max length:", seq_len)
+
+        # kv caches
+
+        cache = None
+
+        # if doing contrastive decoding, turn off filter automatically
+
+        if exists(amateur_model):
+            amateur_model = cast_tuple(amateur_model)
+            contrastive_decode_kwargs = cast_tuple(contrastive_decode_kwargs)
+
+            assert len(amateur_model) == len(contrastive_decode_kwargs)
+
+            amateur_caches = [None] * len(amateur_model)
+            filter_logits_fn = identity
+
+            for i, module in enumerate(amateur_model):
+                if isinstance(module, AutoregressiveWrapper):
+                    amateur_model[i] = module.net
+
+                module.eval()
+
+        # sampling up to seq_len
+
+        for sl in range(seq_len):
+
+            if restrict_to_max_seq_len:
+                x = out[:, -max_seq_len:]
+
+                if exists(cache):
+                    for inter in cache.attn_intermediates:
+                        inter.cached_kv = [t[..., -(max_seq_len - 1):, :] for t in inter.cached_kv]
+
+            logits, new_cache = self.net(
+                x,
+                return_intermediates = True,
+                cache = cache,
+                seq_start_pos = seq_start_pos,
+                **kwargs
+            )
+
+            if cache_kv and self.net.can_cache_kv:
+                cache = new_cache
+
+            logits = logits[:, -1]
+
+            # handle contrastive decoding, Li et al.
+            # https://arxiv.org/abs/2210.15097
+
+            if exists(amateur_model):
+                for i, (amateur, amateur_cache, amateur_contrastive_decode_kwargs) in enumerate(zip(amateur_model, amateur_caches, contrastive_decode_kwargs)):
+                    amateur_logits, next_amateur_cache = amateur(
+                        x,
+                        return_intermediates = True,
+                        cache = amateur_cache,
+                        seq_start_pos = seq_start_pos,
+                        **kwargs
+                    )
+
+                    amateur_logits = amateur_logits[:, -1]
+
+                    assert amateur_logits.shape == logits.shape, 'logits dimension are not the same between amateur and expert model'
+                    logits = contrastive_decode_fn(logits, amateur_logits, **amateur_contrastive_decode_kwargs)
+
+                    if cache_kv and amateur.can_cache_kv:
+                        amateur_caches[i] = next_amateur_cache
+
+            # filter by top_k, top_p (nucleus), top_a, or custom
+
+            filtered_logits = filter_logits_fn(logits, **filter_kwargs)
+
+            probs = F.softmax(filtered_logits / temperature, dim=-1)
+
+            sample = torch.multinomial(probs, 1)
+
+            out = torch.cat((out, sample), dim=-1)
+
+            if verbose:
+              if sl % 32 == 0:
+                print(sl, '/', seq_len)
+
+            if exists(eos_token):
+                is_eos_tokens = (out == eos_token)
+
+                if is_eos_tokens.any(dim = -1).all():
+                    # mask out everything after the eos tokens
+                    shifted_is_eos_tokens = F.pad(is_eos_tokens, (1, -1))
+                    mask = shifted_is_eos_tokens.float().cumsum(dim = -1) >= 1
+                    out = out.masked_fill(mask, self.pad_value)
+
+                    if verbose: 
+                      print('Model called the end of sequence at:', sl, '/', seq_len)
+
+                    break
+
+        if return_prime:
+          return out[:, :]
+        
+        else:
+          return out[:, t:]
+
+        # out, = unpack(out, ps, '* n')
+
+        # return out
+
+    def compute_accuracy(self, logits, labels): 
+        out = torch.argmax(logits, dim=-1) 
+        out = out.flatten() 
+        labels = labels.flatten() 
+
+        mask = (labels != self.ignore_index) # can also be self.pad_value (your choice)
+        out = out[mask] 
+        labels = labels[mask] 
+
+        num_right = (out == labels)
+        num_right = torch.sum(num_right).type(torch.float32)
+
+        acc = num_right / len(labels) 
+        return acc
+
+    def forward(self, x, **kwargs):
+        seq, ignore_index, add_attn_z_loss = x.shape[1], self.ignore_index, self.add_attn_z_loss
+
+        inp, target = x[:, :-1], x[:, 1:]
+        inp = torch.where(inp == ignore_index, self.pad_value, inp)
+
+        if self.mask_prob > 0.:
+            rand = torch.randn(inp.shape, device = x.device)
+            rand[:, 0] = -torch.finfo(rand.dtype).max # first token should not be masked out
+            num_mask = min(int(seq * self.mask_prob), seq - 1)
+            indices = rand.topk(num_mask, dim = -1).indices
+            mask = ~torch.zeros_like(inp).scatter(1, indices, 1.).bool()
+            kwargs.update(self_attn_kv_mask = mask)
+
+        logits, cache = self.net(
+            inp,
+            return_intermediates = True,
+            return_attn_z_loss = add_attn_z_loss,
+            **kwargs
+        )
+
+        acc = self.compute_accuracy(logits, target)
+
+        loss = F.cross_entropy(
+            rearrange(logits, 'b n c -> b c n'),
+            target,
+            ignore_index = ignore_index
+        )
+
+        if add_attn_z_loss:
+            loss = loss + cache.attn_z_loss
+        
+        if self.return_cache:
+            return loss, acc, cache
+            
+        else:
+            return loss, acc
+
+#===============================================================================
+
+import math
+from random import random
+
+import torch
+from torch import nn, einsum, Tensor
+import torch.nn.functional as F
+
+from functools import partial, wraps
+from inspect import isfunction
+from collections import namedtuple
+from dataclasses import dataclass
+from typing import List, Callable, Optional
+
+from einops import rearrange, repeat, reduce, pack, unpack
+from einops.layers.torch import Rearrange
+
+# constants
+
+DEFAULT_DIM_HEAD = 64
+
+@dataclass
+class LayerIntermediates:
+    hiddens: Optional[List[Tensor]] = None
+    attn_intermediates: Optional[List[Intermediates]] = None
+    layer_hiddens: Optional[List[Tensor]] = None
+    attn_z_loss: Optional[Tensor] = None
+    mems: Optional[Tensor] = None
+
+# helpers
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if isfunction(d) else d
+
+def cast_tuple(val, depth):
+    return val if isinstance(val, tuple) else (val,) * depth
+
+def divisible_by(num, den):
+    return (num % den) == 0
+
+def maybe(fn):
+    @wraps(fn)
+    def inner(x, *args, **kwargs):
+        if not exists(x):
+            return x
+        return fn(x, *args, **kwargs)
+    return inner
+
+class always():
+    def __init__(self, val):
+        self.val = val
+    def __call__(self, *args, **kwargs):
+        return self.val
+
+class not_equals():
+    def __init__(self, val):
+        self.val = val
+    def __call__(self, x, *args, **kwargs):
+        return x != self.val
+
+class equals():
+    def __init__(self, val):
+        self.val = val
+    def __call__(self, x, *args, **kwargs):
+        return x == self.val
+
+def Sequential(*modules):
+    return nn.Sequential(*filter(exists, modules))
+
+# tensor helpers
+
+def max_neg_value(tensor):
+    return -torch.finfo(tensor.dtype).max
+
+def l2norm(t, groups = 1):
+    t = rearrange(t, '... (g d) -> ... g d', g = groups)
+    t = F.normalize(t, p = 2, dim = -1)
+    return rearrange(t, '... g d -> ... (g d)')
+
+def pad_at_dim(t, pad, dim = -1, value = 0.):
+    dims_from_right = (- dim - 1) if dim < 0 else (t.ndim - dim - 1)
+    zeros = ((0, 0) * dims_from_right)
+    return F.pad(t, (*zeros, *pad), value = value)
+
+def or_reduce(masks):
+    head, *body = masks
+    for rest in body:
+        head = head | rest
+    return head
+
+# auxiliary loss helpers
+
+def calc_z_loss(
+    pre_softmax_attns: List[Tensor],
+    mask = None,
+    weight = 1.
+):
+    # the same loss applied to the mixture of experts router logits in https://arxiv.org/abs/2202.08906
+    # in the paper, in a tiny footnote, they mention using it on attention logits with stabilizing effects
+    # also used in PaLM as one of the measures
+
+    lse = 0.
+
+    for attn in pre_softmax_attns:
+        lse = lse + attn.logsumexp(dim = -1)
+
+    loss = torch.square(lse)
+    loss = reduce(loss, 'b h n -> b n', 'sum')
+
+    if not exists(mask):
+        return loss.mean() * weight
+
+    loss = loss[mask].sum() / mask.sum().clamp(min = 1e-5)
+    return loss * weight
+
+# init helpers
+
+def init_zero_(layer):
+    nn.init.constant_(layer.weight, 0.)
+    if exists(layer.bias):
+        nn.init.constant_(layer.bias, 0.)
+
+# keyword argument helpers
+
+def pick_and_pop(keys, d):
+    values = list(map(lambda key: d.pop(key), keys))
+    return dict(zip(keys, values))
+
+def group_dict_by_key(cond, d):
+    return_val = [dict(),dict()]
+    for key in d.keys():
+        match = bool(cond(key))
+        ind = int(not match)
+        return_val[ind][key] = d[key]
+    return (*return_val,)
+
+def string_begins_with(prefix, str):
+    return str.startswith(prefix)
+
+def group_by_key_prefix(prefix, d):
+    return group_dict_by_key(partial(string_begins_with, prefix), d)
+
+def groupby_prefix_and_trim(prefix, d):
+    kwargs_with_prefix, kwargs = group_dict_by_key(partial(string_begins_with, prefix), d)
+    kwargs_without_prefix = dict(map(lambda x: (x[0][len(prefix):], x[1]), tuple(kwargs_with_prefix.items())))
+    return kwargs_without_prefix, kwargs
+
+# structured dropout, more effective than traditional attention dropouts
+
+def dropout_seq(seq, mask, dropout):
+    b, n, *_, device = *seq.shape, seq.device
+    logits = torch.randn(b, n, device = device)
+
+    if exists(mask):
+        mask_value = max_neg_value(logits)
+        logits = logits.masked_fill(~mask, mask_value)
+
+    keep_prob = 1. - dropout
+    num_keep = max(1,  int(keep_prob * n))
+    keep_indices = logits.topk(num_keep, dim = 1).indices
+
+    batch_indices = torch.arange(b, device = device)
+    batch_indices = rearrange(batch_indices, 'b -> b 1')
+
+    seq = seq[batch_indices, keep_indices]
+
+    if exists(mask):
+        seq_counts = mask.sum(dim = -1)
+        seq_keep_counts = torch.ceil(seq_counts * keep_prob).int()
+        keep_mask = torch.arange(num_keep, device = device) < rearrange(seq_keep_counts, 'b -> b 1')
+
+        mask = mask[batch_indices, keep_indices] & keep_mask
+
+    return seq, mask
+
+# activations
+
+class ReluSquared(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+# embedding
+
+class TokenEmbedding(nn.Module):
+    def __init__(self, dim, num_tokens, l2norm_embed = False):
+        super().__init__()
+        self.l2norm_embed = l2norm_embed
+        self.emb = nn.Embedding(num_tokens, dim)
+
+    def forward(self, x):
+        token_emb = self.emb(x)
+        return l2norm(token_emb) if self.l2norm_embed else token_emb
+
+# positional embeddings
+
+class AbsolutePositionalEmbedding(nn.Module):
+    def __init__(self, dim, max_seq_len, l2norm_embed = False):
+        super().__init__()
+        self.scale = dim ** -0.5 if not l2norm_embed else 1.
+        self.max_seq_len = max_seq_len
+        self.l2norm_embed = l2norm_embed
+        self.emb = nn.Embedding(max_seq_len, dim)
+
+    def forward(self, x, pos = None, seq_start_pos = None):
+        seq_len, device = x.shape[1], x.device
+        assert seq_len <= self.max_seq_len, f'you are passing in a sequence length of {seq_len} but your absolute positional embedding has a max sequence length of {self.max_seq_len}'
+
+        if not exists(pos):
+            pos = torch.arange(seq_len, device = device)
+
+        if exists(seq_start_pos):
+            pos = (pos - seq_start_pos[..., None]).clamp(min = 0)
+
+        pos_emb = self.emb(pos)
+        pos_emb = pos_emb * self.scale
+        return l2norm(pos_emb) if self.l2norm_embed else pos_emb
+
+class ScaledSinusoidalEmbedding(nn.Module):
+    def __init__(self, dim, theta = 10000):
+        super().__init__()
+        assert divisible_by(dim, 2)
+        self.scale = nn.Parameter(torch.ones(1) * dim ** -0.5)
+
+        half_dim = dim // 2
+        freq_seq = torch.arange(half_dim).float() / half_dim
+        inv_freq = theta ** -freq_seq
+        self.register_buffer('inv_freq', inv_freq, persistent = False)
+
+    def forward(self, x, pos = None, seq_start_pos = None):
+        seq_len, device = x.shape[1], x.device
+
+        if not exists(pos):
+            pos = torch.arange(seq_len, device = device)
+
+        if exists(seq_start_pos):
+            pos = pos - seq_start_pos[..., None]
+
+        emb = einsum('i, j -> i j', pos, self.inv_freq)
+        emb = torch.cat((emb.sin(), emb.cos()), dim = -1)
+        return emb * self.scale
+
+class RelativePositionBias(nn.Module):
+    def __init__(self, scale, causal = False, num_buckets = 32, max_distance = 128, heads = 8):
+        super().__init__()
+        self.scale = scale
+        self.causal = causal
+        self.num_buckets = num_buckets
+        self.max_distance = max_distance
+        self.relative_attention_bias = nn.Embedding(num_buckets, heads)
+
+    @staticmethod
+    def _relative_position_bucket(relative_position, causal = True, num_buckets = 32, max_distance = 128):
+        ret = 0
+        n = -relative_position
+        if not causal:
+            num_buckets //= 2
+            ret += (n < 0).long() * num_buckets
+            n = torch.abs(n)
+        else:
+            n = torch.max(n, torch.zeros_like(n))
+
+        max_exact = num_buckets // 2
+        is_small = n < max_exact
+
+        val_if_large = max_exact + (
+            torch.log(n.float() / max_exact) / math.log(max_distance / max_exact) * (num_buckets - max_exact)
+        ).long()
+        val_if_large = torch.min(val_if_large, torch.full_like(val_if_large, num_buckets - 1))
+
+        ret += torch.where(is_small, n, val_if_large)
+        return ret
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    def forward(self, i, j):
+        device = self.device
+        q_pos = torch.arange(j - i, j, dtype = torch.long, device = device)
+        k_pos = torch.arange(j, dtype = torch.long, device = device)
+        rel_pos = k_pos[None, :] - q_pos[:, None]
+        rp_bucket = self._relative_position_bucket(rel_pos, causal = self.causal, num_buckets = self.num_buckets, max_distance = self.max_distance)
+        values = self.relative_attention_bias(rp_bucket)
+        bias = rearrange(values, 'i j h -> h i j')
+        return bias * self.scale
+
+class DynamicPositionBias(nn.Module):
+    def __init__(self, dim, *, heads, depth, log_distance = False, norm = False):
+        super().__init__()
+        assert depth >= 1, 'depth for dynamic position bias MLP must be greater or equal to 1'
+        self.log_distance = log_distance
+
+        self.mlp = nn.ModuleList([])
+
+        self.mlp.append(Sequential(
+            nn.Linear(1, dim),
+            nn.LayerNorm(dim) if norm else None,
+            nn.SiLU()
+        ))
+
+        for _ in range(depth - 1):
+            self.mlp.append(Sequential(
+                nn.Linear(dim, dim),
+                nn.LayerNorm(dim) if norm else None,
+                nn.SiLU()
+            ))
+
+        self.mlp.append(nn.Linear(dim, heads))
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    def forward(self, i, j):
+        assert i == j
+        n, device = j, self.device
+
+        # get the (n x n) matrix of distances
+        seq_arange = torch.arange(n, device = device)
+        context_arange = torch.arange(n, device = device)
+        indices = rearrange(seq_arange, 'i -> i 1') - rearrange(context_arange, 'j -> 1 j')
+        indices += (n - 1)
+
+        # input to continuous positions MLP
+        pos = torch.arange(-n + 1, n, device = device).float()
+        pos = rearrange(pos, '... -> ... 1')
+
+        if self.log_distance:
+            pos = torch.sign(pos) * torch.log(pos.abs() + 1)  # log of distance is sign(rel_pos) * log(abs(rel_pos) + 1)
+
+        for layer in self.mlp:
+            pos = layer(pos)
+
+        # get position biases        
+        bias = pos[indices]
+        bias = rearrange(bias, 'i j h -> h i j')
+        return bias
+
+class AlibiPositionalBias(nn.Module):
+    def __init__(self, heads, total_heads, **kwargs):
+        super().__init__()
+        self.heads = heads
+        self.total_heads = total_heads
+
+        slopes = Tensor(self._get_slopes(heads))
+        slopes = rearrange(slopes, 'h -> h 1 1')
+        self.register_buffer('slopes', slopes, persistent = False)
+        self.register_buffer('bias', None, persistent = False)
+    
+    def get_bias(self, i, j, device):
+        i_arange = torch.arange(j - i, j, device = device)
+        j_arange = torch.arange(j, device = device)
+        bias = -torch.abs(rearrange(j_arange, 'j -> 1 1 j') - rearrange(i_arange, 'i -> 1 i 1'))
+        return bias
+
+    @staticmethod
+    def _get_slopes(heads):
+        def get_slopes_power_of_2(n):
+            start = (2**(-2**-(math.log2(n)-3)))
+            ratio = start
+            return [start*ratio**i for i in range(n)]
+
+        if math.log2(heads).is_integer():
+            return get_slopes_power_of_2(heads)
+
+        closest_power_of_2 = 2 ** math.floor(math.log2(heads))
+        return get_slopes_power_of_2(closest_power_of_2) + get_slopes_power_of_2(2 * closest_power_of_2)[0::2][:heads-closest_power_of_2]
+
+    @property
+    def device(self):
+        return next(self.buffers()).device
+
+    def forward(self, i, j):
+        h, device = self.total_heads, self.device
+
+        if exists(self.bias) and self.bias.shape[-1] >= j and self.bias.shape[-2] >= i:
+            return self.bias[..., -i:, -j:]
+
+        bias = self.get_bias(i, j, device)
+        bias = bias * self.slopes
+
+        num_heads_unalibied = h - bias.shape[0]
+        bias = pad_at_dim(bias, (0, num_heads_unalibied), dim = 0)
+        self.register_buffer('bias', bias, persistent = False)
+
+        return self.bias
+
+class RotaryEmbedding(nn.Module):
+    def __init__(
+        self,
+        dim,
+        use_xpos = False,
+        scale_base = 512,
+        interpolation_factor = 1.,
+        base = 10000,
+        base_rescale_factor = 1.
+    ):
+        super().__init__()
+        # proposed by reddit user bloc97, to rescale rotary embeddings to longer sequence length without fine-tuning
+        # has some connection to NTK literature
+        # https://www.reddit.com/r/LocalLLaMA/comments/14lz7j5/ntkaware_scaled_rope_allows_llama_models_to_have/
+        base *= base_rescale_factor ** (dim / (dim - 2))
+
+        inv_freq = 1. / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer('inv_freq', inv_freq)
+
+        assert interpolation_factor >= 1.
+        self.interpolation_factor = interpolation_factor
+
+        if not use_xpos:
+            self.register_buffer('scale', None)
+            return
+
+        scale = (torch.arange(0, dim, 2) + 0.4 * dim) / (1.4 * dim)
+
+        self.scale_base = scale_base
+        self.register_buffer('scale', scale)
+
+    def forward(self, seq_len):
+        device = self.inv_freq.device
+        t = torch.arange(seq_len, device = device).type_as(self.inv_freq)
+
+        t = t / self.interpolation_factor
+
+        freqs = torch.einsum('i , j -> i j', t, self.inv_freq)
+        freqs = torch.cat((freqs, freqs), dim = -1)
+
+        if not exists(self.scale):
+            return freqs, 1.
+
+        power = (torch.arange(seq_len, device = device) - (seq_len // 2)) / self.scale_base
+        scale = self.scale ** rearrange(power, 'n -> n 1')
+        scale = torch.cat((scale, scale), dim = -1)
+
+        return freqs, scale
+
+
+def rotate_half(x):
+    x = rearrange(x, '... (j d) -> ... j d', j = 2)
+    x1, x2 = x.unbind(dim = -2)
+    return torch.cat((-x2, x1), dim = -1)
+
+def apply_rotary_pos_emb(t, freqs, scale = 1):
+    rot_dim, seq_len = freqs.shape[-1], t.shape[-2]
+    freqs = freqs[-seq_len:, :]
+
+    if t.ndim == 4 and freqs.ndim == 3:
+        freqs = rearrange(freqs, 'b n d -> b 1 n d')
+
+    # partial rotary embeddings, Wang et al. GPT-J
+    t, t_unrotated = t[..., :rot_dim], t[..., rot_dim:]
+    t = (t * freqs.cos() * scale) + (rotate_half(t) * freqs.sin() * scale)
+    return torch.cat((t, t_unrotated), dim = -1)
+
+# norms
+
+class Scale(nn.Module):
+    def __init__(self, value, fn):
+        super().__init__()
+        self.value = value
+        self.fn = fn
+
+    def forward(self, x, **kwargs):
+        out = self.fn(x, **kwargs)
+        scale_fn = lambda t: t * self.value
+
+        if not isinstance(out, tuple):
+            return scale_fn(out)
+
+        return (scale_fn(out[0]), *out[1:])
+
+class ScaleNorm(nn.Module):
+    def __init__(self, dim, eps = 1e-5):
+        super().__init__()
+        self.eps = eps
+        self.g = nn.Parameter(torch.ones(1) * (dim ** -0.5))
+
+    def forward(self, x):
+        norm = torch.norm(x, dim = -1, keepdim = True)
+        return x / norm.clamp(min = self.eps) * self.g
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.scale = dim ** 0.5
+        self.g = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x):
+        return F.normalize(x, dim = -1) * self.scale * self.g
+
+class SimpleRMSNorm(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.scale = dim ** 0.5
+
+    def forward(self, x):
+        return F.normalize(x, dim = -1) * self.scale
+
+# residual and residual gates
+
+class Residual(nn.Module):
+    def __init__(self, dim, scale_residual = False, scale_residual_constant = 1.):
+        super().__init__()
+        self.residual_scale = nn.Parameter(torch.ones(dim)) if scale_residual else None
+        self.scale_residual_constant = scale_residual_constant
+
+    def forward(self, x, residual):
+        if exists(self.residual_scale):
+            residual = residual * self.residual_scale
+
+        if self.scale_residual_constant != 1:
+            residual = residual * self.scale_residual_constant
+
+        return x + residual
+
+class GRUGating(nn.Module):
+    def __init__(self, dim, scale_residual = False, **kwargs):
+        super().__init__()
+        self.gru = nn.GRUCell(dim, dim)
+        self.residual_scale = nn.Parameter(torch.ones(dim)) if scale_residual else None
+
+    def forward(self, x, residual):
+        if exists(self.residual_scale):
+            residual = residual * self.residual_scale
+
+        gated_output = self.gru(
+            rearrange(x, 'b n d -> (b n) d'),
+            rearrange(residual, 'b n d -> (b n) d')
+        )
+
+        return gated_output.reshape_as(x)
+
+# token shifting
+
+def shift(t, amount, mask = None):
+    if amount == 0:
+        return t
+    else:
+        amount = min(amount, t.shape[1])
+
+    if exists(mask):
+        t = t.masked_fill(~mask[..., None], 0.)
+
+    return pad_at_dim(t, (amount, -amount), dim = - 2, value = 0.)
+
+class ShiftTokens(nn.Module):
+    def __init__(self, shifts, fn):
+        super().__init__()
+        self.fn = fn
+        self.shifts = tuple(shifts)
+
+    def forward(self, x, **kwargs):
+        mask = kwargs.get('mask', None)
+        shifts = self.shifts
+        segments = len(shifts)
+        feats_per_shift = x.shape[-1] // segments
+        splitted = x.split(feats_per_shift, dim = -1)
+        segments_to_shift, rest = splitted[:segments], splitted[segments:]
+        segments_to_shift = list(map(lambda args: shift(*args, mask = mask), zip(segments_to_shift, shifts)))
+        x = torch.cat((*segments_to_shift, *rest), dim = -1)
+        return self.fn(x, **kwargs)
+
+# feedforward
+
+class GLU(nn.Module):
+    def __init__(
+        self,
+        dim_in,
+        dim_out,
+        activation: Callable,
+        mult_bias = False
+    ):
+        super().__init__()
+        self.act = activation
+        self.proj = nn.Linear(dim_in, dim_out * 2)
+        self.mult_bias = nn.Parameter(torch.ones(dim_out)) if mult_bias else 1.
+
+    def forward(self, x):
+        x, gate = self.proj(x).chunk(2, dim = -1)
+        return x * self.act(gate) * self.mult_bias
+
+class FeedForward(nn.Module):
+    def __init__(
+        self,
+        dim,
+        dim_out = None,
+        mult = 4,
+        glu = False,
+        glu_mult_bias = False,
+        swish = False,
+        relu_squared = False,
+        post_act_ln = False,
+        dropout = 0.,
+        no_bias = False,
+        zero_init_output = False
+    ):
+        super().__init__()
+        inner_dim = int(dim * mult)
+        dim_out = default(dim_out, dim)
+
+        if relu_squared:
+            activation = ReluSquared()
+        elif swish:
+            activation = nn.SiLU()
+        else:
+            activation = nn.GELU()
+
+        if glu:
+            project_in = GLU(dim, inner_dim, activation, mult_bias = glu_mult_bias)
+        else:
+            project_in = nn.Sequential(
+                nn.Linear(dim, inner_dim, bias = not no_bias),
+                activation
+            )
+
+        self.ff = Sequential(
+            project_in,
+            nn.LayerNorm(inner_dim) if post_act_ln else None,
+            nn.Dropout(dropout),
+            nn.Linear(inner_dim, dim_out, bias = not no_bias)
+        )
+
+        # init last linear layer to 0
+        if zero_init_output:
+            init_zero_(self.ff[-1])
+
+    def forward(self, x):
+        return self.ff(x)
+
+# attention. it is all we need
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim,
+        dim_head = DEFAULT_DIM_HEAD,
+        heads = 8,
+        causal = False,
+        flash = False,
+        talking_heads = False,
+        head_scale = False,
+        sparse_topk = None,
+        num_mem_kv = 0,
+        dropout = 0.,
+        on_attn = False,
+        gate_value_heads = False,
+        gate_values = False,
+        zero_init_output = False,
+        max_attend_past = None,
+        qk_norm = False,
+        qk_norm_groups = 1,
+        qk_norm_scale = 10,
+        qk_norm_dim_scale = False,
+        one_kv_head = False,
+        kv_heads = None,
+        shared_kv = False,
+        value_dim_head = None,
+        tensor_product = False,      # https://arxiv.org/abs/2208.06061
+        add_zero_kv = False,         # same as add_zero_attn in pytorch
+        rotary_embed_values = False,
+        onnxable = False
+    ):
+        super().__init__()
+        self.scale = dim_head ** -0.5
+
+        self.heads = heads
+        self.causal = causal
+        self.max_attend_past = max_attend_past
+
+        assert not (exists(kv_heads) and one_kv_head), 'either attn_one_kv_head is set to True (in which case kv_heads is set to 1), or attn_kv_heads is set, but not both'
+
+        value_dim_head = default(value_dim_head, dim_head)
+        kv_heads = default(kv_heads, heads)
+
+        kv_heads = 1 if one_kv_head else kv_heads
+        assert divisible_by(heads, kv_heads)
+
+        self.kv_heads = kv_heads
+
+        q_dim = dim_head * heads
+        k_dim = dim_head * kv_heads
+        v_dim = value_dim_head * kv_heads
+        out_dim = value_dim_head * heads
+
+        self.to_q = nn.Linear(dim, q_dim, bias = False)
+        self.to_k = nn.Linear(dim, k_dim, bias = False)
+
+        # shared key / values, for further memory savings during inference
+        assert not (shared_kv and value_dim_head != dim_head), 'key and value head dimensions must be equal for shared key / values'
+        self.to_v = nn.Linear(dim, v_dim, bias = False) if not shared_kv else None
+
+        # relations projection from tp-attention
+        self.to_r = nn.Linear(dim, v_dim, bias = False) if tensor_product else None
+
+        # add GLU gating for aggregated values, from alphafold2
+        self.to_v_gate = None
+        if gate_values:
+            self.to_v_gate = nn.Linear(dim, out_dim)
+            nn.init.constant_(self.to_v_gate.weight, 0)
+            nn.init.constant_(self.to_v_gate.bias, 10)
+
+        # add per head gating of the output values, from 'Attend to nothing' paper
+        self.to_v_head_gate = None
+        if gate_value_heads:
+            self.to_v_head_gate = nn.Linear(dim, heads)
+            nn.init.constant_(self.to_v_head_gate.weight, 0)
+            nn.init.constant_(self.to_v_head_gate.bias, 10)
+
+        # cosine sim attention
+        self.qk_norm = qk_norm
+        self.qk_norm_groups = qk_norm_groups
+        self.qk_norm_scale = qk_norm_scale
+
+        # whether to use the rmsnorm (equivalent to cosine sim attention when scale is equal to 1) - https://arxiv.org/abs/2302.05442
+        self.qk_norm_dim_scale = qk_norm_dim_scale
+
+        self.qk_norm_q_scale = self.qk_norm_k_scale = 1
+        if qk_norm and qk_norm_dim_scale:
+            self.qk_norm_q_scale = nn.Parameter(torch.ones(heads, 1, dim_head))
+            self.qk_norm_k_scale = nn.Parameter(torch.ones(heads, 1, dim_head))
+
+        assert (not qk_norm) or divisible_by(dim_head, qk_norm_groups), 'dimension per attention head must be divisible by the qk norm groups'
+        assert not (qk_norm and (dim_head // qk_norm_groups) <= 2), 'the group dimension may be too small (2 was too small in my tests, but 4 still works, surprisingly)'
+
+        # attend class - includes core attention algorithm + talking heads
+
+        self.attend = Attend(
+            heads = heads,
+            causal = causal,
+            talking_heads = talking_heads,
+            dropout = dropout,
+            sparse_topk = sparse_topk,
+            qk_norm = qk_norm,
+            scale = qk_norm_scale if qk_norm else self.scale,
+            add_zero_kv = add_zero_kv,
+            flash = flash,
+            onnxable = onnxable
+        )
+
+        # head scaling
+        self.head_scale = head_scale
+        if head_scale:
+            self.head_scale_params = nn.Parameter(torch.ones(1, heads, 1, 1))
+
+        # explicit topk sparse attention
+        self.sparse_topk = sparse_topk
+
+        # add memory key / values
+        self.num_mem_kv = num_mem_kv
+        if num_mem_kv > 0:
+            self.mem_k = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head))
+            self.mem_v = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head))
+
+        # attention on attention
+        self.attn_on_attn = on_attn
+        self.to_out = nn.Sequential(nn.Linear(out_dim, dim * 2, bias = False), nn.GLU()) if on_attn else nn.Linear(out_dim, dim, bias = False)
+
+        # whether to rotate positions into values, for absolute positions in addition to relative
+        self.rotary_embed_values = rotary_embed_values
+
+        # init output projection 0
+        if zero_init_output:
+            init_zero_(self.to_out)
+
+    def forward(
+        self,
+        x,
+        context = None,
+        mask = None,
+        context_mask = None,
+        attn_mask = None,
+        rel_pos = None,
+        rotary_pos_emb = None,
+        prev_attn = None,
+        mem = None,
+        return_intermediates = False,
+        cache: Optional[Intermediates] = None,
+    ):
+        b, n, _, h, kv_h, head_scale, device, has_context = *x.shape, self.heads, self.kv_heads, self.head_scale, x.device, exists(context)
+        kv_input = default(context, x)
+
+        q_input = x
+        k_input = kv_input
+        v_input = kv_input
+        r_input = x
+
+        if exists(mem):
+            k_input, mem_packed_shape = pack([mem, k_input], 'b * d')
+            v_input, _ = pack([mem, v_input], 'b * d')
+
+        q = self.to_q(q_input)
+        k = self.to_k(k_input)
+        v = self.to_v(v_input) if exists(self.to_v) else k
+        r = self.to_r(r_input) if exists(self.to_r) else None
+
+        q = rearrange(q, 'b n (h d) -> b h n d', h = h)
+
+        k, v, r = map(lambda t: maybe(rearrange)(t, 'b n (h d) -> b h n d', h = kv_h), (k, v, r))
+
+        if exists(cache) and not has_context:
+            ck, cv = cache.cached_kv
+
+            if exists(mem):
+                mk, k = unpack(k, mem_packed_shape, 'b h * d')
+                mv, v = unpack(v, mem_packed_shape, 'b h * d')
+
+            k = torch.cat((ck, k), dim = -2)
+            v = torch.cat((cv, v), dim = -2)
+
+            if exists(mem):
+                k = torch.cat((mk, k), dim = -2)
+                v = torch.cat((mv, v), dim = -2)
+
+        if return_intermediates:
+            mem_len = mem.shape[-2] if exists(mem) else 0
+            cached_kv = (k[..., mem_len:, :], v[..., mem_len:, :])
+
+        if self.qk_norm:
+            qk_l2norm = partial(l2norm, groups = self.qk_norm_groups)
+            q, k = map(qk_l2norm, (q, k))
+            scale = self.qk_norm_scale
+
+            q = q * self.qk_norm_q_scale
+            k = k * self.qk_norm_k_scale
+
+        if exists(rotary_pos_emb) and not has_context:
+            freqs, xpos_scale = rotary_pos_emb
+            q_xpos_scale, k_xpos_scale = (xpos_scale, xpos_scale ** -1.) if exists(xpos_scale) else (1., 1.)
+
+            q = apply_rotary_pos_emb(q, freqs, q_xpos_scale)
+            k = apply_rotary_pos_emb(k, freqs, k_xpos_scale)
+
+            if self.rotary_embed_values:
+                v = apply_rotary_pos_emb(v, freqs, k_xpos_scale)
+
+        input_mask = context_mask
+
+        if not exists(input_mask) and not has_context:
+            input_mask = mask
+
+        if self.num_mem_kv > 0:
+            mem_k, mem_v = map(lambda t: repeat(t, 'h n d -> b h n d', b = b), (self.mem_k, self.mem_v))
+
+            if self.qk_norm:
+                mem_k = l2norm(mem_k)
+                mem_k = mem_k * self.qk_norm_k_scale
+
+            k = torch.cat((mem_k, k), dim = -2)
+            v = torch.cat((mem_v, v), dim = -2)
+
+            if exists(input_mask):
+                input_mask = pad_at_dim(input_mask, (self.num_mem_kv, 0), dim = -1, value = True)
+
+        i, j = map(lambda t: t.shape[-2], (q, k))
+
+        # determine masking
+
+        mask_value = max_neg_value(q)
+        masks = []
+        final_attn_mask = None
+
+        if exists(input_mask):
+            input_mask = rearrange(input_mask, 'b j -> b 1 1 j')
+            masks.append(~input_mask)
+
+        if exists(attn_mask):
+            assert 2 <= attn_mask.ndim <= 4, 'attention mask must have greater than 2 dimensions but less than or equal to 4'
+            if attn_mask.ndim == 2:
+                attn_mask = rearrange(attn_mask, 'i j -> 1 1 i j')
+            elif attn_mask.ndim == 3:
+                attn_mask = rearrange(attn_mask, 'h i j -> 1 h i j')
+            masks.append(~attn_mask)
+
+        if exists(self.max_attend_past):
+            range_q = torch.arange(j - i, j, device = device)
+            range_k = torch.arange(j, device = device)
+            dist = rearrange(range_q, 'i -> 1 1 i 1') - rearrange(range_k, 'j -> 1 1 1 j')
+            max_attend_past_mask = dist > self.max_attend_past
+            masks.append(max_attend_past_mask)
+
+        if len(masks) > 0:
+            final_attn_mask = ~or_reduce(masks)
+
+        # prepare relative positional bias, if needed
+
+        attn_bias = None
+        if exists(rel_pos):
+            attn_bias = rel_pos(i, j)
+
+        # attention is all we need
+
+        out, intermediates = self.attend(
+            q, k, v,
+            mask = final_attn_mask,
+            attn_bias = attn_bias,
+            prev_attn = prev_attn
+        )
+
+        # https://arxiv.org/abs/2208.06061 proposes to add a residual for better gradients
+
+        if exists(r):
+            out = out * r + out
+
+        # normformer scaling of heads
+
+        if head_scale:
+            out = out * self.head_scale_params
+
+        # per head gating, from https://arxiv.org/abs/2306.12929
+
+        if exists(self.to_v_head_gate):
+            head_gate = self.to_v_head_gate(x)
+            out = out * rearrange(head_gate, 'b n h -> b h n 1').sigmoid()
+
+        # merge heads
+
+        out = rearrange(out, 'b h n d -> b n (h d)')
+
+        # alphafold2 styled gating of the values
+
+        if exists(self.to_v_gate):
+            gates = self.to_v_gate(x)
+            out = out * gates.sigmoid()
+
+        # combine the heads
+
+        out = self.to_out(out)
+
+        if exists(mask):
+            mask = rearrange(mask, 'b n -> b n 1')
+            out = out.masked_fill(~mask, 0.)
+
+        if not return_intermediates:
+            return out
+
+        intermediates.cached_kv = cached_kv
+
+        return out, intermediates
+
+class AttentionLayers(nn.Module):
+    def __init__(
+        self,
+        dim,
+        depth,
+        heads = 8,
+        causal = False,
+        cross_attend = False,
+        only_cross = False,
+        use_scalenorm = False,
+        use_rmsnorm = False,
+        use_simple_rmsnorm = False,
+        alibi_pos_bias = False,
+        alibi_num_heads = None,
+        rel_pos_bias = False,
+        rel_pos_num_buckets = 32,
+        rel_pos_max_distance = 128,
+        dynamic_pos_bias = False,
+        dynamic_pos_bias_log_distance = False,
+        dynamic_pos_bias_mlp_depth = 2,
+        dynamic_pos_bias_norm = False,
+        rotary_pos_emb = False,
+        rotary_emb_dim = None,
+        rotary_xpos = False,
+        rotary_interpolation_factor = 1.,
+        rotary_xpos_scale_base = 512,
+        rotary_base_rescale_factor = 1.,
+        custom_layers = None,
+        sandwich_coef = None,
+        par_ratio = None,
+        weight_tie_layers = False,   # Albert - https://arxiv.org/abs/1909.11942
+        layers_execute_order = None, # generalizes weight tying, can do arbitrary layer execution orders
+        residual_attn = False,
+        cross_residual_attn = False,
+        macaron = False,
+        pre_norm = True,
+        pre_norm_has_final_norm = True,
+        gate_residual = False,
+        scale_residual = False,
+        scale_residual_constant = 1.,
+        shift_tokens = 0,
+        sandwich_norm = False,
+        resi_dual = False,
+        resi_dual_scale = 1.,
+        zero_init_branch_output = False,
+        layer_dropout = 0.,
+        cross_attn_tokens_dropout = 0.,
+        **kwargs
+    ):
+        super().__init__()
+        rotary_pos_emb = rotary_pos_emb or rotary_xpos
+
+        ff_kwargs, kwargs = groupby_prefix_and_trim('ff_', kwargs)
+        attn_kwargs, kwargs = groupby_prefix_and_trim('attn_', kwargs)
+
+        dim_head = attn_kwargs.get('dim_head', DEFAULT_DIM_HEAD)
+
+        self.dim = dim
+        self.depth = depth
+        self.causal = causal
+        self.layers = nn.ModuleList([])
+
+        self.has_pos_emb = rel_pos_bias or rotary_pos_emb
+
+        rotary_emb_dim = max(default(rotary_emb_dim, dim_head // 2), 32)
+
+        assert not (rotary_xpos and not causal), 'rotary xpos is not compatible with bidirectional attention'
+        self.rotary_pos_emb = RotaryEmbedding(rotary_emb_dim, use_xpos = rotary_xpos, scale_base = rotary_xpos_scale_base, interpolation_factor = rotary_interpolation_factor, base_rescale_factor = rotary_base_rescale_factor) if rotary_pos_emb else None
+
+        assert not (alibi_pos_bias and rel_pos_bias), 'you can only choose Alibi positional bias or T5 relative positional bias, not both'
+        assert rel_pos_num_buckets <= rel_pos_max_distance, 'number of relative position buckets must be less than the relative position max distance'
+
+        # relative positional bias
+
+        flash_attn = attn_kwargs.get('flash', False)
+        assert (int(rel_pos_bias) + int(dynamic_pos_bias) + int(alibi_pos_bias)) <= 1, 'you can only choose up to one of t5, alibi, or dynamic positional bias'
+
+        self.rel_pos = None
+        if rel_pos_bias:
+            assert not flash_attn, 'flash attention not compatible with t5 relative positional bias'
+            self.rel_pos = RelativePositionBias(scale = dim_head ** 0.5, causal = causal, heads = heads, num_buckets = rel_pos_num_buckets, max_distance = rel_pos_max_distance)
+        elif dynamic_pos_bias:
+            assert not flash_attn, 'flash attention not compatible with dynamic positional bias'
+            self.rel_pos = DynamicPositionBias(dim = dim // 4, heads = heads, log_distance = dynamic_pos_bias_log_distance, depth = dynamic_pos_bias_mlp_depth, norm = dynamic_pos_bias_norm)
+        elif alibi_pos_bias:
+            alibi_num_heads = default(alibi_num_heads, heads)
+            assert alibi_num_heads <= heads, 'number of ALiBi heads must be less than the total number of heads'
+            self.rel_pos = AlibiPositionalBias(heads = alibi_num_heads, total_heads = heads)
+
+        assert (int(sandwich_norm) + int(resi_dual)) <= 1, 'either sandwich norm or resiDual is selected, but not both'
+        assert not (not pre_norm and sandwich_norm), 'sandwich norm cannot be used when not using prenorm'
+
+        if resi_dual:
+            pre_norm = False
+
+        self.pre_norm = pre_norm
+        self.sandwich_norm = sandwich_norm
+
+        self.resi_dual = resi_dual
+        assert 0 < resi_dual_scale <= 1., 'resiDual prenorm residual must be scaled by a factor greater than 0 and less than or equal to 1.'
+        self.resi_dual_scale = resi_dual_scale
+
+        self.residual_attn = residual_attn
+        self.cross_residual_attn = cross_residual_attn
+        assert not (flash_attn and (residual_attn or cross_residual_attn)), 'flash attention is not compatible with residual attention'
+
+        self.cross_attend = cross_attend
+
+        assert (int(use_scalenorm) + int(use_rmsnorm) + int(use_simple_rmsnorm)) <= 1, 'you can only use either scalenorm, rmsnorm, or simple rmsnorm'
+
+        if use_scalenorm:
+            norm_class = ScaleNorm
+        elif use_rmsnorm:
+            norm_class = RMSNorm
+        elif use_simple_rmsnorm:
+            norm_class = SimpleRMSNorm
+        else:
+            norm_class = nn.LayerNorm
+
+        norm_fn = partial(norm_class, dim)
+
+        if cross_attend and not only_cross:
+            default_block = ('a', 'c', 'f')
+        elif cross_attend and only_cross:
+            default_block = ('c', 'f')
+        else:
+            default_block = ('a', 'f')
+
+        if macaron:
+            default_block = ('f',) + default_block
+
+        # zero init
+
+        if zero_init_branch_output:
+            attn_kwargs = {**attn_kwargs, 'zero_init_output':  True}
+            ff_kwargs = {**ff_kwargs, 'zero_init_output':  True}
+
+        # setup weight tying, which is a special case of `layer_execute_order`
+
+        assert not (weight_tie_layers and any([*map(exists, (custom_layers, par_ratio, sandwich_coef))]))
+
+        if weight_tie_layers:
+            assert not exists(layers_execute_order)
+            layers_execute_order = tuple(range(len(default_block))) * depth
+            depth = 1
+
+        # calculate layer block order
+
+        if exists(custom_layers):
+            layer_types = custom_layers
+        elif exists(par_ratio):
+            par_depth = depth * len(default_block)
+            assert 1 < par_ratio <= par_depth, 'par ratio out of range'
+            default_block = tuple(filter(not_equals('f'), default_block))
+            par_attn  = par_depth // par_ratio
+            depth_cut = par_depth * 2 // 3  # 2 / 3 attention layer cutoff suggested by PAR paper
+            par_width = (depth_cut + depth_cut // par_attn) // par_attn
+            assert len(default_block) <= par_width, 'default block is too large for par_ratio'
+            par_block = default_block + ('f',) * (par_width - len(default_block))
+            par_head = par_block * par_attn
+            layer_types = par_head + ('f',) * (par_depth - len(par_head))
+        elif exists(sandwich_coef):
+            assert sandwich_coef > 0 and sandwich_coef <= depth, 'sandwich coefficient should be less than the depth'
+            layer_types = ('a',) * sandwich_coef + default_block * (depth - sandwich_coef) + ('f',) * sandwich_coef
+        else:
+            layer_types = default_block * depth
+
+        self.layer_types = layer_types
+        self.layers_execute_order = default(layers_execute_order, tuple(range(len(layer_types))))
+
+        assert all([i < len(self.layer_types) for i in self.layers_execute_order])
+
+        self.num_attn_layers = len(list(filter(equals('a'), layer_types)))
+
+        # stochastic depth
+
+        self.layer_dropouts = cast_tuple(layer_dropout, len(layer_types))
+
+        # structured dropout for cross attending
+
+        self.cross_attn_tokens_dropout = cross_attn_tokens_dropout
+
+        # calculate token shifting
+
+        shift_tokens = cast_tuple(shift_tokens, len(layer_types))
+
+        # whether it has post norm
+
+        self.final_norm = norm_fn() if pre_norm or resi_dual else nn.Identity()
+
+        # iterate and construct layers
+
+        for ind, (layer_type, layer_shift_tokens) in enumerate(zip(self.layer_types, shift_tokens)):
+            is_last_layer = ind == (len(self.layer_types) - 1)
+
+            if layer_type == 'a':
+                layer = Attention(dim, heads = heads, causal = causal, **attn_kwargs)
+            elif layer_type == 'c':
+                layer = Attention(dim, heads = heads, **attn_kwargs)
+            elif layer_type == 'f':
+                layer = FeedForward(dim, **ff_kwargs)
+                layer = layer if not macaron else Scale(0.5, layer)
+            else:
+                raise Exception(f'invalid layer type {layer_type}')
+
+            if layer_shift_tokens > 0:
+                shift_range_upper = layer_shift_tokens + 1
+                shift_range_lower = -layer_shift_tokens if not causal else 0
+                layer = ShiftTokens(range(shift_range_lower, shift_range_upper), layer)
+
+            residual_fn = GRUGating if gate_residual else Residual
+            residual = residual_fn(dim, scale_residual = scale_residual, scale_residual_constant = scale_residual_constant)
+
+            pre_branch_norm = norm_fn() if pre_norm else None
+            post_branch_norm = norm_fn() if sandwich_norm else None
+            post_main_norm = norm_fn() if not pre_norm else None
+
+            norms = nn.ModuleList([
+                pre_branch_norm,
+                post_branch_norm,
+                post_main_norm
+            ])
+
+            self.layers.append(nn.ModuleList([
+                norms,
+                layer,
+                residual
+            ]))
+
+    def forward(
+        self,
+        x,
+        context = None,
+        mask = None,
+        context_mask = None,
+        attn_mask = None,
+        self_attn_kv_mask = None,
+        mems = None,
+        seq_start_pos: Optional[Tensor] = None,
+        cache: Optional[LayerIntermediates] = None,
+        cache_age = 1,
+        return_hiddens = False
+    ):
+        assert not (self.cross_attend ^ exists(context)), 'context must be passed in if cross_attend is set to True'
+
+        # initialize accums
+
+        hiddens = []
+        layer_hiddens = []
+        intermediates = []
+
+        prev_attn = None
+        prev_cross_attn = None
+
+        mems = mems.copy() if exists(mems) else [None] * self.num_attn_layers
+
+        # handle left padded sequences
+
+        if exists(seq_start_pos):
+            seq_arange = torch.arange(x.shape[-2], device = x.device, dtype = torch.long)
+            left_pad_mask = seq_arange >= seq_start_pos[..., None]
+
+            if exists(self_attn_kv_mask):
+                self_attn_kv_mask = self_attn_kv_mask & left_pad_mask
+            else:
+                self_attn_kv_mask = left_pad_mask
+
+        # rotary positions
+
+        rotary_pos_emb = None
+
+        if exists(self.rotary_pos_emb):
+            max_rotary_emb_length = max(list(map(lambda m: (m.shape[1] if exists(m) else 0) + x.shape[1], mems)))
+            rotary_pos_emb = self.rotary_pos_emb(max_rotary_emb_length)
+
+        # assume cached key / values
+
+        attn_cache = []
+
+        if exists(cache):
+            assert not self.training and self.causal and not any([*map(exists, (mask, attn_mask))])
+
+            if cache_age > 0:
+                x = x[:, -cache_age:] # for spec decoding, may be greater than 1
+
+            attn_cache = cache.attn_intermediates
+
+        iter_attn_cache = iter(attn_cache)
+
+        # outer residual - for resiDual paper
+
+        outer_residual = x * self.resi_dual_scale
+
+        # get layers to be executed
+
+        layer_variables = (
+            self.layer_types,
+            self.layers,
+            self.layer_dropouts
+        )
+
+        layer_variables = tuple(tuple(layer_variable[i] for i in self.layers_execute_order) for layer_variable in layer_variables)
+
+        # go through the attention and feedforward layers
+
+        for ind, (layer_type, (norm, block, residual_fn), layer_dropout) in enumerate(zip(*layer_variables)):
+            is_last = ind == (len(self.layers) - 1)
+
+            if self.training and layer_dropout > 0. and random() < layer_dropout:
+                continue
+
+            if layer_type == 'a':
+                if return_hiddens:
+                    hiddens.append(x)
+                layer_mem = mems.pop(0) if mems else None
+
+            if layer_type == 'c':
+                if self.training and self.cross_attn_tokens_dropout > 0.:
+                    context, context_mask = dropout_seq(context, context_mask, self.cross_attn_tokens_dropout)
+
+            inner_residual = x
+
+            if return_hiddens:
+                layer_hiddens.append(x)
+
+            pre_norm, post_branch_norm, post_main_norm = norm
+
+            if exists(pre_norm):
+                x = pre_norm(x)
+
+            if layer_type == 'a':
+                out, inter = block(x, mask = mask, context_mask = self_attn_kv_mask, attn_mask = attn_mask, rel_pos = self.rel_pos, rotary_pos_emb = rotary_pos_emb, prev_attn = prev_attn, cache = next(iter_attn_cache, None), mem = layer_mem, return_intermediates = True)
+            elif layer_type == 'c':
+                out, inter = block(x, context = context, mask = mask, context_mask = context_mask, prev_attn = prev_cross_attn, cache = next(iter_attn_cache, None), return_intermediates = True)
+            elif layer_type == 'f':
+                out = block(x)
+
+            if self.resi_dual:
+                outer_residual = outer_residual + out * self.resi_dual_scale
+
+            if exists(post_branch_norm):
+                out = post_branch_norm(out)
+
+            x = residual_fn(out, inner_residual)
+
+            if layer_type in ('a', 'c') and return_hiddens:
+                intermediates.append(inter)
+
+            if layer_type == 'a' and self.residual_attn:
+                prev_attn = inter.pre_softmax_attn
+            elif layer_type == 'c' and self.cross_residual_attn:
+                prev_cross_attn = inter.pre_softmax_attn
+
+            if exists(post_main_norm):
+                x = post_main_norm(x)
+
+        if return_hiddens:
+            layer_hiddens.append(x)
+
+        if self.resi_dual:
+            x = x + self.final_norm(outer_residual)
+        else:
+            x = self.final_norm(x)
+
+        if not return_hiddens:
+            return x
+
+        intermediates = LayerIntermediates(
+            hiddens = hiddens,
+            attn_intermediates = intermediates,
+            layer_hiddens = layer_hiddens
+        )
+
+        return x, intermediates
+
+class Encoder(AttentionLayers):
+    def __init__(self, **kwargs):
+        assert 'causal' not in kwargs, 'cannot set causality on encoder'
+        super().__init__(causal = False, **kwargs)
+
+class Decoder(AttentionLayers):
+    def __init__(self, **kwargs):
+        assert 'causal' not in kwargs, 'cannot set causality on decoder'
+        super().__init__(causal = True, **kwargs)
+
+class CrossAttender(AttentionLayers):
+    def __init__(self, **kwargs):
+        super().__init__(cross_attend = True, only_cross = True, **kwargs)
+
+class ViTransformerWrapper(nn.Module):
+    def __init__(
+        self,
+        *,
+        image_size,
+        patch_size,
+        attn_layers,
+        channels = 3,
+        num_classes = None,
+        post_emb_norm = False,
+        num_register_tokens = 0,
+        emb_dropout = 0.
+    ):
+        super().__init__()
+        assert isinstance(attn_layers, Encoder), 'attention layers must be an Encoder'
+        assert divisible_by(image_size, patch_size), 'image dimensions must be divisible by the patch size'
+        dim = attn_layers.dim
+        num_patches = (image_size // patch_size) ** 2
+        patch_dim = channels * patch_size ** 2
+
+        self.patch_size = patch_size
+
+        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches, dim))
+
+        has_register_tokens = num_register_tokens > 0
+        self.has_register_tokens = has_register_tokens
+
+        if has_register_tokens:
+            self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim))
+
+        self.patch_to_embedding = nn.Sequential(
+            nn.LayerNorm(patch_dim),
+            nn.Linear(patch_dim, dim),
+            nn.LayerNorm(dim)
+        )
+
+        self.post_emb_norm = nn.LayerNorm(dim) if post_emb_norm else nn.Identity()
+        self.dropout = nn.Dropout(emb_dropout)
+
+        self.attn_layers = attn_layers
+
+        self.mlp_head = nn.Linear(dim, num_classes) if exists(num_classes) else nn.Identity()
+
+    def forward(
+        self,
+        img,
+        return_embeddings = False
+    ):
+        b, p = img.shape[0], self.patch_size
+
+        x = rearrange(img, 'b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = p, p2 = p)
+        x = self.patch_to_embedding(x)
+        n = x.shape[1]
+
+        x = x + self.pos_embedding[:, :n]
+
+        x = self.post_emb_norm(x)
+        x = self.dropout(x)
+
+        if self.has_register_tokens:
+            r = repeat(self.register_tokens, 'n d -> b n d', b = b)
+            x, ps = pack((x, r), 'b * d')
+
+        x = self.attn_layers(x)
+
+        if self.has_register_tokens:
+            x, _ = unpack(x, ps, 'b * d')
+
+        if not exists(self.mlp_head) or return_embeddings:
+            return x
+
+        x = x.mean(dim = -2)
+        return self.mlp_head(x)
+
+class TransformerWrapper(nn.Module):
+    def __init__(
+        self,
+        *,
+        num_tokens,
+        max_seq_len,
+        attn_layers,
+        emb_dim = None,
+        max_mem_len = 0,
+        shift_mem_down = 0,
+        emb_dropout = 0.,
+        post_emb_norm = False,
+        num_memory_tokens = None,
+        memory_tokens_interspersed_every = None,
+        tie_embedding = False,
+        logits_dim = None,
+        use_abs_pos_emb = True,
+        scaled_sinu_pos_emb = False,
+        l2norm_embed = False,
+        emb_frac_gradient = 1., # GLM-130B and Cogview successfully used this, set at 0.1
+        attn_z_loss_weight = 1e-4,
+    ):
+        super().__init__()
+        assert isinstance(attn_layers, AttentionLayers), 'attention layers must be one of Encoder or Decoder'
+
+        dim = attn_layers.dim
+        emb_dim = default(emb_dim, dim)
+        self.emb_dim = emb_dim
+        self.num_tokens = num_tokens
+
+        self.max_seq_len = max_seq_len
+        self.max_mem_len = max_mem_len
+        self.shift_mem_down = shift_mem_down
+
+        self.l2norm_embed = l2norm_embed
+        self.token_emb = TokenEmbedding(emb_dim, num_tokens, l2norm_embed = l2norm_embed)
+
+        if not (use_abs_pos_emb and not attn_layers.has_pos_emb):
+            self.pos_emb = always(0)
+        elif scaled_sinu_pos_emb:
+            self.pos_emb = ScaledSinusoidalEmbedding(emb_dim)
+        else:
+            self.pos_emb = AbsolutePositionalEmbedding(emb_dim, max_seq_len, l2norm_embed = l2norm_embed)
+
+        self.emb_frac_gradient = emb_frac_gradient # fraction of the gradient that should go to the embedding, https://arxiv.org/abs/2105.13290
+
+        self.post_emb_norm = nn.LayerNorm(emb_dim) if post_emb_norm else nn.Identity()
+        self.emb_dropout = nn.Dropout(emb_dropout)
+
+        self.project_emb = nn.Linear(emb_dim, dim) if emb_dim != dim else nn.Identity()
+        self.attn_layers = attn_layers
+
+        self.init_()
+
+        logits_dim = default(logits_dim, num_tokens)
+        self.to_logits = nn.Linear(dim, logits_dim) if not tie_embedding else lambda t: t @ self.token_emb.emb.weight.t()
+
+        # memory tokens (like [cls]) from Memory Transformers paper
+
+        num_memory_tokens = default(num_memory_tokens, 0)
+        self.num_memory_tokens = num_memory_tokens
+        if num_memory_tokens > 0:
+            self.memory_tokens = nn.Parameter(torch.randn(num_memory_tokens, dim))
+
+        self.memory_tokens_interspersed_every = memory_tokens_interspersed_every
+
+        # whether can do cached kv decoding
+
+        self.can_cache_kv = self.num_memory_tokens == 0
+
+    def init_(self):
+        if self.l2norm_embed:
+            nn.init.normal_(self.token_emb.emb.weight, std = 1e-5)
+            if not isinstance(self.pos_emb, always):
+                nn.init.normal_(self.pos_emb.emb.weight, std = 1e-5)
+            return
+
+        nn.init.kaiming_normal_(self.token_emb.emb.weight)
+
+    def forward(
+        self,
+        x,
+        return_embeddings = False,
+        return_logits_and_embeddings = False,
+        return_intermediates = False,
+        mask = None,
+        return_mems = False,
+        return_attn = False,
+        mems = None,
+        pos = None,
+        prepend_embeds = None,
+        sum_embeds = None,
+        return_attn_z_loss = False,
+        attn_z_loss_weight = 1e-4,
+        seq_start_pos = None,
+        cache: Optional[LayerIntermediates] = None,
+        **kwargs
+    ):
+        b, n, device, num_mems, has_memory_tokens, emb_frac_gradient = *x.shape, x.device, self.num_memory_tokens, self.num_memory_tokens > 0, self.emb_frac_gradient
+        return_hiddens = return_mems | return_attn | return_intermediates | return_attn_z_loss
+
+        # absolute positional embedding
+
+        external_pos_emb = exists(pos) and pos.dtype != torch.long
+        pos_emb = self.pos_emb(x, pos = pos, seq_start_pos = seq_start_pos) if not external_pos_emb else pos
+        x = self.token_emb(x) + pos_emb
+
+        # for summing embeddings passed externally - needs this for self-conditioning in non-autoregressive training
+
+        if exists(sum_embeds):
+            x = x + sum_embeds
+
+        # post embedding norm, purportedly leads to greater stabilization
+
+        x = self.post_emb_norm(x)
+
+        # whether to append embeds, as in PaLI, for image embeddings
+
+        if exists(prepend_embeds):
+            prepend_seq, prepend_dim = prepend_embeds.shape[1:]
+            assert prepend_dim == x.shape[-1], 'prepended embeddings need to have same dimensions as text model dimensions'
+
+            x = torch.cat((prepend_embeds, x), dim = -2)
+
+        # whether to reduce the gradient going to the embedding, from cogview paper, corroborated by GLM-130B model
+
+        if emb_frac_gradient < 1:
+            assert emb_frac_gradient > 0
+            x = x * emb_frac_gradient + x.detach() * (1 - emb_frac_gradient)
+
+        # embedding dropout
+
+        x = self.emb_dropout(x)
+
+        x = self.project_emb(x)
+
+        if has_memory_tokens:
+            mem_every = self.memory_tokens_interspersed_every
+
+            if exists(mem_every):
+                assert mem_every > 0
+                assert isinstance(self.attn_layers, Decoder), 'only for decoder'
+                next_seq_len = math.ceil(n / mem_every) * mem_every
+
+                x = pad_at_dim(x, (0, next_seq_len - n), dim = -2, value = 0.)
+                x = rearrange(x, 'b (n m) d -> (b n) m d', m = mem_every)
+
+            mem = repeat(self.memory_tokens, 'n d -> b n d', b = x.shape[0])
+            x, mem_packed_shape = pack((mem, x), 'b * d')
+
+            # auto-handle masking after appending memory tokens
+            if not exists(mem_every) and exists(mask):
+                mask = pad_at_dim(mask, (num_mems, 0), dim = -1, value = True)
+
+            if exists(mem_every):
+                x = rearrange(x, '(b n) m d -> b (n m) d', b = b)
+
+        if self.shift_mem_down and exists(mems):
+            mems_l, mems_r = mems[:self.shift_mem_down], mems[self.shift_mem_down:]
+            mems = [*mems_r, *mems_l]
+
+        x, intermediates = self.attn_layers(x, mask = mask, mems = mems, cache = cache, return_hiddens = True, seq_start_pos = seq_start_pos, **kwargs)
+
+        if has_memory_tokens:
+            if exists(mem_every):
+                x = rearrange(x, 'b (n m) d -> (b n) m d', m = (mem_every + num_mems))
+
+            mem, x = unpack(x, mem_packed_shape, 'b * d')
+
+            if exists(mem_every):
+                x = rearrange(x, '(b n) m d -> b (n m) d', b = b)
+
+            x = x[:, :n]
+
+        if return_logits_and_embeddings:
+            out = (self.to_logits(x), x)
+        elif return_embeddings:
+            out = x
+        else:
+            out = self.to_logits(x)
+
+        if return_attn_z_loss:
+            pre_softmax_attns = list(map(lambda t: t.pre_softmax_attn, intermediates.attn_intermediates))
+            intermediates.attn_z_loss = calc_z_loss(pre_softmax_attns, weight = attn_z_loss_weight)
+            return_intermediates = True
+
+        if return_mems:
+            hiddens = intermediates.hiddens
+            new_mems = list(map(lambda pair: torch.cat(pair, dim = -2), zip(mems, hiddens))) if exists(mems) else hiddens
+            new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), new_mems))
+
+            if not return_intermediates:
+                return out, new_mems
+
+            intermediates.mems = new_mems
+
+        if return_intermediates:
+            return out, intermediates
+
+        if return_attn:
+            attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates))
+            return out, attn_maps
+
+        return out
+
+class ContinuousTransformerWrapper(nn.Module):
+    def __init__(
+        self,
+        *,
+        max_seq_len,
+        attn_layers,
+        dim_in = None,
+        dim_out = None,
+        emb_dim = None,
+        max_mem_len = 0,
+        post_emb_norm = False,
+        emb_dropout = 0.,
+        use_abs_pos_emb = True,
+        scaled_sinu_pos_emb = False
+    ):
+        super().__init__()
+        assert isinstance(attn_layers, AttentionLayers), 'attention layers must be one of Encoder or Decoder'
+
+        dim = attn_layers.dim
+
+        self.max_seq_len = max_seq_len
+
+        self.max_mem_len = max_mem_len
+
+        if not (use_abs_pos_emb and not attn_layers.has_pos_emb):
+            self.pos_emb = always(0)
+        elif scaled_sinu_pos_emb:
+            self.pos_emb = ScaledSinusoidalEmbedding(dim)
+        else:
+            self.pos_emb = AbsolutePositionalEmbedding(dim, max_seq_len)
+
+        self.post_emb_norm = nn.LayerNorm(dim) if post_emb_norm else nn.Identity()
+        self.emb_dropout = nn.Dropout(emb_dropout)
+
+        self.project_in = nn.Linear(dim_in, dim) if exists(dim_in) else nn.Identity()
+
+        self.attn_layers = attn_layers
+
+        self.project_out = nn.Linear(dim, dim_out) if exists(dim_out) else nn.Identity()
+
+    def forward(
+        self,
+        x,
+        return_embeddings = False,
+        return_intermediates = False,
+        return_mems = False,
+        mask = None,
+        return_attn = False,
+        mems = None,
+        pos = None,
+        prepend_embeds = None,
+        **kwargs
+    ):
+        x = self.project_in(x)
+        x = x + self.pos_emb(x, pos = pos)
+
+        x = self.post_emb_norm(x)
+
+        # whether to append embeds, as in PaLI, for image embeddings
+
+        if exists(prepend_embeds):
+            _, prepend_dim = prepend_embeds.shape[1:]
+            assert prepend_dim == x.shape[-1], 'prepended embeddings need to have same dimensions as model dimensions'
+
+            x = torch.cat((prepend_embeds, x), dim = -2)
+
+        x = self.emb_dropout(x)
+
+        x, intermediates = self.attn_layers(x, mask = mask, mems = mems, return_hiddens = True, **kwargs)
+
+        out = self.project_out(x) if not return_embeddings else x
+
+        if return_intermediates:
+            return out, intermediates
+
+        if return_mems:
+            hiddens = intermediates.hiddens
+            new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), hiddens))
+            return out, new_mems
+
+        if return_attn:
+            attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates))
+            return out, attn_maps
+
+        return out
+
+class XTransformer(nn.Module):
+    def __init__(
+        self,
+        *,
+        dim,
+        tie_token_emb = False,
+        ignore_index = -100,
+        pad_value = 0,
+        cross_attn_tokens_dropout = 0.,
+        **kwargs
+    ):
+        super().__init__()
+        enc_kwargs, kwargs = groupby_prefix_and_trim('enc_', kwargs)
+        dec_kwargs, kwargs = groupby_prefix_and_trim('dec_', kwargs)
+
+        assert 'dim' not in enc_kwargs and 'dim' not in dec_kwargs, 'dimension of either encoder or decoder must be set with `dim` keyword'
+        enc_transformer_kwargs = pick_and_pop(['num_tokens', 'max_seq_len'], enc_kwargs)
+        enc_transformer_kwargs['emb_dropout'] = enc_kwargs.pop('emb_dropout', 0)
+        enc_transformer_kwargs['num_memory_tokens'] = enc_kwargs.pop('num_memory_tokens', None)
+        enc_transformer_kwargs['scaled_sinu_pos_emb'] = enc_kwargs.pop('scaled_sinu_pos_emb', False)
+        enc_transformer_kwargs['use_abs_pos_emb'] = enc_kwargs.pop('use_abs_pos_emb', True)
+
+        dec_transformer_kwargs = pick_and_pop(['num_tokens', 'max_seq_len'], dec_kwargs)
+        dec_transformer_kwargs['emb_dropout'] = dec_kwargs.pop('emb_dropout', 0)
+        dec_transformer_kwargs['scaled_sinu_pos_emb'] = dec_kwargs.pop('scaled_sinu_pos_emb', False)
+        dec_transformer_kwargs['use_abs_pos_emb'] = dec_kwargs.pop('use_abs_pos_emb', True)
+
+        self.cross_attn_tokens_dropout = cross_attn_tokens_dropout  # how many tokens from the encoder to dropout when cross attending from decoder - seen in a couple papers, including Perceiver AR - this will also be very effective regularization when cross attending to very long memories
+
+        self.encoder = TransformerWrapper(
+            **enc_transformer_kwargs,
+            attn_layers = Encoder(dim = dim, **enc_kwargs)
+        )
+
+        self.decoder = TransformerWrapper(
+            **dec_transformer_kwargs,
+            attn_layers = Decoder(dim = dim, cross_attend = True, **dec_kwargs)
+        )
+
+        if tie_token_emb:
+            self.decoder.token_emb = self.encoder.token_emb
+
+        self.decoder = AutoregressiveWrapper(self.decoder, ignore_index=ignore_index, pad_value=pad_value)
+
+    @torch.no_grad()
+    def generate(self, seq_in, seq_out_start, seq_len, mask = None, attn_mask = None, **kwargs):
+        encodings = self.encoder(seq_in, mask = mask, attn_mask = attn_mask, return_embeddings = True)
+        return self.decoder.generate(seq_out_start, seq_len, context = encodings, context_mask = mask, **kwargs)
+
+    def forward(self, src, tgt, mask = None, attn_mask = None, src_prepend_embeds = None):
+
+        if exists(src_prepend_embeds) and exists(mask):
+            mask = pad_at_dim(mask, (src_prepend_embeds.shape[-2], 0), dim = -1, value = True)
+
+        enc = self.encoder(src, mask = mask, attn_mask = attn_mask, prepend_embeds = src_prepend_embeds, return_embeddings = True)
+
+        if self.training and self.cross_attn_tokens_dropout > 0:
+            enc, mask = dropout_seq(enc, mask, self.cross_attn_tokens_dropout)
+
+        out = self.decoder(tgt, context = enc, context_mask = mask)
+        return out

x_transformer_1_27_16.py

@@ -21,7 +21,16 @@ r'''############################################################################
 #
 # !pip install torch
 # !pip install einops
-# !pip install matplotlib
+#
+#===============================================================================
+#
+# Basic use example
+#
+# from x_transformer_1_27_16 import *
+#
+# model = instantiate_x_transformer_model()
+# save_x_transformer_model(model)
+# load_x_transformer_model('model_checkpoint_1_epochs_1_steps_0_loss_1_acc.pth')
 #
 #===============================================================================
 '''
@@ -3046,11 +3055,7 @@ class AutoregressiveWrapper(Module):
 
         # sampling up to seq_len
 
-        
-
         for sl in range(seq_len):
-          
-          try:
 
             if restrict_to_max_seq_len:
                 max_len_exceeded = out.shape[-1] > max_seq_len
@@ -3124,14 +3129,6 @@ class AutoregressiveWrapper(Module):
                 print('Model called the end of sequence at:', sl, '/', seq_len)
               break
 
-          except KeyboardInterrupt:
-            print('Stopping generation...')
-            break
-          
-          except Exception as e:
-            print('Error:', e)
-            break
-
         if exists(eos_token):
             # mask out everything after the eos tokens
             shifted_is_eos_tokens = F.pad(is_eos_tokens, (1, -1))
@@ -3659,11 +3656,11 @@ import importlib
 
 #===============================================================================
 
-def instantiate_x_transformer_model(max_seq_len,
-                                    num_tokens,
+def instantiate_x_transformer_model(num_tokens=20000,
+                                    max_seq_len=8192,
                                     dim=1024,
-                                    depth=4,
-                                    heads=8,
+                                    depth=32,
+                                    heads=32,
                                     attn_flash=True,
                                     ignore_index=-1,
                                     verbose=True):
@@ -3686,10 +3683,7 @@ def instantiate_x_transformer_model(max_seq_len,
                                   ignore_index=ignore_index
                                   )
 
-    if torch.cuda.is_available():
-      model.cuda()
-    else:
-      model.cpu()
+    model.cuda()
 
     if verbose:
       print('Done!')
@@ -3700,12 +3694,14 @@ def instantiate_x_transformer_model(max_seq_len,
 #===============================================================================
 
 def save_x_transformer_model(model,
-                              number_of_tokens,
-                              max_seq_len,
+                              checkpoint_dir='./',
+                              checkpoint_name='model_checkpoint', 
+                              number_of_tokens=20000, 
+                              ignore_index=-1, 
+                              max_seq_len=8192, 
                               dim=1024, 
-                              depth=4, 
-                              heads=8,
-                              ignore_index=-1,
+                              depth=32, 
+                              heads=32, 
                               use_flash_attn=True,
                               batch_size=4,
                               grad_acc_rate=4,
@@ -3714,8 +3710,6 @@ def save_x_transformer_model(model,
                               num_steps=1,
                               loss=0,
                               accuracy=1,
-                              checkpoint_dir='./',
-                              checkpoint_name='model_checkpoint',
                               verbose=True
                             ):
     
@@ -3783,11 +3777,7 @@ def load_x_transformer_model(checkpoint_file_path,
                                           attn_layers=attn_layers)
     model = class_(transformer_model, ignore_index=checkpoint['ignore_index'])
     model.load_state_dict(checkpoint['model_state_dict'])
-
-    if torch.cuda.is_available():
-      model.cuda()
-    else:
-      model.cpu()
+    model.cuda()
 
     if verbose:
       print('Done!')
@@ -3809,367 +3799,6 @@ def load_x_transformer_model(checkpoint_file_path,
       print('Model accuracy:', checkpoint['accuracy'])
       print('=' * 70)
 
-      return model
-
-################################################################################
-
-def generate_from_x_transformer_model(model=None, 
-                                      num_tokens_to_generate=32,
-                                      prime_tokens_list=[0],
-                                      return_prime=False,
-                                      batch_size=1,
-                                      temperature=0.9,
-                                      precision='bfloat16',
-                                      device='cuda',
-                                      verbose=True
-                                      ):
-  
-    if model is not None:
-    
-      device_options = ['cuda', 'cpu', 'cuda:0']
-      
-      if device not in device_options or not torch.cuda.is_available():
-        device_type = 'cpu'
-      else:
-        device_type = device
-      
-      precision_options = ['float32', 'bfloat16', 'float16']
-
-      if precision == 'bfloat16' and device_type != 'cpu' and not torch.cuda.is_bf16_supported():
-        precision = 'float16'
-
-      if precision in precision_options:
-        ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[precision]
-      else:
-        ptdtype = torch.bfloat16
-
-      ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)
-
-      model.to(device_type)
-
-      model.eval()
-
-      if verbose:
-        print('=' * 70)
-        print('Generation information')
-        print('=' * 70)
-        print('Device:', device)
-        print('Precision:', precision)
-        print('=' * 70)
-        print('Prime tokens sample:', prime_tokens_list[:10])
-        print('=' * 70)
-        print('Model will generate', batch_size, 'batches', num_tokens_to_generate, 'tokens each', )
-        print('Total number of tokens to generate:', num_tokens_to_generate * batch_size)
-        print('=' * 70)
-        print('Model temeperature', temperature)
-        print('=' * 70)
-
-      input = torch.tensor([prime_tokens_list] * batch_size, dtype=torch.long, device=device_type)
-
-      with ctx:
-        out = model.generate(input,
-                              num_tokens_to_generate,
-                              temperature=temperature,
-                              return_prime=return_prime,
-                              verbose=verbose
-                            )
-      if verbose:  
-        print('=' * 70)
-        print('Done!')
-        print('=' * 70)
-
-      return out.tolist()
-    
-    else:
-      print('=' * 70)
-      print('Please check the model!')
-      print('=' * 70)
-
-################################################################################
-
-from torch.utils.data import Dataset
-
-class X_Transformer_Dataset(Dataset):
-    def __init__(self, data, seq_len, batch_size):
-        super().__init__()
-        self.data = data
-        self.seq_len = seq_len
-        self.batch_size = batch_size
-
-    def __getitem__(self, index):
-
-        full_seq = torch.Tensor(self.data[index][:self.seq_len+1]).long()
-
-        return full_seq.cuda()
-
-    def __len__(self):
-        return (len(self.data) // self.batch_size) * self.batch_size
-
-################################################################################
-
-import tqdm
-import pickle
-import matplotlib.pyplot as plt
-
-#===============================================================================
-
-def save_data(data, filename):
-    with open(filename, 'wb') as f:
-      pickle.dump(data, f)
-
-def cycle_train_data(loader):
-    while True:
-        for data in loader:
-            yield data
-
-def default_output_func(output):
-    print(output)
-
-#===============================================================================
-
-def train_x_transformer_model(model,
-                              model_sequence_length,
-                              model_number_of_tokens,
-                              model_name,
-                              training_data,
-                              model_ignore_index=-1,
-                              model_dimension=1024,
-                              model_depth=4,
-                              model_number_of_heads=8,
-                              model_uses_flash_attention=True,
-                              training_data_batch_size=1,
-                              training_learning_rate=1e-4,
-                              accumulate_gradients_every=4,
-                              number_of_training_epochs=1,
-                              validate_every=100,
-                              save_every=500,
-                              generate_every=100,
-                              generate_length=100,
-                              generate_num_prime_tokens=512,
-                              generate_output_custom_func=default_output_func,
-                              print_stats_every=20,
-                              device='cuda',
-                              precision='float16',
-                              clip_grad_norm_value=1.0,
-                              scaler_enabled=True,
-                              save_directory='./',
-                              plot_statistics=True,
-                              verbose=True
-                              ):
-
-    #===========================================================================
-
-    device_options = ['cuda', 'cpu', 'cuda:0']
-    
-    if device not in device_options or not torch.cuda.is_available():
-      device_type = 'cpu'
-    else:
-      device_type = device
-    
-    precision_options = ['float32', 'bfloat16', 'float16']
-
-    if precision == 'bfloat16' and device_type != 'cpu' and not torch.cuda.is_bf16_supported():
-      precision = 'float16'
-
-    if precision in precision_options:
-      ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[precision]
-    else:
-      ptdtype = torch.bfloat16
-
-    ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)
-
-    model.to(device_type)
-
-    optim = torch.optim.Adam(model.parameters(), lr=training_learning_rate)
-
-    scaler = torch.cuda.amp.GradScaler(enabled=scaler_enabled)
-
-    #===========================================================================
-
-    train_losses = []
-    val_losses = []
-
-    train_accs = []
-    val_accs = []
-
-    nsteps = 0
-
-    for ep in range(number_of_training_epochs):
-
-      print('=' * 70)
-      print('Epoch #', ep)
-      print('=' * 70)
-
-      random.shuffle(training_data)
-
-      train_dataset = X_Transformer_Dataset(training_data, model_sequence_length, training_data_batch_size)
-      val_dataset   = X_Transformer_Dataset(training_data, model_sequence_length, training_data_batch_size)
-      train_loader  = cycle_train_data(DataLoader(train_dataset, batch_size = training_data_batch_size))
-      val_loader    = cycle_train_data(DataLoader(val_dataset, batch_size = training_data_batch_size))
-
-      NUM_BATCHES = len(training_data) // training_data_batch_size // accumulate_gradients_every
-
-      for i in tqdm.tqdm(range(NUM_BATCHES), mininterval=10., desc='Training'):
-          model.train()
-
-          for __ in range(accumulate_gradients_every):
-              with ctx:
-                  loss, acc = model(next(train_loader))
-              loss = loss / accumulate_gradients_every
-              scaler.scale(loss).backward(torch.ones(loss.shape).cuda())
-
-          if i % print_stats_every == 0:
-              print(f'Training loss: {loss.mean().item() * accumulate_gradients_every}')
-              print(f'Training acc: {acc.mean().item()}')
-
-          train_losses.append(loss.mean().item() * accumulate_gradients_every)
-          train_accs.append(acc.mean().item())
-
-          scaler.unscale_(optim)
-          torch.nn.utils.clip_grad_norm_(model.parameters(), clip_grad_norm_value)
-          scaler.step(optim)
-          scaler.update()
-          optim.zero_grad(set_to_none=True)
-
-          nsteps += 1
-
-          if i % validate_every == 0:
-            model.eval()
-            with torch.no_grad():
-              with ctx:
-                val_loss, val_acc = model(next(val_loader))
-
-                print(f'Validation loss: {val_loss.mean().item()}')
-                print(f'Validation acc: {val_acc.mean().item()}')
-
-                val_losses.append(val_loss.mean().item())
-                val_accs.append(val_acc.mean().item())
-
-                if plot_statistics:
-
-                  print('Plotting training loss graph...')
-
-                  tr_loss_list = train_losses
-                  plt.plot([i for i in range(len(tr_loss_list))] ,tr_loss_list, 'b')
-                  plt.show()
-                  plt.close()
-                  print('Done!')
-
-                  print('Plotting training acc graph...')
-
-                  tr_loss_list = train_accs
-                  plt.plot([i for i in range(len(tr_loss_list))] ,tr_loss_list, 'b')
-                  plt.show()
-                  plt.close()
-                  print('Done!')
-
-                  print('Plotting validation loss graph...')
-                  tr_loss_list = val_losses
-                  plt.plot([i for i in range(len(tr_loss_list))] ,tr_loss_list, 'b')
-                  plt.show()
-                  plt.close()
-                  print('Done!')
-
-                  print('Plotting validation acc graph...')
-                  tr_loss_list = val_accs
-                  plt.plot([i for i in range(len(tr_loss_list))] ,tr_loss_list, 'b')
-                  plt.show()
-                  plt.close()
-                  print('Done!')
-          
-          #=====================================================================
-
-          if i % generate_every == 0:
-            model.eval()
-
-            inp = random.choice(val_dataset)[:generate_num_prime_tokens]
-
-            print(inp)
-
-            with ctx:
-
-                sample = model.generate(inp[None, ...], generate_length)
-
-            generate_output_custom_func(sample.tolist())
-
-          #=====================================================================
-
-          if i % save_every == 0:
-
-              print('Saving model progress. Please wait...')
-              print('model_checkpoint_' + str(nsteps) + '_steps_' + str(round(float(train_losses[-1]), 4)) + '_loss_' + str(round(float(train_accs[-1]), 4)) + '_acc.pth')
-
-              fname = save_directory+'/model_checkpoint_' + str(nsteps) + '_steps_' + str(round(float(train_losses[-1]), 4)) + '_loss_' + str(round(float(train_accs[-1]), 4)) + '_acc.pth'
-
-              save_x_transformer_model(model, 
-                                       checkpoint_dir=save_directory, 
-                                       checkpoint_name=model_name,
-                                       number_of_tokens=model_number_of_tokens,
-                                       ignore_index=model_ignore_index,
-                                       max_seq_len=model_sequence_length,
-                                       dim=model_dimension,
-                                       depth=model_depth,
-                                       heads=model_number_of_heads,
-                                       use_flash_attn=model_uses_flash_attention,
-                                       batch_size=training_data_batch_size,
-                                       grad_acc_rate=accumulate_gradients_every,
-                                       learning_rate=training_learning_rate,
-                                       num_epochs=number_of_training_epochs,
-                                       num_steps=nsteps,
-                                       loss=str(round(float(train_losses[-1]), 4)),
-                                       accuracy=str(round(float(train_accs[-1]), 4)),
-                                       verbose=verbose)
-
-              data = [train_losses, train_accs, val_losses, val_accs]
-
-              save_data(data, save_directory+'losses_accuracies.pickle')
-
-              print('Done!')
-
-    #===========================================================================
-
-    print('Saving model progress. Please wait...')
-    print('model_checkpoint_' + str(nsteps) + '_steps_' + str(round(float(train_losses[-1]), 4)) + '_loss_' + str(round(float(train_accs[-1]), 4)) + '_acc.pth')
-
-    fname = save_directory+'model_checkpoint_' + str(nsteps) + '_steps_' + str(round(float(train_losses[-1]), 4)) + '_loss_' + str(round(float(train_accs[-1]), 4)) + '_acc.pth'
-
-    torch.save(model.state_dict(), fname)
-
-    print('Done!')
-
-    data = [train_losses, train_accs, val_losses, val_accs]
-
-    save_data(data, save_directory+'losses_accuracies')
-
-    # Save training loss graph
-
-    plt.plot([i for i in range(len(train_losses))] ,train_losses, 'b')
-    plt.savefig(save_directory+'training_loss_graph.png')
-    plt.close()
-    print('Done!')
-
-    # Save training acc graph
-
-    plt.plot([i for i in range(len(train_accs))] ,train_accs, 'b')
-    plt.savefig(save_directory+'training_accuracy_graph.png')
-    plt.close()
-    print('Done!')
-
-    # Save validation loss graph
-
-    plt.plot([i for i in range(len(val_losses))] ,val_losses, 'b')
-    plt.savefig(save_directory+'validation_loss_graph.png')
-    plt.close()
-    print('Done!')
-
-    # Save validation acc graph
-
-    plt.plot([i for i in range(len(val_accs))] ,val_accs, 'b')
-    plt.savefig(save_directory+'validation_accuracy_graph.png')
-    plt.close()
-    print('Done!')
-    
 ################################################################################
-
 # This is the end of x-transformer Python module
 ################################################################################