#! /usr/bin/env python3 import os import pathlib import tempfile import shutil import re import json from collections import OrderedDict from functools import lru_cache import numpy as np import sys_flow.flow_constants as fconsts import sys_flow.flow_utils as futils import snoop DEBUG = True if os.environ.get("REGRESSION_DEBUG", False) else False snoop.install(enabled=DEBUG) # constants P_TMP_MODEL = pathlib.Path("/tmp/model_working") P_TMP_INPUT = pathlib.Path("/tmp/input_data") def get_nef_util_bins(): bin_nef_util = fconsts.BIN_SET["compiler"]["kneron_nef_utils"] bin_kne_util = fconsts.BIN_SET["compiler"]["kneron_kne_utils"] pb_nef = pathlib.Path(bin_nef_util).parent pb_kne = pathlib.Path(bin_kne_util).parent ADD_NEF_UTIL_PATH = f"""export PATH={pb_nef}:{pb_kne}:$PATH""" return ADD_NEF_UTIL_PATH, bin_nef_util, bin_kne_util ADD_NEF_UTIL_PATH, bin_nef_util, bin_kne_util = get_nef_util_bins() ################################################################################### # get model info from nef + ioinfo.json ################################################################################### def clean_list_nef(list_nef): """Convert to str and make uniq.""" # convert to str. it may be pathlib obj l1 = [str(nef) for nef in list_nef] # make unique l2 = list(set(l1)) return " ".join(l2) def combine_nef(list_nef: list, hw_mode, d_out): """Combine multiple nef into one using nef utils. After combination, the combined.nef will run extra `unpack_nefs()` and re-organized with `ioinfo.json` per model. This side-effect is prepared a combined `ioinfo.json` for dongle inference. Args: list_nef (list): each element is path to nef file. hw_mode (int): specify platform. d_out (pathlib / str) : where to put `combined.nef` and `ioinfo.json` Returns: tuple: multiple info returned: - `p_out`: where is the out folder. usually same as specified. - `p_nef`: path of the combined nef - `p_ioinfo`: path of the (combined) ioinfo.json, prepared for dongle, not for normal process! - `fn_maps`: the combined.nef is unpacked and re-organized in `p_out/unpack`. Per-model file mapping is recorded in this. Same as `unpack_nefs()` returned. """ temp_dir = tempfile.mkdtemp() lst = clean_list_nef(list_nef) cmd = f"{ADD_NEF_UTIL_PATH}; {bin_nef_util} --combine_nef \"{lst}\" -O {temp_dir}" # currently no -o option working. we need to cpy $temp_dir/models_xxx.nef to fn_out cp = futils.run_bash_script(cmd) assert cp.returncode == 0, f"extract nef failed with return code: {cp.returncode}" # check output p_temp = pathlib.Path(temp_dir) nefs = list(p_temp.glob("models_*.nef")) assert len(nefs) == 1, f"combine nef but find {len(nefs)} created: {nefs}" # copy necessary files to p_out p_out = pathlib.Path(d_out) p_out.mkdir(parents=True, exist_ok=True) p_nef = p_out / "combined.nef" shutil.copyfile(nefs[0], p_nef) # prepare ioinfo (for convience of dongle) dongle_io = {} fn_maps, p_dump = unpack_nefs(p_nef, hw_mode) for model_id, (p_unpack, ioinfo) in fn_maps.items(): dongle_io[model_id] = {} dongle_io[model_id]["ioinfo_in"] = ioinfo["input"] dongle_io[model_id]["ioinfo_out"] = ioinfo["output"] p_ioinfo = p_out / "ioinfo.json" with open(p_ioinfo, "w") as f: json.dump(dongle_io, f, cls=NumpyEncoder) shutil.rmtree(temp_dir, ignore_errors=True) return p_out, p_nef, p_ioinfo, fn_maps def guess_available_model_id(p_dump, hw_mode): """Guess model_id from extracted filenames from NEF. NOTE: if the nef is from regression, it will have dfault model_id 32768. Args: p_dump (pathlib / str): where the nef was extracted to. hw_mode (int): specify the platform. Returns: tuple: list of model_id available in givem dump folder. """ if hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: # 540/730 s1 = f"models_{hw_mode}_model_*.kne" s2 = rf"models_{hw_mode}_model_(\d+).kne" else: s1 = "NEF_*modelid_*" s2 = r'NEF_.*?_modelid_(\d+)_.*$' p_nefs = pathlib.Path(p_dump).glob(s1) p_names = [p.name for p in p_nefs] modelids = [] for name in p_names: modelids.extend(re.findall(s2, name)) ids = tuple(set([int(a) for a in modelids])) return ids def verify_ioinfo(ioinfo, nef_version): """Verify ioinfo got enought quantization info.""" missing = False for k1 in ["input", "output"]: if DEBUG: print(f"ioinfo got {len(ioinfo[k1])} of {k1}.") for i_info, info in enumerate(ioinfo[k1]): for k2 in ["name", "shape", "onnx_shape", "ch_dim", "radix", "scale", "bitw", "data_format"]: if k2 not in info: print(f"Error: {k1}/{i_info} is missing {k2}") missing = True assert not missing def convert_ioinfo(p_sub, hw_mode): """Load ioinfo from io_raw, then save to ioinfo.json . This is a wrapper function to call correct parser according to hw_mode. """ if hw_mode in fconsts.MODE_HW_LIMIT["nef_v0"]: # 520, or 720 pure bin (obsolete) # BUG: only per-layer quantization info # BUG: only sim shape. (no onnx shape. no dimension transpose in sim shape though.) fn_json_raw = list(p_sub.glob("*_setup.bin.json"))[0] ioinfo = parse_setup_json_v0(fn_json_raw) nef_version = 0 elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v1"]: fn_json_raw = list(p_sub.glob("*_setup.bin.json"))[0] ioinfo = parse_setup_json_v1(fn_json_raw) nef_version = 1 elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: # 540/730 fn_json_raw = list(p_sub.glob("*.kne.no_binary.json"))[0] ioinfo = parse_setup_json_v2(fn_json_raw) nef_version = 2 verify_ioinfo(ioinfo, nef_version) fn_ioinfo = p_sub / "ioinfo.json" with open(fn_ioinfo, "w") as f: json.dump(ioinfo, f, cls=NumpyEncoder) return ioinfo def unpack_nefs(p_nef, hw_mode): """Parse nef to get compiler outputs for csim inference. Ref: `ticket #17762`_ Args: p_nef (pathlib or str): path to the nef file, which may include multiple models. hw_mode (int): specify the platform (520/530/540/630/720/730/etc), because the way to call nef_utils are different. Returns: dict-type: example: `{model_id: (p_sub, ioinfo)}`. - The `model_id` is unique for each released model. - `p_sub` is where the model for `model_id` is unpacked, - the `ioinfo` includes the shape and quantization info of input/output nodes. It will be used to convert input data to bin file as csim/dongle input. .. _ticket #17762: https://redmine.kneron.tw/issues/17762 """ p_out = pathlib.Path(tempfile.mkdtemp(prefix="nef_unpack_")) if hw_mode in fconsts.MODE_HW_LIMIT["nef_v0"]: # 520, or 720 pure bin (obsolete) nef_version = 0 cmd = f"{ADD_NEF_UTIL_PATH}; {bin_nef_util} -X {pathlib.Path(p_nef).absolute()} --keep_all -s -p {hw_mode} -O {p_out}" elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v1"]: # 720/530/630 flatbuffer nef_version = 1 cmd = f"{ADD_NEF_UTIL_PATH}; {bin_nef_util} -X {pathlib.Path(p_nef).absolute()} --keep_all -s -O {p_out}" elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: # 540/730 # 1 nef -> 1 kne (incl multiple models) nef_version = 2 cmd = f"""set -e; {ADD_NEF_UTIL_PATH}; {bin_nef_util} -X {pathlib.Path(p_nef).absolute()} --keep_all -O {p_out} && pushd {p_out} >> /dev/null && {bin_kne_util} -X NEF_0x*_models_{hw_mode}.kne && for k in `ls models_{hw_mode}_model_*.kne` do {bin_kne_util} -j ${{k}} done """ else: raise NotImplementedError # extract nef file cp = futils.run_bash_script(cmd) if DEBUG: print(f"unpack nef (version {nef_version}) to {p_out}") print(cp.stderr) assert cp.returncode == 0, f"extract nef failed with return code: {cp.returncode}." # put each model into submodel # for 520/720/530/630 model_ids = guess_available_model_id(p_out, hw_mode) fn_maps = {} for mid in model_ids: p_sub = p_out / f"model_{mid}" p_sub.mkdir(parents=True, exist_ok=True) if hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: # 540/730 cmd = f"mv {p_out}/models_{hw_mode}_model_{mid}.kne* {p_sub}" else: cmd = f"mv {p_out}/NEF_*_modelid_{mid}_* {p_sub}" cp = futils.run_bash_script(cmd) assert cp.returncode == 0, f"Failed to move model_{mid} bin files. Return code: {cp.returncode}" p_sub = p_out / f"model_{mid}" ioinfo = convert_ioinfo(p_sub, hw_mode) # fn_map = locate_compiler_dump(p_sub, hw_mode, parse_nef=True) fn_maps[mid] = (p_sub, ioinfo) return fn_maps, p_out class NumpyEncoder(json.JSONEncoder): """To save numpy array in json. From `numpy array is not json serializable`_ . .. _numpy array is not json serializable: https://stackoverflow.com/questions/26646362/numpy-array-is-not-json-serializable """ def default(self, obj): """Set default way.""" if isinstance(obj, np.ndarray): return obj.tolist() return json.JSONEncoder.default(self, obj) def parse_setup_json_v0(fn_json): """Parse raw json generated from 520 setup.bin. Necessary info per io node (same for all platform), see `verify_ioinfo()`. NOTE: - we assume only 1 input for 520 models. Related to flow_utils/get_ioinfo_from_knerex_json """ with open(fn_json, "r") as f: raw = json.load(f) ioinfo = {} def get_in(h): v1 = {} # NOTE: for 520, the given dimension is always 1CHW # There will be no onnx shape in setup.bin. # example, [1, 10] will be [1, 10, 1, 1] v1["name"] = "0" v1["shape"] = [1, h["input_channel"], h["input_row"], h["input_col"]] v1["onnx_shape"] = [1, h["input_channel"], h["input_row"], h["input_col"]] v1["bitw"] = 8 # only support 8bit # 520 only support per layer v1["radix"] = [h["input_radix"] for i in range(h["input_channel"])] v1["scale"] = [1.0 for i in range(h["input_channel"])] v1["ch_dim"] = 1 v1["data_format"] = "RGBA_8BIT" # just guess. to keep same format return v1 def get_out(i, h): d = {} # no name saved in 520 setup.bin / nef. so we use index only d["name"] = str(i) d["shape"] = [1, h["ch_length"], h["row_length"], h["col_length"]] d["onnx_shape"] = [1, h["ch_length"], h["row_length"], h["col_length"]] d["bitw"] = 8 # only support 8bit # NOTE: 520 radix/scale are same for all channels d["radix"] = [h["output_radix"] for i in range(h["ch_length"])] per_channel_scales = futils.intle2flt(h["output_scale"]) d["scale"] = [per_channel_scales for i in range(h["ch_length"])] d["ch_dim"] = 1 d["data_format"], _ = parse_data_format(520, h["data_format"]) return d # input. assume only one. # sometime the json have headers or header if "headers" in raw: ioinfo["input"] = [get_in(a) for a in raw["headers"]] else: assert "header" in raw, "Extracted 520 setup.bin.json have no header nor headers." ioinfo["input"] = [get_in(raw["header"])] # output. maybe multiple. ioinfo["output"] = [get_out(i, d) for i, d in enumerate(raw["outputs"])] return ioinfo def parse_data_format(hw_mode, fmt): """Convert fmt number to real format. The raw ioinfo from compiler use int to represent hardware data format. The data-converter require the input of format in "string". This function will take definition from compiler and hard-code here. Update if compiler changed. Ref: `ticket #17762`_ """ if hw_mode == 520: """refer to compiler/lib/target/mozart/basic/hw_define.h not using this info now. """ d = { -1: ("UNKNOWN", 8), 8: ("16W1C8B", 8), 0: ("8W1C16B", 16), 9: ("BY_COL_8BIT", 8), 1: ("BY_COL_16BIT", 16), 10: ("BY_CHNL_8BIT", 8), 2: ("BY_CHNL_16BIT", 16), 15: ("CUSTOMIZE", 8), 16: ("RGBA_8BIT", 8), 17: ("RGBA_16BIT", 16), 18: ("SEQ_32BIT", 32), 100: ("RAW8", 8), 101: ("RAW16", 16), 102: ("RAW_FLOAT", 32), } return d[int(fmt)] elif hw_mode == 720: """refer to compiler/lib/target/beethoven/basic/hw_define.h""" ref = { -1: ("UNKNOWN", 8), 0: ("1W16C8B", 8), 1: ("1W16C8B_INTLV", 8), 2: ("1W16C8BHL", 16), 3: ("1W16C8BHL_INTLV", 16), 4: ("4W4C8B", 8), 5: ("16W1C8B", 8), 6: ("8W1C16B", 16), 7: ("PS_8W1C16B", 16), 8: ("PS_1W8C16B", 16), 9: ("PS_1W4C32B", 32), 11: ("PS_2W4C16B", 16), 12: ("PS_4W1C32B", 32), 13: ("PS_1W16C16B", 16), 14: ("PS_1W8C32B", 32), 15: ("PS_1W16C32B", 32), 16: ("PS_4W2C16B", 16), 17: ("PS_2W4C32B", 32), 18: ("PS_2W2C32B", 32), 100: ("RAW8", 8), 101: ("RAW16", 16), 102: ("RAW_FLOAT", 32), } return ref[int(fmt)] elif hw_mode in [530, 730, 540, 630]: """ 6730/540/630 refer to compiler/lib/target/wagner/basic/hw_define.h 530 see refer to compiler/lib/target/bach/basic/hw_define.h but seems same for now """ ref = { -1: ("UNKNOWN", 8), 0: ("1W16C8B", 8), 1: ("1W16C8BHL", 15), 2: ("4W4C8B", 8), 3: ("4W4C8BHL", 15), 4: ("16W1C8B", 8), 5: ("16W1C8BHL", 15), 6: ("8W1C16B", 16), 7: ("PS_1W16C24B", 24), 100: ("RAW8", 8), 102: ("RAW16", 16), 103: ("RAW_FLOAT", 32), } return ref[int(fmt)] def parse_setup_json_v1(fn_json): """Parse raw json generated from setup.bin (v2 flatbuffer, 530/630/720). Necessary info per io node (same for all platform), please refer to `parse_setup_json_v0()`. Related to flow_utils/get_ioinfo_from_knerex_json """ with open(fn_json, "r") as f: raw = json.load(f) ioinfo = {} def get_platform(j): return int(j["header"]["target"].strip("KL")) platform = get_platform(raw) def get_in(h): v1 = {} v1["name"] = h["name"] # from Jay # setup.bin 的 Tensor 定義： # raw_shape 是 onnx shape # shape 是 hw shape # ioinfo.json 的定義： # onnx_shape 是 onnx_shape # shape 是 hw shape v1["shape"] = np.array(h["shape"]) v1["onnx_shape"] = np.array(h["raw_shape"]) # TODO: is this true? always second? v1["ch_dim"] = 1 v1["data_format"], v1["bitw"] = parse_data_format(platform, h["format"]) # for per channel radix/scale n_ch = v1["onnx_shape"][v1["ch_dim"]] for k in ["radix", "scale"]: t = [a[k] for a in h["quantization"]["fxp_info"]] if len(t) == n_ch: # per channel given v1[k] = np.array(t) else: # per layer given. need expand assert ( len(t) == 1 ), f"channel {n_ch} but got {k} for {len(t)} channels: {t}" v1[k] = np.array([t[0] for i in range(n_ch)]) return v1 # input. maybe multiple ioinfo["input"] = [get_in(d) for d in raw["inputs"]] # output. maybe multiple. ioinfo["output"] = [get_in(d) for d in raw["outputs"]] return ioinfo def parse_setup_json_v2(fn_json): """Parse raw json generated from kne (540/730). Necessary info per io node (same for all platform), please refer to `parse_setup_json_v0()`. Ref: `ticket #17762`_ Related to flow_utils/get_ioinfo_from_knerex_json """ with open(fn_json, "r") as f: raw = json.load(f) ioinfo = {} def get_platform(j): return int(j["header"]["target"].strip("KL")) platform = get_platform(raw) def parse_ch_dim(lst): """Input lst should be a list of 4 elements: [b, c, h, w].""" if lst[0] == -1: # when list is [-1. -1, -1, -1] return 1 else: # there should be no -1 in the list assert lst[1] != -1 return lst[1] def get_in(h): v1 = {} v1["name"] = h["name"] v1["ndim"] = h["ndim"] v1["shape"] = np.array(h["shape"]) # need to combine shape and inv_shape_intrp_dim to get real onnx_shape. # see #18456 v1["onnx_shape"] = np.array([v1["shape"][a] for a in h["inv_shape_intrp_dim"]]) v1["ch_dim"] = parse_ch_dim(h["shape_intrp_dim"]) v1["data_format"], v1["bitw"] = parse_data_format(platform, h["format"]) # for per channel radix n_ch = v1["shape"][1] k = "radix" t = h["quantization"][k] if len(t) == n_ch: # per channel given v1[k] = np.array(t) else: # per layer given. need expand assert len(t) == 1, f"channel {n_ch} but got {k} for {len(t)} channels: {t}" v1[k] = np.array([t[0] for i in range(n_ch)]) # scale k = "scale" scale_le = h["quantization"]["scale"] scale_le_n = h["quantization"]["scale_count"] t = futils.array_le2flt(scale_le, scale_le_n) if len(t) == n_ch: # per channel given v1[k] = np.array(t) else: # per layer given. need expand assert len(t) == 1, f"channel {n_ch} but got {k} for {len(t)} channels: {t}" v1[k] = np.array([t[0] for i in range(n_ch)]) return v1 ioinfo["input"] = [get_in(d) for d in raw["models"][0]["header"]["inputs"]] ioinfo["output"] = [get_in(d) for d in raw["models"][0]["header"]["outputs"]] return ioinfo @lru_cache(maxsize=128) def locate_compiler_dump(p_out, hw_mode, parse_nef=False): """Locate important files in compiler dump folder. Each platform has it's own required files to run csim. Some names may change, e.g., test.conf/apb.npu, but they serve same purpose. This function is to find correponding file and return organized as dict, so that each call will always get correct file independant of hw_mode. """ p_out = pathlib.Path(p_out) if hw_mode in [520]: patterns = { "setup_bin": "*setup.bin", "command_bin": "*command.bin", "weight_bin": "*weight.bin", "apb_npu": "*test.conf", # diff } if parse_nef: # HACK # unpack_nefs will genearte ioinfo.json for 520 patterns["ioinfo_json"] = "*ioinfo.json" # diff elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v1"]: patterns = { "setup_bin": "*setup.bin", "command_bin": "*command.bin", "weight_bin": "*weight.bin", "ioinfo_json": "*ioinfo.json", "apb_npu": "*apb.npu", } if hw_mode in [720]: # diff for 520/720 patterns["apb_npu"] = "*test.conf" elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: patterns = { "kne": f"*models_{hw_mode}*.kne", "ioinfo_json": "*ioinfo.json", } else: raise NotImplementedError fn_map = {} for k, v in patterns.items(): ps = list(p_out.glob(v)) assert len(ps) >= 1, f"Looking for {k}, expect 1, but found {len(ps)}: {ps}" fn_map[k] = ps[0] return fn_map def load_ioinfo_json(fn_ioinfo): """Load compiler generated ioinfo.json then apply special process. Convert `shape`/`onnx_shape`/`radix`/`scale` to numpy array for better process later. NOTE: No ioinfo.json for 520. """ with open(fn_ioinfo, "r") as f: ioinfo = json.load(f) for io in ["input", "output"]: for a in ioinfo[io]: a["name"] = futils.clean_name(a["name"]) for k in ["onnx_shape", "scale", "radix", "shape"]: a[k] = np.array(a[k]) return ioinfo def collect_fps_improve(dir_out): """Load the fps improved from ip_evaluator reports. The reults will be compiled with other analysis and put in the final report. Args: `dir_out`: the output folder of compiler. """ p_f = pathlib.Path(dir_out) / "summary_image_cut_search.txt" if not p_f.exists(): return None with open(p_f, "r") as f: lines = f.readlines() for line in lines: if line.startswith("fps improve: "): return line.strip().replace("fps improve: ", "") return None def get_cpu_node_op_type(dir_out): cpu_node_list_str = set() setup_dir = "{}/{}".format(dir_out, "setup.txt") def extract_cpu_op_type(txt): s = re.compile('"(op_type|opcode_index)": *"(.*?)"') return s.findall(txt)[0][1] try: with open(setup_dir, "r") as f: lines = f.readlines() for line in lines: # new setup.txt(opcode_index) # old setup.txt(op_type) if "op_type" in line or "opcode_index" in line: cpu_node_str = extract_cpu_op_type(str(line)) if cpu_node_str == "CpuFusion": continue cpu_node_list_str.add(cpu_node_str) if len(cpu_node_list_str) == 0: return "None" else: return ",".join(cpu_node_list_str) except: # print("No setup.txt found.") return "N/A" def collect_command_weight_size(dir_out): cmd_size = None weight_size = None stats_dir = "{}/{}".format(dir_out, "dbg.stat.json") try: with open(stats_dir, "r") as f: stats = json.load(f) cmd_size = int(stats["general"]["cmd_size"] / (10**3)) weight_size = int(stats["general"]["wt_size"] / (10**6)) except: pass return cmd_size, weight_size def find_cpu_nodes(lines): nodes = [] found = False for line in lines: if line.startswith("***** Warning: CPU ops types"): found = True continue if found: clean = line.strip().strip(",") if len(clean) > 4: nodes.append(clean) else: found = False if len(nodes) > 0: return "//".join(nodes) else: return "N/A" def collect_FPS(dir_out, hw_mode): """Collect FPS info from compiler output folder. WARNING: - Tiefang will make report same for ALL platforms. - will all be named as `ProfileResult.txt` """ profile_dir = f"{dir_out}/ProfileResult.txt" d_profile = OrderedDict() def search_by_prefix(lines, k): for line in lines: if line.startswith(k): return line.lstrip(k).strip() return None def gb2mb(line): return float(line.strip("GB"))*1000 def convert2int(s): if s == "inf" or s is None: return None return int(float(s)) try: with open(profile_dir, "r") as f: lines = f.readlines() # load fps if hw_mode == 520: d_profile["fps"] = search_by_prefix(lines, "output_fps =") d_profile["ITC(ms)"] = search_by_prefix(lines, "output_total_time =") d_profile["RDMA bandwidth GB/s"] = search_by_prefix(lines, "RDMA_bandwidth_GBPs =") d_profile["WDMA bandwidth GB/s"] = search_by_prefix(lines, "WDMA_bandwidth_GBPs =") d_profile["GETW bandwidth GB/s"] = search_by_prefix(lines, "GETW_bandwidth_GBPs =") d_profile["cpu_node"] = find_cpu_nodes(lines) # d_profile[f"RV(mb)"] = search_by_prefix(lines, "output_total_data_move_in_amount =") # d_profile[f"WV(mb)"] = search_by_prefix(lines, "output_total_data_move_out_amount =") else: d_profile["fps"] = search_by_prefix(lines, "output_fps =") d_profile["ITC(ms)"] = search_by_prefix(lines, "output_total_time =") d_profile["C(GOPs)"] = search_by_prefix(lines, "output_total_theory_mac =") d_profile["RDMA bandwidth GB/s"] = search_by_prefix(lines, "RDMA_bandwidth_GBPs =") d_profile["WDMA bandwidth GB/s"] = search_by_prefix(lines, "WDMA_bandwidth_GBPs =") d_profile["GETW bandwidth GB/s"] = search_by_prefix(lines, "GETW_bandwidth_GBPs =") d_profile["RV(mb)"] = gb2mb(search_by_prefix(lines, "output_total_RDMA_amount =")) d_profile["WV(mb)"] = gb2mb(search_by_prefix(lines, "output_total_WDMA_amount =")) d_profile["cpu_node"] = find_cpu_nodes(lines) except: # print("No {} found.".format(profile_dir)) pass # filter None items d_prof = OrderedDict() for k, v in d_profile.items(): if v: # not None d_prof[k] = v return d_prof