Update app.py

app.py

@@ -1,34 +1,149 @@
-import gradio as gr
-from gradio.inputs import Dropdown
-import requests
-
-"""
-Use Gradio library to create a form with a textbox to store the input text.
-And API_KEY textbox to store the key.
-Use api.openai.com to get the response.
-"""
-
-
-def generate_text(input_text, api_key, temperature, max_tokens, frequency_penalty, presence_penalty, engine_id):
-    url = "https://api.openai.com/v1/engines/{engine_id}/completions".format(engine_id=engine_id)
-    data = {
-        "prompt": input_text,
-        "max_tokens": max_tokens,
-        "temperature": temperature,
-        "frequency_penalty": frequency_penalty,
-        "presence_penalty": presence_penalty
-    }
-    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
-    response = requests.post(url=url, json=data, headers=headers)
-    if response.status_code == 200:
-        return response.json()["choices"][0]["text"]
-    else:
-        return "Error: " + response.text
-
-
-if __name__ == "__main__":
-    gr.Interface(
-        generate_text,  # function to be called
-        [gr.inputs.Textbox(lines=1), gr.inputs.Textbox(lines=1), gr.inputs.Slider(minimum=0, maximum=1, step=0.01),
-         gr.inputs.Slider(minimum=32, maximum=500, step=1), gr.inputs.Slider(minimum=0, maximum=1, step=0.01), gr.inputs.Slider(minimum=0, maximum=1, step=0.01), gr.inputs.Dropdown(["davinci-codex", "cushman-codex"])],  # input types
-        gr.outputs.Textbox()  # output type
+import os
+import sys
+import time
+import numpy as np
+from keras.callbacks import Callback
+from scipy.io.wavfile import read, write
+from keras.models import Model, Sequential
+from keras.layers import Convolution1D, AtrousConvolution1D, Flatten, Dense, \
+    Input, Lambda, merge, Activation
+
+
+def wavenetBlock(n_atrous_filters, atrous_filter_size, atrous_rate):
+    def f(input_):
+        residual = input_
+        tanh_out = AtrousConvolution1D(n_atrous_filters, atrous_filter_size,
+                                       atrous_rate=atrous_rate,
+                                       border_mode='same',
+                                       activation='tanh')(input_)
+        sigmoid_out = AtrousConvolution1D(n_atrous_filters, atrous_filter_size,
+                                          atrous_rate=atrous_rate,
+                                          border_mode='same',
+                                          activation='sigmoid')(input_)
+        merged = merge([tanh_out, sigmoid_out], mode='mul')
+        skip_out = Convolution1D(1, 1, activation='relu', border_mode='same')(merged)
+        out = merge([skip_out, residual], mode='sum')
+        return out, skip_out
+    return f
+
+
+def get_basic_generative_model(input_size):
+    input_ = Input(shape=(input_size, 1))
+    A, B = wavenetBlock(64, 2, 2)(input_)
+    skip_connections = [B]
+    for i in range(20):
+        A, B = wavenetBlock(64, 2, 2**((i+2)%9))(A)
+        skip_connections.append(B)
+    net = merge(skip_connections, mode='sum')
+    net = Activation('relu')(net)
+    net = Convolution1D(1, 1, activation='relu')(net)
+    net = Convolution1D(1, 1)(net)
+    net = Flatten()(net)
+    net = Dense(256, activation='softmax')(net)
+    model = Model(input=input_, output=net)
+    model.compile(loss='categorical_crossentropy', optimizer='sgd',
+                  metrics=['accuracy'])
+    model.summary()
+    return model
+
+
+def get_audio(filename):
+    sr, audio = read(filename)
+    audio = audio.astype(float)
+    audio = audio - audio.min()
+    audio = audio / (audio.max() - audio.min())
+    audio = (audio - 0.5) * 2
+    return sr, audio
+
+
+def frame_generator(sr, audio, frame_size, frame_shift, minibatch_size=20):
+    audio_len = len(audio)
+    X = []
+    y = []
+    while 1:
+        for i in range(0, audio_len - frame_size - 1, frame_shift):
+            frame = audio[i:i+frame_size]
+            if len(frame) < frame_size:
+                break
+            if i + frame_size >= audio_len:
+                break
+            temp = audio[i + frame_size]
+            target_val = int((np.sign(temp) * (np.log(1 + 256*abs(temp)) / (
+                np.log(1+256))) + 1)/2.0 * 255)
+            X.append(frame.reshape(frame_size, 1))
+            y.append((np.eye(256)[target_val]))
+            if len(X) == minibatch_size:
+                yield np.array(X), np.array(y)
+                X = []
+                y = []
+
+
+def get_audio_from_model(model, sr, duration, seed_audio):
+    print 'Generating audio...'
+    new_audio = np.zeros((sr * duration))
+    curr_sample_idx = 0
+    while curr_sample_idx < new_audio.shape[0]:
+        distribution = np.array(model.predict(seed_audio.reshape(1,
+                                                                 frame_size, 1)
+                                             ), dtype=float).reshape(256)
+        distribution /= distribution.sum().astype(float)
+        predicted_val = np.random.choice(range(256), p=distribution)
+        ampl_val_8 = ((((predicted_val) / 255.0) - 0.5) * 2.0)
+        ampl_val_16 = (np.sign(ampl_val_8) * (1/256.0) * ((1 + 256.0)**abs(
+            ampl_val_8) - 1)) * 2**15
+        new_audio[curr_sample_idx] = ampl_val_16
+        seed_audio[-1] = ampl_val_16
+        seed_audio[:-1] = seed_audio[1:]
+        pc_str = str(round(100*curr_sample_idx/float(new_audio.shape[0]), 2))
+        sys.stdout.write('Percent complete: ' + pc_str + '\r')
+        sys.stdout.flush()
+        curr_sample_idx += 1
+    print 'Audio generated.'
+    return new_audio.astype(np.int16)
+
+
+class SaveAudioCallback(Callback):
+    def __init__(self, ckpt_freq, sr, seed_audio):
+        super(SaveAudioCallback, self).__init__()
+        self.ckpt_freq = ckpt_freq
+        self.sr = sr
+        self.seed_audio = seed_audio
+
+    def on_epoch_end(self, epoch, logs={}):
+        if (epoch+1)%self.ckpt_freq==0:
+            ts = str(int(time.time()))
+            filepath = os.path.join('output/', 'ckpt_'+ts+'.wav')
+            audio = get_audio_from_model(self.model, self.sr, 0.5, self.seed_audio)
+            write(filepath, self.sr, audio)
+
+
+if __name__ == '__main__':
+    n_epochs = 2000
+    frame_size = 2048
+    frame_shift = 128
+    sr_training, training_audio = get_audio('train.wav')
+    # training_audio = training_audio[:sr_training*1200]
+    sr_valid, valid_audio = get_audio('validate.wav')
+    # valid_audio = valid_audio[:sr_valid*60]
+    assert sr_training == sr_valid, "Training, validation samplerate mismatch"
+    n_training_examples = int((len(training_audio)-frame_size-1) / float(
+        frame_shift))
+    n_validation_examples = int((len(valid_audio)-frame_size-1) / float(
+        frame_shift))
+    model = get_basic_generative_model(frame_size)
+    print 'Total training examples:', n_training_examples
+    print 'Total validation examples:', n_validation_examples
+    audio_context = valid_audio[:frame_size]
+    save_audio_clbk = SaveAudioCallback(100, sr_training, audio_context)
+    validation_data_gen = frame_generator(sr_valid, valid_audio, frame_size, frame_shift)
+    training_data_gen = frame_generator(sr_training, training_audio, frame_size, frame_shift)
+    model.fit_generator(training_data_gen, samples_per_epoch=3000, nb_epoch=n_epochs, validation_data=validation_data_gen,nb_val_samples=500, verbose=1, callbacks=[save_audio_clbk])
+    print 'Saving model...'
+    str_timestamp = str(int(time.time()))
+    model.save('models/model_'+str_timestamp+'_'+str(n_epochs)+'.h5')
+    print 'Generating audio...'
+    new_audio = get_audio_from_model(model, sr_training, 2, audio_context)
+    outfilepath = 'output/generated_'+str_timestamp+'.wav'
+    print 'Writing generated audio to:', outfilepath
+    write(outfilepath, sr_training, new_audio)
+    print '\nDone!'