autochord

To perform cross-validation, use the get_next_cv_split generator. It takes a train_split and a list of val_splits. In each iteration, it yields a new training set composed of the original train_split plus all val_splits except the current one, and uses the current val_split as the validation set. This ensures that every validation split is used for training exactly once across the full CV loop.

def get_next_cv_split(train_split, val_splits):
    num_cv = len(val_splits)
    for v_ix in range(num_cv):
        addl_train_splits = val_splits[0:v_ix] + val_splits[v_ix+1:]
        val_split = val_splits[v_ix]

        full_train_feats = np.concatenate((train_split.feats, *[split.feats for split in addl_train_splits]))
        full_train_labels = np.concatenate((train_split.labels, *[split.labels for split in addl_train_splits]))
        full_train_split = SplitData(feats=full_train_feats, labels=full_train_labels)
        yield full_train_split, val_split

To prepare datasets for training, use QueueData to manage data chunks and SplitData to hold feature/label pairs. The SplitData class supports concatenating new features and labels via .push(feats, labels) and provides a .shape property.

When splitting data, ensure you have enough samples per class to satisfy the requirements of your test and validation splits. The get_splits function (demonstrated in the notebook) uses a QueueData object to pull a specific number of samples per class for testing, multiple validation splits, and finally the remaining data for training.

class SplitData():
    def __init__(self, feats=None, labels=None):
        self.feats = feats
        self.labels = labels

    def push(self, feats, labels):
        assert(len(feats)==len(labels))
        if self.feats is None:
            self.feats = feats
        else:
            self.feats = np.concatenate((self.feats, feats))

        if self.labels is None:
            self.labels = labels
        else:
            self.labels = np.concatenate((self.labels, labels))

    def __len__(self):
        return len(self.labels)

    @property
    def shape(self):
        return (self.feats.shape, self.labels.shape)

To export the model as a frozen graph (useful for deployment in environments without full Keras support), follow these steps:

1. Access the base_model.
2. Convert the model to a ConcreteFunction using tf.function.
3. Use convert_variables_to_constants_v2 to freeze the variables.
4. Write the graph to disk using tf.io.write_graph in either .pb (binary) or .pbtxt (text) format.

import tensorflow as tf
from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2

# 1. Convert to ConcreteFunction
full_model = tf.function(lambda x: model.base_model(x))
full_model = full_model.get_concrete_function(
    x=tf.TensorSpec(model.base_model.inputs[0].shape, model.base_model.inputs[0].dtype))

# 2. Freeze variables
frozen_func = convert_variables_to_constants_v2(full_model)

# 3. Save to disk
tf.io.write_graph(graph_or_graph_def=frozen_func.graph, 
                  logdir="models/graph/", 
                  name="frozen_model.pb", 
                  as_text=False)

To optimize model performance, combine hyperopt for searching the parameter space and guild for experiment tracking.

1. Define a training function (hpset_trainloop) that accepts hyperparameters as arguments and returns a metric (e.g., validation accuracy).
2. Define a tuning loop (tuning_loop) that uses guild.run to execute the training function for each hyperparameter set suggested by hyperopt.
3. Use fmin to find the best parameters. Note that fmin minimizes the return value, so if you are maximizing accuracy, return (1 - avg_acc).

Important: If a hyperparameter set performs extremely poorly on a single CV split (e.g., acc < 0.5), you can return a high penalty (e.g., 1.0) to prune that branch early.

from hyperopt import hp, tpe, fmin
import guild.ipy as guild

# 1. The training function to track
def hpset_trainloop(hd=256, dp=0.6, opt='adam', lr=0.001, bs=512, si=0):
    # ... training logic ...
    return best_acc

# 2. The tuning loop for hyperopt
def tuning_loop(hparams):
    global _TRAIN, _VAL
    avg_acc = 0.0
    num_runs = 0
    for cv_ix, (train, val) in enumerate(ds.get_next_cv_split()):
        _TRAIN, _VAL = train, val
        run, acc = guild.run(hpset_trainloop, 
                             hd=int(hparams['base_hidden_dim']),
                             dp=hparams['drop_rate'],
                             opt=hparams['opt'],
                             lr=hparams['lr'], 
                             bs=int(hparams['batch_size']),
                             si=cv_ix)
        if acc < 0.5: return 1.0 # Early exit for bad params
        avg_acc += acc
        num_runs += 1
    return (1 - (avg_acc / num_runs))

# 3. Define search space and run
hparams = {
    'base_hidden_dim': hp.choice('base_hidden_dim', [256, 512, 1024]),
    'drop_rate': hp.choice('drop_rate', [0.9, 0.7, 0.5, 0.3]),
    'opt': hp.choice('opt', ['adam']),
    'lr': hp.choice('lr', [1e-2, 1e-3, 3e-4, 1e-4]),
    'batch_size': hp.choice('batch_size', [16, 32, 64]),
}

best = fmin(tuning_loop, hparams, algo=tpe.suggest, max_evals=1)

To prepare a dataset for training, you can iterate through song IDs, extract features and labels using a dataloader, divide them into subsequences, and save the resulting dictionary to a pickle file.

Recommended workflow:

1. Load song metadata from a CSV (e.g., billboard-2.0-manychords.csv).
2. Use dataloader.get_chord_features_and_labels to fetch raw features.
3. Use divide_to_subsequences to chunk the data.
4. Store in a dictionary keyed by song ID.
5. Save using pickle.dump or joblib.dump for large datasets.

import os
import pickle
import dataloader
import lazycats.np as catnp

_DUMP_DIR = 'data/chordseq'
_LABEL_TYPE = 'majmin'
_SEQ_LEN = 128

chordseq_dict = {}
for _id in df_songs.index:
    chroma_vectors, chord_labels = dataloader.get_chord_features_and_labels(_id, label_type=_LABEL_TYPE)
    
    # Chunking
    chordseq_vectors = catnp.divide_to_subsequences(chroma_vectors, sub_len=_SEQ_LEN, pad=[0]*24)
    chordseq_labels = catnp.divide_to_subsequences(chord_labels, sub_len=_SEQ_LEN, pad=0)
    
    chordseq_dict[_id] = {'feats': chordseq_vectors, 'labels': chordseq_labels}

# Save the dataset
os.makedirs(_DUMP_DIR, exist_ok=True)
with open(f'{_DUMP_DIR}/{_LABEL_TYPE}_{_SEQ_LEN}.pkl', 'wb') as f:
    pickle.dump(chordseq_dict, f)