{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "389cd136",
   "metadata": {},
   "source": [
    "# 处理异常数据\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "917fa110",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "import h5py\n",
    "\n",
    "def load_from_HDF(fname):\n",
    "    \"\"\"Load data from a HDF5 file to a dictionary.\"\"\"\n",
    "    data = dict()\n",
    "    with h5py.File(fname, 'r') as f:\n",
    "        for key in f:\n",
    "            data[key] = np.asarray(f[key])\n",
    "            if isinstance(data[key][0], np.bytes_):\n",
    "                data[key] = data[key].astype(str)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cddb976e",
   "metadata": {},
   "outputs": [],
   "source": [
    "path47 = 'Aggregated_CP_GE.h5'\n",
    "\n",
    "# data36 = load_from_HDF(path36)\n",
    "data47 = load_from_HDF(path47)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "54e51b05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "整个数组的数据范围：[-20.614704132080078, 2870874.0]\n",
      "------------------------------\n",
      "整个数组的数据范围：[-1249.9088134765625, 19152610.0]\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 计算整个数组的最小值和最大值\n",
    "data_min = data47['control_CP'].min()\n",
    "data_max = data47['control_CP'].max()\n",
    "\n",
    "# 计算每列（即每个特征）的最小值和最大值\n",
    "# axis=0 表示对每一列进行操作\n",
    "min_per_column = np.min(data47['control_CP'], axis=0)\n",
    "max_per_column = np.max(data47['control_CP'], axis=0)\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)\n",
    "\n",
    "# 计算整个数组的最小值和最大值\n",
    "data_min = data47['target_CP'].min()\n",
    "data_max = data47['target_CP'].max()\n",
    "\n",
    "# 计算每列（即每个特征）的最小值和最大值\n",
    "# axis=0 表示对每一列进行操作\n",
    "min_per_column = np.min(data47['target_CP'], axis=0)\n",
    "max_per_column = np.max(data47['target_CP'], axis=0)\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bde80b4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "整个数组的数据范围：[-2.230109453201294, 1.6778349876403809]\n",
      "------------------------------\n",
      "整个数组的数据范围：[-6.4108500480651855, 9.534767150878906]\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 计算整个数组的最小值和最大值\n",
    "data_min = data47['control_GE'].min()\n",
    "data_max = data47['control_GE'].max()\n",
    "\n",
    "# 计算每列（即每个特征）的最小值和最大值\n",
    "# axis=0 表示对每一列进行操作\n",
    "min_per_column = np.min(data47['control_GE'], axis=0)\n",
    "max_per_column = np.max(data47['control_GE'], axis=0)\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)\n",
    "\n",
    "# 计算整个数组的最小值和最大值\n",
    "data_min = data47['target_GE'].min()\n",
    "data_max = data47['target_GE'].max()\n",
    "\n",
    "# 计算每列（即每个特征）的最小值和最大值\n",
    "# axis=0 表示对每一列进行操作\n",
    "min_per_column = np.min(data47['target_GE'], axis=0)\n",
    "max_per_column = np.max(data47['target_GE'], axis=0)\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "053cfaa7",
   "metadata": {},
   "source": [
    "## 看看 cpg0016 的数值范围"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c81440ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "整个数组的数据范围：[-1.2491892576217651, 1.3490736484527588]\n",
      "------------------------------\n",
      "整个数组的数据范围：[-6.057624816894531, 6.188350677490234]\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "cpg0016_data = '/home/bob/boom/VCBench/data/Image/cpg0016_data.h5'\n",
    "\n",
    "# data36 = load_from_HDF(path36)\n",
    "cpg0016_data = load_from_HDF(cpg0016_data)\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# 计算整个数组的最小值和最大值\n",
    "data_min = cpg0016_data['control'].min()\n",
    "data_max = cpg0016_data['control'].max()\n",
    "\n",
    "# 计算每列（即每个特征）的最小值和最大值\n",
    "# axis=0 表示对每一列进行操作\n",
    "min_per_column = np.min(cpg0016_data['control'], axis=0)\n",
    "max_per_column = np.max(cpg0016_data['control'], axis=0)\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)\n",
    "\n",
    "# 计算整个数组的最小值和最大值\n",
    "data_min = cpg0016_data['target'].min()\n",
    "data_max = cpg0016_data['target'].max()\n",
    "\n",
    "# 计算每列（即每个特征）的最小值和最大值\n",
    "# axis=0 表示对每一列进行操作\n",
    "min_per_column = np.min(cpg0016_data['target'], axis=0)\n",
    "max_per_column = np.max(cpg0016_data['target'], axis=0)\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2b2f331e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "标准化后的整个数组的数据范围：[-11.38830852508545, 10.123730659484863]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 假设 data47['target_CP'] 是你的原始数据, target_CP, \n",
    "data_with_outlier = data47['control_CP']\n",
    "\n",
    "# 1. 异常值处理 - 使用截断法 (Clipping)\n",
    "# 设定一个更保守的上限，例如基于分位数\n",
    "q99 = np.percentile(data_with_outlier, 99)\n",
    "clip_max = q99 * 2 # 或者直接用一个固定值，比如 5\n",
    "data_clipped = np.clip(data_with_outlier, a_min=None, a_max=clip_max)\n",
    "# 2. 数据标准化 - Z-score Normalization\n",
    "# 计算每列（特征）的均值和标准差\n",
    "mu = data_clipped.mean(axis=0)\n",
    "sigma = data_clipped.std(axis=0)\n",
    "\n",
    "# 初始化一个与数据形状相同的零数组\n",
    "data_normalized = np.zeros_like(data_clipped, dtype=float)\n",
    "\n",
    "# 找到标准差不为0的列\n",
    "# 为了避免浮点数误差，使用一个非常小的阈值来检查\n",
    "epsilon = 1e-8\n",
    "nonzero_sigma_cols = sigma > epsilon\n",
    "\n",
    "# 对这些列进行零均值化\n",
    "data_normalized[:, nonzero_sigma_cols] = (data_clipped[:, nonzero_sigma_cols] - mu[nonzero_sigma_cols]) / sigma[nonzero_sigma_cols]\n",
    "\n",
    "# 检查结果\n",
    "data_min = data_normalized.min()\n",
    "data_max = data_normalized.max()\n",
    "\n",
    "print(f\"\\n标准化后的整个数组的数据范围：[{data_min}, {data_max}]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9ccda958",
   "metadata": {},
   "outputs": [],
   "source": [
    "control_CP = data_normalized.copy()\n",
    "# print(control_CP.shape)\n",
    "# target_CP = data_normalized.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6e515034",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "整个数组的数据范围：[-11.38830852508545, 10.123730659484863]\n",
      "------------------------------\n",
      "整个数组的数据范围：[-129.0272979736328, 64.47639465332031]\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "data_min = control_CP.min()\n",
    "data_max = control_CP.max()\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)\n",
    "# 计算整个数组的最小值和最大值\n",
    "data_min = target_CP.min()\n",
    "data_max = target_CP.max()\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "481b57e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64 float64\n",
      "float32 float32\n"
     ]
    }
   ],
   "source": [
    "print(control_CP.dtype, target_CP.dtype)\n",
    "\n",
    "control_CP_float32 = control_CP.astype(np.float32)\n",
    "target_CP_float32 = target_CP.astype(np.float32)\n",
    "print(control_CP_float32.dtype, target_CP_float32.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6e2d6030",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "已删除旧的 'control_CP' 数据集。\n",
      "已删除旧的 'target_CP' 数据集。\n",
      "已成功写入新的 'control_CP' 和 'target_CP' 数据集。\n",
      "操作完成。\n"
     ]
    }
   ],
   "source": [
    "file_path = 'Aggregated_CP_GE.h5'\n",
    "# 使用 'a' (append) 模式打开文件\n",
    "with h5py.File(file_path, 'a') as f:\n",
    "    \n",
    "    # 1. 删除旧的数据集（如果存在）\n",
    "    if \"control_CP\" in f:\n",
    "        del f[\"control_CP\"]\n",
    "        print(\"已删除旧的 'control_CP' 数据集。\")\n",
    "        \n",
    "    if \"target_CP\" in f:\n",
    "        del f[\"target_CP\"]\n",
    "        print(\"已删除旧的 'target_CP' 数据集。\")\n",
    "    \n",
    "    # 2. 创建并写入新的数据集\n",
    "    f.create_dataset(\"control_CP\", data=control_CP_float32)\n",
    "    f.create_dataset(\"target_CP\", data=target_CP_float32)\n",
    "    \n",
    "    print(\"已成功写入新的 'control_CP' 和 'target_CP' 数据集。\")\n",
    "\n",
    "print(\"操作完成。\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b131c13e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5a82372f",
   "metadata": {},
   "source": [
    "# 看基因数据是否异常 -- 没有"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a81ddc86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "整个数组的数据范围：[-11.38830852508545, 10.123730659484863]\n",
      "------------------------------\n",
      "每列数据的最小值（前10个）：\n",
      "[-1.7736303 -2.8932922 -1.9792434 -1.3063283 -1.5805442 -2.5623124\n",
      " -2.9260125 -3.1737845 -3.493395  -5.5112543]\n",
      "------------------------------\n",
      "每列数据的最大值（前10个）：\n",
      "[3.8115907 4.765787  9.468964  3.2014632 2.3736608 4.2486434 4.5805535\n",
      " 4.513591  1.7128    2.9639645]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "data47 = load_from_HDF( 'Aggregated_CP_GE.h5')\n",
    "# 计算整个数组的最小值和最大值\n",
    "data_min = data47['control_CP'].min()\n",
    "data_max = data47['control_CP'].max()\n",
    "\n",
    "# 计算每列（即每个特征）的最小值和最大值\n",
    "# axis=0 表示对每一列进行操作\n",
    "min_per_column = np.min(data47['control_CP'], axis=0)\n",
    "max_per_column = np.max(data47['control_CP'], axis=0)\n",
    "\n",
    "print(f\"整个数组的数据范围：[{data_min}, {data_max}]\")\n",
    "print(\"-\" * 30)\n",
    "print(\"每列数据的最小值（前10个）：\")\n",
    "print(min_per_column[:10])\n",
    "print(\"-\" * 30)\n",
    "print(\"每列数据的最大值（前10个）：\")\n",
    "print(max_per_column[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "770f3727",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 看看方差\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10693804",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c072eea5",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "boom",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}