def main():
# Parse command line arguments.
if len(sys.argv) < 4:
usage_and_exit()
pass_size = int(sys.argv[1])
reg_type = sys.argv[2]
reg_fname = sys.argv[3]
# Stuff we need to generate a password.
reg = None
if reg_type == 'nnet':
reg = nnet.load(reg_fname)
elif reg_type == 'svm':
reg = svm.load(reg_fname)
elif reg_type == 'knn':
reg = knn.load(reg_fname)
else:
usage_and_exit()
feature_fun = features.transform_all
all_chars = ''.join(util.NORMAL_LAYOUT)
scorer = passgen.Scorer(reg, feature_fun, util.layout_mapping())
# Generate and print a password.
print passgen.generate(scorer, all_chars, pass_size, 4)
import sys
from argparse import ArgumentParser
from iris import feature
from skimage.util import img_as_ubyte
from skimage.data import imread
from svm import SVM, load
from features import FeatureExtractor
parser = ArgumentParser()
parser.add_argument('path')
if __name__ == "__main__":
args = parser.parse_args()
vector = feature(args.path, FeatureExtractor(set(['daisy', 'hog', 'raw'])))
classifier = load('rf')
prediction = classifier.predict(vector)
print >>sys.stderr, prediction
if abs(prediction[2][0] - prediction[2][1]) <= 0.05:
print >>sys.stderr, "Doubt"
exit(-1)
print prediction[1].split('/')[-1]
def main(args):
# Loading Dataset and Preprocessing Data
X_train, Y_train, X_test, Y_test, train_sample, valid_sample, testing_sample = svm.load(
args.window_size)
# Build Input Fn
train_input_fn = svm.np_input_fn(X_train,
Y_train,
samples=train_sample,
shuffle=True,
window_size=args.window_size,
batch=args.batch,
epoch=args.epoch)
# Training Model
input_dim = args.window_size * args.window_size * 6
if args.model == "linear":
estimator = svm.create_linear_model(args.learning_rate,
input_dim,
config=config(args))
if args.model == "rffm":
estimator = svm.create_rffm_model(args.learning_rate,
input_dim,
args.dimension,
args.stddev,
config=config(args))
start = time.time()
if args.train:
estimator.fit(input_fn=train_input_fn) # Train.
train_sec = time.time() - start
print('Training Elapsed time: {} seconds'.format(train_sec))
# Evaluating Training Data
if not args.evaluate:
return
start = time.time()
train_metrics = svm.evaluate_model(estimator,
X_train,
Y_train,
train_sample,
batch=2048,
window_size=args.window_size)
valid_metrics = svm.evaluate_model(estimator,
X_train,
Y_train,
valid_sample,
batch=2048,
window_size=args.window_size)
testing_metrics = svm.evaluate_model(estimator,
X_test,
Y_test,
testing_sample,
batch=2048,
window_size=args.window_size)
eval_sec = time.time() - start
print('Evaluate Elapsed time: {} seconds'.format(eval_sec))
train = datastat.sum_stat(Y_train, train_sample)[0]
vaild = datastat.sum_stat(Y_train, valid_sample)[0]
test = datastat.sum_stat(Y_test, testing_sample)[0]
train_metrics["tn"] = train - (train_metrics["tp"] + train_metrics["fp"] +
train_metrics["fn"])
valid_metrics["tn"] = vaild - (valid_metrics["tp"] + valid_metrics["fp"] +
valid_metrics["fn"])
testing_metrics["tn"] = test - (
testing_metrics["tp"] + testing_metrics["fp"] + testing_metrics["fn"])
print(train_metrics)
print(valid_metrics)
print(testing_metrics)
global_step = estimator.get_variable_value("global_step")
result = "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %s %f %f %f\n" % (
train_metrics["tp"], train_metrics["fp"], train_metrics["fn"],
train_metrics["tn"], valid_metrics["tp"], valid_metrics["fp"],
valid_metrics["fn"], valid_metrics["tn"], testing_metrics["tp"],
testing_metrics["fp"], testing_metrics["fn"], testing_metrics["tn"],
global_step, args.epoch, args.batch, args.window_size,
args.learning_rate, args.dimension, args.stddev, args.model, train_sec,
eval_sec, train_sec + eval_sec)
print(result)
f = open(args.output, "a+")
f.write(result)
f.close()
# coding: utf-8
# In[ ]:
import fio
import svm
import numpy as np
import itertools
# In[ ]:
if __name__ == "__main__":
X_train, Y_train, X_test, Y_test, train_sample, valid_sample, testing_sample = svm.load(23)
# In[ ]:
def count(Y, sample):
if isinstance(Y, list):
arr = np.array([], dtype=int)
for y, s in zip(Y, sample):
arr = np.append(arr, count(y, s))
return arr.reshape((-1,3))
if sample is None:
return np.array([0,0,0])
