在开始之前和结束之后检查体重，偏倚都会改变。 损失值不断减少
问题是准确性值从未动过
这是我的代码，其中有一部分
这段代码只是在制造重量和偏见
class variableDataSet:
def __set_Random_Weight__(self):
self.W1 = np.random.rand(2, 5)
self.W5 = np.random.rand(5, 2)
def __set_Random_bias__(self):
self.b = np.random.rand(5)
self.b_out = np.random.rand(2)
def create_Datas(self):
self.__set_Random_Weight__()
self.__set_Random_bias__()
这是我的训练数据集
set_x_data （）和 set_y_data （）是创建x_data和y_data这是训练数据集
x_data创建类似array（50〜1000，1）的外部联接array（0.5〜10，0.5）
accuracy_rate （）只是从x_data创建y_data的过程
classify_Data_Set （）是对训练数据和验证数据进行细化和分类
class trainingDataSet:
idealTargetArea = 1.0
idealTargetDistance = 100.0
tryCount = 5
def __set_x_data__(self):
#distance
self.distance = np.arange(50, 1000, 1.0)
#target area
self.area = np.arange(0.5, 10, 0.5)
temp_data = np.zeros(shape=(self.area.size, self.distance.size, 2))
for i in range(self.distance.size):
for j in range(self.area.size):
temp_data[j][i] = np.array([self.distance[i], self.area[j]])
self.x_data = temp_data
def __accuracy_rate__(self, inputData, givenAccuracy):
idealAccuracyWithGivenArea = givenAccuracy * (inputData[1] / self.idealTargetArea)
coefficient = (self.idealTargetDistance / inputData[0]) ** 2
seeArea = coefficient * inputData[1]
ratio = seeArea * inputData[1]
return idealAccuracyWithGivenArea * ratio
def __set_y_data__(self, x_data, givenAccuracy, efficiency):
pos = posibility.Posibility()
self.y_data = np.zeros(shape=(np.size(x_data, 0), np.size(x_data, 1), 2))
for i in range(np.size(x_data, 0)):
for j in range(np.size(x_data, 1)):
accuracy = self.__accuracy_rate__(x_data[i][j], givenAccuracy)
correct = pos.result(self.tryCount, accuracy, int(efficiency * self.tryCount))
if(correct >= efficiency):
temp = np.array([0, 1])
else:
temp = np.array([1, 0])
self.y_data[i][j] = temp
def __classify_Data_Set__(self):
r1 = np.random.permutation(self.x_data.shape[0])
r2 = np.random.permutation(self.x_data.shape[1])
input1 = r1[int(r1.size * 0.7):]
input2 = r2[int(r2.size * 0.7):]
x_validation = np.zeros(shape=(input1.size, input2.size, self.x_data.shape[2]))
y_validation = np.zeros(shape=(input1.size, input2.size, self.y_data.shape[2]))
for i in range(input1.size):
for j in range(input2.size):
x_validation[i][j] = np.array([self.x_data[input1[i]][input2[j]]])
y_validation[i][j] = np.array([self.y_data[input1[i]][input2[j]]])
self.x_validation = x_validation
self.y_validation = y_validation
input1 = r1[:int(r1.size * 0.7)]
input2 = r2[:int(r2.size * 0.7)]
x_data = np.zeros(shape=(input1.size, input2.size, self.x_data.shape[2]))
y_data = np.zeros(shape=(input1.size, input2.size, self.y_data.shape[2]))
for i in range(input1.size):
for j in range(input2.size):
x_data[i][j] = np.array([self.x_data[input1[i]][input2[j]]])
y_data[i][j] = np.array([self.y_data[input1[i]][input2[j]]])
self.x_data = x_data
self.y_data = y_data
def create_Datas(self, accuracy, efficiency):
self.accuracy = accuracy
self.efficiency = efficiency
self.__set_x_data__()
self.__set_y_data__(self.x_data, self.accuracy, self.efficiency)
self.__classify_Data_Set__()
self.__write_Data__()
这是我的假设
隐藏层的活动函数为S型，而最后一层的活动函数为softmax
class fireDecision:
SCALE_X = 1000
def __init__(self):
self.sess = tf.Session()
def Session(self):
return self.sess
def algorithm(self, x):
x = x / self.SCALE_X
hidden_layer1 = tf.sigmoid(tf.matmul(x, self.W1) + self.b)
out_layer = tf.nn.softmax(tf.matmul(hidden_layer1, self.W5) + self.b_out)
return out_layer
这是教练代码
损失函数是交叉熵，优化器是梯度下降
class trainer:
def __loss__(self, hypothesis, y):
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y * tf.log(hypothesis), reduction_indices=[1]))
return cross_entropy
def __train__(self, loss):
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)
train = optimizer.minimize(loss)
return train
def __accuracy__(self, hypothesis, y):
correct_prediction = tf.equal(tf.argmax(hypothesis, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
return accuracy
def check_accuracy(self, x, y, epoch, hypothesis, sess):
accuracy_test = self.__accuracy__(hypothesis, y)
self.accuracy[epoch] = sess.run(accuracy_test, feed_dict={x:self.x_validation, y:self.y_validation})
print("accuracy : " + str(self.accuracy[epoch]))
def training(self, network, data_set, train_Epoch):
self.set_training_data_set(data_set)
self.set_validation_data_set(data_set)
//network is fireDecision class
sess = network.Session()
x= tf.placeholder(tf.float32, shape=[None, 2], name='x')
y= tf.placeholder(tf.float32, shape=[None, 2], name='y')
hypothesis = network.algorithm(x)
loss = self.__loss__(hypothesis, y)
train = self.__train__(loss)
epochs = train_Epoch//I was input epoch 2000
self.losses = np.zeros(epochs)
self.accuracy = np.zeros(epochs)
loop = self.x_data.shape[0] * self.x_data.shape[1]
x_data_input = np.zeros((loop, 2))
y_data_input = np.zeros((loop, 2))
print("Training Step")
for step in range(epochs):
print("Step : " + str(step))
count = 0
for i in range(self.x_data.shape[0]):
for j in range(self.x_data.shape[1]):
x_data_input[count] = self.x_data[i][j]
y_data_input[count] = self.y_data[i][j]
count += 1
h, _, l = sess.run([hypothesis, train, loss], feed_dict={x:x_data_input, y:y_data_input})
self.losses[step] = l
print("Loss : " + str(self.losses[step]))
self.check_accuracy(x, y, step, hypothesis, sess)
如果要运行我的代码，这是我代码的空洞
import numpy as np
class rwFromDirectory:
def __init(self):
pass
def write_data(self, file_path, write_data):
np.savetxt(file_path, write_data)
def read_data(self, file_path):
return np.loadtxt(file_path).astype(np.float32)
import rwFromDirectory
import numpy as np
class variableDataSet:
def __init__(self):
self.W1 = None
self.W5 = None
self.b = None
self.b_out = None
self.rw = rwFromDirectory.rwFromDirectory()
def __set_Random_Weight__(self):
self.W1 = np.random.rand(2, 5)
self.W5 = np.random.rand(5, 2)
def __set_Random_bias__(self):
self.b = np.random.rand(5)
self.b_out = np.random.rand(2)
def create_Datas(self):
self.__set_Random_Weight__()
self.__set_Random_bias__()
self.write_Datas()
def set_Datas(self, W1, W5, b, b_out):
self.W1 = W1
self.W5 = W5
self.b = b
self.b_out = b_out
def write_Datas(self):
self.rw.write_data('./model_data/W1', self.W1)
self.rw.write_data('./model_data/W5', self.W5)
self.rw.write_data('./model_data/b', self.b)
self.rw.write_data('./model_data/b_out', self.b_out)
def read_Datas(self):
self.W1 = self.rw.read_data('./model_data/W1')
self.W5 = self.rw.read_data('./model_data/W5')
self.b = self.rw.read_data('./model_data/b')
self.b_out = self.rw.read_data('./model_data/b_out')
def get_W1(self):
return self.W1
def get_W5(self):
return self.W5
def get_b(self):
return self.b
def get_b_out(self):
return self.b_out
class Posibility:
def __init__(self):
pass
def __factorial__(self, n):
result = 1
for i in range(n):
result *= (i + 1)
return result
def __Combination__(self, tryCount, hopeResult):
result = self.__factorial__(tryCount) / (self.__factorial__(tryCount - hopeResult) * self.__factorial__(hopeResult))
return result
def result(self, tryCount, probability, hopeResult):
result = self.__Combination__(tryCount, hopeResult) * pow(probability, hopeResult) * pow((1 - probability), (tryCount - hopeResult))
return result
import posibility
import numpy as np
import rwFromDirectory
class trainingDataSet:
idealTargetArea = 1.0
idealTargetDistance = 100.0
tryCount = 5
def __init__(self):
self.x_data = None
self.y_data = None
self.accuracy = None
self.efficiency = None
self.rw = rwFromDirectory.rwFromDirectory()
def __set_x_data__(self):
#distance
self.distance = np.arange(50, 1000, 1.0)
#target area
self.area = np.arange(0.5, 10, 0.5)
temp_data = np.zeros(shape=(self.area.size, self.distance.size, 2))
for i in range(self.distance.size):
for j in range(self.area.size):
temp_data[j][i] = np.array([self.distance[i], self.area[j]])
self.x_data = temp_data
def __accuracy_rate__(self, inputData, givenAccuracy):
idealAccuracyWithGivenArea = givenAccuracy * (inputData[1] / self.idealTargetArea)
coefficient = (self.idealTargetDistance / inputData[0]) ** 2
seeArea = coefficient * inputData[1]
ratio = seeArea * inputData[1]
return idealAccuracyWithGivenArea * ratio
def __set_y_data__(self, x_data, givenAccuracy, efficiency):
pos = posibility.Posibility()
self.y_data = np.zeros(shape=(np.size(x_data, 0), np.size(x_data, 1), 2))
for i in range(np.size(x_data, 0)):
for j in range(np.size(x_data, 1)):
accuracy = self.__accuracy_rate__(x_data[i][j], givenAccuracy)
correct = pos.result(self.tryCount, accuracy, int(efficiency * self.tryCount))
if(correct >= efficiency):
temp = np.array([0, 1])
else:
temp = np.array([1, 0])
self.y_data[i][j] = temp
def __classify_Data_Set__(self):
r1 = np.random.permutation(self.x_data.shape[0])
r2 = np.random.permutation(self.x_data.shape[1])
input1 = r1[int(r1.size * 0.7):]
input2 = r2[int(r2.size * 0.7):]
x_validation = np.zeros(shape=(input1.size, input2.size, self.x_data.shape[2]))
y_validation = np.zeros(shape=(input1.size, input2.size, self.y_data.shape[2]))
for i in range(input1.size):
for j in range(input2.size):
x_validation[i][j] = np.array([self.x_data[input1[i]][input2[j]]])
y_validation[i][j] = np.array([self.y_data[input1[i]][input2[j]]])
self.x_validation = x_validation
self.y_validation = y_validation
input1 = r1[:int(r1.size * 0.7)]
input2 = r2[:int(r2.size * 0.7)]
x_data = np.zeros(shape=(input1.size, input2.size, self.x_data.shape[2]))
y_data = np.zeros(shape=(input1.size, input2.size, self.y_data.shape[2]))
for i in range(input1.size):
for j in range(input2.size):
x_data[i][j] = np.array([self.x_data[input1[i]][input2[j]]])
y_data[i][j] = np.array([self.y_data[input1[i]][input2[j]]])
self.x_data = x_data
self.y_data = y_data
def __write_Data__(self):
size = np.array([[self.x_data.shape[0], self.x_data.shape[1], self.x_data.shape[2]], [self.y_data.shape[0], self.y_data.shape[1], self.y_data.shape[2]]])
self.rw.write_data('./model_data/xy_size', size)
temp_Array = self.x_data
temp_Array = temp_Array.reshape((self.x_data.size))
self.rw.write_data('./model_data/x_data', temp_Array)
temp_Array = self.y_data
temp_Array = temp_Array.reshape((self.y_data.size))
self.rw.write_data('./model_data/y_data', temp_Array)
array = np.array([self.accuracy, self.efficiency])
self.rw.write_data('./model_data/etc', array)
size = np.array([[self.x_validation.shape[0], self.x_validation.shape[1], self.x_validation.shape[2]], [self.y_validation.shape[0], self.y_validation.shape[1], self.y_validation.shape[2]]])
self.rw.write_data('./model_data/xy_validation_size', size)
temp_Array = self.x_validation
temp_Array = temp_Array.reshape((self.x_validation.size))
self.rw.write_data('./model_data/x_validation', temp_Array)
temp_Array = self.y_validation
temp_Array = temp_Array.reshape((self.y_validation.size))
self.rw.write_data('./model_data/y_validation', temp_Array)
def create_Datas(self, accuracy, efficiency):
self.accuracy = accuracy
self.efficiency = efficiency
self.__set_x_data__()
self.__set_y_data__(self.x_data, self.accuracy, self.efficiency)
self.__classify_Data_Set__()
self.__write_Data__()
def read_Datas(self):
xy_size = self.rw.read_data('./model_data/xy_size')
array = self.rw.read_data('./model_data/x_data')
self.x_data = array.reshape((int(xy_size[0][0]), int(xy_size[0][1]), int(xy_size[0][2])))
array = self.rw.read_data('./model_data/y_data')
self.y_data = array.reshape((int(xy_size[1][0]), int(xy_size[1][1]), int(xy_size[1][2])))
array = self.rw.read_data('./model_data/etc')
self.accuracy = array[0]
self.efficiency = array[1]
xy_validation_size = self.rw.read_data('./model_data/xy_validation_size')
array = self.rw.read_data('./model_data/x_validation')
self.x_validation = array.reshape((int(xy_validation_size[0][0]), int(xy_validation_size[0][1]), int(xy_validation_size[0][2])))
array = self.rw.read_data('./model_data/y_validation')
self.y_validation = array.reshape((int(xy_validation_size[0][0]), int(xy_validation_size[0][1]), int(xy_validation_size[0][2])))
def get_x_data(self):
return self.x_data
def get_y_data(self):
return self.y_data
def get_accuracy(self):
return self.accuracy
def get_efficiency(self):
return self.efficiency
def get_x_validation(self):
return self.x_validation
def get_y_validation(self):
return self.y_validation
import variableDataSet
import numpy as np
import tensorflow as tf
class fireDecision:
SCALE_X = 1000
set_test = False
set_train = False
def __init__(self):
self.sess = tf.Session()
def __read_Data__(self):
v = variableDataSet.variableDataSet()
v.read_Datas()
return v
def __set_Train__(self):
v = self.__read_Data__()
self.W1 = tf.Variable(v.get_W1(), dtype = tf.float32)
self.W5 = tf.Variable(v.get_W5(), dtype = tf.float32)
self.b = tf.Variable(v.get_b(), dtype = tf.float32)
self.b_out = tf.Variable(v.get_b_out(), dtype = tf.float32)
self.sess.run(tf.global_variables_initializer())
def __set_Test__(self):
v = self.__read_Data__()
self.W1 = v.get_W1()
self.W5 = v.get_W5()
self.b = v.get_b()
self.b_out = v.get_b_out()
def write_data(self):
v = variableDataSet.variableDataSet()
W1 = self.sess.run(self.W1)
W5 = self.sess.run(self.W5)
b = np.array([self.sess.run(self.b)])
b_out = np.array([self.sess.run(self.b_out)])
v.set_Datas(W1, W5, b, b_out)
v.write_Datas()
def Session(self):
return self.sess
def algorithm(self, x):
if(not self.set_train):
self.set_test = False
self.set_train = True
self.__set_Train__()
x = x / self.SCALE_X
hidden_layer1 = tf.sigmoid(tf.matmul(x, self.W1) + self.b)
out_layer = tf.nn.softmax(tf.matmul(hidden_layer1, self.W5) + self.b_out)
return out_layer
def decision(self, distance, targetArea):
self.input = np.array([[distance/self.SCALE_X, targetArea]])
if(not self.set_test):
self.set_test = True
self.set_train = False
self.__set_Test__()
return self.sess.run(self.algorithm(self.input))
import rwFromDirectory
import numpy as np
import tensorflow as tf
class trainer:
def __init__(self):
self.rw = rwFromDirectory.rwFromDirectory()
def __loss__(self, hypothesis, y):
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y * tf.log(hypothesis), reduction_indices=[1]))
return cross_entropy
def __train__(self, loss):
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1)
train = optimizer.minimize(loss)
return train
def set_training_data_set(self, trainingDataSet):
self.x_data = trainingDataSet.get_x_data()
self.y_data = trainingDataSet.get_y_data()
def __set_validation__(self):
x_validation_ = np.zeros((self.x_validation.shape[0] * self.x_validation.shape[1], self.x_validation.shape[2]))
y_validation_ = np.zeros((self.y_validation.shape[0] * self.y_validation.shape[1], self.y_validation.shape[2]))
for i in range(self.x_validation.shape[0]):
count = 0
for j in range(self.x_validation.shape[1]):
x_validation_[count] = self.x_validation[i][j]
y_validation_[count] = self.y_validation[i][j]
count += 1
self.x_validation = x_validation_
self.y_validation = y_validation_
def set_validation_data_set(self, trainingDataSet):
self.x_validation = trainingDataSet.get_x_validation()
self.y_validation = trainingDataSet.get_y_validation()
self.__set_validation__()
def __accuracy__(self, hypothesis, y):
correct_prediction = tf.equal(tf.argmax(hypothesis, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
return accuracy
def check_accuracy(self, x, y, epoch, hypothesis, sess):
accuracy_test = self.__accuracy__(hypothesis, y)
self.accuracy[epoch] = sess.run(accuracy_test, feed_dict={x:self.x_validation, y:self.y_validation})
print("accuracy : " + str(self.accuracy[epoch]))
def training(self, network, data_set, train_Epoch):
self.set_training_data_set(data_set)
self.set_validation_data_set(data_set)
sess = network.Session()
x= tf.placeholder(tf.float32, shape=[None, 2], name='x')
y= tf.placeholder(tf.float32, shape=[None, 2], name='y')
hypothesis = network.algorithm(x)
loss = self.__loss__(hypothesis, y)
train = self.__train__(loss)
epochs = train_Epoch
self.losses = np.zeros(epochs)
self.accuracy = np.zeros(epochs)
loop = self.x_data.shape[0] * self.x_data.shape[1]
x_data_input = np.zeros((loop, 2))
y_data_input = np.zeros((loop, 2))
print("Training Step")
for step in range(epochs):
print("Step : " + str(step))
count = 0
for i in range(self.x_data.shape[0]):
for j in range(self.x_data.shape[1]):
x_data_input[count] = self.x_data[i][j]
y_data_input[count] = self.y_data[i][j]
count += 1
h, _, l = sess.run([hypothesis, train, loss], feed_dict={x:x_data_input, y:y_data_input})
self.losses[step] = l
print("Loss : " + str(self.losses[step]))
self.check_accuracy(x, y, step, hypothesis, sess)
self.write_result(network)
def write_result(self, network):
network.write_data()
self.rw.write_data('./model_data/losses', self.losses)
self.rw.write_data('./model_data/accuracy', self.accuracy)
您可以以此运行代码
import fireDecision
fireDecision = fireDecision.fireDecision()
import trainingDataSet
trainingDataSet = trainingDataSet.trainingDataSet()
trainingDataSet.create_Datas(0.8, 0.6)
import variableDataSet
variableDataSet = variableDataSet.variableDataSet()
variableDataSet.create_Datas()
import trainer
trainer = trainer.trainer()
trainer.training(fireDecision, trainingDataSet, 2000)