示例#1
0
def exportCatDogRNN(net, fileName=root.path() + "/res/cat_dog_nm_params"):
    # arr = net.params
    # np.save(fileName, arr)
    # fileObject = open(fileName+'.pickle', 'w')
    # pickle.dump(net, fileObject)
    # fileObject.close()
    NetworkWriter.writeToFile(net, fileName + '.xml')
示例#2
0
def exportCatDogRFCNN(net, fileName = root.path()+"/res/cat_dog_fc_params"):
    # arr = net.params
    # np.save(fileName, arr)
    # fileObject = open(fileName+'.pickle', 'w')
    # pickle.dump(net, fileObject)
    # fileObject.close()
    NetworkWriter.writeToFile(net, fileName+'.xml')
示例#3
0
def xmlInvariance(n, forwardpasses = 1):
    """ try writing a network to an xml file, reading it, rewrite it, reread it, and compare
    if the result looks the same (compare string representation, and forward processing 
    of some random inputs) """
    tmpfile = tempfile.NamedTemporaryFile()
    f = tmpfile.name
    NetworkWriter.writeToFile(n, f)
    tmpnet = NetworkReader.readFrom(f)
    NetworkWriter.writeToFile(tmpnet, f)
    endnet = NetworkReader.readFrom(f)
    netCompare(tmpnet, endnet, forwardpasses, True)
示例#4
0
def xmlInvariance(n, forwardpasses=1):
    """ try writing a network to an xml file, reading it, rewrite it, reread it, and compare
    if the result looks the same (compare string representation, and forward processing 
    of some random inputs) """
    tmpfile = tempfile.NamedTemporaryFile()
    f = tmpfile.name
    NetworkWriter.writeToFile(n, f)
    tmpnet = NetworkReader.readFrom(f)
    NetworkWriter.writeToFile(tmpnet, f)
    endnet = NetworkReader.readFrom(f)
    netCompare(tmpnet, endnet, forwardpasses, True)
 def build_net(self):
     if os.path.exists(self.NET_FILE):
         return NetworkReader.readFrom(self.NET_FILE)
     ds = ClassificationDataSet(len(feats), nb_classes=len(classes))
     for c in classes:
         print c
         with codecs.open(os.path.join(self.data_root, c+".txt"), 'r', 'utf8') as f:
             for line in f:
                 r = Record("11", line, c, "")
                 ds.appendLinked(r.features(), [r.class_idx()])
     ds._convertToOneOfMany([0, 1])
     net = buildNetwork(ds.indim, int((ds.indim + ds.outdim)/2), ds.outdim, bias=True, hiddenclass=TanhLayer, outclass=SoftmaxLayer)
     trainer = BackpropTrainer(net, ds, momentum=0.75, verbose=True)
     trainer.trainUntilConvergence(maxEpochs=300)
     NetworkWriter.writeToFile(net, self.NET_FILE)
     return net
def train():
    f = open('train.csv', 'r')

    csv_reader = csv.reader(f)

    dataset = SupervisedDataSet(64, 1)
    for d in csv_reader:
        dataset.addSample(d[0:64], d[64])

    network = buildNetwork(64, 19, 1)
    trainer = BackpropTrainer(network, dataset)
    for i in range(100):
        trainer.train()

    NetworkWriter.writeToFile(network, "model.xml")

    f.close()
示例#7
0
文件: helpers.py 项目: bayerj/pybrain
def xmlInvariance(n, forwardpasses = 1):
    """ try writing a network to an xml file, reading it, rewrite it, reread it, and compare
    if the result looks the same (compare string representation, and forward processing 
    of some random inputs) """
    # We only use this for file creation.
    tmpfile = tempfile.NamedTemporaryFile(dir=".")
    f = tmpfile.name
    tmpfile.close()

    NetworkWriter.writeToFile(n, f)
    tmpnet = NetworkReader.readFrom(f)
    NetworkWriter.writeToFile(tmpnet, f)
    endnet = NetworkReader.readFrom(f)

    # Unlink temporary file.
    os.unlink(f)

    netCompare(tmpnet, endnet, forwardpasses, True)
def train():
    f = open('train_tower.csv', 'r')

    csvreader = csv.reader(f)

    dataset = SupervisedDataSet(64, 2)
    for d in csvreader:
        if d[64] == '0':
            dataset.addSample(d[0:64], [1, 0])
        else:
            dataset.addSample(d[0:64], [0, 1])

    network = buildNetwork(64, 19, 2)
    trainer = BackpropTrainer(network, dataset)
    for i in range(100):
        trainer.train()
    trainer.testOnData(dataset, verbose=True)

    NetworkWriter.writeToFile(network, "tower.xml")

    f.close()
示例#9
0
文件: helpers.py 项目: HKou/pybrain
def xmlInvariance(n, forwardpasses = 1):
    """ try writing a network to an xml file, reading it, rewrite it, reread it, and compare
    if the result looks the same (compare string representation, and forward processing 
    of some random inputs) """
    import os.path
    f = 'temp/xmlInvarianceTest.xml'
    if os.path.split(os.path.abspath(os.path.curdir))[1] == 'unittests':        
        f = '../'+f
    NetworkWriter.writeToFile(n, f)
    tmpnet = NetworkReader.readFrom(f)
    NetworkWriter.writeToFile(tmpnet, f)
    endnet = NetworkReader.readFrom(f)
    if str(n) == str(endnet):
        print 'Same representation'
    else:
        print n
        print "-" * 80
        print endnet
        
    outN = zeros(n.outdim)
    outEnd = zeros(endnet.outdim)
    n.reset()
    endnet.reset()
    for dummy in range(forwardpasses):
        inp = randn(n.indim)
        outN += n.activate(inp)
        outEnd += endnet.activate(inp)
        
    if sum(map(abs, outN - outEnd)) < 1e-9:
        print 'Same function'
    else:
        print outN
        print outEnd

    if n.__class__ == endnet.__class__:
        print 'Same class'
    else:        
        print n.__class__
        print endnet.__class__
示例#10
0
def xmlInvariance(n, forwardpasses=1):
    """ try writing a network to an xml file, reading it, rewrite it, reread it, and compare
    if the result looks the same (compare string representation, and forward processing 
    of some random inputs) """
    import os.path
    f = 'temp/xmlInvarianceTest.xml'
    if os.path.split(os.path.abspath(os.path.curdir))[1] == 'unittests':
        f = '../' + f
    NetworkWriter.writeToFile(n, f)
    tmpnet = NetworkReader.readFrom(f)
    NetworkWriter.writeToFile(tmpnet, f)
    endnet = NetworkReader.readFrom(f)
    if str(n) == str(endnet):
        print 'Same representation'
    else:
        print n
        print "-" * 80
        print endnet

    outN = zeros(n.outdim)
    outEnd = zeros(endnet.outdim)
    n.reset()
    endnet.reset()
    for dummy in range(forwardpasses):
        inp = randn(n.indim)
        outN += n.activate(inp)
        outEnd += endnet.activate(inp)

    if sum(map(abs, outN - outEnd)) < 1e-9:
        print 'Same function'
    else:
        print outN
        print outEnd

    if n.__class__ == endnet.__class__:
        print 'Same class'
    else:
        print n.__class__
        print endnet.__class__
示例#11
0
 def saveNetwork(self, fname):
     """ save the trained network to a file """
     NetworkWriter.writeToFile(self.Trainer.module, fname) 
     logging.info("Network saved to: "+fname)
示例#12
0
 def saveNetwork(self, fname):
     """ save the trained network to a file """
     NetworkWriter.writeToFile(self.Trainer.module, fname) 
     logging.info("Network saved to: "+fname)
示例#13
0
 def save(self, file_path):
     NetworkWriter.writeToFile(self.network, file_path)
示例#14
0
def export_network(network, file_path):
    NetworkWriter.writeToFile(network, file_path)
	outputTest = net.activateOnDataset(test_data)
	outputTest = outputTest.argmax(axis=1)
	testResult = percentError(outputTest, real_test)

	finalTrainResult = 100 - trainResult
	finalTestResult = 100 - testResult

	print "Epoch: " + str(i + 1) + "\tTraining set accuracy: " + str(finalTrainResult) + "\tTest set accuracy: " + str(
		finalTestResult)
	# getStatistics(	)

	trainResultArr.append(finalTestResult)
	testResultArr.append(finalTrainResult)
	epochs.append(i)

prediction = net.activate(test_input)

# returns the index of the highest value down the columns
p = argmax(prediction, axis=0)

NetworkWriter.writeToFile(net, 'extra_layers.xml')

plt.plot(epochs, trainResultArr)
plt.plot(epochs, testResultArr)
plt.title('Training Result (Orange) vs Test Result of ANN (Blue)')
plt.xlabel('Epochs')
plt.ylabel('Accuracy %')

plt.show()

示例#16
0
文件: ann.py 项目: CBITT/python_prac
    trainResultArr.append((finalTestRes))
    testResultArr.append((finalTrainRes))

    trainResultArrHB.append((finalTestResHB))
    testResultArrHB.append((finalTrainResHB))
    epochs.append((i))

X1 = im3.reshape((X.shape[1]))
prediction = net.activate(X1)

predictionHB = netHB.activate(X1)

# returns the index of the highest value down the columns
p = argmax(prediction, axis=0)
pHB = argmax(predictionHB, axis=0)
NetworkWriter.writeToFile(net, 'dig.xml')
print("predicted output after training is", p)

NetworkWriter.writeToFile(netHB, 'digHB.xml')
print(
    "predicted output after training net with hyperbolic activation function is",
    pHB)

plt.plot(epochs, trainResultArr)
plt.plot(epochs, testResultArr)
plt.plot(epochs, trainResultArrHB)
plt.plot(epochs, testResultArrHB)
plt.title('Training Result (Orange) vs Test Result of ANN (Blue)')
plt.xlabel('Epochs')
plt.ylabel('Accuracy %')
示例#17
0
    outputTest = net.activateOnDataset(test_data)
    outputTest = outputTest.argmax(axis=1)
    testResult = percentError(outputTest, real_test)

    finalTrainRes = 100 - trainResult
    finalTestRes = 100 - testResult
    print "Epoch: " + str(i) + "\tTraining set accuracy: " + str(finalTrainRes) + "\tTest set accuracy: " + str(finalTestRes)

    trainResultArr.append((finalTestRes))
    testResultArr.append((finalTrainRes))
    epochs.append((i))

X1 = im3.reshape((X.shape[1]))
prediction = net.activate(X1)

# returns the index of the highest value down the columns
p = argmax(prediction, axis=0)
NetworkWriter.writeToFile(net, 'dig_img_from_dir.xml')
print("predicted output after training is", p)


plt.plot(epochs,trainResultArr)
plt.plot(epochs,testResultArr)
plt.title('Training Result (Orange) vs Test Result of ANN (Blue)')
plt.xlabel('Epochs')
plt.ylabel('Accuracy %')

plt.show()

示例#18
0
 def write_to_file(self, fnn):
     path_to_file = self.get_path()
     NetworkWriter.writeToFile(fnn, path_to_file)
示例#19
0
# Predefine iterations: epochs & cycles
EPOCHS_PER_CYCLE = 5
CYCLES = 100
EPOCHS = EPOCHS_PER_CYCLE * CYCLES

# Training loop
for i in xrange(CYCLES):
    trainer.trainEpochs(EPOCHS_PER_CYCLE)
    error = trainer.testOnData()
    epoch = (i + 1) * EPOCHS_PER_CYCLE
    print("\r Epoch: {}/{} Error: {}".format(epoch, EPOCHS, error), end="")
    stdout.flush()

# Save model
NetworkWriter.writeToFile(rnn, 'rnn3.xml')

# Ad hoc test
for test in test_data:
    for i in xrange(0, len(test) - 6, 5):
        # Get 5 obs, 6th we wish to predict
        obs, nxt = test[i:i + 5], test[i + 6]

        # Predict all
        prds = map(rnn.activate, obs)
        # Get 6th prediction
        prd = prds.pop()[0]

        # Test if prd is anomalous
        anm = prd > (1 + np.mean(obs) + 2 * np.std(obs))
        # Get previous 5 obs,prd error rate
def save_net():
        from pybrain.tools.xml import NetworkWriter
        save_filename = tkFileDialog.asksaveasfilename()
        NetworkWriter.writeToFile(net,save_filename)
示例#21
0
for single_npz in training_data:
    with np.load(single_npz) as data:
        print data.files
        train_temp = data['train']
        train_labels_temp = data['train_labels']
        print (train_temp.shape)
        print (train_labels_temp.shape)
    image_array = np.vstack((image_array, train_temp))
    label_array = np.vstack((label_array, train_labels_temp))
t1 = time.time()
for i in range(train_temp.shape[0]):
    target.addSample(image_array[i],label_array[i])
print 'loading time : ' , time.time() - t1


# train
while True:
    try:
        while True:
            errors  = trainer.train()
            if (j % 5) == 0:
                print ("epoch%d error : %f" % (j, errors))
            elif(errors < 2e-2) :
                print ("epoch%d error : %f" % (j, errors))
                break
            j += 1
    finally:
        NetworkWriter.writeToFile(network, XML)
        break
raw_input('>')
示例#22
0
def savenet(net):
    fileObject = open('C:\\Users\\hardy_000\\Documents\\datasci\\net', 'w')

    pickle.dump(net, fileObject)
    NetworkWriter.writeToFile(net, 'C:\\Users\\hardy_000\\Documents\\datasci\\net.xml')
    fileObject.close()