Or Perets - 1 year ago 129

Python Question

I`m just finished to write neural net with tensorflow

attached code :

`import tensorflow as tensorFlow`

import csv

# read data from csv

file = open('stub.csv')

reader = csv.reader(file)

temp = list(reader)

del temp[0]

# change data from string to float (Tensorflow)

# create data & goal lists

data = []

goal = []

for i in range(len(temp)):

data.append(map(float, temp[i]))

goal.append([data[i][6], 0.0])

del data[i][6]

# change lists to tuple

data = tuple(tuple(x) for x in data)

goal = tuple(goal)

# create training data and test data by 70-30

a = int(len(data) * 0.6) # training set 60%

b = int(len(data) * 0.8) # validation & test: each one is 20%

trainData = data[0:a] # 60%

validationData = data[b: len(data)]

testData = data[a: b] # 20%

trainGoal = goal[0:a]

validationGoal = goal[b:len(data)]

testGoal = goal[a: b]

numberOfLayers = 500

nodesLayer = []

# define the numbers of nodes in hidden layers

for i in range(numberOfLayers):

nodesLayer.append(500)

# define our goal class

classes = 2

batchSize = 2000

# x for input, y for output

sizeOfRow = len(data[0])

x = tensorFlow.placeholder(dtype= tensorFlow.float32, shape=[None, sizeOfRow])

y = tensorFlow.placeholder(dtype= tensorFlow.float32, shape=[None, classes])

hiddenLayers = []

layers = []

def neuralNetworkModel(x):

# first step: (input * weights) + bias, linear operation like y = ax + b

# each layer connection to other layer will represent by nodes(i) * nodes(i+1)

for i in range(0,numberOfLayers):

if i == 0:

hiddenLayers.append({"weights": tensorFlow.Variable(tensorFlow.random_normal([sizeOfRow, nodesLayer[i]])),

"biases": tensorFlow.Variable(tensorFlow.random_normal([nodesLayer[i]]))})

elif i > 0 and i < numberOfLayers-1:

hiddenLayers.append({"weights" : tensorFlow.Variable(tensorFlow.random_normal([nodesLayer[i], nodesLayer[i+1]])),

"biases" : tensorFlow.Variable(tensorFlow.random_normal([nodesLayer[i+1]]))})

else:

outputLayer = {"weights": tensorFlow.Variable(tensorFlow.random_normal([nodesLayer[i], classes])),

"biases": tensorFlow.Variable(tensorFlow.random_normal([classes]))}

# create the layers

for i in range(numberOfLayers):

if i == 0:

layers.append(tensorFlow.add(tensorFlow.matmul(x, hiddenLayers[i]["weights"]), hiddenLayers[i]["biases"]))

layers.append(tensorFlow.nn.relu(layers[i])) # pass values to activation function (i.e sigmoid, softmax) and add it to the layer

elif i >0 and i < numberOfLayers-1:

layers.append(tensorFlow.add(tensorFlow.matmul(layers[i-1], hiddenLayers[i]["weights"]), hiddenLayers[i]["biases"]))

layers.append(tensorFlow.nn.relu(layers[i]))

output = tensorFlow.matmul(layers[numberOfLayers-1], outputLayer["weights"]) + outputLayer["biases"]

return output

def neuralNetworkTrain(data, x, y):

prediction = neuralNetworkModel(x)

# using softmax function, normalize values to range(0,1)

cost = tensorFlow.reduce_mean(tensorFlow.nn.softmax_cross_entropy_with_logits(prediction, y))

# minimize the cost function

# using AdamOptimizer algorithm

optimizer = tensorFlow.train.AdadeltaOptimizer().minimize(cost)

epochs = 2 # feed machine forward + backpropagation = epoch

# build sessions and train the model

with tensorFlow.Session() as sess:

sess.run(tensorFlow.initialize_all_variables())

for epoch in range(epochs):

epochLoss = 0

i = 0

for _ in range(int(len(data) / batchSize)):

ex, ey = nextBatch(i) # takes 500 examples

i += 1

feedDict = {x :ex, y:ey }

_, cos = sess.run([optimizer,cost], feed_dict= feedDict) # start session to optimize the cost function

epochLoss += cos

print("Epoch", epoch + 1, "completed out of", epochs, "loss:", epochLoss)

correct = tensorFlow.equal(tensorFlow.argmax(prediction,1), tensorFlow.argmax(y, 1))

accuracy = tensorFlow.reduce_mean(tensorFlow.cast(correct, "float"))

print("Accuracy:", accuracy.eval({ x: trainData, y:trainGoal}))

# takes 500 examples each iteration

def nextBatch(num):

# Return the next `batch_size` examples from this data set.

# case: using our data & batch size

num *= batchSize

if num < (len(data) - batchSize):

return data[num: num+batchSize], goal[num: num +batchSize]

neuralNetworkTrain(trainData, x, y)

each epoch (iteration) I`ve got the value of loss function and all good.

now I want to try it on my validation/test set.

Someone now what should I do exactly?

Thanks

Recommended for you: Get network issues from **WhatsUp Gold**. **Not end users.**

Answer Source

If you want to get predictions on the trained data you can simply put something like:

```
tf_p = tf.nn.softmax(prediction)
```

...In your graph, having loaded your test data into `x_test`

. Then evaluate predictions with:

```
[p] = session.run([tf_p], feed_dict = {
x : x_test,
y : y_test
}
)
```

at the end of your `neuralNetworkTrain`

method, and you should end up having them in `p`

.

Recommended from our users: **Dynamic Network Monitoring from WhatsUp Gold from IPSwitch**. ** Free Download**