Exemple #1
0
data = []
for pkl_file in glob.glob('../data/msd/pkl/*/*/*/*.pkl'):
    with open(pkl_file) as f:
        try:
            data.append(pickle.load(f))
        except:
            pass

# Create a separate list of the sequences
sequences = [d['hash_list'] for d in data]
# And mean chroma vectors
mean_chromas = np.array([d['mean_chroma'] for d in data])

print "Loading in hasher ..."
layers = hashing_utils.build_network(
    (None, 1, 100, 48), num_filters['X'], filter_size['X'], ds['X'],
    hidden_layer_sizes['X'], dropout, n_bits)
hashing_utils.load_model(layers, '../results/model_X.pkl')
hash = theano.function(
    [layers[0].input_var], layers[-1].get_output(deterministic=True))

# Load in training set statistics for standardization
with open('../results/X_mean_std.pkl') as f:
    train_stats = pickle.load(f)


def match_one_midi(midi_file):
    '''
    Hash and match a single MIDI file against the MSD

    :parameters:
def train_cross_modality_hasher(X_train, Y_train, X_validate, Y_validate,
                                num_filters, filter_size, ds,
                                hidden_layer_sizes, alpha_XY, m_XY, n_bits=16,
                                dropout=False, learning_rate=.001, momentum=.0,
                                batch_size=50, sequence_length=100,
                                epoch_size=100, initial_patience=1000,
                                improvement_threshold=0.99,
                                patience_increase=10, max_iter=100000):
    ''' Utility function for training a siamese net for cross-modality hashing
    So many parameters.
    Assumes X_train[n] should be mapped close to Y_train[m] only when n == m
    The number of convolutional/pooling layers in inferred from the length of
    the entries in the num_filters, filter_size, ds dicts (all of which should
    have the same length).  The number of hidden layers is inferred from the
    length of the entries of the hidden_layer_sizes dict.  A final dense output
    layer is also included.

    :parameters:
        - X_train, Y_train, X_validate, Y_validate : list of np.ndarray
            List of train/validate sequences from X/Y modality
            Each shape=(n_channels, n_time_steps, n_features)
        - num_filters : dict of list-like
            Number of features in each convolutional layer for X/Y network
        - filter_size : dict of list-like
            Number of features in each convolutional layer for X/Y network
        - ds : dict of list-like
            Number of features in each convolutional layer for X/Y network
        - hidden_layer_sizes : dict of list-like
            Size of each hidden layer in X/Y network
        - alpha_XY : float
            Scaling parameter for cross-modality negative example cost
        - m_XY : int
            Cross-modality negative example threshold
        - n_bits : int
            Number of bits in the output representation
        - dropout : bool
            Whether to use dropout between the hidden layers
        - learning_rate : float
            SGD learning rate
        - momentum : float
            SGD momentum
        - batch_size : int
            Mini-batch size
        - sequence_length : int
            Size of extracted sequences
        - epoch_size : int
            Number of mini-batches per epoch
        - initial_patience : int
            Always train on at least this many batches
        - improvement_threshold : float
            Validation cost must decrease by this factor to increase patience
        - patience_increase : int
            How many more epochs should we wait when we increase patience
        - max_iter : int
            Maximum number of batches to train on

    :returns:
        - epoch : iterator
            Results for each epoch are yielded
    '''
    # First neural net, for X modality
    X_p_input = T.tensor4('X_p_input')
    X_n_input = T.tensor4('X_n_input')
    # For eval
    X_input = T.tensor4('X_input')
    # Second neural net, for Y modality
    Y_p_input = T.tensor4('Y_p_input')
    Y_n_input = T.tensor4('Y_n_input')
    Y_input = T.tensor4('Y_input')

    # Create networks
    layers = {
        'X': hashing_utils.build_network(
            (None, X_train[0].shape[0], sequence_length, X_train[0].shape[2]),
            num_filters['X'], filter_size['X'], ds['X'],
            hidden_layer_sizes['X'], dropout, n_bits),
        'Y': hashing_utils.build_network(
            (None, Y_train[0].shape[0], sequence_length, Y_train[0].shape[2]),
            num_filters['Y'], filter_size['Y'], ds['Y'],
            hidden_layer_sizes['Y'], dropout, n_bits)}

    # Compute \sum max(0, m - ||a - b||_2)^2
    def hinge_cost(m, a, b):
        dist = m - T.sqrt(T.sum((a - b)**2, axis=1))
        return T.mean((dist*(dist > 0))**2)

    def hasher_cost(deterministic):
        X_p_output = lasagne.layers.get_output(
            layers['X'][-1], X_p_input, deterministic=deterministic)
        X_n_output = lasagne.layers.get_output(
            layers['X'][-1], X_n_input, deterministic=deterministic)
        Y_p_output = lasagne.layers.get_output(
            layers['Y'][-1], Y_p_input, deterministic=deterministic)
        Y_n_output = lasagne.layers.get_output(
            layers['Y'][-1], Y_n_input, deterministic=deterministic)

        # Unthresholded, unscaled cost of positive examples across modalities
        cost_p = T.mean((X_p_output - Y_p_output)**2)
        # Thresholded, scaled cost of cross-modality negative examples
        cost_n = alpha_XY*hinge_cost(m_XY, X_n_output, Y_n_output)
        # Sum positive and negative costs for overall cost
        cost = cost_p + cost_n
        return cost

    # Combine all parameters from both networks
    params = (lasagne.layers.get_all_params(layers['X'][-1])
              + lasagne.layers.get_all_params(layers['Y'][-1]))
    # Compute RMSProp gradient descent updates
    updates = lasagne.updates.rmsprop(hasher_cost(False), params,
                                      learning_rate, momentum)
    # Function for training the network
    train = theano.function(
        [X_p_input, X_n_input, Y_p_input, Y_n_input], hasher_cost(False),
        updates=updates)

    # Compute cost without training
    cost = theano.function(
        [X_p_input, X_n_input, Y_p_input, Y_n_input], hasher_cost(True))

    # Start with infinite validate cost; we will always increase patience once
    current_validate_cost = np.inf
    patience = initial_patience

    # Functions for computing the neural net output on the train and val sets
    X_output = theano.function([X_input], lasagne.layers.get_output(
        layers['X'][-1], X_input, deterministic=True))
    Y_output = theano.function([Y_input], lasagne.layers.get_output(
        layers['Y'][-1], Y_input, deterministic=True))

    # Extract sample seqs from the validation set (only need to do this once)
    X_validate, Y_validate = hashing_utils.sample_sequences(
        X_validate, Y_validate, sequence_length)

    # Create fixed negative example validation set
    X_validate_n = X_validate[np.random.permutation(X_validate.shape[0])]
    Y_validate_n = Y_validate[np.random.permutation(Y_validate.shape[0])]
    X_validate_shuffle = np.random.permutation(X_output(X_validate).shape[0])
    data_iterator = hashing_utils.get_next_batch(
        X_train, Y_train, batch_size, sequence_length, max_iter)
    # We will accumulate the mean train cost over each epoch
    train_cost = 0

    for n, (X_p, Y_p, X_n, Y_n) in enumerate(data_iterator):
        # Occasionally Theano was raising a MemoryError, this fails gracefully
        try:
            train_cost += train(X_p, X_n, Y_p, Y_n)
        except MemoryError:
            return
        # Stop training if a NaN is encountered
        if not np.isfinite(train_cost):
            print 'Bad training cost {} at iteration {}'.format(train_cost, n)
            break
        # Validate the net after each epoch
        if n and (not n % epoch_size):
            epoch_result = collections.OrderedDict()
            epoch_result['iteration'] = n
            # Compute average training cost over the epoch
            epoch_result['train_cost'] = train_cost / float(epoch_size)
            # Reset training cost mean accumulation
            train_cost = 0
            # Also compute validate cost
            epoch_result['validate_cost'] = cost(
                X_validate, X_validate_n, Y_validate, Y_validate_n)

            # Compute statistics on validation set
            X_val_output = X_output(X_validate)
            Y_val_output = Y_output(Y_validate)
            in_dist, in_mean, in_std = hashing_utils.statistics(
                X_val_output > 0, Y_val_output > 0)
            out_dist, out_mean, out_std = hashing_utils.statistics(
                X_val_output[X_validate_shuffle] > 0, Y_val_output > 0)
            epoch_result['validate_accuracy'] = in_dist[0]
            epoch_result['validate_in_class_distance_mean'] = in_mean
            epoch_result['validate_in_class_distance_std'] = in_std
            epoch_result['validate_collisions'] = out_dist[0]
            epoch_result['validate_out_of_class_distance_mean'] = out_mean
            epoch_result['validate_out_of_class_distance_std'] = out_std
            X_entropy = hashing_utils.hash_entropy(X_val_output > 0)
            epoch_result['validate_hash_entropy_X'] = X_entropy
            Y_entropy = hashing_utils.hash_entropy(Y_val_output > 0)
            epoch_result['validate_hash_entropy_Y'] = Y_entropy
            # Objective is negative bhattacharyya distance
            # We should try to maximize it
            # When either is small, it's not really valid
            if out_dist[0] > 1e-5 and in_dist[0] > 1e-2:
                bhatt_coeff = -np.sum(np.sqrt(in_dist*out_dist))
                epoch_result['validate_objective'] = bhatt_coeff
            else:
                epoch_result['validate_objective'] = -1

            if epoch_result['validate_cost'] < current_validate_cost:
                patience_cost = improvement_threshold*current_validate_cost
                if epoch_result['validate_cost'] < patience_cost:
                    patience += epoch_size*patience_increase
                current_validate_cost = epoch_result['validate_cost']

            # Yield scores and statistics for this epoch
            X_params = lasagne.layers.get_all_param_values(layers['X'][-1])
            Y_params = lasagne.layers.get_all_param_values(layers['Y'][-1])
            yield (epoch_result, X_params, Y_params)

            if n > patience:
                break

    return