# from vox_audio import audiofile_to_input_vector_vox

import pysndfile

from pysndfile import PySndfile

#from pathlib2 import Path

# print(pysndfile.get_sndfile_formats())

import math

import numpy as np

from six.moves import range

import threading

import time

import os

import time

import threading

import tensorflow as tf

#from itertools import izip, izip_longest

from vox_audio import audiofile_to_input_vector_vox, audiofile_to_input_vector_ted

def weight_variable(shape, name):

return tf.get_variable(name,shape=shape, initializer=tf.contrib.layers.xavier_initializer())

# initial = tf.truncated_normal(shape, stddev=0.1)

# return tf.Variable(initial)

def bias_variable(shape, name):

# initial = tf.constant(0.1, shape=shape)

# return tf.Variable(initial)

return tf.get_variable(name,shape=shape, initializer=tf.contrib.layers.xavier_initializer())

def conv2d(x, W,stride):

return tf.nn.conv2d(x, W, strides=stride, padding='VALID')

def max_pool_2x2(x, window, stride):

return tf.nn.avg_pool(x, ksize=[1, window, 1, 1],

strides=[1, stride, 1, 1], padding='VALID')

from tensorflow.python.framework import ops

class FlipGradientBuilder(object):

return y

flip_gradient = FlipGradientBuilder()

def read_my_file_format(filename_queue):

return feats, labels

# def input_pipeline(batch_size = 128, num_epochs=100):

# filename_queue

batch_size = 128

num_epochs=180

filename_queue1 = tf.train.string_input_producer(['clean_american-v2.csv'], num_epochs=num_epochs, shuffle=True)

filename_queue2 = tf.train.string_input_producer(['clean_british-v2.csv'], num_epochs=num_epochs*10, shuffle=True)

source_batch_x, source_batch_y = read_my_file_format(filename_queue1)

target_batch_x, target_batch_y = read_my_file_format(filename_queue2)

source_batch_x.set_shape([None, 4960 ])

source_batch_y.set_shape([None])

target_batch_x.set_shape([None, 4960])

target_batch_y.set_shape([None])

source_batch_x = tf.reshape(source_batch_x, [-1, 4960, 1, 1])

target_batch_x = tf.reshape(target_batch_x, [-1, 4960, 1, 1])

target_batch_y = tf.reshape(target_batch_y, [-1])

source_batch_y = tf.reshape(source_batch_y, [-1])

# print(source_x.get_shape().as_list())

min_after_dequeue = 10000

capacity = min_after_dequeue + 3*batch_size

# print(tf.rank(source_x))

source_x, source_y = tf.train.shuffle_batch([source_batch_x, source_batch_y], batch_size=batch_size, capacity=capacity,

min_after_dequeue=min_after_dequeue, enqueue_many=True, num_threads=3)

target_x, target_y = tf.train.shuffle_batch([target_batch_x, target_batch_y], batch_size=batch_size, capacity=capacity,

min_after_dequeue=min_after_dequeue, enqueue_many=True, num_threads=3)

# return source_batch_x, source_batch_y, target_batch_x, target_batch_y

# with tf.Session() as sess:

# coord = tf.train.Coordinator()

# threads = tf.train.start_queue_runners(coord=coord)

# for i in range(1200000):

# example = sess.run([feats_path_source])

# coord.request_stop()

# coord.join(threads)

batch_size = 128

num_steps = int(2031250*0.6)

class Acoustic_Model(object):

self.domain_loss = tf.nn.softmax_cross_entropy_with_logits(logits=d_logits, labels=self.domain)

graph = tf.get_default_graph()

with graph.as_default():

model = Acoustic_Model()

# learning_rate = tf.placeholder(tf.float32, [])

learning_rate = model.lr

pred_loss = tf.reduce_mean(model.pred_loss)

domain_loss = tf.reduce_mean(model.domain_loss)

total_loss = pred_loss + domain_loss

with tf.name_scope('Training'):

regular_train_op = tf.train.MomentumOptimizer(learning_rate, 0.9).minimize(pred_loss)

dann_train_op = tf.train.MomentumOptimizer(learning_rate, 0.9).minimize(total_loss)

# Evaluation

correct_label_pred = tf.equal(tf.argmax(model.classify_labels, 1), tf.argmax(model.pred, 1))

label_acc = tf.reduce_mean(tf.cast(correct_label_pred, tf.float32))

correct_domain_pred = tf.equal(tf.argmax(model.domain, 1), tf.argmax(model.domain_pred, 1))

domain_acc = tf.reduce_mean(tf.cast(correct_domain_pred, tf.float32))

tf.summary.scalar('prediction loss', pred_loss)

tf.summary.scalar('domain loss', domain_loss)

tf.summary.scalar('total loss', total_loss)

tf.summary.scalar('label accuracy', label_acc)

tf.summary.scalar('domain accuracy', domain_acc)

summary_op = tf.summary.merge_all()

with tf.Session(graph=graph, config=tf.ConfigProto(intra_op_parallelism_threads=12, allow_soft_placement=True)) as sess:

print('entered')

sess.run(tf.local_variables_initializer())

sess.run(tf.global_variables_initializer())

print('initilized')

coord = tf.train.Coordinator()

print('initilized2')

threads = tf.train.start_queue_runners(sess=sess,coord=coord)

print('startting sess')

saver = tf.train.Saver()

sess.graph.finalize()

k = 0

avg_loss = []

avg_accuracy = []

avg_domain_loss = []

avg_domain_accuracy = []

for i in range(num_steps):

_, ploss, dloss, l_acc, d_acc,lam = sess.run([dann_train_op, pred_loss, domain_loss, label_acc, domain_acc, model.l])

avg_loss.append(ploss)

avg_accuracy.append(l_acc)

avg_domain_loss.append(dloss)

avg_domain_accuracy.append(d_acc)

if i%10000 == 0:

print('epoch:%d/%d ploss:%f dloss:%f accuracy:%f avg_loss:%f avg_accuracy:%f avg_domain_loss:%f avg_domain_accuracy:%f l_parameter:%f'%(k,i%234375, ploss, dloss,l_acc,sum(avg_loss)/len(avg_loss), sum(avg_accuracy)/len(avg_accuracy), sum(avg_domain_loss)/len(avg_domain_loss), sum(avg_domain_accuracy)/len(avg_domain_accuracy), lam))

if i%234375 == 0:

k = k+1

avg_loss = []

avg_accuracy = []

if i%10000 == 0:

save_path = saver.save(sess, 'saved_model_baseline_adver/baseline_model.ckpt')

coord.request_stop()

coord.join(threads)