forked from PHengLEI/PHengLEI-TestCases
616 lines
22 KiB
Python
616 lines
22 KiB
Python
|
# -*- coding: utf-8 -*-
|
|||
|
|
"""
|
|||
|
|
Created on Sun Nov 10 18:13:57 2019
|
|||
|
|
|
|||
|
|
@author: sun
|
|||
|
|
|
|||
|
|
Fortran 调用Python时的模块，包含一些必要的函数和类。如果需要改动增加新的函数与类，则需要写好之后重新
|
|||
|
|
编译DLL，如果只是更改函数内部的处理方式，则不需要。
|
|||
|
|
|
|||
|
|
这个版本的程序传递过来的数据是最原始的流场变量数据，特征的构建和顺序需要在BuildFeatures函数里面完成
|
|||
|
|
模型的预测赋值也直接在pred函数里面完成，所以一定不要改pred函数里面x的值，否则数据可能会传递不过去
|
|||
|
|
这里只是不分区涡粘模型的写法，其他的类似
|
|||
|
|
如果需要提高运行速度，一个优化策略是有选择性的取消属性访问，比如把np.vstack改为form numpy import vstack，而且要尽量使用局部变量
|
|||
|
|
----2020.1.25s
|
|||
|
|
|
|||
|
|
调用华为om模型执行推理 2022.4.20
|
|||
|
|
"""
|
|||
|
|
import numpy as np
|
|||
|
|
import time
|
|||
|
|
import acl
|
|||
|
|
|
|||
|
|
import constants as const
|
|||
|
|
import acllite_utils as utils
|
|||
|
|
from acllite_logger import log_error, log_info, log_warning
|
|||
|
|
from acllite_resource import resource_list, AclLiteResource
|
|||
|
|
from omaclitemodel import AclLiteModel
|
|||
|
|
|
|||
|
|
from constant import ACL_MEM_MALLOC_HUGE_FIRST, \
|
|||
|
|
ACL_MEMCPY_HOST_TO_DEVICE, ACL_MEMCPY_DEVICE_TO_HOST, \
|
|||
|
|
NPY_FLOAT32, ACL_SUCCESS, NPY_FLOAT16,ACL_PROF_ACL_API, \
|
|||
|
|
ACL_PROF_TASK_TIME, ACL_PROF_AICPU_TRACE, ACL_PROF_AICORE_METRICS, ACL_PROF_L2CACHE
|
|||
|
|
|
|||
|
|
buffer_method = {
|
|||
|
|
"in": acl.mdl.get_input_size_by_index,
|
|||
|
|
"out": acl.mdl.get_output_size_by_index
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
# create the dictionary mapping ctypes to np dtypes
|
|||
|
|
|
|||
|
|
ctype2dtype = {}
|
|||
|
|
|
|||
|
|
# Intertypes
|
|||
|
|
for prefix in ('int', 'uint'):
|
|||
|
|
for log_bytes in range(4):
|
|||
|
|
ctype = '%s%d_t' % (prefix, 8 * (2 ** log_bytes))
|
|||
|
|
dtype = '%s%d' % (prefix[0], 2 ** log_bytes)
|
|||
|
|
ctype2dtype[ctype] = np.dtype(dtype)
|
|||
|
|
|
|||
|
|
# Floating point types
|
|||
|
|
ctype2dtype['float'] = np.dtype('f4')
|
|||
|
|
ctype2dtype['double'] = np.dtype('f8')
|
|||
|
|
ctype2dtype['int'] = np.dtype('int32')
|
|||
|
|
|
|||
|
|
def check_ret(message, ret):
|
|||
|
|
if ret != ACL_SUCCESS:
|
|||
|
|
raise Exception("{} failed ret={}"
|
|||
|
|
.format(message, ret))
|
|||
|
|
|
|||
|
|
def GetDataFromPointer(ffi, pointer):
|
|||
|
|
"""
|
|||
|
|
将指针的数据获取出来
|
|||
|
|
"""
|
|||
|
|
T = ffi.getctype(ffi.typeof(pointer).item)
|
|||
|
|
value = np.frombuffer(ffi.buffer(pointer, ffi.sizeof(T)),
|
|||
|
|
ctype2dtype[T])
|
|||
|
|
value = value.item()
|
|||
|
|
return value
|
|||
|
|
|
|||
|
|
class BFNet(object):
|
|||
|
|
def __init__(self, device_id, model_path, model_path_2, model_path_3):
|
|||
|
|
self.device_id = device_id # int
|
|||
|
|
self.model_path = model_path # string
|
|||
|
|
self.model_path_2 = model_path_2
|
|||
|
|
self.model_path_3 = model_path_3
|
|||
|
|
self.model_id = None # pointer
|
|||
|
|
self.model_id_2 = None
|
|||
|
|
self.model_id_3 = None
|
|||
|
|
self.context = None # pointer
|
|||
|
|
|
|||
|
|
self.input_data = []
|
|||
|
|
self.output_data = []
|
|||
|
|
self.output_data_2 = []
|
|||
|
|
self.output_data_3 = []
|
|||
|
|
self.model_desc = None # pointer when using
|
|||
|
|
self.model_desc_2 = None
|
|||
|
|
self.model_desc_3 = None
|
|||
|
|
self.load_input_dataset = None
|
|||
|
|
self.load_output_dataset = None
|
|||
|
|
self.load_output_dataset_2 = None
|
|||
|
|
self.load_output_dataset_3 = None
|
|||
|
|
self.prof_config = None
|
|||
|
|
|
|||
|
|
self.init_resource()
|
|||
|
|
|
|||
|
|
def __del__(self):
|
|||
|
|
print("Releasing resources stage:")
|
|||
|
|
ret = acl.mdl.unload(self.model_id)
|
|||
|
|
# check_ret("acl.mdl.unload", ret)
|
|||
|
|
ret = acl.mdl.unload(self.model_id_2)
|
|||
|
|
# ret = acl.mdl.unload(self.model_id_3)
|
|||
|
|
if self.model_desc:
|
|||
|
|
acl.mdl.destroy_desc(self.model_desc)
|
|||
|
|
self.model_desc = None
|
|||
|
|
if self.model_desc_2:
|
|||
|
|
acl.mdl.destroy_desc(self.model_desc_2)
|
|||
|
|
self.model_desc_2 = None
|
|||
|
|
if self.model_desc_3:
|
|||
|
|
acl.mdl.destroy_desc(self.model_desc_3)
|
|||
|
|
self.model_desc_3 = None
|
|||
|
|
|
|||
|
|
while self.input_data:
|
|||
|
|
item = self.input_data.pop()
|
|||
|
|
ret = acl.rt.free(item["buffer"])
|
|||
|
|
# check_ret("acl.rt.free", ret)
|
|||
|
|
|
|||
|
|
while self.output_data:
|
|||
|
|
item = self.output_data.pop()
|
|||
|
|
ret = acl.rt.free(item["buffer"])
|
|||
|
|
# check_ret("acl.rt.free", ret)
|
|||
|
|
|
|||
|
|
while self.output_data_2:
|
|||
|
|
item = self.output_data_2.pop()
|
|||
|
|
ret = acl.rt.free(item["buffer"])
|
|||
|
|
# check_ret("acl.rt.free", ret)
|
|||
|
|
|
|||
|
|
while self.output_data_3:
|
|||
|
|
item = self.output_data_3.pop()
|
|||
|
|
ret = acl.rt.free(item["buffer"])
|
|||
|
|
# check_ret("acl.rt.free", ret)
|
|||
|
|
|
|||
|
|
if self.context:
|
|||
|
|
ret = acl.rt.destroy_context(self.context)
|
|||
|
|
# check_ret("acl.rt.destroy_context", ret)
|
|||
|
|
self.context = None
|
|||
|
|
|
|||
|
|
|
|||
|
|
ret = acl.rt.reset_device(self.device_id)
|
|||
|
|
# check_ret("acl.rt.reset_device", ret)
|
|||
|
|
ret = acl.finalize()
|
|||
|
|
# check_ret("acl.finalize", ret)
|
|||
|
|
# print('Resources released successfully.')
|
|||
|
|
|
|||
|
|
def init_resource(self):
|
|||
|
|
# print("init resource stage:")
|
|||
|
|
ret = acl.init()
|
|||
|
|
# check_ret("acl.init", ret)
|
|||
|
|
ret = acl.rt.set_device(self.device_id)
|
|||
|
|
# check_ret("acl.rt.set_device", ret)
|
|||
|
|
|
|||
|
|
self.context, ret = acl.rt.create_context(self.device_id)
|
|||
|
|
# check_ret("acl.rt.create_context", ret)
|
|||
|
|
|
|||
|
|
# load_model
|
|||
|
|
self.model_id, ret = acl.mdl.load_from_file(self.model_path)
|
|||
|
|
# check_ret("acl.mdl.load_from_file", ret)
|
|||
|
|
# print("model_id:{}".format(self.model_id))
|
|||
|
|
|
|||
|
|
self.model_id_2, ret = acl.mdl.load_from_file(self.model_path_2)
|
|||
|
|
# check_ret("acl.mdl.load_from_file", ret)
|
|||
|
|
# print("model_id_2:{}".format(self.model_id_2))
|
|||
|
|
|
|||
|
|
self.model_id_3, ret = acl.mdl.load_from_file(self.model_path_3)
|
|||
|
|
check_ret("acl.mdl.load_from_file", ret)
|
|||
|
|
# print("model_id_2:{}".format(self.model_id_2))
|
|||
|
|
|
|||
|
|
self.model_desc = acl.mdl.create_desc()
|
|||
|
|
self._get_model_info()
|
|||
|
|
|
|||
|
|
self.model_desc_2 = acl.mdl.create_desc()
|
|||
|
|
self._get_model_info_2()
|
|||
|
|
|
|||
|
|
self.model_desc_3 = acl.mdl.create_desc()
|
|||
|
|
self._get_model_info_3()
|
|||
|
|
# print("init resource success")
|
|||
|
|
|
|||
|
|
def _get_model_info(self,):
|
|||
|
|
ret = acl.mdl.get_desc(self.model_desc, self.model_id)
|
|||
|
|
# check_ret("acl.mdl.get_desc", ret)
|
|||
|
|
input_size = acl.mdl.get_num_inputs(self.model_desc)
|
|||
|
|
# print("input_size")
|
|||
|
|
# print(input_size)
|
|||
|
|
output_size = acl.mdl.get_num_outputs(self.model_desc)
|
|||
|
|
# print("output_size")
|
|||
|
|
# print(output_size)
|
|||
|
|
self._gen_data_buffer(input_size, des="in")
|
|||
|
|
self._gen_data_buffer(output_size, des="out")
|
|||
|
|
|
|||
|
|
def _get_model_info_2(self,):
|
|||
|
|
ret = acl.mdl.get_desc(self.model_desc_2, self.model_id_2)
|
|||
|
|
# check_ret("acl.mdl.get_desc", ret)
|
|||
|
|
input_size = acl.mdl.get_num_inputs(self.model_desc_2)
|
|||
|
|
# print("model_2_input_size")
|
|||
|
|
# print(input_size)
|
|||
|
|
output_size = acl.mdl.get_num_outputs(self.model_desc_2)
|
|||
|
|
# print("model2_output_size")
|
|||
|
|
# print(output_size)
|
|||
|
|
# self._gen_data_buffer(input_size, des="in")
|
|||
|
|
self._gen_data_buffer_2(output_size, des="out")
|
|||
|
|
|
|||
|
|
def _get_model_info_3(self,):
|
|||
|
|
ret = acl.mdl.get_desc(self.model_desc_3, self.model_id_3)
|
|||
|
|
# check_ret("acl.mdl.get_desc", ret)
|
|||
|
|
input_size = acl.mdl.get_num_inputs(self.model_desc_3)
|
|||
|
|
# print("model_3_input_size")
|
|||
|
|
# print(input_size)
|
|||
|
|
output_size = acl.mdl.get_num_outputs(self.model_desc_3)
|
|||
|
|
# print("model_3_output_size")
|
|||
|
|
# print(output_size)
|
|||
|
|
# self._gen_data_buffer(input_size, des="in")
|
|||
|
|
self._gen_data_buffer_3(output_size, des="out")
|
|||
|
|
|
|||
|
|
def _gen_data_buffer(self, size, des):
|
|||
|
|
func = buffer_method[des]
|
|||
|
|
for i in range(size):
|
|||
|
|
# check temp_buffer dtype
|
|||
|
|
temp_buffer_size = func(self.model_desc, i)
|
|||
|
|
temp_buffer, ret = acl.rt.malloc(temp_buffer_size,
|
|||
|
|
ACL_MEM_MALLOC_HUGE_FIRST)
|
|||
|
|
# check_ret("acl.rt.malloc", ret)
|
|||
|
|
|
|||
|
|
if des == "in":
|
|||
|
|
self.input_data.append({"buffer": temp_buffer,
|
|||
|
|
"size": temp_buffer_size})
|
|||
|
|
elif des == "out":
|
|||
|
|
self.output_data.append({"buffer": temp_buffer,
|
|||
|
|
"size": temp_buffer_size})
|
|||
|
|
|
|||
|
|
def _gen_data_buffer_2(self, size, des):
|
|||
|
|
func = buffer_method[des]
|
|||
|
|
for i in range(size):
|
|||
|
|
# check temp_buffer dtype
|
|||
|
|
temp_buffer_size = func(self.model_desc_2, i)
|
|||
|
|
temp_buffer, ret = acl.rt.malloc(temp_buffer_size,
|
|||
|
|
ACL_MEM_MALLOC_HUGE_FIRST)
|
|||
|
|
# check_ret("acl.rt.malloc", ret)
|
|||
|
|
#
|
|||
|
|
# if des == "in":
|
|||
|
|
# self.input_data.append({"buffer": temp_buffer,
|
|||
|
|
# "size": temp_buffer_size})
|
|||
|
|
# elif des == "out":
|
|||
|
|
self.output_data_2.append({"buffer": temp_buffer,
|
|||
|
|
"size": temp_buffer_size})
|
|||
|
|
|
|||
|
|
def _gen_data_buffer_3(self, size, des):
|
|||
|
|
func = buffer_method[des]
|
|||
|
|
for i in range(size):
|
|||
|
|
# check temp_buffer dtype
|
|||
|
|
temp_buffer_size = func(self.model_desc_3, i)
|
|||
|
|
temp_buffer, ret = acl.rt.malloc(temp_buffer_size,
|
|||
|
|
ACL_MEM_MALLOC_HUGE_FIRST)
|
|||
|
|
# check_ret("acl.rt.malloc", ret)
|
|||
|
|
#
|
|||
|
|
# if des == "in":
|
|||
|
|
# self.input_data.append({"buffer": temp_buffer,
|
|||
|
|
# "size": temp_buffer_size})
|
|||
|
|
# elif des == "out":
|
|||
|
|
self.output_data_3.append({"buffer": temp_buffer,
|
|||
|
|
"size": temp_buffer_size})
|
|||
|
|
|
|||
|
|
def _data_interaction(self, dataset, policy=ACL_MEMCPY_HOST_TO_DEVICE):
|
|||
|
|
temp_data_buffer = self.input_data \
|
|||
|
|
if policy == ACL_MEMCPY_HOST_TO_DEVICE \
|
|||
|
|
else self.output_data_3
|
|||
|
|
if len(dataset) == 0 and policy == ACL_MEMCPY_DEVICE_TO_HOST:
|
|||
|
|
for item in self.output_data_3:
|
|||
|
|
begin = time.time()
|
|||
|
|
temp, ret = acl.rt.malloc_host(item["size"])
|
|||
|
|
end = time.time()
|
|||
|
|
# print(f"ACL_MEMCPY_HOST_TO_DEVICE malloc = {end-begin}")
|
|||
|
|
# print("item[size]")
|
|||
|
|
# print(item["size"])
|
|||
|
|
if ret != 0:
|
|||
|
|
raise Exception("can't malloc_host ret={}".format(ret))
|
|||
|
|
dataset.append({"size": item["size"], "buffer": temp})
|
|||
|
|
|
|||
|
|
for i, item in enumerate(temp_data_buffer):
|
|||
|
|
if policy == ACL_MEMCPY_HOST_TO_DEVICE:
|
|||
|
|
# print(f"i is {i}")
|
|||
|
|
a = item["size"]
|
|||
|
|
# print(f"size is {a}")
|
|||
|
|
# print(i)
|
|||
|
|
# print(dataset.shape)
|
|||
|
|
ptr,_ = acl.util.numpy_contiguous_to_ptr(dataset[i])
|
|||
|
|
begin = time.time()
|
|||
|
|
ret = acl.rt.memcpy(item["buffer"],
|
|||
|
|
item["size"],
|
|||
|
|
ptr,
|
|||
|
|
item["size"],
|
|||
|
|
policy)
|
|||
|
|
end = time.time()
|
|||
|
|
# print(f"ACL_MEMCPY_HOST_TO_DEVICE = {end-begin}")
|
|||
|
|
check_ret("acl.rt.memcpy", ret)
|
|||
|
|
|
|||
|
|
else:
|
|||
|
|
# print(f"i is {i}")
|
|||
|
|
a = item["size"]
|
|||
|
|
# print(f"size is {a}")
|
|||
|
|
ptr = dataset[i]["buffer"]
|
|||
|
|
begin = time.time()
|
|||
|
|
ret = acl.rt.memcpy(ptr,
|
|||
|
|
item["size"],
|
|||
|
|
item["buffer"],
|
|||
|
|
item["size"],
|
|||
|
|
policy)
|
|||
|
|
end = time.time()
|
|||
|
|
# print(f"ACL_MEMCPY_DEVICE_TO_HOST = {end-begin}")
|
|||
|
|
check_ret("acl.rt.memcpy", ret)
|
|||
|
|
|
|||
|
|
def _gen_dataset(self, type_str="in"):
|
|||
|
|
dataset = acl.mdl.create_dataset()
|
|||
|
|
|
|||
|
|
temp_dataset = None
|
|||
|
|
if type_str == "in":
|
|||
|
|
self.load_input_dataset = dataset
|
|||
|
|
temp_dataset = self.input_data
|
|||
|
|
elif type_str == "out":
|
|||
|
|
self.load_output_dataset = dataset
|
|||
|
|
temp_dataset = self.output_data
|
|||
|
|
elif type_str == "out2":
|
|||
|
|
self.load_output_dataset_2 = dataset
|
|||
|
|
temp_dataset = self.output_data_2
|
|||
|
|
elif type_str == "out3":
|
|||
|
|
self.load_output_dataset_3 = dataset
|
|||
|
|
temp_dataset = self.output_data_3
|
|||
|
|
|
|||
|
|
for item in temp_dataset:
|
|||
|
|
data = acl.create_data_buffer(item["buffer"], item["size"])
|
|||
|
|
_, ret = acl.mdl.add_dataset_buffer(dataset, data)
|
|||
|
|
|
|||
|
|
if ret != ACL_SUCCESS:
|
|||
|
|
ret = acl.destroy_data_buffer(data)
|
|||
|
|
# check_ret("acl.destroy_data_buffer", ret)
|
|||
|
|
|
|||
|
|
def _data_from_host_to_device(self, images):
|
|||
|
|
# print("data interaction from host to device")
|
|||
|
|
# copy images to device
|
|||
|
|
|
|||
|
|
begin = time.time()
|
|||
|
|
# print("images is ", images)
|
|||
|
|
# print(len(images))
|
|||
|
|
self._data_interaction(images, ACL_MEMCPY_HOST_TO_DEVICE)
|
|||
|
|
|
|||
|
|
end = time.time()
|
|||
|
|
|
|||
|
|
# print(f"_data_from_host_to_device = {end-begin}")
|
|||
|
|
# load input data into model
|
|||
|
|
self._gen_dataset("in")
|
|||
|
|
# load output data into model
|
|||
|
|
self._gen_dataset("out")
|
|||
|
|
# load second output data into model
|
|||
|
|
self._gen_dataset("out2")
|
|||
|
|
# # load third output data into model
|
|||
|
|
self._gen_dataset("out3")
|
|||
|
|
# # print("data interaction from host to device success")
|
|||
|
|
|
|||
|
|
def _data_from_device_to_host(self):
|
|||
|
|
# print("data interaction from device to host")
|
|||
|
|
res = []
|
|||
|
|
# copy device to host
|
|||
|
|
begin = time.time()
|
|||
|
|
|
|||
|
|
self._data_interaction(res, ACL_MEMCPY_DEVICE_TO_HOST)
|
|||
|
|
|
|||
|
|
end = time.time()
|
|||
|
|
|
|||
|
|
# print(f"_data_from_device_to_host = {end-begin}")
|
|||
|
|
# print("data interaction from device to host success")
|
|||
|
|
# result = self.get_result(res,self.model_desc_3, NPY_FLOAT32)
|
|||
|
|
result = self.get_result(res, self.model_desc_3, NPY_FLOAT32)
|
|||
|
|
# self._print_result(result)
|
|||
|
|
# free host memory
|
|||
|
|
# for item in res:
|
|||
|
|
# ptr = item['buffer']
|
|||
|
|
# ret = acl.rt.free_host(ptr)
|
|||
|
|
# check_ret('acl.rt.free_host', ret)
|
|||
|
|
return result
|
|||
|
|
def run(self, images):
|
|||
|
|
start = time.time()
|
|||
|
|
self._data_from_host_to_device(images)
|
|||
|
|
end = time.time()
|
|||
|
|
# print(f"_data_from_host_to_device = {end-start}")
|
|||
|
|
# self.start_profile()
|
|||
|
|
self.forward()
|
|||
|
|
end2 = time.time()
|
|||
|
|
# print(f"forward = {end2-end}")
|
|||
|
|
# self.end_profile(self.prof_config)
|
|||
|
|
result = self._data_from_device_to_host()
|
|||
|
|
end3 = time.time()
|
|||
|
|
# print(f"_data_from_device_to_host = {end3-end2}")
|
|||
|
|
return result
|
|||
|
|
|
|||
|
|
def forward(self):
|
|||
|
|
# print('execute stage:')
|
|||
|
|
start = time.time()
|
|||
|
|
ret = acl.mdl.execute(self.model_id, self.load_input_dataset, self.load_output_dataset)
|
|||
|
|
end1 = time.time()
|
|||
|
|
# print(f"first om time={end1 - start}")
|
|||
|
|
# check_ret("acl.mdl.execute", ret)
|
|||
|
|
# start = time.time()
|
|||
|
|
ret = acl.mdl.execute(self.model_id_2, self.load_output_dataset, self.load_output_dataset_2)
|
|||
|
|
end2 = time.time()
|
|||
|
|
# print(f"second om time={end2 - end1}")
|
|||
|
|
# check_ret("acl.mdl.execute", ret)
|
|||
|
|
# start = time.time()
|
|||
|
|
ret = acl.mdl.execute(self.model_id_3, self.load_output_dataset_2, self.load_output_dataset_3)
|
|||
|
|
end3 = time.time()
|
|||
|
|
# print(f"third om time={end3 - end2}")
|
|||
|
|
# check_ret("acl.mdl.execute", ret)
|
|||
|
|
self._destroy_databuffer()
|
|||
|
|
# print('execute stage success')
|
|||
|
|
|
|||
|
|
def _print_result(self, result):
|
|||
|
|
print(result)
|
|||
|
|
|
|||
|
|
def _destroy_databuffer(self):
|
|||
|
|
# for dataset in [self.load_input_dataset, self.load_output_dataset, self.load_output_dataset_2, self.load_output_dataset_3]:
|
|||
|
|
for dataset in [self.load_input_dataset, self.load_output_dataset, self.load_output_dataset_2, self.load_output_dataset_3]:
|
|||
|
|
# for dataset in [self.load_input_dataset, self.load_output_dataset, self.load_output_dataset_2]:
|
|||
|
|
if not dataset:
|
|||
|
|
continue
|
|||
|
|
number = acl.mdl.get_dataset_num_buffers(dataset)
|
|||
|
|
for i in range(number):
|
|||
|
|
data_buf = acl.mdl.get_dataset_buffer(dataset, i)
|
|||
|
|
if data_buf:
|
|||
|
|
ret = acl.destroy_data_buffer(data_buf)
|
|||
|
|
# check_ret("acl.destroy_data_buffer", ret)
|
|||
|
|
ret = acl.mdl.destroy_dataset(dataset)
|
|||
|
|
# check_ret("acl.mdl.destroy_dataset", ret)
|
|||
|
|
|
|||
|
|
def get_result(self, output_data, model_desc, data_type):
|
|||
|
|
result = []
|
|||
|
|
dims, ret = acl.mdl.get_cur_output_dims(model_desc, 0)
|
|||
|
|
# check_ret("acl.mdl.get_cur_output_dims", ret)
|
|||
|
|
out_dim = dims['dims']
|
|||
|
|
# print(tuple(out_dim))
|
|||
|
|
for temp in output_data:
|
|||
|
|
ptr = temp["buffer"]
|
|||
|
|
# print(temp)
|
|||
|
|
# 转化为float32类型的数据
|
|||
|
|
data = acl.util.ptr_to_numpy(ptr, tuple(out_dim), data_type)
|
|||
|
|
# print(data)
|
|||
|
|
result.append(data)
|
|||
|
|
return result
|
|||
|
|
|
|||
|
|
def asarray(ffi, x_ptr, shape1_ptr, shape2_ptr):
|
|||
|
|
"""
|
|||
|
|
x_ptr : Fortran传递过来的数组的地址
|
|||
|
|
size_ptr : Fortran数组的大小的地址
|
|||
|
|
因为传递过来的都是地址，因此需要先把地址中的数值取出来，才可以进行数据处理
|
|||
|
|
"""
|
|||
|
|
shape = [GetDataFromPointer(ffi, pointer) for pointer in (shape1_ptr,
|
|||
|
|
shape2_ptr)]
|
|||
|
|
length = np.prod(shape)
|
|||
|
|
# Get the canonical C type of the elments of ptr as a string
|
|||
|
|
T = ffi.getctype(ffi.typeof(x_ptr).item)
|
|||
|
|
x = np.frombuffer(ffi.buffer(x_ptr, length * ffi.sizeof(T)),
|
|||
|
|
ctype2dtype[T]).reshape(shape, order='C')
|
|||
|
|
return x
|
|||
|
|
|
|||
|
|
def read_data(file_path):
|
|||
|
|
with open(file_path, 'r') as f:
|
|||
|
|
return np.array([float(x) for x in f.read().split()]).reshape(-1, 1)
|
|||
|
|
|
|||
|
|
class pythonmodel(object):
|
|||
|
|
def __init__(self):
|
|||
|
|
"""
|
|||
|
|
类初始化
|
|||
|
|
"""
|
|||
|
|
self.sca_min = np.loadtxt('./model/sca_min.dat').reshape(-1, 1)
|
|||
|
|
self.sca_max = np.loadtxt('./model/sca_max.dat').reshape(-1, 1)
|
|||
|
|
self.temp = np.ones((1300000, 17))
|
|||
|
|
self.model1_path = "./model/bf_op.om"
|
|||
|
|
self.model2_path = "./model/model16.om"
|
|||
|
|
self.model3_path = "./model/post_op.om"
|
|||
|
|
self.flag = 0
|
|||
|
|
print('model loaded!')
|
|||
|
|
|
|||
|
|
def modelInit(self, zone_id):
|
|||
|
|
"""
|
|||
|
|
om模型初始化
|
|||
|
|
"""
|
|||
|
|
self.dev_id = zone_id % 8
|
|||
|
|
# self.DSTURB_min = dis_min
|
|||
|
|
self.bfnet = BFNet(self.dev_id, self.model1_path, self.model2_path, self.model3_path)
|
|||
|
|
|
|||
|
|
def BuildFeatures(self, x):
|
|||
|
|
"""
|
|||
|
|
基于原始变量，构建模型需要的输入特征
|
|||
|
|
x : 包含原始变量，依次为：Ru, U, V, W, P, Ux, Uy, Uz, Vx, Vy, Vz, Wx, Wy, Wz, Px, Py, Pz, x, y, z, dis, ma, aoa, re
|
|||
|
|
"""
|
|||
|
|
ma = x[:, -2]
|
|||
|
|
self.Re = x[:, -1]
|
|||
|
|
print(self.Re.shape)
|
|||
|
|
# eps = 1e-13
|
|||
|
|
# aoa = x[:, -2]
|
|||
|
|
Ru, P = x[:, 0], x[:, 3] * ma ** 2
|
|||
|
|
U, V = x[:, 1], x[:, 2]
|
|||
|
|
Ux, Uy, Uz = x[:, 4], x[:, 5], x[:, 6]
|
|||
|
|
Vx, Vy, Vz = x[:, 7], x[:, 8], x[:, 9]
|
|||
|
|
Wx, Wy, Wz = x[:, 10], x[:, 11], x[:, 12]
|
|||
|
|
# Px, Py, Pz = x[:, 14] * ma ** 2, x[:, 15] * ma ** 2, x[:, 16] * ma ** 2
|
|||
|
|
Y = x[:, 13]
|
|||
|
|
dis = x[:, 14]
|
|||
|
|
self.dis = dis
|
|||
|
|
|
|||
|
|
# q1 = np.sqrt(U**2 + V**2 + W**2)
|
|||
|
|
q1 = U # / np.sqrt(U**2 + V**2 + W**2)
|
|||
|
|
# q1_2 = V / np.sqrt(U**2 + V**2 + W**2)
|
|||
|
|
|
|||
|
|
w1 = 0.5 * (Wy - Vz)
|
|||
|
|
w2 = 0.5 * (Uz - Wx)
|
|||
|
|
w3 = 0.5 * (Vx - Uy)
|
|||
|
|
RF = np.sqrt(w1 ** 2 + w2 ** 2 + w3 ** 2)
|
|||
|
|
# q2 = np.log(np.abs(RF) + 1.0)
|
|||
|
|
|
|||
|
|
q3 = (P / Ru ** 1.4) - 1.0
|
|||
|
|
|
|||
|
|
label = np.where(dis < 0.001, 1, 2)
|
|||
|
|
|
|||
|
|
sigY = np.sign(Y)
|
|||
|
|
q5 = np.arctan(sigY * V / U)
|
|||
|
|
|
|||
|
|
S11 = Ux
|
|||
|
|
S12 = 0.5 * (Uy + Vx)
|
|||
|
|
S13 = 0.5 * (Uz + Wx)
|
|||
|
|
S22 = Vy
|
|||
|
|
S23 = 0.5 * (Vz + Wy)
|
|||
|
|
S33 = Wz
|
|||
|
|
SF = np.sqrt(S11 ** 2 + S12 ** 2 + S13 ** 2 + S22 ** 2 + S23 ** 2 + S33 ** 2)
|
|||
|
|
# q7 = np.log(np.abs(SF) + 1.0)
|
|||
|
|
|
|||
|
|
q8 = dis ** 2 * RF * (1 - np.tanh(dis))
|
|||
|
|
q9 = dis ** 2 * SF * (1 - np.tanh(dis))
|
|||
|
|
|
|||
|
|
Dref0 = 1.0 / np.sqrt(self.Re)
|
|||
|
|
Dref1 = np.min([dis, Dref0], axis=0)
|
|||
|
|
Dref2 = np.max([dis, Dref0], axis=0)
|
|||
|
|
expfunc = 2.71828 ** (np.sqrt(Dref1 / (dis)))
|
|||
|
|
q10 = expfunc * np.sqrt(Dref0 / (Dref2))
|
|||
|
|
|
|||
|
|
q11 = (RF ** 2 - SF ** 2) / (RF ** 2 + SF ** 2)
|
|||
|
|
|
|||
|
|
data = np.vstack((q1, label, RF, q3, q5, SF, q8, q9, q10, q11)).T # 输入特征顺序
|
|||
|
|
|
|||
|
|
col = data.shape[1]
|
|||
|
|
x = (data - self.sca_min[0:col, 0]) / (self.sca_max[0:col, 0] - self.sca_min[0:col, 0])
|
|||
|
|
return x
|
|||
|
|
|
|||
|
|
def GetFueatures(self, x):
|
|||
|
|
ma = x[:, -3]
|
|||
|
|
self.Re = x[:, -1]
|
|||
|
|
aoa = x[:, -2]
|
|||
|
|
Ru, P = x[:, 0], x[:, 3]
|
|||
|
|
U, V = x[:, 1], x[:, 2]
|
|||
|
|
Ux, Uy = x[:, 4], x[:, 5]
|
|||
|
|
Vx, Vy = x[:, 6], x[:, 7]
|
|||
|
|
Y, self.dis = x[:, 8], x[:, 9]
|
|||
|
|
data = [ma, aoa, self.Re, self.dis, Ux, U, V, Uy, Vx, Vy, Y, P, Ru]
|
|||
|
|
return data
|
|||
|
|
|
|||
|
|
def ACT(self, x, low, up, length):
|
|||
|
|
"""
|
|||
|
|
调用om模型预测涡粘
|
|||
|
|
low: 归一化下界
|
|||
|
|
up: 归一化上界
|
|||
|
|
x: 输入特征，np.array格式
|
|||
|
|
"""
|
|||
|
|
x = x.astype(np.float32)
|
|||
|
|
ptr, data_out = acl.util.numpy_contiguous_to_ptr(x)
|
|||
|
|
pred = self.bfnet.run([data_out])[0]
|
|||
|
|
pred = pred[0:length]
|
|||
|
|
return pred
|
|||
|
|
|
|||
|
|
def Pred(self, x):
|
|||
|
|
"""
|
|||
|
|
模型预测涡粘
|
|||
|
|
"""
|
|||
|
|
start = time.time()
|
|||
|
|
length = x.shape[0]
|
|||
|
|
self.temp[0:length, :] = x[:, :]
|
|||
|
|
low, up = 0.0, 1.0
|
|||
|
|
pred = self.ACT(self.temp, low, up, length)
|
|||
|
|
x[:, 0] = pred[:].copy()
|
|||
|
|
end = time.time()
|
|||
|
|
|
|||
|
|
def post_op(pred, low, high) :
|
|||
|
|
sca_min = np.loadtxt('./model/sca_min.dat').reshape(-1, )
|
|||
|
|
sca_max = np.loadtxt('./model/sca_max.dat').reshape(-1, )
|
|||
|
|
|
|||
|
|
Re = 11710000
|
|||
|
|
|
|||
|
|
pred = np.clip(pred[:, 0], low, high).reshape(-1, 1)
|
|||
|
|
|
|||
|
|
mut_min = 8.539709649871904494e-07
|
|||
|
|
mut_max = 8.296507258753202052e+01
|
|||
|
|
pred = pred * (mut_max - mut_min) + mut_min
|
|||
|
|
pred = pred * (Re / 1e6)
|
|||
|
|
return pred
|
|||
|
|
|
|||
|
|
if __name__ == "__main__" :
|
|||
|
|
|
|||
|
|
model_2 = pythonmodel()
|
|||
|
|
model_2.modelInit(5)
|
|||
|
|
|
|||
|
|
np.random.seed(4)
|
|||
|
|
x = np.random.rand(1300000, 17).astype(np.float32)
|
|||
|
|
y = x.copy()
|
|||
|
|
model_2.Pred(y)
|
|||
|
|
pred_2 = y[:, 0]
|
|||
|
|
print("**********")
|
|||
|
|
print(pred_2)
|
|||
|
|
print(type(pred_2))
|
|||
|
|
print(pred_2.mean())
|
|||
|
|
print(pred_2.std())
|
|||
|
|
print(pred_2.shape)
|