def test():
with open("train-images-idx3-ubyte", "r") as f:
magic = np.fromfile(f, dtype=np.dtype('>i4'), count=1)
num_images = np.fromfile(f, dtype=np.dtype('>i4'), count=1)
num_rows = np.fromfile(f, dtype=np.dtype('>i4'), count=1)
num_cols = np.fromfile(f, dtype=np.dtype('>i4'), count=1)
images = np.fromfile(f, dtype=np.ubyte)
images = images.reshape((num_images, num_rows * num_cols)).transpose()
images = images.astype(np.float64) / 255
f.close()
input_size = 64
hidden_size = 36
data = np.random.randn(input_size, 10)
hidden_size = 96
L = []
L.append({"type":'NLayer',"params":{"size": 28 * 28, "ac_func":'sigmoid', "lam": 3e-3,"sparsity_param":0} })
L.append({"type":'NLayer',"params":{"size": 196, "ac_func":'sigmoid', "lam": 3e-3,"sparsity_param":0.1} })
L.append({"type":'NLayer',"params":{"size": 28 * 28, "ac_func":'sigmoid', "lam": 3e-3,"sparsity_param":0} })
ae = NNet(Layers = L,lam = 3e-3, beta = 3)
ae.train(data = images[:, 0:10000], output = images[:, 0:10000], debug = False)
def getPolicy_NNet(pra, extent, vown, vint=0., nbin=250, ra=-1, bounds=[]):
# Load network of given pRA into Python
nnet_file_name = "networks/VertCAS_pra%02d_v4_45HU_200.nnet" % (pra + 1)
net = NNet(nnet_file_name)
tauMin, tauMax, hMin, hMax = extent
# Get safeable bounds
possAdv = getPossibleAdvisories(pra)
# Generate a heat map using the bounds for each set
# Use meshgrid to define array of all inputs to network
hVec = np.linspace(hMin, hMax, nbin)
tauVec = np.linspace(tauMin, tauMax, nbin)
hMesh, tauMesh = np.meshgrid(hVec, tauVec)
hMesh = hMesh.reshape(nbin**2, 1)
tauMesh = tauMesh.reshape(nbin**2, 1)
vownMesh = np.ones((nbin**2, 1)) * vown
vintMesh = np.ones((nbin**2, 1)) * vint
netIn = np.concatenate((hMesh, vownMesh, vintMesh, tauMesh), axis=1)
# Evaluate network on all inputs
netOut = net.evaluate_network_multiple(netIn)
# Convert outputs to best advisories
bestAdv = np.argmax(netOut, axis=1)
heatMap = np.array([possAdv[i] for i in bestAdv])
# Highlight SAT points if bounds given
if len(bounds) > 0:
for i in range(nbin**2):
if heatMap[i] == ra and satisfiesBounds(bounds, netIn[i, 0],
netIn[i, 3]):
heatMap[i] = 10
# Reshape the map and flip around the axes for plotting purposes
heatMap = heatMap.reshape((nbin, nbin)).T[::-1]
return heatMap
def run(num_classes,learning_rate,width,depth,mini_batch_size):
precision = accuracy = recall = f_score = np.array([])
X_train,X_test,y_train,y_test,unknown_data = dp.load_data()
X_train,X_test,y_train,y_test,unknown_data,dtype = dp.prepare_data(X_train,X_test,y_train,y_test,unknown_data)
for _ in range(1):
model = NN.Net1(num_classes,depth=depth,width=width).type(dtype)
opt = optim.SGD(params=model.parameters(),lr=learning_rate,momentum=rp.m,nesterov=True)
train_losses,test_losses = model.train_validate(X_train,y_train,X_test,y_test,opt,mini_batch_size,dtype)
model = torch.load("Models/Best_Model.pkl")
y_pred,_ = model.test(X_test)
# Calculate metrics
y_true = y_test.data.cpu().numpy()
y_pred = y_pred.data.cpu().numpy()
a,p,r,f = m.compute_metrics(y_true,y_pred)
accuracy = np.append(accuracy,a)
precision = np.append(precision,p)
recall = np.append(recall,r)
f_score = np.append(f_score,f)
accuracy = np.mean(accuracy)
precision = np.mean(precision)
recall = np.mean(recall)
f_score = np.mean(f_score)
m.show_results(accuracy,precision,recall,f_score,num_classes,train_losses,test_losses)
#g.generate_graph(model,X_train)
fw.create_data_csv(learning_rate,depth,width,mini_batch_size,rp.m,len(test_losses)-10,accuracy)
# Store unknown_data prediction
y_pred,_ = model.test(unknown_data)
fw.store_prediction(y_pred.data.cpu().numpy())
dep_posts = new_arr
y = np.concatenate((np.ones(len(reg_posts)), np.zeros(len(dep_posts))))
x = np.concatenate((reg_posts, dep_posts))
print('b. initializing')
rs = ShuffleSplit(n_splits=10, test_size=.10, random_state=0)
rs.get_n_splits(x)
split = 0
for train_index, test_index in rs.split(x):
print "split", split
x_train, x_test = x[train_index], x[test_index]
y_train, y_test = y[train_index], y[test_index]
new_doc = D2V('w2v_' + str(split), 300)
train_arrays, test_arrays, train_labels, test_labels = new_doc.build_d2v_vecs(
x_train, x_test, y_train, y_test)
print('Logreg')
logreg.run_logreg(train_arrays, test_arrays, train_labels, test_labels)
print('SVM')
svm.train_svm(train_arrays, test_arrays, train_labels, test_labels)
print('Simple neural network')
NNet.simpleNN(train_arrays, test_arrays, train_labels, test_labels,
0.01, 100, 100)
split += 1
split = 0
for train_index, test_index in rs.split(x):
print "split", split
x_train, x_test = x[train_index], x[test_index]
y_train, y_test = y[train_index], y[test_index]
feat_model = DeCh("reg")
feat_model.load_liwc('data/mixed_liwc2007.csv',
'data/anxiety_filtered2007.csv')
print "calculating train"
train_vecs = feat_model.build_feat(x_train, train_index)
print "calculating test"
test_vecs = feat_model.build_feat(x_test, test_index)
np.save('feat/test_de' + str(split), test_vecs)
np.save('feat/train_de' + str(split), train_vecs)
print('Simple NN')
NNet.simpleNN(train_vecs, test_vecs, y_train, y_test, 0.01, 100, 100)
print('Logreg')
logreg.run_logreg(train_vecs, test_vecs, y_train, y_test)
print('SVM')
svm.train_svm(train_vecs, test_vecs, y_train, y_test)
split += 1
import Game
import Players
import MCTS
import Arena
import numpy as np
import NNet
from utils import *
game = Game.Game2048()
player = Players.RandomPlayer(game)
nnet_player = NNet.NNetWrapper(game)
nnet_player.load_checkpoint('./temp', 'best.pth.tar')
args = dotdict({
'numIters': 1000,
'numEps': 100, # Number of complete self-play games to simulate during a new iteration.
'tempThreshold': 15, #
'updateThreshold': 0.6,
# During arena playoff, new neural net will be accepted if threshold or more of games are won.
'maxlenOfQueue': 200000, # Number of game examples to train the neural networks.
'numMCTSSims': 25, # Number of games moves for MCTS to simulate.
'arenaCompare': 40, # Number of games to play during arena play to determine if new net will be accepted.
'cpuct': 1,
'checkpoint': './temp/',
'load_model': False,
'load_folder_file': ('/dev/models/8x100x50', 'best.pth.tar'),
'numItersForTrainExamplesHistory': 20,
})
mcts = MCTS.MCTS(game, nnet_player, args)
def __init__(self):
self.Net = NNet()
return
class Anduril():
def __init__(self):
self.Net = NNet()
return
def init(self,sconfig,classreg = 0, numcores = 1, gradd = 0, costfunc = 0):
if (type(sconfig) == str) and (type(classreg) == int) and (type(numcores) == int) and (type(gradd) == int) and (type(costfunc) == int):
self.Net.init(sconfig,classreg,numcores,gradd,costfunc)
else:
print "Invalid input, network not initailized"
return
def func_arch(self,flayer):
if type(flayer) != str:
print "flayer must be a string"
return
else:
self.Net.func_arch(flayer)
return
def load(self,filename, mode = 0, sep1 = ",", sep2 = " "):
if (type(filename) == str) and (type(mode) == int) and (type(sep1) == str) and (type(sep2) == str):
self.Net.load(filename,mode,sep1,sep2)
return
else:
print "Invalid input, files not loaded!"
return
def test_file(self,filename, netname = " ", sep1 = ",", sep2 = " "):
if (type(filename) == str) and (type(netname) == str) and (type(sep1) == str) and (type(sep2) == str):
self.Net.test_file(filename, netname, sep1, sep2)
return
else:
print "Invalid input type!"
return
def error_stats(self, num_bins):
if type(num_bins) != int:
print "Please enter an integer for the number of bins"
return
self.Net.error_stats()
f_train = open(".train","r")
f_test = open(".test", "r")
train_vals = []
test_vals = []
for line in f_train:
train_vals.append(float(line))
for line in f_test:
test_vals.append(float(line))
mean_train = np.mean(train_vals)
std_train = np.std(train_vals)
mean_test = np.mean(test_vals)
std_test = np.std(test_vals)
fig = plt.figure()
ax1 = fig.add_subplot(2, 1, 1)
ax2 = fig.add_subplot(2, 1, 2)
ax1.hist(train_vals, bins=num_bins)
ax1.set_title("Histogram on training error (Mean: " + str(mean_train) + "," + "Standard Deviation: " + str(std_train) + ")")
ax1.set_xlabel("Error")
ax1.set_ylabel("Number of points")
ax2.hist(test_vals, bins=num_bins)
ax2.set_title("Histogram on test error (Mean: " +str(mean_test) + "," + "Standard Deviation: " + str(std_test) + ")")
ax2.set_xlabel("Error")
ax2.set_ylabel("Number of points")
plt.show()
return
def train_net(self,epoch,lrate, mode = 1, verbose = 0, logfile = " "):
if (type(epoch) == int) and (type(lrate) == float) and (type(mode) == int) and (type(verbose) == int) and (type(logfile) == str):
if (mode < 0) or (mode > 1):
print "The mode must be either 0 or 1"
return
if (verbose < 0) or (verbose > 1):
print "Verbose must either be 0 or 1"
return
self.Net.train_net(epoch,lrate,mode,verbose,logfile)
return
else:
print "Invalid input, network not trained!"
return
def train_rprop(self,epoch, mode = 1, verbose = 0, logfile = " ", tmax = 1.0):
if (type(epoch) == int) and (type(mode) == int) and (type(verbose) == int) and (type(logfile) == str) and (type(tmax) == float):
if (mode < 0) or (mode > 1):
print "The mode must be either 0 or 1"
return
if (verbose < 0) or (verbose > 1):
print "Verbose must either be 0 or 1"
return
self.Net.train_rprop(epoch,mode,verbose,logfile,tmax)
return
else:
print "Invalid input, network not trained!"
return
def d_trainrprop(self,mode = 1, verbose = 0, logfile = " ", tmax = 1.0):
if (type(mode) == int) and (type(verbose) == int) and (type(logfile) == str) and (type(tmax) == float):
if (mode < 0) or (mode > 1):
print "The mode must be either 0 or 1"
return
if (verbose < 0) or (verbose > 1):
print "Verbose must either be 0 or 1"
return
self.Net.d_trainrprop(mode,verbose,logfile,tmax)
return
else:
print "Invalid input, network not trained!"
return
def test_net(self,verbose = 0):
if (type(verbose) == int):
if (verbose != 0) or (verbose != 1):
print "Verbose must either be 0 or 1"
return
self.Net.test_net(verbose)
return
else:
print "Invalid input!"
return
def savenet(self,netname):
if (type(netname) == str):
self.Net.savenet(netname)
return
else:
print "Invalid input, netname must be a string!"
return
def loadnet(self,netname):
if (type(netname) == str):
self.Net.loadnet(netname)
return
else:
print "Invalid input, netname must be a string!"
return
def snets(self):
self.Net.snets()
return
class Anduril():
def __init__(self):
self.Net = NNet()
return
def init(self,sconfig,classreg = 0, numcores = 1, gradd = 0, costfunc = 0):
if (type(sconfig) == str) and (type(classreg) == int) and (type(numcores) == int) and (type(gradd) == int) and (type(costfunc) == int):
self.Net.init(sconfig,classreg,numcores,gradd,costfunc)
else:
print "Invalid input, network not initailized"
return
def func_arch(self,flayer):
if type(flayer) != str:
print "flayer must be a string"
return
else:
self.Net.func_arch(flayer)
return
def load(self,filename, mode = 0, sep1 = ",", sep2 = " "):
if (type(filename) == str) and (type(mode) == int) and (type(sep1) == str) and (type(sep2) == str):
self.Net.load(filename,mode,sep1,sep2)
return
else:
print "Invalid input, files not loaded!"
return
def test_file(self,filename, netname = " ", sep1 = ",", sep2 = " "):
if (type(filename) == str) and (type(netname) == str) and (type(sep1) == str) and (type(sep2) == str):
self.Net.test_file(filename, netname, sep1, sep2)
return
else:
print "Invalid input type!"
return
def error_stats(self, num_bins):
if type(num_bins) != int:
print "Please enter an integer for the number of bins"
return
self.Net.error_stats()
f_train = open(".train","r")
f_test = open(".test", "r")
train_vals = []
test_vals = []
for line in f_train:
train_vals.append(float(line))
for line in f_test:
test_vals.append(float(line))
mean_train = np.mean(train_vals)
std_train = np.std(train_vals)
mean_test = np.mean(test_vals)
std_test = np.std(test_vals)
fig = plt.figure()
ax1 = fig.add_subplot(2, 1, 1)
ax2 = fig.add_subplot(2, 1, 2)
ax1.hist(train_vals, bins=num_bins)
ax1.set_title("Histogram on training error (Mean: " + str(mean_train) + "," + "Standard Deviation: " + str(std_train) + ")")
ax1.set_xlabel("Error")
ax1.set_ylabel("Number of points")
ax2.hist(test_vals, bins=num_bins)
ax2.set_title("Histogram on test error (Mean: " +str(mean_test) + "," + "Standard Deviation: " + str(std_test) + ")")
ax2.set_xlabel("Error")
ax2.set_ylabel("Number of points")
plt.show()
return
def train_net(self,epoch,lrate, mode = 1, verbose = 0, logfile = " "):
if (type(epoch) == int) and (type(lrate) == float) and (type(mode) == int) and (type(verbose) == int) and (type(logfile) == str):
if (mode < 0) or (mode > 1):
print "The mode must be either 0 or 1"
return
if (verbose < 0) or (verbose > 1):
print "Verbose must either be 0 or 1"
return
self.Net.train_net(epoch,lrate,mode,verbose,logfile)
return
else:
print "Invalid input, network not trained!"
return
def train_rprop(self,epoch, mode = 1, verbose = 0, logfile = " ", tmax = 1.0):
if (type(epoch) == int) and (type(mode) == int) and (type(verbose) == int) and (type(logfile) == str) and (type(tmax) == float):
if (mode < 0) or (mode > 1):
print "The mode must be either 0 or 1"
return
if (verbose < 0) or (verbose > 1):
print "Verbose must either be 0 or 1"
return
self.Net.train_rprop(epoch,mode,verbose,logfile,tmax)
return
else:
print "Invalid input, network not trained!"
return
def d_trainrprop(self,mode = 1, verbose = 0, logfile = " ", tmax = 1.0):
if (type(mode) == int) and (type(verbose) == int) and (type(logfile) == str) and (type(tmax) == float):
if (mode < 0) or (mode > 1):
print "The mode must be either 0 or 1"
return
if (verbose < 0) or (verbose > 1):
print "Verbose must either be 0 or 1"
return
self.Net.d_trainrprop(mode,verbose,logfile,tmax)
return
else:
print "Invalid input, network not trained!"
return
def test_net(self,verbose = 0):
if (type(verbose) == int):
if (verbose != 0) or (verbose != 1):
print "Verbose must either be 0 or 1"
return
self.Net.test_net(verbose)
return
else:
print "Invalid input!"
return
def savenet(self,netname):
if (type(netname) == str):
self.Net.savenet(netname)
return
else:
print "Invalid input, netname must be a string!"
return
def loadnet(self,netname):
if (type(netname) == str):
self.Net.loadnet(netname)
return
else:
print "Invalid input, netname must be a string!"
return
def snets(self):
self.Net.snets()
return
test_vecs_u = np.load('feat/test_unibigram' + str(split) + '.npy')
train_vecs_u = np.load('feat/train_unibigram' + str(split) + '.npy')
test_vecs_l = np.load('feat/test_lda' + str(split) + '.npy')
train_vecs_l = np.load('feat/train_lda' + str(split) + '.npy')
test_vecs = np.concatenate((test_vecs_w, test_vecs_l), axis=1)
train_vecs = np.concatenate((train_vecs_w, train_vecs_l), axis=1)
print('Logreg')
acc, per, rec = logreg.run_logreg(train_vecs, test_vecs, y_train, y_test)
results[split][0] = acc
results[split][1] = per
results[split][2] = rec
print('SVM')
acc, per, rec = svm.train_svm(train_vecs_l, test_vecs_l, y_train, y_test)
results[split][3] = acc
results[split][4] = per
results[split][5] = rec
print('Simple NN')
acc, per, rec = NNet.simpleNN(train_vecs, test_vecs, y_train, y_test, 0.01, 10, 100)
results[split][6] = acc
results[split][7] = per
results[split][8] = rec
split += 1
from flask import Flask, render_template, request, jsonify
from NNet import *
import numpy as np
import base64
import re
import base64
import cv2
np.set_printoptions(linewidth=np.inf)
nn = NNet(784, 60, 10)
w1 = np.loadtxt("wt1.txt", delimiter=",")
w2 = np.loadtxt("wt2.txt", delimiter=",")
nn.loadWt1(w1)
nn.loadWt2(w2)
app = Flask(__name__)
@app.route("/")
def home():
return render_template("index.html")
@app.route("/digitPredict", methods=["POST"])
def digitPredict():
image_b64 = request.json['imageBase64']
image_data = base64.b64decode(
re.sub('^data:image/.+;base64,', '', image_b64))
image = np.asarray(bytearray(image_data), dtype="uint8")
image = cv2.imdecode(image, cv2.IMREAD_GRAYSCALE)
image = ~image
## считывание значений для валидации (тратит много времени, потому используется редко)
# sheet = wb['obs_valid']
# for i in range(size):
# for j in range(size): # число вложенных циклов долно быть равно dim !!
# input_true[i * size + j][0] = \
# int(sheet.cell(column=1, row=1 + i * size + j).value)
# input_true[i * size + j][1] = \
# int(sheet.cell(column=2, row=1 + i * size + j).value)
# output_true[i * size + j][0] = \
# int(sheet.cell(column=3, row=1 + i * size + j).value)
wb.close()
#
#
net1 = NNet.Net(dim, device, 3, 15, "sigm")
net2 = NNet.copy_net(net1)
epoch_amount = 10000
optimizer1 = t.optim.SGD(net1.parameters(), lr=0.05)
optimizer2 = t.optim.SGD(net2.parameters(), lr=0.05)
loss = t.nn.MSELoss()
def learning(net, optimizer):
for epoch_number in range(epoch_amount):
optimizer.zero_grad()
#
prediction = net.forward(input_data)
loss_val = loss(prediction, output_data)
loss_val.backward()
optimizer.step()
