AI Mass人工智能大模型即服务时代：AI Mass在音乐创作中的应用案例

    import tensorflow as tf
    from scipy.io import wavfile # For loading the audio file
    import numpy as np
    
    def load_wav_file(filename):
    """Load a WAV file"""
    sampling_rate, data = wavfile.read(filename)
    if len(data.shape)>1:
        data=np.mean(data,axis=1)
    return data,sampling_rate
    
      
      
      
      
      
      
      
      
      
    
    代码解读

    def compute_spectrogram(signal, sr, nperseg=160, noverlap=79):
    """Compute the spectrogram of an input signal"""
    freqs, times, spec = stft(signal, fs=sr, window='hann', nperseg=nperseg, noverlap=noverlap)
    
    # Scale by the number of samples to get units dB per sample
    dbscale = lambda x: 10 * np.log10(np.abs(x) / len(signal))
    logspec = list(map(dbscale, spec))
    
    return freqs, times, logspec
    
      
      
      
      
      
      
      
      
    
    代码解读

    def extract_features(y, sr, feature_type="mfcc"):
    """Extract features from a raw audio signal y at a given sample rate sr."""
    if feature_type == "mfcc":
        mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
    elif feature_type == "fbank":
        fbank = librosa.core.spectrum.power_to_db(librosa.feature.melspectrogram(y=y, sr=sr, hop_length=hop_len))
    else:
        raise ValueError("Invalid feature type specified.")
    
    delta1_mfcc = librosa.feature.delta(mfcc, order=1)
    delta2_mfcc = librosa.feature.delta(mfcc, order=2)
    
    return np.concatenate([mfcc.T, delta1_mfcc.T, delta2_mfcc.T], axis=1).astype('float32')
    
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    def train_model():
    """Train a model on the dataset using TensorFlow."""
    dataset = np.load('/path/to/dataset.npy')
    X_train, Y_train, X_test, Y_test = split_dataset(dataset)
    
    # Define placeholders and variables
    learning_rate = tf.placeholder(tf.float32)
    dropout_keep_prob = tf.placeholder(tf.float32)
    
    num_outputs = Y_train.shape[1]
    inputs = tf.placeholder(tf.float32, [None, X_train.shape[1]])
    labels = tf.placeholder(tf.int32, [None])
    
    logits = build_network(inputs, num_outputs, is_training=True)
    
    loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits))
    
    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)
    
    correct_prediction = tf.equal(tf.argmax(logits, 1), labels)
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    
    saver = tf.train.Saver()
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
    
        for i in range(num_epochs):
            _, c = sess.run([optimizer, loss], feed_dict={
                inputs: X_train, 
                labels: Y_train, 
                learning_rate: lr, 
                dropout_keep_prob: keep_prob})
    
            test_accuracy = sess.run(accuracy, 
                                      {inputs: X_test, labels: Y_test, dropout_keep_prob: 1.0})
    
            print("Epoch", i+1, ", Cost=", "{:.3f}".format(c), \
                  "Test Accuracy=", "{:.3f}".format(test_accuracy))
    
        save_path = saver.save(sess, "/tmp/speech_recognizer.ckpt")
        print("Model saved in file: %s" % save_path)
    
    def split_dataset(dataset):
    """Split the dataset into training and testing sets."""
    np.random.shuffle(dataset)
    
    n_samples = int(0.7*dataset.shape[0])
    
    X_train = dataset[:n_samples, :-1]
    Y_train = dataset[:n_samples, -1].reshape(-1,1).astype(int)
    
    X_test = dataset[n_samples:, :-1]
    Y_test = dataset[n_samples:, -1].reshape(-1,1).astype(int)
    
    return X_train, Y_train, X_test, Y_test
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    def predict(audio_path, model_path="/tmp/speech_recognizer.ckpt"):
    """Predict whether an input WAV file matches any of the trained speakers."""
    graph = tf.Graph()
    with graph.as_default(), tf.device('/cpu:0'):
        config = tf.ConfigProto(allow_soft_placement=True)
        sess = tf.Session(config=config)
        with sess.as_default():
            saver = tf.train.import_meta_graph(model_path + '.meta')
            saver.restore(sess, model_path)
    
            # Get the placeholders
            inputs = graph.get_operation_by_name('inputs').outputs[0]
            labels = graph.get_operation_by_name('labels').outputs[0]
            dropout_keep_prob = graph.get_operation_by_name('dropout_keep_prob').outputs[0]
    
            # Extract the features and make predictions
            feat = preprocess_audio(audio_path)
            pred_op = tf.argmax(graph.get_tensor_by_name('final_output/add'), 1)
    
            prediction = sess.run(pred_op,
                                  {inputs: feat, labels: [-1], dropout_keep_prob: 1.0})[0]
    
            return label_dict[str(prediction)]
    
    def preprocess_audio(audio_path):
    """Preprocess an audio file before extracting features."""
    filename = os.path.basename(audio_path)
    audio_dir = os.path.dirname(os.path.abspath(audio_path))
    
    output_dir = os.path.join(audio_dir, 'preprocessed')
    os.makedirs(output_dir, exist_ok=True)
    
    preprocessed_path = os.path.join(output_dir, filename)
    
    cmd = ['ffmpeg', '-i', audio_path,
           '-ac', '1', '-ar', str(sampling_rate),
           preprocessed_path]
    subprocess.call(cmd)
    
    data, _ = load_wav_file(preprocessed_path)
    feat = extract_features(data, sampling_rate)
    
    return feat.flatten().astype(np.float32)[np.newaxis,:]
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读