#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS, AS WELL AS THE UNIVERSITY
# OF BRITISH COLUMBIA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
# EVENT SHALL THE AUTHORS OR THE UNIVERSITY OF BRITISH COLUMBIA BE LIABLE
# FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
# IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#---------------------------------------------------------------------------
import tensorflow as tf
import numpy as np
import sys
sys.path.append('../../src')
import processMif as mif
tf.logging.set_verbosity(tf.logging.INFO)
size = 64
in_x = np.random.rand(size)
mif.createMem([in_x])
with tf.Session() as sess:
x = tf.placeholder(tf.float32, [size])
with tf.device("device:XLA_CPU:0"):
y = tf.nn.softmax(x)
result = sess.run(y, {x: in_x})
np.save("tf_result.npy", result)
print(result)
import tensorflow as tf
import numpy as np
import string
import sys
sys.path.append('../../src')
import processMif as mif
size = 64
outputs = 2
X = tf.placeholder(tf.float32, [1, size,size,1])
weights = tf.placeholder(tf.float32, [3,3,1,outputs])
in_x = np.random.rand(1,size,size,1)
in_weights = np.random.rand(3,3,1,outputs)
mif.createMem([in_x,in_weights])
with tf.Session() as sess:
with tf.device("device:XLA_CPU:0"):
y = tf.nn.conv2d(X, weights, strides=[1, 1, 1, 1], padding='SAME')
sess.run(tf.global_variables_initializer())
result = sess.run(y,{X: in_x, weights: in_weights})
np.save("tf_result.npy" ,result)
print(result)
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
# IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#---------------------------------------------------------------------------
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import sys
sys.path.append('../../src')
import processMif as mif
import additionalOptions as options
# Configs
image_width = 32
image_height = 32
#Prepare input array
in_a = np.random.rand(1, image_width, image_height, 1)
mif.createMem([in_a])
with tf.Session() as sess:
# Create hardware for max pooling
x = tf.placeholder(tf.float32, [1, image_width, image_height, 1])
with tf.device("device:XLA_CPU:0"):
y = tf.layers.max_pooling2d(inputs=x, pool_size=[3, 3], strides=3)
result = sess.run(y, {x: in_a})
np.save("tf_result.npy", result)
print(result)
options.setUnrollThreshold(100000000)
sys.path.append('../../src')
import processMif as mif
from tensorflow.examples.tutorials.mnist import input_data
# Import MNIST data
mnist_data = input_data.read_data_sets("MNIST_data/", one_hot=True)
# Configs
image_width=28
image_height=28
image_to_test=987
#Prepare input array
shape=[1, image_width, image_height, 1] #[batch_size, image_width, image_height, channels]
reshaped_input_array = np.reshape(mnist_data.test.images[image_to_test], shape)
with tf.Session() as sess:
# Create hardware for max pooling
x = tf.placeholder(tf.float32,shape)
with tf.device("device:XLA_CPU:0"):
y=tf.layers.max_pooling2d(inputs=x, pool_size=[3, 3], strides=3)
sess.run(y,{x: reshaped_input_array})
# Generate test memory
mif.createMem([reshaped_input_array])
# Plot original image
first_array=np.reshape(mnist_data.test.images[image_to_test],[image_width,image_height])
plt.imshow(first_array, cmap='gray', interpolation = 'none')
plt.show()
mnist_data = input_data.read_data_sets("MNIST_data/", one_hot=True)
test_image=123
with tf.Session(graph=graph) as session:
with tf.device("device:XLA_CPU:0"):
hp1 = tf.nn.max_pool(tf.nn.relu(tf.add(tf.nn.conv2d(tf.reshape(x, [-1,28,28,1]), w_c1, strides=[1, 1, 1, 1], padding='SAME'),b_c1)),ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
hp2 = tf.nn.max_pool(tf.nn.relu(tf.add(tf.nn.conv2d(hp1, w_c2, strides=[1, 1, 1, 1], padding='SAME'), b_c2)),ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
h_fc1 = tf.nn.relu(tf.add(tf.nn.conv2d(hp2, w_fc1, strides=[1, 1, 1, 1], padding='VALID'), b_fc1))
y = tf.nn.softmax(tf.add(tf.matmul(tf.reshape(h_fc1, [-1, 20]), w_fc2), b_fc2))
ret = session.run(y, feed_dict={x: [mnist_data.test.images[test_image]]})
print("Expected Result: "+str(np.argmax(mnist_data.test.labels[test_image])))
print("Real Result: "+str(ret))
# Creating memories for testing
param1 = mnist_data.test.images[test_image]
param0 = w_c1.eval()
param2 = b_c1.eval()
param3 = w_c2.eval()
param4 = b_c2.eval()
param5 = w_fc1.eval()
param6 = b_fc1.eval()
param7 = w_fc2.eval()
param8 = b_fc2.eval()
mif.createMem([param0,param1,param2,param3,param4,param5,param6,param7,param8])
#options.setUnrollThreshold(100000000)
fig, axs = plt.subplots(2, 3, sharex=True,sharey=True)
axs[0,0].imshow(img,cmap='gray')
axs[0,0].axis('off')
fig.subplots_adjust(hspace=0,wspace=0,right=1,top=1,left=0,bottom=0)
axs[0,0].text(.9, 0.9, string.ascii_uppercase[0], transform=axs[0,0].transAxes,
size=20, weight='bold',color='white')
for i in range(1, num_outputs+1):
axs[i/3,i%3].imshow(np.clip(result[:,:,i-1], 0, 1),cmap='gray')
axs[i/3,i%3].axis('off')
fig.subplots_adjust(hspace=0,wspace=0,right=1,top=1,left=0,bottom=0)
axs[i/3,i%3].text(.9, 0.9, string.ascii_uppercase[i], transform=axs[i/3,i%3].transAxes,
size=20, weight='bold',color='white')
plt.show()
# Generate test memory
mif.createMem([original_image,weights])
epochs = 1000
session.run(init)
for _ in range(epochs):
batch_x, batch_y = mnist_data.train.next_batch(100)
session.run(train_step, feed_dict={x: batch_x, real_y: batch_y})
correct_prediction = tensorflow.equal(tensorflow.argmax(y, 1),
tensorflow.argmax(real_y, 1))
accuracy = tensorflow.reduce_mean(
tensorflow.cast(correct_prediction, tensorflow.float32))
network_accuracy = session.run(accuracy,
feed_dict={
x: mnist_data.test.images,
real_y: mnist_data.test.labels
})
print('The accuracy over the MNIST data is {:.2f}%'.format(
network_accuracy * 100))
# Generating hardware
with tensorflow.device("device:XLA_CPU:0"):
y = tensorflow.nn.softmax(tensorflow.add(
tensorflow.matmul(x, W)[0], b))
session.run(y, {x: [mnist_data.test.images[123]]})
# Creating memories for testing
test_image = 123
mif.createMem([b.eval(), W.eval(), mnist_data.test.images[test_image]])
# Print expected result
print("Expected Result: " +
str(np.argmax(mnist_data.test.labels[test_image])))
X = tf.placeholder(tf.float32, [1, 3])
test = rand([1, 3])
dense1_w = tf.Variable(rand([3, nodes]))
dense1_b = tf.Variable(rand([nodes]))
with tf.Session() as sess:
# Generating circuit
with tf.device("device:XLA_CPU:0"):
dense1 = tf.add(tf.matmul(X, dense1_w)[0], dense1_b)
#y = tf.cast(dense1[0], tf.int32)
y = dense1[0]
# y = tf.cast(dense1, tf.int32)
#y = dense1
sess.run(tf.global_variables_initializer())
result = sess.run(y, {X: test})
# Print expected result
print("Result Calculated: " + str(result))
# Creating .mif files to initialize the memories
# To do this, go to <your_file>_ir_7.ll and check the list of params (inputs) and their sizes
param5 = dense1_w.eval()
param6 = dense1_b.eval()
mif.createMem([param5, test, param6])
#mif.createMem([test,param5,param6])
import sys
sys.path.append('../../src')
import processMif as mif
tf.logging.set_verbosity(tf.logging.INFO)
# Network Parameters
n_input = 1
n_output = 8
# tf Graph input
X = tf.placeholder(tf.float32, [None, n_input])
weights = tf.placeholder(tf.float32, [n_input, n_output])
biases = tf.placeholder(tf.float32, [n_output])
in_x = np.random.rand(1, n_input)
in_weights = np.random.rand(n_input, n_output)
in_biases = np.random.rand(n_output)
mif.createMem([in_weights, in_biases, in_x])
# matmul must be an array of arrays but add can only be one array
with tf.Session() as sess:
with tf.device("device:XLA_CPU:0"):
aux = tf.matmul(X, weights)
y = tf.add(biases, aux[0])
sess.run(tf.global_variables_initializer())
result = sess.run(y, {X: in_x, weights: in_weights, biases: in_biases})
np.save("tf_result.npy", result)
print(result)
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
# EVENT SHALL THE AUTHORS OR THE UNIVERSITY OF BRITISH COLUMBIA BE LIABLE
# FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
# IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#---------------------------------------------------------------------------
import tensorflow as tf
import numpy as np
import sys
sys.path.append('../../src')
import processMif as mif
size = 64
in_a = np.random.rand(size)
in_b = np.random.rand(size)
mif.createMem([in_a, in_b])
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Session() as sess:
x = tf.placeholder(tf.float32, [size])
z = tf.placeholder(tf.float32, [size])
with tf.device("device:XLA_CPU:0"):
y = x * z
result = sess.run(y, {x: in_a, z: in_b})
np.save("tf_result.npy", result)
print(result)
