{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import glob, os, gc\nimport pandas as pd\nimport numpy as np\nimport argparse\n# import matplotlib.pyplot as plt\nimport tensorflow as tf\n# train_dir1 = \"/AxBio_share2/users/wangqiyang/competition/train/tdcsfog\"\nfrom scipy.interpolate import CubicSpline, interp1d\nfrom tensorflow import keras\n# from memory_profiler import memory_usage\n\ntrain_dir1 = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/tdcsfog'\ntrain_dir1_dc = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/defog'\ntest_dir1 = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/test'\nmodel_path = '/kaggle/input/pretrained-model/model_best'\n# train_dir1 = '/AxBio_share2/users/wangqiyang/competition/train/tdcsfog/'\n# train_dir1_dc = '/AxBio_share2/users/wangqiyang/competition/train/defog'\n# model_path = '/AxBio_share2/users/wangqiyang/compet_model/saved_data/model_best'\n# test_dir1 = '/AxBio_share2/users/wangqiyang/competition/test'\n# train_dir1 = 'C:\\work\\CCS\\compet_gait\\dataset/train/tdcsfog'\n# train_dir1_dc = 'C:\\work\\CCS\\compet_gait\\dataset/train/defog'\n# test_dir1 = 'C:\\work\\CCS\\compet_gait\\dataset/test'\n# model_path = 'C:/work/CCS/compet_gait/saved_data/model_best'\ntcf_fq = 128\ndc_fq = 100\ntcf_period = 1 / 128\ndc_period = 1 / 100\n\ndef sliding_roll( sensor, result, window, future ):\n    input = []\n    for index in range(window):\n        if index < window - 1:\n            input.append(sensor[index:-(window - index - 1)])\n        else:\n            input.append(sensor[index:])\n    input = np.stack(input, axis=0)\n    input = np.transpose(input, (1, 0, 2))\n    if future > 0:\n        past = window - future\n        label = result[past - 1: -future]\n    else:\n        label = result[window - 1:]\n    return input, label\n\ndef gen_1( file_path, window,future, key ):\n    file_path_ = file_path.decode()\n    key_r = key.decode()\n    # print(file_path_)\n    df = pd.read_csv(file_path_, usecols=['AccV', 'AccML', 'AccAP', key_r],\n                     dtype={'AccV': np.float16,\n                            'AccML': np.float16,\n                            'AccAP': np.float16,\n                            key_r: np.int8})\n    return (df[['AccV', 'AccML', 'AccAP']].to_numpy(), df[key_r].to_numpy()[window - 1:])\n\n\ndef gen_dc( file_path, window,future, key ):\n    # print(file_path)\n    # file_path = bytes.decode(file_path)\n    # file_path_r = file_path.numpy()\n    # print(file_path_r)\n    file_path_ = file_path.decode()\n    key_r = key.decode()\n    # print(file_path_)\n    df = pd.read_csv( file_path_ )\n    sensor = df[['AccV', 'AccML', 'AccAP']]\n    result = df[key_r].to_numpy()\n    sensor = sensor.to_numpy()\n    input, label = sliding_roll(sensor, result, window, future)\n    if future > 0:\n        past = window - future\n        filter_data = df.iloc[past - 1: -future]\n    else:\n        filter_data = df.iloc[window - 1:]\n    filter_valid = filter_data['Valid']==1\n    filter_valid = filter_valid.to_numpy()\n    filter_task = filter_data['Task'] == 1\n    filter_task = filter_task.to_numpy()\n    filter = np.logical_and(filter_task,filter_valid)\n    input = input[filter]\n    label = label[filter]\n\n    return (tf.constant(input,dtype=tf.float32),tf.constant(label, dtype=tf.int32))\n\ndef gen_ori(file_list, window, future, key):\n    # file_path_ = file_path.decode()\n    # key_r = key.decode()\n    # print(\"wqy :  \", sensor)\n    # print(\"wqy :  \", result)\n    # df = pd.read_csv(file_path_)\n    # sensor = df[['AccV', 'AccML', 'AccAP']]\n    # sensor = df['StartHesitation','Turn','Walking' ]\n    # result = result.to_numpy().astype(dtype=np.int8)\n    # sensor = sensor.to_numpy().astype(dtype=np.float16)\n    # cur_numble = len(df) - window + 1\n    # for i in range(cur_numble):\n    #     input_ = sensor[i:(i+window)]\n    #     label = result[window+i-1-future]\n    #     yield (tf.constant(input_, dtype=tf.float16), tf.constant(label, dtype=tf.int8))\n    for file in file_list:\n        df = pd.read_csv(file)\n        sensor = df[['AccV', 'AccML', 'AccAP']]\n        result = df[key]\n        result = result.to_numpy().astype(dtype=np.int8)\n        sensor = sensor.to_numpy().astype(dtype=np.float16)\n        total_len = len(df)\n        cur_index = 0\n        end_index = total_len - window + 1\n        for index in range(end_index):\n            input_ = sensor[index:index + window]\n            label = result[index + window - 1 -future]\n            yield input_,label\n            # yield (tf.constant(input_, dtype=tf.float16), tf.constant(label, dtype=tf.int8))\n        del sensor\n        del result\n        gc.collect()\n\ndef split_file( file_path, window, future, key ):\n    file_path_ = file_path.decode()\n    key_r = key.decode()\n    split_frcac = 10\n    df = pd.read_csv(file_path_)\n    sensor = df[['AccV', 'AccML', 'AccAP']]\n    # sensor = df['StartHesitation','Turn','Walking' ]\n    result = df[key_r].to_numpy().astype(dtype=np.int8)\n    sensor = sensor.to_numpy().astype(dtype=np.float16)\n    cur_len = len(df)\n    inter_val = split_frcac - 1\n    each_len = int((cur_len - inter_val*window)/window) + window\n    start_index = 0\n    split_data = []\n    split_label = []\n    while start_index < cur_len:\n        if start_index + each_len < cur_len:\n            end_index = start_index + each_len\n            split_data.append( sensor[start_index:end_index] )\n            split_label.append( result[start_index:end_index] )\n            start_index = end_index - window + 1\n        else:\n            break\n    split_data = np.stack(split_data, axis=0)\n    split_label = np.stack(split_label, axis=0)\n    del df\n    del sensor\n    del result\n    gc.collect()\n    return (tf.constant(split_data, dtype=tf.float16), tf.constant(split_label, dtype=tf.int8))\n\ndef get_True_data(file_path_, output_folder):\n    df = pd.read_csv(file_path_)\n    base_name = os.path.basename(file_path_)\n    global tcf_fq, dc_fq, tcf_period, dc_period\n    len_data = len(df)\n    x_p = dc_period * np.arange(len_data)\n    AccV_ip = CubicSpline(x=x_p, y=df['AccV'].to_numpy())\n    AccML_ip = CubicSpline(x=x_p, y=df['AccML'].to_numpy())\n    AccAP_ip = CubicSpline(x=x_p, y=df['AccAP'].to_numpy())\n    Valid_ip = interp1d(x=x_p, y=df['Valid'].to_numpy(), kind='nearest')\n    Task_ip = interp1d(x=x_p, y=df['Task'].to_numpy(), kind='nearest')\n    StartHesitation_ip = interp1d(x=x_p, y=df['StartHesitation'].to_numpy(), kind='nearest')\n    Turn_ip = interp1d(x=x_p, y=df['Turn'].to_numpy(), kind='nearest')\n    Walking_ip = interp1d(x=x_p, y=df['Walking'].to_numpy(), kind='nearest')\n    out_len = int(len_data * tcf_fq / dc_fq)\n    out_x = tcf_period * np.arange(out_len)\n    span_ = out_x[-1] - x_p[-1]\n    #     print(\"is that accurate?: \", out_x[-1], x_p[-1], span_ )\n    if span_ > 0:\n        out_x = out_x[:-1]\n    AccV = AccV_ip(out_x)\n    AccML = AccML_ip(out_x)\n    AccAP = AccAP_ip(out_x)\n    Valid = np.array(Valid_ip(out_x), dtype=int)\n    Task = np.array(Task_ip(out_x), dtype=int)\n    StartHesitation = np.array(StartHesitation_ip(out_x), dtype=int)\n    Turn = np.array(Turn_ip(out_x), dtype=int)\n    Walking = np.array(Walking_ip(out_x), dtype=int)\n    info_dic = {\"AccV\": AccV,\n                \"AccML\": AccML,\n                \"AccAP\": AccAP,\n                \"Valid\": Valid,\n                \"Task\": Task,\n                \"StartHesitation\": StartHesitation,\n                \"Turn\": Turn,\n                \"Walking\": Walking}\n    df = pd.DataFrame(info_dic)\n    gc.collect()\n    #     output_file = os.path.join( output_folder, base_name )\n    #     df.to_csv( output_file )\n    return df\n\ndef make_dataset(file_list, window, future, batch_size, repeat, key, prefech, thread_num, bcache=True):\n    # dataset = tf.data.Dataset.from_generator( lambda : gen_ori(file_list, window, future, key), \\\n    #                                           output_signature=(tf.TensorSpec(shape=(window, 3), dtype=tf.float16),\n    #                                               tf.TensorSpec(shape=(), dtype=tf.int8)))\n    dataset = tf.data.Dataset.list_files(file_list, shuffle=False)\n    # dataset = files.map(lambda x: tf.numpy_function(split_file, [x, window, future, key], [tf.float16, tf.int8]),\n    #                     num_parallel_calls=thread_num)\n    # dataset = dataset.flat_map(lambda e, l: tf.data.Dataset.zip((\n    #     tf.data.Dataset.from_tensor_slices(e),\n    #     tf.data.Dataset.from_tensor_slices(l))))\n    dataset = dataset.map(\n        lambda x: tf.numpy_function(gen_1, [x, window, future, key], [tf.float16, tf.int8]),\n        num_parallel_calls=thread_num)\n\n    # dataset = dataset.map(\n    #     lambda e, l: tf.data.Dataset.from_tensor_slices((e,l)),\n    #     num_parallel_calls=thread_num)\n    dataset = dataset.cache()\n    dataset = dataset.shuffle(batch_size)\n    dataset = dataset.batch(1)\n    # dataset = dataset.repeat(repeat)\n    dataset = dataset.prefetch(prefech)\n    return dataset\n\ndef make_dataset_dc( file_list, window,future, batch_size, repeat, key, prefech, thread_num, bcache=True ):\n    files = tf.data.Dataset.list_files(file_list)\n    # for item in files:\n    #     print(item)\n    dataset = files.map( lambda x: tf.numpy_function(gen_dc, [x,window,future,key], [tf.float32,tf.int32]),\n                         num_parallel_calls = thread_num )\n    dataset = dataset.flat_map(lambda e, l: tf.data.Dataset.zip((\n                tf.data.Dataset.from_tensor_slices(e),\n                tf.data.Dataset.from_tensor_slices(l))))\n    dataset = dataset.cache()\n    dataset = dataset.shuffle(batch_size)\n    dataset = dataset.batch(batch_size)\n    dataset = dataset.repeat(repeat)\n    dataset = dataset.prefetch(prefech)\n    return dataset\n\ndef span_between_train_valid_dc(key, train_file, valid_file):\n    hes_train_total = 0\n    train_total = 0\n    for file in train_file:\n        df = pd.read_csv(file)\n        df = df[(df['Valid'] == 1) & (df['Task'] == 1)]\n        train_total += len(df)\n        hes_len = len(df.loc[df[key] == 1])\n        hes_train_total += hes_len\n\n    train_rate_hes = hes_train_total / train_total\n    print(key,train_rate_hes)\n    if train_rate_hes < 1e-20:\n        return \"no positive in train\"\n\n    hes_train_total = 0\n    train_total = 0\n    for file_1 in valid_file:\n        df = pd.read_csv(file_1)\n        df = df[(df['Valid'] == 1) & (df['Task'] == 1)]\n        train_total += len(df)\n        hes_len = len(df.loc[df[key] == 1])\n        hes_train_total += hes_len\n\n    valid_rate_hes = hes_train_total / train_total\n    print( key, \"valid rate: \", valid_rate_hes )\n    return (train_rate_hes - valid_rate_hes) / train_rate_hes\n\ndef span_between_train_valid(key, train_file, valid_file):\n    hes_train_total = 0\n    train_total = 0\n    for file in train_file:\n        df = pd.read_csv(file)\n        train_total += df.shape[0]\n        hes_temp = df.loc[df[key] == 1]['Time']\n        hes_train_total += hes_temp.size\n\n    train_rate_hes = hes_train_total / train_total\n\n    hes_train_total = 0\n    train_total = 0\n    for file_1 in valid_file:\n        df = pd.read_csv(file_1)\n        train_total += df.shape[0]\n        hes_temp = df.loc[df[key] == 1]['Time']\n        hes_train_total += hes_temp.size\n\n    valid_rate_hes = hes_train_total / train_total\n    gc.collect()\n    return (train_rate_hes - valid_rate_hes) / train_rate_hes, train_rate_hes\n\n\ndef build_model(window, Dense_unit):\n    inputs = keras.Input(shape=(None, 3), name=\"inputs\")\n    x = keras.layers.Conv1D(filters=256, kernel_size=window)(inputs)\n    # x = keras.layers.Flatten()(x)\n    x = keras.layers.Dense(units=Dense_unit, activation=\"relu\")(x)\n    # x = keras.layers.BatchNormalization(axis=1)(x)\n    x = keras.layers.Dropout(0.3)(x)\n    x = keras.layers.Dense(units=Dense_unit, activation=\"relu\")(x)\n    # x = keras.layers.BatchNormalization(axis=1)(x)\n    x = keras.layers.Dropout(0.4)(x)\n    outputs = keras.layers.Dense(units=1, activation=\"sigmoid\")(x)\n    model_ = keras.Model(\n        inputs, outputs\n    )\n\n    return model_\n\ndef train(train_dir1, window, future, key_cur, seed, epochs, \\\n          batch_size=100000, repeat=10, prefetch=tf.data.AUTOTUNE, thread_num=tf.data.AUTOTUNE, btcf=True):\n    path_all = os.path.join(train_dir1, '*')\n    path_list = glob.glob(path_all)\n    path_list = sorted(path_list)\n    data_len = len(path_list)\n    #     print(data_len)\n\n    vali_split = 0.2\n    whole_index = np.arange(data_len)\n    np.random.seed(seed)\n    np.random.shuffle(whole_index)\n    valid_len = int(data_len * vali_split)\n    train_index = whole_index[valid_len:]\n    valid_index = whole_index[:valid_len]\n\n    bcache = True\n    train_file = [path_list[index] for index in train_index]\n    trainset = make_dataset(train_file, window, future, batch_size, repeat=repeat, key=key_cur, prefech=prefetch,\n                            thread_num=thread_num, bcache=bcache)\n\n    # print(\"is this cut?\")\n    # test_array = []\n    # for i in trainset:\n    #     test_array.append(i[0][-1,-1,-1])\n    #\n    # print(\"wqy test: \", max(test_array))\n    valid_file = [path_list[index] for index in valid_index]\n    validset = make_dataset(valid_file, window, future, batch_size, repeat=1, key=key_cur, prefech=prefetch,\n                            thread_num=thread_num, bcache=bcache)\n\n    span_train_valid, pos_rate = span_between_train_valid(key_cur, train_file, valid_file)\n    print(\"span: \", span_train_valid)\n\n    learning_rates = 0.000001\n    model_turn = build_model(window=window, Dense_unit=512)\n    print(model_turn.summary())\n\n    opt = tf.keras.optimizers.Adam(learning_rate=learning_rates)\n    model_turn.compile(\n        optimizer=opt, loss=tf.keras.losses.BinaryCrossentropy(), metrics=[\"binary_accuracy\"]\n    )\n\n    model_turn.fit(trainset, epochs=epochs, validation_data=validset)\n\n    del trainset\n    del validset\n    del path_list\n    gc.collect()\n    return model_turn, pos_rate\n    # gc.collect()\n\n\ndef get_True_data_t(file_path_):\n    df = pd.read_csv(file_path_)\n    len_ori = len(df)\n    base_name = os.path.basename(file_path_)\n    global tcf_fq, dc_fq, tcf_period, dc_period\n    len_data = len(df)\n    x_p = dc_period * np.arange(len_data)\n    AccV_ip = CubicSpline(x=x_p, y=df['AccV'].to_numpy())\n    AccML_ip = CubicSpline(x=x_p, y=df['AccML'].to_numpy())\n    AccAP_ip = CubicSpline(x=x_p, y=df['AccAP'].to_numpy())\n\n    out_len = round(len_data * tcf_fq / dc_fq)\n    out_x = tcf_period * np.arange(out_len)\n    span_ = out_x[-1] - x_p[-1]\n    #     print(\"is that accurate?: \", out_x[-1], x_p[-1], span_ )\n    AccV = AccV_ip(out_x)\n    AccML = AccML_ip(out_x)\n    AccAP = AccAP_ip(out_x)\n    info_dic = {\"AccV\": AccV,\n                \"AccML\": AccML,\n                \"AccAP\": AccAP}\n    df = pd.DataFrame(info_dic)\n    return df, len_ori\n\n\ndef to_dc(result, len_ori):\n    global tcf_fq, dc_fq, tcf_period, dc_period\n    len_data = result.size\n    x_p = tcf_period * np.arange(len_data)\n    intor = CubicSpline(x=x_p, y=result)\n\n    out_len = round(len_data * dc_fq / tcf_fq)\n    if out_len != len_ori:\n        #         print(len_ori - out_len)\n        out_len = len_ori\n    out_x = dc_period * np.arange(out_len)\n    span_ = out_x[-1] - x_p[-1]\n    #     print(\"is that accurate?: \", out_x[-1], x_p[-1], span_)\n    r_result = intor(out_x)\n\n    return r_result\n\n\ndef sliding_roll_t(sensor, window):\n    input = []\n    for index in range(window):\n        if index < window - 1:\n            input.append(sensor[index:-(window - index - 1)])\n        else:\n            input.append(sensor[index:])\n    input = np.stack(input, axis=0)\n    input = np.transpose(input, (1, 0, 2))\n    return input\n\n# @profile\ndef get_dc_result( file_path, window, model ):\n    result = np.array([])\n    df = pd.read_csv(file_path)\n    sensor = df[['AccV', 'AccML', 'AccAP']].to_numpy(dtype=np.float16)\n    total_len = len(sensor)\n    batch_s = 1000\n    cur_index = 0\n\n    while (cur_index < total_len - window + 1):\n        input_array = []\n        end_index = min([total_len - window + 1,cur_index + batch_s])\n        for i in range(cur_index, end_index, 1):\n            if i + window == total_len:\n                cur_sensor = sensor[i:]\n            else:\n                cur_sensor = sensor[i:i+window]\n            input_array.append(cur_sensor)\n        input_array = np.stack(input_array,axis=0)\n        cur_result = model.predict(input_array, verbose = 1)\n        result = np.concatenate( [result,cur_result.flatten()] )\n        cur_index += batch_s\n        gc.collect()\n        # gc.co\n    return result\n\ndef gen_dc_t( file_path, window ):\n    # print(file_path)\n    # file_path = bytes.decode(file_path)\n    # file_path_r = file_path.numpy()\n    # print(file_path_r)\n    # print(file_path_)\n    df = pd.read_csv( file_path )\n    sensor = df[['AccV', 'AccML', 'AccAP']].to_numpy(dtype=np.float16)\n    # result = df[key_r].to_numpy(dtype=np.float16)\n    input = sliding_roll_t(sensor, window)\n    # filter_data = df.iloc[window - 1:]\n    # filter_valid = filter_data['Valid']==1\n    # filter_valid = filter_valid.to_numpy()\n    # filter_task = filter_data['Task'] == 1\n    # filter_task = filter_task.to_numpy()\n    # filter = np.logical_and(filter_task,filter_valid)\n    # input = input[filter]\n\n    return input\n\ndef gen_1_t(file_path):\n    df = pd.read_csv(file_path, usecols=['AccV', 'AccML', 'AccAP'],\n                     dtype={'AccV': np.float16,\n                            'AccML': np.float16,\n                            'AccAP': np.float16})\n    return np.expand_dims(df[['AccV', 'AccML', 'AccAP']].to_numpy(),axis=0)\n\n\ndef get_result(data, model_index):\n    #     model_file = os.path.join(model_path, key_cur, str(model_index))\n    #     model_hes = tf.keras.models.load_model(model_file, custom_objects=None, compile=False, options=None)\n    #     opt = tf.keras.optimizers.Adam(learning_rate=0.000001)\n    #     model_hes.compile(optimizer=opt, loss=\"binary_crossentropy\", metrics=[\"binary_accuracy\"])\n    results = model_index.predict(data)\n    return results\n\ndef get_posi_rate( path_list, key ):\n    hes_train_total = 0\n    train_total = 0\n    for file in path_list:\n        df = pd.read_csv(file)\n        train_total += df.shape[0]\n        hes_temp = df.loc[df[key] == 1]['Time']\n        hes_train_total += hes_temp.size\n\n    train_rate_hes = hes_train_total / train_total\n    return train_rate_hes\n\ndef evaluate_data( path_list, seed, window, key, model):\n    model.compile( loss=tf.keras.losses.BinaryCrossentropy(), metrics=[\"binary_accuracy\"]\n    )\n    data_len = len(path_list)\n    vali_split = 0.2\n    valid_len = int(data_len * vali_split)\n    batch_size = 1\n    prefetch = tf.data.AUTOTUNE\n    thread_num = tf.data.AUTOTUNE\n\n    whole_index = np.arange(data_len)\n    np.random.seed(seed)\n    np.random.shuffle(whole_index)\n    train_index = whole_index[valid_len:]\n    valid_index = whole_index[:valid_len]\n    valid_file = [path_list[index] for index in valid_index]\n    train_file = [path_list[index] for index in train_index]\n    print(\"span: \", span_between_train_valid(key, train_file, valid_file))\n    future = 0\n    validset = make_dataset(valid_file, window, future, batch_size, repeat=1, key=key, prefech=prefetch,\n                            thread_num=thread_num, bcache=True)\n    score = model.evaluate(validset, verbose=2)\n\n    print(key, ' Test loss:', score[0], 'Test accuracy:',score[1])\n\ndef evaluate_data_dc( path_list, seed, window, key, model):\n    model.compile( loss=tf.keras.losses.BinaryCrossentropy(), metrics=[\"binary_accuracy\"]\n    )\n    data_len = len(path_list)\n    vali_split = 0.2\n    valid_len = int(data_len * vali_split)\n    print(key, \"valid len: \", valid_len, \"data_len: \", data_len)\n    batch_size = 10000\n    prefetch = tf.data.AUTOTUNE\n    thread_num = tf.data.AUTOTUNE\n\n    whole_index = np.arange(data_len)\n    np.random.seed(seed)\n    np.random.shuffle(whole_index)\n    valid_index = whole_index[:valid_len]\n    valid_file = [path_list[index] for index in valid_index]\n    train_index = whole_index[valid_len:]\n    train_file = [path_list[index] for index in train_index]\n    print(\"span: \", span_between_train_valid_dc(key, train_file, valid_file))\n    future = 0\n    validset = make_dataset_dc(valid_file, window, future, batch_size, repeat=1, key=key, prefech=prefetch,\n                            thread_num=thread_num, bcache=True)\n    score = model.evaluate(validset, verbose=2)\n\n    print(key, ' Test loss:', score[0], 'Test accuracy:',score[1])\n\n# @profile\ndef main():\n    path_all = os.path.join(train_dir1, '*')\n    path_list = glob.glob(path_all)\n    path_list = sorted(path_list)\n    path_all_dc = os.path.join(train_dir1_dc, '*')\n    path_list_dc = glob.glob(path_all_dc)\n    path_list_dc = sorted(path_list_dc)\n\n    # rate_hes = get_posi_rate(path_list, 'StartHesitation')\n    # rate_turn = get_posi_rate(path_list, 'Turn')\n    # rate_walk = get_posi_rate(path_list, 'Walking')\n    model_hes_path = os.path.join(model_path,\"hes\")\n    model_hes = tf.keras.models.load_model(model_hes_path, custom_objects=None, compile=False, options=None)\n    model_turn_path = os.path.join(model_path,\"Turn\")\n    model_turn = tf.keras.models.load_model(model_turn_path, custom_objects=None, compile=False, options=None)\n    modle_walk_path = os.path.join(model_path,\"walk\")\n    modle_walk = tf.keras.models.load_model(modle_walk_path, custom_objects=None, compile=False, options=None)\n    model_hes_dc_path = os.path.join(model_path,\"hes_dc\")\n    model_hes_dc = tf.keras.models.load_model(model_hes_dc_path, custom_objects=None, compile=False, options=None)\n    model_turn_dc_path = os.path.join(model_path,\"Turn_dc\")\n    model_turn_dc = tf.keras.models.load_model(model_turn_dc_path, custom_objects=None, compile=False, options=None)\n    modle_walk_dc_path = os.path.join(model_path,\"walk_dc\")\n    modle_walk_dc = tf.keras.models.load_model(modle_walk_dc_path, custom_objects=None, compile=False, options=None)\n\n#     evaluate_data(path_list,259,131,'StartHesitation', model_hes)\n#     evaluate_data(path_list,14,500,'Turn', model_turn)\n#     evaluate_data(path_list,168,608,'Walking', modle_walk)\n#     evaluate_data_dc(path_list_dc,56,131,'StartHesitation', model_hes_dc)\n#     evaluate_data_dc(path_list_dc,399,500,'Turn', model_turn_dc)\n#     evaluate_data_dc(path_list_dc,14,608,'Walking', modle_walk_dc)\n    # tcf_id = \"003f117e14\"\n    # tcf_name = tcf_id + '.csv'\n    tcffolder = os.path.join(test_dir1, 'tdcsfog', \"*.csv\")\n    tcf_test_list = sorted(glob.glob(tcffolder))\n    # dc_id = \"02ab235146\"\n    # dc_name = dc_id + '.csv'\n    dcfolder = os.path.join(test_dir1, 'defog', \"*.csv\")\n    dc_test_list = sorted(glob.glob(dcfolder))\n\n    pd_list = list()\n    for test_file in tcf_test_list:\n        in_id = os.path.basename(test_file)\n        in_id = in_id.split('.csv')[0]\n        key_cur = 'StartHesitation'\n        window = 131\n        data_hes = gen_1_t(test_file)\n        hes_result_tcf = get_result(data_hes, model_hes)\n        hes_result_tcf = hes_result_tcf.flatten()\n        spl = np.ones((window - 1))*0\n        hes_result_tcf = np.concatenate([spl, hes_result_tcf], axis=0)\n\n        key_cur = 'Turn'\n        window = 500\n        data_turn = gen_1_t(test_file)\n        turn_result_tcf = get_result(data_turn, model_turn)\n        turn_result_tcf = turn_result_tcf.flatten()\n        spl = np.ones((window - 1))*0\n        turn_result_tcf = np.concatenate([spl, turn_result_tcf], axis=0)\n\n        key_cur = 'Walking'\n        window = 608\n        data_walk = gen_1_t(test_file)\n        walk_result_tcf = get_result(data_walk, modle_walk)\n        walk_result_tcf = walk_result_tcf.flatten()\n        spl = np.ones((window - 1))*0\n        walk_result_tcf = np.concatenate([spl, walk_result_tcf], axis=0)\n\n        len_tcf = walk_result_tcf.shape[0]\n        index_test = [in_id + '_' + str(i) for i in range(len_tcf)]\n        dic_result = {'Id': index_test,\n                      'StartHesitation': hes_result_tcf,\n                      'Turn': turn_result_tcf,\n                      'Walking': walk_result_tcf}\n        df_result = pd.DataFrame(dic_result)\n        pd_list.append(df_result)\n\n    for test_file in dc_test_list:\n        in_id = os.path.basename(test_file)\n        in_id = in_id.split('.csv')[0]\n        key_cur = 'StartHesitation'\n        window = 131\n        # data_hes = gen_dc_t(test_file,window)\n        hes_result_tcf = get_dc_result(test_file, window, model_hes_dc)\n        hes_result_tcf = hes_result_tcf.flatten()\n        spl = np.ones((window - 1))*0\n        hes_result_tcf = np.concatenate([spl, hes_result_tcf], axis=0)\n\n        key_cur = 'Turn'\n        window = 500\n        # data_turn = gen_dc_t(test_file,window)\n        turn_result_tcf = get_dc_result(test_file, window, model_turn_dc)\n        turn_result_tcf = turn_result_tcf.flatten()\n        spl = np.ones((window - 1))*0\n        turn_result_tcf = np.concatenate([spl, turn_result_tcf], axis=0)\n\n        key_cur = 'Walking'\n        window = 608\n        # data_walk = gen_dc_t(test_file,window)\n        walk_result_tcf = get_dc_result(test_file,window, modle_walk_dc)\n        walk_result_tcf = walk_result_tcf.flatten()\n        spl = np.ones((window - 1))*0\n        walk_result_tcf = np.concatenate([spl, walk_result_tcf], axis=0)\n\n        len_tcf = walk_result_tcf.shape[0]\n        index_test = [in_id + '_' + str(i) for i in range(len_tcf)]\n        dic_result = {'Id': index_test,\n                      'StartHesitation': hes_result_tcf,\n                      'Turn': turn_result_tcf,\n                      'Walking': walk_result_tcf}\n        df_result = pd.DataFrame(dic_result)\n        pd_list.append(df_result)\n\n    df_result = pd.concat(pd_list, ignore_index=True)\n    result_file = 'submission.csv'\n    df_result.to_csv(result_file, index=False)\n\nif __name__ == '__main__':\n    main()","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-05-18T02:02:43.517190Z","iopub.execute_input":"2023-05-18T02:02:43.517560Z","iopub.status.idle":"2023-05-18T02:10:10.233309Z","shell.execute_reply.started":"2023-05-18T02:02:43.517526Z","shell.execute_reply":"2023-05-18T02:10:10.231864Z"},"trusted":true},"execution_count":null,"outputs":[]}]}