Initial commit of server files

__init__.py

@@ -0,0 +1 @@
+# This file makes the directory a Python package.

app.py

@@ -0,0 +1,128 @@
+from flask import Flask, request, jsonify
+import numpy as np
+import json
+from .music_generator import MusicGenerator
+
+app = Flask(__name__)
+
+# Load the consonance matrix
+with open('/home/KidIkaros/Documents/code/Ikaros/musick/chord_detector_extension/consonance_matrix.json') as f:
+    consonance_matrix = np.array(json.load(f))
+
+notes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+generator = MusicGenerator(len(notes))
+
+def note_to_index(note):
+    return notes.index(note.split(':')[0])
+
+def index_to_note(index):
+    return notes[index]
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    data = request.get_json()
+    history = data.get('history', [])
+
+    if len(history) < 1:
+        return jsonify({'prediction': 'N/A'})
+
+    try:
+        last_note_index = note_to_index(history[-1]['chord'])
+        prediction_index = generator.generate([last_note_index], length=1)[-1]
+        prediction = index_to_note(prediction_index)
+    except (ValueError, IndexError):
+        prediction = 'N/A'
+
+    return jsonify({'prediction': prediction})
+
+@app.route('/generate', methods=['POST'])
+def generate():
+    data = request.get_json()
+    start_sequence_indices = [note_to_index(note) for note in data.get('start_sequence', [])]
+    length = data.get('length', 10)
+
+    if not start_sequence_indices:
+        return jsonify({'generated_sequence': []})
+
+    generated_indices = generator.generate(start_sequence_indices, length)
+    generated_notes = [index_to_note(i) for i in generated_indices]
+    return jsonify({'generated_sequence': generated_notes})
+
+
+@app.route('/analyze_harmony', methods=['POST'])
+def analyze_harmony():
+    data = request.get_json()
+    history = data.get('history', [])
+
+    if len(history) < 2:
+        return jsonify({'harmony_scores': []})
+
+    harmony_scores = []
+    for i in range(len(history) - 1):
+        try:
+            note1_index = note_to_index(history[i]['chord'])
+            note2_index = note_to_index(history[i+1]['chord'])
+            score = consonance_matrix[note1_index, note2_index]
+            harmony_scores.append(score)
+        except (ValueError, IndexError):
+            # Handle cases where a chord is not in our 'notes' list (e.g., 'N')
+            harmony_scores.append(0) # Assign a neutral score
+
+    return jsonify({'harmony_scores': harmony_scores})
+
+@app.route('/what_if', methods=['POST'])
+def what_if():
+    data = request.get_json()
+    history = data.get('history', [])
+    suggestion_index = data.get('suggestion')
+
+    if len(history) < 1 or suggestion_index is None:
+        return jsonify({'harmony_score': 0})
+
+    try:
+        last_note_index = note_to_index(history[-1]['chord'])
+        score = consonance_matrix[last_note_index, suggestion_index]
+    except (ValueError, IndexError):
+        score = 0
+
+    return jsonify({'harmony_score': score})
+
+
+from sklearn.decomposition import PCA
+
+@app.route('/song_fingerprint', methods=['POST'])
+def song_fingerprint():
+    data = request.get_json()
+    history = data.get('history', [])
+
+    if len(history) < 3:
+        return jsonify({'fingerprint': []})
+
+    # Create a matrix of chord transitions
+    transitions = []
+    for i in range(len(history) - 1):
+        try:
+            note1_index = note_to_index(history[i]['chord'])
+            note2_index = note_to_index(history[i+1]['chord'])
+            transitions.append([note1_index, note2_index])
+        except (ValueError, IndexError):
+            pass
+
+    if len(transitions) < 3:
+        return jsonify({'fingerprint': []})
+
+    # Use PCA to reduce to 3 dimensions
+    pca = PCA(n_components=3)
+    fingerprint = pca.fit_transform(transitions).tolist()
+
+    return jsonify({'fingerprint': fingerprint})
+
+
+if __name__ == '__main__':
+    # Train the generator on some dummy data
+    sequences = [
+        [0, 4, 7, 0], # Cmaj -> C
+        [5, 9, 0, 5]  # Fmaj -> F
+    ]
+    generator.train(sequences)
+    app.run(port=5000)

consonance_matrix.json

@@ -0,0 +1,170 @@
+[
+  [
+    10,
+    -8,
+    -4,
+    5,
+    6,
+    4,
+    -10,
+    4,
+    6,
+    5,
+    -4,
+    -8
+  ],
+  [
+    -8,
+    10,
+    -8,
+    -4,
+    5,
+    6,
+    4,
+    -10,
+    4,
+    6,
+    5,
+    -4
+  ],
+  [
+    -4,
+    -8,
+    10,
+    -8,
+    -4,
+    5,
+    6,
+    4,
+    -10,
+    4,
+    6,
+    5
+  ],
+  [
+    5,
+    -4,
+    -8,
+    10,
+    -8,
+    -4,
+    5,
+    6,
+    4,
+    -10,
+    4,
+    6
+  ],
+  [
+    6,
+    5,
+    -4,
+    -8,
+    10,
+    -8,
+    -4,
+    5,
+    6,
+    4,
+    -10,
+    4
+  ],
+  [
+    4,
+    6,
+    5,
+    -4,
+    -8,
+    10,
+    -8,
+    -4,
+    5,
+    6,
+    4,
+    -10
+  ],
+  [
+    -10,
+    4,
+    6,
+    5,
+    -4,
+    -8,
+    10,
+    -8,
+    -4,
+    5,
+    6,
+    4
+  ],
+  [
+    4,
+    -10,
+    4,
+    6,
+    5,
+    -4,
+    -8,
+    10,
+    -8,
+    -4,
+    5,
+    6
+  ],
+  [
+    6,
+    4,
+    -10,
+    4,
+    6,
+    5,
+    -4,
+    -8,
+    10,
+    -8,
+    -4,
+    5
+  ],
+  [
+    5,
+    6,
+    4,
+    -10,
+    4,
+    6,
+    5,
+    -4,
+    -8,
+    10,
+    -8,
+    -4
+  ],
+  [
+    -4,
+    5,
+    6,
+    4,
+    -10,
+    4,
+    6,
+    5,
+    -4,
+    -8,
+    10,
+    -8
+  ],
+  [
+    -8,
+    -4,
+    5,
+    6,
+    4,
+    -10,
+    4,
+    6,
+    5,
+    -4,
+    -8,
+    10
+  ]
+]

harmony_matrix_generator.py

@@ -0,0 +1,51 @@
+import json
+import numpy as np
+
+def generate_consonance_matrix():
+    """
+    Generates a 12x12 matrix representing the consonance/dissonance
+    between the 12 notes of the chromatic scale.
+    """
+    # Scores based on music theory (higher is more consonant)
+    # These values are chosen to represent relative consonance and dissonance.
+    interval_scores = {
+        0: 10,  # Unison
+        1: -8,  # Minor Second (dissonant)
+        2: -4,  # Major Second (dissonant)
+        3: 5,   # Minor Third (consonant)
+        4: 6,   # Major Third (consonant)
+        5: 4,   # Perfect Fourth (context-dependent, generally consonant)
+        6: -10, # Tritone (highly dissonant)
+        7: 8,   # Perfect Fifth (highly consonant)
+        8: 5,   # Minor Sixth (consonant)
+        9: 6,   # Major Sixth (consonant)
+        10: -3, # Minor Seventh (dissonant)
+        11: -7  # Major Seventh (dissonant)
+    }
+
+    matrix = np.zeros((12, 12), dtype=int)
+
+    for i in range(12):
+        for j in range(12):
+            interval = abs(i - j)
+            # We only care about the shortest distance between notes on the circle
+            if interval > 6:
+                interval = 12 - interval
+            
+            matrix[i, j] = interval_scores[interval]
+
+    return matrix
+
+def save_matrix_to_json(matrix, path):
+    """
+    Saves the matrix to a JSON file.
+    """
+    with open(path, 'w') as f:
+        json.dump(matrix.tolist(), f, indent=2)
+
+if __name__ == '__main__':
+    consonance_matrix = generate_consonance_matrix()
+    file_path = '/home/KidIkaros/Documents/code/Ikaros/musick/chord_detector_extension/consonance_.json'
+    save_matrix_to_json(consonance_matrix, file_path)
+    print(f"Consonance matrix saved to {file_path}")
+    print(consonance_matrix)

music_generator.py

@@ -0,0 +1,47 @@
+import tensorflow as tf
+from tensorflow.keras.layers import LSTM, Dense, Embedding
+from tensorflow.keras.models import Sequential
+import numpy as np
+
+class MusicGenerator:
+    def __init__(self, vocab_size):
+        self.model = Sequential([
+            Embedding(vocab_size, 128, input_length=1),
+            LSTM(256, return_sequences=True),
+            LSTM(256),
+            Dense(vocab_size, activation='softmax')
+        ])
+        self.model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
+        self.vocab_size = vocab_size
+
+    def train(self, sequences, epochs=10):
+        X = np.array([s[:-1] for s in sequences])
+        y = np.array([s[1:] for s in sequences])
+        self.model.fit(X, y, epochs=epochs)
+
+    def generate(self, start_sequence, length=10):
+        result = start_sequence
+        current_sequence = np.array(start_sequence)
+        for _ in range(length):
+            predicted_probs = self.model.predict(current_sequence, verbose=0)[0]
+            predicted_id = np.random.choice(len(predicted_probs), p=predicted_probs)
+            result.append(predicted_id)
+            current_sequence = np.array([predicted_id])
+        return result
+
+if __name__ == '__main__':
+    # Example usage
+    vocab_size = 12  # C, C#, D, ...
+    generator = MusicGenerator(vocab_size)
+
+    # Dummy training data (replace with real data)
+    sequences = [
+        [0, 4, 7, 0], # Cmaj -> C
+        [5, 9, 0, 5]  # Fmaj -> F
+    ]
+    generator.train(sequences)
+
+    # Generate a new sequence
+    start_sequence = [0] # Start with C
+    generated_sequence = generator.generate(start_sequence)
+    print("Generated sequence:", generated_sequence)

music_math.py

@@ -0,0 +1,43 @@
+import json
+import networkx as nx
+import numpy as np
+
+def create_music_graph():
+    """
+    Creates a directed graph representing the 12-tone chromatic scale
+    with edges for major and minor thirds, and perfect fifths.
+    """
+    notes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+    G = nx.DiGraph()
+    for i, note in enumerate(notes):
+        G.add_node(i, label=note)
+
+    for i in range(12):
+        # Major third (4 semitones)
+        G.add_edge(i, (i + 4) % 12, interval='M3')
+        # Minor third (3 semitones)
+        G.add_edge(i, (i + 3) % 12, interval='m3')
+        # Perfect fifth (7 semitones)
+        G.add_edge(i, (i + 7) % 12, interval='P5')
+
+    return G
+
+def get_adjacency_matrix(G):
+    """
+    Returns the adjacency matrix of the graph.
+    """
+    return nx.to_numpy_array(G, dtype=int)
+
+def save_matrix_to_json(matrix, path='matrix.json'):
+    """
+    Saves the matrix to a JSON file.
+    """
+    with open(path, 'w') as f:
+        json.dump(matrix.tolist(), f)
+
+if __name__ == '__main__':
+    graph = create_music_graph()
+    adj_matrix = get_adjacency_matrix(graph)
+    save_matrix_to_json(adj_matrix, '/home/KidIkaros/Documents/code/Ikaros/musick/chord-detector-extension/matrix.json')
+    print("Adjacency matrix saved to matrix.json")
+    print(adj_matrix)

requirements.txt

@@ -0,0 +1,5 @@
+networkx==3.3
+numpy==1.26.4
+flask
+flask-cors
+tensorflow