args = parser.parse_args()
number = int(args.number)
iterations = int(args.iterations)
pf = strengthen_functions.PF81
nn = NeuralNetwork(strength_function=pf,
image_scale=8,
transmission_history_len=10**4)
'''
train_imgs, _ = skl.load_data()
train_imgs = train_imgs[number]
size = len(train_imgs)
'''
# average_img = skl.average_img_by_number(number)
train_imgs = skl.get_imgs_by_number(number)
plotting_strength = True
if plotting_strength: strength_stats = []
start_time = datetime.datetime.now()
for i in range(iterations):
_, img = random.choice(train_imgs)
nn.propagate_once(img, gray_max=16)
if plotting_strength:
if i % 10 == 0: strength_stats.append(nn.stats()['strength'])
end_time = datetime.datetime.now()
print('%s: ' % number, 'start time:', start_time, 'stop time: ', end_time)
if plotting_strength:
plt.plot(strength_stats)
# import random
# import argparse
import matplotlib as mpl
mpl.use('Agg', warn=False)
import matplotlib.pyplot as plt
from nn_growable import NeuralNetwork
# import mnist
import skl
import utils
# import seaborn as sns
# import sys
import random
iters = 5 * 10**4
imgs_l = [skl.get_imgs_by_number(i) for i in range(10)]
strength_matrix_l = [
utils.read_pickle('pkl/nn_growable_' + str(i) + '.pkl') for i in range(10)
]
fig, axes = plt.subplots(2, 2, figsize=(10, 5), sharex=True, sharey=False)
axes = axes.flatten()
pfs = [
lambda img, matrix: NeuralNetwork.validate_linear(
img, matrix, gray_max=16, power=0, weight=10),
lambda img, matrix: NeuralNetwork.validate_linear(
img, matrix, gray_max=16, power=1, weight=10),
lambda img, matrix: NeuralNetwork.validate_linear(
img, matrix, gray_max=16, power=3, weight=10),
lambda img, matrix: NeuralNetwork.validate_threshold(
# the number of 0~9 to train NN with
parser = argparse.ArgumentParser()
parser.add_argument('-i', action="store", dest="iterations", default=1000)
parser.add_argument('-j', action="store", dest="num", default=-1)
args = parser.parse_args()
iterations = int(args.iterations)
num = int(args.num)
'''
threshhold = 0.8
weight = 100
print('threshhold %s weight %s' % (threshhold, weight))
'''
if num >=0:
imgs = skl.get_imgs_by_number(num)
else:
imgs = skl.get_imgs_by_number()
strength_matrix_l = [utils.read_pickle('pkl/nn_meshed_' + str(i) + '.pkl') for i in range(10)]
correct = .0
trails = .0
for i in range(iterations):
trails += 1
label, img = random.choice(imgs)
scores_a = np.array([NeuralNetwork.validate(img, strength_matrix, gray_max=16.) for strength_matrix in strength_matrix_l])
if label == random.choice(np.where(scores_a == scores_a.max())[0]):
correct += 1
if not (i % 10) and i > 0:
# print(round(correct / trails * 100, 2), label, scores_a)
from __future__ import print_function
import numpy as np
import random
# import argparse
# import matplotlib as mpl
# mpl.use('Agg', warn=False)
import matplotlib.pyplot as plt
from nn_mnist_jellyfish import NeuralNetwork
# import mnist
import skl
import utils
imgs1 = skl.get_imgs_by_number(0)
imgs2 = skl.get_imgs_by_number(3)
strength_matrix = utils.read_pickle('pkl/nn_mnist_jellyfish_0.pkl')
# for label, img in imgs1:
propagated_1 = []
propagated_2 = []
r = range(np.min([len(imgs1), len(imgs2)]))
index = random.choice(r)
for i in range(10000):
propagated_1.append(
NeuralNetwork.validate(imgs1[index][1], strength_matrix))
propagated_2.append(
NeuralNetwork.validate(imgs2[index][1], strength_matrix))
propagated_1 = np.array(propagated_1)
propagated_2 = np.array(propagated_2)
fig, axes = plt.subplots(2, 1, figsize=(3, 3))
import argparse
from nn_growable import NeuralNetwork
import skl
import utils
random.seed()
iterations = 50000
validators = [
lambda img, matrix: NeuralNetwork.validate_original(img, matrix),
lambda img, matrix: NeuralNetwork.validate_step(img, matrix, threshold=.6),
lambda img, matrix: NeuralNetwork.validate_linear(img, matrix, power=3, weight=100),
lambda img, matrix: NeuralNetwork.validate_threshold(img, matrix, power=3, threshhold=.2, weight=10)]
imgs = skl.get_imgs_by_number(1)
label, img = imgs[100]
strength_matrix_l = [utils.read_pickle('pkl/nn_growable_' + str(i) + '.pkl') for i in range(10)]
trails = .0
targets_l = [0] * 10
for i in range(iterations):
# label, img = random.choice(imgs)
scores_a = np.array([validators[3](img, strength_matrix) for strength_matrix in strength_matrix_l])
target = random.choice(np.where(scores_a == scores_a.max())[0])
targets_l[target] += 1
trails += 1
targets_a = np.array(targets_l)
print((targets_a / trails * 100).round(2).tolist())
parser.add_argument('-n', action="store", dest="mnist_number")
parser.add_argument('-i',
action="store",
dest="iterations",
default=25000,
help="default: 25000")
args = parser.parse_args()
mnist_number = int(args.mnist_number)
iterations = int(args.iterations)
# images choice indexes = [181, 100, 333, 100, 3282, 5239, 5070, 893, 2117, 5712]
pf = lambda x: (1 / (1 + np.exp(-1 * 10 * x)) - .5) * 1.8 + .05
nn = NeuralNetwork(strength_function=pf, image_scale=8)
imgs = skl.get_imgs_by_number(mnist_number)
i = random.choice(range(len(imgs)))
img = imgs[i][1]
print('%s: #%s' % (mnist_number, i))
start_time = datetime.datetime.now()
plotting_strength = True
if plotting_strength: strength_stats = []
for i in range(iterations):
nn.propagate_once(img, gray_max=16)
if plotting_strength:
if i % 10 == 0: strength_stats.append(nn.stats()['strength'])
end_time = datetime.datetime.now()
