def setUp(self):
self.s = esppy.ESP(HOST, PORT, USER, PASSWD, protocol=PROTOCOL)
model_xml_path = os.path.join(DATA_DIR, 'model_sa.xml')
name = 'ESPUnitTestProjectSA'
with self.assertRaises(KeyError):
self.s.get_project(name)
self.project = self.s.install_project(model_xml_path)
def test_env_connection(self):
os.environ['ESPHOST'] = HOST
os.environ['ESPPORT'] = str(PORT)
os.environ['ESPPPROTOCOL'] = PROTOCOL or 'http'
os.environ['ESPUSER'] = USER or ''
os.environ['ESPPASSWORD'] = PASSWD or ''
conn = esppy.ESP()
self.assertEqual(
str(conn).replace("u'", "'"),
("ESP('http://%s:%s')" % (HOST, PORT)).replace("u'", "'"))
def setUp(self):
self.s = esppy.ESP(HOST, PORT, USER, PASSWD, protocol=PROTOCOL)
model_xml_path = os.path.join(DATA_DIR, 'sub_data_csv_model.xml')
name = 'project_01_UnitTest'
with self.assertRaises(KeyError):
self.s.get_project(name)
self.project = self.s.load_project(model_xml_path, name=name)
def setUp(self):
self.s = esppy.ESP(HOST, PORT, USER, PASSWD, protocol=PROTOCOL)
model_xml_path = os.path.join(DATA_DIR, 'model_sa.xml')
name = 'ESPUnitTestProjectSA'
with self.assertRaises(KeyError):
self.s.get_project(name)
self.project = self.s.install_project(model_xml_path)
self.query = self.project.queries['contquery']
self.window = self.project.queries['contquery']['w_data']
self.sub = None
def setUp(self):
self.s = esppy.ESP(HOST, PORT, USER, PASSWD, protocol=PROTOCOL)
def test_url_connection(self):
conn = esppy.ESP('%s://%s:%s' % (PROTOCOL or 'http', HOST, PORT))
self.assertEqual(
str(conn).replace("u'", "'"),
("ESP('%s://%s:%s')" % (PROTOCOL or 'http', HOST, PORT)).replace(
"u'", "'"))
def start_project():
astore_file=args.model
schema_file=args.schema
def createYoloLabelString(file):
regex = re.compile(r'^ *(.*?): *(.*?) *(\(.*?\))?$')
astore_map = {}
current_map='' #input_map: or output_map:
with open(file, newline = '') as source:
reader = csv.reader(source, delimiter='\t')
for row in reader:
if row[0] == 'input-map:':
astore_map[row[0]]=['id*:int64']
current_map=row[0]
elif row[0] == 'output-map:':
astore_map[row[0]]=['id*:int64','_image_:blob']
#astore_map[row[0]].append('_image_:blob')
current_map=row[0]
else:
line=regex.findall(row[0])
if line:
if len(line[0]) == 3:
astore_map[current_map].append(line[0][0].replace(" ", "")+":"+line[0][1].replace(" ", ""))
return astore_map['output-map:']
#host = os.environ['ESPHOST']
#port = os.environ['ESPPORT']
#host = 'espserver.esp19w25.local'
#port = 30001
# connect to the esp server
try:
esp = esppy.ESP('127.0.0.1', args.httpport)
except Exception as e:
print("Can't connect to ESP server: ")
print(e)
logger.info(esp.server_info)
#creating an empty project
logger.info("### Creating Project ###")
detectionProject = esp.create_project('detectionProject')
#adding source window
src = esp.SourceWindow(schema=('id*:int64', 'image:blob'),
index_type='empty', insert_only=True)
detectionProject.windows['w_data'] = src
#adding resize window
resize = esp.calculate.ImageProcessing(schema=('id*:int64', '_image_:blob'), function="resize", width=416, height=416)
resize.set_inputs( imageInput='image:blob')
resize.set_outputs( imageOutput='_image_:blob')
detectionProject.windows['resized'] = resize
#define a request window to inject the astore model to the reader window
model_request = esp.SourceWindow(schema=('req_id*:int64', 'req_key:string', 'req_val:string'),
index_type='empty', insert_only=True)
detectionProject.windows['w_request'] = model_request
#define a model reader window
model_reader = esp.ModelReaderWindow()
detectionProject.windows['w_reader'] = model_reader
labelList = createYoloLabelString(schema_file)
#logger.info(labelList)
scorer = esp.ScoreWindow()
scorer.schema = labelList
scorer.add_offline_model(model_type='astore')
detectionProject.windows['w_score'] = scorer
#connecting the windows
src.add_target( resize, role='data')
resize.add_target( scorer, role='data')
model_request.add_target( model_reader, role='request')
model_reader.add_target( scorer, role='model')
logger.info("### Loading Project ###")
#load the project
esp.load_project(detectionProject)
#print(detectionProject.to_xml(pretty=True))
logger.info("### Loading Model ###")
#send the load model signal
logger.info("Loading " + astore_file)
pub = model_request.create_publisher(blocksize=1, rate=0, pause=0,
dateformat='%Y%m%dT%H:%M:%S.%f', opcode='insert', format='csv')
pub.send('i,n,1,"action","load"\n')
pub.send('i,n,2,"type","astore"\n')
pub.send('i,n,3,"reference","' + astore_file + '"\n')
pub.send('i,n,4,usegpuesp,1\n')
pub.send('i,n,5,NDEVICES,1\n')
pub.send('i,n,6,DEVICE0,0\n')
pub.send('i,n,7,,\n')
pub.close()
logger.info("### Project Started ###")
prediction = prediction2
prediction = ' '.join(filter(
None, prediction.split(' '))) # filter out white space
if prediction == 'good':
prediction_precentage = str(math.floor(float(Precentgood) * 100)) + "%"
elif prediction == 'bad':
prediction_precentage = str(math.floor(float(Precentbad) * 100)) + "%"
else:
prediction_precentage = str(math.floor(
float(Precentempty) * 100)) + "%"
print(prediction, prediction_precentage, "-score durration- ",
localimagesendtime, ' seconds')
return
esp = esppy.ESP(ESPServerURL)
projects = esp.get_projects()
project = projects['prog1']
source = project.queries['CQ'].windows['image']
scored = project.queries['CQ'].windows['imageScoring']
dest = source.create_publisher(blocksize=1,
rate=0,
pause=0,
dateformat='%Y-%m-%d%20%H:%M:%S',
opcode='insert',
format='csv')
finalDest = project.queries['CQ'].windows['imageScoring']
#finalDest.subscribe() # subscribe to output from scoring window.
sub2 = finalDest.create_subscriber(
# import the necessary packages
import base64
import requests
import imutils
import cv2
import os
import sys
import time
esp_host = "http://esp52.dept-crp.sashq-r.openstack.sas.com"
http_port = "60011"
import esppy
# Connect to ESP Server
esp = esppy.ESP(f'{esp_host}:{http_port}')
print(f"INFO: Connected to ESP Server :- {esp}")
proj = esp.get_project('rt_cnn_score')
model_request = proj.windows['w_request']
# Load up ASTORE and set it up for hot loading
pub = model_request.create_publisher(blocksize=1,
rate=0,
pause=0,
dateformat='%Y%m%dT%H:%M:%S.%f',
opcode='insert',
format='csv')
strToSend = 'i,n,1,"action","load"\n'
pub.send(strToSend)
import argparse
import csv
import base64
import uuid
import websocket
sys.path.append("/app/python-esppy")
import esppy
from esppy.plotting import StreamingImages
ESP_HOST = '127.0.0.1'
ESP_PORT = 30003
# connect the ESP server
# please modify your host name and http port number here
esp = esp = esppy.ESP(ESP_HOST, ESP_PORT)
projects = esp.get_projects()
project = projects['detectionProject']
src = project["contquery"]["w_data"]
pub = src.create_publisher()
cal = project["contquery"]["w_score"]
cal.subscribe()
time.sleep(1)
def getUniqueId():
id = str(uuid.uuid1().int >> 96).strip()
return id
def score():
def index():
image = None
form = UploadForm()
label = None
result_series = None
if form.validate_on_submit():
image = 'uploads/' + form.image_file.data.filename
form.image_file.data.save(os.path.join(app.static_folder, image))
# read the image again, move it to ESP
f = cv2.imread(os.path.join(app.static_folder, image))
img_id = random.randint(10, 999999999)
# Encode the image and ship to ESP
returnvalue, array_in_buffer = cv2.imencode('.jpg', f)
encoded_string = base64.b64encode(array_in_buffer)
esp = esppy.ESP(f'{esp_host}:{http_port}')
print(f"INFO: Connected to ESP Server :- {esp}")
proj = esp.get_project('sir_fred_retail')
model_request = proj.windows['w_request']
# Load up ASTORE and set it up for hot loading
# load the model
pub = model_request.create_publisher(blocksize=1,
rate=0,
pause=0,
dateformat='%Y%m%dT%H:%M:%S.%f',
opcode='insert',
format='csv')
strToSend = 'i,n,1,"action","load"\n'
pub.send(strToSend)
strToSend = 'i,n,2,"type","astore"\n'
pub.send(strToSend)
strToSend = 'i,n,3,"reference","/home/cloud-user/race_img_bkp_full/s_Img_Recognition/resnet101_notop.astore"\n'
pub.send(strToSend)
strToSend = 'i,n,4,,\n'
pub.send(strToSend)
print("INFO: ASTORE loaded into ESP for Scoring")
src = proj.windows['w_data']
src_pub = src.create_publisher(blocksize=1,
rate=0,
pause=0,
dateformat='%Y%m%dT%H:%M:%S.%f',
opcode='insert',
format='csv')
model_score = proj.windows['w_score']
model_score.subscribe()
strToSend = f"i,n,{img_id}," + encoded_string.decode() + "\n"
src_pub.send(strToSend)
print(f"INFO: Image {img_id} published into ESP at {time.ctime()}")
# request_url = f'{esp_host}:{http_port}/SASESP/windows/sir_fred_retail/contquery/w_data/state?value=injected'
# payload = {"_body":{
# "id" :f"{img_id}",
# "image":f"{encoded_string.decode()}"
# }}
# headers = {'content-type': 'application/json'}
#
# r = requests.put(request_url,payload,headers=headers)
# try:
# r.raise_for_status()
# if r.status_code==200:
# print(f"INFO: Image {img_id} published into ESP at {time.ctime()}")
# except requests.HTTPError as e:
# print("Could not send image to ESP!")
# print("Error" + str(e))
# toy with this - n/w latency - might not need for a true edge deployment
active_scoring = True
start = time.time()
while active_scoring:
try:
if len(model_score.data) > 0:
result_series = model_score.data.loc[img_id]
label = result_series[0].strip()
result_series = result_series.to_frame().to_html()
active_scoring = False
end = time.time()
score_time = end - start
print(f"total score time of {score_time} seconds")
else:
pass
except:
pass
# might want to refactor this later - but works for the demo
request_url = f'{esp_host}:{http_port}/SASESP/server/state'
payload = {"value": "reloaded"}
r = requests.put(request_url, params=payload)
try:
r.raise_for_status()
if r.status_code == 200:
print("INFO: Remote ESP Server Reloaded for another run!")
except requests.HTTPError as e:
print(
"ERROR: Could not reload the remote ESP server - shutdown & reload manually"
)
print("Error: " + str(e))
return render_template('index.html',
form=form,
image=image,
label=label,
result_series=result_series)
