def test_zero_system(self):
net = NeuralNet(3, 2, 4, 1, seed=0)
net.weights = [
np.zeros((3, 4)),
np.zeros((4, 4)),
np.zeros((4, 4)),
np.zeros((4, 1))
]
inpt = np.asarray([1, 1, 1])
print(net.forward(inpt))
for layer in net.forward(inpt)[1:]:
for neuron in layer:
assert neuron == 0.5
def __init__(self):
super().__init__()
self.setupUi(self)
self.scene = GraphicScene(self)
self.graphicsView.setScene(self.scene)
self.graphicsView.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignTop)
self.net = NeuralNet(1, 1, 1, 0)
self.checkButton.clicked.connect(self.netCheck)
self.clearButton.clicked.connect(self.clearGraphicsScene)
self.trainButton.clicked.connect(self.trainNetworkWithCurrentData)
self.addTrainDataButton.clicked.connect(self.addTrainDataToFile)
self.saveWeigthsButton.clicked.connect(self.saveWeights)
def __init__(self):
self.queue = Queue()
with open('config.json') as config_file:
self.config = json.load(config_file)
self.model = NeuralNet(self.config)
with open('params.json') as f:
self.load_params(json.load(f))
self.params = self.config['optimizer']['parameters']
self.params['params'] = self.model.parameters()
self.parameter_lengths = list(
map(lambda x: x.data.nelement(), self.model.parameters()))
self.optimizer = utils.create_object(**self.config['optimizer'])
self.accuracy = None
self.lock = Lock()
self.changed = True
self.params_updated = False
self.loader = utils.get_data()
self.convert_params()
self.compute_accuracy()
Thread(target=self.update_model, daemon=True).start()
def main():
app = QtWidgets.QApplication(sys.argv)
window = Window()
window.show()
#create net
n = 50
input_nodes = n * n
hidden_nodes = int(n * n / 10)
output_nodes = 10
learning_rate = 0.3
net = NeuralNet(input_nodes, hidden_nodes, output_nodes, learning_rate)
wih_data_file = open("wih.txt", 'r')
wih_data_list = wih_data_file.readlines()
wih_data_file.close()
who_data_file = open("who.txt", 'r')
who_data_list = who_data_file.readlines()
who_data_file.close()
if (len(wih_data_list) == len(net.wih)
and len(who_data_list) == len(net.who)):
for i in range(len(wih_data_list)):
string_values = wih_data_list[i].split(',')
float_values = numpy.asfarray(string_values)
net.wih[i] = float_values
for i in range(len(who_data_list)):
string_values = who_data_list[i].split(',')
float_values = numpy.asfarray(string_values)
net.who[i] = float_values
#set net to GUI app
window.setupNeuralNet(net)
app.exec_()
import numpy as np
from net import NeuralNet
net = NeuralNet(2, 1, 3, 1, 342047)
output_dot = False
inputs = np.array([[1, 1], [0, 0], [1, 0], [0, 1]])
outputs = np.array([[0], [0], [1], [1]])
for i in xrange(80000):
if i % 100 == 0:
print("epoch: {}\terror: {}".format(i, net.error(inputs, outputs)))
if output_dot:
open("/tmp/xor{:05d}graph".format(i),
mode="w").write(net.output_dot((inputs, outputs)))
net.learn(inputs, outputs, 0.05)
print("trained")
print("error: {}".format(net.error(inputs, outputs)))
for inpt in inputs:
print(net.forward(inpt))
import numpy as np from net import NeuralNet nn = NeuralNet([2, 3, 1]) nn.train(np.array([[1, 0], [0, 0]]), np.array([[1], [0]]))
class Model:
def __init__(self):
self.queue = Queue()
with open('config.json') as config_file:
self.config = json.load(config_file)
self.model = NeuralNet(self.config)
with open('params.json') as f:
self.load_params(json.load(f))
self.params = self.config['optimizer']['parameters']
self.params['params'] = self.model.parameters()
self.parameter_lengths = list(
map(lambda x: x.data.nelement(), self.model.parameters()))
self.optimizer = utils.create_object(**self.config['optimizer'])
self.accuracy = None
self.lock = Lock()
self.changed = True
self.params_updated = False
self.loader = utils.get_data()
self.convert_params()
self.compute_accuracy()
Thread(target=self.update_model, daemon=True).start()
def get_parameters(self):
return self.config
def check_parameters(self, parameters):
try:
return (len(parameters) == len(self.parameter_lengths) and all(
map(lambda x, y: len(x) == y, parameters,
self.parameter_lengths)))
except TypeError:
return False
def convert_params(self):
if self.changed:
with self.lock:
utils.log('Updating parameters JSON')
self.params['params'] = utils.convert_model_parameters_to_list(
self.model.parameters())
with open('params/%s.json' % utils.now(), 'w') as f:
json.dump(self.params['params'], f)
self.changed = False
self.params_updated = True
timer = Timer(P.update_json_time, self.convert_params)
timer.daemon = True
timer.start()
def compute_accuracy(self):
if self.params_updated:
with self.lock:
utils.log('Computing model accuracy')
self.accuracy = self.test()
self.params_updated = False
timer = Timer(P.test_model_time, self.compute_accuracy)
timer.daemon = True
timer.start()
def update_model(self):
while True:
try:
parameters = utils.parse_model_parameters_from_list(
self.queue.get())
with self.lock:
utils.log('Updating model')
utils.merge(self.model.parameters(), parameters,
P.merge_ratio)
self.changed = True
except ValueError as v:
print(v, end='\n' + '*' * 40 + '\n')
def test(self):
return utils.test(self.model, self.loader)
def merge(self, parameters):
self.queue.put_nowait(parameters)
def load_params(self, lst):
utils.merge(self.model.parameters(),
utils.parse_model_parameters_from_list(lst), 0)
def get_net(config_layers):
"""
Given the layers section in a config file,
return a network with the described layers
!!Not yet support for Convolutional layers
"""
layer_names = []
linear_layer_sizes = []
init_scale = 0.1
c = 0
conv_params = []
for i, key in enumerate(config_layers):
layer_list = config_layers[key].split(sep=' ')
if key == "init_scale":
init_scale = float(config_layers[key])
else:
layer_names.append(layer_list[0])
if "size" in layer_list:
index = layer_list.index("size") + 1
sizes = layer_list[index].split(sep=',')
sizes = [int(sizes[0]), int(sizes[1])]
linear_layer_sizes.append(sizes)
elif "ConvolutionLayer" in layer_list:
index_size = layer_list.index("input_size") + 1
if "scale" in layer_list:
index_scale = layer_list.index("scale") + 1
else:
i_s = layer_list.index("s") + 1
i_p = layer_list.index("p") + 1
i_k = layer_list.index("k") + 1
index_channels_o = layer_list.index("channels_out") + 1
index_channels_i = layer_list.index("channels_in") + 1
index_dim = layer_list.index("dim") + 1
conv_params.append({
"is": int(layer_list[index_size]),
"ci": int(layer_list[index_channels_i]),
"co": int(layer_list[index_channels_o]),
"dim": int(layer_list[index_dim])
})
if "scale" in layer_list:
conv_params[-1]["sc"] = float(layer_list[index_scale])
else:
conv_params[-1]["spk"] = {
"s": int(layer_list[i_s]),
"p": int(layer_list[i_p]),
"k": int(layer_list[i_k])
}
layers = []
for layer_name in layer_names:
if layer_name == "LinearLayer":
sizes = linear_layer_sizes.pop(0)
layers.append(LinearLayer(sizes[0], sizes[1], init_scale))
elif layer_name == "ConvolutionLayer":
params = conv_params.pop(0)
if "sc" in params:
valid_configs = get_cnn_configurations(params["is"],
params["sc"])[0]
layers.append(
ConvolutionLayer(params["ci"], params["co"],
valid_configs["f"], params["is"],
params["dim"], valid_configs["s"],
valid_configs["p"], init_scale))
else:
layers.append(
ConvolutionLayer(params["ci"], params["co"],
params["spk"]["k"], params["is"],
params["dim"], params["spk"]["s"],
params["spk"]["p"], init_scale))
else:
layers.append(eval(layer_name)())
net = NeuralNet(layers)
return net
class Window(QtWidgets.QWidget, design.Ui_Form):
def __init__(self):
super().__init__()
self.setupUi(self)
self.scene = GraphicScene(self)
self.graphicsView.setScene(self.scene)
self.graphicsView.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignTop)
self.net = NeuralNet(1, 1, 1, 0)
self.checkButton.clicked.connect(self.netCheck)
self.clearButton.clicked.connect(self.clearGraphicsScene)
self.trainButton.clicked.connect(self.trainNetworkWithCurrentData)
self.addTrainDataButton.clicked.connect(self.addTrainDataToFile)
self.saveWeigthsButton.clicked.connect(self.saveWeights)
def setupNeuralNet(self, net):
self.net = net
def saveWeights(self):
wih_data_file = open("wih.txt", 'w+')
who_data_file = open("who.txt", 'w+')
for i in range(len(self.net.who)):
for j in range(len(self.net.who[i])):
if j < len(self.net.who[i]) - 1:
who_data_file.write(str(self.net.who[i][j]) + ",")
else:
who_data_file.write(str(self.net.who[i][j]))
who_data_file.write("\n")
for i in range(len(self.net.wih)):
for j in range(len(self.net.wih[i])):
if j < len(self.net.wih[i]) - 1:
wih_data_file.write(str(self.net.wih[i][j]) + ",")
else:
wih_data_file.write(str(self.net.wih[i][j]))
wih_data_file.write("\n")
wih_data_file.close()
who_data_file.close()
def clearGraphicsScene(self):
self.scene.clear()
def trainNetwork(self):
self.net.trainByself()
def trainNetworkWithCurrentData(self):
#получить картинку (pixmap) из view
self.scene.pixmap = self.graphicsView.grab(
QtCore.QRect(1, 1, self.scene.rectX, self.scene.rectY))
self.scene.image = self.scene.pixmap.toImage()
#записать цвет каждого пикселя в матрицу размерностью картинки (56x56)
w = self.scene.image.width()
h = self.scene.image.height()
inputs = [0] * (w * h)
for y in range(h):
for x in range(w):
inputs[y * h + x] = self.scene.image.pixelColor(x, y).black()
target = self.spinBox.value()
self.net.trainWithCurrentData(inputs, target)
self.clearGraphicsScene()
def addTrainDataToFile(self):
self.scene.pixmap = self.graphicsView.grab(
QtCore.QRect(1, 1, self.scene.rectX, self.scene.rectY))
self.scene.image = self.scene.pixmap.toImage()
#записать цвет каждого пикселя в матрицу размерностью картинки (56x56)
w = self.scene.image.width()
h = self.scene.image.height()
data = [0] * (w * h + 1)
for y in range(h):
for x in range(w):
data[y * h + x + 1] = self.scene.image.pixelColor(x, y).black()
target = self.spinBox.value()
data[0] = target
train_data_file = open("train_data.txt", 'a')
for i in range(len(data)):
if i < len(data) - 1:
train_data_file.write(str(data[i]) + ",")
else:
train_data_file.write(str(data[i]))
train_data_file.write("\n")
train_data_file.close()
self.clearGraphicsScene()
def netCheck(self):
#получить картинку (pixmap) из view
self.scene.pixmap = self.graphicsView.grab(
QtCore.QRect(1, 1, self.scene.rectX, self.scene.rectY))
self.scene.image = self.scene.pixmap.toImage()
#записать цвет каждого пикселя в матрицу размерностью картинки (56x56)
w = self.scene.image.width()
h = self.scene.image.height()
all_values = [0] * (w * h)
for y in range(h):
for x in range(w):
all_values[y * h + x] = self.scene.image.pixelColor(x,
y).black()
#отправить список пикселей в нейросеть для проверки
inputs = (numpy.asfarray(all_values[0:]) / 255.0 * 0.99) + 0.01
final_outputs = self.net.query(inputs)
def train(net: NeuralNet,
inputs,
targets,
num_epochs=100,
batch_size=5,
loss=CrossEntropy(),
optimizer=Optimizer(),
regularizer=False,
validation=True,
verbose=False):
"""
inputs.shape = [sample_size,n_samples]
targets.shape = [target_shape,n_samples]
"""
reg_cost = lambda x: 0
if regularizer:
reg_cost = regularizer.reg
if validation:
validator = Validation(inputs, targets, validation_fraction=0.2)
inputs = inputs[..., 0:validator.train_size]
targets = targets[..., 0:validator.train_size]
epoch_losses = []
for epoch in range(num_epochs):
epoch_loss = 0.0
starts = np.arange(0, len(inputs[-1]), batch_size)
np.random.shuffle(starts)
for start in starts:
end = start + batch_size
num_batches = len(starts)
predicted = net.forward(inputs[..., start:end], verbose=verbose)
epoch_loss += loss.loss(
predicted, targets[...,
start:end]) / num_batches #+ reg_cost(net)
grad = loss.grad(predicted, targets[..., start:end])
net.backward(grad, verbose=verbose)
if not isinstance(regularizer, bool):
net.backward_regularizer(regularizer.grad_func)
optimizer.step(net)
if validation:
validator.validate(net, loss)
print(epoch, epoch_loss)
epoch_losses.append(epoch_loss)
if validation:
plt.plot(np.linspace(0, num_epochs,
num_epochs // validator.validation_freq),
validator.v_errors,
label="Validation")
plt.plot(np.linspace(0, num_epochs, num_epochs),
epoch_losses,
label="Training")
plt.legend()