def testSPS():
from util.util import interval
from module.Module import Constant
config = SPSConfig.SPSConfig()
moduleFactory = ModuleFactory(config)
modelfactory = ModelFactory(moduleFactory)
model = modelfactory.get_built()
ltl = ['U[1, {0}]'.format(730), 'T', 'failure'] # 一年之内系统失效
checker = Checker(model, ltl, duration=730, fb=False)
wrapper = ExperimentWrapper(checker, samples_per_param=100)
trainx = interval(1, 10, 0.5)
testx = interval(1, 10, 0.1)
thickness_params = [Constant('SCREEN_THICKNESS', st) for st in trainx]
wrapper.setconstants([thickness_params])
result = wrapper.do_expe()
cases = map(lambda tuple: tuple[0], result)
labels = map(lambda tuple: tuple[1], result)
regressor = BPNeuralNetwork()
regressor.setup(1, 5, 1)
regressor.train(cases, labels)
test_cases = map(lambda c: Constant('SCREEN_THICKNESS', c), testx)
test_labels = [regressor.predict(test_case) for test_case in testx]
# 对多组参数进行模型验证
# logger.info("mc begin")
#
wrapper.setconstants([test_cases])
# mcresult = wrapper.modelcheck()
# mc_labels = map(lambda tuple: tuple[1], mcresult)
plt.plot(testx, [i[0] for i in test_labels], label='predict')
# plt.plot(map(lambda const: const.get_value(), test_cases), mc_labels, label='mc')
plt.show()
def get_products():
factory = ModelFactory()
products = factory.read(Product)
return jsonify(status=200,
message='OK',
body={
'status': 200,
'message': 'OK',
'payload': products
})
def get_users(user_id):
factory = ModelFactory()
user_info = factory.get(User, id=user_id)
return jsonify(status=200,
message='OK',
body={
'status': 200,
'message': 'OK',
'payload': user_info
})
def create_product():
data = request.json
factory = ModelFactory()
product_id = factory.create(Product,
seller=data['seller'],
name=data['name'])
for color in data['option']['color']:
for size in data['option']['size']:
factory.create(ProductOption,
product_id=product_id,
color=color,
size=size)
for seq, image in enumerate(data['images']):
factory.create(ProductImage,
product_id=product_id,
seq=int(seq),
path=image['path'],
url=image['url'])
factory.create(ProductPrice, product_id=product_id, price=data['price'])
return jsonify(status=201, message='Created')
def get_main_page():
factory = ModelFactory()
products = factory.read(Product)
return render_template('products.html', products=products)
import numpy as np
import random
import tensorflow as tf
from data.dataset import Dataset
from model.ModelFactory import ModelFactory
from evaluator import FoldOutEvaluator
np.random.seed(2018)
random.seed(2018)
tf.random.set_random_seed(2018)
if __name__ == "__main__":
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
model_factory = ModelFactory()
Model, config = model_factory.get_model()
dataset = Dataset(config)
evaluator = FoldOutEvaluator(dataset.train_matrix, dataset.test_matrix)
model = Model(sess, config, dataset, evaluator)
model.train_model()
def get_built_model():
return ModelFactory().get_built()
def get_product_detail(product_id):
factory = ModelFactory()
product = factory.get(Product, id=product_id)
return render_template('product_detail.html', product=product)
