repo_name
stringlengths 8
130
| hexsha
sequence | file_path
sequence | code
sequence | apis
sequence |
|---|---|---|---|---|
Randal1936/FinancialSupervision | [
"3d78b1cc662a2c0675ace880a772cc38eaf7672f"
] | [
"tools/PolicyAnalysis/Businesses.py"
] | [
"import pandas as pd\nimport numpy as np\nimport xlwings as xw\nfrom PolicyAnalysis import cptj as cj\n\n\"\"\"\n————————————————————\n以下是使用 re 检索+ DFC 映射的数据处理写法\n————————————————————\n\"\"\"\n\nclass businesses_re:\n\n def __init__(self, Data, userdict):\n self.Data = Data\n self.userdict = userdict\n\n data = Data.copy()\n # 先获取关键词字典\n n = cj.txt_to_list(self.userdict)\n\n # 把被监管的业务分类，做成字典映射\n # 首先生成一个列表，标记一下关键词所在的位置\n loc = [(0, 4), (4, 10), (10, 15), (15, 19), (19, 22), (22, 26), (26, 29), (29, 31), (31, 40),\n (40, 41), (41, 42), (42, 43), (43, 44), (44, 45)]\n\n # 然后遍历列表，按照标记的位置生成关键词切片，把同类的关键词映射到相同的数值\n i = 0\n keymap = {}\n for rank in loc:\n lst = n[rank[0]: rank[1]]\n for item in lst:\n keymap[item] = i\n i += 1\n\n # 情况一，对全部正文进行检索\n result1 = cj.words_docs_freq(n, data)\n dfc1 = result1['DFC']\n dtm1_class = result1['DTM']\n dtm1_final = cj.dfc_sort_filter(dfc1, keymap, '被监管业务-正文分类统计.xlsx')\n\n # 情况二，对正文前十句话进行检索\n # 造一个正文栏只包括正文前十句话的样本矩阵\n tf = data\n for i in range(0, data.shape[0]):\n tf.iloc[i, 2] = cj.top_n_sent(10, data.iloc[i, 2])\n\n result2 = cj.words_docs_freq(n, tf)\n dfc2 = result2['DFC']\n dtm2_class = result2['DTM']\n dtm2_final = cj.dfc_sort_filter(dfc2, keymap, '被监管业务-前十句话分类统计.xlsx')\n\n # 情况三，仅对标题进行检索\n # 首先把样本弄成一样的格式\n # 建议用这种赋值+循环 iloc 赋值来新建样本\n # 否则会报乱七八糟的错：不能用 slice 来更改原 DataFrame 值啊 blablabla\n tf3 = data\n for i in range(0, data.shape[0]):\n tf3.iloc[i, 2] = data.iloc[i, 1]\n # 生成词频统计结果\n result3 = cj.words_docs_freq(n, tf3)\n dfc3 = result3['DFC']\n dtm3_class = result3['DTM']\n dtm3_final = cj.dfc_sort_filter(dfc3, keymap, '被监管业务-标题分类统计.xlsx')\n\n dtm_final = pd.concat([dtm1_final, dtm2_final, dtm3_final], axis=1)\n dtm_final.columns = ['被监管业务数（正文）', '被监管业务数（前十句）', '被监管业务数（标题）']\n\n dtm_aver_class = dtm_final.agg(np.mean, axis=1)\n dtm_aver_class = pd.DataFrame(dtm_aver_class, columns=['被监管业务数'])\n\n self.DTM_aver = dtm_aver_class # DTM 1、2、3 被监管业务数求均值\n self.DTM_final = dtm_final # DTM 1、2、3 被监管业务种类数汇总\n self.DTM1_class = dtm1_class # 按正文检索得到的 Doc-Term Matrix\n self.DTM2_class = dtm2_class # 按前十句话检索的 Doc-Term Matrix\n self.DTM3_class = dtm3_class # 按标题检索得到的 Doc-Term Matrix\n\n\n\"\"\"\n——————————————————————\n以下是使用 jieba 检索+ DTM 映射的数据处理写法\n——————————————————————\n\"\"\"\n\nclass business_jieba:\n\n def __init__(self, Data, userdict, indifile, indisheet, stopwords):\n self.Data = Data\n self.userdict = userdict\n self.indifile = indifile\n self.indisheet = indisheet\n self.stopwords = stopwords\n\n data = Data.copy()\n\n # 导入指标文件\n app = xw.App(visible=False, add_book=False)\n app.screen_updating = False\n app.display_alerts = False\n try:\n wb = app.books.open(self.indifile)\n sht = wb.sheets[self.indisheet]\n df_indi = sht.used_range.value\n df_indi = pd.DataFrame(df_indi)\n df_indi.columns = df_indi.loc[0]\n df_indi.drop(0, axis=0, inplace=True)\n df_indi.dropna(axis=0, how='all', inplace=True)\n finally:\n app.quit()\n\n # 生成 Business 分类字典, {'Institution': [keyword1, keyword2, keyword3, ....], ....}\n keymap = {}\n for i in range(df_indi.shape[1]):\n keymap[df_indi.columns[i]] = list(df_indi.iloc[:, i].dropna(''))\n\n # 情况一，对全部正文进行检索\n dtm1 = cj.jieba_vectorizer(data, self.userdict, self.stopwords).DTM\n dtm1_result = cj.dtm_sort_filter(dtm1, keymap, '被监管业务-正文分类统计.xlsx')\n dtm1_class = dtm1_result['DTM_class']\n dtm1_final = dtm1_result['DTM_final']\n\n # 情况二，对正文前十句话进行检索\n # 造一个正文栏只包括正文前十句话的样本矩阵\n tf = data.copy()\n for i in range(0, data.shape[0]):\n tf.iloc[i, 2] = cj.top_n_sent(10, data.iloc[i, 2])\n\n dtm2 = cj.jieba_vectorizer(tf, self.userdict, self.stopwords).DTM\n dtm2_result = cj.dtm_sort_filter(dtm2, keymap, '被监管业务-前十句话分类统计.xlsx')\n dtm2_class = dtm2_result['DTM_class']\n dtm2_final = dtm2_result['DTM_final']\n\n # 情况三，仅对标题进行检索\n # 首先把样本弄成一样的格式\n # 建议用这种赋值+循环 iloc 赋值来新建样本\n # 否则会报乱七八糟的错：不能用 slice 来更改原 DataFrame 值啊 blablabla\n tf3 = data.copy()\n for i in range(0, data.shape[0]):\n tf3.iloc[i, 2] = data.iloc[i, 1]\n # 生成词频统计结果\n\n dtm3 = cj.jieba_vectorizer(tf3, self.userdict, self.stopwords).DTM\n dtm3_result = cj.dtm_sort_filter(dtm3, keymap)\n dtm3_class = dtm3_result['DTM_class']\n dtm3_final = dtm3_result['DTM_final']\n\n dtm_final = pd.concat([dtm1_final, dtm2_final, dtm3_final], axis=1)\n dtm_final.columns = ['被监管业务数（正文）', '被监管业务数（前十句）', '被监管业务数（标题）']\n\n dtm_aver_class = dtm_final.agg(np.mean, axis=1)\n dtm_aver_class = pd.DataFrame(dtm_aver_class, columns=['被监管业务种类数'])\n\n self.DTM_aver = dtm_aver_class # DTM 1、2、3 被监管业务数求均值\n self.DTM_final = dtm_final # DTM 1、2、3 被监管业务种类数汇总\n self.DTM1_class = dtm1_class # 按正文检索得到的 Doc-Term Matrix\n self.DTM2_class = dtm2_class # 按前十句话检索的 Doc-Term Matrix\n self.DTM3_class = dtm3_class # 按标题检索得到的 Doc-Term Matrix\n"
] | [
[
"pandas.DataFrame",
"pandas.concat"
]
] |
simbilod/gdsfactory | [
"4d76db32674c3edb4d16260e3177ee29ef9ce11d",
"4d76db32674c3edb4d16260e3177ee29ef9ce11d"
] | [
"gdsfactory/simulation/simphony/components/ring_double_siepic.py",
"gdsfactory/simulation/modes/tests/test_find_modes_dispersion.py"
] | [
"from simphony.library import siepic\nfrom simphony.netlist import Subcircuit\n\n\ndef ring_double_siepic(\n wg_width=0.5,\n gap=0.2,\n length_x=4,\n bend_radius=5,\n length_y=2,\n coupler=siepic.ebeam_dc_halfring_straight,\n straight=siepic.ebeam_wg_integral_1550,\n terminator=siepic.ebeam_terminator_te1550,\n):\n r\"\"\"Return double bus ring made of two couplers (ct: top, cb: bottom).\n\n connected with two vertical straights (wyl: left, wyr: right)\n\n .. code::\n\n --==ct==--\n | |\n wl wr length_y\n | |\n --==cb==-- gap\n\n length_x\n\n\n drop n1 _ _ n3 cdrop\n \\______/\n ______\n in n2 _/ \\_n4\n | |\n n1 | | n3\n \\______/\n ______\n in n2 _/ \\_n4 output\n\n\n \"\"\"\n straight = straight() if callable(straight) else straight\n coupler = coupler() if callable(coupler) else coupler\n\n # Create the circuit, add all individual instances\n circuit = Subcircuit(\"mzi\")\n circuit.add([(coupler, \"ct\"), (coupler, \"cb\"), (straight, \"wl\"), (straight, \"wr\")])\n\n # Circuits can be connected using the elements' string names:\n circuit.connect_many(\n [\n (\"cb\", \"n1\", \"wl\", \"n1\"),\n (\"wl\", \"n2\", \"ct\", \"n2\"),\n (\"ct\", \"n4\", \"wr\", \"n1\"),\n (\"wr\", \"n2\", \"cb\", \"n3\"),\n ]\n )\n circuit.elements[\"cb\"].pins[\"n2\"] = \"input\"\n circuit.elements[\"cb\"].pins[\"n4\"] = \"output\"\n circuit.elements[\"ct\"].pins[\"n1\"] = \"drop\"\n circuit.elements[\"ct\"].pins[\"n3\"] = \"cdrop\"\n return circuit\n\n\nif __name__ == \"__main__\":\n import matplotlib.pyplot as plt\n\n from gdsfactory.simulationsimphony import plot_circuit\n\n c = ring_double_siepic()\n plot_circuit(c)\n plt.show()\n",
"import numpy as np\n\nfrom gdsfactory.simulation.modes.find_mode_dispersion import find_mode_dispersion\n\n\ndef test_find_modes_waveguide_dispersion() -> None:\n modes = find_mode_dispersion(wg_width=0.45, resolution=20, cache=None)\n m1 = modes\n\n # print(f\"neff1 = {m1.neff}\")\n # print(f\"ng1 = {m1.ng}\")\n\n # neff1 = 2.3948\n # ng1 = 4.23194\n\n neff1 = 2.362907833437435\n ng1 = 4.202169359808116\n\n assert np.isclose(m1.neff, neff1), (m1.neff, neff1)\n assert np.isclose(m1.ng, ng1), (m1.ng, ng1)\n\n\nif __name__ == \"__main__\":\n test_find_modes_waveguide_dispersion()\n"
] | [
[
"matplotlib.pyplot.show"
],
[
"numpy.isclose"
]
] |
layumi/dgcnn | [
"a7b58796ffe549f2d8bdb06a84f62aba03e1d3a1"
] | [
"pytorch/data.py"
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n@Author: Yue Wang\n@Contact: [email protected]\n@File: data.py\n@Time: 2018/10/13 6:21 PM\n\nModified by \n@Author: An Tao\n@Contact: [email protected]\n@Time: 2020/2/27 9:32 PM\n\"\"\"\n\n\nimport os\nimport sys\nimport glob\nimport h5py\nimport numpy as np\nimport torch\nfrom torch.utils.data import Dataset\n\n\ndef download_modelnet40():\n BASE_DIR = os.path.dirname(os.path.abspath(__file__))\n DATA_DIR = os.path.join(BASE_DIR, 'data')\n if not os.path.exists(DATA_DIR):\n os.mkdir(DATA_DIR)\n if not os.path.exists(os.path.join(DATA_DIR, 'modelnet40_ply_hdf5_2048')):\n www = 'https://shapenet.cs.stanford.edu/media/modelnet40_ply_hdf5_2048.zip'\n zipfile = os.path.basename(www)\n os.system('wget %s; unzip %s' % (www, zipfile))\n os.system('mv %s %s' % (zipfile[:-4], DATA_DIR))\n os.system('rm %s' % (zipfile))\n\n\ndef download_shapenetpart():\n BASE_DIR = os.path.dirname(os.path.abspath(__file__))\n DATA_DIR = os.path.join(BASE_DIR, 'data')\n if not os.path.exists(DATA_DIR):\n os.mkdir(DATA_DIR)\n if not os.path.exists(os.path.join(DATA_DIR, 'shapenet_part_seg_hdf5_data')):\n www = 'https://shapenet.cs.stanford.edu/media/shapenet_part_seg_hdf5_data.zip'\n zipfile = os.path.basename(www)\n os.system('wget %s --no-check-certificate; unzip %s' % (www, zipfile))\n os.system('mv %s %s' % (zipfile[:-4], os.path.join(DATA_DIR, 'shapenet_part_seg_hdf5_data')))\n os.system('rm %s' % (zipfile))\n\n\ndef download_S3DIS():\n BASE_DIR = os.path.dirname(os.path.abspath(__file__))\n DATA_DIR = os.path.join(BASE_DIR, 'data')\n if not os.path.exists(DATA_DIR):\n os.mkdir(DATA_DIR)\n if not os.path.exists(os.path.join(DATA_DIR, 'indoor3d_sem_seg_hdf5_data')):\n www = 'https://shapenet.cs.stanford.edu/media/indoor3d_sem_seg_hdf5_data.zip'\n zipfile = os.path.basename(www)\n os.system('wget --no-check-certificate %s; unzip %s' % (www, zipfile))\n os.system('mv %s %s' % (zipfile[:-4], DATA_DIR))\n os.system('rm %s' % (zipfile))\n if not os.path.exists(os.path.join(DATA_DIR, 'Stanford3dDataset_v1.2_Aligned_Version')):\n if not os.path.exists(os.path.join(DATA_DIR, 'Stanford3dDataset_v1.2_Aligned_Version.zip')):\n print('Please download Stanford3dDataset_v1.2_Aligned_Version.zip \\\n from https://goo.gl/forms/4SoGp4KtH1jfRqEj2 and place it under data/')\n sys.exit(0)\n else:\n zippath = os.path.join(DATA_DIR, 'Stanford3dDataset_v1.2_Aligned_Version.zip')\n os.system('unzip %s' % (zippath))\n os.system('rm %s' % (zippath))\n\n\ndef load_data_cls(partition):\n download_modelnet40()\n BASE_DIR = os.path.dirname(os.path.abspath(__file__))\n DATA_DIR = os.path.join(BASE_DIR, 'data')\n all_data = []\n all_label = []\n for h5_name in glob.glob(os.path.join(DATA_DIR, 'modelnet40*hdf5_2048', '*%s*.h5'%partition)):\n f = h5py.File(h5_name, 'r+')\n data = f['data'][:].astype('float32')\n label = f['label'][:].astype('int64')\n f.close()\n all_data.append(data)\n all_label.append(label)\n all_data = np.concatenate(all_data, axis=0)\n all_label = np.concatenate(all_label, axis=0)\n return all_data, all_label\n\n\ndef load_data_partseg(partition):\n download_shapenetpart()\n BASE_DIR = os.path.dirname(os.path.abspath(__file__))\n DATA_DIR = os.path.join(BASE_DIR, 'data')\n all_data = []\n all_label = []\n all_seg = []\n if partition == 'trainval':\n file = glob.glob(os.path.join(DATA_DIR, 'shapenet*hdf5*', '*train*.h5')) \\\n + glob.glob(os.path.join(DATA_DIR, 'shapenet*hdf5*', '*val*.h5'))\n else:\n file = glob.glob(os.path.join(DATA_DIR, 'shapenet*hdf5*', '*%s*.h5'%partition))\n for h5_name in file:\n f = h5py.File(h5_name, 'r+')\n data = f['data'][:].astype('float32')\n label = f['label'][:].astype('int64')\n seg = f['pid'][:].astype('int64')\n f.close()\n all_data.append(data)\n all_label.append(label)\n all_seg.append(seg)\n all_data = np.concatenate(all_data, axis=0)\n all_label = np.concatenate(all_label, axis=0)\n all_seg = np.concatenate(all_seg, axis=0)\n return all_data, all_label, all_seg\n\n\ndef prepare_test_data_semseg():\n BASE_DIR = os.path.dirname(os.path.abspath(__file__))\n DATA_DIR = os.path.join(BASE_DIR, 'data')\n if not os.path.exists(os.path.join(DATA_DIR, 'stanford_indoor3d')):\n os.system('python prepare_data/collect_indoor3d_data.py')\n if not os.path.exists(os.path.join(DATA_DIR, 'indoor3d_sem_seg_hdf5_data_test')):\n os.system('python prepare_data/gen_indoor3d_h5.py')\n\n\ndef load_data_semseg(partition, test_area):\n BASE_DIR = os.path.dirname(os.path.abspath(__file__))\n DATA_DIR = os.path.join(BASE_DIR, 'data')\n download_S3DIS()\n prepare_test_data_semseg()\n if partition == 'train':\n data_dir = os.path.join(DATA_DIR, 'indoor3d_sem_seg_hdf5_data')\n else:\n data_dir = os.path.join(DATA_DIR, 'indoor3d_sem_seg_hdf5_data_test')\n with open(os.path.join(data_dir, \"all_files.txt\")) as f:\n all_files = [line.rstrip() for line in f]\n with open(os.path.join(data_dir, \"room_filelist.txt\")) as f:\n room_filelist = [line.rstrip() for line in f]\n data_batchlist, label_batchlist = [], []\n for f in all_files:\n file = h5py.File(os.path.join(DATA_DIR, f), 'r+')\n data = file[\"data\"][:]\n label = file[\"label\"][:]\n data_batchlist.append(data)\n label_batchlist.append(label)\n data_batches = np.concatenate(data_batchlist, 0)\n seg_batches = np.concatenate(label_batchlist, 0)\n test_area_name = \"Area_\" + test_area\n train_idxs, test_idxs = [], []\n for i, room_name in enumerate(room_filelist):\n if test_area_name in room_name:\n test_idxs.append(i)\n else:\n train_idxs.append(i)\n if partition == 'train':\n all_data = data_batches[train_idxs, ...]\n all_seg = seg_batches[train_idxs, ...]\n else:\n all_data = data_batches[test_idxs, ...]\n all_seg = seg_batches[test_idxs, ...]\n return all_data, all_seg\n\n\ndef translate_pointcloud(pointcloud):\n xyz1 = np.random.uniform(low=2./3., high=3./2., size=[3])\n xyz2 = np.random.uniform(low=-0.2, high=0.2, size=[3])\n \n translated_pointcloud = np.add(np.multiply(pointcloud, xyz1), xyz2).astype('float32')\n return translated_pointcloud\n\n\ndef jitter_pointcloud(pointcloud, sigma=0.01, clip=0.02):\n N, C = pointcloud.shape\n pointcloud += np.clip(sigma * np.random.randn(N, C), -1*clip, clip)\n return pointcloud\n\n\ndef rotate_pointcloud(pointcloud):\n theta = np.pi*2 * np.random.uniform()\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)],[np.sin(theta), np.cos(theta)]])\n pointcloud[:,[0,2]] = pointcloud[:,[0,2]].dot(rotation_matrix) # random rotation (x,z)\n return pointcloud\n\n\nclass ModelNet40(Dataset):\n def __init__(self, num_points, partition='train'):\n self.data, self.label = load_data_cls(partition)\n self.num_points = num_points\n self.partition = partition \n\n def __getitem__(self, item):\n pointcloud = self.data[item][:self.num_points]\n label = self.label[item]\n if self.partition == 'train':\n pointcloud = translate_pointcloud(pointcloud)\n np.random.shuffle(pointcloud)\n return pointcloud, label\n\n def __len__(self):\n return self.data.shape[0]\n\n\nclass ShapeNetPart(Dataset):\n def __init__(self, num_points, partition='train', class_choice=None):\n self.data, self.label, self.seg = load_data_partseg(partition)\n self.cat2id = {'airplane': 0, 'bag': 1, 'cap': 2, 'car': 3, 'chair': 4, \n 'earphone': 5, 'guitar': 6, 'knife': 7, 'lamp': 8, 'laptop': 9, \n 'motor': 10, 'mug': 11, 'pistol': 12, 'rocket': 13, 'skateboard': 14, 'table': 15}\n self.seg_num = [4, 2, 2, 4, 4, 3, 3, 2, 4, 2, 6, 2, 3, 3, 3, 3]\n self.index_start = [0, 4, 6, 8, 12, 16, 19, 22, 24, 28, 30, 36, 38, 41, 44, 47]\n self.num_points = num_points\n self.partition = partition \n self.class_choice = class_choice\n\n if self.class_choice != None:\n id_choice = self.cat2id[self.class_choice]\n indices = (self.label == id_choice).squeeze()\n self.data = self.data[indices]\n self.label = self.label[indices]\n self.seg = self.seg[indices]\n self.seg_num_all = self.seg_num[id_choice]\n self.seg_start_index = self.index_start[id_choice]\n else:\n self.seg_num_all = 50\n self.seg_start_index = 0\n\n def __getitem__(self, item):\n pointcloud = self.data[item][:self.num_points]\n label = self.label[item]\n seg = self.seg[item][:self.num_points]\n if self.partition == 'trainval':\n # pointcloud = translate_pointcloud(pointcloud)\n indices = list(range(pointcloud.shape[0]))\n np.random.shuffle(indices)\n pointcloud = pointcloud[indices]\n seg = seg[indices]\n return pointcloud, label, seg\n\n def __len__(self):\n return self.data.shape[0]\n\n\nclass S3DIS(Dataset):\n def __init__(self, num_points=4096, partition='train', test_area='1'):\n self.data, self.seg = load_data_semseg(partition, test_area)\n self.num_points = num_points\n self.partition = partition \n\n def __getitem__(self, item):\n pointcloud = self.data[item][:self.num_points]\n seg = self.seg[item][:self.num_points]\n if self.partition == 'train':\n indices = list(range(pointcloud.shape[0]))\n np.random.shuffle(indices)\n pointcloud = pointcloud[indices]\n seg = seg[indices]\n seg = torch.LongTensor(seg)\n return pointcloud, seg\n\n def __len__(self):\n return self.data.shape[0]\n\n\nif __name__ == '__main__':\n train = ModelNet40(1024)\n test = ModelNet40(1024, 'test')\n data, label = train[0]\n print(data.shape)\n print(label.shape)\n\n trainval = ShapeNetPart(2048, 'trainval')\n test = ShapeNetPart(2048, 'test')\n data, label, seg = trainval[0]\n print(data.shape)\n print(label.shape)\n print(seg.shape)\n\n train = S3DIS(4096)\n test = S3DIS(4096, 'test')\n data, seg = train[0]\n print(data.shape)\n print(seg.shape)\n"
] | [
[
"numpy.random.uniform",
"numpy.multiply",
"numpy.random.shuffle",
"numpy.random.randn",
"numpy.cos",
"numpy.sin",
"numpy.concatenate",
"torch.LongTensor"
]
] |
wip-abramson/PySyft | [
"2940bfebb3e0f37a1b7451cf9581c41917534ed6"
] | [
"packages/syft/tests/syft/lib/sklearn/model_serialize_test.py"
] | [
"# third party\nimport numpy as np\nimport pytest\nfrom sklearn.linear_model import LogisticRegression\n\n# syft absolute\nimport syft as sy\nfrom syft.experimental_flags import flags\n\nsy.load(\"sklearn\")\nsy.load(\"numpy\")\n\n\[email protected](lib=\"sklearn\")\[email protected](\"arrow_backend\", [True, False])\ndef test_logistic_model_serde(\n arrow_backend: bool, root_client: sy.VirtualMachineClient\n) -> None:\n flags.APACHE_ARROW_TENSOR_SERDE = arrow_backend\n X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])\n y = np.array([0, 0, 1, 1])\n clf = LogisticRegression(random_state=0).fit(X, y)\n\n clf_remote = clf.send(root_client)\n\n clf_2 = clf_remote.get()\n\n dict_1 = vars(clf)\n dict_2 = vars(clf_2)\n\n for key in dict_1.keys():\n if type(dict_1[key]) == float:\n assert abs(dict_1[key] - dict_2[key]) < 0.0001\n elif type(dict_1[key]) == np.ndarray:\n assert dict_1[key].all() == dict_2[key].all()\n else:\n assert dict_1[key] == dict_2[key]\n"
] | [
[
"numpy.array",
"sklearn.linear_model.LogisticRegression"
]
] |
3D-semantic-Sgmentation/pointnet | [
"029c0217143e6b69e685ab57cf243e322d47860f"
] | [
"models/pointnet_seg.py"
] | [
"# import tensorflow as tf\nimport numpy as np\nimport math\nimport sys\nimport os\nimport tensorflow.compat.v1 as tf\nimport tensorflow as tf2\n\nBASE_DIR = os.path.dirname(os.path.abspath(__file__))\nsys.path.append(BASE_DIR)\nsys.path.append(os.path.join(BASE_DIR, '../utils'))\nimport tf_util\nfrom transform_nets import input_transform_net, feature_transform_net\n\ndef placeholder_inputs(batch_size, num_point):\n tf.compat.v1.disable_eager_execution()\n pointclouds_pl = tf.placeholder(tf.float32,\n shape=(batch_size, num_point, 3))\n labels_pl = tf.placeholder(tf.int32,\n shape=(batch_size, num_point))\n return pointclouds_pl, labels_pl\n\n\ndef get_model(point_cloud, is_training, bn_decay=None):\n \"\"\" Classification PointNet, input is BxNx3, output BxNx50 \"\"\"\n batch_size = point_cloud.get_shape()[0]\n num_point = point_cloud.get_shape()[1]\n end_points = {}\n\n with tf.variable_scope('transform_net1') as sc:\n transform = input_transform_net(point_cloud, is_training, bn_decay, K=3)\n point_cloud_transformed = tf.matmul(point_cloud, transform)\n input_image = tf.expand_dims(point_cloud_transformed, -1)\n\n net = tf_util.conv2d(input_image, 64, [1,3],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv1', bn_decay=bn_decay)\n net = tf_util.conv2d(net, 64, [1,1],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv2', bn_decay=bn_decay)\n\n with tf.variable_scope('transform_net2') as sc:\n transform = feature_transform_net(net, is_training, bn_decay, K=64)\n end_points['transform'] = transform\n net_transformed = tf.matmul(tf.squeeze(net, axis=[2]), transform)\n point_feat = tf.expand_dims(net_transformed, [2])\n print(point_feat)\n\n net = tf_util.conv2d(point_feat, 64, [1,1],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv3', bn_decay=bn_decay)\n net = tf_util.conv2d(net, 128, [1,1],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv4', bn_decay=bn_decay)\n net = tf_util.conv2d(net, 1024, [1,1],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv5', bn_decay=bn_decay)\n global_feat = tf_util.max_pool2d(net, [num_point,1],\n padding='VALID', scope='maxpool')\n print(global_feat)\n\n global_feat_expand = tf.tile(global_feat, [1, num_point, 1, 1])\n concat_feat = tf.concat(axis=3, values=[point_feat, global_feat_expand])\n print(concat_feat)\n\n net = tf_util.conv2d(concat_feat, 512, [1,1],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv6', bn_decay=bn_decay)\n net = tf_util.conv2d(net, 256, [1,1],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv7', bn_decay=bn_decay)\n net = tf_util.conv2d(net, 128, [1,1],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv8', bn_decay=bn_decay)\n net = tf_util.conv2d(net, 128, [1,1],\n padding='VALID', stride=[1,1],\n bn=True, is_training=is_training,\n scope='conv9', bn_decay=bn_decay)\n\n net = tf_util.conv2d(net, 9, [1,1],\n padding='VALID', stride=[1,1], activation_fn=None,\n scope='conv10')\n net = tf.squeeze(net, [2]) # BxNxC\n\n return net, end_points\n\n\ndef get_loss(pred, label, end_points, reg_weight=0.001):\n \"\"\" pred: BxNxC,\n label: BxN, \"\"\"\n\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=pred, labels=label)\n classify_loss = tf.reduce_mean(loss)\n tf2.summary.scalar('classify loss', classify_loss)\n\n # Enforce the transformation as orthogonal matrix\n transform = end_points['transform'] # BxKxK\n K = transform.get_shape()[1]\n mat_diff = tf.matmul(transform, tf.transpose(transform, perm=[0,2,1]))\n mat_diff -= tf.constant(np.eye(K), dtype=tf.float32)\n mat_diff_loss = tf.nn.l2_loss(mat_diff) \n tf2.summary.scalar('mat_loss', mat_diff_loss)\n\n return classify_loss + mat_diff_loss * reg_weight\n\n\nif __name__=='__main__':\n with tf.Graph().as_default():\n inputs = tf.zeros((32,1024,3))\n labels = tf.zeros((32,1024))\n print(labels.shape.rank)\n pred, end_points = get_model(inputs, tf.constant(True))\n loss = get_loss(pred, labels, end_points)\n print(outputs)\n"
] | [
[
"tensorflow.compat.v1.placeholder",
"tensorflow.summary.scalar",
"numpy.eye",
"tensorflow.compat.v1.transpose",
"tensorflow.compat.v1.tile",
"tensorflow.compat.v1.nn.sparse_softmax_cross_entropy_with_logits",
"tensorflow.compat.v1.zeros",
"tensorflow.compat.v1.Graph",
"tensorflow.compat.v1.matmul",
"tensorflow.compat.v1.reduce_mean",
"tensorflow.compat.v1.concat",
"tensorflow.compat.v1.nn.l2_loss",
"tensorflow.compat.v1.expand_dims",
"tensorflow.compat.v1.squeeze",
"tensorflow.compat.v1.variable_scope",
"tensorflow.compat.v1.constant",
"tensorflow.compat.v1.compat.v1.disable_eager_execution"
]
] |
vedashree29296/BentoML | [
"79f94d543a0684e04551207d102a2d254b770ad3"
] | [
"tests/adapters/test_dataframe_input.py"
] | [
"# pylint: disable=redefined-outer-name\n\nimport itertools\nimport json\nimport math\nimport time\n\nimport flask\nimport numpy as np\nimport pandas as pd\nimport psutil # noqa # pylint: disable=unused-import\nimport pytest\n\nfrom bentoml.adapters import DataframeInput\nfrom bentoml.adapters.dataframe_input import read_dataframes_from_json_n_csv\nfrom bentoml.utils.csv import csv_splitlines\nfrom bentoml.utils.dataframe_util import guess_orient\n\ntry:\n from unittest.mock import MagicMock\nexcept ImportError:\n from mock import MagicMock\n\n\ndef test_dataframe_request_schema():\n input_adapter = DataframeInput(\n dtype={\"col1\": \"int\", \"col2\": \"float\", \"col3\": \"string\"}\n )\n\n schema = input_adapter.request_schema[\"application/json\"][\"schema\"]\n assert \"object\" == schema[\"type\"]\n assert 3 == len(schema[\"properties\"])\n assert \"array\" == schema[\"properties\"][\"col1\"][\"type\"]\n assert \"integer\" == schema[\"properties\"][\"col1\"][\"items\"][\"type\"]\n assert \"number\" == schema[\"properties\"][\"col2\"][\"items\"][\"type\"]\n assert \"string\" == schema[\"properties\"][\"col3\"][\"items\"][\"type\"]\n\n\ndef test_dataframe_handle_cli(capsys, make_api, tmpdir):\n def test_func(df):\n return df[\"name\"]\n\n input_adapter = DataframeInput()\n api = make_api(input_adapter, test_func)\n\n json_file = tmpdir.join(\"test.json\")\n with open(str(json_file), \"w\") as f:\n f.write('[{\"name\": \"john\",\"game\": \"mario\",\"city\": \"sf\"}]')\n\n test_args = [\"--input-file\", str(json_file)]\n api.handle_cli(test_args)\n out, _ = capsys.readouterr()\n assert \"john\" in out\n\n\ndef test_dataframe_handle_aws_lambda_event(make_api):\n test_content = '[{\"name\": \"john\",\"game\": \"mario\",\"city\": \"sf\"}]'\n\n def test_func(df):\n return df[\"name\"]\n\n input_adapter = DataframeInput()\n api = make_api(input_adapter, test_func)\n event = {\n \"headers\": {\"Content-Type\": \"application/json\"},\n \"body\": test_content,\n }\n response = api.handle_aws_lambda_event(event)\n assert response[\"statusCode\"] == 200\n assert response[\"body\"] == '[{\"name\":\"john\"}]'\n\n event_without_content_type_header = {\n \"headers\": {},\n \"body\": test_content,\n }\n response = api.handle_aws_lambda_event(event_without_content_type_header)\n assert response[\"statusCode\"] == 200\n assert response[\"body\"] == '[{\"name\":\"john\"}]'\n\n event_with_bad_input = {\n \"headers\": {},\n \"body\": \"bad_input_content\",\n }\n response = api.handle_aws_lambda_event(event_with_bad_input)\n assert response[\"statusCode\"] == 400\n\n\ndef test_dataframe_handle_request_csv(make_api):\n def test_func(df):\n return df[\"name\"]\n\n input_adapter = DataframeInput()\n api = make_api(input_adapter, test_func)\n csv_data = b'name,game,city\\njohn,mario,sf'\n request = MagicMock(spec=flask.Request)\n request.headers = {'Content-Type': 'text/csv'}\n request.get_data.return_value = csv_data\n\n result = api.handle_request(request)\n assert result.get_data().decode('utf-8') == '[{\"name\":\"john\"}]'\n\n\ndef assert_df_equal(left: pd.DataFrame, right: pd.DataFrame):\n '''\n Compare two instances of pandas.DataFrame ignoring index and columns\n '''\n try:\n left_array = left.values\n right_array = right.values\n if right_array.dtype == np.float:\n np.testing.assert_array_almost_equal(left_array, right_array)\n else:\n np.testing.assert_array_equal(left_array, right_array)\n except AssertionError:\n raise AssertionError(\n f\"\\n{left.to_string()}\\n is not equal to \\n{right.to_string()}\\n\"\n )\n\n\nDF_CASES = (\n pd.DataFrame(np.random.rand(1, 3)),\n pd.DataFrame(np.random.rand(2, 3)),\n pd.DataFrame(np.random.rand(2, 3), columns=['A', 'B', 'C']),\n pd.DataFrame([\"str1\", \"str2\", \"str3\"]), # single dim sting array\n pd.DataFrame([np.nan]), # special values\n pd.DataFrame([math.nan]), # special values\n pd.DataFrame([\" \", 'a\"b', \"a,b\", \"a\\nb\"]), # special values\n pd.DataFrame({\"test\": [\" \", 'a\"b', \"a,b\", \"a\\nb\"]}), # special values\n # pd.Series(np.random.rand(2)), # TODO: Series support\n # pd.DataFrame([\"\"]), # TODO: -> NaN\n)\n\n\[email protected](params=DF_CASES)\ndef df(request):\n return request.param\n\n\[email protected](params=pytest.DF_ORIENTS)\ndef orient(request):\n return request.param\n\n\ndef test_batch_read_dataframes_from_mixed_json_n_csv(df):\n test_datas = []\n test_types = []\n\n # test content_type=application/json with various orients\n for orient in pytest.DF_ORIENTS:\n try:\n assert_df_equal(df, pd.read_json(df.to_json(orient=orient)))\n except (AssertionError, ValueError):\n # skip cases not supported by official pandas\n continue\n\n test_datas.extend([df.to_json(orient=orient).encode()] * 3)\n test_types.extend(['json'] * 3)\n\n test_datas.extend([df.to_csv(index=False).encode()] * 3)\n test_types.extend(['csv'] * 3)\n\n df_merged, counts = read_dataframes_from_json_n_csv(test_datas, test_types)\n i = 0\n for count in counts:\n assert_df_equal(df_merged[i : i + count], df)\n i += count\n\n\ndef test_batch_read_dataframes_from_csv_other_CRLF(df):\n csv_str = df.to_csv(index=False)\n\n if '\\r\\n' in csv_str:\n csv_str = '\\n'.join(csv_splitlines(csv_str)).encode()\n else:\n csv_str = '\\r\\n'.join(csv_splitlines(csv_str)).encode()\n df_merged, _ = read_dataframes_from_json_n_csv([csv_str], ['csv'])\n assert_df_equal(df_merged, df)\n\n\ndef test_batch_read_dataframes_from_json_of_orients(df, orient):\n test_datas = [df.to_json(orient=orient).encode()] * 3\n test_types = ['json'] * 3\n df_merged, counts = read_dataframes_from_json_n_csv(test_datas, test_types, orient)\n i = 0\n for count in counts:\n assert_df_equal(df_merged[i : i + count], df)\n i += count\n\n\ndef test_batch_read_dataframes_from_json_with_wrong_orients(df, orient):\n test_datas = [df.to_json(orient='table').encode()] * 3\n test_types = ['json'] * 3\n\n df_merged, counts = read_dataframes_from_json_n_csv(test_datas, test_types, orient)\n assert not df_merged\n for count in counts:\n assert not count\n\n\ndef test_batch_read_dataframes_from_json_in_mixed_order():\n # different column order when orient=records\n df_json = b'[{\"A\": 1, \"B\": 2, \"C\": 3}, {\"C\": 6, \"A\": 2, \"B\": 4}]'\n df_merged, counts = read_dataframes_from_json_n_csv([df_json], ['json'])\n i = 0\n for count in counts:\n assert_df_equal(df_merged[i : i + count], pd.read_json(df_json))\n i += count\n\n # different row/column order when orient=columns\n df_json1 = b'{\"A\": {\"1\": 1, \"2\": 2}, \"B\": {\"1\": 2, \"2\": 4}, \"C\": {\"1\": 3, \"2\": 6}}'\n df_json2 = b'{\"B\": {\"1\": 2, \"2\": 4}, \"A\": {\"1\": 1, \"2\": 2}, \"C\": {\"1\": 3, \"2\": 6}}'\n df_json3 = b'{\"A\": {\"1\": 1, \"2\": 2}, \"B\": {\"2\": 4, \"1\": 2}, \"C\": {\"1\": 3, \"2\": 6}}'\n df_merged, counts = read_dataframes_from_json_n_csv(\n [df_json1, df_json2, df_json3], ['json'] * 3\n )\n i = 0\n for count in counts:\n assert_df_equal(\n df_merged[i : i + count][[\"A\", \"B\", \"C\"]],\n pd.read_json(df_json1)[[\"A\", \"B\", \"C\"]],\n )\n i += count\n\n\ndef test_guess_orient(df, orient):\n json_str = df.to_json(orient=orient)\n guessed_orient = guess_orient(json.loads(json_str), strict=True)\n assert orient == guessed_orient or orient in guessed_orient\n\n\[email protected]('not psutil.POSIX')\ndef test_benchmark_load_dataframes():\n '''\n read_dataframes_from_json_n_csv should be 30x faster than pd.read_json + pd.concat\n '''\n test_count = 50\n\n dfs = [pd.DataFrame(np.random.rand(10, 100)) for _ in range(test_count)]\n inputs = [df.to_json().encode() for df in dfs]\n\n time_st = time.time()\n dfs = [pd.read_json(i) for i in inputs]\n result1 = pd.concat(dfs)\n time1 = time.time() - time_st\n\n time_st = time.time()\n result2, _ = read_dataframes_from_json_n_csv(\n inputs, itertools.repeat('json'), 'columns'\n )\n\n time2 = time.time() - time_st\n assert_df_equal(result1, result2)\n\n # 5 is just an estimate on the smaller end, which should be true for most\n # development machines and Github actions CI environment, the actual ratio depends\n # on the hardware and available computing resource\n assert time1 / time2 > 5\n"
] | [
[
"pandas.DataFrame",
"numpy.testing.assert_array_equal",
"pandas.read_json",
"numpy.testing.assert_array_almost_equal",
"numpy.random.rand",
"pandas.concat"
]
] |
SsisyphusTao/TensorRT | [
"69f5a5093a39184e137a55c908d5c4d1340b009a"
] | [
"tools/Polygraphy/tests/comparator/test_comparator.py"
] | [
"#\n# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\nimport subprocess as sp\n\nimport numpy as np\nimport pytest\nimport tensorrt as trt\nfrom polygraphy.backend.onnx import BytesFromOnnx, OnnxFromTfGraph, GsFromOnnx\nfrom polygraphy.backend.onnxrt import OnnxrtRunner, SessionFromOnnx\nfrom polygraphy.backend.pluginref import PluginRefRunner\nfrom polygraphy.backend.tf import SessionFromGraph, TfRunner\nfrom polygraphy.backend.trt import EngineFromNetwork, NetworkFromOnnxBytes, TrtRunner\nfrom polygraphy.exception import PolygraphyException\nfrom polygraphy.comparator import Comparator, CompareFunc, DataLoader, IterationResult, PostprocessFunc, RunResults\nfrom polygraphy import mod\nfrom tests.models.meta import ONNX_MODELS, TF_MODELS\n\n\nclass TestComparator(object):\n def test_warmup_runs(self):\n onnx_loader = ONNX_MODELS[\"identity\"].loader\n runner = OnnxrtRunner(SessionFromOnnx(onnx_loader))\n run_results = Comparator.run([runner], warm_up=2)\n assert len(run_results[runner.name]) == 1\n\n def test_list_as_data_loader(self):\n onnx_loader = ONNX_MODELS[\"identity\"].loader\n runner = OnnxrtRunner(SessionFromOnnx(onnx_loader), name=\"onnx_runner\")\n\n data = [{\"x\": np.ones((1, 1, 2, 2), dtype=np.float32)}] * 2\n run_results = Comparator.run([runner], data_loader=data)\n iter_results = run_results[\"onnx_runner\"]\n assert len(iter_results) == 2\n for actual, expected in zip(iter_results, data):\n assert np.all(actual[\"y\"] == expected[\"x\"])\n\n def test_generator_as_data_loader(self):\n onnx_loader = ONNX_MODELS[\"identity\"].loader\n runner = OnnxrtRunner(SessionFromOnnx(onnx_loader), name=\"onnx_runner\")\n\n def data():\n for feed_dict in [{\"x\": np.ones((1, 1, 2, 2), dtype=np.float32)}] * 2:\n yield feed_dict\n\n run_results = Comparator.run([runner], data_loader=data())\n iter_results = run_results[\"onnx_runner\"]\n assert len(iter_results) == 2\n for actual, expected in zip(iter_results, data()):\n assert np.all(actual[\"y\"] == expected[\"x\"])\n\n def test_multiple_runners(self):\n load_tf = TF_MODELS[\"identity\"].loader\n build_tf_session = SessionFromGraph(load_tf)\n onnx_model = OnnxFromTfGraph(load_tf)\n load_serialized_onnx = BytesFromOnnx(onnx_model)\n build_onnxrt_session = SessionFromOnnx(load_serialized_onnx)\n load_engine = EngineFromNetwork(NetworkFromOnnxBytes(load_serialized_onnx))\n gs_graph = GsFromOnnx(onnx_model)\n\n runners = [\n TfRunner(build_tf_session),\n OnnxrtRunner(build_onnxrt_session),\n PluginRefRunner(gs_graph),\n TrtRunner(load_engine),\n ]\n\n run_results = Comparator.run(runners)\n compare_func = CompareFunc.simple(check_shapes=mod.version(trt.__version__) >= mod.version(\"7.0\"))\n assert bool(Comparator.compare_accuracy(run_results, compare_func=compare_func))\n assert len(list(run_results.values())[0]) == 1 # Default number of iterations\n\n def test_postprocess(self):\n onnx_loader = ONNX_MODELS[\"identity\"].loader\n run_results = Comparator.run([OnnxrtRunner(SessionFromOnnx(onnx_loader))], use_subprocess=True)\n # Output shape is (1, 1, 2, 2)\n postprocessed = Comparator.postprocess(run_results, postprocess_func=PostprocessFunc.topk_func(k=1, axis=-1))\n for _, results in postprocessed.items():\n for result in results:\n for _, output in result.items():\n assert output.shape == (1, 1, 2, 1)\n\n def test_errors_do_not_hang(self):\n # Should error because interface is not implemented correctly.\n class FakeRunner(object):\n def __init__(self):\n self.name = \"fake\"\n\n runners = [FakeRunner()]\n with pytest.raises(PolygraphyException):\n Comparator.run(runners, use_subprocess=True, subprocess_polling_interval=1)\n\n def test_segfault_does_not_hang(self):\n def raise_called_process_error():\n class FakeSegfault(sp.CalledProcessError):\n pass\n\n raise FakeSegfault(-11, [\"simulate\", \"segfault\"])\n\n runners = [TrtRunner(EngineFromNetwork(raise_called_process_error))]\n with pytest.raises(PolygraphyException):\n Comparator.run(runners, use_subprocess=True, subprocess_polling_interval=1)\n\n def test_multirun_outputs_are_different(self):\n onnx_loader = ONNX_MODELS[\"identity\"].loader\n runner = TrtRunner(EngineFromNetwork(NetworkFromOnnxBytes(onnx_loader)))\n run_results = Comparator.run([runner], data_loader=DataLoader(iterations=2))\n\n iteration0 = run_results[runner.name][0]\n iteration1 = run_results[runner.name][1]\n for name in iteration0.keys():\n assert np.any(iteration0[name] != iteration1[name])\n\n def test_validate_nan(self):\n run_results = RunResults()\n run_results[\"fake-runner\"] = [IterationResult(outputs={\"x\": np.array(np.nan)})]\n assert not Comparator.validate(run_results)\n\n def test_validate_inf(self):\n run_results = RunResults()\n run_results[\"fake-runner\"] = [IterationResult(outputs={\"x\": np.array(np.inf)})]\n assert not Comparator.validate(run_results, check_inf=True)\n\n def test_dim_param_trt_onnxrt(self):\n load_onnx_bytes = ONNX_MODELS[\"dim_param\"].loader\n build_onnxrt_session = SessionFromOnnx(load_onnx_bytes)\n load_engine = EngineFromNetwork(NetworkFromOnnxBytes(load_onnx_bytes))\n\n runners = [\n OnnxrtRunner(build_onnxrt_session),\n TrtRunner(load_engine),\n ]\n\n run_results = Comparator.run(runners)\n compare_func = CompareFunc.simple(check_shapes=mod.version(trt.__version__) >= mod.version(\"7.0\"))\n assert bool(Comparator.compare_accuracy(run_results, compare_func=compare_func))\n assert len(list(run_results.values())[0]) == 1 # Default number of iterations\n"
] | [
[
"numpy.any",
"numpy.ones",
"numpy.all",
"numpy.array"
]
] |
larssl780/thin_wrappers | [
"c0791d76a734303708892a25cce2e237caf9920a"
] | [
"tests/test_db_utils.py"
] | [
"import pytest\nimport pathlib\nimport sys\n\nimport requests\nimport io\nimport zipfile\nimport tempfile\nimport pandas as pd\nimport os\nHERE = pathlib.Path(__file__).resolve().parent\n\n\n\n# insert at 1, 0 is the script path (or '' in REPL)\n# temporary hack until package is published and we can inherit from there:\n\nsys.path.insert(1, '%s/thin_wrappers' % HERE.parent)\nimport db_utils as db # NOQA: E402\n\n\n\ndef headers():\n return {'Accept': 'application/json, text/plain, */*',\n 'Accept-Language': 'en-US,en;q=0.5',\n 'Cache-Control': 'no-cache',\n 'Connection': 'keep-alive',\n 'DNT': '1',\n 'Pragma': 'no-cache',\n 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A',\n }\n\n\ndef download_data():\n url = 'https://eforexcel.com/wp/wp-content/uploads/2017/07/100-CC-Records.zip'\n res = requests.get(url, headers=headers())\n filebytes = io.BytesIO(res.content)\n tmp = zipfile.ZipFile(filebytes)\n temp = tempfile.NamedTemporaryFile(delete=False, suffix='.csv')\n with open(temp.name, 'wb') as fp:\n fp.write(tmp.read('100 CC Records.csv'))\n datum = pd.read_csv(temp.name, encoding='cp1252')\n return datum\n\n\ndef test_database():\n \"\"\"Test that it works writig data to an sqlite db and then read it.\n \"\"\"\n df = download_data()\n\n db.write_db_table('dummy', df, 'replace', 'test_db.sqlite')\n\n assert os.path.exists('test_db.sqlite'), \"Did not find database?!\"\n\n n_records = len(df)\n from_db = db.read_sql_table('dummy', 'test_db.sqlite')\n assert len(\n from_db) == n_records, \"Number of records does not match between database and data!\"\n db.write_db_table('dummy', df, 'append', 'test_db.sqlite')\n from_db = db.read_sql_table('dummy', 'test_db.sqlite')\n assert len(from_db) == (\n 2 * n_records), \"Number of records does not match between database and data!\"\n\n\nif __name__ == '__main__':\n pytest.main([__file__])\n"
] | [
[
"pandas.read_csv"
]
] |
rdenise/virome_pipeline | [
"3c629aef75b184bf39f2d14043f94e8787e3ea14"
] | [
"workflow/scripts/combine_virsorter_virfinder.py"
] | [
"from Bio import SeqIO\nimport pandas as pd\nimport sys\nimport os\n\n# Put error and out into the log file\nsys.stderr = sys.stdout = open(snakemake.log[0], \"w\")\n\n###########################################################\n###########################################################\n\n# List that will contains all the contigs to filter\nall_contig_ids = []\n\n# Dataframe that contains all the informations about\noutput_df = pd.DataFrame(columns=[\"contig_id\", \"virsorter_cat\", \"deepvirfinder\"])\n\n# Get all the names from the virsorter keep2 list\nids_virsorter_keep2 = snakemake.input.ids_virsorter_keep2_checked\n\nwith open(ids_virsorter_keep2) as r_file:\n r_file.readline()\n\n for line in r_file:\n rstrip_line = line.rstrip()\n rstrip_line = rstrip_line.split(\"||\")[0]\n\n all_contig_ids.append(rstrip_line)\n\n output_df.at[rstrip_line, \"contig_id\"] = rstrip_line\n output_df.at[rstrip_line, \"virsorter_cat\"] = \"keep2_checked\"\n\n# Get all the names from the virsorter keep1 list and remove redondant name\nids_virsorter_keep1 = snakemake.input.ids_virsorter_keep1\n\nwith open(ids_virsorter_keep1) as r_file:\n r_file.readline()\n\n for line in r_file:\n rstrip_line = line.rstrip()\n rstrip_line = rstrip_line.split(\"||\")[0]\n\n if rstrip_line not in all_contig_ids:\n all_contig_ids.append(rstrip_line)\n\n output_df.at[rstrip_line, \"contig_id\"] = rstrip_line\n output_df.at[rstrip_line, \"virsorter_cat\"] = \"keep1\"\n\n# Get all the names from the deepvirfinder list and remove redondant name\nids_virfinder = snakemake.input.ids_virfinder\n\nwith open(ids_virfinder) as r_file:\n r_file.readline()\n\n for line in r_file:\n rstrip_line = line.rstrip()\n\n output_df.at[rstrip_line, \"contig_id\"] = rstrip_line\n output_df.at[rstrip_line, \"deepvirfinder\"] = \"Yes\"\n\n if rstrip_line not in all_contig_ids:\n all_contig_ids.append(rstrip_line)\n\n# Fill the informations missing now the list of contigs we keep is set\ndict_map_virsorter = {}\n\nfiles_with_info = {\n snakemake.input.ids_virsorter_keep2_suspicious: \"keep2_suspicious\",\n snakemake.input.ids_virsorter_manual_check: \"to_manual_check\",\n snakemake.input.ids_virsorter_discarded: \"discarded\",\n}\n\nfor file_ids in files_with_info:\n with open(file_ids) as r_file:\n r_file.readline()\n\n for line in r_file:\n rstrip_line = line.rstrip()\n rstrip_line = rstrip_line.split(\"||\")[0]\n\n if rstrip_line not in all_contig_ids:\n dict_map_virsorter[rstrip_line] = files_with_info[file_ids]\n\n# Fill the dataframe\nlist_contig2add_virsorter_cat = list(dict_map_virsorter.keys())\noutput_df.loc[\n output_df.contig_id.isin(list_contig2add_virsorter_cat), \"virsorter_cat\"\n] = output_df.loc[\n output_df.contig_id.isin(list_contig2add_virsorter_cat), \"contig_id\"\n].map(\n dict_map_virsorter\n)\n\noutput_df.fillna(\"No\", inplace=True)\n\n# Parse the fasta of the contig and create the new one\nfasta_contigs = snakemake.input.contigs\n\nwith open(snakemake.output.fasta, \"w\") as w_file:\n with open(snakemake.output.translation_table, \"w\") as tsv_file:\n tsv_file.write(\"old_contig_name\\tnew_contig_name\\n\")\n\n parser = SeqIO.parse(fasta_contigs, \"fasta\")\n\n for contig in parser:\n if contig.id in all_contig_ids:\n contig_id = f\"{snakemake.wildcards.sample}-{contig.id}\".replace(\n \"_\", \"-\"\n )\n\n tsv_file.write(f\"{contig.id}\\t{contig_id}\\n\")\n\n contig.id = contig_id\n contig.name = \"\"\n contig.description = \"\"\n\n SeqIO.write(contig, w_file, \"fasta\")\n\noutput_df.to_csv(snakemake.output.tsv, sep=\"\\t\", index=False)\n\n###########################################################\n###########################################################\n"
] | [
[
"pandas.DataFrame"
]
] |
CipiOrhei/eecvf | [
"759fb2127c8d65a570ba2df536ff8429ccf5bdf2"
] | [
"Benchmarking/CM_Benchmark/basic_benchmark/rde.py"
] | [
"import math\r\nimport os\r\nfrom math import log10\r\n# noinspection PyPackageRequirements\r\nimport cv2\r\nimport numpy as np\r\nfrom scipy.ndimage import distance_transform_edt\r\n\r\nimport config_main\r\nfrom Utils.log_handler import log_setup_info_to_console, log_error_to_console, log_benchmark_info_to_console\r\nfrom Benchmarking.Util.image_parsing import find_img_extension\r\nfrom Benchmarking.Config.create_benchmark_job import set_gt_location, set_image_set, set_input_location, job_set\r\n\r\n\r\ndef rde_calc(img, img_gt, k_value):\r\n \"\"\"\r\n Dubuisson, M.P.; Jain, A.K. A modified Hausdorff distance for object matching. IEEE ICPR 1994, 1, 566-568\r\n http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.1.8155&rep=rep1&type=pdf\r\n :param img: edge map resulting of algorithm\r\n :param img_gt: ground truth image\r\n :return: psnr value for image\r\n \"\"\"\r\n # calculate distances\r\n dist_gt = distance_transform_edt(np.invert(img_gt))\r\n dist_dc = distance_transform_edt(np.invert(img))\r\n\r\n # calculate sum(d^k(D))\r\n sum_dc = 0.0\r\n sum_gt = 0.0\r\n left = 0.0\r\n right = 0.0\r\n\r\n for i in range(0, img_gt.shape[0]):\r\n for j in range(0, img_gt.shape[1]):\r\n if img_gt[i, j]:\r\n sum_dc += dist_dc[i, j] ** k_value\r\n\r\n for i in range(0, img.shape[0]):\r\n for j in range(0, img.shape[1]):\r\n if img[i, j]:\r\n sum_gt += dist_gt[i, j] ** k_value\r\n\r\n cn_cd = np.count_nonzero(img)\r\n cn_gt = np.count_nonzero(img_gt)\r\n\r\n if cn_cd != 0 :\r\n left = math.pow(sum_gt / cn_cd, 1.0/k_value)\r\n if cn_gt != 0:\r\n right = math.pow(sum_dc / cn_gt, 1.0/k_value)\r\n\r\n if cn_cd==0:\r\n rde = 1000\r\n else:\r\n rde = left + right\r\n\r\n return rde\r\n\r\n\r\n# noinspection PyPep8Naming\r\ndef run_RDE_benchmark(input_location: str, gt_location: str,\r\n raw_image: str, jobs_set: list,\r\n k: int):\r\n \"\"\"\r\n xxx\r\n :param input_location: location of algorithm images\r\n :param gt_location: location of gt images\r\n :param raw_image: location of raw images\r\n :param jobs_set: algo sets to evaluate\r\n :return: None\r\n \"\"\"\r\n\r\n set_gt_location(gt_location)\r\n set_input_location(input_location)\r\n set_image_set(raw_image)\r\n job_set(jobs_set)\r\n\r\n run_CM_benchmark_RDE(k)\r\n\r\n\r\ndef run_CM_benchmark_RDE(k_value):\r\n \"\"\"\r\n :return:\r\n \"\"\"\r\n log_setup_info_to_console(\"BENCHMARKING CM RDEK\" + int(k_value).__str__())\r\n idx = 0\r\n\r\n for set in config_main.BENCHMARK_SETS:\r\n log_benchmark_info_to_console('Current set: {number}\\{total} : {set}'.format(number=idx, total=len(config_main.BENCHMARK_SETS), set=set))\r\n idx += 1\r\n\r\n # try:\r\n if True:\r\n # Write results to disk\r\n results_path = os.path.join(os.getcwd(), config_main.BENCHMARK_RESULTS, \"RDEK\" + int(k_value).__str__())\r\n\r\n if not os.path.exists(results_path):\r\n os.makedirs(results_path)\r\n\r\n csv = open(os.path.join(results_path, set + '.log'), \"w+\")\r\n csv.write('Per image (#, RDEK' + int(k_value).__str__() + ':\\n')\r\n # log_benchmark_info_to_console('Per image (#, RDE):\\n')\r\n\r\n avg = 0\r\n count = 0\r\n\r\n for file in config_main.BENCHMARK_SAMPLE_NAMES:\r\n # find extension of images and gt_images\r\n if config_main.APPL_SAVE_JOB_NAME is True:\r\n img_extension = find_img_extension(os.path.join(config_main.BENCHMARK_INPUT_LOCATION, set, set + '_' + file))\r\n else:\r\n img_extension = find_img_extension(os.path.join(config_main.BENCHMARK_INPUT_LOCATION, set, file))\r\n\r\n gt_extension = find_img_extension(os.path.join(config_main.BENCHMARK_GT_LOCATION, file))\r\n\r\n path_img_gt = os.path.join(config_main.BENCHMARK_GT_LOCATION, file + gt_extension)\r\n\r\n if config_main.APPL_SAVE_JOB_NAME is True:\r\n path_img_al = os.path.join(config_main.BENCHMARK_INPUT_LOCATION, set, set + '_' + file + img_extension)\r\n else:\r\n path_img_al = os.path.join(config_main.BENCHMARK_INPUT_LOCATION, set, file + img_extension)\r\n\r\n img_gt = cv2.cvtColor(cv2.imread(path_img_gt), cv2.COLOR_BGR2GRAY)\r\n img_al = cv2.cvtColor(cv2.imread(path_img_al), cv2.COLOR_BGR2GRAY)\r\n\r\n try:\r\n val = rde_calc(img_al, img_gt, k_value)\r\n avg += val\r\n count += 1\r\n csv.write('{:<10s} {:<10.6f}\\n'.format(file, val))\r\n # log_benchmark_info_to_console('{:<10s} {:<10.6f}\\n'.format(file, val))\r\n except Exception as ex:\r\n log_error_to_console(\"BENCHMARK CM RDEK{val}: {file}\".format(val=int(k_value).__str__(), file=file), ex.__str__())\r\n\r\n log_benchmark_info_to_console('RDEK{val}: {set:<10s} {cnt:<10.6f}\\n'.format(val=int(k_value).__str__(), set=set, cnt=avg / count))\r\n csv.write('RDEK{val}: {set:<10s} {cnt:<10.6f}\\n'.format(val=int(k_value).__str__(), set=set, cnt=avg / count))\r\n\r\n # except Exception as ex:\r\n # log_error_to_console('BENCHMARK CM RDEK' + int(k_value).__str__() + 'NOK', ex.__str__())\r\n\r\n\r\nif __name__ == \"__main__\":\r\n pass\r\n"
] | [
[
"numpy.invert",
"numpy.count_nonzero"
]
] |
zhousanfu/paddle-demo | [
"56860c5241874fe6111def46ea2f3f91e3ba80de"
] | [
"PaddleCV/tracking/ltr/data/loader.py"
] | [
"import os\nimport sys\n\nimport dataflow as df\nimport numpy as np\n\n\nclass LTRLoader(df.DataFlow):\n \"\"\"\n Data loader. Combines a dataset and a sampler, and provides\n single- or multi-process iterators over the dataset.\n\n Note: an additional option stack_dim is available to\n select along which dimension the data should be stacked to form a batch.\n\n Arguments:\n dataset (Dataset): dataset from which to load the data.\n batch_size (int, optional): how many samples per batch to load\n (default: 1).\n shuffle (bool, optional): set to ``True`` to have the data reshuffled\n at every epoch (default: False).\n sampler (Sampler, optional): defines the strategy to draw samples from\n the dataset. If specified, ``shuffle`` must be False.\n batch_sampler (Sampler, optional): like sampler, but returns a batch of\n indices at a time. Mutually exclusive with batch_size, shuffle,\n sampler, and drop_last.\n num_workers (int, optional): how many subprocesses to use for data\n loading. 0 means that the data will be loaded in the main process.\n (default: 0)\n collate_fn (callable, optional): merges a list of samples to form a mini-batch.\n stack_dim (int): Dimension along which to stack to form the batch. (default: 0)\n pin_memory (bool, optional): If ``True``, the data loader will copy tensors\n into CUDA pinned memory before returning them.\n drop_last (bool, optional): set to ``True`` to drop the last incomplete batch,\n if the dataset size is not divisible by the batch size. If ``False`` and\n the size of dataset is not divisible by the batch size, then the last batch\n will be smaller. (default: False)\n timeout (numeric, optional): if positive, the timeout value for collecting a batch\n from workers. Should always be non-negative. (default: 0)\n worker_init_fn (callable, optional): If not None, this will be called on each\n worker subprocess with the worker id (an int in ``[0, num_workers - 1]``) as\n input, after seeding and before data loading. (default: None)\n\n\n .. warning:: If ``spawn`` start method is used, :attr:`worker_init_fn` cannot be an\n unpicklable object, e.g., a lambda function.\n \"\"\"\n\n __initialized = False\n\n def __init__(self,\n name,\n dataset,\n training=True,\n batch_size=1,\n shuffle=False,\n sampler=None,\n batch_sampler=None,\n num_workers=0,\n epoch_interval=1,\n collate_fn=None,\n stack_dim=0,\n pin_memory=False,\n drop_last=False,\n timeout=0,\n worker_init_fn=None):\n\n super().__init__()\n\n ds = df.RepeatedData(dataset, -1)\n ds = df.MultiProcessRunnerZMQ(ds, num_proc=num_workers, hwm=300)\n # ds = df.MultiThreadRunner(lambda: ds, num_prefetch=1024, num_thread=num_workers)\n ds = df.BatchData(ds, batch_size)\n self.ds = ds\n\n self.name = name\n self.training = training\n self.epoch_interval = epoch_interval\n self.stack_dim = stack_dim\n self.batches_per_epoch = len(dataset) // batch_size\n\n def __len__(self):\n return self.batches_per_epoch\n\n def __iter__(self):\n if not self.__initialized:\n self.reset_state()\n self.__initialized = True\n\n for d in self.ds:\n if self.stack_dim > 0:\n for k, v in d.items():\n if len(v.shape) >= self.stack_dim + 1:\n d[k] = np.swapaxes(v, 0, self.stack_dim)\n yield d\n\n def reset_state(self):\n self.ds.reset_state()\n"
] | [
[
"numpy.swapaxes"
]
] |
ximingxing/Learning-To-Learn | [
"0135cb41521a61d1f3248cf3fe409e51f824fe25"
] | [
"learningTolearn/backbone/common.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\n Description : Common routines for models in PyTorch.\n Author : xxm\n\"\"\"\n\n__all__ = ['round_channels', 'Identity', 'Swish', 'HSigmoid', 'HSwish', 'get_activation_layer', 'conv1x1', 'conv3x3',\n 'depthwise_conv3x3', 'ConvBlock', 'conv1x1_block', 'conv3x3_block', 'conv7x7_block', 'dwconv_block',\n 'dwconv3x3_block', 'dwconv5x5_block', 'dwsconv3x3_block', 'PreConvBlock', 'pre_conv1x1_block',\n 'pre_conv3x3_block', 'InterpolationBlock', 'ChannelShuffle', 'ChannelShuffle2', 'SEBlock', 'IBN',\n 'DualPathSequential', 'Concurrent', 'SequentialConcurrent', 'ParametricSequential', 'ParametricConcurrent',\n 'Hourglass', 'SesquialteralHourglass', 'MultiOutputSequential', 'Flatten']\n\nimport math\nfrom inspect import isfunction\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchmeta.modules import MetaModule, MetaSequential, MetaConv2d, MetaBatchNorm2d\n\n\ndef round_channels(channels,\n divisor=8):\n \"\"\"\n Round weighted channel number (make divisible operation).\n Parameters:\n ----------\n channels : int or float\n Original number of channels.\n divisor : int, default 8\n Alignment value.\n Returns\n -------\n int\n Weighted number of channels.\n \"\"\"\n rounded_channels = max(int(channels + divisor / 2.0) // divisor * divisor, divisor)\n if float(rounded_channels) < 0.9 * channels:\n rounded_channels += divisor\n return rounded_channels\n\n\nclass Identity(nn.Module):\n \"\"\"\n Identity block.\n \"\"\"\n\n def __init__(self):\n super(Identity, self).__init__()\n\n def forward(self, x):\n return x\n\n\nclass Swish(nn.Module):\n \"\"\"\n Swish activation function from 'Searching for Activation Functions,' https://arxiv.org/abs/1710.05941.\n \"\"\"\n\n def forward(self, x):\n return x * torch.sigmoid(x)\n\n\nclass HSigmoid(nn.Module):\n \"\"\"\n Approximated sigmoid function, so-called hard-version of sigmoid from 'Searching for MobileNetV3,'\n https://arxiv.org/abs/1905.02244.\n \"\"\"\n\n def forward(self, x):\n return F.relu6(x + 3.0, inplace=True) / 6.0\n\n\nclass HSwish(nn.Module):\n \"\"\"\n H-Swish activation function from 'Searching for MobileNetV3,' https://arxiv.org/abs/1905.02244.\n Parameters:\n ----------\n inplace : bool\n Whether to use inplace version of the module.\n \"\"\"\n\n def __init__(self, inplace=False):\n super(HSwish, self).__init__()\n self.inplace = inplace\n\n def forward(self, x):\n return x * F.relu6(x + 3.0, inplace=self.inplace) / 6.0\n\n\ndef get_activation_layer(activation):\n \"\"\"\n Create activation layer from string/function.\n Parameters:\n ----------\n activation : function, or str, or nn.Module\n Activation function or name of activation function.\n Returns\n -------\n nn.Module\n Activation layer.\n \"\"\"\n assert (activation is not None)\n if isfunction(activation):\n return activation()\n elif isinstance(activation, str):\n if activation == \"relu\":\n return nn.ReLU(inplace=True)\n elif activation == \"relu6\":\n return nn.ReLU6(inplace=True)\n elif activation == \"swish\":\n return Swish()\n elif activation == \"hswish\":\n return HSwish(inplace=True)\n elif activation == \"sigmoid\":\n return nn.Sigmoid()\n elif activation == \"hsigmoid\":\n return HSigmoid()\n elif activation == \"identity\":\n return Identity()\n else:\n raise NotImplementedError()\n else:\n assert (isinstance(activation, nn.Module))\n return activation\n\n\ndef conv1x1(in_channels,\n out_channels,\n stride=1,\n groups=1,\n bias=False):\n \"\"\"\n Convolution 1x1 layer.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n groups : int, default 1\n Number of groups.\n bias : bool, default False\n Whether the layer uses a bias vector.\n \"\"\"\n return nn.Conv2d(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=1,\n stride=stride,\n groups=groups,\n bias=bias)\n\n\ndef conv3x3(in_channels,\n out_channels,\n stride=1,\n padding=1,\n dilation=1,\n groups=1,\n bias=False):\n \"\"\"\n Convolution 3x3 layer.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 1\n Padding value for convolution layer.\n groups : int, default 1\n Number of groups.\n bias : bool, default False\n Whether the layer uses a bias vector.\n \"\"\"\n return nn.Conv2d(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=3,\n stride=stride,\n padding=padding,\n dilation=dilation,\n groups=groups,\n bias=bias)\n\n\ndef depthwise_conv3x3(channels,\n stride):\n \"\"\"\n Depthwise convolution 3x3 layer.\n Parameters:\n ----------\n channels : int\n Number of input/output channels.\n strides : int or tuple/list of 2 int\n Strides of the convolution.\n \"\"\"\n return nn.Conv2d(\n in_channels=channels,\n out_channels=channels,\n kernel_size=3,\n stride=stride,\n padding=1,\n groups=channels,\n bias=False)\n\n\nclass ConvBlock(nn.Module):\n \"\"\"\n Standard convolution block with Batch normalization and activation.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n kernel_size : int or tuple/list of 2 int\n Convolution window size.\n stride : int or tuple/list of 2 int\n Strides of the convolution.\n padding : int or tuple/list of 2 int\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n groups : int, default 1\n Number of groups.\n bias : bool, default False\n Whether the layer uses a bias vector.\n use_bn : bool, default True\n Whether to use BatchNorm layer.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n\n def __init__(self,\n in_channels,\n out_channels,\n kernel_size,\n stride,\n padding,\n dilation=1,\n groups=1,\n bias=False,\n use_bn=True,\n bn_eps=1e-5,\n activation=(lambda: nn.ReLU(inplace=True))):\n super(ConvBlock, self).__init__()\n self.activate = (activation is not None)\n self.use_bn = use_bn\n\n self.conv = nn.Conv2d(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=stride,\n padding=padding,\n dilation=dilation,\n groups=groups,\n bias=bias)\n if self.use_bn:\n self.bn = nn.BatchNorm2d(\n num_features=out_channels,\n eps=bn_eps)\n if self.activate:\n self.activ = get_activation_layer(activation)\n\n def forward(self, x):\n x = self.conv(x)\n if self.use_bn:\n x = self.bn(x)\n if self.activate:\n x = self.activ(x)\n return x\n\n\nclass MetaConvBlock(MetaModule):\n \"\"\"\n Meta convolution block with Batch normalization and activation.\n Weight and\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n kernel_size : int or tuple/list of 2 int\n Convolution window size.\n stride : int or tuple/list of 2 int\n Strides of the convolution.\n padding : int or tuple/list of 2 int\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n groups : int, default 1\n Number of groups.\n bias : bool, default False\n Whether the layer uses a bias vector.\n use_bn : bool, default True\n Whether to use BatchNorm layer.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n\n def __init__(self,\n in_channels,\n out_channels,\n kernel_size,\n stride,\n padding,\n dilation=1,\n groups=1,\n bias=False,\n use_bn=True,\n bn_eps=1e-5,\n activation=(lambda: nn.ReLU(inplace=True))):\n super(MetaConvBlock, self).__init__()\n self.activate = (activation is not None)\n self.use_bn = use_bn\n\n self.conv = MetaConv2d(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=stride,\n padding=padding,\n dilation=dilation,\n groups=groups,\n bias=bias)\n if self.use_bn:\n self.bn = MetaBatchNorm2d(\n num_features=out_channels,\n eps=bn_eps)\n if self.activate:\n self.activ = get_activation_layer(activation)\n\n def forward(self, x, params=None):\n x = self.conv(x, params=self.get_subdict(params, 'conv'))\n if self.use_bn:\n x = self.bn(x, params=self.get_subdict(params, 'bn'))\n if self.activate:\n x = self.activ(x)\n return x\n\n\ndef conv1x1_block(in_channels,\n out_channels,\n stride=1,\n padding=0,\n groups=1,\n bias=False,\n use_bn=True,\n bn_eps=1e-5,\n activation=(lambda: nn.ReLU(inplace=True)),\n mode=''):\n \"\"\"\n 1x1 version of the standard convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 0\n Padding value for convolution layer.\n groups : int, default 1\n Number of groups.\n bias : bool, default False\n Whether the layer uses a bias vector.\n use_bn : bool, default True\n Whether to use BatchNorm layer.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n if mode == 'maml':\n return MetaConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=1,\n stride=stride,\n padding=padding,\n groups=groups,\n bias=bias,\n use_bn=use_bn,\n bn_eps=bn_eps,\n activation=activation)\n else:\n return ConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=1,\n stride=stride,\n padding=padding,\n groups=groups,\n bias=bias,\n use_bn=use_bn,\n bn_eps=bn_eps,\n activation=activation)\n\n\ndef conv3x3_block(in_channels,\n out_channels,\n stride=1,\n padding=1,\n dilation=1,\n groups=1,\n bias=False,\n use_bn=True,\n bn_eps=1e-5,\n activation=(lambda: nn.ReLU(inplace=True)),\n mode=''):\n \"\"\"\n 3x3 version of the standard convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 1\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n groups : int, default 1\n Number of groups.\n bias : bool, default False\n Whether the layer uses a bias vector.\n use_bn : bool, default True\n Whether to use BatchNorm layer.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n if mode == 'maml':\n return MetaConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=3,\n stride=stride,\n padding=padding,\n dilation=dilation,\n groups=groups,\n bias=bias,\n use_bn=use_bn,\n bn_eps=bn_eps,\n activation=activation)\n else:\n return ConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=3,\n stride=stride,\n padding=padding,\n dilation=dilation,\n groups=groups,\n bias=bias,\n use_bn=use_bn,\n bn_eps=bn_eps,\n activation=activation)\n\n\ndef conv5x5_block(in_channels,\n out_channels,\n stride=1,\n padding=2,\n dilation=1,\n groups=1,\n bias=False,\n bn_eps=1e-5,\n activation=(lambda: nn.ReLU(inplace=True)),\n mode=''):\n \"\"\"\n 5x5 version of the standard convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 2\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n groups : int, default 1\n Number of groups.\n bias : bool, default False\n Whether the layer uses a bias vector.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n if mode == 'maml':\n return MetaConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=5,\n stride=stride,\n padding=padding,\n dilation=dilation,\n groups=groups,\n bias=bias,\n bn_eps=bn_eps,\n activation=activation)\n else:\n return ConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=5,\n stride=stride,\n padding=padding,\n dilation=dilation,\n groups=groups,\n bias=bias,\n bn_eps=bn_eps,\n activation=activation)\n\n\ndef conv7x7_block(in_channels,\n out_channels,\n stride=1,\n padding=3,\n bias=False,\n use_bn=True,\n activation=(lambda: nn.ReLU(inplace=True)),\n mode='maml'):\n \"\"\"\n 7x7 version of the standard convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 3\n Padding value for convolution layer.\n bias : bool, default False\n Whether the layer uses a bias vector.\n use_bn : bool, default True\n Whether to use BatchNorm layer.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n if mode == 'maml':\n return MetaSequential(MetaConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=7,\n stride=stride,\n padding=padding,\n bias=bias,\n use_bn=use_bn,\n activation=activation))\n else:\n return ConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=7,\n stride=stride,\n padding=padding,\n bias=bias,\n use_bn=use_bn,\n activation=activation)\n\n\ndef dwconv_block(in_channels,\n out_channels,\n kernel_size,\n stride=1,\n padding=1,\n dilation=1,\n bias=False,\n use_bn=True,\n bn_eps=1e-5,\n activation=(lambda: nn.ReLU(inplace=True))):\n \"\"\"\n Depthwise version of the standard convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n kernel_size : int or tuple/list of 2 int\n Convolution window size.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 1\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n bias : bool, default False\n Whether the layer uses a bias vector.\n use_bn : bool, default True\n Whether to use BatchNorm layer.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n return ConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=stride,\n padding=padding,\n dilation=dilation,\n groups=out_channels,\n bias=bias,\n use_bn=use_bn,\n bn_eps=bn_eps,\n activation=activation)\n\n\ndef dwconv3x3_block(in_channels,\n out_channels,\n stride=1,\n padding=1,\n dilation=1,\n bias=False,\n bn_eps=1e-5,\n activation=(lambda: nn.ReLU(inplace=True))):\n \"\"\"\n 3x3 depthwise version of the standard convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 1\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n bias : bool, default False\n Whether the layer uses a bias vector.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n return dwconv_block(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=3,\n stride=stride,\n padding=padding,\n dilation=dilation,\n bias=bias,\n bn_eps=bn_eps,\n activation=activation)\n\n\ndef dwconv5x5_block(in_channels,\n out_channels,\n stride=1,\n padding=2,\n dilation=1,\n bias=False,\n bn_eps=1e-5,\n activation=(lambda: nn.ReLU(inplace=True))):\n \"\"\"\n 5x5 depthwise version of the standard convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 2\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n bias : bool, default False\n Whether the layer uses a bias vector.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function or name of activation function.\n \"\"\"\n return dwconv_block(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=5,\n stride=stride,\n padding=padding,\n dilation=dilation,\n bias=bias,\n bn_eps=bn_eps,\n activation=activation)\n\n\nclass DwsConvBlock(nn.Module):\n \"\"\"\n Depthwise separable convolution block with BatchNorms and activations at each convolution layers.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n kernel_size : int or tuple/list of 2 int\n Convolution window size.\n stride : int or tuple/list of 2 int\n Strides of the convolution.\n padding : int or tuple/list of 2 int\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n bias : bool, default False\n Whether the layer uses a bias vector.\n use_bn : bool, default True\n Whether to use BatchNorm layer.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n dw_activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function after the depthwise convolution block.\n pw_activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function after the pointwise convolution block.\n \"\"\"\n\n def __init__(self,\n in_channels,\n out_channels,\n kernel_size,\n stride,\n padding,\n dilation=1,\n bias=False,\n use_bn=True,\n bn_eps=1e-5,\n dw_activation=(lambda: nn.ReLU(inplace=True)),\n pw_activation=(lambda: nn.ReLU(inplace=True))):\n super(DwsConvBlock, self).__init__()\n self.dw_conv = dwconv_block(\n in_channels=in_channels,\n out_channels=in_channels,\n kernel_size=kernel_size,\n stride=stride,\n padding=padding,\n dilation=dilation,\n bias=bias,\n use_bn=use_bn,\n bn_eps=bn_eps,\n activation=dw_activation)\n self.pw_conv = conv1x1_block(\n in_channels=in_channels,\n out_channels=out_channels,\n bias=bias,\n use_bn=use_bn,\n bn_eps=bn_eps,\n activation=pw_activation)\n\n def forward(self, x):\n x = self.dw_conv(x)\n x = self.pw_conv(x)\n return x\n\n\ndef dwsconv3x3_block(in_channels,\n out_channels,\n stride=1,\n padding=1,\n dilation=1,\n bias=False,\n bn_eps=1e-5,\n dw_activation=(lambda: nn.ReLU(inplace=True)),\n pw_activation=(lambda: nn.ReLU(inplace=True))):\n \"\"\"\n 3x3 depthwise separable version of the standard convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 1\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n bias : bool, default False\n Whether the layer uses a bias vector.\n bn_eps : float, default 1e-5\n Small float added to variance in Batch norm.\n dw_activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function after the depthwise convolution block.\n pw_activation : function or str or None, default nn.ReLU(inplace=True)\n Activation function after the pointwise convolution block.\n \"\"\"\n return DwsConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=3,\n stride=stride,\n padding=padding,\n dilation=dilation,\n bias=bias,\n bn_eps=bn_eps,\n dw_activation=dw_activation,\n pw_activation=pw_activation)\n\n\nclass PreConvBlock(nn.Module):\n \"\"\"\n Convolution block with Batch normalization and ReLU pre-activation.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n kernel_size : int or tuple/list of 2 int\n Convolution window size.\n stride : int or tuple/list of 2 int\n Strides of the convolution.\n padding : int or tuple/list of 2 int\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n bias : bool, default False\n Whether the layer uses a bias vector.\n return_preact : bool, default False\n Whether return pre-activation. It's used by PreResNet.\n activate : bool, default True\n Whether activate the convolution block.\n \"\"\"\n\n def __init__(self,\n in_channels,\n out_channels,\n kernel_size,\n stride,\n padding,\n dilation=1,\n bias=False,\n return_preact=False,\n activate=True):\n super(PreConvBlock, self).__init__()\n self.return_preact = return_preact\n self.activate = activate\n\n self.bn = nn.BatchNorm2d(num_features=in_channels)\n if self.activate:\n self.activ = nn.ReLU(inplace=True)\n self.conv = nn.Conv2d(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=stride,\n padding=padding,\n dilation=dilation,\n bias=bias)\n\n def forward(self, x):\n x = self.bn(x)\n if self.activate:\n x = self.activ(x)\n if self.return_preact:\n x_pre_activ = x\n x = self.conv(x)\n if self.return_preact:\n return x, x_pre_activ\n else:\n return x\n\n\ndef pre_conv1x1_block(in_channels,\n out_channels,\n stride=1,\n bias=False,\n return_preact=False,\n activate=True):\n \"\"\"\n 1x1 version of the pre-activated convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n bias : bool, default False\n Whether the layer uses a bias vector.\n return_preact : bool, default False\n Whether return pre-activation.\n activate : bool, default True\n Whether activate the convolution block.\n \"\"\"\n return PreConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=1,\n stride=stride,\n padding=0,\n bias=bias,\n return_preact=return_preact,\n activate=activate)\n\n\ndef pre_conv3x3_block(in_channels,\n out_channels,\n stride=1,\n padding=1,\n dilation=1,\n return_preact=False,\n activate=True):\n \"\"\"\n 3x3 version of the pre-activated convolution block.\n Parameters:\n ----------\n in_channels : int\n Number of input channels.\n out_channels : int\n Number of output channels.\n stride : int or tuple/list of 2 int, default 1\n Strides of the convolution.\n padding : int or tuple/list of 2 int, default 1\n Padding value for convolution layer.\n dilation : int or tuple/list of 2 int, default 1\n Dilation value for convolution layer.\n return_preact : bool, default False\n Whether return pre-activation.\n activate : bool, default True\n Whether activate the convolution block.\n \"\"\"\n return PreConvBlock(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=3,\n stride=stride,\n padding=padding,\n dilation=dilation,\n return_preact=return_preact,\n activate=activate)\n\n\nclass InterpolationBlock(nn.Module):\n \"\"\"\n Interpolation upsampling block.\n Parameters:\n ----------\n scale_factor : float\n Multiplier for spatial size.\n mode : str, default 'bilinear'\n Algorithm used for upsampling.\n align_corners : bool, default True\n Whether to align the corner pixels of the input and output tensors\n \"\"\"\n\n def __init__(self,\n scale_factor,\n mode=\"bilinear\",\n align_corners=True):\n super(InterpolationBlock, self).__init__()\n self.scale_factor = scale_factor\n self.mode = mode\n self.align_corners = align_corners\n\n def forward(self, x):\n return F.interpolate(\n input=x,\n scale_factor=self.scale_factor,\n mode=self.mode,\n align_corners=self.align_corners)\n\n def __repr__(self):\n s = '{name}(scale_factor={scale_factor}, mode={mode}, align_corners={align_corners})'\n return s.format(\n name=self.__class__.__name__,\n scale_factor=self.scale_factor,\n mode=self.mode,\n align_corners=self.align_corners)\n\n def calc_flops(self, x):\n assert (x.shape[0] == 1)\n if self.mode == \"bilinear\":\n num_flops = 9 * x.numel()\n else:\n num_flops = 4 * x.numel()\n num_macs = 0\n return num_flops, num_macs\n\n\ndef channel_shuffle(x,\n groups):\n \"\"\"\n Channel shuffle operation from 'ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices,'\n https://arxiv.org/abs/1707.01083.\n Parameters:\n ----------\n x : Tensor\n Input tensor.\n groups : int\n Number of groups.\n Returns\n -------\n Tensor\n Resulted tensor.\n \"\"\"\n batch, channels, height, width = x.size()\n # assert (channels % groups == 0)\n channels_per_group = channels // groups\n x = x.view(batch, groups, channels_per_group, height, width)\n x = torch.transpose(x, 1, 2).contiguous()\n x = x.view(batch, channels, height, width)\n return x\n\n\nclass ChannelShuffle(nn.Module):\n \"\"\"\n Channel shuffle layer. This is a wrapper over the same operation. It is designed to save the number of groups.\n Parameters:\n ----------\n channels : int\n Number of channels.\n groups : int\n Number of groups.\n \"\"\"\n\n def __init__(self,\n channels,\n groups):\n super(ChannelShuffle, self).__init__()\n # assert (channels % groups == 0)\n if channels % groups != 0:\n raise ValueError('channels must be divisible by groups')\n self.groups = groups\n\n def forward(self, x):\n return channel_shuffle(x, self.groups)\n\n\ndef channel_shuffle2(x,\n groups):\n \"\"\"\n Channel shuffle operation from 'ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices,'\n https://arxiv.org/abs/1707.01083. The alternative version.\n Parameters:\n ----------\n x : Tensor\n Input tensor.\n groups : int\n Number of groups.\n Returns\n -------\n Tensor\n Resulted tensor.\n \"\"\"\n batch, channels, height, width = x.size()\n # assert (channels % groups == 0)\n channels_per_group = channels // groups\n x = x.view(batch, channels_per_group, groups, height, width)\n x = torch.transpose(x, 1, 2).contiguous()\n x = x.view(batch, channels, height, width)\n return x\n\n\nclass ChannelShuffle2(nn.Module):\n \"\"\"\n Channel shuffle layer. This is a wrapper over the same operation. It is designed to save the number of groups.\n The alternative version.\n Parameters:\n ----------\n channels : int\n Number of channels.\n groups : int\n Number of groups.\n \"\"\"\n\n def __init__(self,\n channels,\n groups):\n super(ChannelShuffle2, self).__init__()\n # assert (channels % groups == 0)\n if channels % groups != 0:\n raise ValueError('channels must be divisible by groups')\n self.groups = groups\n\n def forward(self, x):\n return channel_shuffle2(x, self.groups)\n\n\nclass SEBlock(nn.Module):\n \"\"\"\n Squeeze-and-Excitation block from 'Squeeze-and-Excitation Networks,' https://arxiv.org/abs/1709.01507.\n Parameters:\n ----------\n channels : int\n Number of channels.\n reduction : int, default 16\n Squeeze reduction value.\n round_mid : bool, default False\n Whether to round middle channel number (make divisible by 8).\n activation : function, or str, or nn.Module, default 'relu'\n Activation function after the first convolution.\n out_activation : function, or str, or nn.Module, default 'sigmoid'\n Activation function after the last convolution.\n \"\"\"\n\n def __init__(self,\n channels,\n reduction=16,\n round_mid=False,\n mid_activation=(lambda: nn.ReLU(inplace=True)),\n out_activation=(lambda: nn.Sigmoid())):\n super(SEBlock, self).__init__()\n mid_channels = channels // reduction if not round_mid else round_channels(float(channels) / reduction)\n\n self.pool = nn.AdaptiveAvgPool2d(output_size=1)\n self.conv1 = conv1x1(\n in_channels=channels,\n out_channels=mid_channels,\n bias=True)\n self.activ = get_activation_layer(mid_activation)\n self.conv2 = conv1x1(\n in_channels=mid_channels,\n out_channels=channels,\n bias=True)\n self.sigmoid = get_activation_layer(out_activation)\n\n def forward(self, x):\n w = self.pool(x)\n w = self.conv1(w)\n w = self.activ(w)\n w = self.conv2(w)\n w = self.sigmoid(w)\n x = x * w\n return x\n\n\nclass IBN(nn.Module):\n \"\"\"\n Instance-Batch Normalization block from 'Two at Once: Enhancing Learning and Generalization Capacities via IBN-Net,'\n https://arxiv.org/abs/1807.09441.\n Parameters:\n ----------\n channels : int\n Number of channels.\n inst_fraction : float, default 0.5\n The first fraction of channels for normalization.\n inst_first : bool, default True\n Whether instance normalization be on the first part of channels.\n \"\"\"\n\n def __init__(self,\n channels,\n first_fraction=0.5,\n inst_first=True):\n super(IBN, self).__init__()\n self.inst_first = inst_first\n h1_channels = int(math.floor(channels * first_fraction))\n h2_channels = channels - h1_channels\n self.split_sections = [h1_channels, h2_channels]\n\n if self.inst_first:\n self.inst_norm = nn.InstanceNorm2d(\n num_features=h1_channels,\n affine=True)\n self.batch_norm = nn.BatchNorm2d(num_features=h2_channels)\n else:\n self.batch_norm = nn.BatchNorm2d(num_features=h1_channels)\n self.inst_norm = nn.InstanceNorm2d(\n num_features=h2_channels,\n affine=True)\n\n def forward(self, x):\n x1, x2 = torch.split(x, split_size_or_sections=self.split_sections, dim=1)\n if self.inst_first:\n x1 = self.inst_norm(x1.contiguous())\n x2 = self.batch_norm(x2.contiguous())\n else:\n x1 = self.batch_norm(x1.contiguous())\n x2 = self.inst_norm(x2.contiguous())\n x = torch.cat((x1, x2), dim=1)\n return x\n\n\nclass DualPathSequential(nn.Sequential):\n \"\"\"\n A sequential container for modules with dual inputs/outputs.\n Modules will be executed in the order they are added.\n Parameters:\n ----------\n return_two : bool, default True\n Whether to return two output after execution.\n first_ordinals : int, default 0\n Number of the first modules with single input/output.\n last_ordinals : int, default 0\n Number of the final modules with single input/output.\n dual_path_scheme : function\n Scheme of dual path response for a module.\n dual_path_scheme_ordinal : function\n Scheme of dual path response for an ordinal module.\n \"\"\"\n\n def __init__(self,\n return_two=True,\n first_ordinals=0,\n last_ordinals=0,\n dual_path_scheme=(lambda module, x1, x2: module(x1, x2)),\n dual_path_scheme_ordinal=(lambda module, x1, x2: (module(x1), x2))):\n super(DualPathSequential, self).__init__()\n self.return_two = return_two\n self.first_ordinals = first_ordinals\n self.last_ordinals = last_ordinals\n self.dual_path_scheme = dual_path_scheme\n self.dual_path_scheme_ordinal = dual_path_scheme_ordinal\n\n def forward(self, x1, x2=None):\n length = len(self._modules.values())\n for i, module in enumerate(self._modules.values()):\n if (i < self.first_ordinals) or (i >= length - self.last_ordinals):\n x1, x2 = self.dual_path_scheme_ordinal(module, x1, x2)\n else:\n x1, x2 = self.dual_path_scheme(module, x1, x2)\n if self.return_two:\n return x1, x2\n else:\n return x1\n\n\nclass Concurrent(nn.Sequential):\n \"\"\"\n A container for concatenation of modules on the base of the sequential container.\n Parameters:\n ----------\n axis : int, default 1\n The axis on which to concatenate the outputs.\n stack : bool, default False\n Whether to concatenate tensors along a new dimension.\n \"\"\"\n\n def __init__(self,\n axis=1,\n stack=False):\n super(Concurrent, self).__init__()\n self.axis = axis\n self.stack = stack\n\n def forward(self, x):\n out = []\n for module in self._modules.values():\n out.append(module(x))\n if self.stack:\n out = torch.stack(tuple(out), dim=self.axis)\n else:\n out = torch.cat(tuple(out), dim=self.axis)\n return out\n\n\nclass SequentialConcurrent(nn.Sequential):\n \"\"\"\n A sequential container with concatenated outputs.\n Modules will be executed in the order they are added.\n Parameters:\n ----------\n axis : int, default 1\n The axis on which to concatenate the outputs.\n stack : bool, default False\n Whether to concatenate tensors along a new dimension.\n cat_input : bool, default True\n Whether to concatenate input tensor.\n \"\"\"\n\n def __init__(self,\n axis=1,\n stack=False,\n cat_input=True):\n super(SequentialConcurrent, self).__init__()\n self.axis = axis\n self.stack = stack\n self.cat_input = cat_input\n\n def forward(self, x):\n out = [x] if self.cat_input else []\n for module in self._modules.values():\n x = module(x)\n out.append(x)\n if self.stack:\n out = torch.stack(tuple(out), dim=self.axis)\n else:\n out = torch.cat(tuple(out), dim=self.axis)\n return out\n\n\nclass ParametricSequential(nn.Sequential):\n \"\"\"\n A sequential container for modules with parameters.\n Modules will be executed in the order they are added.\n \"\"\"\n\n def __init__(self, *args):\n super(ParametricSequential, self).__init__(*args)\n\n def forward(self, x, **kwargs):\n for module in self._modules.values():\n x = module(x, **kwargs)\n return x\n\n\nclass ParametricConcurrent(nn.Sequential):\n \"\"\"\n A container for concatenation of modules with parameters.\n Parameters:\n ----------\n axis : int, default 1\n The axis on which to concatenate the outputs.\n \"\"\"\n\n def __init__(self, axis=1):\n super(ParametricConcurrent, self).__init__()\n self.axis = axis\n\n def forward(self, x, **kwargs):\n out = []\n for module in self._modules.values():\n out.append(module(x, **kwargs))\n out = torch.cat(tuple(out), dim=self.axis)\n return out\n\n\nclass Hourglass(nn.Module):\n \"\"\"\n A hourglass block.\n Parameters:\n ----------\n down_seq : nn.Sequential\n Down modules as sequential.\n up_seq : nn.Sequential\n Up modules as sequential.\n skip_seq : nn.Sequential\n Skip connection modules as sequential.\n merge_type : str, default 'add'\n Type of concatenation of up and skip outputs.\n return_first_skip : bool, default False\n Whether return the first skip connection output. Used in ResAttNet.\n \"\"\"\n\n def __init__(self,\n down_seq,\n up_seq,\n skip_seq,\n merge_type=\"add\",\n return_first_skip=False):\n super(Hourglass, self).__init__()\n assert (len(up_seq) == len(down_seq))\n assert (len(skip_seq) == len(down_seq))\n assert (merge_type in [\"add\"])\n self.merge_type = merge_type\n self.return_first_skip = return_first_skip\n self.depth = len(down_seq)\n\n self.down_seq = down_seq\n self.up_seq = up_seq\n self.skip_seq = skip_seq\n\n def forward(self, x, **kwargs):\n y = None\n down_outs = [x]\n for down_module in self.down_seq._modules.values():\n x = down_module(x)\n down_outs.append(x)\n for i in range(len(down_outs)):\n if i != 0:\n y = down_outs[self.depth - i]\n skip_module = self.skip_seq[self.depth - i]\n y = skip_module(y)\n if (y is not None) and (self.merge_type == \"add\"):\n x = x + y\n if i != len(down_outs) - 1:\n up_module = self.up_seq[self.depth - 1 - i]\n x = up_module(x)\n if self.return_first_skip:\n return x, y\n else:\n return x\n\n\nclass SesquialteralHourglass(nn.Module):\n \"\"\"\n A sesquialteral hourglass block.\n Parameters:\n ----------\n down1_seq : nn.Sequential\n The first down modules as sequential.\n skip1_seq : nn.Sequential\n The first skip connection modules as sequential.\n up_seq : nn.Sequential\n Up modules as sequential.\n skip2_seq : nn.Sequential\n The second skip connection modules as sequential.\n down2_seq : nn.Sequential\n The second down modules as sequential.\n merge_type : str, default 'con'\n Type of concatenation of up and skip outputs.\n \"\"\"\n\n def __init__(self,\n down1_seq,\n skip1_seq,\n up_seq,\n skip2_seq,\n down2_seq,\n merge_type=\"cat\"):\n super(SesquialteralHourglass, self).__init__()\n assert (len(down1_seq) == len(up_seq))\n assert (len(down1_seq) == len(down2_seq))\n assert (len(skip1_seq) == len(skip2_seq))\n assert (len(down1_seq) == len(skip1_seq) - 1)\n assert (merge_type in [\"cat\", \"add\"])\n self.merge_type = merge_type\n self.depth = len(down1_seq)\n\n self.down1_seq = down1_seq\n self.skip1_seq = skip1_seq\n self.up_seq = up_seq\n self.skip2_seq = skip2_seq\n self.down2_seq = down2_seq\n\n def _merge(self, x, y):\n if y is not None:\n if self.merge_type == \"cat\":\n x = torch.cat((x, y), dim=1)\n elif self.merge_type == \"add\":\n x = x + y\n return x\n\n def forward(self, x, **kwargs):\n y = self.skip1_seq[0](x)\n skip1_outs = [y]\n for i in range(self.depth):\n x = self.down1_seq[i](x)\n y = self.skip1_seq[i + 1](x)\n skip1_outs.append(y)\n x = skip1_outs[self.depth]\n y = self.skip2_seq[0](x)\n skip2_outs = [y]\n for i in range(self.depth):\n x = self.up_seq[i](x)\n y = skip1_outs[self.depth - 1 - i]\n x = self._merge(x, y)\n y = self.skip2_seq[i + 1](x)\n skip2_outs.append(y)\n x = self.skip2_seq[self.depth](x)\n for i in range(self.depth):\n x = self.down2_seq[i](x)\n y = skip2_outs[self.depth - 1 - i]\n x = self._merge(x, y)\n return x\n\n\nclass MultiOutputSequential(nn.Sequential):\n \"\"\"\n A sequential container with multiple outputs.\n Modules will be executed in the order they are added.\n \"\"\"\n\n def __init__(self):\n super(MultiOutputSequential, self).__init__()\n\n def forward(self, x):\n outs = []\n for module in self._modules.values():\n x = module(x)\n if hasattr(module, \"do_output\") and module.do_output:\n outs.append(x)\n return [x] + outs\n\n\nclass Flatten(nn.Module):\n \"\"\"\n Simple flatten module.\n \"\"\"\n\n def forward(self, x):\n return x.view(x.size(0), -1)\n"
] | [
[
"torch.nn.BatchNorm2d",
"torch.nn.functional.relu6",
"torch.split",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.ReLU6",
"torch.nn.Conv2d",
"torch.nn.InstanceNorm2d",
"torch.sigmoid",
"torch.nn.Sigmoid",
"torch.nn.ReLU",
"torch.cat",
"torch.nn.functional.interpolate",
"torch.transpose"
]
] |
invertedv/utilities | [
"42c331893b1beee73b2d21df6cb2bad73b872bb7"
] | [
"muti/glmu.py"
] | [
"from muti import genu\nimport clickhouse_driver\nimport pandas as pd\nfrom modeling.glm import glm\nimport numpy as np\nimport math\n\n\ndef build_model_formula(features_dict: dict, target: str):\n \"\"\"\n Builds the model formula for glm from modeling based on the features_dict specification.\n Does not included embedded features\n \n :param features_dict: features dictionary\n :param target: dependent variable\n :return: model formula\n :rtype str\n \"\"\"\n ms = target + '~'\n extra = ''\n for feature in features_dict:\n if features_dict[feature][0] == 'cts':\n ms += extra + feature\n elif features_dict[feature][0] == 'spl':\n ms += extra + 'h(' + feature + ',' + features_dict[feature][1] + ',0)'\n elif features_dict[feature][0] == 'cat':\n ms += extra + 'c(' + feature + ',' + features_dict[feature][2] + ')'\n extra = ' + '\n return ms\n\n\ndef incr_build(model: str, target_var: str, start_list: list, add_list: list, get_data_fn, sample_size: int,\n client: clickhouse_driver.Client, global_valid_df_in: pd.DataFrame, family='normal'):\n\n \"\"\"\n This function builds a sequence of GLM models. The get_data_fn takes a list of values as contained in\n start_list and add_list and returns data subset to those values. The initial model is built on the\n values of start_list and then evaluated on the data subset to the first value of add_list.\n\n At the next step, the data in the first element of add_list is added to the start_list data, the model\n is updated and the evaluation is conducted on the second element of add_list.\n\n This function is the GLM counterpart to incr_build\n\n :param model: model specification for glm\n :param target_var: response variable we're modeling\n :param start_list: list of (general) time periods for model build for the first model build\n :param add_list: list of out-of-time periods to evaluate\n :param get_data_fn: function to get a pandas DataFrame of data to work on\n :param sample_size: size of pandas DataFrames to get\n :param client: db connector\n :param family: family of the model ('normal' or 'binomial')\n :param global_valid_df_in: pandas DataFrame covering all the values of add_list for validation\n :return: lists of out-of-sample values:\n add_list\n rmse root mean squared error\n corr correlation\n \"\"\"\n \n build_list = start_list\n global_valid_df = global_valid_df_in.copy()\n global_valid_df['model_glm_inc'] = np.full((global_valid_df.shape[0]), 0.0)\n rmse_valid = []\n corr_valid = []\n segs = []\n for j, valid in enumerate(add_list):\n segs += [valid]\n model_df = get_data_fn(build_list, sample_size, client)\n valid_df = get_data_fn([valid], sample_size, client)\n print('Data sizes for out-of-sample value {0}: build {1}, validate {2}'.format(valid, model_df.shape[0],\n valid_df.shape[0]))\n # print('Build list: {0}'.format(build_list))\n \n glm_model = glm(model, model_df, family=family)\n build_list += [valid]\n\n gyh = glm_model.predict(global_valid_df)\n i = global_valid_df['vintage'] == valid\n global_valid_df.loc[i, 'model_glm_inc'] = gyh[i]\n\n yh = glm_model.predict(valid_df)\n res = valid_df[target_var] - np.array(yh).flatten()\n rmse_valid += [math.sqrt(np.square(res).mean())]\n valid_df['yh'] = yh\n cor = genu.r_square(valid_df['yh'], valid_df[target_var])\n corr_valid += [cor]\n \n return segs, rmse_valid, corr_valid, global_valid_df\n"
] | [
[
"numpy.array",
"numpy.square",
"numpy.full"
]
] |
nelhage/data | [
"50a1ab91b786c9f89a8ff6ff10ea57ea5335490d"
] | [
"src/pipelines/epidemiology/nl_authority.py"
] | [
"# Copyright 2020 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom datetime import datetime\nfrom typing import Any, Dict, List\nfrom pandas import DataFrame, concat, merge\nfrom lib.pipeline import DataSource\nfrom lib.time import datetime_isoformat\nfrom lib.utils import grouped_diff\n\n\nclass NetherlandsDataSource(DataSource):\n def parse_dataframes(\n self, dataframes: List[DataFrame], aux: Dict[str, DataFrame], **parse_opts\n ) -> DataFrame:\n\n # Rename the appropriate columns\n data = dataframes[0].rename(\n columns={\n \"Date_of_report\": \"date\",\n \"Municipality_code\": \"subregion2_code\",\n \"Municipality_name\": \"subregion2_name\",\n \"Province\": \"subregion1_name\",\n \"Total_reported\": \"confirmed\",\n \"Hospital_admission\": \"hospitalized\",\n \"Deceased\": \"deceased\",\n }\n )\n\n # Drop data without a clear demarcation\n data = data[~data.subregion1_name.isna()]\n data = data[~data.subregion2_code.isna()]\n data = data[~data.subregion2_name.isna()]\n\n # Get date in ISO format\n data.date = data.date.apply(lambda x: datetime.fromisoformat(x).date().isoformat())\n\n # Make sure the region code is zero-padded and without prefix\n data[\"subregion2_code\"] = data[\"subregion2_code\"].apply(lambda x: x[2:])\n\n data = data.drop(columns=[\"subregion1_name\", \"subregion2_name\"])\n data = data.merge(aux[\"metadata\"], on=\"subregion2_code\")\n\n # We only need to keep key-date pair for identification\n data = data[[\"date\", \"key\", \"confirmed\", \"deceased\", \"hospitalized\"]]\n\n # Compute the daily counts\n data = grouped_diff(data, [\"key\", \"date\"])\n\n # Group by level 2 region, and add the parts\n l2 = data.copy()\n l2[\"key\"] = l2.key.apply(lambda x: x[:5])\n l2 = l2.groupby([\"key\", \"date\"]).sum().reset_index()\n\n # Group by country level, and add the parts\n l1 = l2.copy().drop(columns=[\"key\"])\n l1 = l1.groupby(\"date\").sum().reset_index()\n l1[\"key\"] = \"NL\"\n\n # Output the results\n return concat([l1, l2, data])\n"
] | [
[
"pandas.concat"
]
] |
BensonRen/idlm_Ben | [
"0d83780232d6341575daf88792959542aef82132"
] | [
"Pytorch/class_wrapper.py"
] | [
"\"\"\"\nThe class wrapper for the networks\n\"\"\"\n# Built-in\nimport os\nimport time\n\n# Torch\nimport torch\nfrom torch import nn\nfrom torch.utils.tensorboard import SummaryWriter\nfrom torchsummary import summary\n\n# Libs\nimport numpy as np\n\n# Own module\n\n\nclass Network(object):\n def __init__(self, model_fn, flags, train_loader, test_loader,\n ckpt_dir=os.path.join(os.path.abspath(''), 'models'),\n inference_mode=False, saved_model=None):\n self.model_fn = model_fn # The model maker function\n self.flags = flags # The Flags containing the specs\n if inference_mode: # If inference mode, use saved model\n self.ckpt_dir = os.path.join(ckpt_dir, saved_model)\n self.saved_model = saved_model\n else: # training mode, create a new ckpt folder\n self.ckpt_dir = os.path.join(ckpt_dir, time.strftime('%Y%m%d_%H%M%S', time.localtime()))\n self.model = self.create_model() # The model itself\n self.loss = self.make_loss() # The loss function\n self.optm = self.make_optimizer() # The optimizer\n self.train_loader = train_loader # The train data loader\n self.test_loader = test_loader # The test data loader\n self.log = SummaryWriter(self.ckpt_dir) # Create a summary writer for keeping the summary to the tensor board\n self.best_validation_loss = float('inf') # Set the BVL to large number\n\n def create_model(self):\n \"\"\"\n Function to create the network module from provided model fn and flags\n :return: the created nn module\n \"\"\"\n model = self.model_fn(self.flags)\n #summary(model, input_size=(128, 8))\n print(model)\n return model\n\n def make_loss(self, logit=None, labels=None):\n \"\"\"\n Create a tensor that represents the loss. This is consistant both at training time \\\n and inference time for Backward model\n :param logit: The output of the network\n :return: the total loss\n \"\"\"\n if logit is None:\n return None\n MSE_loss = nn.functional.mse_loss(logit, labels) # The MSE Loss of the\n BDY_loss = 0 # Implemenation later\n return MSE_loss + BDY_loss\n\n def make_optimizer(self):\n \"\"\"\n Make the corresponding optimizer from the flags. Only below optimizers are allowed. Welcome to add more\n :return:\n \"\"\"\n if self.flags.optim == 'Adam':\n op = torch.optim.Adam(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\n elif self.flags.optim == 'RMSprop':\n op = torch.optim.RMSprop(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\n elif self.flags.optim == 'SGD':\n op = torch.optim.SGD(self.model.parameters(), lr=self.flags.lr, weight_decay=self.flags.reg_scale)\n else:\n raise Exception(\"Your Optimizer is neither Adam, RMSprop or SGD, please change in param or contact Ben\")\n return op\n\n def save(self):\n \"\"\"\n Saving the model to the current check point folder with name best_model.pt\n :return: None\n \"\"\"\n #torch.save(self.model.state_dict, os.path.join(self.ckpt_dir, 'best_model_state_dict.pt'))\n torch.save(self.model, os.path.join(self.ckpt_dir, 'best_model.pt'))\n\n def load(self):\n \"\"\"\n Loading the model from the check point folder with name best_model.pt\n :return:\n \"\"\"\n #self.model.load_state_dict(torch.load(os.path.join(self.ckpt_dir, 'best_model_state_dict.pt')))\n self.model.load(torch.load(os.path.join(self.ckpt_dir, 'best_model.pt')))\n\n def train(self):\n \"\"\"\n The major training function. This would start the training using information given in the flags\n :return: None\n \"\"\"\n cuda = True if torch.cuda.is_available() else False\n if cuda:\n self.model.cuda()\n for epoch in range(self.flags.train_step):\n # Set to Training Mode\n train_loss = 0\n self.model.train()\n for j, (geometry, spectra) in enumerate(self.train_loader):\n if cuda:\n geometry = geometry.cuda() # Put data onto GPU\n spectra = spectra.cuda() # Put data onto GPU\n self.optm.zero_grad() # Zero the gradient first\n logit = self.model(geometry) # Get the output\n loss = self.make_loss(logit, spectra) # Get the loss tensor\n loss.backward() # Calculate the backward gradients\n self.optm.step() # Move one step the optimizer\n train_loss += loss # Aggregate the loss\n\n if epoch % self.flags.eval_step: # For eval steps, do the evaluations and tensor board\n # Record the training loss to the tensorboard\n train_avg_loss = train_loss.data.numpy() / (j+1)\n self.log.add_scalar('Loss/train', train_avg_loss, epoch)\n\n # Set to Evaluation Mode\n self.model.eval()\n print(\"Doing Evaluation on the model now\")\n test_loss = 0\n for j, (geometry, spectra) in enumerate(self.test_loader): # Loop through the eval set\n if cuda:\n geometry = geometry.cuda()\n spectra = spectra.cuda()\n logit = self.model(geometry)\n loss = self.make_loss(logit, spectra) # compute the loss\n test_loss += loss # Aggregate the loss\n\n # Record the testing loss to the tensorboard\n test_avg_loss = test_loss.data.numpy() / (j+1)\n self.log.add_scalar('Loss/test', test_avg_loss, epoch)\n\n print(\"This is Epoch %d, training loss %.5f, validation loss %.5f\" \\\n % (epoch, train_avg_loss, test_avg_loss ))\n\n # Model improving, save the model down\n if test_avg_loss < self.best_validation_loss:\n self.best_validation_loss = test_avg_loss\n self.save()\n print(\"Saving the model down...\")\n\n if self.best_validation_loss < self.flags.stop_threshold:\n print(\"Training finished EARLIER at epoch %d, reaching loss of %.5f\" %\\\n (epoch, self.best_validation_loss))\n return None\n\n def evaluate(self, save_dir='data/'):\n self.load()\n self.model.eval() # Evaluation mode\n\n # Get the file names\n Ypred_file = os.path.join(save_dir, 'test_Ypred_{}.csv'.format(self.saved_model))\n Xtruth_file = os.path.join(save_dir, 'test_Xtruth_{}.csv'.format(self.saved_model))\n Ytruth_file = os.path.join(save_dir, 'test_Ytruth_{}.csv'.format(self.saved_model))\n #Xpred_file = os.path.join(save_dir, 'test_Xpred_{}.csv'.format(self.saved_model)) # For pure forward model, there is no Xpred\n\n # Open those files to append\n with open(Xtruth_file,'a') as fxt,open(Ytruth_file, 'a') as fyt, open(Ypred_file,'a') as fyp:\n # Loop through the eval data and evaluate\n for ind, (geometry, spectra) in enumerate(self.test_loader):\n logits = self.model(geometry)\n np.savetxt(fxt, geometry.numpy(), fmt='%.3f')\n np.savetxt(fyt, spectra.numpy(), fmt='%.3f')\n np.savetxt(fyp, logits.numpy(), fmt='%.3f')\n\n\n"
] | [
[
"torch.utils.tensorboard.SummaryWriter",
"torch.nn.functional.mse_loss",
"torch.cuda.is_available"
]
] |
magic428/subjects_notes | [
"6930adbb3f445c11ca9d024abb12a53d6aca19e7",
"6930adbb3f445c11ca9d024abb12a53d6aca19e7"
] | [
"computer_vision/learning-opencv-practical/image-process-100ask/Question_31_40/answers/answer_40.py",
"computer_vision/learning-opencv-practical/image-process-100ask/Question_41_50/answers/answer_48.py"
] | [
"import cv2\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n# Read image\r\nimg = cv2.imread(\"imori.jpg\").astype(np.float32)\r\nH, W, C = img.shape\r\n\r\n# RGB > YCbCr\r\nY = 0.2990 * img[..., 2] + 0.5870 * img[..., 1] + 0.1140 * img[..., 0]\r\nCb = -0.1687 * img[..., 2] - 0.3313 * img[..., 1] + 0.5 * img[..., 0] + 128.\r\nCr = 0.5 * img[..., 2] - 0.4187 * img[..., 1] - 0.0813 * img[..., 0] + 128.\r\n\r\nYCC = np.zeros_like(img, dtype=np.float32)\r\nYCC[..., 0] = Y\r\nYCC[..., 1] = Cb\r\nYCC[..., 2] = Cr\r\n\r\n\r\n# DCT\r\nT = 8\r\nK = 8\r\nX = np.zeros((H, W, C), dtype=np.float64)\r\n\r\nQ1 = np.array(((16, 11, 10, 16, 24, 40, 51, 61),\r\n (12, 12, 14, 19, 26, 58, 60, 55),\r\n (14, 13, 16, 24, 40, 57, 69, 56),\r\n (14, 17, 22, 29, 51, 87, 80, 62),\r\n (18, 22, 37, 56, 68, 109, 103, 77),\r\n (24, 35, 55, 64, 81, 104, 113, 92),\r\n (49, 64, 78, 87, 103, 121, 120, 101),\r\n (72, 92, 95, 98, 112, 100, 103, 99)), dtype=np.float32)\r\n\r\nQ2 = np.array(((17, 18, 24, 47, 99, 99, 99, 99),\r\n (18, 21, 26, 66, 99, 99, 99, 99),\r\n (24, 26, 56, 99, 99, 99, 99, 99),\r\n (47, 66, 99, 99, 99, 99, 99, 99),\r\n (99, 99, 99, 99, 99, 99, 99, 99),\r\n (99, 99, 99, 99, 99, 99, 99, 99),\r\n (99, 99, 99, 99, 99, 99, 99, 99),\r\n (99, 99, 99, 99, 99, 99, 99, 99)), dtype=np.float32)\r\n\r\ndef w(x, y, u, v):\r\n cu = 1.\r\n cv = 1.\r\n if u == 0:\r\n cu /= np.sqrt(2)\r\n if v == 0:\r\n cv /= np.sqrt(2)\r\n theta = np.pi / (2 * T)\r\n return (( 2 * cu * cv / T) * np.cos((2*x+1)*u*theta) * np.cos((2*y+1)*v*theta))\r\n \r\nfor yi in range(0, H, T):\r\n for xi in range(0, W, T):\r\n for v in range(T):\r\n for u in range(T):\r\n for y in range(T):\r\n for x in range(T):\r\n for c in range(C):\r\n X[v+yi, u+xi, c] += YCC[y+yi, x+xi, c] * w(x,y,u,v)\r\n \r\n X[yi:yi+T, xi:xi+T, 0] = np.round(X[yi:yi+T, xi:xi+T, 0] / Q1) * Q1\r\n X[yi:yi+T, xi:xi+T, 1] = np.round(X[yi:yi+T, xi:xi+T, 1] / Q2) * Q2\r\n X[yi:yi+T, xi:xi+T, 2] = np.round(X[yi:yi+T, xi:xi+T, 2] / Q2) * Q2\r\n \r\n\r\n# IDCT\r\nIYCC = np.zeros((H, W, 3), dtype=np.float64)\r\n\r\nfor yi in range(0, H, T):\r\n for xi in range(0, W, T):\r\n for y in range(T):\r\n for x in range(T):\r\n for v in range(K):\r\n for u in range(K):\r\n IYCC[y+yi, x+xi] += X[v+yi, u+xi] * w(x,y,u,v)\r\n\r\n\r\n# YCbCr > RGB\r\nout = np.zeros_like(img, dtype=np.float32)\r\nout[..., 2] = IYCC[..., 0] + (IYCC[..., 2] - 128.) * 1.4020\r\nout[..., 1] = IYCC[..., 0] - (IYCC[..., 1] - 128.) * 0.3441 - (IYCC[..., 2] - 128.) * 0.7139\r\nout[..., 0] = IYCC[..., 0] + (IYCC[..., 1] - 128.) * 1.7718\r\n\r\nout[out>255] = 255\r\nout = out.astype(np.uint8)\r\n \r\n# MSE\r\nv_max = 255.\r\nmse = np.sum(np.power(np.abs(img.astype(np.float32) - out.astype(np.float32)), 2)) / (H * W * C)\r\npsnr = 10 * np.log10(v_max ** 2 / mse)\r\n\r\nprint(\"PSNR >>\", psnr)\r\n\r\nbitrate = 1. * T * K ** 2 / (T ** 2)\r\nprint(\"bitrate >>\", bitrate)\r\n\r\n# Save result\r\ncv2.imshow(\"result\", out)\r\ncv2.waitKey(0)\r\ncv2.imwrite(\"out.jpg\", out)\r\n",
"import cv2\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n# Read image\r\nimg = cv2.imread(\"imori.jpg\").astype(np.float32)\r\nH, W, C = img.shape\r\n\r\n# Otsu binary\r\n## Grayscale\r\nout = 0.2126 * img[..., 2] + 0.7152 * img[..., 1] + 0.0722 * img[..., 0]\r\nout = out.astype(np.uint8)\r\n\r\n## Determine threshold of Otsu's binarization\r\nmax_sigma = 0\r\nmax_t = 0\r\n\r\nfor _t in range(1, 255):\r\n v0 = out[np.where(out < _t)]\r\n m0 = np.mean(v0) if len(v0) > 0 else 0.\r\n w0 = len(v0) / (H * W)\r\n v1 = out[np.where(out >= _t)]\r\n m1 = np.mean(v1) if len(v1) > 0 else 0.\r\n w1 = len(v1) / (H * W)\r\n sigma = w0 * w1 * ((m0 - m1) ** 2)\r\n if sigma > max_sigma:\r\n max_sigma = sigma\r\n max_t = _t\r\n\r\n## Binarization\r\n#print(\"threshold >>\", max_t)\r\nth = max_t\r\nout[out < th] = 0\r\nout[out >= th] = 255\r\n\r\n\r\n# Morphology filter\r\nMF = np.array(((0, 1, 0),\r\n (1, 0, 1),\r\n (0, 1, 0)), dtype=np.int)\r\n\r\n# Morphology - erode\r\nErode_time = 2\r\n\r\nfor i in range(Erode_time):\r\n tmp = np.pad(out, (1, 1), 'edge')\r\n for y in range(1, H+1):\r\n for x in range(1, W+1):\r\n if np.sum(MF * tmp[y-1:y+2, x-1:x+2]) < 255*4:\r\n out[y-1, x-1] = 0\r\n\r\n\r\n# Save result\r\ncv2.imwrite(\"out.jpg\", out)\r\ncv2.imshow(\"result\", out)\r\ncv2.waitKey(0)\r\ncv2.destroyAllWindows()\r\n"
] | [
[
"numpy.sqrt",
"numpy.zeros_like",
"numpy.zeros",
"numpy.cos",
"numpy.log10",
"numpy.array",
"numpy.round"
],
[
"numpy.sum",
"numpy.where",
"numpy.array",
"numpy.pad",
"numpy.mean"
]
] |
BatsiBoy/PyFrac | [
"a898f6111295fa9196c382613639fc84e73d6035"
] | [
"examples/visexp.py"
] | [
"# -*- coding: utf-8 -*-\n#Name: Fractal Example - Exponential Curves\n#Author: Sean Pope\n\n#Example use of the fractal engine and coefficient block.\n#Creates random coefficient blocks and draws frames to create a simple animation.\n#This one is optimized for the exponential variation.\n\nimport matplotlib.pyplot as plt\nimport PyFrac as pf\n\nplt.style.use('dark_background') #Mostly just used for the black background.\n\nax = plt.subplot(111,frameon=False) #Create a figure and axes for drawing.\nax.axes.get_xaxis().set_visible(False) #Hide axis\nax.axes.get_yaxis().set_visible(False)\nplt.xlim(-1,1) #This function looks best in the biunit square.\nplt.ylim(-1,1)\n\n\n\ndef quitloop(*args): #Closes the event loop when no longer needed.\n global run\n run = 0\n return\n\n\n\nfig = plt.gcf() #Get the figure that pyplot spawned.\nfig.canvas.mpl_connect('close_event', quitloop) #If the window is closed, exit loop.\nfig.canvas.mpl_connect('key_press_event', quitloop) #If a button is pressed, close.\n\nmng = plt.get_current_fig_manager() #Grab the figure window\nmng.full_screen_toggle() #Maximize the image to fill the screen.\n\n\"\"\" Runtime variables \"\"\"\n\nrun = 1 #Set to continue drawing frames, unset to terminate\nframecount = 0 #Used to set frames drawn per coefficient block\nframeclear = 0 #Starts deleting frames when set\n\ncoeffs = pf.coeffs.rand(0.9,0.2)\n\n\"\"\" Main event loop. \"\"\"\n\nwhile(run):\n framecount += 1\n if framecount == 40: #Draws a new coefficient set if the current image is done.\n frameclear = 1\n coeffs = pf.coeffs.rand(0.9,0.2)\n framecount -= 40 #Reset frame counter.\n\n fractal = pf.engine.fractpoints(coeffs, 200, pf.variations.exponential) #Run the engine to get a figure.\n plt.scatter(fractal['x'], fractal['y'], #Get the x,y coordinates for each point\n marker='.', alpha=0.8, #Use small pixel markers with low opacity\n c=fractal['color'], cmap='plasma', #Map the color row to this colormap.\n s=25, edgecolor='none'\n )\n if frameclear:\n del ax.collections[0] #Remove the oldest frame.\n\n plt.pause(.01) #This pause draws the frame before looping.\n\n\nplt.close(fig)"
] | [
[
"matplotlib.pyplot.style.use",
"matplotlib.pyplot.pause",
"matplotlib.pyplot.gcf",
"matplotlib.pyplot.get_current_fig_manager",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.close",
"matplotlib.pyplot.scatter"
]
] |
dengniewei/Face-Recognition-Class-Attendance-System | [
"58aa85ff3b378991da3ccebd69e6ace5ec2af93f"
] | [
"02 Main/mainRUN.py"
] | [
"# 导入必要的模块\r\nfrom PyQt5 import QtCore, QtGui\r\nfrom PyQt5.QtWidgets import QApplication, QWidget, QMessageBox, QInputDialog\r\nfrom PyQt5.QtGui import QImage, QIcon, QPixmap\r\nfrom PyQt5.QtCore import QTimer, QDateTime, QCoreApplication, QThread\r\nimport sys, os\r\nimport cv2, imutils\r\n# 导入UI主界面\r\nimport main\r\n# 导入信息采集框界面\r\nimport infoUI\r\n# 导入打印中文脚本\r\nimport ChinesePutText\r\n# 导入人脸识别检测包\r\nfrom imutils.video import VideoStream\r\nimport numpy as np\r\nimport pickle\r\n# 导入眨眼检测必要的包\r\nfrom scipy.spatial import distance as dist\r\nfrom imutils import face_utils\r\nfrom datetime import datetime\r\nimport dlib\r\n# 导入数据库操作包\r\nimport pymysql\r\n\r\n# 定义活体检测-眨眼检测类\r\nclass BlinksDetectThread(QThread):\r\n trigger = QtCore.pyqtSignal()\r\n def __init__(self):\r\n super(BlinksDetectThread, self).__init__()\r\n # 定义两个常数，一个用于眼睛纵横比以指示眨眼，第二个作为眨眼连续帧数的阈值\r\n self.EYE_AR_THRESH = 0.25\r\n self.EYE_AR_CONSEC_FRAMES = 3\r\n # 初始化帧计数器和总闪烁次数\r\n self.COUNTER = 0\r\n self.TOTAL = 0\r\n # 初始化变量\r\n self.A = 0\r\n self.B = 0\r\n self.C = 0\r\n self.leftEye = 0\r\n self.rightEye = 0\r\n self.leftEAR = 0\r\n self.rightEAR = 0\r\n self.ear = 0\r\n # 线程启动停止标识符\r\n self.BlinksFlag = 1\r\n # 初始化摄像头\r\n self.cap3 = cv2.VideoCapture()\r\n\r\n # 定义眨眼检测距离函数\r\n def eye_aspect_ratio(self, eye):\r\n # 计算两组垂直方向上的眼睛标记（x，y）坐标之间的欧氏距离\r\n self.A = dist.euclidean(eye[1], eye[5])\r\n self.B = dist.euclidean(eye[2], eye[4])\r\n # 计算水平方向上的眼睛标记（x，y）坐标之间的欧氏距离\r\n self.C = dist.euclidean(eye[0], eye[3])\r\n # 计算眼睛的纵横比\r\n ear = (self.A + self.B) / (2.0 * self.C)\r\n # 返回眼睛的纵横比\r\n return ear\r\n\r\n def run(self):\r\n if self.BlinksFlag == 1:\r\n # 初始化dlib的人脸检测器（基于HOG），然后创建面部标志预测器\r\n print(\"[INFO] loading facial landmark predictor...\")\r\n shape_predictor_path = \"shape_predictor_68_face_landmarks.dat\"\r\n detector = dlib.get_frontal_face_detector()\r\n predictor = dlib.shape_predictor(shape_predictor_path)\r\n # 分别提取左眼和右眼的面部标志的索引\r\n (lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS[\"left_eye\"]\r\n (rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS[\"right_eye\"]\r\n # 在视频流的帧中循环\r\n self.cap3.open(cv2.CAP_DSHOW)\r\n while self.BlinksFlag == 1:\r\n # 从线程视频文件流中抓取帧，调整其大小，并将其转换为灰度通道\r\n vs = VideoStream(src=cv2.CAP_DSHOW).start()\r\n frame3 = vs.read()\r\n # ret, frame3 = self.cap3.read()\r\n QApplication.processEvents()\r\n frame3 = imutils.resize(frame3, width=900)\r\n gray = cv2.cvtColor(frame3, cv2.COLOR_BGR2GRAY)\r\n # 检测灰度帧中的人脸\r\n rects = detector(gray, 0)\r\n # 循环检测人脸\r\n for rect in rects:\r\n # 确定面部区域的面部标记，然后将面部标记（x，y）坐标转换为NumPy阵列\r\n shape = predictor(gray, rect)\r\n shape = face_utils.shape_to_np(shape)\r\n # 提取左眼和右眼坐标，然后使用坐标计算双眼的眼睛纵横比\r\n self.leftEye = shape[lStart:lEnd]\r\n self.rightEye = shape[rStart:rEnd]\r\n self.leftEAR = self.eye_aspect_ratio(self.leftEye)\r\n self.rightEAR = self.eye_aspect_ratio(self.rightEye)\r\n # 两只眼睛的平均眼睛纵横比\r\n self.ear = (self.leftEAR + self.rightEAR) / 2.0\r\n # 检查眼睛纵横比是否低于闪烁阈值,如果是,则增加闪烁帧计数器;否则执行else\r\n if self.ear < self.EYE_AR_THRESH:\r\n self.COUNTER += 1\r\n else:\r\n # 如果眼睛闭合次数足够则增加眨眼总数\r\n if self.COUNTER >= self.EYE_AR_CONSEC_FRAMES:\r\n self.TOTAL += 1\r\n # 重置眼框计数器\r\n self.COUNTER = 0\r\n self.trigger.emit()\r\n if self.TOTAL == 1:\r\n print(\"活体！眨眼次数为: {}\".format(self.TOTAL))\r\n\r\n # 定义停止线程操作\r\n def terminate(self):\r\n self.BlinksFlag = 0\r\n if flag2 == 0:\r\n VideoStream(src=cv2.CAP_DSHOW).stop()\r\n\r\n#########################################################################################\r\n\r\nclass MainWindow(QWidget):\r\n # 类构造函数\r\n def __init__(self):\r\n # super()构造器方法返回父级的对象。__init__()方法是构造器的一个方法。\r\n super().__init__()\r\n self.ui = main.Ui_Form()\r\n self.ui.setupUi(self)\r\n # 设置窗口名称和图标\r\n self.setWindowTitle('人脸识别考勤系统')\r\n self.setWindowIcon(QIcon('fcblogo.jpg'))\r\n # label_time显示系统时间\r\n timer = QTimer(self)\r\n timer.timeout.connect(self.showTimeText)\r\n timer.start()\r\n # 初始化摄像头\r\n # self.url = 0 # 这样调用摄像头会报错，并且会卡死。\r\n self.url = cv2.CAP_DSHOW # 默认调用0，如果要调用摄像头1，可以这样写:cv2.CAP_DSHOW + 1\r\n self.cap = cv2.VideoCapture()\r\n # 设置单张图片背景\r\n pixmap = QPixmap('background1.png')\r\n self.ui.label_camera.setPixmap(pixmap)\r\n # 设置摄像头按键连接函数\r\n self.ui.bt_openCamera.clicked.connect(self.openCamera)\r\n # 设置开始考勤按键的回调函数\r\n self.ui.bt_startCheck.clicked.connect(self.autoControl)\r\n # 设置活体检测按键的回调函数\r\n self.ui.bt_blinks.clicked.connect(self.BlinksThread)\r\n # 设置“退出系统”按键事件, 按下之后退出主界面\r\n self.ui.bt_exit.clicked.connect(QCoreApplication.instance().quit)\r\n # 设置信息采集按键连接\r\n self.bt_gathering = self.ui.bt_gathering\r\n # 设置区分打开摄像头还是人脸识别的标识符\r\n self.switch_bt = 0\r\n global flag2\r\n flag2 = 0\r\n\r\n # 初始化需要记录的人名\r\n self.record_name1 = ([])\r\n\r\n # 设置更新人脸数据库的按键连接函数\r\n self.ui.bt_generator.clicked.connect(self.trainModel)\r\n # 设置查询班级人数按键的连接函数\r\n self.ui.bt_check.clicked.connect(self.checkNums)\r\n # 设置请假按键的连接函数\r\n self.ui.bt_leave.clicked.connect(self.leaveButton)\r\n # 设置漏签补签按键的连接函数\r\n self.ui.bt_Supplement.clicked.connect(self.supplymentButton)\r\n # 设置对输入内容的删除提示\r\n self.ui.lineEdit.setClearButtonEnabled(True)\r\n self.ui.lineEdit_2.setClearButtonEnabled(True)\r\n # 设置查看结果（显示未到和迟到）按键的连接函数\r\n self.ui.bt_view.clicked.connect(self.showLateAbsentee)\r\n\r\n self.checkTime, ok = QInputDialog.getText(self, '考勤时间设定', '请输入考勤时间(格式为00:00:00):')\r\n\r\n # 显示系统时间以及相关文字提示函数\r\n def showTimeText(self):\r\n # 设置宽度\r\n self.ui.label_time.setFixedWidth(200)\r\n # 设置显示文本格式\r\n self.ui.label_time.setStyleSheet(\r\n # \"QLabel{background:white;}\" 此处设置背景色\r\n # \"QLabel{color:rgb(300,300,300,120); font-size:14px; font-weight:bold; font-family:宋体;}\"\r\n \"QLabel{font-size:14px; font-weight:bold; font-family:宋体;}\"\r\n )\r\n datetime = QDateTime.currentDateTime().toString()\r\n self.ui.label_time.setText(\"\" + datetime)\r\n\r\n # 显示“人脸识别考勤系统”文字\r\n self.ui.label_title.setFixedWidth(400)\r\n self.ui.label_title.setStyleSheet(\r\n \"QLabel{font-size:30px; font-weight:bold; font-family:宋体;}\")\r\n self.ui.label_title.setText(\"人脸识别考勤系统\")\r\n\r\n def openCamera(self, url):\r\n # 判断摄像头是否打开，如果打开则为true，反之为false\r\n flag = self.cap.isOpened()\r\n if flag == False:\r\n self.ui.label_logo.clear()\r\n self.cap.open(self.url)\r\n self.showCamera()\r\n elif flag == True:\r\n self.cap.release()\r\n self.ui.label_logo.clear()\r\n self.ui.label_camera.clear()\r\n self.ui.bt_openCamera.setText(u'打开相机')\r\n\r\n # 进入考勤模式，通过switch_bt进行控制的函数\r\n def autoControl(self):\r\n if self.switch_bt == 0:\r\n self.switch_bt = 1\r\n flag2 = 1\r\n self.ui.bt_startCheck.setText(u'退出考勤')\r\n self.showCamera()\r\n elif self.switch_bt == 1:\r\n self.switch_bt = 0\r\n flag2 = 0\r\n self.ui.bt_startCheck.setText(u'开始考勤')\r\n self.showCamera()\r\n\r\n def BlinksThread(self):\r\n bt_text = self.ui.bt_blinks.text()\r\n if bt_text == '活体检测':\r\n # 初始化眨眼检测线程\r\n self.startThread = BlinksDetectThread()\r\n self.startThread.start() # 启动线程\r\n self.ui.bt_blinks.setText('停止检测')\r\n else:\r\n self.ui.bt_blinks.setText('活体检测')\r\n # self.startThread.terminate() # 停止线程\r\n\r\n def showCamera(self):\r\n # 如果按键按下\r\n if self.switch_bt == 0:\r\n self.ui.label_logo.clear()\r\n self.ui.bt_openCamera.setText(u'关闭相机')\r\n while (self.cap.isOpened()):\r\n # 以BGR格式读取图像\r\n ret, self.image = self.cap.read(cv2.CAP_DSHOW)\r\n QApplication.processEvents() # 这句代码告诉QT处理来处理任何没有被处理的事件，并且将控制权返回给调用者，让代码变的没有那么卡\r\n # 将图像转换为RGB格式\r\n show = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB) # 这里指的是显示原图\r\n # opencv 读取图片的样式，不能通过Qlabel进行显示，需要转换为Qimage QImage(uchar * data, int width,\r\n self.showImage = QImage(show.data, show.shape[1], show.shape[0], QImage.Format_RGB888)\r\n self.ui.label_camera.setPixmap(QPixmap.fromImage(self.showImage))\r\n # 因为最后会存留一张图像在lable上，需要对lable进行清理\r\n self.ui.label_camera.clear()\r\n self.ui.bt_openCamera.setText(u'打开相机')\r\n\r\n elif self.switch_bt == 1:\r\n self.ui.label_logo.clear()\r\n self.ui.bt_startCheck.setText(u'退出考勤')\r\n # OpenCV深度学习人脸检测器的路径\r\n detector = \"face_detection_model\"\r\n # OpenCV深度学习面部嵌入模型的路径\r\n embedding_model = \"face_detection_model/openface_nn4.small2.v1.t7\"\r\n # 训练模型以识别面部的路径\r\n recognizer_path = \"output/recognizer.pickle\"\r\n # 标签编码器的路径\r\n le_path = \"output/le.pickle\"\r\n # 置信度\r\n confidence_default = 0.5\r\n # 从磁盘加载序列化面部检测器\r\n protoPath = os.path.sep.join([detector, \"deploy.prototxt\"])\r\n modelPath = os.path.sep.join([detector, \"res10_300x300_ssd_iter_140000.caffemodel\"])\r\n detector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)\r\n # 从磁盘加载我们的序列化面嵌入模型\r\n print(\"[INFO] loading face recognizer...\")\r\n embedder = cv2.dnn.readNetFromTorch(embedding_model)\r\n # 加载实际的人脸识别模型和标签\r\n recognizer = pickle.loads(open(recognizer_path, \"rb\").read())\r\n le = pickle.loads(open(le_path, \"rb\").read())\r\n # 循环来自视频文件流的帧\r\n while (self.cap.isOpened()):\r\n # 从线程视频流中抓取帧\r\n ret, frame = self.cap.read()\r\n QApplication.processEvents()\r\n # 调整框架的大小以使其宽度为900像素（同时保持纵横比），然后抓取图像尺寸\r\n frame = imutils.resize(frame, width=900)\r\n (h, w) = frame.shape[:2]\r\n # 从图像构造一个blob\r\n imageBlob = cv2.dnn.blobFromImage(\r\n cv2.resize(frame, (300, 300)), 1.0, (300, 300),\r\n (104.0, 177.0, 123.0), swapRB=False, crop=False)\r\n # 应用OpenCV的基于深度学习的人脸检测器来定位输入图像中的人脸\r\n detector.setInput(imageBlob)\r\n detections = detector.forward()\r\n # 保存识别到的人脸\r\n face_names = []\r\n # 循环检测\r\n for i in np.arange(0, detections.shape[2]):\r\n # 提取与预测相关的置信度（即概率）\r\n confidence = detections[0, 0, i, 2]\r\n\r\n # 用于更新相机开关按键信息\r\n flag = self.cap.isOpened()\r\n if flag == False:\r\n self.ui.bt_openCamera.setText(u'打开相机')\r\n elif flag == True:\r\n self.ui.bt_openCamera.setText(u'关闭相机')\r\n\r\n # 过滤弱检测\r\n if confidence > confidence_default:\r\n # 计算面部边界框的（x，y）坐标\r\n box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\r\n (startX, startY, endX, endY) = box.astype(\"int\")\r\n\r\n # 提取面部ROI\r\n face = frame[startY:endY, startX:endX]\r\n (fH, fW) = face.shape[:2]\r\n\r\n # 确保面部宽度和高度足够大\r\n if fW < 20 or fH < 20:\r\n continue\r\n\r\n # 为面部ROI构造一个blob，然后通过我们的面部嵌入模型传递blob以获得面部的128-d量化\r\n faceBlob = cv2.dnn.blobFromImage(face, 1.0 / 255, (96, 96), (0, 0, 0), swapRB=True, crop=False)\r\n embedder.setInput(faceBlob)\r\n vec = embedder.forward()\r\n # 执行分类识别面部\r\n preds = recognizer.predict_proba(vec)[0]\r\n j = np.argmax(preds)\r\n proba = preds[j]\r\n name = le.classes_[j]\r\n # 绘制面部的边界框以及相关的概率\r\n text = \"{}: {:.2f}%\".format(name, proba * 100)\r\n y = startY - 10 if startY - 10 > 10 else startY + 10\r\n cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 0, 255), 2)\r\n frame = cv2.putText(frame, text, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)\r\n face_names.append(name)\r\n\r\n bt_liveness = self.ui.bt_blinks.text()\r\n if bt_liveness == '停止检测':\r\n ChineseText = ChinesePutText.put_chinese_text('microsoft.ttf')\r\n frame = ChineseText.draw_text(frame, (330, 80), ' 请眨眨眼睛 ', 25, (55, 255, 55))\r\n # 显示输出框架\r\n show_video = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # 这里指的是显示原图\r\n # opencv读取图片的样式，不能通过Qlabel进行显示，需要转换为Qimage。\r\n # QImage(uchar * data, int width, int height, int bytesPerLine, Format format)\r\n self.showImage = QImage(show_video.data, show_video.shape[1], show_video.shape[0], QImage.Format_RGB888)\r\n self.ui.label_camera.setPixmap(QPixmap.fromImage(self.showImage))\r\n self.set_name = set(face_names)\r\n self.set_names = tuple(self.set_name)\r\n self.recordNames()\r\n\r\n # 因为最后一张画面会显示在GUI中，此处实现清除。\r\n self.ui.label_camera.clear()\r\n\r\n def recordNames(self):\r\n if self.set_name.issubset(self.record_name1): # 如果self.set_names是self.record_names 的子集返回ture\r\n pass # record_name1是要写进数据库中的名字信息 set_name是从摄像头中读出人脸的tuple形式\r\n else:\r\n self.different_name1 = self.set_name.difference(self.record_name1) # 获取到self.set_name有而self.record_name无的名字\r\n self.record_name1 = self.set_name.union(self.record_name1) # 把self.record_name变成两个集合的并集\r\n # different_name是为了获取到之前没有捕捉到的人脸，并再次将record_name1进行更新\r\n # 将集合变成tuple，并统计人数\r\n self.write_data = tuple(self.different_name1)\r\n names_num = len(self.write_data)\r\n # 显示签到人数\r\n self.ui.lcd_2.display(len(self.record_name1))\r\n\r\n if names_num > 0:\r\n # 将签到信息写入数据库\r\n self.lineTextInfo2 = []\r\n # 打开数据库连接\r\n db2 = pymysql.connect(\"localhost\", \"root\", \"mysql105\", \"facerecognition\")\r\n # 使用cursor()方法获取操作游标\r\n cursor2 = db2.cursor()\r\n # 获取系统时间，保存到秒\r\n import datetime\r\n currentTime2 = str(datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\r\n results2 = self.useIDGetInfo(self.write_data[0])\r\n # 判断是否迟到\r\n import datetime\r\n self.ymd = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\r\n self.ymd2 = datetime.datetime.now().strftime(\"%H:%M:%S\")\r\n compareResult2 = self.compare_time('{}'.format(self.ymd2), '{}'.format(self.checkTime))\r\n\r\n # 82800表示23个小时,在compare_time()函数中,如果第一个时间小于第二个时间,则为第一个时间加24h后再减去第二时间;\r\n # 而正常的结果应该为'正常'.\r\n if compareResult2 <= 82800:\r\n self.description2 = '迟到'\r\n else:\r\n self.description2 = '正常'\r\n self.lineTextInfo2.append((results2[0], results2[1], results2[2], currentTime2, self.description2))\r\n print(self.lineTextInfo2)\r\n\r\n # 写入数据库\r\n try:\r\n # 如果存在数据，先删除再写入。前提是设置唯一索引字段或者主键。\r\n insert_sql2 = \"replace into checkin(Name, ID, Class, Time, Description) values(%s, %s, %s, %s, %s)\"\r\n users2 = self.lineTextInfo2\r\n cursor2.executemany(insert_sql2, users2)\r\n except Exception as e:\r\n print(e)\r\n print(\"SQL execute failed!\")\r\n else:\r\n print(\"SQL execute success!\")\r\n QMessageBox.information(self, \"Tips\", \"签到成功，请勿重复操作！\", QMessageBox.Yes | QMessageBox.No)\r\n # 提交到数据库执行\r\n db2.commit()\r\n cursor2.close()\r\n db2.close()\r\n\r\n # 比较时间大小，判断是否迟到\r\n def compare_time(self, time1, time2):\r\n import datetime\r\n s_time = datetime.datetime.strptime(time1, '%H:%M:%S')\r\n e_time = datetime.datetime.strptime(time2, '%H:%M:%S')\r\n delta = s_time - e_time\r\n return delta.seconds\r\n\r\n # 查询班级人数\r\n def checkNums(self):\r\n # 选择的班级\r\n input_Class = self.ui.comboBox.currentText()\r\n # 打开数据库连接\r\n db = pymysql.connect(\"localhost\", \"root\", \"mysql105\", \"facerecognition\")\r\n # 使用cursor()方法获取操作游标\r\n cursor = db.cursor()\r\n\r\n # 查询语句，实现通过ID关键字检索个人信息的功能\r\n sql = \"select * from studentnums where class = {}\".format(input_Class)\r\n # 执行查询\r\n if input_Class != '':\r\n try:\r\n cursor.execute(sql)\r\n # 获取所有记录列表\r\n results = cursor.fetchall()\r\n self.nums = []\r\n for i in results:\r\n self.nums.append(i[1])\r\n except:\r\n print(\"Error: unable to fetch data\")\r\n\r\n # 用于查询每班的实到人数\r\n sql2 = \"select * from checkin where class = {}\".format(input_Class)\r\n # 执行查询\r\n if input_Class != '':\r\n try:\r\n cursor.execute(sql2)\r\n # 获取所有记录列表\r\n results2 = cursor.fetchall()\r\n self.nums2 = []\r\n for i in results2:\r\n self.nums2.append(i[2])\r\n except:\r\n print(\"Error: unable to fetch data\")\r\n\r\n # lcd控件显示人数\r\n self.ui.lcd_1.display(self.nums[0])\r\n self.ui.lcd_2.display(len(self.nums2))\r\n # 关闭数据库连接\r\n db.close()\r\n\r\n # 请假/补签登记\r\n def leaveButton(self):\r\n self.leaveStudents(1)\r\n def supplymentButton(self):\r\n self.leaveStudents(2)\r\n def leaveStudents(self, button):\r\n self.lineTextInfo = []\r\n # 为防止输入为空卡死，先进行是否输入数据的判断\r\n if self.ui.lineEdit.isModified() or self.ui.lineEdit_2.isModified():\r\n # 打开数据库连接\r\n db = pymysql.connect(\"localhost\", \"root\", \"mysql105\", \"facerecognition\")\r\n # 使用cursor()方法获取操作游标\r\n cursor = db.cursor()\r\n # 获取系统时间，保存到秒\r\n currentTime = str(datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\r\n if button == 1:\r\n self.description = '请假'\r\n self.lineTextID = self.ui.lineEdit.text()\r\n results = self.useIDGetInfo(self.lineTextID)\r\n elif button == 2:\r\n self.description = '漏签补签'\r\n self.lineTextID = self.ui.lineEdit_2.text()\r\n results = self.useIDGetInfo(self.lineTextID)\r\n self.lineTextInfo.append((results[0], results[1], results[2], currentTime, self.description))\r\n # 写入数据库\r\n try:\r\n # 如果存在数据，先删除再写入。前提是设置唯一索引字段或者主键。\r\n insert_sql = \"replace into checkin(Name, ID, Class, Time, Description) values(%s, %s, %s, %s, %s)\"\r\n users = self.lineTextInfo\r\n cursor.executemany(insert_sql, users)\r\n except Exception as e:\r\n print(e)\r\n print(\"sql execute failed\")\r\n else:\r\n print(\"sql execute success\")\r\n QMessageBox.warning(self, \"warning\", \"{} 登记成功，请勿重复操作！\".format(self.description), QMessageBox.Yes | QMessageBox.No)\r\n # 提交到数据库执行\r\n db.commit()\r\n cursor.close()\r\n db.close()\r\n else:\r\n QMessageBox.warning(self, \"warning\", \"学号不能为空，请输入后重试！\", QMessageBox.Yes | QMessageBox.No)\r\n # 输入框清零\r\n self.ui.lineEdit.clear()\r\n self.ui.lineEdit_2.clear()\r\n\r\n # 使用ID当索引找到其它信息\r\n def useIDGetInfo(self, ID):\r\n # 打开数据库连接\r\n db = pymysql.connect(\"localhost\", \"root\", \"mysql105\", \"facerecognition\")\r\n # 使用cursor()方法获取操作游标\r\n cursor = db.cursor()\r\n # 查询语句，实现通过ID关键字检索个人信息的功能\r\n sql = \"select * from students where ID = {}\".format(ID)\r\n # 执行查询\r\n if ID != '':\r\n try:\r\n cursor.execute(sql)\r\n # 获取所有记录列表\r\n results = cursor.fetchall()\r\n self.checkInfo = []\r\n for i in results:\r\n self.checkInfo.append(i[1])\r\n self.checkInfo.append(i[0])\r\n self.checkInfo.append(i[2])\r\n return self.checkInfo\r\n except:\r\n print(\"Error: unable to fetch data\")\r\n\r\n # 显示迟到和未到\r\n def showLateAbsentee(self):\r\n db = pymysql.connect(\"localhost\", \"root\", \"mysql105\", \"facerecognition\")\r\n cursor = db.cursor()\r\n # 一定要注意字符串在检索时要加''！\r\n sql1 = \"select name from checkin where Description = '{}'\".format('迟到')\r\n sql2 = \"select name from students\"\r\n try:\r\n cursor.execute(sql1)\r\n results = cursor.fetchall()\r\n self.lateNums = []\r\n for x in results:\r\n self.lateNums.append(x[0])\r\n self.lateNums.sort()\r\n # print(self.lateNums)\r\n except:\r\n print(\"Error: unable to fetch latedata\")\r\n try:\r\n cursor.execute(sql2)\r\n results2 = cursor.fetchall()\r\n self.allNums = []\r\n for i in results2:\r\n self.allNums.append(i[0])\r\n self.allNums.sort()\r\n print(self.allNums)\r\n except:\r\n print(\"Error: unable to fetch absenteedata\")\r\n\r\n db.commit()\r\n cursor.close()\r\n db.close()\r\n\r\n # 集合运算，算出未到的和迟到的\r\n self.AbsenteeNums = set(set(self.allNums) - set(self.lateNums))\r\n self.AbsenteeNums = list(self.AbsenteeNums)\r\n self.AbsenteeNums.sort()\r\n\r\n # 在控件中显示未到的同学\r\n rowLate = len(self.lateNums)\r\n rowAbsentee = len(self.AbsenteeNums)\r\n model1 = QtGui.QStandardItemModel(rowLate, 0)\r\n # 设置数据行、列标题\r\n model1.setHorizontalHeaderLabels(['姓名'])\r\n # 设置填入数据内容\r\n for row in range(rowLate):\r\n item = QtGui.QStandardItem(self.lateNums[row])\r\n # 设置每个位置的文本值\r\n model1.setItem(row, 0, item)\r\n # 指定显示的tableView控件，实例化表格视图\r\n View1 = self.ui.tableView_escape\r\n View1.setModel(model1)\r\n\r\n # 迟到显示\r\n model2 = QtGui.QStandardItemModel(rowAbsentee, 0)\r\n # 设置数据行、列标题\r\n model2.setHorizontalHeaderLabels(['姓名'])\r\n # 设置填入数据内容\r\n for row in range(rowAbsentee):\r\n item = QtGui.QStandardItem(self.AbsenteeNums[row])\r\n # 设置每个位置的文本值\r\n model2.setItem(row, 0, item)\r\n # 指定显示的tableView控件，实例化表格视图\r\n View2 = self.ui.tableView_late\r\n View2.setModel(model2)\r\n\r\n # 训练人脸识别模型\r\n def trainModel(self):\r\n import GeneratorModel\r\n GeneratorModel.Generator()\r\n GeneratorModel.TrainModel()\r\n print('Model have been trained!')\r\n\r\n##########################################################################################\r\n\r\nclass infoDialog(QWidget):\r\n def __init__(self):\r\n # super()构造器方法返回父级的对象。__init__()方法是构造器的一个方法。\r\n super().__init__()\r\n self.Dialog = infoUI.Ui_Form()\r\n self.Dialog.setupUi(self)\r\n\r\n # 设置窗口名称和图标\r\n self.setWindowTitle('个人信息采集')\r\n self.setWindowIcon(QIcon('fcblogo.jpg'))\r\n\r\n # 设置单张图片背景\r\n pixmap = QPixmap('background2.png')\r\n self.Dialog.label_capture.setPixmap(pixmap)\r\n\r\n # 设置信息采集按键连接函数\r\n self.Dialog.bt_collectInfo.clicked.connect(self.openCam)\r\n # 设置拍照按键连接函数\r\n self.Dialog.bt_takephoto.clicked.connect(self.takePhoto)\r\n # 设置查询信息按键连接函数\r\n self.Dialog.bt_checkInfo.clicked.connect(self.checkInfo)\r\n # 设置写入信息按键连接函数\r\n self.Dialog.bt_changeInfo.clicked.connect(self.changeInfo)\r\n # 初始化信息导入列表\r\n self.users = []\r\n # 初始化摄像头\r\n self.url2 = cv2.CAP_DSHOW\r\n self.cap2 = cv2.VideoCapture()\r\n # 初始化保存人脸数目\r\n self.photos = 0\r\n\r\n def handle_click(self):\r\n if not self.isVisible():\r\n self.show()\r\n def handle_close(self):\r\n self.close()\r\n\r\n def openCam(self):\r\n # 判断摄像头是否打开，如果打开则为true，反之为false\r\n flagCam = self.cap2.isOpened()\r\n if flagCam == False:\r\n # 通过对话框设置被采集人学号\r\n self.text, self.ok = QInputDialog.getText(self, '创建个人图像数据库', '请输入学号:')\r\n if self.ok and self.text != '':\r\n self.Dialog.label_capture.clear()\r\n self.cap2.open(self.url2)\r\n self.showCapture()\r\n elif flagCam == True:\r\n self.cap2.release()\r\n self.Dialog.label_capture.clear()\r\n self.Dialog.bt_collectInfo.setText(u'采集人像')\r\n\r\n def showCapture(self):\r\n self.Dialog.bt_collectInfo.setText(u'停止采集')\r\n self.Dialog.label_capture.clear()\r\n # 导入opencv人脸检测xml文件\r\n cascade = 'haarcascades_cuda/haarcascade_frontalface_default.xml'\r\n # 加载 Haar级联人脸检测库\r\n detector = cv2.CascadeClassifier(cascade)\r\n print(\"[INFO] starting video stream...\")\r\n # 循环来自视频文件流的帧\r\n while self.cap2.isOpened():\r\n ret, frame2 = self.cap2.read()\r\n QApplication.processEvents()\r\n self.orig = frame2.copy()\r\n frame2 = imutils.resize(frame2, width=500)\r\n rects = detector.detectMultiScale(cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY), scaleFactor=1.1,\r\n minNeighbors=5, minSize=(30, 30))\r\n for (x, y, w, h) in rects:\r\n cv2.rectangle(frame2, (x, y), (x + w, y + h), (0, 255, 0), 2)\r\n frame2 = cv2.putText(frame2, \"Have token {}/20 faces\".format(self.photos), (50, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7,\r\n (200, 100, 50), 2)\r\n # 显示输出框架\r\n show_video2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2RGB) # 这里指的是显示原图\r\n # opencv读取图片的样式，不能通过Qlabel进行显示，需要转换为Qimage。\r\n # QImage(uchar * data, int width, int height, int bytesPerLine, Format format)\r\n self.showImage2 = QImage(show_video2.data, show_video2.shape[1], show_video2.shape[0], QImage.Format_RGB888)\r\n self.Dialog.label_capture.setPixmap(QPixmap.fromImage(self.showImage2))\r\n # 因为最后一张画面会显示在GUI中，此处实现清除。\r\n self.Dialog.label_capture.clear()\r\n\r\n # 创建文件夹\r\n def mkdir(self, path):\r\n # 去除首位空格\r\n path = path.strip()\r\n # 去除尾部 \\ 符号\r\n path = path.rstrip(\"\\\\\")\r\n # 判断路径是否存在, 存在=True; 不存在=False\r\n isExists = os.path.exists(path)\r\n # 判断结果\r\n if not isExists:\r\n # 如果不存在则创建目录\r\n os.makedirs(path)\r\n return True\r\n\r\n def takePhoto(self):\r\n self.photos += 1\r\n self.filename = \"D:\\\\Github\\\\class-attendance-system-based-on-face-recognition\\\\02 Main\\\\dataset\\\\{}\\\\\".format(self.text)\r\n self.mkdir(self.filename)\r\n photo_save_path = os.path.join(os.path.dirname(os.path.abspath('__file__')), '{}'.format(self.filename))\r\n self.showImage2.save(photo_save_path + datetime.now().strftime(\"%Y%m%d%H%M%S\") + \".png\")\r\n # p = os.path.sep.join([output, \"{}.png\".format(str(total).zfill(5))])\r\n # cv2.imwrite(p, self.showImage2)\r\n if self.photos == 20:\r\n QMessageBox.information(self, \"Information\", self.tr(\"采集成功!\"), QMessageBox.Yes | QMessageBox.No)\r\n\r\n # 数据库查询\r\n def checkInfo(self):\r\n # 键入ID\r\n self.input_ID = self.Dialog.lineEdit_ID.text()\r\n # 打开数据库连接\r\n db = pymysql.connect(\"localhost\", \"root\", \"mysql105\", \"facerecognition\")\r\n # 使用cursor()方法获取操作游标\r\n cursor = db.cursor()\r\n # 查询语句，实现通过ID关键字检索个人信息的功能\r\n sql = \"SELECT * FROM STUDENTS WHERE ID = {}\".format(self.input_ID)\r\n # 执行查询\r\n if self.input_ID != '':\r\n try:\r\n cursor.execute(sql)\r\n # 获取所有记录列表\r\n results = cursor.fetchall()\r\n self.lists = []\r\n for i in results:\r\n self.lists.append(i[0])\r\n self.lists.append(i[1])\r\n self.lists.append(i[2])\r\n self.lists.append(i[3])\r\n self.lists.append(i[4])\r\n except:\r\n print(\"Error: unable to fetch data\")\r\n\r\n # 设置显示数据层次结构，5行2列(包含行表头)\r\n self.model = QtGui.QStandardItemModel(5, 0)\r\n # 设置数据行、列标题\r\n self.model.setHorizontalHeaderLabels(['值'])\r\n self.model.setVerticalHeaderLabels(['学号', '姓名', '班级', '性别', '生日'])\r\n # 设置填入数据内容\r\n nums = len(self.lists)\r\n if nums == 0:\r\n QMessageBox.warning(self, \"warning\", \"人脸数据库中无此人信息，请马上录入！\", QMessageBox.Yes | QMessageBox.No)\r\n\r\n for row in range(nums):\r\n item = QtGui.QStandardItem(self.lists[row])\r\n # 设置每个位置的文本值\r\n self.model.setItem(row, 0, item)\r\n # 指定显示的tableView控件，实例化表格视图\r\n self.View = self.Dialog.tableView\r\n self.View.setModel(self.model)\r\n # 关闭数据库连接\r\n db.close()\r\n\r\n # 将采集信息写入数据库\r\n def userInfo(self):\r\n ID = self.Dialog.lineEdit_ID.text()\r\n Name = self.Dialog.lineEdit_Name.text()\r\n Class = self.Dialog.lineEdit_Class.text()\r\n Sex = self.Dialog.lineEdit_Sex.text()\r\n Birth = self.Dialog.lineEdit_Birth.text()\r\n self.users.append((ID, Name, Class, Sex, Birth))\r\n return self.users\r\n\r\n def changeInfo(self):\r\n # 打开数据库连接\r\n db = pymysql.connect(\"localhost\", \"root\", \"mysql105\", \"facerecognition\")\r\n # 使用cursor()方法获取操作游标\r\n cursor = db.cursor()\r\n # 写入数据库\r\n try:\r\n # 如果存在数据，先删除再写入。前提是设置唯一索引字段或者主键。\r\n insert_sql = \"replace into students(ID, Name, Class, Sex, Birthday) values(%s, %s, %s, %s, %s)\"\r\n users = self.userInfo()\r\n cursor.executemany(insert_sql, users)\r\n except Exception as e:\r\n print(e)\r\n print(\"sql execute failed\")\r\n else:\r\n print(\"sql execute success\")\r\n QMessageBox.warning(self, \"warning\", \"录入成功，请勿重复操作！\", QMessageBox.Yes | QMessageBox.No)\r\n # 提交到数据库执行\r\n db.commit()\r\n # 关闭数据库\r\n cursor.close()\r\n # 关闭数据库连接\r\n db.close()\r\n\r\nif __name__ == '__main__':\r\n app = QApplication(sys.argv)\r\n # 创建并显示窗口\r\n mainWindow = MainWindow()\r\n infoWindow = infoDialog()\r\n mainWindow.ui.bt_gathering.clicked.connect(infoWindow.handle_click)\r\n mainWindow.show()\r\n sys.exit(app.exec_())"
] | [
[
"numpy.arange",
"scipy.spatial.distance.euclidean",
"numpy.array",
"numpy.argmax"
]
] |
AVsolutionsai/YOLOv3_custom | [
"d974e8305310cef31621b20128ba29c3b09ce2af"
] | [
"yolov3_tf2/models.py"
] | [
"from absl import flags\nfrom absl.flags import FLAGS\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.keras import Model\nfrom tensorflow.keras.layers import (\n Add,\n Concatenate,\n Conv2D,\n Input,\n Lambda,\n LeakyReLU,\n MaxPool2D,\n UpSampling2D,\n ZeroPadding2D,\n)\nfrom tensorflow.keras.regularizers import l2\nfrom tensorflow.keras.losses import (\n binary_crossentropy,\n sparse_categorical_crossentropy\n)\nfrom .batch_norm import BatchNormalization\nfrom .utils import broadcast_iou\n\nyolo_max_boxes = 100\nyolo_iou_threshold = 0.1\nyolo_score_threshold = 0.1\n# customize your model through the following parameters\nflags.DEFINE_integer('yolo_max_boxes', 100, 'maximum number of detections at one time')\nflags.DEFINE_float('yolo_iou_threshold', 0.5, 'iou threshold')\nflags.DEFINE_float('yolo_score_threshold', 0.5, 'score threshold')\n\nyolo_anchors = np.array([(10, 13), (16, 30), (33, 23), (30, 61), (62, 45),\n (59, 119), (116, 90), (156, 198), (373, 326)],\n np.float32) / 416\nyolo_anchor_masks = np.array([[6, 7, 8], [3, 4, 5], [0, 1, 2]])\n\nyolo_tiny_anchors = np.array([(10, 14), (23, 27), (37, 58),\n (81, 82), (135, 169), (344, 319)],\n np.float32) / 416\nyolo_tiny_anchor_masks = np.array([[3, 4, 5], [0, 1, 2]])\n\n\ndef DarknetConv(x, filters, size, strides=1, batch_norm=True):\n if strides == 1:\n padding = 'same'\n else:\n x = ZeroPadding2D(((1, 0), (1, 0)))(x) # top left half-padding\n padding = 'valid'\n x = Conv2D(filters=filters, kernel_size=size,\n strides=strides, padding=padding,\n use_bias=not batch_norm, kernel_regularizer=l2(0.0005))(x)\n if batch_norm:\n x = BatchNormalization()(x)\n x = LeakyReLU(alpha=0.1)(x)\n return x\n\n\ndef DarknetResidual(x, filters):\n prev = x\n x = DarknetConv(x, filters // 2, 1)\n x = DarknetConv(x, filters, 3)\n x = Add()([prev, x])\n return x\n\n\ndef DarknetBlock(x, filters, blocks):\n x = DarknetConv(x, filters, 3, strides=2)\n for _ in range(blocks):\n x = DarknetResidual(x, filters)\n return x\n\n\ndef Darknet(name=None):\n x = inputs = Input([None, None, 3])\n x = DarknetConv(x, 32, 3)\n x = DarknetBlock(x, 64, 1)\n x = DarknetBlock(x, 128, 2) # skip connection\n x = x_36 = DarknetBlock(x, 256, 8) # skip connection\n x = x_61 = DarknetBlock(x, 512, 8)\n x = DarknetBlock(x, 1024, 4)\n return tf.keras.Model(inputs, (x_36, x_61, x), name=name)\n\n\ndef DarknetTiny(name=None):\n x = inputs = Input([None, None, 3])\n x = DarknetConv(x, 16, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 32, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 64, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 128, 3)\n x = MaxPool2D(2, 2, 'same')(x)\n x = x_8 = DarknetConv(x, 256, 3) # skip connection\n x = MaxPool2D(2, 2, 'same')(x)\n x = DarknetConv(x, 512, 3)\n x = MaxPool2D(2, 1, 'same')(x)\n x = DarknetConv(x, 1024, 3)\n return tf.keras.Model(inputs, (x_8, x), name=name)\n\n\ndef YoloConv(filters, name=None):\n def yolo_conv(x_in):\n if isinstance(x_in, tuple):\n inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])\n x, x_skip = inputs\n\n # concat with skip connection\n x = DarknetConv(x, filters, 1)\n x = UpSampling2D(2)(x)\n x = Concatenate()([x, x_skip])\n else:\n x = inputs = Input(x_in.shape[1:])\n\n x = DarknetConv(x, filters, 1)\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, filters, 1)\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, filters, 1)\n return Model(inputs, x, name=name)(x_in)\n return yolo_conv\n\n\ndef YoloConvTiny(filters, name=None):\n def yolo_conv(x_in):\n if isinstance(x_in, tuple):\n inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])\n x, x_skip = inputs\n\n # concat with skip connection\n x = DarknetConv(x, filters, 1)\n x = UpSampling2D(2)(x)\n x = Concatenate()([x, x_skip])\n else:\n x = inputs = Input(x_in.shape[1:])\n x = DarknetConv(x, filters, 1)\n\n return Model(inputs, x, name=name)(x_in)\n return yolo_conv\n\n\ndef YoloOutput(filters, anchors, classes, name=None):\n def yolo_output(x_in):\n x = inputs = Input(x_in.shape[1:])\n x = DarknetConv(x, filters * 2, 3)\n x = DarknetConv(x, anchors * (classes + 5), 1, batch_norm=False)\n x = Lambda(lambda x: tf.reshape(x, (-1, tf.shape(x)[1], tf.shape(x)[2],\n anchors, classes + 5)))(x)\n return tf.keras.Model(inputs, x, name=name)(x_in)\n return yolo_output\n\n\ndef yolo_boxes(pred, anchors, classes):\n # pred: (batch_size, grid, grid, anchors, (x, y, w, h, obj, ...classes))\n grid_size = tf.shape(pred)[1]\n box_xy, box_wh, objectness, class_probs = tf.split(\n pred, (2, 2, 1, classes), axis=-1)\n\n box_xy = tf.sigmoid(box_xy)\n objectness = tf.sigmoid(objectness)\n class_probs = tf.sigmoid(class_probs)\n pred_box = tf.concat((box_xy, box_wh), axis=-1) # original xywh for loss\n\n # !!! grid[x][y] == (y, x)\n grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))\n grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2) # [gx, gy, 1, 2]\n\n box_xy = (box_xy + tf.cast(grid, tf.float32)) / \\\n tf.cast(grid_size, tf.float32)\n box_wh = tf.exp(box_wh) * anchors\n\n box_x1y1 = box_xy - box_wh / 2\n box_x2y2 = box_xy + box_wh / 2\n bbox = tf.concat([box_x1y1, box_x2y2], axis=-1)\n\n return bbox, objectness, class_probs, pred_box\n\n\ndef yolo_nms(outputs, anchors, masks, classes):\n # boxes, conf, type\n b, c, t = [], [], []\n\n for o in outputs:\n b.append(tf.reshape(o[0], (tf.shape(o[0])[0], -1, tf.shape(o[0])[-1])))\n c.append(tf.reshape(o[1], (tf.shape(o[1])[0], -1, tf.shape(o[1])[-1])))\n t.append(tf.reshape(o[2], (tf.shape(o[2])[0], -1, tf.shape(o[2])[-1])))\n\n bbox = tf.concat(b, axis=1)\n confidence = tf.concat(c, axis=1)\n class_probs = tf.concat(t, axis=1)\n\n scores = confidence * class_probs\n boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(\n boxes=tf.reshape(bbox, (tf.shape(bbox)[0], -1, 1, 4)),\n scores=tf.reshape(\n scores, (tf.shape(scores)[0], -1, tf.shape(scores)[-1])),\n max_output_size_per_class=yolo_max_boxes,\n max_total_size=yolo_max_boxes,\n iou_threshold=yolo_iou_threshold,\n score_threshold=yolo_score_threshold\n )\n\n return boxes, scores, classes, valid_detections\n\n\ndef YoloV3(size=None, channels=3, anchors=yolo_anchors,\n masks=yolo_anchor_masks, classes=80, training=False):\n physical_devices = tf.config.experimental.list_physical_devices('GPU')\n if len(physical_devices) > 0:\n tf.config.experimental.set_memory_growth(physical_devices[0], True)\n x = inputs = Input([size, size, channels], name='input')\n\n x_36, x_61, x = Darknet(name='yolo_darknet')(x)\n\n x = YoloConv(512, name='yolo_conv_0')(x)\n output_0 = YoloOutput(512, len(masks[0]), classes, name='yolo_output_0')(x)\n\n x = YoloConv(256, name='yolo_conv_1')((x, x_61))\n output_1 = YoloOutput(256, len(masks[1]), classes, name='yolo_output_1')(x)\n\n x = YoloConv(128, name='yolo_conv_2')((x, x_36))\n output_2 = YoloOutput(128, len(masks[2]), classes, name='yolo_output_2')(x)\n\n if training:\n return Model(inputs, (output_0, output_1, output_2), name='yolov3')\n\n boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),\n name='yolo_boxes_0')(output_0)\n boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),\n name='yolo_boxes_1')(output_1)\n boxes_2 = Lambda(lambda x: yolo_boxes(x, anchors[masks[2]], classes),\n name='yolo_boxes_2')(output_2)\n\n outputs = Lambda(lambda x: yolo_nms(x, anchors, masks, classes),\n name='yolo_nms')((boxes_0[:3], boxes_1[:3], boxes_2[:3]))\n\n return Model(inputs, outputs, name='yolov3')\n\n\ndef YoloV3Tiny(size=None, channels=3, anchors=yolo_tiny_anchors,\n masks=yolo_tiny_anchor_masks, classes=80, training=False):\n physical_devices = tf.config.experimental.list_physical_devices('GPU')\n if len(physical_devices) > 0:\n tf.config.experimental.set_memory_growth(physical_devices[0], True)\n x = inputs = Input([size, size, channels], name='input')\n\n x_8, x = DarknetTiny(name='yolo_darknet')(x)\n\n x = YoloConvTiny(256, name='yolo_conv_0')(x)\n output_0 = YoloOutput(256, len(masks[0]), classes, name='yolo_output_0')(x)\n\n x = YoloConvTiny(128, name='yolo_conv_1')((x, x_8))\n output_1 = YoloOutput(128, len(masks[1]), classes, name='yolo_output_1')(x)\n\n if training:\n return Model(inputs, (output_0, output_1), name='yolov3')\n\n boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),\n name='yolo_boxes_0')(output_0)\n boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),\n name='yolo_boxes_1')(output_1)\n outputs = Lambda(lambda x: yolo_nms(x, anchors, masks, classes),\n name='yolo_nms')((boxes_0[:3], boxes_1[:3]))\n return Model(inputs, outputs, name='yolov3_tiny')\n\n\ndef YoloLoss(anchors, classes=80, ignore_thresh=0.5):\n def yolo_loss(y_true, y_pred):\n # 1. transform all pred outputs\n # y_pred: (batch_size, grid, grid, anchors, (x, y, w, h, obj, ...cls))\n pred_box, pred_obj, pred_class, pred_xywh = yolo_boxes(\n y_pred, anchors, classes)\n pred_xy = pred_xywh[..., 0:2]\n pred_wh = pred_xywh[..., 2:4]\n\n # 2. transform all true outputs\n # y_true: (batch_size, grid, grid, anchors, (x1, y1, x2, y2, obj, cls))\n true_box, true_obj, true_class_idx = tf.split(\n y_true, (4, 1, 1), axis=-1)\n true_xy = (true_box[..., 0:2] + true_box[..., 2:4]) / 2\n true_wh = true_box[..., 2:4] - true_box[..., 0:2]\n\n # give higher weights to small boxes\n box_loss_scale = 2 - true_wh[..., 0] * true_wh[..., 1]\n\n # 3. inverting the pred box equations\n grid_size = tf.shape(y_true)[1]\n grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))\n grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)\n true_xy = true_xy * tf.cast(grid_size, tf.float32) - \\\n tf.cast(grid, tf.float32)\n true_wh = tf.math.log(true_wh / anchors)\n true_wh = tf.where(tf.math.is_inf(true_wh),\n tf.zeros_like(true_wh), true_wh)\n\n # 4. calculate all masks\n obj_mask = tf.squeeze(true_obj, -1)\n # ignore false positive when iou is over threshold\n best_iou = tf.map_fn(\n lambda x: tf.reduce_max(broadcast_iou(x[0], tf.boolean_mask(\n x[1], tf.cast(x[2], tf.bool))), axis=-1),\n (pred_box, true_box, obj_mask),\n tf.float32)\n ignore_mask = tf.cast(best_iou < ignore_thresh, tf.float32)\n\n # 5. calculate all losses\n xy_loss = obj_mask * box_loss_scale * \\\n tf.reduce_sum(tf.square(true_xy - pred_xy), axis=-1)\n wh_loss = obj_mask * box_loss_scale * \\\n tf.reduce_sum(tf.square(true_wh - pred_wh), axis=-1)\n obj_loss = binary_crossentropy(true_obj, pred_obj)\n obj_loss = obj_mask * obj_loss + \\\n (1 - obj_mask) * ignore_mask * obj_loss\n # TODO: use binary_crossentropy instead\n class_loss = obj_mask * sparse_categorical_crossentropy(\n true_class_idx, pred_class)\n\n # 6. sum over (batch, gridx, gridy, anchors) => (batch, 1)\n xy_loss = tf.reduce_sum(xy_loss, axis=(1, 2, 3))\n wh_loss = tf.reduce_sum(wh_loss, axis=(1, 2, 3))\n obj_loss = tf.reduce_sum(obj_loss, axis=(1, 2, 3))\n class_loss = tf.reduce_sum(class_loss, axis=(1, 2, 3))\n\n return xy_loss + wh_loss + obj_loss + class_loss\n return yolo_loss\n"
] | [
[
"tensorflow.keras.layers.Concatenate",
"tensorflow.sigmoid",
"tensorflow.squeeze",
"tensorflow.keras.layers.ZeroPadding2D",
"tensorflow.keras.layers.Add",
"tensorflow.math.is_inf",
"tensorflow.concat",
"tensorflow.keras.losses.sparse_categorical_crossentropy",
"tensorflow.config.experimental.list_physical_devices",
"tensorflow.reduce_sum",
"tensorflow.split",
"tensorflow.math.log",
"tensorflow.config.experimental.set_memory_growth",
"tensorflow.stack",
"tensorflow.shape",
"tensorflow.keras.losses.binary_crossentropy",
"tensorflow.keras.regularizers.l2",
"tensorflow.zeros_like",
"tensorflow.keras.layers.LeakyReLU",
"tensorflow.cast",
"tensorflow.keras.layers.UpSampling2D",
"tensorflow.range",
"tensorflow.keras.Model",
"tensorflow.exp",
"tensorflow.square",
"numpy.array",
"tensorflow.keras.layers.MaxPool2D",
"tensorflow.keras.layers.Input"
]
] |
israel-cj/GAMA-GEISHA | [
"210101df0e280d5c2eb5d325fc26d551bba74ed6"
] | [
"secret/gama/genetic_programming/compilers/scikitlearn.py"
] | [
"from datetime import datetime\nimport logging\nimport os\nimport time\nfrom typing import Callable, Tuple, Optional, Sequence\n\nimport stopit\nfrom sklearn.base import TransformerMixin, is_classifier\nfrom sklearn.model_selection import ShuffleSplit, cross_validate, check_cv\nfrom sklearn.pipeline import Pipeline\n\nfrom gama.utilities.evaluation_library import Evaluation\nfrom gama.utilities.generic.stopwatch import Stopwatch\nimport numpy as np\nfrom gama.utilities.metrics import Metric\nfrom gama.genetic_programming.components import Individual, PrimitiveNode, Fitness\n\nlog = logging.getLogger(__name__)\n\n\ndef primitive_node_to_sklearn(primitive_node: PrimitiveNode) -> object:\n hyperparameters = {\n terminal.output: terminal.value for terminal in primitive_node._terminals\n }\n return primitive_node._primitive.identifier(**hyperparameters)\n\n\ndef compile_individual(\n individual: Individual,\n parameter_checks=None,\n preprocessing_steps: Sequence[Tuple[str, TransformerMixin]] = None,\n) -> Pipeline:\n steps = [\n (str(i), primitive_node_to_sklearn(primitive))\n for i, primitive in enumerate(individual.primitives)\n ]\n if preprocessing_steps:\n steps = steps + list(reversed(preprocessing_steps))\n return Pipeline(list(reversed(steps)))\n\n\ndef object_is_valid_pipeline(o):\n \"\"\" Determines if object behaves like a scikit-learn pipeline. \"\"\"\n return (\n o is not None\n and hasattr(o, \"fit\")\n and hasattr(o, \"predict\")\n and hasattr(o, \"steps\")\n )\n\n\ndef evaluate_pipeline(\n pipeline, x, y_train, timeout: float, metrics: Tuple[Metric], cv=5, subsample=None,\n) -> Tuple:\n \"\"\" Score `pipeline` with k-fold CV according to `metrics` on (a subsample of) X, y\n Returns\n -------\n Tuple:\n prediction: np.ndarray if successful, None if not\n scores: tuple with one float per metric, each value is -inf on fail.\n estimators: list of fitted pipelines if successful, None if not\n error: None if successful, otherwise an Exception\n \"\"\"\n if not object_is_valid_pipeline(pipeline):\n raise TypeError(f\"Pipeline must not be None and requires fit, predict, steps.\")\n if not timeout > 0:\n raise ValueError(f\"`timeout` must be greater than 0, is {timeout}.\")\n\n prediction, estimators = None, None\n # default score for e.g. timeout or failure\n scores = tuple([float(\"-inf\")] * len(metrics))\n\n with stopit.ThreadingTimeout(timeout) as c_mgr:\n try:\n if isinstance(subsample, int) and subsample < len(y_train):\n sampler = ShuffleSplit(n_splits=1, train_size=subsample, random_state=0)\n idx, _ = next(sampler.split(x))\n x, y_train = x.iloc[idx, :], y_train[idx]\n\n splitter = check_cv(cv, y_train, is_classifier(pipeline))\n result = cross_validate(\n pipeline,\n x,\n y_train,\n cv=splitter,\n return_estimator=True,\n scoring=[m.name for m in metrics],\n error_score=\"raise\",\n )\n scores = tuple([np.mean(result[f\"test_{m.name}\"]) for m in metrics])\n estimators = result[\"estimator\"]\n\n for (estimator, (_, test)) in zip(estimators, splitter.split(x, y_train)):\n if any([m.requires_probabilities for m in metrics]):\n fold_pred = estimator.predict_proba(x.iloc[test, :])\n else:\n fold_pred = estimator.predict(x.iloc[test, :])\n\n if prediction is None:\n if fold_pred.ndim == 2:\n prediction = np.empty(shape=(len(y_train), fold_pred.shape[1]))\n else:\n prediction = np.empty(shape=(len(y_train),))\n prediction[test] = fold_pred\n\n # prediction, scores, estimators = cross_val_predict_score(\n # pipeline, x, y_train, cv=cv, metrics=metrics\n # )\n except stopit.TimeoutException:\n # This exception is handled by the ThreadingTimeout context manager.\n raise\n except KeyboardInterrupt:\n raise\n except Exception as e:\n return prediction, scores, estimators, e\n\n if c_mgr.state == c_mgr.INTERRUPTED:\n # A TimeoutException was raised, but not by the context manager.\n # This indicates that the outer context manager (the ea) timed out.\n raise stopit.utils.TimeoutException()\n\n if not c_mgr:\n # For now we treat an eval timeout the same way as\n # e.g. NaN exceptions and use the default score.\n return prediction, scores, estimators, stopit.TimeoutException()\n\n return prediction, tuple(scores), estimators, None\n\n\ndef evaluate_individual(\n individual: Individual,\n evaluate_pipeline: Callable,\n timeout: float = 1e6,\n deadline: Optional[float] = None,\n add_length_to_score: bool = True,\n **kwargs,\n) -> Evaluation:\n \"\"\" Evaluate the pipeline specified by individual, and record\n Parameters\n ----------\n individual: Individual\n Blueprint for the pipeline to evaluate.\n evaluate_pipeline: Callable\n Function which takes the pipeline and produces validation predictions,\n scores, estimators and errors.\n timeout: float (default=1e6)\n Maximum time in seconds that the evaluation is allowed to take.\n Don't depend on high accuracy.\n A shorter timeout is imposed if `deadline` is in less than `timeout` seconds.\n deadline: float, optional\n A time in seconds since epoch.\n Cut off evaluation at `deadline` even if `timeout` seconds have not yet elapsed.\n add_length_to_score: bool (default=True)\n Add the length of the individual to the score result of the evaluation.\n **kwargs: Dict, optional (default=None)\n Passed to `evaluate_pipeline` function.\n Returns\n -------\n Evaluation\n \"\"\"\n result = Evaluation(individual, pid=os.getpid())\n result.start_time = datetime.now()\n\n if deadline is not None:\n time_to_deadline = deadline - time.time()\n timeout = min(timeout, time_to_deadline)\n\n with Stopwatch() as wall_time, Stopwatch(time.process_time) as process_time:\n evaluation = evaluate_pipeline(individual.pipeline, timeout=timeout, **kwargs)\n result._predictions, result.score, result._estimators, error = evaluation\n if error is not None:\n result.error = f\"{type(error)} {str(error)}\"\n result.duration = wall_time.elapsed_time\n\n if add_length_to_score:\n result.score = result.score + (-len(individual.primitives),)\n individual.fitness = Fitness(\n result.score,\n result.start_time,\n wall_time.elapsed_time,\n process_time.elapsed_time,\n )\n\n return result"
] | [
[
"sklearn.model_selection.ShuffleSplit",
"sklearn.model_selection.cross_validate",
"numpy.mean",
"sklearn.base.is_classifier"
]
] |
rhong3/GBM | [
"088b1e99f4fe02395b62d324ec4f9e8402417651"
] | [
"Scripts/Slicer.py"
] | [
"\"\"\"\nTile real scn/svs files; used by Cutter.py\n\nCreated on 11/19/2018\n\n*** Removed imlist storage to minimize memory usage 01/24/2019 ***\n\n@author: RH\n\"\"\"\nfrom openslide import OpenSlide\nimport numpy as np\nimport pandas as pd\nimport multiprocessing as mp\nimport staintools\nfrom PIL import Image\n\n\n# check if a tile is background or not; return a blank pixel percentage score\ndef bgcheck(img, ts):\n the_imagea = np.array(img)[:, :, :3]\n the_imagea = np.nan_to_num(the_imagea)\n mask = (the_imagea[:, :, :3] > 200).astype(np.uint8)\n maskb = (the_imagea[:, :, :3] < 50).astype(np.uint8)\n greya = ((np.ptp(the_imagea[0])) < 100).astype(np.uint8)\n greyb = ((np.ptp(the_imagea[1])) < 100).astype(np.uint8)\n greyc = ((np.ptp(the_imagea[2])) < 100).astype(np.uint8)\n grey = greya * greyb * greyc\n mask = mask[:, :, 0] * mask[:, :, 1] * mask[:, :, 2]\n maskb = maskb[:, :, 0] * maskb[:, :, 1] * maskb[:, :, 2]\n white = (np.sum(mask) + np.sum(maskb)) / (ts * ts) + grey\n return white\n\n\n# Tile color normalization\ndef normalization(img, sttd):\n img = np.array(img)[:, :, :3]\n img = staintools.LuminosityStandardizer.standardize(img)\n normalizer = staintools.StainNormalizer(method='vahadane')\n normalizer.fit(sttd)\n img = normalizer.transform(img)\n img = Image.fromarray(img.astype('uint8'), 'RGB')\n return img\n\n\n# tile method; slp is the scn/svs image; n_y is the number of tiles can be cut on y column to be cut;\n# x and y are the upper left position of each tile; tile_size is tile size; stepsize of each step; x0 is the row to cut.\n# outdir is the output directory for images;\n# imloc record each tile's relative and absolute coordinates; imlist is a list of cut tiles (Removed 01/24/2019).\ndef v_slide(slp, n_y, x, y, tile_size, stepsize, x0, outdir, level, dp, std):\n # pid = os.getpid()\n # print('{}: start working'.format(pid))\n slide = OpenSlide(slp)\n imloc = []\n y0 = 0\n target_x = x0 * stepsize\n image_x = (target_x + x)*(4**level)\n while y0 < n_y:\n target_y = y0 * stepsize\n image_y = (target_y + y)*(4**level)\n img = slide.read_region((image_x, image_y), level, (tile_size, tile_size))\n wscore = bgcheck(img, tile_size)\n if 0.01 < wscore < 0.4:\n img = img.resize((299, 299))\n img = normalization(img, std)\n if dp:\n img.save(outdir + \"/region_x-{}-y-{}_{}.png\".format(image_x, image_y, str(dp)))\n strr = outdir + \"/region_x-{}-y-{}_{}.png\".format(image_x, image_y, str(dp))\n else:\n img.save(outdir + \"/region_x-{}-y-{}.png\".format(image_x, image_y))\n strr = outdir + \"/region_x-{}-y-{}.png\".format(image_x, image_y)\n imloc.append([x0, y0, image_x, image_y, strr])\n y0 += 1\n slide.close()\n return imloc\n\n\n# image_file is the scn/svs name; outdir is the output directory; path_to_slide is where the scn/svs stored.\n# First open the slide, determine how many tiles can be cut, record the residue edges width,\n# and calculate the final output prediction heat map size should be. Then, using multithread to cut tiles, and stack up\n# tiles and their position dictionaries.\ndef tile(image_file, outdir, level, std_img, path_to_slide=\"../images/\", dp=None, ft=1):\n slide = OpenSlide(path_to_slide+image_file)\n slp = str(path_to_slide+image_file)\n print(slp)\n print(slide.level_dimensions)\n\n bounds_width = slide.level_dimensions[level][0]\n bounds_height = slide.level_dimensions[level][1]\n x = 0\n y = 0\n half_width_region = 49*ft\n full_width_region = 299*ft\n stepsize = (full_width_region - half_width_region)\n\n n_x = int((bounds_width - 1) / stepsize)\n n_y = int((bounds_height - 1) / stepsize)\n\n residue_x = int((bounds_width - n_x * stepsize)/50)\n residue_y = int((bounds_height - n_y * stepsize)/50)\n lowres = slide.read_region((x, y), 2, (int(n_x*stepsize/16), int(n_y*stepsize/16)))\n lowres = np.array(lowres)[:,:,:3]\n\n x0 = 0\n # create multiporcessing pool\n print(mp.cpu_count())\n pool = mp.Pool(processes=mp.cpu_count())\n tasks = []\n while x0 < n_x:\n task = tuple((slp, n_y, x, y, full_width_region, stepsize, x0, outdir, level, dp, std_img))\n tasks.append(task)\n x0 += 1\n # slice images with multiprocessing\n temp = pool.starmap(v_slide, tasks)\n tempdict = list(temp)\n temp = None\n pool.close()\n pool.join()\n\n tempdict = list(filter(None, tempdict))\n imloc = []\n list(map(imloc.extend, tempdict))\n imlocpd = pd.DataFrame(imloc, columns = [\"X_pos\", \"Y_pos\", \"X\", \"Y\", \"Loc\"])\n imlocpd = imlocpd.sort_values([\"X_pos\", \"Y_pos\"], ascending=[True, True])\n imlocpd = imlocpd.reset_index(drop=True)\n imlocpd = imlocpd.reset_index(drop=False)\n imlocpd.columns = [\"Num\", \"X_pos\", \"Y_pos\", \"X\", \"Y\", \"Loc\"]\n if dp:\n imlocpd.to_csv(outdir + \"/{}_dict.csv\".format(dp), index=False)\n else:\n imlocpd.to_csv(outdir + \"/dict.csv\", index=False)\n tempdict = None\n ct = len(imloc)\n print(ct)\n\n return n_x, n_y, lowres, residue_x, residue_y, ct\n\n\n"
] | [
[
"numpy.sum",
"pandas.DataFrame",
"numpy.ptp",
"numpy.array",
"numpy.nan_to_num"
]
] |
MarkWuNLP/StreamingTransformer | [
"df9bfe348608b7e55ef1ff70464070c0055ea799"
] | [
"espnet/asr/pytorch_backend/asr_recog.py"
] | [
"#!/usr/bin/env python3\n# encoding: utf-8\n\n# Copyright 2017 Johns Hopkins University (Shinji Watanabe)\n# Apache 2.0 (http://www.apache.org/licenses/LICENSE-2.0)\n\n\"\"\"Training/decoding definition for the speech recognition task.\"\"\"\n\nimport json\nimport logging\nimport os\n\nimport numpy as np\nimport torch\n\nfrom espnet.asr.asr_utils import add_results_to_json, add_single_results\nfrom espnet.asr.asr_utils import get_model_conf\nfrom espnet.asr.asr_utils import torch_load\nfrom espnet.asr.pytorch_backend.asr_init import load_trained_model\nimport espnet.nets.pytorch_backend.lm.default as lm_pytorch\nfrom espnet.utils.deterministic_utils import set_deterministic_pytorch\nfrom espnet.utils.dynamic_import import dynamic_import\nfrom espnet.utils.io_utils import LoadInputsAndTargets\n\n\ndef _recursive_to(xs, device):\n if torch.is_tensor(xs):\n return xs.to(device)\n if isinstance(xs, tuple):\n return tuple(_recursive_to(x, device) for x in xs)\n return xs\n\n\ndef recog(args):\n \"\"\"Decode with the given args.\n\n Args:\n args (namespace): The program arguments.\n\n \"\"\"\n set_deterministic_pytorch(args)\n model, train_args = load_trained_model(args.model)\n model.recog_args = args\n\n\n # read rnnlm\n if args.rnnlm:\n rnnlm_args = get_model_conf(args.rnnlm, args.rnnlm_conf)\n if getattr(rnnlm_args, \"model_module\", \"default\") != \"default\":\n raise ValueError(\n \"use '--api v2' option to decode with non-default language model\"\n )\n rnnlm = lm_pytorch.ClassifierWithState(\n lm_pytorch.RNNLM(\n len(train_args.char_list),\n rnnlm_args.layer,\n rnnlm_args.unit,\n getattr(rnnlm_args, \"embed_unit\", None), # for backward compatibility\n )\n )\n torch_load(args.rnnlm, rnnlm)\n rnnlm.eval()\n else:\n rnnlm = None\n\n\n # gpu\n if args.ngpu == 1:\n gpu_id = list(range(args.ngpu))\n logging.info(\"gpu id: \" + str(gpu_id))\n model.cuda()\n if rnnlm:\n rnnlm.cuda()\n\n # read json data\n with open(args.recog_json, \"rb\") as f:\n js = json.load(f)[\"utts\"]\n new_js = {}\n\n load_inputs_and_targets = LoadInputsAndTargets(\n mode=\"asr\",\n load_output=False,\n sort_in_input_length=False,\n preprocess_conf=train_args.preprocess_conf\n if args.preprocess_conf is None\n else args.preprocess_conf,\n preprocess_args={\"train\": False},\n )\n\n with torch.no_grad():\n for idx, name in enumerate(js.keys(), 1):\n logging.info(\"(%d/%d) decoding \" + name, idx, len(js.keys()))\n batch = [(name, js[name])]\n feat = load_inputs_and_targets(batch)\n feat = feat[0][0]\n if args.prefix_decode:\n best, ids, score = model.prefix_recognize(feat, args, train_args, train_args.char_list, rnnlm)\n new_js[name] = add_single_results(js[name], best, ids, score)\n else:\n nbest_hyps = model.recognize(\n feat, args, train_args.char_list, rnnlm\n )\n new_js[name] = add_results_to_json(\n js[name], nbest_hyps, train_args.char_list\n )\n\n\n with open(args.result_label, \"wb\") as f:\n f.write(\n json.dumps(\n {\"utts\": new_js}, indent=4, ensure_ascii=False, sort_keys=True\n ).encode(\"utf_8\")\n )\n\ndef viterbi_decode(args):\n set_deterministic_pytorch(args)\n idim, odim, train_args = get_model_conf(\n args.model, os.path.join(os.path.dirname(args.model), 'model.json'))\n model_class = dynamic_import(train_args.model_module)\n model = model_class(idim, odim, train_args)\n if args.model is not None:\n load_params = dict(torch.load(args.model))\n if 'model' in load_params:\n load_params = dict(load_params['model'])\n if 'state_dict' in load_params:\n load_params = dict(load_params['state_dict'])\n model_params = dict(model.named_parameters())\n for k, v in load_params.items():\n k = k.replace('module.', '')\n if k in model_params and v.size() == model_params[k].size():\n model_params[k].data = v.data\n logging.warning('load parameters {}'.format(k))\n model.recog_args = args\n\n if args.ngpu == 1:\n gpu_id = list(range(args.ngpu))\n logging.info('gpu id: ' + str(gpu_id))\n model.cuda()\n\n with open(args.recog_json, 'rb') as f:\n js = json.load(f)['utts']\n new_js = {}\n\n\n load_inputs_and_targets = LoadInputsAndTargets(\n mode='asr', load_output=False, sort_in_input_length=False,\n preprocess_conf=train_args.preprocess_conf\n if args.preprocess_conf is None else args.preprocess_conf,\n preprocess_args={'train': False})\n\n\n with torch.no_grad():\n for idx, name in enumerate(js.keys(), 1):\n logging.info('(%d/%d) decoding ' + name, idx, len(js.keys()))\n batch = [(name, js[name])]\n feat = load_inputs_and_targets(batch)\n y = np.fromiter(map(int, batch[0][1]['output'][0]['tokenid'].split()), dtype=np.int64)\n align = model.viterbi_decode(feat[0][0], y)\n assert len(align) == len(y)\n new_js[name] = js[name]\n new_js[name]['output'][0]['align'] = ' '.join([str(i) for i in list(align)])\n\n with open(args.result_label, 'wb') as f:\n f.write(json.dumps({'utts': new_js}, indent=4, ensure_ascii=False, sort_keys=True).encode('utf_8'))\n"
] | [
[
"torch.no_grad",
"torch.is_tensor",
"torch.load"
]
] |
jiyauppal/face-mask-detector.github.io | [
"210ce81fa37c441a076fbb8db28376268e634412"
] | [
"draw_tracking_line.py"
] | [
"import cv2\r\nimport datetime\r\nimport imutils\r\nimport numpy as np\r\nfrom centroidtracker import CentroidTracker\r\nfrom collections import defaultdict\r\n\r\nprotopath = \"MobileNetSSD_deploy.prototxt\"\r\nmodelpath = \"MobileNetSSD_deploy.caffemodel\"\r\ndetector = cv2.dnn.readNetFromCaffe(prototxt=protopath, caffeModel=modelpath)\r\n\r\n# Only enable it if you are using OpenVino environment\r\n# detector.setPreferableBackend(cv2.dnn.DNN_BACKEND_INFERENCE_ENGINE)\r\n# detector.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)\r\n\r\n\r\nCLASSES = [\"background\", \"aeroplane\", \"bicycle\", \"bird\", \"boat\",\r\n \"bottle\", \"bus\", \"car\", \"cat\", \"chair\", \"cow\", \"diningtable\",\r\n \"dog\", \"horse\", \"motorbike\", \"person\", \"pottedplant\", \"sheep\",\r\n \"sofa\", \"train\", \"tvmonitor\"]\r\n\r\ntracker = CentroidTracker(maxDisappeared=80, maxDistance=90)\r\n\r\n\r\ndef non_max_suppression_fast(boxes, overlapThresh):\r\n try:\r\n if len(boxes) == 0:\r\n return []\r\n\r\n if boxes.dtype.kind == \"i\":\r\n boxes = boxes.astype(\"float\")\r\n\r\n pick = []\r\n\r\n x1 = boxes[:, 0]\r\n y1 = boxes[:, 1]\r\n x2 = boxes[:, 2]\r\n y2 = boxes[:, 3]\r\n\r\n area = (x2 - x1 + 1) * (y2 - y1 + 1)\r\n idxs = np.argsort(y2)\r\n\r\n while len(idxs) > 0:\r\n last = len(idxs) - 1\r\n i = idxs[last]\r\n pick.append(i)\r\n\r\n xx1 = np.maximum(x1[i], x1[idxs[:last]])\r\n yy1 = np.maximum(y1[i], y1[idxs[:last]])\r\n xx2 = np.minimum(x2[i], x2[idxs[:last]])\r\n yy2 = np.minimum(y2[i], y2[idxs[:last]])\r\n\r\n w = np.maximum(0, xx2 - xx1 + 1)\r\n h = np.maximum(0, yy2 - yy1 + 1)\r\n\r\n overlap = (w * h) / area[idxs[:last]]\r\n\r\n idxs = np.delete(idxs, np.concatenate(([last],\r\n np.where(overlap > overlapThresh)[0])))\r\n\r\n return boxes[pick].astype(\"int\")\r\n except Exception as e:\r\n print(\"Exception occurred in non_max_suppression : {}\".format(e))\r\n\r\n\r\ndef main():\r\n cap = cv2.VideoCapture('test_video.mp4')\r\n\r\n fps_start_time = datetime.datetime.now()\r\n fps = 0\r\n total_frames = 0\r\n centroid_dict = defaultdict(list)\r\n object_id_list = []\r\n\r\n while True:\r\n ret, frame = cap.read()\r\n frame = imutils.resize(frame, width=600)\r\n total_frames = total_frames + 1\r\n\r\n (H, W) = frame.shape[:2]\r\n\r\n blob = cv2.dnn.blobFromImage(frame, 0.007843, (W, H), 127.5)\r\n\r\n detector.setInput(blob)\r\n person_detections = detector.forward()\r\n rects = []\r\n for i in np.arange(0, person_detections.shape[2]):\r\n confidence = person_detections[0, 0, i, 2]\r\n if confidence > 0.5:\r\n idx = int(person_detections[0, 0, i, 1])\r\n\r\n if CLASSES[idx] != \"person\":\r\n continue\r\n\r\n person_box = person_detections[0, 0, i, 3:7] * np.array([W, H, W, H])\r\n (startX, startY, endX, endY) = person_box.astype(\"int\")\r\n rects.append(person_box)\r\n\r\n boundingboxes = np.array(rects)\r\n boundingboxes = boundingboxes.astype(int)\r\n rects = non_max_suppression_fast(boundingboxes, 0.3)\r\n\r\n objects = tracker.update(rects)\r\n for (objectId, bbox) in objects.items():\r\n x1, y1, x2, y2 = bbox\r\n x1 = int(x1)\r\n y1 = int(y1)\r\n x2 = int(x2)\r\n y2 = int(y2)\r\n\r\n cX = int((x1 + x2) / 2.0)\r\n cY = int((y1 + y2) / 2.0)\r\n cv2.circle(frame, (cX, cY), 4, (0, 255, 0), -1)\r\n\r\n centroid_dict[objectId].append((cX, cY))\r\n if objectId not in object_id_list:\r\n object_id_list.append(objectId)\r\n start_pt = (cX, cY)\r\n end_pt = (cX, cY)\r\n cv2.line(frame, start_pt, end_pt, (0, 255, 0), 2)\r\n else:\r\n l = len(centroid_dict[objectId])\r\n for pt in range(len(centroid_dict[objectId])):\r\n if not pt + 1 == l:\r\n start_pt = (centroid_dict[objectId][pt][0], centroid_dict[objectId][pt][1])\r\n end_pt = (centroid_dict[objectId][pt + 1][0], centroid_dict[objectId][pt + 1][1])\r\n cv2.line(frame, start_pt, end_pt, (0, 255, 0), 2)\r\n\r\n cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 0, 255), 2)\r\n text = \"ID: {}\".format(objectId)\r\n cv2.putText(frame, text, (x1, y1 - 5), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 1)\r\n\r\n fps_end_time = datetime.datetime.now()\r\n time_diff = fps_end_time - fps_start_time\r\n if time_diff.seconds == 0:\r\n fps = 0.0\r\n else:\r\n fps = (total_frames / time_diff.seconds)\r\n\r\n fps_text = \"FPS: {:.2f}\".format(fps)\r\n\r\n cv2.putText(frame, fps_text, (5, 30), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 1)\r\n\r\n cv2.imshow(\"Application\", frame)\r\n key = cv2.waitKey(1)\r\n if key == ord('q'):\r\n break\r\n\r\n cv2.destroyAllWindows()\r\n\r\n\r\nmain()\r\n"
] | [
[
"numpy.maximum",
"numpy.argsort",
"numpy.arange",
"numpy.array",
"numpy.where",
"numpy.minimum"
]
] |
Elenadisa/PhenCo | [
"f320fc286b90ec566afb5edfe3d6d1e3dcc28497"
] | [
"scripts/py_scripts/calculate_cluster_average.py"
] | [
"#! /usr/bin/env python\n##############################################################################################################################################\n#\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tMETHODS\n##############################################################################################################################################\nimport functions as fn\n\n\n##############################################################################################################################################\n#\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tOPTPARSE\n##############################################################################################################################################\nimport optparse\nparser = optparse.OptionParser()\nparser.add_option(\"-c\", \"--cluster file\", dest=\"dictionary\",\n help=\"Input file with the clusters of a network\", metavar=\"FILE\")\nparser.add_option(\"-A\", \"--cluster_id\", dest=\"cluster_id\", \n help=\"column which have clusters identificators\", type='int')\nparser.add_option(\"-B\", \"--item_id\", dest=\"item_id\", \n help=\"column which have HPO o disease identificators\", type='int')\nparser.add_option(\"-m\", \"--model\", dest=\"model_type\",\n help=\"network_type\", metavar=\"str\")\nparser.add_option(\"-n\", \"--model_name\", dest=\"model_name\",\n help=\"network_name\", metavar=\"str\")\nparser.add_option(\"-e\", \"--enrichment_type\", dest=\"enrichment\",\n help=\"type of enrichment\", metavar=\"str\")\nparser.add_option(\"-p\", \"--p_value\", dest=\"pvalue\",\n help=\"pvalue\", metavar=\"float\")\n\n\n(options, args) = parser.parse_args()\n\n###############################################################################################################################################\n# \t\t\t\t\t\t\t\t\t\t\t\t\t\t\tMAIN\n###############################################################################################################################################\nimport numpy as np\nimport os.path as path\n\n#If the principal file exits it makes a dictionary cluster HPO\nif path.exists(options.dictionary): #if the dictionary has a length different to 0 append the length of every cluster in the empty list, esle append 0.\n\tdictionary = fn.build_dictionary(options.dictionary, options.cluster_id, options.item_id)\n\n\tsize = []\t\t#empty list\n\tif int(len(dictionary)) != 0:\t\t\n\t\tfor cluster_id in dictionary:\n\t\t\tsize.append(len(dictionary[cluster_id]))\n\telse:\n\t\tsize.append(0)\n\t \n\tmean = np.mean(size) #Calculate the mean of the clusters length\n\nelse :\t\t\t\t\t#If the dictionary has length 0 the mean of clusters size is 0\n\tmean = 0\n\nprint(options.model_name + \"\\t\" + options.model_type + \"\\t\" + \"Average_Cluster_size_\" + options.enrichment + \"_\" + options.pvalue + \"\\t\" + str(mean))\n\n"
] | [
[
"numpy.mean"
]
] |
sntgl/scipy | [
"6660830eb7d7590d56f1377d27bf7ee97bb3adec"
] | [
"scipy/stats/_distn_infrastructure.py"
] | [
"#\n# Author: Travis Oliphant 2002-2011 with contributions from\n# SciPy Developers 2004-2011\n#\nfrom scipy._lib._util import getfullargspec_no_self as _getfullargspec\n\nimport sys\nimport keyword\nimport re\nimport types\nimport warnings\nimport inspect\nfrom itertools import zip_longest\nfrom collections import namedtuple\n\nfrom scipy._lib import doccer\nfrom scipy._lib._util import _lazywhere\nfrom ._distr_params import distcont, distdiscrete\nfrom scipy._lib._util import check_random_state\n\nfrom scipy.special import (comb, chndtr, entr, xlogy, ive)\n\n# for root finding for continuous distribution ppf, and max likelihood\n# estimation\nfrom scipy import optimize\n\n# for functions of continuous distributions (e.g. moments, entropy, cdf)\nfrom scipy import integrate\n\n# to approximate the pdf of a continuous distribution given its cdf\nfrom scipy.misc import derivative\n\n# for scipy.stats.entropy. Attempts to import just that function or file\n# have cause import problems\nfrom scipy import stats\n\nfrom numpy import (arange, putmask, ravel, ones, shape, ndarray, zeros, floor,\n logical_and, log, sqrt, place, argmax, vectorize, asarray,\n nan, inf, isinf, NINF, empty)\n\nimport numpy as np\nfrom ._constants import _XMAX\n\n# These are the docstring parts used for substitution in specific\n# distribution docstrings\n\ndocheaders = {'methods': \"\"\"\\nMethods\\n-------\\n\"\"\",\n 'notes': \"\"\"\\nNotes\\n-----\\n\"\"\",\n 'examples': \"\"\"\\nExamples\\n--------\\n\"\"\"}\n\n_doc_rvs = \"\"\"\\\nrvs(%(shapes)s, loc=0, scale=1, size=1, random_state=None)\n Random variates.\n\"\"\"\n_doc_pdf = \"\"\"\\\npdf(x, %(shapes)s, loc=0, scale=1)\n Probability density function.\n\"\"\"\n_doc_logpdf = \"\"\"\\\nlogpdf(x, %(shapes)s, loc=0, scale=1)\n Log of the probability density function.\n\"\"\"\n_doc_pmf = \"\"\"\\\npmf(k, %(shapes)s, loc=0, scale=1)\n Probability mass function.\n\"\"\"\n_doc_logpmf = \"\"\"\\\nlogpmf(k, %(shapes)s, loc=0, scale=1)\n Log of the probability mass function.\n\"\"\"\n_doc_cdf = \"\"\"\\\ncdf(x, %(shapes)s, loc=0, scale=1)\n Cumulative distribution function.\n\"\"\"\n_doc_logcdf = \"\"\"\\\nlogcdf(x, %(shapes)s, loc=0, scale=1)\n Log of the cumulative distribution function.\n\"\"\"\n_doc_sf = \"\"\"\\\nsf(x, %(shapes)s, loc=0, scale=1)\n Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate).\n\"\"\"\n_doc_logsf = \"\"\"\\\nlogsf(x, %(shapes)s, loc=0, scale=1)\n Log of the survival function.\n\"\"\"\n_doc_ppf = \"\"\"\\\nppf(q, %(shapes)s, loc=0, scale=1)\n Percent point function (inverse of ``cdf`` --- percentiles).\n\"\"\"\n_doc_isf = \"\"\"\\\nisf(q, %(shapes)s, loc=0, scale=1)\n Inverse survival function (inverse of ``sf``).\n\"\"\"\n_doc_moment = \"\"\"\\\nmoment(order, %(shapes)s, loc=0, scale=1)\n Non-central moment of the specified order.\n\"\"\"\n_doc_stats = \"\"\"\\\nstats(%(shapes)s, loc=0, scale=1, moments='mv')\n Mean('m'), variance('v'), skew('s'), and/or kurtosis('k').\n\"\"\"\n_doc_entropy = \"\"\"\\\nentropy(%(shapes)s, loc=0, scale=1)\n (Differential) entropy of the RV.\n\"\"\"\n_doc_fit = \"\"\"\\\nfit(data)\n Parameter estimates for generic data.\n See `scipy.stats.rv_continuous.fit <https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.rv_continuous.fit.html#scipy.stats.rv_continuous.fit>`__ for detailed documentation of the\n keyword arguments.\n\"\"\"\n_doc_expect = \"\"\"\\\nexpect(func, args=(%(shapes_)s), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds)\n Expected value of a function (of one argument) with respect to the distribution.\n\"\"\"\n_doc_expect_discrete = \"\"\"\\\nexpect(func, args=(%(shapes_)s), loc=0, lb=None, ub=None, conditional=False)\n Expected value of a function (of one argument) with respect to the distribution.\n\"\"\"\n_doc_median = \"\"\"\\\nmedian(%(shapes)s, loc=0, scale=1)\n Median of the distribution.\n\"\"\"\n_doc_mean = \"\"\"\\\nmean(%(shapes)s, loc=0, scale=1)\n Mean of the distribution.\n\"\"\"\n_doc_var = \"\"\"\\\nvar(%(shapes)s, loc=0, scale=1)\n Variance of the distribution.\n\"\"\"\n_doc_std = \"\"\"\\\nstd(%(shapes)s, loc=0, scale=1)\n Standard deviation of the distribution.\n\"\"\"\n_doc_interval = \"\"\"\\\ninterval(confidence, %(shapes)s, loc=0, scale=1)\n Confidence interval with equal areas around the median.\n\"\"\"\n_doc_allmethods = ''.join([docheaders['methods'], _doc_rvs, _doc_pdf,\n _doc_logpdf, _doc_cdf, _doc_logcdf, _doc_sf,\n _doc_logsf, _doc_ppf, _doc_isf, _doc_moment,\n _doc_stats, _doc_entropy, _doc_fit,\n _doc_expect, _doc_median,\n _doc_mean, _doc_var, _doc_std, _doc_interval])\n\n_doc_default_longsummary = \"\"\"\\\nAs an instance of the `rv_continuous` class, `%(name)s` object inherits from it\na collection of generic methods (see below for the full list),\nand completes them with details specific for this particular distribution.\n\"\"\"\n\n_doc_default_frozen_note = \"\"\"\nAlternatively, the object may be called (as a function) to fix the shape,\nlocation, and scale parameters returning a \"frozen\" continuous RV object:\n\nrv = %(name)s(%(shapes)s, loc=0, scale=1)\n - Frozen RV object with the same methods but holding the given shape,\n location, and scale fixed.\n\"\"\"\n_doc_default_example = \"\"\"\\\nExamples\n--------\n>>> from scipy.stats import %(name)s\n>>> import matplotlib.pyplot as plt\n>>> fig, ax = plt.subplots(1, 1)\n\nCalculate the first four moments:\n\n%(set_vals_stmt)s\n>>> mean, var, skew, kurt = %(name)s.stats(%(shapes)s, moments='mvsk')\n\nDisplay the probability density function (``pdf``):\n\n>>> x = np.linspace(%(name)s.ppf(0.01, %(shapes)s),\n... %(name)s.ppf(0.99, %(shapes)s), 100)\n>>> ax.plot(x, %(name)s.pdf(x, %(shapes)s),\n... 'r-', lw=5, alpha=0.6, label='%(name)s pdf')\n\nAlternatively, the distribution object can be called (as a function)\nto fix the shape, location and scale parameters. This returns a \"frozen\"\nRV object holding the given parameters fixed.\n\nFreeze the distribution and display the frozen ``pdf``:\n\n>>> rv = %(name)s(%(shapes)s)\n>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')\n\nCheck accuracy of ``cdf`` and ``ppf``:\n\n>>> vals = %(name)s.ppf([0.001, 0.5, 0.999], %(shapes)s)\n>>> np.allclose([0.001, 0.5, 0.999], %(name)s.cdf(vals, %(shapes)s))\nTrue\n\nGenerate random numbers:\n\n>>> r = %(name)s.rvs(%(shapes)s, size=1000)\n\nAnd compare the histogram:\n\n>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2)\n>>> ax.legend(loc='best', frameon=False)\n>>> plt.show()\n\n\"\"\"\n\n_doc_default_locscale = \"\"\"\\\nThe probability density above is defined in the \"standardized\" form. To shift\nand/or scale the distribution use the ``loc`` and ``scale`` parameters.\nSpecifically, ``%(name)s.pdf(x, %(shapes)s, loc, scale)`` is identically\nequivalent to ``%(name)s.pdf(y, %(shapes)s) / scale`` with\n``y = (x - loc) / scale``. Note that shifting the location of a distribution\ndoes not make it a \"noncentral\" distribution; noncentral generalizations of\nsome distributions are available in separate classes.\n\"\"\"\n\n_doc_default = ''.join([_doc_default_longsummary,\n _doc_allmethods,\n '\\n',\n _doc_default_example])\n\n_doc_default_before_notes = ''.join([_doc_default_longsummary,\n _doc_allmethods])\n\ndocdict = {\n 'rvs': _doc_rvs,\n 'pdf': _doc_pdf,\n 'logpdf': _doc_logpdf,\n 'cdf': _doc_cdf,\n 'logcdf': _doc_logcdf,\n 'sf': _doc_sf,\n 'logsf': _doc_logsf,\n 'ppf': _doc_ppf,\n 'isf': _doc_isf,\n 'stats': _doc_stats,\n 'entropy': _doc_entropy,\n 'fit': _doc_fit,\n 'moment': _doc_moment,\n 'expect': _doc_expect,\n 'interval': _doc_interval,\n 'mean': _doc_mean,\n 'std': _doc_std,\n 'var': _doc_var,\n 'median': _doc_median,\n 'allmethods': _doc_allmethods,\n 'longsummary': _doc_default_longsummary,\n 'frozennote': _doc_default_frozen_note,\n 'example': _doc_default_example,\n 'default': _doc_default,\n 'before_notes': _doc_default_before_notes,\n 'after_notes': _doc_default_locscale\n}\n\n# Reuse common content between continuous and discrete docs, change some\n# minor bits.\ndocdict_discrete = docdict.copy()\n\ndocdict_discrete['pmf'] = _doc_pmf\ndocdict_discrete['logpmf'] = _doc_logpmf\ndocdict_discrete['expect'] = _doc_expect_discrete\n_doc_disc_methods = ['rvs', 'pmf', 'logpmf', 'cdf', 'logcdf', 'sf', 'logsf',\n 'ppf', 'isf', 'stats', 'entropy', 'expect', 'median',\n 'mean', 'var', 'std', 'interval']\nfor obj in _doc_disc_methods:\n docdict_discrete[obj] = docdict_discrete[obj].replace(', scale=1', '')\n\n_doc_disc_methods_err_varname = ['cdf', 'logcdf', 'sf', 'logsf']\nfor obj in _doc_disc_methods_err_varname:\n docdict_discrete[obj] = docdict_discrete[obj].replace('(x, ', '(k, ')\n\ndocdict_discrete.pop('pdf')\ndocdict_discrete.pop('logpdf')\n\n_doc_allmethods = ''.join([docdict_discrete[obj] for obj in _doc_disc_methods])\ndocdict_discrete['allmethods'] = docheaders['methods'] + _doc_allmethods\n\ndocdict_discrete['longsummary'] = _doc_default_longsummary.replace(\n 'rv_continuous', 'rv_discrete')\n\n_doc_default_frozen_note = \"\"\"\nAlternatively, the object may be called (as a function) to fix the shape and\nlocation parameters returning a \"frozen\" discrete RV object:\n\nrv = %(name)s(%(shapes)s, loc=0)\n - Frozen RV object with the same methods but holding the given shape and\n location fixed.\n\"\"\"\ndocdict_discrete['frozennote'] = _doc_default_frozen_note\n\n_doc_default_discrete_example = \"\"\"\\\nExamples\n--------\n>>> from scipy.stats import %(name)s\n>>> import matplotlib.pyplot as plt\n>>> fig, ax = plt.subplots(1, 1)\n\nCalculate the first four moments:\n\n%(set_vals_stmt)s\n>>> mean, var, skew, kurt = %(name)s.stats(%(shapes)s, moments='mvsk')\n\nDisplay the probability mass function (``pmf``):\n\n>>> x = np.arange(%(name)s.ppf(0.01, %(shapes)s),\n... %(name)s.ppf(0.99, %(shapes)s))\n>>> ax.plot(x, %(name)s.pmf(x, %(shapes)s), 'bo', ms=8, label='%(name)s pmf')\n>>> ax.vlines(x, 0, %(name)s.pmf(x, %(shapes)s), colors='b', lw=5, alpha=0.5)\n\nAlternatively, the distribution object can be called (as a function)\nto fix the shape and location. This returns a \"frozen\" RV object holding\nthe given parameters fixed.\n\nFreeze the distribution and display the frozen ``pmf``:\n\n>>> rv = %(name)s(%(shapes)s)\n>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,\n... label='frozen pmf')\n>>> ax.legend(loc='best', frameon=False)\n>>> plt.show()\n\nCheck accuracy of ``cdf`` and ``ppf``:\n\n>>> prob = %(name)s.cdf(x, %(shapes)s)\n>>> np.allclose(x, %(name)s.ppf(prob, %(shapes)s))\nTrue\n\nGenerate random numbers:\n\n>>> r = %(name)s.rvs(%(shapes)s, size=1000)\n\"\"\"\n\n\n_doc_default_discrete_locscale = \"\"\"\\\nThe probability mass function above is defined in the \"standardized\" form.\nTo shift distribution use the ``loc`` parameter.\nSpecifically, ``%(name)s.pmf(k, %(shapes)s, loc)`` is identically\nequivalent to ``%(name)s.pmf(k - loc, %(shapes)s)``.\n\"\"\"\n\ndocdict_discrete['example'] = _doc_default_discrete_example\ndocdict_discrete['after_notes'] = _doc_default_discrete_locscale\n\n_doc_default_before_notes = ''.join([docdict_discrete['longsummary'],\n docdict_discrete['allmethods']])\ndocdict_discrete['before_notes'] = _doc_default_before_notes\n\n_doc_default_disc = ''.join([docdict_discrete['longsummary'],\n docdict_discrete['allmethods'],\n docdict_discrete['frozennote'],\n docdict_discrete['example']])\ndocdict_discrete['default'] = _doc_default_disc\n\n# clean up all the separate docstring elements, we do not need them anymore\nfor obj in [s for s in dir() if s.startswith('_doc_')]:\n exec('del ' + obj)\ndel obj\n\n\ndef _moment(data, n, mu=None):\n if mu is None:\n mu = data.mean()\n return ((data - mu)**n).mean()\n\n\ndef _moment_from_stats(n, mu, mu2, g1, g2, moment_func, args):\n if (n == 0):\n return 1.0\n elif (n == 1):\n if mu is None:\n val = moment_func(1, *args)\n else:\n val = mu\n elif (n == 2):\n if mu2 is None or mu is None:\n val = moment_func(2, *args)\n else:\n val = mu2 + mu*mu\n elif (n == 3):\n if g1 is None or mu2 is None or mu is None:\n val = moment_func(3, *args)\n else:\n mu3 = g1 * np.power(mu2, 1.5) # 3rd central moment\n val = mu3+3*mu*mu2+mu*mu*mu # 3rd non-central moment\n elif (n == 4):\n if g1 is None or g2 is None or mu2 is None or mu is None:\n val = moment_func(4, *args)\n else:\n mu4 = (g2+3.0)*(mu2**2.0) # 4th central moment\n mu3 = g1*np.power(mu2, 1.5) # 3rd central moment\n val = mu4+4*mu*mu3+6*mu*mu*mu2+mu*mu*mu*mu\n else:\n val = moment_func(n, *args)\n\n return val\n\n\ndef _skew(data):\n \"\"\"\n skew is third central moment / variance**(1.5)\n \"\"\"\n data = np.ravel(data)\n mu = data.mean()\n m2 = ((data - mu)**2).mean()\n m3 = ((data - mu)**3).mean()\n return m3 / np.power(m2, 1.5)\n\n\ndef _kurtosis(data):\n \"\"\"kurtosis is fourth central moment / variance**2 - 3.\"\"\"\n data = np.ravel(data)\n mu = data.mean()\n m2 = ((data - mu)**2).mean()\n m4 = ((data - mu)**4).mean()\n return m4 / m2**2 - 3\n\n\ndef _fit_determine_optimizer(optimizer):\n if not callable(optimizer) and isinstance(optimizer, str):\n if not optimizer.startswith('fmin_'):\n optimizer = \"fmin_\"+optimizer\n if optimizer == 'fmin_':\n optimizer = 'fmin'\n try:\n optimizer = getattr(optimize, optimizer)\n except AttributeError as e:\n raise ValueError(\"%s is not a valid optimizer\" % optimizer) from e\n return optimizer\n\n\n# Frozen RV class\nclass rv_frozen:\n\n def __init__(self, dist, *args, **kwds):\n self.args = args\n self.kwds = kwds\n\n # create a new instance\n self.dist = dist.__class__(**dist._updated_ctor_param())\n\n shapes, _, _ = self.dist._parse_args(*args, **kwds)\n self.a, self.b = self.dist._get_support(*shapes)\n\n @property\n def random_state(self):\n return self.dist._random_state\n\n @random_state.setter\n def random_state(self, seed):\n self.dist._random_state = check_random_state(seed)\n\n def cdf(self, x):\n return self.dist.cdf(x, *self.args, **self.kwds)\n\n def logcdf(self, x):\n return self.dist.logcdf(x, *self.args, **self.kwds)\n\n def ppf(self, q):\n return self.dist.ppf(q, *self.args, **self.kwds)\n\n def isf(self, q):\n return self.dist.isf(q, *self.args, **self.kwds)\n\n def rvs(self, size=None, random_state=None):\n kwds = self.kwds.copy()\n kwds.update({'size': size, 'random_state': random_state})\n return self.dist.rvs(*self.args, **kwds)\n\n def sf(self, x):\n return self.dist.sf(x, *self.args, **self.kwds)\n\n def logsf(self, x):\n return self.dist.logsf(x, *self.args, **self.kwds)\n\n def stats(self, moments='mv'):\n kwds = self.kwds.copy()\n kwds.update({'moments': moments})\n return self.dist.stats(*self.args, **kwds)\n\n def median(self):\n return self.dist.median(*self.args, **self.kwds)\n\n def mean(self):\n return self.dist.mean(*self.args, **self.kwds)\n\n def var(self):\n return self.dist.var(*self.args, **self.kwds)\n\n def std(self):\n return self.dist.std(*self.args, **self.kwds)\n\n def moment(self, order=None, **kwds):\n return self.dist.moment(order, *self.args, **self.kwds, **kwds)\n\n def entropy(self):\n return self.dist.entropy(*self.args, **self.kwds)\n\n def interval(self, confidence=None, **kwds):\n return self.dist.interval(confidence, *self.args, **self.kwds, **kwds)\n\n def expect(self, func=None, lb=None, ub=None, conditional=False, **kwds):\n # expect method only accepts shape parameters as positional args\n # hence convert self.args, self.kwds, also loc/scale\n # See the .expect method docstrings for the meaning of\n # other parameters.\n a, loc, scale = self.dist._parse_args(*self.args, **self.kwds)\n if isinstance(self.dist, rv_discrete):\n return self.dist.expect(func, a, loc, lb, ub, conditional, **kwds)\n else:\n return self.dist.expect(func, a, loc, scale, lb, ub,\n conditional, **kwds)\n\n def support(self):\n return self.dist.support(*self.args, **self.kwds)\n\n\nclass rv_discrete_frozen(rv_frozen):\n\n def pmf(self, k):\n return self.dist.pmf(k, *self.args, **self.kwds)\n\n def logpmf(self, k): # No error\n return self.dist.logpmf(k, *self.args, **self.kwds)\n\n\nclass rv_continuous_frozen(rv_frozen):\n\n def pdf(self, x):\n return self.dist.pdf(x, *self.args, **self.kwds)\n\n def logpdf(self, x):\n return self.dist.logpdf(x, *self.args, **self.kwds)\n\n\ndef argsreduce(cond, *args):\n \"\"\"Clean arguments to:\n\n 1. Ensure all arguments are iterable (arrays of dimension at least one\n 2. If cond != True and size > 1, ravel(args[i]) where ravel(condition) is\n True, in 1D.\n\n Return list of processed arguments.\n\n Examples\n --------\n >>> rng = np.random.default_rng()\n >>> A = rng.random((4, 5))\n >>> B = 2\n >>> C = rng.random((1, 5))\n >>> cond = np.ones(A.shape)\n >>> [A1, B1, C1] = argsreduce(cond, A, B, C)\n >>> A1.shape\n (4, 5)\n >>> B1.shape\n (1,)\n >>> C1.shape\n (1, 5)\n >>> cond[2,:] = 0\n >>> [A1, B1, C1] = argsreduce(cond, A, B, C)\n >>> A1.shape\n (15,)\n >>> B1.shape\n (1,)\n >>> C1.shape\n (15,)\n\n \"\"\"\n # some distributions assume arguments are iterable.\n newargs = np.atleast_1d(*args)\n\n # np.atleast_1d returns an array if only one argument, or a list of arrays\n # if more than one argument.\n if not isinstance(newargs, list):\n newargs = [newargs, ]\n\n if np.all(cond):\n # broadcast arrays with cond\n *newargs, cond = np.broadcast_arrays(*newargs, cond)\n return [arg.ravel() for arg in newargs]\n\n s = cond.shape\n # np.extract returns flattened arrays, which are not broadcastable together\n # unless they are either the same size or size == 1.\n return [(arg if np.size(arg) == 1\n else np.extract(cond, np.broadcast_to(arg, s)))\n for arg in newargs]\n\n\nparse_arg_template = \"\"\"\ndef _parse_args(self, %(shape_arg_str)s %(locscale_in)s):\n return (%(shape_arg_str)s), %(locscale_out)s\n\ndef _parse_args_rvs(self, %(shape_arg_str)s %(locscale_in)s, size=None):\n return self._argcheck_rvs(%(shape_arg_str)s %(locscale_out)s, size=size)\n\ndef _parse_args_stats(self, %(shape_arg_str)s %(locscale_in)s, moments='mv'):\n return (%(shape_arg_str)s), %(locscale_out)s, moments\n\"\"\"\n\n\n# Both the continuous and discrete distributions depend on ncx2.\n# The function name ncx2 is an abbreviation for noncentral chi squared.\n\ndef _ncx2_log_pdf(x, df, nc):\n # We use (xs**2 + ns**2)/2 = (xs - ns)**2/2 + xs*ns, and include the\n # factor of exp(-xs*ns) into the ive function to improve numerical\n # stability at large values of xs. See also `rice.pdf`.\n df2 = df/2.0 - 1.0\n xs, ns = np.sqrt(x), np.sqrt(nc)\n res = xlogy(df2/2.0, x/nc) - 0.5*(xs - ns)**2\n corr = ive(df2, xs*ns) / 2.0\n # Return res + np.log(corr) avoiding np.log(0)\n return _lazywhere(\n corr > 0,\n (res, corr),\n f=lambda r, c: r + np.log(c),\n fillvalue=-np.inf)\n\n\ndef _ncx2_pdf(x, df, nc):\n # Copy of _ncx2_log_pdf avoiding np.log(0) when corr = 0\n df2 = df/2.0 - 1.0\n xs, ns = np.sqrt(x), np.sqrt(nc)\n res = xlogy(df2/2.0, x/nc) - 0.5*(xs - ns)**2\n corr = ive(df2, xs*ns) / 2.0\n return np.exp(res) * corr\n\n\ndef _ncx2_cdf(x, df, nc):\n return chndtr(x, df, nc)\n\n\nclass rv_generic:\n \"\"\"Class which encapsulates common functionality between rv_discrete\n and rv_continuous.\n\n \"\"\"\n def __init__(self, seed=None):\n super().__init__()\n\n # figure out if _stats signature has 'moments' keyword\n sig = _getfullargspec(self._stats)\n self._stats_has_moments = ((sig.varkw is not None) or\n ('moments' in sig.args) or\n ('moments' in sig.kwonlyargs))\n self._random_state = check_random_state(seed)\n\n # For historical reasons, `size` was made an attribute that was read\n # inside _rvs(). The code is being changed so that 'size'\n # is an argument\n # to self._rvs(). However some external (non-SciPy) distributions\n # have not\n # been updated. Maintain backwards compatibility by checking if\n # the self._rvs() signature has the 'size' keyword, or a **kwarg,\n # and if not set self._size inside self.rvs()\n # before calling self._rvs().\n argspec = inspect.getfullargspec(self._rvs)\n self._rvs_uses_size_attribute = (argspec.varkw is None and\n 'size' not in argspec.args and\n 'size' not in argspec.kwonlyargs)\n # Warn on first use only\n self._rvs_size_warned = False\n\n @property\n def random_state(self):\n \"\"\"Get or set the generator object for generating random variates.\n\n If `seed` is None (or `np.random`), the `numpy.random.RandomState`\n singleton is used.\n If `seed` is an int, a new ``RandomState`` instance is used,\n seeded with `seed`.\n If `seed` is already a ``Generator`` or ``RandomState`` instance then\n that instance is used.\n\n \"\"\"\n return self._random_state\n\n @random_state.setter\n def random_state(self, seed):\n self._random_state = check_random_state(seed)\n\n def __setstate__(self, state):\n try:\n self.__dict__.update(state)\n # attaches the dynamically created methods on each instance.\n # if a subclass overrides rv_generic.__setstate__, or implements\n # it's own _attach_methods, then it must make sure that\n # _attach_argparser_methods is called.\n self._attach_methods()\n except ValueError:\n # reconstitute an old pickle scipy<1.6, that contains\n # (_ctor_param, random_state) as state\n self._ctor_param = state[0]\n self._random_state = state[1]\n self.__init__()\n\n def _attach_methods(self):\n \"\"\"Attaches dynamically created methods to the rv_* instance.\n\n This method must be overridden by subclasses, and must itself call\n _attach_argparser_methods. This method is called in __init__ in\n subclasses, and in __setstate__\n \"\"\"\n raise NotImplementedError\n\n def _attach_argparser_methods(self):\n \"\"\"\n Generates the argument-parsing functions dynamically and attaches\n them to the instance.\n\n Should be called from `_attach_methods`, typically in __init__ and\n during unpickling (__setstate__)\n \"\"\"\n ns = {}\n exec(self._parse_arg_template, ns)\n # NB: attach to the instance, not class\n for name in ['_parse_args', '_parse_args_stats', '_parse_args_rvs']:\n setattr(self, name, types.MethodType(ns[name], self))\n\n def _construct_argparser(\n self, meths_to_inspect, locscale_in, locscale_out):\n \"\"\"Construct the parser string for the shape arguments.\n\n This method should be called in __init__ of a class for each\n distribution. It creates the `_parse_arg_template` attribute that is\n then used by `_attach_argparser_methods` to dynamically create and\n attach the `_parse_args`, `_parse_args_stats`, `_parse_args_rvs`\n methods to the instance.\n\n If self.shapes is a non-empty string, interprets it as a\n comma-separated list of shape parameters.\n\n Otherwise inspects the call signatures of `meths_to_inspect`\n and constructs the argument-parsing functions from these.\n In this case also sets `shapes` and `numargs`.\n \"\"\"\n\n if self.shapes:\n # sanitize the user-supplied shapes\n if not isinstance(self.shapes, str):\n raise TypeError('shapes must be a string.')\n\n shapes = self.shapes.replace(',', ' ').split()\n\n for field in shapes:\n if keyword.iskeyword(field):\n raise SyntaxError('keywords cannot be used as shapes.')\n if not re.match('^[_a-zA-Z][_a-zA-Z0-9]*$', field):\n raise SyntaxError(\n 'shapes must be valid python identifiers')\n else:\n # find out the call signatures (_pdf, _cdf etc), deduce shape\n # arguments. Generic methods only have 'self, x', any further args\n # are shapes.\n shapes_list = []\n for meth in meths_to_inspect:\n shapes_args = _getfullargspec(meth) # NB does not contain self\n args = shapes_args.args[1:] # peel off 'x', too\n\n if args:\n shapes_list.append(args)\n\n # *args or **kwargs are not allowed w/automatic shapes\n if shapes_args.varargs is not None:\n raise TypeError(\n '*args are not allowed w/out explicit shapes')\n if shapes_args.varkw is not None:\n raise TypeError(\n '**kwds are not allowed w/out explicit shapes')\n if shapes_args.kwonlyargs:\n raise TypeError(\n 'kwonly args are not allowed w/out explicit shapes')\n if shapes_args.defaults is not None:\n raise TypeError('defaults are not allowed for shapes')\n\n if shapes_list:\n shapes = shapes_list[0]\n\n # make sure the signatures are consistent\n for item in shapes_list:\n if item != shapes:\n raise TypeError('Shape arguments are inconsistent.')\n else:\n shapes = []\n\n # have the arguments, construct the method from template\n shapes_str = ', '.join(shapes) + ', ' if shapes else '' # NB: not None\n dct = dict(shape_arg_str=shapes_str,\n locscale_in=locscale_in,\n locscale_out=locscale_out,\n )\n\n # this string is used by _attach_argparser_methods\n self._parse_arg_template = parse_arg_template % dct\n\n self.shapes = ', '.join(shapes) if shapes else None\n if not hasattr(self, 'numargs'):\n # allows more general subclassing with *args\n self.numargs = len(shapes)\n\n def _construct_doc(self, docdict, shapes_vals=None):\n \"\"\"Construct the instance docstring with string substitutions.\"\"\"\n tempdict = docdict.copy()\n tempdict['name'] = self.name or 'distname'\n tempdict['shapes'] = self.shapes or ''\n\n if shapes_vals is None:\n shapes_vals = ()\n vals = ', '.join('%.3g' % val for val in shapes_vals)\n tempdict['vals'] = vals\n\n tempdict['shapes_'] = self.shapes or ''\n if self.shapes and self.numargs == 1:\n tempdict['shapes_'] += ','\n\n if self.shapes:\n tempdict['set_vals_stmt'] = '>>> %s = %s' % (self.shapes, vals)\n else:\n tempdict['set_vals_stmt'] = ''\n\n if self.shapes is None:\n # remove shapes from call parameters if there are none\n for item in ['default', 'before_notes']:\n tempdict[item] = tempdict[item].replace(\n \"\\n%(shapes)s : array_like\\n shape parameters\", \"\")\n for i in range(2):\n if self.shapes is None:\n # necessary because we use %(shapes)s in two forms (w w/o \", \")\n self.__doc__ = self.__doc__.replace(\"%(shapes)s, \", \"\")\n try:\n self.__doc__ = doccer.docformat(self.__doc__, tempdict)\n except TypeError as e:\n raise Exception(\"Unable to construct docstring for \"\n \"distribution \\\"%s\\\": %s\" %\n (self.name, repr(e))) from e\n\n # correct for empty shapes\n self.__doc__ = self.__doc__.replace('(, ', '(').replace(', )', ')')\n\n def _construct_default_doc(self, longname=None, extradoc=None,\n docdict=None, discrete='continuous'):\n \"\"\"Construct instance docstring from the default template.\"\"\"\n if longname is None:\n longname = 'A'\n if extradoc is None:\n extradoc = ''\n if extradoc.startswith('\\n\\n'):\n extradoc = extradoc[2:]\n self.__doc__ = ''.join(['%s %s random variable.' % (longname, discrete),\n '\\n\\n%(before_notes)s\\n', docheaders['notes'],\n extradoc, '\\n%(example)s'])\n self._construct_doc(docdict)\n\n def freeze(self, *args, **kwds):\n \"\"\"Freeze the distribution for the given arguments.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution. Should include all\n the non-optional arguments, may include ``loc`` and ``scale``.\n\n Returns\n -------\n rv_frozen : rv_frozen instance\n The frozen distribution.\n\n \"\"\"\n if isinstance(self, rv_continuous):\n return rv_continuous_frozen(self, *args, **kwds)\n else:\n return rv_discrete_frozen(self, *args, **kwds)\n\n def __call__(self, *args, **kwds):\n return self.freeze(*args, **kwds)\n __call__.__doc__ = freeze.__doc__\n\n # The actual calculation functions (no basic checking need be done)\n # If these are defined, the others won't be looked at.\n # Otherwise, the other set can be defined.\n def _stats(self, *args, **kwds):\n return None, None, None, None\n\n # Noncentral moments (also known as the moment about the origin).\n # Expressed in LaTeX, munp would be $\\mu'_{n}$, i.e. \"mu-sub-n-prime\".\n # The primed mu is a widely used notation for the noncentral moment.\n def _munp(self, n, *args):\n # Silence floating point warnings from integration.\n with np.errstate(all='ignore'):\n vals = self.generic_moment(n, *args)\n return vals\n\n def _argcheck_rvs(self, *args, **kwargs):\n # Handle broadcasting and size validation of the rvs method.\n # Subclasses should not have to override this method.\n # The rule is that if `size` is not None, then `size` gives the\n # shape of the result (integer values of `size` are treated as\n # tuples with length 1; i.e. `size=3` is the same as `size=(3,)`.)\n #\n # `args` is expected to contain the shape parameters (if any), the\n # location and the scale in a flat tuple (e.g. if there are two\n # shape parameters `a` and `b`, `args` will be `(a, b, loc, scale)`).\n # The only keyword argument expected is 'size'.\n size = kwargs.get('size', None)\n all_bcast = np.broadcast_arrays(*args)\n\n def squeeze_left(a):\n while a.ndim > 0 and a.shape[0] == 1:\n a = a[0]\n return a\n\n # Eliminate trivial leading dimensions. In the convention\n # used by numpy's random variate generators, trivial leading\n # dimensions are effectively ignored. In other words, when `size`\n # is given, trivial leading dimensions of the broadcast parameters\n # in excess of the number of dimensions in size are ignored, e.g.\n # >>> np.random.normal([[1, 3, 5]], [[[[0.01]]]], size=3)\n # array([ 1.00104267, 3.00422496, 4.99799278])\n # If `size` is not given, the exact broadcast shape is preserved:\n # >>> np.random.normal([[1, 3, 5]], [[[[0.01]]]])\n # array([[[[ 1.00862899, 3.00061431, 4.99867122]]]])\n #\n all_bcast = [squeeze_left(a) for a in all_bcast]\n bcast_shape = all_bcast[0].shape\n bcast_ndim = all_bcast[0].ndim\n\n if size is None:\n size_ = bcast_shape\n else:\n size_ = tuple(np.atleast_1d(size))\n\n # Check compatibility of size_ with the broadcast shape of all\n # the parameters. This check is intended to be consistent with\n # how the numpy random variate generators (e.g. np.random.normal,\n # np.random.beta) handle their arguments. The rule is that, if size\n # is given, it determines the shape of the output. Broadcasting\n # can't change the output size.\n\n # This is the standard broadcasting convention of extending the\n # shape with fewer dimensions with enough dimensions of length 1\n # so that the two shapes have the same number of dimensions.\n ndiff = bcast_ndim - len(size_)\n if ndiff < 0:\n bcast_shape = (1,)*(-ndiff) + bcast_shape\n elif ndiff > 0:\n size_ = (1,)*ndiff + size_\n\n # This compatibility test is not standard. In \"regular\" broadcasting,\n # two shapes are compatible if for each dimension, the lengths are the\n # same or one of the lengths is 1. Here, the length of a dimension in\n # size_ must not be less than the corresponding length in bcast_shape.\n ok = all([bcdim == 1 or bcdim == szdim\n for (bcdim, szdim) in zip(bcast_shape, size_)])\n if not ok:\n raise ValueError(\"size does not match the broadcast shape of \"\n \"the parameters. %s, %s, %s\" % (size, size_,\n bcast_shape))\n\n param_bcast = all_bcast[:-2]\n loc_bcast = all_bcast[-2]\n scale_bcast = all_bcast[-1]\n\n return param_bcast, loc_bcast, scale_bcast, size_\n\n # These are the methods you must define (standard form functions)\n # NB: generic _pdf, _logpdf, _cdf are different for\n # rv_continuous and rv_discrete hence are defined in there\n def _argcheck(self, *args):\n \"\"\"Default check for correct values on args and keywords.\n\n Returns condition array of 1's where arguments are correct and\n 0's where they are not.\n\n \"\"\"\n cond = 1\n for arg in args:\n cond = logical_and(cond, (asarray(arg) > 0))\n return cond\n\n def _get_support(self, *args, **kwargs):\n \"\"\"Return the support of the (unscaled, unshifted) distribution.\n\n *Must* be overridden by distributions which have support dependent\n upon the shape parameters of the distribution. Any such override\n *must not* set or change any of the class members, as these members\n are shared amongst all instances of the distribution.\n\n Parameters\n ----------\n arg1, arg2, ... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n\n Returns\n -------\n a, b : numeric (float, or int or +/-np.inf)\n end-points of the distribution's support for the specified\n shape parameters.\n \"\"\"\n return self.a, self.b\n\n def _support_mask(self, x, *args):\n a, b = self._get_support(*args)\n with np.errstate(invalid='ignore'):\n return (a <= x) & (x <= b)\n\n def _open_support_mask(self, x, *args):\n a, b = self._get_support(*args)\n with np.errstate(invalid='ignore'):\n return (a < x) & (x < b)\n\n def _rvs(self, *args, size=None, random_state=None):\n # This method must handle size being a tuple, and it must\n # properly broadcast *args and size. size might be\n # an empty tuple, which means a scalar random variate is to be\n # generated.\n\n # Use basic inverse cdf algorithm for RV generation as default.\n U = random_state.uniform(size=size)\n Y = self._ppf(U, *args)\n return Y\n\n def _logcdf(self, x, *args):\n with np.errstate(divide='ignore'):\n return log(self._cdf(x, *args))\n\n def _sf(self, x, *args):\n return 1.0-self._cdf(x, *args)\n\n def _logsf(self, x, *args):\n with np.errstate(divide='ignore'):\n return log(self._sf(x, *args))\n\n def _ppf(self, q, *args):\n return self._ppfvec(q, *args)\n\n def _isf(self, q, *args):\n return self._ppf(1.0-q, *args) # use correct _ppf for subclasses\n\n # These are actually called, and should not be overwritten if you\n # want to keep error checking.\n def rvs(self, *args, **kwds):\n \"\"\"Random variates of given type.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n scale : array_like, optional\n Scale parameter (default=1).\n size : int or tuple of ints, optional\n Defining number of random variates (default is 1).\n random_state : {None, int, `numpy.random.Generator`,\n `numpy.random.RandomState`}, optional\n\n If `seed` is None (or `np.random`), the `numpy.random.RandomState`\n singleton is used.\n If `seed` is an int, a new ``RandomState`` instance is used,\n seeded with `seed`.\n If `seed` is already a ``Generator`` or ``RandomState`` instance\n then that instance is used.\n\n Returns\n -------\n rvs : ndarray or scalar\n Random variates of given `size`.\n\n \"\"\"\n discrete = kwds.pop('discrete', None)\n rndm = kwds.pop('random_state', None)\n args, loc, scale, size = self._parse_args_rvs(*args, **kwds)\n cond = logical_and(self._argcheck(*args), (scale >= 0))\n if not np.all(cond):\n message = (\"Domain error in arguments. The `scale` parameter must \"\n \"be positive for all distributions; see the \"\n \"distribution documentation for other restrictions.\")\n raise ValueError(message)\n\n if np.all(scale == 0):\n return loc*ones(size, 'd')\n\n # extra gymnastics needed for a custom random_state\n if rndm is not None:\n random_state_saved = self._random_state\n random_state = check_random_state(rndm)\n else:\n random_state = self._random_state\n\n # Maintain backwards compatibility by setting self._size\n # for distributions that still need it.\n if self._rvs_uses_size_attribute:\n if not self._rvs_size_warned:\n warnings.warn(\n f'The signature of {self._rvs} does not contain '\n f'a \"size\" keyword. Such signatures are deprecated.',\n np.VisibleDeprecationWarning)\n self._rvs_size_warned = True\n self._size = size\n self._random_state = random_state\n vals = self._rvs(*args)\n else:\n vals = self._rvs(*args, size=size, random_state=random_state)\n\n vals = vals * scale + loc\n\n # do not forget to restore the _random_state\n if rndm is not None:\n self._random_state = random_state_saved\n\n # Cast to int if discrete\n if discrete:\n if size == ():\n vals = int(vals)\n else:\n vals = vals.astype(np.int64)\n\n return vals\n\n def stats(self, *args, **kwds):\n \"\"\"Some statistics of the given RV.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional (continuous RVs only)\n scale parameter (default=1)\n moments : str, optional\n composed of letters ['mvsk'] defining which moments to compute:\n 'm' = mean,\n 'v' = variance,\n 's' = (Fisher's) skew,\n 'k' = (Fisher's) kurtosis.\n (default is 'mv')\n\n Returns\n -------\n stats : sequence\n of requested moments.\n\n \"\"\"\n args, loc, scale, moments = self._parse_args_stats(*args, **kwds)\n # scale = 1 by construction for discrete RVs\n loc, scale = map(asarray, (loc, scale))\n args = tuple(map(asarray, args))\n cond = self._argcheck(*args) & (scale > 0) & (loc == loc)\n output = []\n default = np.full(shape(cond), fill_value=self.badvalue)\n\n # Use only entries that are valid in calculation\n if np.any(cond):\n goodargs = argsreduce(cond, *(args+(scale, loc)))\n scale, loc, goodargs = goodargs[-2], goodargs[-1], goodargs[:-2]\n\n if self._stats_has_moments:\n mu, mu2, g1, g2 = self._stats(*goodargs,\n **{'moments': moments})\n else:\n mu, mu2, g1, g2 = self._stats(*goodargs)\n\n if 'm' in moments:\n if mu is None:\n mu = self._munp(1, *goodargs)\n out0 = default.copy()\n place(out0, cond, mu * scale + loc)\n output.append(out0)\n\n if 'v' in moments:\n if mu2 is None:\n mu2p = self._munp(2, *goodargs)\n if mu is None:\n mu = self._munp(1, *goodargs)\n # if mean is inf then var is also inf\n with np.errstate(invalid='ignore'):\n mu2 = np.where(~np.isinf(mu), mu2p - mu**2, np.inf)\n out0 = default.copy()\n place(out0, cond, mu2 * scale * scale)\n output.append(out0)\n\n if 's' in moments:\n if g1 is None:\n mu3p = self._munp(3, *goodargs)\n if mu is None:\n mu = self._munp(1, *goodargs)\n if mu2 is None:\n mu2p = self._munp(2, *goodargs)\n mu2 = mu2p - mu * mu\n with np.errstate(invalid='ignore'):\n mu3 = (-mu*mu - 3*mu2)*mu + mu3p\n g1 = mu3 / np.power(mu2, 1.5)\n out0 = default.copy()\n place(out0, cond, g1)\n output.append(out0)\n\n if 'k' in moments:\n if g2 is None:\n mu4p = self._munp(4, *goodargs)\n if mu is None:\n mu = self._munp(1, *goodargs)\n if mu2 is None:\n mu2p = self._munp(2, *goodargs)\n mu2 = mu2p - mu * mu\n if g1 is None:\n mu3 = None\n else:\n # (mu2**1.5) breaks down for nan and inf\n mu3 = g1 * np.power(mu2, 1.5)\n if mu3 is None:\n mu3p = self._munp(3, *goodargs)\n with np.errstate(invalid='ignore'):\n mu3 = (-mu * mu - 3 * mu2) * mu + mu3p\n with np.errstate(invalid='ignore'):\n mu4 = ((-mu**2 - 6*mu2) * mu - 4*mu3)*mu + mu4p\n g2 = mu4 / mu2**2.0 - 3.0\n out0 = default.copy()\n place(out0, cond, g2)\n output.append(out0)\n else: # no valid args\n output = [default.copy() for _ in moments]\n\n if len(output) == 1:\n return output[0]\n else:\n return tuple(output)\n\n def entropy(self, *args, **kwds):\n \"\"\"Differential entropy of the RV.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n scale : array_like, optional (continuous distributions only).\n Scale parameter (default=1).\n\n Notes\n -----\n Entropy is defined base `e`:\n\n >>> drv = rv_discrete(values=((0, 1), (0.5, 0.5)))\n >>> np.allclose(drv.entropy(), np.log(2.0))\n True\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n # NB: for discrete distributions scale=1 by construction in _parse_args\n loc, scale = map(asarray, (loc, scale))\n args = tuple(map(asarray, args))\n cond0 = self._argcheck(*args) & (scale > 0) & (loc == loc)\n output = zeros(shape(cond0), 'd')\n place(output, (1-cond0), self.badvalue)\n goodargs = argsreduce(cond0, scale, *args)\n goodscale = goodargs[0]\n goodargs = goodargs[1:]\n place(output, cond0, self.vecentropy(*goodargs) + log(goodscale))\n return output\n\n def moment(self, order=None, *args, **kwds):\n \"\"\"non-central moment of distribution of specified order.\n\n .. deprecated:: 1.9.0\n Parameter `n` is replaced by parameter `order` to avoid name\n collisions with the shape parameter `n` of several distributions.\n Parameter `n` will be removed in SciPy 1.11.0.\n\n Parameters\n ----------\n order : int, order >= 1\n Order of moment.\n arg1, arg2, arg3,... : float\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n \"\"\"\n # This function was originally written with parameter `n`, but `n`\n # is also the name of many distribution shape parameters.\n # This block allows the function to accept both `n` and its\n # replacement `order` during a deprecation period; it can be removed\n # in the second release after 1.9.0.\n # The logic to provide a DeprecationWarning only when `n` is passed\n # as a keyword, accept the new keyword `order`, and otherwise be\n # backward-compatible deserves explanation. We need to look out for\n # the following:\n # * Does the distribution have a shape named `n`?\n # * Is `order` provided? It doesn't matter whether it is provided as a\n # positional or keyword argument; it will be used as the order of the\n # moment rather than a distribution shape parameter because:\n # - The first positional argument of `moment` has always been the\n # order of the moment.\n # - The keyword `order` is new, so it's unambiguous that it refers to\n # the order of the moment.\n # * Is `n` provided as a keyword argument? It _does_ matter whether it\n # is provided as a positional or keyword argument.\n # - The first positional argument of `moment` has always been the\n # order of moment, but\n # - if `n` is provided as a keyword argument, its meaning depends\n # on whether the distribution accepts `n` as a shape parameter.\n has_shape_n = (self.shapes is not None\n and \"n\" in (self.shapes.split(\", \")))\n got_order = order is not None\n got_keyword_n = kwds.get(\"n\", None) is not None\n\n # These lead to the following cases.\n # Case A: If the distribution _does_ accept `n` as a shape\n # 1. If both `order` and `n` are provided, this is now OK:\n # it is unambiguous that `order` is the order of the moment and `n`\n # is the shape parameter. Previously, this would have caused an\n # error because `n` was provided both as a keyword argument and\n # as the first positional argument. I don't think it is credible for\n # users to rely on this error in their code, though, so I don't see\n # this as a backward compatibility break.\n # 2. If only `n` is provided (as a keyword argument), this would have\n # been an error in the past because `n` would have been treated as\n # the order of the moment while the shape parameter would be\n # missing. It is still the same type of error, but for a different\n # reason: now, `n` is treated as the shape parameter while the\n # order of the moment is missing.\n # 3. If only `order` is provided, no special treament is needed.\n # Clearly this value is intended to be the order of the moment,\n # and the rest of the function will determine whether `n` is\n # available as a shape parameter in `args`.\n # 4. If neither `n` nor `order` is provided, this would have been an\n # error (order of the moment is not provided) and it is still an\n # error for the same reason.\n\n # Case B: the distribution does _not_ accept `n` as a shape\n # 1. If both `order` and `n` are provided, this was an error, and it\n # still is an error: two values for same parameter.\n # 2. If only `n` is provided (as a keyword argument), this was OK and\n # is still OK, but there shold now be a `DeprecationWarning`. The\n # value of `n` should be removed from `kwds` and stored in `order`.\n # 3. If only `order` is provided, there was no problem before providing\n # only the first argument of `moment`, and there is no problem with\n # that now.\n # 4. If neither `n` nor `order` is provided, this would have been an\n # error (order of the moment is not provided), and it is still an\n # error for the same reason.\n if not got_order and ((not got_keyword_n) # A4 and B4\n or (got_keyword_n and has_shape_n)): # A2\n message = (\"moment() missing 1 required \"\n \"positional argument: `order`\")\n raise TypeError(message)\n\n if got_keyword_n and not has_shape_n:\n if got_order: # B1\n # this will change to \"moment got unexpected argument n\"\n message = \"moment() got multiple values for first argument\"\n raise TypeError(message)\n else: # B2\n message = (\"Use of keyword argument `n` for method \"\n \"`moment` is deprecated. Use first positional \"\n \"argument or keyword argument `order` instead.\")\n order = kwds.pop(\"n\")\n warnings.warn(message, DeprecationWarning, stacklevel=2)\n n = order\n # No special treatment of A1, A3, or B3 is needed because the order\n # of the moment is now in variable `n` and the shape parameter, if\n # needed, will be fished out of `args` or `kwds` by _parse_args\n # A3 might still cause an error if the shape parameter called `n`\n # is not found in `args`.\n\n shapes, loc, scale = self._parse_args(*args, **kwds)\n args = np.broadcast_arrays(*(*shapes, loc, scale))\n *shapes, loc, scale = args\n\n i0 = np.logical_and(self._argcheck(*shapes), scale > 0)\n i1 = np.logical_and(i0, loc == 0)\n i2 = np.logical_and(i0, loc != 0)\n\n args = argsreduce(i0, *shapes, loc, scale)\n *shapes, loc, scale = args\n\n if (floor(n) != n):\n raise ValueError(\"Moment must be an integer.\")\n if (n < 0):\n raise ValueError(\"Moment must be positive.\")\n mu, mu2, g1, g2 = None, None, None, None\n if (n > 0) and (n < 5):\n if self._stats_has_moments:\n mdict = {'moments': {1: 'm', 2: 'v', 3: 'vs', 4: 'vk'}[n]}\n else:\n mdict = {}\n mu, mu2, g1, g2 = self._stats(*shapes, **mdict)\n val = np.empty(loc.shape) # val needs to be indexed by loc\n val[...] = _moment_from_stats(n, mu, mu2, g1, g2, self._munp, shapes)\n\n # Convert to transformed X = L + S*Y\n # E[X^n] = E[(L+S*Y)^n] = L^n sum(comb(n, k)*(S/L)^k E[Y^k], k=0...n)\n result = zeros(i0.shape)\n place(result, ~i0, self.badvalue)\n\n if i1.any():\n res1 = scale[loc == 0]**n * val[loc == 0]\n place(result, i1, res1)\n\n if i2.any():\n mom = [mu, mu2, g1, g2]\n arrs = [i for i in mom if i is not None]\n idx = [i for i in range(4) if mom[i] is not None]\n if any(idx):\n arrs = argsreduce(loc != 0, *arrs)\n j = 0\n for i in idx:\n mom[i] = arrs[j]\n j += 1\n mu, mu2, g1, g2 = mom\n args = argsreduce(loc != 0, *shapes, loc, scale, val)\n *shapes, loc, scale, val = args\n\n res2 = zeros(loc.shape, dtype='d')\n fac = scale / loc\n for k in range(n):\n valk = _moment_from_stats(k, mu, mu2, g1, g2, self._munp,\n shapes)\n res2 += comb(n, k, exact=True)*fac**k * valk\n res2 += fac**n * val\n res2 *= loc**n\n place(result, i2, res2)\n\n if result.ndim == 0:\n return result.item()\n return result\n\n def median(self, *args, **kwds):\n \"\"\"Median of the distribution.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n Location parameter, Default is 0.\n scale : array_like, optional\n Scale parameter, Default is 1.\n\n Returns\n -------\n median : float\n The median of the distribution.\n\n See Also\n --------\n rv_discrete.ppf\n Inverse of the CDF\n\n \"\"\"\n return self.ppf(0.5, *args, **kwds)\n\n def mean(self, *args, **kwds):\n \"\"\"Mean of the distribution.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n mean : float\n the mean of the distribution\n\n \"\"\"\n kwds['moments'] = 'm'\n res = self.stats(*args, **kwds)\n if isinstance(res, ndarray) and res.ndim == 0:\n return res[()]\n return res\n\n def var(self, *args, **kwds):\n \"\"\"Variance of the distribution.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n var : float\n the variance of the distribution\n\n \"\"\"\n kwds['moments'] = 'v'\n res = self.stats(*args, **kwds)\n if isinstance(res, ndarray) and res.ndim == 0:\n return res[()]\n return res\n\n def std(self, *args, **kwds):\n \"\"\"Standard deviation of the distribution.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n std : float\n standard deviation of the distribution\n\n \"\"\"\n kwds['moments'] = 'v'\n res = sqrt(self.stats(*args, **kwds))\n return res\n\n def interval(self, confidence=None, *args, **kwds):\n \"\"\"Confidence interval with equal areas around the median.\n\n .. deprecated:: 1.9.0\n Parameter `alpha` is replaced by parameter `confidence` to avoid\n name collisions with the shape parameter `alpha` of some\n distributions. Parameter `alpha` will be removed in SciPy 1.11.0.\n\n Parameters\n ----------\n confidence : array_like of float\n Probability that an rv will be drawn from the returned range.\n Each value should be in the range [0, 1].\n arg1, arg2, ... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n location parameter, Default is 0.\n scale : array_like, optional\n scale parameter, Default is 1.\n\n Returns\n -------\n a, b : ndarray of float\n end-points of range that contain ``100 * alpha %`` of the rv's\n possible values.\n\n \"\"\"\n # This function was originally written with parameter `alpha`, but\n # `alpha` is also the name of a shape parameter of two distributions.\n # This block allows the function to accept both `alpha` and its\n # replacement `confidence` during a deprecation period; it can be\n # removed in the second release after 1.9.0.\n # See description of logic in `moment` method.\n has_shape_alpha = (self.shapes is not None\n and \"alpha\" in (self.shapes.split(\", \")))\n got_confidence = confidence is not None\n got_keyword_alpha = kwds.get(\"alpha\", None) is not None\n\n if not got_confidence and ((not got_keyword_alpha)\n or (got_keyword_alpha and has_shape_alpha)):\n message = (\"interval() missing 1 required positional argument: \"\n \"`confidence`\")\n raise TypeError(message)\n\n if got_keyword_alpha and not has_shape_alpha:\n if got_confidence:\n # this will change to \"interval got unexpected argument alpha\"\n message = \"interval() got multiple values for first argument\"\n raise TypeError(message)\n else:\n message = (\"Use of keyword argument `alpha` for method \"\n \"`interval` is deprecated. Use first positional \"\n \"argument or keyword argument `confidence` \"\n \"instead.\")\n confidence = kwds.pop(\"alpha\")\n warnings.warn(message, DeprecationWarning, stacklevel=2)\n alpha = confidence\n\n alpha = asarray(alpha)\n if np.any((alpha > 1) | (alpha < 0)):\n raise ValueError(\"alpha must be between 0 and 1 inclusive\")\n q1 = (1.0-alpha)/2\n q2 = (1.0+alpha)/2\n a = self.ppf(q1, *args, **kwds)\n b = self.ppf(q2, *args, **kwds)\n return a, b\n\n def support(self, *args, **kwargs):\n \"\"\"Support of the distribution.\n\n Parameters\n ----------\n arg1, arg2, ... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n location parameter, Default is 0.\n scale : array_like, optional\n scale parameter, Default is 1.\n\n Returns\n -------\n a, b : array_like\n end-points of the distribution's support.\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwargs)\n arrs = np.broadcast_arrays(*args, loc, scale)\n args, loc, scale = arrs[:-2], arrs[-2], arrs[-1]\n cond = self._argcheck(*args) & (scale > 0)\n _a, _b = self._get_support(*args)\n if cond.all():\n return _a * scale + loc, _b * scale + loc\n elif cond.ndim == 0:\n return self.badvalue, self.badvalue\n # promote bounds to at least float to fill in the badvalue\n _a, _b = np.asarray(_a).astype('d'), np.asarray(_b).astype('d')\n out_a, out_b = _a * scale + loc, _b * scale + loc\n place(out_a, 1-cond, self.badvalue)\n place(out_b, 1-cond, self.badvalue)\n return out_a, out_b\n\n def nnlf(self, theta, x):\n \"\"\"Negative loglikelihood function.\n Notes\n -----\n This is ``-sum(log pdf(x, theta), axis=0)`` where `theta` are the\n parameters (including loc and scale).\n \"\"\"\n loc, scale, args = self._unpack_loc_scale(theta)\n if not self._argcheck(*args) or scale <= 0:\n return inf\n x = asarray((x-loc) / scale)\n n_log_scale = len(x) * log(scale)\n if np.any(~self._support_mask(x, *args)):\n return inf\n return self._nnlf(x, *args) + n_log_scale\n\n def _nnlf(self, x, *args):\n return -np.sum(self._logpxf(x, *args), axis=0)\n\n def _nnlf_and_penalty(self, x, args):\n cond0 = ~self._support_mask(x, *args)\n n_bad = np.count_nonzero(cond0, axis=0)\n if n_bad > 0:\n x = argsreduce(~cond0, x)[0]\n logpxf = self._logpxf(x, *args)\n finite_logpxf = np.isfinite(logpxf)\n n_bad += np.sum(~finite_logpxf, axis=0)\n if n_bad > 0:\n penalty = n_bad * log(_XMAX) * 100\n return -np.sum(logpxf[finite_logpxf], axis=0) + penalty\n return -np.sum(logpxf, axis=0)\n\n def _penalized_nnlf(self, theta, x):\n \"\"\"Penalized negative loglikelihood function.\n i.e., - sum (log pdf(x, theta), axis=0) + penalty\n where theta are the parameters (including loc and scale)\n \"\"\"\n loc, scale, args = self._unpack_loc_scale(theta)\n if not self._argcheck(*args) or scale <= 0:\n return inf\n x = asarray((x-loc) / scale)\n n_log_scale = len(x) * log(scale)\n return self._nnlf_and_penalty(x, args) + n_log_scale\n\n\nclass _ShapeInfo:\n def __init__(self, name, integrality=False, domain=(-np.inf, np.inf),\n inclusive=(True, True)):\n self.name = name\n self.integrality = integrality\n\n domain = list(domain)\n if np.isfinite(domain[0]) and not inclusive[0]:\n domain[0] = np.nextafter(domain[0], np.inf)\n if np.isfinite(domain[1]) and not inclusive[1]:\n domain[1] = np.nextafter(domain[1], -np.inf)\n self.domain = domain\n\n\ndef _get_fixed_fit_value(kwds, names):\n \"\"\"\n Given names such as `['f0', 'fa', 'fix_a']`, check that there is\n at most one non-None value in `kwds` associaed with those names.\n Return that value, or None if none of the names occur in `kwds`.\n As a side effect, all occurrences of those names in `kwds` are\n removed.\n \"\"\"\n vals = [(name, kwds.pop(name)) for name in names if name in kwds]\n if len(vals) > 1:\n repeated = [name for name, val in vals]\n raise ValueError(\"fit method got multiple keyword arguments to \"\n \"specify the same fixed parameter: \" +\n ', '.join(repeated))\n return vals[0][1] if vals else None\n\n# continuous random variables: implement maybe later\n#\n# hf --- Hazard Function (PDF / SF)\n# chf --- Cumulative hazard function (-log(SF))\n# psf --- Probability sparsity function (reciprocal of the pdf) in\n# units of percent-point-function (as a function of q).\n# Also, the derivative of the percent-point function.\n\n\nclass rv_continuous(rv_generic):\n \"\"\"A generic continuous random variable class meant for subclassing.\n\n `rv_continuous` is a base class to construct specific distribution classes\n and instances for continuous random variables. It cannot be used\n directly as a distribution.\n\n Parameters\n ----------\n momtype : int, optional\n The type of generic moment calculation to use: 0 for pdf, 1 (default)\n for ppf.\n a : float, optional\n Lower bound of the support of the distribution, default is minus\n infinity.\n b : float, optional\n Upper bound of the support of the distribution, default is plus\n infinity.\n xtol : float, optional\n The tolerance for fixed point calculation for generic ppf.\n badvalue : float, optional\n The value in a result arrays that indicates a value that for which\n some argument restriction is violated, default is np.nan.\n name : str, optional\n The name of the instance. This string is used to construct the default\n example for distributions.\n longname : str, optional\n This string is used as part of the first line of the docstring returned\n when a subclass has no docstring of its own. Note: `longname` exists\n for backwards compatibility, do not use for new subclasses.\n shapes : str, optional\n The shape of the distribution. For example ``\"m, n\"`` for a\n distribution that takes two integers as the two shape arguments for all\n its methods. If not provided, shape parameters will be inferred from\n the signature of the private methods, ``_pdf`` and ``_cdf`` of the\n instance.\n extradoc : str, optional, deprecated\n This string is used as the last part of the docstring returned when a\n subclass has no docstring of its own. Note: `extradoc` exists for\n backwards compatibility, do not use for new subclasses.\n seed : {None, int, `numpy.random.Generator`,\n `numpy.random.RandomState`}, optional\n\n If `seed` is None (or `np.random`), the `numpy.random.RandomState`\n singleton is used.\n If `seed` is an int, a new ``RandomState`` instance is used,\n seeded with `seed`.\n If `seed` is already a ``Generator`` or ``RandomState`` instance then\n that instance is used.\n\n Methods\n -------\n rvs\n pdf\n logpdf\n cdf\n logcdf\n sf\n logsf\n ppf\n isf\n moment\n stats\n entropy\n expect\n median\n mean\n std\n var\n interval\n __call__\n fit\n fit_loc_scale\n nnlf\n support\n\n Notes\n -----\n Public methods of an instance of a distribution class (e.g., ``pdf``,\n ``cdf``) check their arguments and pass valid arguments to private,\n computational methods (``_pdf``, ``_cdf``). For ``pdf(x)``, ``x`` is valid\n if it is within the support of the distribution.\n Whether a shape parameter is valid is decided by an ``_argcheck`` method\n (which defaults to checking that its arguments are strictly positive.)\n\n **Subclassing**\n\n New random variables can be defined by subclassing the `rv_continuous` class\n and re-defining at least the ``_pdf`` or the ``_cdf`` method (normalized\n to location 0 and scale 1).\n\n If positive argument checking is not correct for your RV\n then you will also need to re-define the ``_argcheck`` method.\n\n For most of the scipy.stats distributions, the support interval doesn't\n depend on the shape parameters. ``x`` being in the support interval is\n equivalent to ``self.a <= x <= self.b``. If either of the endpoints of\n the support do depend on the shape parameters, then\n i) the distribution must implement the ``_get_support`` method; and\n ii) those dependent endpoints must be omitted from the distribution's\n call to the ``rv_continuous`` initializer.\n\n Correct, but potentially slow defaults exist for the remaining\n methods but for speed and/or accuracy you can over-ride::\n\n _logpdf, _cdf, _logcdf, _ppf, _rvs, _isf, _sf, _logsf\n\n The default method ``_rvs`` relies on the inverse of the cdf, ``_ppf``,\n applied to a uniform random variate. In order to generate random variates\n efficiently, either the default ``_ppf`` needs to be overwritten (e.g.\n if the inverse cdf can expressed in an explicit form) or a sampling\n method needs to be implemented in a custom ``_rvs`` method.\n\n If possible, you should override ``_isf``, ``_sf`` or ``_logsf``.\n The main reason would be to improve numerical accuracy: for example,\n the survival function ``_sf`` is computed as ``1 - _cdf`` which can\n result in loss of precision if ``_cdf(x)`` is close to one.\n\n **Methods that can be overwritten by subclasses**\n ::\n\n _rvs\n _pdf\n _cdf\n _sf\n _ppf\n _isf\n _stats\n _munp\n _entropy\n _argcheck\n _get_support\n\n There are additional (internal and private) generic methods that can\n be useful for cross-checking and for debugging, but might work in all\n cases when directly called.\n\n A note on ``shapes``: subclasses need not specify them explicitly. In this\n case, `shapes` will be automatically deduced from the signatures of the\n overridden methods (`pdf`, `cdf` etc).\n If, for some reason, you prefer to avoid relying on introspection, you can\n specify ``shapes`` explicitly as an argument to the instance constructor.\n\n\n **Frozen Distributions**\n\n Normally, you must provide shape parameters (and, optionally, location and\n scale parameters to each call of a method of a distribution.\n\n Alternatively, the object may be called (as a function) to fix the shape,\n location, and scale parameters returning a \"frozen\" continuous RV object:\n\n rv = generic(<shape(s)>, loc=0, scale=1)\n `rv_frozen` object with the same methods but holding the given shape,\n location, and scale fixed\n\n **Statistics**\n\n Statistics are computed using numerical integration by default.\n For speed you can redefine this using ``_stats``:\n\n - take shape parameters and return mu, mu2, g1, g2\n - If you can't compute one of these, return it as None\n - Can also be defined with a keyword argument ``moments``, which is a\n string composed of \"m\", \"v\", \"s\", and/or \"k\".\n Only the components appearing in string should be computed and\n returned in the order \"m\", \"v\", \"s\", or \"k\" with missing values\n returned as None.\n\n Alternatively, you can override ``_munp``, which takes ``n`` and shape\n parameters and returns the n-th non-central moment of the distribution.\n\n Examples\n --------\n To create a new Gaussian distribution, we would do the following:\n\n >>> from scipy.stats import rv_continuous\n >>> class gaussian_gen(rv_continuous):\n ... \"Gaussian distribution\"\n ... def _pdf(self, x):\n ... return np.exp(-x**2 / 2.) / np.sqrt(2.0 * np.pi)\n >>> gaussian = gaussian_gen(name='gaussian')\n\n ``scipy.stats`` distributions are *instances*, so here we subclass\n `rv_continuous` and create an instance. With this, we now have\n a fully functional distribution with all relevant methods automagically\n generated by the framework.\n\n Note that above we defined a standard normal distribution, with zero mean\n and unit variance. Shifting and scaling of the distribution can be done\n by using ``loc`` and ``scale`` parameters: ``gaussian.pdf(x, loc, scale)``\n essentially computes ``y = (x - loc) / scale`` and\n ``gaussian._pdf(y) / scale``.\n\n \"\"\"\n def __init__(self, momtype=1, a=None, b=None, xtol=1e-14,\n badvalue=None, name=None, longname=None,\n shapes=None, extradoc=None, seed=None):\n\n super().__init__(seed)\n\n if extradoc is not None:\n warnings.warn(\"extradoc is deprecated and will be removed in \"\n \"SciPy 1.11.0\", DeprecationWarning)\n\n # save the ctor parameters, cf generic freeze\n self._ctor_param = dict(\n momtype=momtype, a=a, b=b, xtol=xtol,\n badvalue=badvalue, name=name, longname=longname,\n shapes=shapes, extradoc=extradoc, seed=seed)\n\n if badvalue is None:\n badvalue = nan\n if name is None:\n name = 'Distribution'\n self.badvalue = badvalue\n self.name = name\n self.a = a\n self.b = b\n if a is None:\n self.a = -inf\n if b is None:\n self.b = inf\n self.xtol = xtol\n self.moment_type = momtype\n self.shapes = shapes\n self.extradoc = extradoc\n\n self._construct_argparser(meths_to_inspect=[self._pdf, self._cdf],\n locscale_in='loc=0, scale=1',\n locscale_out='loc, scale')\n self._attach_methods()\n\n if longname is None:\n if name[0] in ['aeiouAEIOU']:\n hstr = \"An \"\n else:\n hstr = \"A \"\n longname = hstr + name\n\n if sys.flags.optimize < 2:\n # Skip adding docstrings if interpreter is run with -OO\n if self.__doc__ is None:\n self._construct_default_doc(longname=longname,\n extradoc=extradoc,\n docdict=docdict,\n discrete='continuous')\n else:\n dct = dict(distcont)\n self._construct_doc(docdict, dct.get(self.name))\n\n def __getstate__(self):\n dct = self.__dict__.copy()\n\n # these methods will be remade in __setstate__\n # _random_state attribute is taken care of by rv_generic\n attrs = [\"_parse_args\", \"_parse_args_stats\", \"_parse_args_rvs\",\n \"_cdfvec\", \"_ppfvec\", \"vecentropy\", \"generic_moment\"]\n [dct.pop(attr, None) for attr in attrs]\n return dct\n\n def _attach_methods(self):\n \"\"\"\n Attaches dynamically created methods to the rv_continuous instance.\n \"\"\"\n # _attach_methods is responsible for calling _attach_argparser_methods\n self._attach_argparser_methods()\n\n # nin correction\n self._ppfvec = vectorize(self._ppf_single, otypes='d')\n self._ppfvec.nin = self.numargs + 1\n self.vecentropy = vectorize(self._entropy, otypes='d')\n self._cdfvec = vectorize(self._cdf_single, otypes='d')\n self._cdfvec.nin = self.numargs + 1\n\n if self.moment_type == 0:\n self.generic_moment = vectorize(self._mom0_sc, otypes='d')\n else:\n self.generic_moment = vectorize(self._mom1_sc, otypes='d')\n # Because of the *args argument of _mom0_sc, vectorize cannot count the\n # number of arguments correctly.\n self.generic_moment.nin = self.numargs + 1\n\n def _updated_ctor_param(self):\n \"\"\"Return the current version of _ctor_param, possibly updated by user.\n\n Used by freezing.\n Keep this in sync with the signature of __init__.\n \"\"\"\n dct = self._ctor_param.copy()\n dct['a'] = self.a\n dct['b'] = self.b\n dct['xtol'] = self.xtol\n dct['badvalue'] = self.badvalue\n dct['name'] = self.name\n dct['shapes'] = self.shapes\n dct['extradoc'] = self.extradoc\n return dct\n\n def _ppf_to_solve(self, x, q, *args):\n return self.cdf(*(x, )+args)-q\n\n def _ppf_single(self, q, *args):\n factor = 10.\n left, right = self._get_support(*args)\n\n if np.isinf(left):\n left = min(-factor, right)\n while self._ppf_to_solve(left, q, *args) > 0.:\n left, right = left * factor, left\n # left is now such that cdf(left) <= q\n # if right has changed, then cdf(right) > q\n\n if np.isinf(right):\n right = max(factor, left)\n while self._ppf_to_solve(right, q, *args) < 0.:\n left, right = right, right * factor\n # right is now such that cdf(right) >= q\n\n return optimize.brentq(self._ppf_to_solve,\n left, right, args=(q,)+args, xtol=self.xtol)\n\n # moment from definition\n def _mom_integ0(self, x, m, *args):\n return x**m * self.pdf(x, *args)\n\n def _mom0_sc(self, m, *args):\n _a, _b = self._get_support(*args)\n return integrate.quad(self._mom_integ0, _a, _b,\n args=(m,)+args)[0]\n\n # moment calculated using ppf\n def _mom_integ1(self, q, m, *args):\n return (self.ppf(q, *args))**m\n\n def _mom1_sc(self, m, *args):\n return integrate.quad(self._mom_integ1, 0, 1, args=(m,)+args)[0]\n\n def _pdf(self, x, *args):\n return derivative(self._cdf, x, dx=1e-5, args=args, order=5)\n\n # Could also define any of these\n def _logpdf(self, x, *args):\n p = self._pdf(x, *args)\n with np.errstate(divide='ignore'):\n return log(p)\n\n def _logpxf(self, x, *args):\n # continuous distributions have PDF, discrete have PMF, but sometimes\n # the distinction doesn't matter. This lets us use `_logpxf` for both\n # discrete and continuous distributions.\n return self._logpdf(x, *args)\n\n def _cdf_single(self, x, *args):\n _a, _b = self._get_support(*args)\n return integrate.quad(self._pdf, _a, x, args=args)[0]\n\n def _cdf(self, x, *args):\n return self._cdfvec(x, *args)\n\n # generic _argcheck, _logcdf, _sf, _logsf, _ppf, _isf, _rvs are defined\n # in rv_generic\n\n def pdf(self, x, *args, **kwds):\n \"\"\"Probability density function at x of the given RV.\n\n Parameters\n ----------\n x : array_like\n quantiles\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n pdf : ndarray\n Probability density function evaluated at x\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n x, loc, scale = map(asarray, (x, loc, scale))\n args = tuple(map(asarray, args))\n dtyp = np.find_common_type([x.dtype, np.float64], [])\n x = np.asarray((x - loc)/scale, dtype=dtyp)\n cond0 = self._argcheck(*args) & (scale > 0)\n cond1 = self._support_mask(x, *args) & (scale > 0)\n cond = cond0 & cond1\n output = zeros(shape(cond), dtyp)\n putmask(output, (1-cond0)+np.isnan(x), self.badvalue)\n if np.any(cond):\n goodargs = argsreduce(cond, *((x,)+args+(scale,)))\n scale, goodargs = goodargs[-1], goodargs[:-1]\n place(output, cond, self._pdf(*goodargs) / scale)\n if output.ndim == 0:\n return output[()]\n return output\n\n def logpdf(self, x, *args, **kwds):\n \"\"\"Log of the probability density function at x of the given RV.\n\n This uses a more numerically accurate calculation if available.\n\n Parameters\n ----------\n x : array_like\n quantiles\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n logpdf : array_like\n Log of the probability density function evaluated at x\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n x, loc, scale = map(asarray, (x, loc, scale))\n args = tuple(map(asarray, args))\n dtyp = np.find_common_type([x.dtype, np.float64], [])\n x = np.asarray((x - loc)/scale, dtype=dtyp)\n cond0 = self._argcheck(*args) & (scale > 0)\n cond1 = self._support_mask(x, *args) & (scale > 0)\n cond = cond0 & cond1\n output = empty(shape(cond), dtyp)\n output.fill(NINF)\n putmask(output, (1-cond0)+np.isnan(x), self.badvalue)\n if np.any(cond):\n goodargs = argsreduce(cond, *((x,)+args+(scale,)))\n scale, goodargs = goodargs[-1], goodargs[:-1]\n place(output, cond, self._logpdf(*goodargs) - log(scale))\n if output.ndim == 0:\n return output[()]\n return output\n\n def cdf(self, x, *args, **kwds):\n \"\"\"\n Cumulative distribution function of the given RV.\n\n Parameters\n ----------\n x : array_like\n quantiles\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n cdf : ndarray\n Cumulative distribution function evaluated at `x`\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n x, loc, scale = map(asarray, (x, loc, scale))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n dtyp = np.find_common_type([x.dtype, np.float64], [])\n x = np.asarray((x - loc)/scale, dtype=dtyp)\n cond0 = self._argcheck(*args) & (scale > 0)\n cond1 = self._open_support_mask(x, *args) & (scale > 0)\n cond2 = (x >= np.asarray(_b)) & cond0\n cond = cond0 & cond1\n output = zeros(shape(cond), dtyp)\n place(output, (1-cond0)+np.isnan(x), self.badvalue)\n place(output, cond2, 1.0)\n if np.any(cond): # call only if at least 1 entry\n goodargs = argsreduce(cond, *((x,)+args))\n place(output, cond, self._cdf(*goodargs))\n if output.ndim == 0:\n return output[()]\n return output\n\n def logcdf(self, x, *args, **kwds):\n \"\"\"Log of the cumulative distribution function at x of the given RV.\n\n Parameters\n ----------\n x : array_like\n quantiles\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n logcdf : array_like\n Log of the cumulative distribution function evaluated at x\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n x, loc, scale = map(asarray, (x, loc, scale))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n dtyp = np.find_common_type([x.dtype, np.float64], [])\n x = np.asarray((x - loc)/scale, dtype=dtyp)\n cond0 = self._argcheck(*args) & (scale > 0)\n cond1 = self._open_support_mask(x, *args) & (scale > 0)\n cond2 = (x >= _b) & cond0\n cond = cond0 & cond1\n output = empty(shape(cond), dtyp)\n output.fill(NINF)\n place(output, (1-cond0)*(cond1 == cond1)+np.isnan(x), self.badvalue)\n place(output, cond2, 0.0)\n if np.any(cond): # call only if at least 1 entry\n goodargs = argsreduce(cond, *((x,)+args))\n place(output, cond, self._logcdf(*goodargs))\n if output.ndim == 0:\n return output[()]\n return output\n\n def sf(self, x, *args, **kwds):\n \"\"\"Survival function (1 - `cdf`) at x of the given RV.\n\n Parameters\n ----------\n x : array_like\n quantiles\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n sf : array_like\n Survival function evaluated at x\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n x, loc, scale = map(asarray, (x, loc, scale))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n dtyp = np.find_common_type([x.dtype, np.float64], [])\n x = np.asarray((x - loc)/scale, dtype=dtyp)\n cond0 = self._argcheck(*args) & (scale > 0)\n cond1 = self._open_support_mask(x, *args) & (scale > 0)\n cond2 = cond0 & (x <= _a)\n cond = cond0 & cond1\n output = zeros(shape(cond), dtyp)\n place(output, (1-cond0)+np.isnan(x), self.badvalue)\n place(output, cond2, 1.0)\n if np.any(cond):\n goodargs = argsreduce(cond, *((x,)+args))\n place(output, cond, self._sf(*goodargs))\n if output.ndim == 0:\n return output[()]\n return output\n\n def logsf(self, x, *args, **kwds):\n \"\"\"Log of the survival function of the given RV.\n\n Returns the log of the \"survival function,\" defined as (1 - `cdf`),\n evaluated at `x`.\n\n Parameters\n ----------\n x : array_like\n quantiles\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n logsf : ndarray\n Log of the survival function evaluated at `x`.\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n x, loc, scale = map(asarray, (x, loc, scale))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n dtyp = np.find_common_type([x.dtype, np.float64], [])\n x = np.asarray((x - loc)/scale, dtype=dtyp)\n cond0 = self._argcheck(*args) & (scale > 0)\n cond1 = self._open_support_mask(x, *args) & (scale > 0)\n cond2 = cond0 & (x <= _a)\n cond = cond0 & cond1\n output = empty(shape(cond), dtyp)\n output.fill(NINF)\n place(output, (1-cond0)+np.isnan(x), self.badvalue)\n place(output, cond2, 0.0)\n if np.any(cond):\n goodargs = argsreduce(cond, *((x,)+args))\n place(output, cond, self._logsf(*goodargs))\n if output.ndim == 0:\n return output[()]\n return output\n\n def ppf(self, q, *args, **kwds):\n \"\"\"Percent point function (inverse of `cdf`) at q of the given RV.\n\n Parameters\n ----------\n q : array_like\n lower tail probability\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n x : array_like\n quantile corresponding to the lower tail probability q.\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n q, loc, scale = map(asarray, (q, loc, scale))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n cond0 = self._argcheck(*args) & (scale > 0) & (loc == loc)\n cond1 = (0 < q) & (q < 1)\n cond2 = cond0 & (q == 0)\n cond3 = cond0 & (q == 1)\n cond = cond0 & cond1\n output = np.full(shape(cond), fill_value=self.badvalue)\n\n lower_bound = _a * scale + loc\n upper_bound = _b * scale + loc\n place(output, cond2, argsreduce(cond2, lower_bound)[0])\n place(output, cond3, argsreduce(cond3, upper_bound)[0])\n\n if np.any(cond): # call only if at least 1 entry\n goodargs = argsreduce(cond, *((q,)+args+(scale, loc)))\n scale, loc, goodargs = goodargs[-2], goodargs[-1], goodargs[:-2]\n place(output, cond, self._ppf(*goodargs) * scale + loc)\n if output.ndim == 0:\n return output[()]\n return output\n\n def isf(self, q, *args, **kwds):\n \"\"\"Inverse survival function (inverse of `sf`) at q of the given RV.\n\n Parameters\n ----------\n q : array_like\n upper tail probability\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n location parameter (default=0)\n scale : array_like, optional\n scale parameter (default=1)\n\n Returns\n -------\n x : ndarray or scalar\n Quantile corresponding to the upper tail probability q.\n\n \"\"\"\n args, loc, scale = self._parse_args(*args, **kwds)\n q, loc, scale = map(asarray, (q, loc, scale))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n cond0 = self._argcheck(*args) & (scale > 0) & (loc == loc)\n cond1 = (0 < q) & (q < 1)\n cond2 = cond0 & (q == 1)\n cond3 = cond0 & (q == 0)\n cond = cond0 & cond1\n output = np.full(shape(cond), fill_value=self.badvalue)\n\n lower_bound = _a * scale + loc\n upper_bound = _b * scale + loc\n place(output, cond2, argsreduce(cond2, lower_bound)[0])\n place(output, cond3, argsreduce(cond3, upper_bound)[0])\n\n if np.any(cond):\n goodargs = argsreduce(cond, *((q,)+args+(scale, loc)))\n scale, loc, goodargs = goodargs[-2], goodargs[-1], goodargs[:-2]\n place(output, cond, self._isf(*goodargs) * scale + loc)\n if output.ndim == 0:\n return output[()]\n return output\n\n def _unpack_loc_scale(self, theta):\n try:\n loc = theta[-2]\n scale = theta[-1]\n args = tuple(theta[:-2])\n except IndexError as e:\n raise ValueError(\"Not enough input arguments.\") from e\n return loc, scale, args\n\n def _fitstart(self, data, args=None):\n \"\"\"Starting point for fit (shape arguments + loc + scale).\"\"\"\n if args is None:\n args = (1.0,)*self.numargs\n loc, scale = self._fit_loc_scale_support(data, *args)\n return args + (loc, scale)\n\n def _reduce_func(self, args, kwds, data=None):\n \"\"\"\n Return the (possibly reduced) function to optimize in order to find MLE\n estimates for the .fit method.\n \"\"\"\n # Convert fixed shape parameters to the standard numeric form: e.g. for\n # stats.beta, shapes='a, b'. To fix `a`, the caller can give a value\n # for `f0`, `fa` or 'fix_a'. The following converts the latter two\n # into the first (numeric) form.\n shapes = []\n if self.shapes:\n shapes = self.shapes.replace(',', ' ').split()\n for j, s in enumerate(shapes):\n key = 'f' + str(j)\n names = [key, 'f' + s, 'fix_' + s]\n val = _get_fixed_fit_value(kwds, names)\n if val is not None:\n kwds[key] = val\n\n args = list(args)\n Nargs = len(args)\n fixedn = []\n names = ['f%d' % n for n in range(Nargs - 2)] + ['floc', 'fscale']\n x0 = []\n for n, key in enumerate(names):\n if key in kwds:\n fixedn.append(n)\n args[n] = kwds.pop(key)\n else:\n x0.append(args[n])\n\n methods = {\"mle\", \"mm\"}\n method = kwds.pop('method', \"mle\").lower()\n if method == \"mm\":\n n_params = len(shapes) + 2 - len(fixedn)\n exponents = (np.arange(1, n_params+1))[:, np.newaxis]\n data_moments = np.sum(data[None, :]**exponents/len(data), axis=1)\n\n def objective(theta, x):\n return self._moment_error(theta, x, data_moments)\n elif method == \"mle\":\n objective = self._penalized_nnlf\n else:\n raise ValueError(\"Method '{0}' not available; must be one of {1}\"\n .format(method, methods))\n\n if len(fixedn) == 0:\n func = objective\n restore = None\n else:\n if len(fixedn) == Nargs:\n raise ValueError(\n \"All parameters fixed. There is nothing to optimize.\")\n\n def restore(args, theta):\n # Replace with theta for all numbers not in fixedn\n # This allows the non-fixed values to vary, but\n # we still call self.nnlf with all parameters.\n i = 0\n for n in range(Nargs):\n if n not in fixedn:\n args[n] = theta[i]\n i += 1\n return args\n\n def func(theta, x):\n newtheta = restore(args[:], theta)\n return objective(newtheta, x)\n\n return x0, func, restore, args\n\n def _moment_error(self, theta, x, data_moments):\n loc, scale, args = self._unpack_loc_scale(theta)\n if not self._argcheck(*args) or scale <= 0:\n return inf\n\n dist_moments = np.array([self.moment(i+1, *args, loc=loc, scale=scale)\n for i in range(len(data_moments))])\n if np.any(np.isnan(dist_moments)):\n raise ValueError(\"Method of moments encountered a non-finite \"\n \"distribution moment and cannot continue. \"\n \"Consider trying method='MLE'.\")\n\n return (((data_moments - dist_moments) /\n np.maximum(np.abs(data_moments), 1e-8))**2).sum()\n\n def fit(self, data, *args, **kwds):\n \"\"\"\n Return estimates of shape (if applicable), location, and scale\n parameters from data. The default estimation method is Maximum\n Likelihood Estimation (MLE), but Method of Moments (MM)\n is also available.\n\n Starting estimates for\n the fit are given by input arguments; for any arguments not provided\n with starting estimates, ``self._fitstart(data)`` is called to generate\n such.\n\n One can hold some parameters fixed to specific values by passing in\n keyword arguments ``f0``, ``f1``, ..., ``fn`` (for shape parameters)\n and ``floc`` and ``fscale`` (for location and scale parameters,\n respectively).\n\n Parameters\n ----------\n data : array_like\n Data to use in estimating the distribution parameters.\n arg1, arg2, arg3,... : floats, optional\n Starting value(s) for any shape-characterizing arguments (those not\n provided will be determined by a call to ``_fitstart(data)``).\n No default value.\n **kwds : floats, optional\n - `loc`: initial guess of the distribution's location parameter.\n - `scale`: initial guess of the distribution's scale parameter.\n\n Special keyword arguments are recognized as holding certain\n parameters fixed:\n\n - f0...fn : hold respective shape parameters fixed.\n Alternatively, shape parameters to fix can be specified by name.\n For example, if ``self.shapes == \"a, b\"``, ``fa`` and ``fix_a``\n are equivalent to ``f0``, and ``fb`` and ``fix_b`` are\n equivalent to ``f1``.\n\n - floc : hold location parameter fixed to specified value.\n\n - fscale : hold scale parameter fixed to specified value.\n\n - optimizer : The optimizer to use.\n The optimizer must take ``func``,\n and starting position as the first two arguments,\n plus ``args`` (for extra arguments to pass to the\n function to be optimized) and ``disp=0`` to suppress\n output as keyword arguments.\n\n - method : The method to use. The default is \"MLE\" (Maximum\n Likelihood Estimate); \"MM\" (Method of Moments)\n is also available.\n\n\n Returns\n -------\n parameter_tuple : tuple of floats\n Estimates for any shape parameters (if applicable),\n followed by those for location and scale.\n For most random variables, shape statistics\n will be returned, but there are exceptions (e.g. ``norm``).\n\n Notes\n -----\n With ``method=\"MLE\"`` (default), the fit is computed by minimizing\n the negative log-likelihood function. A large, finite penalty\n (rather than infinite negative log-likelihood) is applied for\n observations beyond the support of the distribution.\n\n With ``method=\"MM\"``, the fit is computed by minimizing the L2 norm\n of the relative errors between the first *k* raw (about zero) data\n moments and the corresponding distribution moments, where *k* is the\n number of non-fixed parameters.\n More precisely, the objective function is::\n\n (((data_moments - dist_moments)\n / np.maximum(np.abs(data_moments), 1e-8))**2).sum()\n\n where the constant ``1e-8`` avoids division by zero in case of\n vanishing data moments. Typically, this error norm can be reduced to\n zero.\n Note that the standard method of moments can produce parameters for\n which some data are outside the support of the fitted distribution;\n this implementation does nothing to prevent this.\n\n For either method,\n the returned answer is not guaranteed to be globally optimal; it\n may only be locally optimal, or the optimization may fail altogether.\n If the data contain any of ``np.nan``, ``np.inf``, or ``-np.inf``,\n the `fit` method will raise a ``RuntimeError``.\n\n Examples\n --------\n\n Generate some data to fit: draw random variates from the `beta`\n distribution\n\n >>> from scipy.stats import beta\n >>> a, b = 1., 2.\n >>> x = beta.rvs(a, b, size=1000)\n\n Now we can fit all four parameters (``a``, ``b``, ``loc``\n and ``scale``):\n\n >>> a1, b1, loc1, scale1 = beta.fit(x)\n\n We can also use some prior knowledge about the dataset: let's keep\n ``loc`` and ``scale`` fixed:\n\n >>> a1, b1, loc1, scale1 = beta.fit(x, floc=0, fscale=1)\n >>> loc1, scale1\n (0, 1)\n\n We can also keep shape parameters fixed by using ``f``-keywords. To\n keep the zero-th shape parameter ``a`` equal 1, use ``f0=1`` or,\n equivalently, ``fa=1``:\n\n >>> a1, b1, loc1, scale1 = beta.fit(x, fa=1, floc=0, fscale=1)\n >>> a1\n 1\n\n Not all distributions return estimates for the shape parameters.\n ``norm`` for example just returns estimates for location and scale:\n\n >>> from scipy.stats import norm\n >>> x = norm.rvs(a, b, size=1000, random_state=123)\n >>> loc1, scale1 = norm.fit(x)\n >>> loc1, scale1\n (0.92087172783841631, 2.0015750750324668)\n \"\"\"\n data = np.asarray(data)\n method = kwds.get('method', \"mle\").lower()\n\n # memory for method of moments\n Narg = len(args)\n if Narg > self.numargs:\n raise TypeError(\"Too many input arguments.\")\n\n if not np.isfinite(data).all():\n raise RuntimeError(\"The data contains non-finite values.\")\n\n start = [None]*2\n if (Narg < self.numargs) or not ('loc' in kwds and\n 'scale' in kwds):\n # get distribution specific starting locations\n start = self._fitstart(data)\n args += start[Narg:-2]\n loc = kwds.pop('loc', start[-2])\n scale = kwds.pop('scale', start[-1])\n args += (loc, scale)\n x0, func, restore, args = self._reduce_func(args, kwds, data=data)\n optimizer = kwds.pop('optimizer', optimize.fmin)\n # convert string to function in scipy.optimize\n optimizer = _fit_determine_optimizer(optimizer)\n # by now kwds must be empty, since everybody took what they needed\n if kwds:\n raise TypeError(\"Unknown arguments: %s.\" % kwds)\n\n # In some cases, method of moments can be done with fsolve/root\n # instead of an optimizer, but sometimes no solution exists,\n # especially when the user fixes parameters. Minimizing the sum\n # of squares of the error generalizes to these cases.\n vals = optimizer(func, x0, args=(ravel(data),), disp=0)\n obj = func(vals, data)\n\n if restore is not None:\n vals = restore(args, vals)\n vals = tuple(vals)\n\n loc, scale, shapes = self._unpack_loc_scale(vals)\n if not (np.all(self._argcheck(*shapes)) and scale > 0):\n raise Exception(\"Optimization converged to parameters that are \"\n \"outside the range allowed by the distribution.\")\n\n if method == 'mm':\n if not np.isfinite(obj):\n raise Exception(\"Optimization failed: either a data moment \"\n \"or fitted distribution moment is \"\n \"non-finite.\")\n\n return vals\n\n def _fit_loc_scale_support(self, data, *args):\n \"\"\"Estimate loc and scale parameters from data accounting for support.\n\n Parameters\n ----------\n data : array_like\n Data to fit.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n\n Returns\n -------\n Lhat : float\n Estimated location parameter for the data.\n Shat : float\n Estimated scale parameter for the data.\n\n \"\"\"\n data = np.asarray(data)\n\n # Estimate location and scale according to the method of moments.\n loc_hat, scale_hat = self.fit_loc_scale(data, *args)\n\n # Compute the support according to the shape parameters.\n self._argcheck(*args)\n _a, _b = self._get_support(*args)\n a, b = _a, _b\n support_width = b - a\n\n # If the support is empty then return the moment-based estimates.\n if support_width <= 0:\n return loc_hat, scale_hat\n\n # Compute the proposed support according to the loc and scale\n # estimates.\n a_hat = loc_hat + a * scale_hat\n b_hat = loc_hat + b * scale_hat\n\n # Use the moment-based estimates if they are compatible with the data.\n data_a = np.min(data)\n data_b = np.max(data)\n if a_hat < data_a and data_b < b_hat:\n return loc_hat, scale_hat\n\n # Otherwise find other estimates that are compatible with the data.\n data_width = data_b - data_a\n rel_margin = 0.1\n margin = data_width * rel_margin\n\n # For a finite interval, both the location and scale\n # should have interesting values.\n if support_width < np.inf:\n loc_hat = (data_a - a) - margin\n scale_hat = (data_width + 2 * margin) / support_width\n return loc_hat, scale_hat\n\n # For a one-sided interval, use only an interesting location parameter.\n if a > -np.inf:\n return (data_a - a) - margin, 1\n elif b < np.inf:\n return (data_b - b) + margin, 1\n else:\n raise RuntimeError\n\n def fit_loc_scale(self, data, *args):\n \"\"\"\n Estimate loc and scale parameters from data using 1st and 2nd moments.\n\n Parameters\n ----------\n data : array_like\n Data to fit.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n\n Returns\n -------\n Lhat : float\n Estimated location parameter for the data.\n Shat : float\n Estimated scale parameter for the data.\n\n \"\"\"\n mu, mu2 = self.stats(*args, **{'moments': 'mv'})\n tmp = asarray(data)\n muhat = tmp.mean()\n mu2hat = tmp.var()\n Shat = sqrt(mu2hat / mu2)\n Lhat = muhat - Shat*mu\n if not np.isfinite(Lhat):\n Lhat = 0\n if not (np.isfinite(Shat) and (0 < Shat)):\n Shat = 1\n return Lhat, Shat\n\n def _entropy(self, *args):\n def integ(x):\n val = self._pdf(x, *args)\n return entr(val)\n\n # upper limit is often inf, so suppress warnings when integrating\n _a, _b = self._get_support(*args)\n with np.errstate(over='ignore'):\n h = integrate.quad(integ, _a, _b)[0]\n\n if not np.isnan(h):\n return h\n else:\n # try with different limits if integration problems\n low, upp = self.ppf([1e-10, 1. - 1e-10], *args)\n if np.isinf(_b):\n upper = upp\n else:\n upper = _b\n if np.isinf(_a):\n lower = low\n else:\n lower = _a\n return integrate.quad(integ, lower, upper)[0]\n\n def expect(self, func=None, args=(), loc=0, scale=1, lb=None, ub=None,\n conditional=False, **kwds):\n \"\"\"Calculate expected value of a function with respect to the\n distribution by numerical integration.\n\n The expected value of a function ``f(x)`` with respect to a\n distribution ``dist`` is defined as::\n\n ub\n E[f(x)] = Integral(f(x) * dist.pdf(x)),\n lb\n\n where ``ub`` and ``lb`` are arguments and ``x`` has the ``dist.pdf(x)``\n distribution. If the bounds ``lb`` and ``ub`` correspond to the\n support of the distribution, e.g. ``[-inf, inf]`` in the default\n case, then the integral is the unrestricted expectation of ``f(x)``.\n Also, the function ``f(x)`` may be defined such that ``f(x)`` is ``0``\n outside a finite interval in which case the expectation is\n calculated within the finite range ``[lb, ub]``.\n\n Parameters\n ----------\n func : callable, optional\n Function for which integral is calculated. Takes only one argument.\n The default is the identity mapping f(x) = x.\n args : tuple, optional\n Shape parameters of the distribution.\n loc : float, optional\n Location parameter (default=0).\n scale : float, optional\n Scale parameter (default=1).\n lb, ub : scalar, optional\n Lower and upper bound for integration. Default is set to the\n support of the distribution.\n conditional : bool, optional\n If True, the integral is corrected by the conditional probability\n of the integration interval. The return value is the expectation\n of the function, conditional on being in the given interval.\n Default is False.\n\n Additional keyword arguments are passed to the integration routine.\n\n Returns\n -------\n expect : float\n The calculated expected value.\n\n Notes\n -----\n The integration behavior of this function is inherited from\n `scipy.integrate.quad`. Neither this function nor\n `scipy.integrate.quad` can verify whether the integral exists or is\n finite. For example ``cauchy(0).mean()`` returns ``np.nan`` and\n ``cauchy(0).expect()`` returns ``0.0``.\n\n The function is not vectorized.\n\n Examples\n --------\n\n To understand the effect of the bounds of integration consider\n\n >>> from scipy.stats import expon\n >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0)\n 0.6321205588285578\n\n This is close to\n\n >>> expon(1).cdf(2.0) - expon(1).cdf(0.0)\n 0.6321205588285577\n\n If ``conditional=True``\n\n >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0, conditional=True)\n 1.0000000000000002\n\n The slight deviation from 1 is due to numerical integration.\n \"\"\"\n lockwds = {'loc': loc,\n 'scale': scale}\n self._argcheck(*args)\n _a, _b = self._get_support(*args)\n if func is None:\n def fun(x, *args):\n return x * self.pdf(x, *args, **lockwds)\n else:\n def fun(x, *args):\n return func(x) * self.pdf(x, *args, **lockwds)\n if lb is None:\n lb = loc + _a * scale\n if ub is None:\n ub = loc + _b * scale\n if conditional:\n invfac = (self.sf(lb, *args, **lockwds)\n - self.sf(ub, *args, **lockwds))\n else:\n invfac = 1.0\n kwds['args'] = args\n # Silence floating point warnings from integration.\n with np.errstate(all='ignore'):\n vals = integrate.quad(fun, lb, ub, **kwds)[0] / invfac\n return vals\n\n def _param_info(self):\n shape_info = self._shape_info()\n loc_info = _ShapeInfo(\"loc\", False, (-np.inf, np.inf), (False, False))\n scale_info = _ShapeInfo(\"scale\", False, (0, np.inf), (False, False))\n param_info = shape_info + [loc_info, scale_info]\n return param_info\n\n# Helpers for the discrete distributions\ndef _drv2_moment(self, n, *args):\n \"\"\"Non-central moment of discrete distribution.\"\"\"\n def fun(x):\n return np.power(x, n) * self._pmf(x, *args)\n\n _a, _b = self._get_support(*args)\n return _expect(fun, _a, _b, self.ppf(0.5, *args), self.inc)\n\n\ndef _drv2_ppfsingle(self, q, *args): # Use basic bisection algorithm\n _a, _b = self._get_support(*args)\n b = _b\n a = _a\n if isinf(b): # Be sure ending point is > q\n b = int(max(100*q, 10))\n while 1:\n if b >= _b:\n qb = 1.0\n break\n qb = self._cdf(b, *args)\n if (qb < q):\n b += 10\n else:\n break\n else:\n qb = 1.0\n if isinf(a): # be sure starting point < q\n a = int(min(-100*q, -10))\n while 1:\n if a <= _a:\n qb = 0.0\n break\n qa = self._cdf(a, *args)\n if (qa > q):\n a -= 10\n else:\n break\n else:\n qa = self._cdf(a, *args)\n\n while 1:\n if (qa == q):\n return a\n if (qb == q):\n return b\n if b <= a+1:\n if qa > q:\n return a\n else:\n return b\n c = int((a+b)/2.0)\n qc = self._cdf(c, *args)\n if (qc < q):\n if a != c:\n a = c\n else:\n raise RuntimeError('updating stopped, endless loop')\n qa = qc\n elif (qc > q):\n if b != c:\n b = c\n else:\n raise RuntimeError('updating stopped, endless loop')\n qb = qc\n else:\n return c\n\n\n# Must over-ride one of _pmf or _cdf or pass in\n# x_k, p(x_k) lists in initialization\n\n\nclass rv_discrete(rv_generic):\n \"\"\"A generic discrete random variable class meant for subclassing.\n\n `rv_discrete` is a base class to construct specific distribution classes\n and instances for discrete random variables. It can also be used\n to construct an arbitrary distribution defined by a list of support\n points and corresponding probabilities.\n\n Parameters\n ----------\n a : float, optional\n Lower bound of the support of the distribution, default: 0\n b : float, optional\n Upper bound of the support of the distribution, default: plus infinity\n moment_tol : float, optional\n The tolerance for the generic calculation of moments.\n values : tuple of two array_like, optional\n ``(xk, pk)`` where ``xk`` are integers and ``pk`` are the non-zero\n probabilities between 0 and 1 with ``sum(pk) = 1``. ``xk``\n and ``pk`` must have the same shape.\n inc : integer, optional\n Increment for the support of the distribution.\n Default is 1. (other values have not been tested)\n badvalue : float, optional\n The value in a result arrays that indicates a value that for which\n some argument restriction is violated, default is np.nan.\n name : str, optional\n The name of the instance. This string is used to construct the default\n example for distributions.\n longname : str, optional\n This string is used as part of the first line of the docstring returned\n when a subclass has no docstring of its own. Note: `longname` exists\n for backwards compatibility, do not use for new subclasses.\n shapes : str, optional\n The shape of the distribution. For example \"m, n\" for a distribution\n that takes two integers as the two shape arguments for all its methods\n If not provided, shape parameters will be inferred from\n the signatures of the private methods, ``_pmf`` and ``_cdf`` of\n the instance.\n extradoc : str, optional, deprecated\n This string is used as the last part of the docstring returned when a\n subclass has no docstring of its own. Note: `extradoc` exists for\n backwards compatibility, do not use for new subclasses.\n seed : {None, int, `numpy.random.Generator`,\n `numpy.random.RandomState`}, optional\n\n If `seed` is None (or `np.random`), the `numpy.random.RandomState`\n singleton is used.\n If `seed` is an int, a new ``RandomState`` instance is used,\n seeded with `seed`.\n If `seed` is already a ``Generator`` or ``RandomState`` instance then\n that instance is used.\n\n Methods\n -------\n rvs\n pmf\n logpmf\n cdf\n logcdf\n sf\n logsf\n ppf\n isf\n moment\n stats\n entropy\n expect\n median\n mean\n std\n var\n interval\n __call__\n support\n\n Notes\n -----\n This class is similar to `rv_continuous`. Whether a shape parameter is\n valid is decided by an ``_argcheck`` method (which defaults to checking\n that its arguments are strictly positive.)\n The main differences are:\n\n - the support of the distribution is a set of integers\n - instead of the probability density function, ``pdf`` (and the\n corresponding private ``_pdf``), this class defines the\n *probability mass function*, `pmf` (and the corresponding\n private ``_pmf``.)\n - scale parameter is not defined.\n\n To create a new discrete distribution, we would do the following:\n\n >>> from scipy.stats import rv_discrete\n >>> class poisson_gen(rv_discrete):\n ... \"Poisson distribution\"\n ... def _pmf(self, k, mu):\n ... return exp(-mu) * mu**k / factorial(k)\n\n and create an instance::\n\n >>> poisson = poisson_gen(name=\"poisson\")\n\n Note that above we defined the Poisson distribution in the standard form.\n Shifting the distribution can be done by providing the ``loc`` parameter\n to the methods of the instance. For example, ``poisson.pmf(x, mu, loc)``\n delegates the work to ``poisson._pmf(x-loc, mu)``.\n\n **Discrete distributions from a list of probabilities**\n\n Alternatively, you can construct an arbitrary discrete rv defined\n on a finite set of values ``xk`` with ``Prob{X=xk} = pk`` by using the\n ``values`` keyword argument to the `rv_discrete` constructor.\n\n Examples\n --------\n Custom made discrete distribution:\n\n >>> from scipy import stats\n >>> xk = np.arange(7)\n >>> pk = (0.1, 0.2, 0.3, 0.1, 0.1, 0.0, 0.2)\n >>> custm = stats.rv_discrete(name='custm', values=(xk, pk))\n >>>\n >>> import matplotlib.pyplot as plt\n >>> fig, ax = plt.subplots(1, 1)\n >>> ax.plot(xk, custm.pmf(xk), 'ro', ms=12, mec='r')\n >>> ax.vlines(xk, 0, custm.pmf(xk), colors='r', lw=4)\n >>> plt.show()\n\n Random number generation:\n\n >>> R = custm.rvs(size=100)\n\n \"\"\"\n def __new__(cls, a=0, b=inf, name=None, badvalue=None,\n moment_tol=1e-8, values=None, inc=1, longname=None,\n shapes=None, extradoc=None, seed=None):\n\n if values is not None:\n # dispatch to a subclass\n return super(rv_discrete, cls).__new__(rv_sample)\n else:\n # business as usual\n return super(rv_discrete, cls).__new__(cls)\n\n def __init__(self, a=0, b=inf, name=None, badvalue=None,\n moment_tol=1e-8, values=None, inc=1, longname=None,\n shapes=None, extradoc=None, seed=None):\n\n super().__init__(seed)\n\n if extradoc is not None:\n warnings.warn(\"extradoc is deprecated and will be removed in \"\n \"SciPy 1.11.0\", DeprecationWarning)\n\n # cf generic freeze\n self._ctor_param = dict(\n a=a, b=b, name=name, badvalue=badvalue,\n moment_tol=moment_tol, values=values, inc=inc,\n longname=longname, shapes=shapes, extradoc=extradoc, seed=seed)\n\n if badvalue is None:\n badvalue = nan\n self.badvalue = badvalue\n self.a = a\n self.b = b\n self.moment_tol = moment_tol\n self.inc = inc\n self.shapes = shapes\n\n if values is not None:\n raise ValueError(\"rv_discrete.__init__(..., values != None, ...)\")\n\n self._construct_argparser(meths_to_inspect=[self._pmf, self._cdf],\n locscale_in='loc=0',\n # scale=1 for discrete RVs\n locscale_out='loc, 1')\n self._attach_methods()\n self._construct_docstrings(name, longname, extradoc)\n\n def __getstate__(self):\n dct = self.__dict__.copy()\n # these methods will be remade in __setstate__\n attrs = [\"_parse_args\", \"_parse_args_stats\", \"_parse_args_rvs\",\n \"_cdfvec\", \"_ppfvec\", \"generic_moment\"]\n [dct.pop(attr, None) for attr in attrs]\n return dct\n\n def _attach_methods(self):\n \"\"\"Attaches dynamically created methods to the rv_discrete instance.\"\"\"\n self._cdfvec = vectorize(self._cdf_single, otypes='d')\n self.vecentropy = vectorize(self._entropy)\n\n # _attach_methods is responsible for calling _attach_argparser_methods\n self._attach_argparser_methods()\n\n # nin correction needs to be after we know numargs\n # correct nin for generic moment vectorization\n _vec_generic_moment = vectorize(_drv2_moment, otypes='d')\n _vec_generic_moment.nin = self.numargs + 2\n self.generic_moment = types.MethodType(_vec_generic_moment, self)\n\n # correct nin for ppf vectorization\n _vppf = vectorize(_drv2_ppfsingle, otypes='d')\n _vppf.nin = self.numargs + 2\n self._ppfvec = types.MethodType(_vppf, self)\n\n # now that self.numargs is defined, we can adjust nin\n self._cdfvec.nin = self.numargs + 1\n\n def _construct_docstrings(self, name, longname, extradoc):\n if name is None:\n name = 'Distribution'\n self.name = name\n self.extradoc = extradoc\n\n # generate docstring for subclass instances\n if longname is None:\n if name[0] in ['aeiouAEIOU']:\n hstr = \"An \"\n else:\n hstr = \"A \"\n longname = hstr + name\n\n if sys.flags.optimize < 2:\n # Skip adding docstrings if interpreter is run with -OO\n if self.__doc__ is None:\n self._construct_default_doc(longname=longname,\n extradoc=extradoc,\n docdict=docdict_discrete,\n discrete='discrete')\n else:\n dct = dict(distdiscrete)\n self._construct_doc(docdict_discrete, dct.get(self.name))\n\n # discrete RV do not have the scale parameter, remove it\n self.__doc__ = self.__doc__.replace(\n '\\n scale : array_like, '\n 'optional\\n scale parameter (default=1)', '')\n\n def _updated_ctor_param(self):\n \"\"\"Return the current version of _ctor_param, possibly updated by user.\n\n Used by freezing.\n Keep this in sync with the signature of __init__.\n \"\"\"\n dct = self._ctor_param.copy()\n dct['a'] = self.a\n dct['b'] = self.b\n dct['badvalue'] = self.badvalue\n dct['moment_tol'] = self.moment_tol\n dct['inc'] = self.inc\n dct['name'] = self.name\n dct['shapes'] = self.shapes\n dct['extradoc'] = self.extradoc\n return dct\n\n def _nonzero(self, k, *args):\n return floor(k) == k\n\n def _pmf(self, k, *args):\n return self._cdf(k, *args) - self._cdf(k-1, *args)\n\n def _logpmf(self, k, *args):\n return log(self._pmf(k, *args))\n\n def _logpxf(self, k, *args):\n # continuous distributions have PDF, discrete have PMF, but sometimes\n # the distinction doesn't matter. This lets us use `_logpxf` for both\n # discrete and continuous distributions.\n return self._logpmf(k, *args)\n\n def _unpack_loc_scale(self, theta):\n try:\n loc = theta[-1]\n scale = 1\n args = tuple(theta[:-1])\n except IndexError as e:\n raise ValueError(\"Not enough input arguments.\") from e\n return loc, scale, args\n\n def _cdf_single(self, k, *args):\n _a, _b = self._get_support(*args)\n m = arange(int(_a), k+1)\n return np.sum(self._pmf(m, *args), axis=0)\n\n def _cdf(self, x, *args):\n k = floor(x)\n return self._cdfvec(k, *args)\n\n # generic _logcdf, _sf, _logsf, _ppf, _isf, _rvs defined in rv_generic\n\n def rvs(self, *args, **kwargs):\n \"\"\"Random variates of given type.\n\n Parameters\n ----------\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n size : int or tuple of ints, optional\n Defining number of random variates (Default is 1). Note that `size`\n has to be given as keyword, not as positional argument.\n random_state : {None, int, `numpy.random.Generator`,\n `numpy.random.RandomState`}, optional\n\n If `seed` is None (or `np.random`), the `numpy.random.RandomState`\n singleton is used.\n If `seed` is an int, a new ``RandomState`` instance is used,\n seeded with `seed`.\n If `seed` is already a ``Generator`` or ``RandomState`` instance\n then that instance is used.\n\n Returns\n -------\n rvs : ndarray or scalar\n Random variates of given `size`.\n\n \"\"\"\n kwargs['discrete'] = True\n return super().rvs(*args, **kwargs)\n\n def pmf(self, k, *args, **kwds):\n \"\"\"Probability mass function at k of the given RV.\n\n Parameters\n ----------\n k : array_like\n Quantiles.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information)\n loc : array_like, optional\n Location parameter (default=0).\n\n Returns\n -------\n pmf : array_like\n Probability mass function evaluated at k\n\n \"\"\"\n args, loc, _ = self._parse_args(*args, **kwds)\n k, loc = map(asarray, (k, loc))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n k = asarray((k-loc))\n cond0 = self._argcheck(*args)\n cond1 = (k >= _a) & (k <= _b) & self._nonzero(k, *args)\n cond = cond0 & cond1\n output = zeros(shape(cond), 'd')\n place(output, (1-cond0) + np.isnan(k), self.badvalue)\n if np.any(cond):\n goodargs = argsreduce(cond, *((k,)+args))\n place(output, cond, np.clip(self._pmf(*goodargs), 0, 1))\n if output.ndim == 0:\n return output[()]\n return output\n\n def logpmf(self, k, *args, **kwds):\n \"\"\"Log of the probability mass function at k of the given RV.\n\n Parameters\n ----------\n k : array_like\n Quantiles.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter. Default is 0.\n\n Returns\n -------\n logpmf : array_like\n Log of the probability mass function evaluated at k.\n\n \"\"\"\n args, loc, _ = self._parse_args(*args, **kwds)\n k, loc = map(asarray, (k, loc))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n k = asarray((k-loc))\n cond0 = self._argcheck(*args)\n cond1 = (k >= _a) & (k <= _b) & self._nonzero(k, *args)\n cond = cond0 & cond1\n output = empty(shape(cond), 'd')\n output.fill(NINF)\n place(output, (1-cond0) + np.isnan(k), self.badvalue)\n if np.any(cond):\n goodargs = argsreduce(cond, *((k,)+args))\n place(output, cond, self._logpmf(*goodargs))\n if output.ndim == 0:\n return output[()]\n return output\n\n def cdf(self, k, *args, **kwds):\n \"\"\"Cumulative distribution function of the given RV.\n\n Parameters\n ----------\n k : array_like, int\n Quantiles.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n\n Returns\n -------\n cdf : ndarray\n Cumulative distribution function evaluated at `k`.\n\n \"\"\"\n args, loc, _ = self._parse_args(*args, **kwds)\n k, loc = map(asarray, (k, loc))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n k = asarray((k-loc))\n cond0 = self._argcheck(*args)\n cond1 = (k >= _a) & (k < _b)\n cond2 = (k >= _b)\n cond = cond0 & cond1\n output = zeros(shape(cond), 'd')\n place(output, cond2*(cond0 == cond0), 1.0)\n place(output, (1-cond0) + np.isnan(k), self.badvalue)\n\n if np.any(cond):\n goodargs = argsreduce(cond, *((k,)+args))\n place(output, cond, np.clip(self._cdf(*goodargs), 0, 1))\n if output.ndim == 0:\n return output[()]\n return output\n\n def logcdf(self, k, *args, **kwds):\n \"\"\"Log of the cumulative distribution function at k of the given RV.\n\n Parameters\n ----------\n k : array_like, int\n Quantiles.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n\n Returns\n -------\n logcdf : array_like\n Log of the cumulative distribution function evaluated at k.\n\n \"\"\"\n args, loc, _ = self._parse_args(*args, **kwds)\n k, loc = map(asarray, (k, loc))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n k = asarray((k-loc))\n cond0 = self._argcheck(*args)\n cond1 = (k >= _a) & (k < _b)\n cond2 = (k >= _b)\n cond = cond0 & cond1\n output = empty(shape(cond), 'd')\n output.fill(NINF)\n place(output, (1-cond0) + np.isnan(k), self.badvalue)\n place(output, cond2*(cond0 == cond0), 0.0)\n\n if np.any(cond):\n goodargs = argsreduce(cond, *((k,)+args))\n place(output, cond, self._logcdf(*goodargs))\n if output.ndim == 0:\n return output[()]\n return output\n\n def sf(self, k, *args, **kwds):\n \"\"\"Survival function (1 - `cdf`) at k of the given RV.\n\n Parameters\n ----------\n k : array_like\n Quantiles.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n\n Returns\n -------\n sf : array_like\n Survival function evaluated at k.\n\n \"\"\"\n args, loc, _ = self._parse_args(*args, **kwds)\n k, loc = map(asarray, (k, loc))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n k = asarray(k-loc)\n cond0 = self._argcheck(*args)\n cond1 = (k >= _a) & (k < _b)\n cond2 = (k < _a) & cond0\n cond = cond0 & cond1\n output = zeros(shape(cond), 'd')\n place(output, (1-cond0) + np.isnan(k), self.badvalue)\n place(output, cond2, 1.0)\n if np.any(cond):\n goodargs = argsreduce(cond, *((k,)+args))\n place(output, cond, np.clip(self._sf(*goodargs), 0, 1))\n if output.ndim == 0:\n return output[()]\n return output\n\n def logsf(self, k, *args, **kwds):\n \"\"\"Log of the survival function of the given RV.\n\n Returns the log of the \"survival function,\" defined as 1 - `cdf`,\n evaluated at `k`.\n\n Parameters\n ----------\n k : array_like\n Quantiles.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n\n Returns\n -------\n logsf : ndarray\n Log of the survival function evaluated at `k`.\n\n \"\"\"\n args, loc, _ = self._parse_args(*args, **kwds)\n k, loc = map(asarray, (k, loc))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n k = asarray(k-loc)\n cond0 = self._argcheck(*args)\n cond1 = (k >= _a) & (k < _b)\n cond2 = (k < _a) & cond0\n cond = cond0 & cond1\n output = empty(shape(cond), 'd')\n output.fill(NINF)\n place(output, (1-cond0) + np.isnan(k), self.badvalue)\n place(output, cond2, 0.0)\n if np.any(cond):\n goodargs = argsreduce(cond, *((k,)+args))\n place(output, cond, self._logsf(*goodargs))\n if output.ndim == 0:\n return output[()]\n return output\n\n def ppf(self, q, *args, **kwds):\n \"\"\"Percent point function (inverse of `cdf`) at q of the given RV.\n\n Parameters\n ----------\n q : array_like\n Lower tail probability.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n\n Returns\n -------\n k : array_like\n Quantile corresponding to the lower tail probability, q.\n\n \"\"\"\n args, loc, _ = self._parse_args(*args, **kwds)\n q, loc = map(asarray, (q, loc))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n cond0 = self._argcheck(*args) & (loc == loc)\n cond1 = (q > 0) & (q < 1)\n cond2 = (q == 1) & cond0\n cond = cond0 & cond1\n output = np.full(shape(cond), fill_value=self.badvalue, dtype='d')\n # output type 'd' to handle nin and inf\n place(output, (q == 0)*(cond == cond), _a-1 + loc)\n place(output, cond2, _b + loc)\n if np.any(cond):\n goodargs = argsreduce(cond, *((q,)+args+(loc,)))\n loc, goodargs = goodargs[-1], goodargs[:-1]\n place(output, cond, self._ppf(*goodargs) + loc)\n\n if output.ndim == 0:\n return output[()]\n return output\n\n def isf(self, q, *args, **kwds):\n \"\"\"Inverse survival function (inverse of `sf`) at q of the given RV.\n\n Parameters\n ----------\n q : array_like\n Upper tail probability.\n arg1, arg2, arg3,... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n loc : array_like, optional\n Location parameter (default=0).\n\n Returns\n -------\n k : ndarray or scalar\n Quantile corresponding to the upper tail probability, q.\n\n \"\"\"\n args, loc, _ = self._parse_args(*args, **kwds)\n q, loc = map(asarray, (q, loc))\n args = tuple(map(asarray, args))\n _a, _b = self._get_support(*args)\n cond0 = self._argcheck(*args) & (loc == loc)\n cond1 = (q > 0) & (q < 1)\n cond2 = (q == 1) & cond0\n cond3 = (q == 0) & cond0\n cond = cond0 & cond1\n\n # same problem as with ppf; copied from ppf and changed\n output = np.full(shape(cond), fill_value=self.badvalue, dtype='d')\n # output type 'd' to handle nin and inf\n lower_bound = _a - 1 + loc\n upper_bound = _b + loc\n place(output, cond2*(cond == cond), lower_bound)\n place(output, cond3*(cond == cond), upper_bound)\n\n # call place only if at least 1 valid argument\n if np.any(cond):\n goodargs = argsreduce(cond, *((q,)+args+(loc,)))\n loc, goodargs = goodargs[-1], goodargs[:-1]\n # PB same as ticket 766\n place(output, cond, self._isf(*goodargs) + loc)\n\n if output.ndim == 0:\n return output[()]\n return output\n\n def _entropy(self, *args):\n if hasattr(self, 'pk'):\n return stats.entropy(self.pk)\n else:\n _a, _b = self._get_support(*args)\n return _expect(lambda x: entr(self.pmf(x, *args)),\n _a, _b, self.ppf(0.5, *args), self.inc)\n\n def expect(self, func=None, args=(), loc=0, lb=None, ub=None,\n conditional=False, maxcount=1000, tolerance=1e-10, chunksize=32):\n \"\"\"\n Calculate expected value of a function with respect to the distribution\n for discrete distribution by numerical summation.\n\n Parameters\n ----------\n func : callable, optional\n Function for which the expectation value is calculated.\n Takes only one argument.\n The default is the identity mapping f(k) = k.\n args : tuple, optional\n Shape parameters of the distribution.\n loc : float, optional\n Location parameter.\n Default is 0.\n lb, ub : int, optional\n Lower and upper bound for the summation, default is set to the\n support of the distribution, inclusive (``lb <= k <= ub``).\n conditional : bool, optional\n If true then the expectation is corrected by the conditional\n probability of the summation interval. The return value is the\n expectation of the function, `func`, conditional on being in\n the given interval (k such that ``lb <= k <= ub``).\n Default is False.\n maxcount : int, optional\n Maximal number of terms to evaluate (to avoid an endless loop for\n an infinite sum). Default is 1000.\n tolerance : float, optional\n Absolute tolerance for the summation. Default is 1e-10.\n chunksize : int, optional\n Iterate over the support of a distributions in chunks of this size.\n Default is 32.\n\n Returns\n -------\n expect : float\n Expected value.\n\n Notes\n -----\n For heavy-tailed distributions, the expected value may or\n may not exist,\n depending on the function, `func`. If it does exist, but the\n sum converges\n slowly, the accuracy of the result may be rather low. For instance, for\n ``zipf(4)``, accuracy for mean, variance in example is only 1e-5.\n increasing `maxcount` and/or `chunksize` may improve the result,\n but may also make zipf very slow.\n\n The function is not vectorized.\n\n \"\"\"\n if func is None:\n def fun(x):\n # loc and args from outer scope\n return (x+loc)*self._pmf(x, *args)\n else:\n def fun(x):\n # loc and args from outer scope\n return func(x+loc)*self._pmf(x, *args)\n # used pmf because _pmf does not check support in randint and there\n # might be problems(?) with correct self.a, self.b at this stage maybe\n # not anymore, seems to work now with _pmf\n\n _a, _b = self._get_support(*args)\n if lb is None:\n lb = _a\n else:\n lb = lb - loc # convert bound for standardized distribution\n if ub is None:\n ub = _b\n else:\n ub = ub - loc # convert bound for standardized distribution\n if conditional:\n invfac = self.sf(lb-1, *args) - self.sf(ub, *args)\n else:\n invfac = 1.0\n\n if isinstance(self, rv_sample):\n res = self._expect(fun, lb, ub)\n return res / invfac\n\n # iterate over the support, starting from the median\n x0 = self.ppf(0.5, *args)\n res = _expect(fun, lb, ub, x0, self.inc, maxcount, tolerance, chunksize)\n return res / invfac\n\n def _param_info(self):\n shape_info = self._shape_info()\n loc_info = _ShapeInfo(\"loc\", True, (-np.inf, np.inf), (False, False))\n param_info = shape_info + [loc_info]\n return param_info\n\n\ndef _expect(fun, lb, ub, x0, inc, maxcount=1000, tolerance=1e-10,\n chunksize=32):\n \"\"\"Helper for computing the expectation value of `fun`.\"\"\"\n # short-circuit if the support size is small enough\n if (ub - lb) <= chunksize:\n supp = np.arange(lb, ub+1, inc)\n vals = fun(supp)\n return np.sum(vals)\n\n # otherwise, iterate starting from x0\n if x0 < lb:\n x0 = lb\n if x0 > ub:\n x0 = ub\n\n count, tot = 0, 0.\n # iterate over [x0, ub] inclusive\n for x in _iter_chunked(x0, ub+1, chunksize=chunksize, inc=inc):\n count += x.size\n delta = np.sum(fun(x))\n tot += delta\n if abs(delta) < tolerance * x.size:\n break\n if count > maxcount:\n warnings.warn('expect(): sum did not converge', RuntimeWarning)\n return tot\n\n # iterate over [lb, x0)\n for x in _iter_chunked(x0-1, lb-1, chunksize=chunksize, inc=-inc):\n count += x.size\n delta = np.sum(fun(x))\n tot += delta\n if abs(delta) < tolerance * x.size:\n break\n if count > maxcount:\n warnings.warn('expect(): sum did not converge', RuntimeWarning)\n break\n\n return tot\n\n\ndef _iter_chunked(x0, x1, chunksize=4, inc=1):\n \"\"\"Iterate from x0 to x1 in chunks of chunksize and steps inc.\n\n x0 must be finite, x1 need not be. In the latter case, the iterator is\n infinite.\n Handles both x0 < x1 and x0 > x1. In the latter case, iterates downwards\n (make sure to set inc < 0.)\n\n >>> [x for x in _iter_chunked(2, 5, inc=2)]\n [array([2, 4])]\n >>> [x for x in _iter_chunked(2, 11, inc=2)]\n [array([2, 4, 6, 8]), array([10])]\n >>> [x for x in _iter_chunked(2, -5, inc=-2)]\n [array([ 2, 0, -2, -4])]\n >>> [x for x in _iter_chunked(2, -9, inc=-2)]\n [array([ 2, 0, -2, -4]), array([-6, -8])]\n\n \"\"\"\n if inc == 0:\n raise ValueError('Cannot increment by zero.')\n if chunksize <= 0:\n raise ValueError('Chunk size must be positive; got %s.' % chunksize)\n\n s = 1 if inc > 0 else -1\n stepsize = abs(chunksize * inc)\n\n x = x0\n while (x - x1) * inc < 0:\n delta = min(stepsize, abs(x - x1))\n step = delta * s\n supp = np.arange(x, x + step, inc)\n x += step\n yield supp\n\n\nclass rv_sample(rv_discrete):\n \"\"\"A 'sample' discrete distribution defined by the support and values.\n\n The ctor ignores most of the arguments, only needs the `values` argument.\n \"\"\"\n def __init__(self, a=0, b=inf, name=None, badvalue=None,\n moment_tol=1e-8, values=None, inc=1, longname=None,\n shapes=None, extradoc=None, seed=None):\n\n super(rv_discrete, self).__init__(seed)\n\n if extradoc is not None:\n warnings.warn(\"extradoc is deprecated and will be removed in \"\n \"SciPy 1.11.0\", DeprecationWarning)\n\n if values is None:\n raise ValueError(\"rv_sample.__init__(..., values=None,...)\")\n\n # cf generic freeze\n self._ctor_param = dict(\n a=a, b=b, name=name, badvalue=badvalue,\n moment_tol=moment_tol, values=values, inc=inc,\n longname=longname, shapes=shapes, extradoc=extradoc, seed=seed)\n\n if badvalue is None:\n badvalue = nan\n self.badvalue = badvalue\n self.moment_tol = moment_tol\n self.inc = inc\n self.shapes = shapes\n self.vecentropy = self._entropy\n\n xk, pk = values\n\n if np.shape(xk) != np.shape(pk):\n raise ValueError(\"xk and pk must have the same shape.\")\n if np.less(pk, 0.0).any():\n raise ValueError(\"All elements of pk must be non-negative.\")\n if not np.allclose(np.sum(pk), 1):\n raise ValueError(\"The sum of provided pk is not 1.\")\n\n indx = np.argsort(np.ravel(xk))\n self.xk = np.take(np.ravel(xk), indx, 0)\n self.pk = np.take(np.ravel(pk), indx, 0)\n self.a = self.xk[0]\n self.b = self.xk[-1]\n\n self.qvals = np.cumsum(self.pk, axis=0)\n\n self.shapes = ' ' # bypass inspection\n\n self._construct_argparser(meths_to_inspect=[self._pmf],\n locscale_in='loc=0',\n # scale=1 for discrete RVs\n locscale_out='loc, 1')\n\n self._attach_methods()\n\n self._construct_docstrings(name, longname, extradoc)\n\n def __getstate__(self):\n dct = self.__dict__.copy()\n\n # these methods will be remade in rv_generic.__setstate__,\n # which calls rv_generic._attach_methods\n attrs = [\"_parse_args\", \"_parse_args_stats\", \"_parse_args_rvs\"]\n [dct.pop(attr, None) for attr in attrs]\n\n return dct\n\n def _attach_methods(self):\n \"\"\"Attaches dynamically created argparser methods.\"\"\"\n self._attach_argparser_methods()\n\n def _get_support(self, *args):\n \"\"\"Return the support of the (unscaled, unshifted) distribution.\n\n Parameters\n ----------\n arg1, arg2, ... : array_like\n The shape parameter(s) for the distribution (see docstring of the\n instance object for more information).\n\n Returns\n -------\n a, b : numeric (float, or int or +/-np.inf)\n end-points of the distribution's support.\n \"\"\"\n return self.a, self.b\n\n def _pmf(self, x):\n return np.select([x == k for k in self.xk],\n [np.broadcast_arrays(p, x)[0] for p in self.pk], 0)\n\n def _cdf(self, x):\n xx, xxk = np.broadcast_arrays(x[:, None], self.xk)\n indx = np.argmax(xxk > xx, axis=-1) - 1\n return self.qvals[indx]\n\n def _ppf(self, q):\n qq, sqq = np.broadcast_arrays(q[..., None], self.qvals)\n indx = argmax(sqq >= qq, axis=-1)\n return self.xk[indx]\n\n def _rvs(self, size=None, random_state=None):\n # Need to define it explicitly, otherwise .rvs() with size=None\n # fails due to explicit broadcasting in _ppf\n U = random_state.uniform(size=size)\n if size is None:\n U = np.array(U, ndmin=1)\n Y = self._ppf(U)[0]\n else:\n Y = self._ppf(U)\n return Y\n\n def _entropy(self):\n return stats.entropy(self.pk)\n\n def generic_moment(self, n):\n n = asarray(n)\n return np.sum(self.xk**n[np.newaxis, ...] * self.pk, axis=0)\n\n def _expect(self, fun, lb, ub, *args, **kwds):\n # ignore all args, just do a brute force summation\n supp = self.xk[(lb <= self.xk) & (self.xk <= ub)]\n vals = fun(supp)\n return np.sum(vals)\n\n\ndef _check_shape(argshape, size):\n \"\"\"\n This is a utility function used by `_rvs()` in the class geninvgauss_gen.\n It compares the tuple argshape to the tuple size.\n\n Parameters\n ----------\n argshape : tuple of integers\n Shape of the arguments.\n size : tuple of integers or integer\n Size argument of rvs().\n\n Returns\n -------\n The function returns two tuples, scalar_shape and bc.\n\n scalar_shape : tuple\n Shape to which the 1-d array of random variates returned by\n _rvs_scalar() is converted when it is copied into the\n output array of _rvs().\n\n bc : tuple of booleans\n bc is an tuple the same length as size. bc[j] is True if the data\n associated with that index is generated in one call of _rvs_scalar().\n\n \"\"\"\n scalar_shape = []\n bc = []\n for argdim, sizedim in zip_longest(argshape[::-1], size[::-1],\n fillvalue=1):\n if sizedim > argdim or (argdim == sizedim == 1):\n scalar_shape.append(sizedim)\n bc.append(True)\n else:\n bc.append(False)\n return tuple(scalar_shape[::-1]), tuple(bc[::-1])\n\n\ndef get_distribution_names(namespace_pairs, rv_base_class):\n \"\"\"Collect names of statistical distributions and their generators.\n\n Parameters\n ----------\n namespace_pairs : sequence\n A snapshot of (name, value) pairs in the namespace of a module.\n rv_base_class : class\n The base class of random variable generator classes in a module.\n\n Returns\n -------\n distn_names : list of strings\n Names of the statistical distributions.\n distn_gen_names : list of strings\n Names of the generators of the statistical distributions.\n Note that these are not simply the names of the statistical\n distributions, with a _gen suffix added.\n\n \"\"\"\n distn_names = []\n distn_gen_names = []\n for name, value in namespace_pairs:\n if name.startswith('_'):\n continue\n if name.endswith('_gen') and issubclass(value, rv_base_class):\n distn_gen_names.append(name)\n if isinstance(value, rv_base_class):\n distn_names.append(name)\n return distn_names, distn_gen_names\n"
] | [
[
"numpy.sum",
"numpy.ones",
"numpy.vectorize",
"numpy.less",
"numpy.any",
"numpy.asarray",
"numpy.size",
"numpy.nextafter",
"numpy.log",
"scipy.misc.derivative",
"numpy.isfinite",
"numpy.logical_and",
"scipy.stats.entropy",
"numpy.abs",
"numpy.isnan",
"scipy._lib.doccer.docformat",
"scipy._lib._util.getfullargspec_no_self",
"numpy.broadcast_arrays",
"numpy.zeros",
"scipy.special.entr",
"scipy.special.xlogy",
"scipy._lib._util.check_random_state",
"numpy.argmax",
"numpy.count_nonzero",
"numpy.arange",
"numpy.all",
"numpy.power",
"numpy.min",
"numpy.max",
"scipy.special.comb",
"numpy.broadcast_to",
"numpy.array",
"scipy.integrate.quad",
"numpy.cumsum",
"numpy.empty",
"numpy.isinf",
"numpy.floor",
"numpy.exp",
"numpy.atleast_1d",
"numpy.ravel",
"scipy.optimize.brentq",
"numpy.place",
"numpy.errstate",
"numpy.shape",
"scipy.special.chndtr",
"numpy.sqrt",
"numpy.find_common_type",
"scipy.special.ive"
]
] |
sperlingxx/cudf | [
"c681211df6253e1ceee9203658108980e7e93e3c",
"c681211df6253e1ceee9203658108980e7e93e3c"
] | [
"python/cudf/cudf/tests/test_duplicates.py",
"python/cudf_kafka/setup.py"
] | [
"# Copyright (c) 2020-2021, NVIDIA CORPORATION.\n\nimport itertools as it\nimport random\n\nimport numpy as np\nimport pytest\nfrom pandas import DataFrame, MultiIndex, Series, date_range\n\nimport cudf\nfrom cudf import concat\nfrom cudf.tests.utils import assert_eq, assert_exceptions_equal\n\n# TODO: PANDAS 1.0 support\n# Revisit drop_duplicates() tests to update parameters like ignore_index.\n\n\ndef assert_df(g, p):\n # assert_eq() with sorted index of dataframes\n g = g.sort_index()\n p = p.sort_index()\n return assert_eq(g, p)\n\n\ndef assert_df2(g, p):\n assert g.index.dtype == p.index.dtype\n np.testing.assert_equal(g.index.to_array(), p.index)\n assert tuple(g.columns) == tuple(p.columns)\n for k in g.columns:\n assert g[k].dtype == p[k].dtype\n np.testing.assert_equal(g[k].to_array(), p[k])\n\n\n# most tests are similar to pandas drop_duplicates\n\n\[email protected](\"subset\", [\"a\", [\"a\"], [\"a\", \"B\"]])\ndef test_duplicated_with_misspelled_column_name(subset):\n df = DataFrame({\"A\": [0, 0, 1], \"B\": [0, 0, 1], \"C\": [0, 0, 1]})\n gdf = cudf.DataFrame.from_pandas(df)\n\n assert_exceptions_equal(\n lfunc=df.drop_duplicates,\n rfunc=gdf.drop_duplicates,\n lfunc_args_and_kwargs=([subset],),\n rfunc_args_and_kwargs=([subset],),\n compare_error_message=False,\n )\n\n\[email protected](\"keep\", [\"first\", \"last\", False])\[email protected](\n \"data\",\n [\n [1, 2, 4, 5, 6, 6],\n [],\n [\"a\", \"b\", \"s\", \"sd\", \"a\", \"b\"],\n Series([\"aaa\"] * 10, dtype=\"object\"),\n ],\n)\ndef test_drop_duplicates_series(data, keep):\n pds = cudf.utils.utils._create_pandas_series(data)\n gds = cudf.from_pandas(pds)\n\n assert_df(pds.drop_duplicates(keep=keep), gds.drop_duplicates(keep=keep))\n pds.drop_duplicates(keep=keep, inplace=True)\n gds.drop_duplicates(keep=keep, inplace=True)\n assert_df(pds, gds)\n\n\ndef test_drop_duplicates():\n pdf = DataFrame(\n {\n \"AAA\": [\"foo\", \"bar\", \"foo\", \"bar\", \"foo\", \"bar\", \"bar\", \"foo\"],\n \"B\": [\"one\", \"one\", \"two\", \"two\", \"two\", \"two\", \"one\", \"two\"],\n \"C\": [1, 1, 2, 2, 2, 2, 1, 2],\n \"D\": range(8),\n }\n )\n gdf = cudf.DataFrame.from_pandas(pdf)\n # single column\n result = gdf.copy()\n result.drop_duplicates(\"AAA\", inplace=True)\n expected = pdf.copy()\n expected.drop_duplicates(\"AAA\", inplace=True)\n assert_df(result, expected)\n\n result = gdf.drop_duplicates(\"AAA\", keep=\"last\")\n expected = pdf.drop_duplicates(\"AAA\", keep=\"last\")\n assert_df(result, expected)\n\n result = gdf.drop_duplicates(\"AAA\", keep=False)\n expected = pdf.drop_duplicates(\"AAA\", keep=False)\n assert_df(result, expected)\n assert len(result) == 0\n\n # multi column\n expected = pdf.loc[[0, 1, 2, 3]]\n result = gdf.drop_duplicates(np.array([\"AAA\", \"B\"]))\n assert_df(result, expected)\n result = pdf.drop_duplicates(np.array([\"AAA\", \"B\"]))\n assert_df(result, expected)\n\n result = gdf.drop_duplicates((\"AAA\", \"B\"), keep=\"last\")\n expected = pdf.drop_duplicates((\"AAA\", \"B\"), keep=\"last\")\n assert_df(result, expected)\n\n result = gdf.drop_duplicates((\"AAA\", \"B\"), keep=False)\n expected = pdf.drop_duplicates((\"AAA\", \"B\"), keep=False)\n assert_df(result, expected)\n\n # consider everything\n df2 = gdf.loc[:, [\"AAA\", \"B\", \"C\"]]\n\n result = df2.drop_duplicates()\n # in this case only\n expected = df2.drop_duplicates([\"AAA\", \"B\"])\n assert_df(result, expected)\n\n result = df2.drop_duplicates(keep=\"last\")\n expected = df2.drop_duplicates([\"AAA\", \"B\"], keep=\"last\")\n assert_df(result, expected)\n\n result = df2.drop_duplicates(keep=False)\n expected = df2.drop_duplicates([\"AAA\", \"B\"], keep=False)\n assert_df(result, expected)\n\n # integers\n result = gdf.drop_duplicates(\"C\")\n expected = pdf.drop_duplicates(\"C\")\n assert_df(result, expected)\n result = gdf.drop_duplicates(\"C\", keep=\"last\")\n expected = pdf.drop_duplicates(\"C\", keep=\"last\")\n assert_df(result, expected)\n\n gdf[\"E\"] = gdf[\"C\"].astype(\"int8\")\n result = gdf.drop_duplicates(\"E\")\n pdf[\"E\"] = pdf[\"C\"].astype(\"int8\")\n expected = pdf.drop_duplicates(\"E\")\n assert_df(result, expected)\n result = gdf.drop_duplicates(\"E\", keep=\"last\")\n expected = pdf.drop_duplicates(\"E\", keep=\"last\")\n assert_df(result, expected)\n\n pdf = DataFrame({\"x\": [7, 6, 3, 3, 4, 8, 0], \"y\": [0, 6, 5, 5, 9, 1, 2]})\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(), pdf.drop_duplicates())\n\n pdf = DataFrame([[1, 0], [0, 2]])\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(), pdf.drop_duplicates())\n\n pdf = DataFrame([[-2, 0], [0, -4]])\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(), pdf.drop_duplicates())\n\n x = np.iinfo(np.int64).max / 3 * 2\n pdf = DataFrame([[-x, x], [0, x + 4]])\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(), pdf.drop_duplicates())\n\n pdf = DataFrame([[-x, x], [x, x + 4]])\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(), pdf.drop_duplicates())\n\n pdf = DataFrame([i] * 9 for i in range(16))\n pdf = pdf.append([[1] + [0] * 8], ignore_index=True)\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(), pdf.drop_duplicates())\n\n\[email protected](reason=\"cudf does not support duplicate column names yet\")\ndef test_drop_duplicates_with_duplicate_column_names():\n df = DataFrame([[1, 2, 5], [3, 4, 6], [3, 4, 7]], columns=[\"a\", \"a\", \"b\"])\n df = cudf.DataFrame.from_pandas(df)\n\n result0 = df.drop_duplicates()\n assert_df(result0, df)\n\n result1 = df.drop_duplicates(\"a\")\n expected1 = df[:2]\n assert_df(result1, expected1)\n\n\ndef test_drop_duplicates_for_take_all():\n pdf = DataFrame(\n {\n \"AAA\": [\"foo\", \"bar\", \"baz\", \"bar\", \"foo\", \"bar\", \"qux\", \"foo\"],\n \"B\": [\"one\", \"one\", \"two\", \"two\", \"two\", \"two\", \"one\", \"two\"],\n \"C\": [1, 1, 2, 2, 2, 2, 1, 2],\n \"D\": range(8),\n }\n )\n gdf = cudf.DataFrame.from_pandas(pdf)\n # single column\n result = gdf.drop_duplicates(\"AAA\")\n expected = pdf.drop_duplicates(\"AAA\")\n assert_df(result, expected)\n\n result = gdf.drop_duplicates(\"AAA\", keep=\"last\")\n expected = pdf.drop_duplicates(\"AAA\", keep=\"last\")\n assert_df(result, expected)\n\n result = gdf.drop_duplicates(\"AAA\", keep=False)\n expected = pdf.drop_duplicates(\"AAA\", keep=False)\n assert_df(result, expected)\n\n # multiple columns\n result = gdf.drop_duplicates([\"AAA\", \"B\"])\n expected = pdf.drop_duplicates([\"AAA\", \"B\"])\n assert_df(result, expected)\n\n result = gdf.drop_duplicates([\"AAA\", \"B\"], keep=\"last\")\n expected = pdf.drop_duplicates([\"AAA\", \"B\"], keep=\"last\")\n assert_df(result, expected)\n\n result = gdf.drop_duplicates([\"AAA\", \"B\"], keep=False)\n expected = pdf.drop_duplicates([\"AAA\", \"B\"], keep=False)\n assert_df(result, expected)\n\n\ndef test_drop_duplicates_tuple():\n pdf = DataFrame(\n {\n (\"AA\", \"AB\"): [\n \"foo\",\n \"bar\",\n \"foo\",\n \"bar\",\n \"foo\",\n \"bar\",\n \"bar\",\n \"foo\",\n ],\n \"B\": [\"one\", \"one\", \"two\", \"two\", \"two\", \"two\", \"one\", \"two\"],\n \"C\": [1, 1, 2, 2, 2, 2, 1, 2],\n \"D\": range(8),\n }\n )\n gdf = cudf.DataFrame.from_pandas(pdf)\n # single column\n result = gdf.drop_duplicates((\"AA\", \"AB\"))\n expected = pdf.drop_duplicates((\"AA\", \"AB\"))\n assert_df(result, expected)\n\n result = gdf.drop_duplicates((\"AA\", \"AB\"), keep=\"last\")\n expected = pdf.drop_duplicates((\"AA\", \"AB\"), keep=\"last\")\n assert_df(result, expected)\n\n result = gdf.drop_duplicates((\"AA\", \"AB\"), keep=False)\n expected = pdf.drop_duplicates((\"AA\", \"AB\"), keep=False) # empty df\n assert len(result) == 0\n assert_df(result, expected)\n\n # multi column\n expected = pdf.drop_duplicates(((\"AA\", \"AB\"), \"B\"))\n result = gdf.drop_duplicates(((\"AA\", \"AB\"), \"B\"))\n assert_df(result, expected)\n\n\[email protected](\n \"df\",\n [\n DataFrame(),\n DataFrame(columns=[]),\n DataFrame(columns=[\"A\", \"B\", \"C\"]),\n DataFrame(index=[]),\n DataFrame(index=[\"A\", \"B\", \"C\"]),\n ],\n)\ndef test_drop_duplicates_empty(df):\n df = cudf.DataFrame.from_pandas(df)\n result = df.drop_duplicates()\n assert_df(result, df)\n\n result = df.copy()\n result.drop_duplicates(inplace=True)\n assert_df(result, df)\n\n\[email protected](\"num_columns\", [3, 4, 5])\ndef test_dataframe_drop_duplicates_numeric_method(num_columns):\n comb = list(it.permutations(range(num_columns), num_columns))\n shuf = list(comb)\n random.Random(num_columns).shuffle(shuf)\n\n def get_pdf(n_dup):\n # create dataframe with n_dup duplicate rows\n rows = comb + shuf[:n_dup]\n random.Random(n_dup).shuffle(rows)\n return DataFrame(rows)\n\n for i in range(5):\n pdf = get_pdf(i)\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(), pdf.drop_duplicates())\n\n # subset columns, single columns\n assert_df(\n gdf.drop_duplicates(pdf.columns[:-1]),\n pdf.drop_duplicates(pdf.columns[:-1]),\n )\n assert_df(\n gdf.drop_duplicates(pdf.columns[-1]),\n pdf.drop_duplicates(pdf.columns[-1]),\n )\n assert_df(\n gdf.drop_duplicates(pdf.columns[0]),\n pdf.drop_duplicates(pdf.columns[0]),\n )\n\n # subset columns shuffled\n cols = list(pdf.columns)\n random.Random(3).shuffle(cols)\n assert_df(gdf.drop_duplicates(cols), pdf.drop_duplicates(cols))\n random.Random(3).shuffle(cols)\n assert_df(gdf.drop_duplicates(cols[:-1]), pdf.drop_duplicates(cols[:-1]))\n random.Random(3).shuffle(cols)\n assert_df(gdf.drop_duplicates(cols[-1]), pdf.drop_duplicates(cols[-1]))\n assert_df(\n gdf.drop_duplicates(cols, keep=\"last\"),\n pdf.drop_duplicates(cols, keep=\"last\"),\n )\n\n\ndef test_dataframe_drop_duplicates_method():\n pdf = DataFrame(\n [(1, 2, \"a\"), (2, 3, \"b\"), (3, 4, \"c\"), (2, 3, \"d\"), (3, 5, \"c\")],\n columns=[\"n1\", \"n2\", \"s1\"],\n )\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(), pdf.drop_duplicates())\n\n assert_eq(\n gdf.drop_duplicates(\"n1\")[\"n1\"].reset_index(drop=True),\n pdf.drop_duplicates(\"n1\")[\"n1\"].reset_index(drop=True),\n )\n assert_eq(\n gdf.drop_duplicates(\"n2\")[\"n2\"].reset_index(drop=True),\n pdf.drop_duplicates(\"n2\")[\"n2\"].reset_index(drop=True),\n )\n assert_eq(\n gdf.drop_duplicates(\"s1\")[\"s1\"].reset_index(drop=True),\n pdf.drop_duplicates(\"s1\")[\"s1\"].reset_index(drop=True),\n )\n assert_eq(\n gdf.drop_duplicates(\"s1\", keep=\"last\")[\"s1\"]\n .sort_index()\n .reset_index(drop=True),\n pdf.drop_duplicates(\"s1\", keep=\"last\")[\"s1\"].reset_index(drop=True),\n )\n assert gdf.drop_duplicates(\"s1\", inplace=True) is None\n\n gdf = cudf.DataFrame.from_pandas(pdf)\n assert_df(gdf.drop_duplicates(\"n1\"), pdf.drop_duplicates(\"n1\"))\n assert_df(gdf.drop_duplicates(\"n2\"), pdf.drop_duplicates(\"n2\"))\n assert_df(gdf.drop_duplicates(\"s1\"), pdf.drop_duplicates(\"s1\"))\n assert_df(\n gdf.drop_duplicates([\"n1\", \"n2\"]), pdf.drop_duplicates([\"n1\", \"n2\"])\n )\n assert_df(\n gdf.drop_duplicates([\"n1\", \"s1\"]), pdf.drop_duplicates([\"n1\", \"s1\"])\n )\n\n # Test drop error\n assert_exceptions_equal(\n lfunc=pdf.drop_duplicates,\n rfunc=gdf.drop_duplicates,\n lfunc_args_and_kwargs=([\"n3\"],),\n rfunc_args_and_kwargs=([\"n3\"],),\n expected_error_message=\"columns {'n3'} do not exist\",\n )\n\n assert_exceptions_equal(\n lfunc=pdf.drop_duplicates,\n rfunc=gdf.drop_duplicates,\n lfunc_args_and_kwargs=([[\"n1\", \"n4\", \"n3\"]],),\n rfunc_args_and_kwargs=([[\"n1\", \"n4\", \"n3\"]],),\n expected_error_message=\"columns {'n[34]', 'n[34]'} do not exist\",\n )\n\n\ndef test_datetime_drop_duplicates():\n\n date_df = cudf.DataFrame()\n date_df[\"date\"] = date_range(\"11/20/2018\", periods=6, freq=\"D\")\n date_df[\"value\"] = np.random.sample(len(date_df))\n\n df = concat([date_df, date_df[:4]])\n assert_df(df[:-4], df.drop_duplicates())\n\n df2 = df.reset_index()\n assert_df(df2[:-4], df2.drop_duplicates())\n\n df3 = df.set_index(\"date\")\n assert_df(df3[:-4], df3.drop_duplicates())\n\n\ndef test_drop_duplicates_NA():\n # none\n df = DataFrame(\n {\n \"A\": [None, None, \"foo\", \"bar\", \"foo\", \"bar\", \"bar\", \"foo\"],\n \"B\": [\"one\", \"one\", \"two\", \"two\", \"two\", \"two\", \"one\", \"two\"],\n \"C\": [1.0, np.nan, np.nan, np.nan, 1.0, 1.0, 1, 1.0],\n \"D\": range(8),\n }\n )\n df = cudf.DataFrame.from_pandas(df)\n # single column\n result = df.drop_duplicates(\"A\")\n expected = df.to_pandas().loc[[0, 2, 3]]\n assert_df(result, expected)\n\n result = df.drop_duplicates(\"A\", keep=\"last\")\n expected = df.to_pandas().loc[[1, 6, 7]]\n assert_df(result, expected)\n\n result = df.drop_duplicates(\"A\", keep=False)\n expected = df.to_pandas().loc[[]] # empty df\n assert_df(result, expected)\n assert len(result) == 0\n\n # multi column\n result = df.drop_duplicates([\"A\", \"B\"])\n expected = df.to_pandas().loc[[0, 2, 3, 6]]\n assert_df(result, expected)\n\n result = df.drop_duplicates([\"A\", \"B\"], keep=\"last\")\n expected = df.to_pandas().loc[[1, 5, 6, 7]]\n assert_df(result, expected)\n\n result = df.drop_duplicates([\"A\", \"B\"], keep=False)\n expected = df.to_pandas().loc[[6]]\n assert_df(result, expected)\n\n # nan\n df = DataFrame(\n {\n \"A\": [\"foo\", \"bar\", \"foo\", \"bar\", \"foo\", \"bar\", \"bar\", \"foo\"],\n \"B\": [\"one\", \"one\", \"two\", \"two\", \"two\", \"two\", \"one\", \"two\"],\n \"C\": [1.0, np.nan, np.nan, np.nan, 1.0, 1.0, 1, 1.0],\n \"D\": range(8),\n }\n )\n df = cudf.DataFrame.from_pandas(df)\n # single column\n result = df.drop_duplicates(\"C\")\n expected = df[:2]\n assert_df(result, expected)\n\n result = df.drop_duplicates(\"C\", keep=\"last\")\n expected = df.to_pandas().loc[[3, 7]]\n assert_df(result, expected)\n\n result = df.drop_duplicates(\"C\", keep=False)\n expected = df.to_pandas().loc[[]] # empty df\n assert_df(result, expected)\n assert len(result) == 0\n\n # multi column\n result = df.drop_duplicates([\"C\", \"B\"])\n expected = df.to_pandas().loc[[0, 1, 2, 4]]\n assert_df(result, expected)\n\n result = df.drop_duplicates([\"C\", \"B\"], keep=\"last\")\n expected = df.to_pandas().loc[[1, 3, 6, 7]]\n assert_df(result, expected)\n\n result = df.drop_duplicates([\"C\", \"B\"], keep=False)\n expected = df.to_pandas().loc[[1]]\n assert_df(result, expected)\n\n\ndef test_drop_duplicates_NA_for_take_all():\n # TODO: PANDAS 1.0 support - add ignore_index for\n # pandas drop_duplicates calls in this function.\n\n # none\n pdf = DataFrame(\n {\n \"A\": [None, None, \"foo\", \"bar\", \"foo\", \"baz\", \"bar\", \"qux\"],\n \"C\": [1.0, np.nan, np.nan, np.nan, 1.0, 2.0, 3, 1.0],\n }\n )\n\n df = cudf.DataFrame.from_pandas(pdf)\n # single column\n result = df.drop_duplicates(\"A\")\n expected = pdf.iloc[[0, 2, 3, 5, 7]]\n assert_df(result, expected)\n assert_df(\n df.drop_duplicates(\"A\", ignore_index=True),\n result.reset_index(drop=True),\n )\n\n result = df.drop_duplicates(\"A\", keep=\"last\")\n expected = pdf.iloc[[1, 4, 5, 6, 7]]\n assert_df(result, expected)\n assert_df(\n df.drop_duplicates(\"A\", ignore_index=True, keep=\"last\"),\n result.reset_index(drop=True),\n )\n\n result = df.drop_duplicates(\"A\", keep=False)\n expected = pdf.iloc[[5, 7]]\n assert_df(result, expected)\n assert_df(\n df.drop_duplicates(\"A\", ignore_index=True, keep=False),\n result.reset_index(drop=True),\n )\n\n # nan\n\n # single column\n result = df.drop_duplicates(\"C\")\n expected = pdf.iloc[[0, 1, 5, 6]]\n assert_df(result, expected)\n\n result = df.drop_duplicates(\"C\", keep=\"last\")\n expected = pdf.iloc[[3, 5, 6, 7]]\n assert_df(result, expected)\n\n result = df.drop_duplicates(\"C\", keep=False)\n expected = pdf.iloc[[5, 6]]\n assert_df(result, expected)\n\n\ndef test_drop_duplicates_inplace():\n orig = DataFrame(\n {\n \"A\": [\"foo\", \"bar\", \"foo\", \"bar\", \"foo\", \"bar\", \"bar\", \"foo\"],\n \"B\": [\"one\", \"one\", \"two\", \"two\", \"two\", \"two\", \"one\", \"two\"],\n \"C\": [1, 1, 2, 2, 2, 2, 1, 2],\n \"D\": range(8),\n }\n )\n orig = cudf.DataFrame.from_pandas(orig)\n # single column\n df = orig.copy()\n df.drop_duplicates(\"A\", inplace=True)\n expected = orig[:2]\n result = df\n assert_df(result, expected)\n\n df = orig.copy()\n df.drop_duplicates(\"A\", keep=\"last\", inplace=True)\n expected = orig.loc[[6, 7]]\n result = df\n assert_df(result, expected)\n\n df = orig.copy()\n df.drop_duplicates(\"A\", keep=False, inplace=True)\n expected = orig.loc[[]]\n result = df\n assert_df(result, expected)\n assert len(df) == 0\n\n # multi column\n df = orig.copy()\n df.drop_duplicates([\"A\", \"B\"], inplace=True)\n expected = orig.loc[[0, 1, 2, 3]]\n result = df\n assert_df(result, expected)\n\n df = orig.copy()\n df.drop_duplicates([\"A\", \"B\"], keep=\"last\", inplace=True)\n expected = orig.loc[[0, 5, 6, 7]]\n result = df\n assert_df(result, expected)\n\n df = orig.copy()\n df.drop_duplicates([\"A\", \"B\"], keep=False, inplace=True)\n expected = orig.loc[[0]]\n result = df\n assert_df(result, expected)\n\n # consider everything\n orig2 = orig.loc[:, [\"A\", \"B\", \"C\"]].copy()\n\n df2 = orig2.copy()\n df2.drop_duplicates(inplace=True)\n # in this case only\n expected = orig2.drop_duplicates([\"A\", \"B\"])\n result = df2\n assert_df(result, expected)\n\n df2 = orig2.copy()\n df2.drop_duplicates(keep=\"last\", inplace=True)\n expected = orig2.drop_duplicates([\"A\", \"B\"], keep=\"last\")\n result = df2\n assert_df(result, expected)\n\n df2 = orig2.copy()\n df2.drop_duplicates(keep=False, inplace=True)\n expected = orig2.drop_duplicates([\"A\", \"B\"], keep=False)\n result = df2\n assert_df(result, expected)\n\n\ndef test_drop_duplicates_multi_index():\n arrays = [\n [\"bar\", \"bar\", \"baz\", \"baz\", \"foo\", \"foo\", \"qux\", \"qux\"],\n [\"one\", \"two\", \"one\", \"two\", \"one\", \"two\", \"one\", \"two\"],\n ]\n\n idx = MultiIndex.from_tuples(list(zip(*arrays)), names=[\"a\", \"b\"])\n pdf = DataFrame(np.random.randint(0, 2, (8, 4)), index=idx)\n gdf = cudf.DataFrame.from_pandas(pdf)\n\n expected = pdf.drop_duplicates()\n result = gdf.drop_duplicates()\n assert_df(result.to_pandas(), expected)\n # FIXME: to_pandas needed until sort_index support for MultiIndex\n\n for col in gdf.columns:\n assert_df(\n gdf[col].drop_duplicates().to_pandas(), pdf[col].drop_duplicates(),\n )\n",
"# Copyright (c) 2020, NVIDIA CORPORATION.\nimport os\nimport shutil\nimport sysconfig\nfrom distutils.sysconfig import get_python_lib\n\nimport numpy as np\nfrom Cython.Build import cythonize\nfrom setuptools import find_packages, setup\nfrom setuptools.extension import Extension\n\nimport versioneer\n\ninstall_requires = [\"cudf\", \"cython\"]\n\ncython_files = [\"cudf_kafka/_lib/*.pyx\"]\n\nCUDA_HOME = os.environ.get(\"CUDA_HOME\", False)\nif not CUDA_HOME:\n path_to_cuda_gdb = shutil.which(\"cuda-gdb\")\n if path_to_cuda_gdb is None:\n raise OSError(\n \"Could not locate CUDA. \"\n \"Please set the environment variable \"\n \"CUDA_HOME to the path to the CUDA installation \"\n \"and try again.\"\n )\n CUDA_HOME = os.path.dirname(os.path.dirname(path_to_cuda_gdb))\n\nif not os.path.isdir(CUDA_HOME):\n raise OSError(f\"Invalid CUDA_HOME: directory does not exist: {CUDA_HOME}\")\n\ncuda_include_dir = os.path.join(CUDA_HOME, \"include\")\n\nCUDF_ROOT = os.environ.get(\n \"CUDF_ROOT\",\n os.path.abspath(\n os.path.join(\n os.path.dirname(os.path.abspath(__file__)), \"../../cpp/build/\"\n )\n ),\n)\nCUDF_KAFKA_ROOT = os.environ.get(\n \"CUDF_KAFKA_ROOT\", \"../../libcudf_kafka/build\"\n)\n\ntry:\n nthreads = int(os.environ.get(\"PARALLEL_LEVEL\", \"0\") or \"0\")\nexcept Exception:\n nthreads = 0\n\nextensions = [\n Extension(\n \"*\",\n sources=cython_files,\n include_dirs=[\n os.path.abspath(os.path.join(CUDF_ROOT, \"../include/cudf\")),\n os.path.abspath(os.path.join(CUDF_ROOT, \"../include\")),\n os.path.abspath(\n os.path.join(CUDF_ROOT, \"../libcudf_kafka/include/cudf_kafka\")\n ),\n os.path.join(CUDF_ROOT, \"include\"),\n os.path.join(CUDF_ROOT, \"_deps/libcudacxx-src/include\"),\n os.path.join(\n os.path.dirname(sysconfig.get_path(\"include\")),\n \"libcudf/libcudacxx\",\n ),\n os.path.dirname(sysconfig.get_path(\"include\")),\n np.get_include(),\n cuda_include_dir,\n ],\n library_dirs=([get_python_lib(), os.path.join(os.sys.prefix, \"lib\")]),\n libraries=[\"cudf\", \"cudf_kafka\"],\n language=\"c++\",\n extra_compile_args=[\"-std=c++14\"],\n )\n]\n\nsetup(\n name=\"cudf_kafka\",\n version=versioneer.get_version(),\n description=\"cuDF Kafka Datasource\",\n url=\"https://github.com/rapidsai/cudf\",\n author=\"NVIDIA Corporation\",\n license=\"Apache 2.0\",\n classifiers=[\n \"Intended Audience :: Developers\",\n \"Topic :: Streaming\",\n \"Topic :: Scientific/Engineering\",\n \"Topic :: Apache Kafka\",\n \"License :: OSI Approved :: Apache Software License\",\n \"Programming Language :: Python\",\n \"Programming Language :: Python :: 3.7\",\n \"Programming Language :: Python :: 3.8\",\n ],\n # Include the separately-compiled shared library\n setup_requires=[\"Cython>=0.29,<0.30\"],\n ext_modules=cythonize(\n extensions,\n nthreads=nthreads,\n compiler_directives=dict(\n profile=False, language_level=3, embedsignature=True\n ),\n ),\n packages=find_packages(include=[\"cudf_kafka\", \"cudf_kafka.*\"]),\n package_data=dict.fromkeys(\n find_packages(include=[\"cudf_kafka._lib*\"]), [\"*.pxd\"],\n ),\n cmdclass=versioneer.get_cmdclass(),\n install_requires=install_requires,\n extras_require={\"test\": [\"pytest\", \"pytest-xdist\"]},\n zip_safe=False,\n)\n"
] | [
[
"pandas.Series",
"pandas.date_range",
"pandas.DataFrame",
"numpy.iinfo",
"numpy.array",
"numpy.random.randint"
],
[
"numpy.get_include"
]
] |
stasbel/Meme-Machinery-VKHack2018 | [
"5e15198d6bc8d350f2dc0158a34467f3415da0bc"
] | [
"experiments/download.py"
] | [
"\"\"\"Downloads prescribed data from the Internet, embed and store it.\"\"\"\n\nimport logging\n\nimport numpy as np\nimport torch\n\nfrom experiments.scrap import META_PATH\nfrom mem.gen.stages import Extractor\n\nlogger = logging.getLogger(__name__)\n\nMATRIX_PATH = 'matrix.npy'\nNEW_META_PATH = 'processed_reddit_data.pth'\n\n\ndef main(_):\n meta = torch.load(META_PATH)\n\n extractor = Extractor()\n meta, matrix = extractor.extract(meta)\n\n torch.save(meta, NEW_META_PATH)\n logger.info(f'Obtain matrix of shape {matrix.shape}.')\n np.save(MATRIX_PATH, matrix)\n\n\ndef _parse_config():\n logging.basicConfig(\n format='%(asctime)s | %(message)s',\n handlers=[\n logging.StreamHandler()\n ],\n level=logging.INFO\n )\n\n\nif __name__ == '__main__':\n main(_parse_config())\n"
] | [
[
"numpy.save",
"torch.save",
"torch.load"
]
] |
jiangyangby/DRDSC | [
"4b53e18626b9839578bea6c84bba47d15bc8d3d6"
] | [
"models.py"
] | [
"from __future__ import print_function, absolute_import, division\n\nimport tensorflow as tf\nfrom tensorflow.contrib import layers\n\nmu = 1.0e-6\n\n\[email protected]_gradient\ndef f_norm(x):\n f2 = tf.square(tf.norm(x, ord='fro', axis=[-2, -1]))\n f = tf.sqrt(f2 + mu ** 2) - mu\n def grad(dy):\n return dy * (x / tf.sqrt(f2 + mu ** 2))\n return f, grad\n\n\[email protected]_gradient\ndef l2_norm(x):\n f2 = tf.square(tf.norm(x, ord=2))\n f = tf.sqrt(f2 + mu ** 2) - mu\n def grad(dy):\n return dy * (x / tf.sqrt(f2 + mu ** 2))\n return f, grad\n\n\nclass RSCConvAE:\n '''\n Duet Robust Deep Subspace Clustering\n '''\n\n def __init__(self, n_input, kernel_size, n_hidden, z_dim, lamda1=1.0,\n lamda2=1.0, eta1=1.0, eta2=1.0, batch_size=200, reg=None,\n denoise=False, save_path=None, restore_path=None,\n normalize_input=False, logs_path='./logs'):\n self.n_input = n_input\n self.kernel_size = kernel_size\n self.n_hidden = n_hidden\n self.batch_size = batch_size\n self.z_dim = z_dim\n self.reg = reg\n self.save_path = save_path\n self.restore_path = restore_path\n self.iter = 0\n\n # input required to be fed\n self.x = tf.placeholder(tf.float32, [None, n_input[0], n_input[1], 1])\n self.learning_rate = tf.placeholder(tf.float32, [])\n\n weights = self._initialize_weights()\n self.x_noise = weights['x_noise']\n self.z_noise = weights['z_noise']\n\n self.z, self.Coef, self.x_r, self.x_diff, self.z_diff = \\\n self._forward(denoise, normalize_input, weights)\n\n # l_2 reconstruction loss\n self.reconst_cost = self._get_reconstruction_loss(eta1)\n tf.summary.scalar(\"recons_loss\", self.reconst_cost)\n\n self.reg_loss = self._get_coef_reg_loss(reg_type='l2') # l2 reg\n tf.summary.scalar(\"reg_loss\", lamda2 * self.reg_loss)\n\n selfexpress_cost = tf.square(self.z_diff - self.z_noise)\n z_noise_reg = tf.map_fn(lambda frame: l2_norm(frame), self.z_noise)\n self.selfexpress_loss = 0.5 * \\\n tf.reduce_sum(selfexpress_cost) + eta2 * tf.reduce_sum(z_noise_reg)\n tf.summary.scalar(\"selfexpress_loss\", lamda1 *\n self.selfexpress_loss)\n\n self.loss = self.reconst_cost + lamda1 * \\\n self.selfexpress_loss + lamda2 * self.reg_loss\n\n self.merged_summary_op = tf.summary.merge_all()\n self.optimizer = tf.train.AdamOptimizer(\n # self.optimizer = tf.train.GradientDescentOptimizer(\n learning_rate=self.learning_rate).minimize(self.loss)\n\n self.init = tf.global_variables_initializer()\n self.sess = tf.InteractiveSession()\n self.sess.run(self.init)\n self.saver = tf.train.Saver(\n [v for v in tf.trainable_variables() if not (v.name.startswith(\"Coef\"))])\n self.summary_writer = tf.summary.FileWriter(\n logs_path, graph=tf.get_default_graph())\n\n def _build_input(self, denoise, normalize_input):\n if not normalize_input:\n x_input = self.x\n else:\n x_input = tf.map_fn(\n lambda frame: tf.image.per_image_standardization(frame), self.x)\n if denoise:\n x_input = tf.add(self.x, tf.random_normal(shape=tf.shape(self.x),\n mean=0,\n stddev=0.2,\n dtype=tf.float32))\n return x_input\n\n def _forward(self, denoise, normalize_input, weights):\n x_input = self._build_input(denoise, normalize_input)\n latent, shape = self.encoder(x_input, weights)\n\n z = tf.reshape(latent, [self.batch_size, -1])\n Coef = weights['Coef']\n Coef = Coef - tf.diag(tf.diag_part(Coef))\n z_c = tf.matmul(Coef, z)\n latent_c = tf.reshape(z_c, tf.shape(latent))\n x_r = self.decoder(latent_c, weights, shape)\n z_diff = z - z_c\n x_diff = x_input - x_r\n return z, Coef, x_r, x_diff, z_diff\n\n def _get_reconstruction_loss(self, eta1):\n reconst_cost = tf.square(self.x_diff - self.x_noise) # l2\n x_noise_3dim = tf.squeeze(self.x_noise)\n x_noise_group_reg = tf.map_fn(\n lambda frame: f_norm(frame), x_noise_3dim)\n reconst_cost = 0.5 * tf.reduce_sum(reconst_cost) + \\\n eta1 * tf.reduce_sum(x_noise_group_reg)\n return reconst_cost\n\n def _get_coef_reg_loss(self, reg_type='l2'):\n if reg_type is 'l2':\n loss = tf.reduce_sum(tf.square(self.Coef))\n elif reg_type is 'l1':\n loss = tf.reduce_sum(tf.abs(self.Coef))\n return loss\n\n def _initialize_weights(self):\n all_weights = dict()\n n_layers = len(self.n_hidden)\n # all_weights['Coef'] = tf.Variable(\n # tf.random_normal([self.batch_size, self.batch_size],\n # mean=0.0, stddev=0.1, dtype=tf.float32,\n # seed=None), name='Coef')\n all_weights['Coef'] = tf.Variable(\n 0 * tf.ones([self.batch_size, self.batch_size], tf.float32), name='Coef')\n all_weights['x_noise'] = tf.Variable(\n tf.zeros([self.batch_size, self.n_input[0],\n self.n_input[1], 1], tf.float32), name='Coef')\n all_weights['z_noise'] = tf.Variable(\n tf.zeros([self.batch_size, self.z_dim], tf.float32), name='Coef')\n\n all_weights['enc_w0'] = tf.get_variable(\"enc_w0\", shape=[self.kernel_size[0], self.kernel_size[0], 1, self.n_hidden[0]],\n initializer=layers.xavier_initializer_conv2d(), regularizer=self.reg)\n all_weights['enc_b0'] = tf.Variable(\n tf.zeros([self.n_hidden[0]], dtype=tf.float32))\n\n for iter_i in range(1, n_layers):\n enc_name_wi = 'enc_w' + str(iter_i)\n all_weights[enc_name_wi] = tf.get_variable(enc_name_wi, shape=[self.kernel_size[iter_i], self.kernel_size[iter_i], self.n_hidden[iter_i - 1],\n self.n_hidden[iter_i]], initializer=layers.xavier_initializer_conv2d(), regularizer=self.reg)\n enc_name_bi = 'enc_b' + str(iter_i)\n all_weights[enc_name_bi] = tf.Variable(\n tf.zeros([self.n_hidden[iter_i]], dtype=tf.float32))\n\n for iter_i in range(1, n_layers):\n dec_name_wi = 'dec_w' + str(iter_i - 1)\n all_weights[dec_name_wi] = tf.get_variable(dec_name_wi, shape=[self.kernel_size[n_layers - iter_i], self.kernel_size[n_layers - iter_i],\n self.n_hidden[n_layers - iter_i - 1], self.n_hidden[n_layers - iter_i]],\n initializer=layers.xavier_initializer_conv2d(), regularizer=self.reg)\n dec_name_bi = 'dec_b' + str(iter_i - 1)\n all_weights[dec_name_bi] = tf.Variable(tf.zeros(\n [self.n_hidden[n_layers - iter_i - 1]], dtype=tf.float32))\n\n dec_name_wi = 'dec_w' + str(n_layers - 1)\n all_weights[dec_name_wi] = tf.get_variable(dec_name_wi, shape=[self.kernel_size[0], self.kernel_size[0], 1, self.n_hidden[0]],\n initializer=layers.xavier_initializer_conv2d(), regularizer=self.reg)\n dec_name_bi = 'dec_b' + str(n_layers - 1)\n all_weights[dec_name_bi] = tf.Variable(\n tf.zeros([1], dtype=tf.float32))\n\n return all_weights\n\n # Building the encoder\n def encoder(self, x, weights):\n shapes = []\n shapes.append(x.get_shape().as_list())\n layeri = tf.nn.bias_add(tf.nn.conv2d(x, weights['enc_w0'], strides=[\n 1, 2, 2, 1], padding='SAME'), weights['enc_b0'])\n layeri = tf.nn.relu(layeri)\n shapes.append(layeri.get_shape().as_list())\n\n for iter_i in range(1, len(self.n_hidden)):\n layeri = tf.nn.bias_add(tf.nn.conv2d(layeri, weights['enc_w' + str(iter_i)], strides=[\n 1, 2, 2, 1], padding='SAME'), weights['enc_b' + str(iter_i)])\n layeri = tf.nn.relu(layeri)\n shapes.append(layeri.get_shape().as_list())\n\n layer3 = layeri\n return layer3, shapes\n\n # Building the decoder\n def decoder(self, z, weights, shapes):\n n_layers = len(self.n_hidden)\n layer3 = z\n for iter_i in range(n_layers):\n shape_de = shapes[n_layers - iter_i - 1]\n layer3 = tf.add(tf.nn.conv2d_transpose(layer3, weights['dec_w' + str(iter_i)], tf.stack([tf.shape(self.x)[0], shape_de[1], shape_de[2], shape_de[3]]),\n strides=[1, 2, 2, 1], padding='SAME'), weights['dec_b' + str(iter_i)])\n layer3 = tf.nn.relu(layer3)\n return layer3\n\n def partial_fit(self, X, lr):\n cost, summary, _, Coef, z_diff, x_diff = self.sess.run(\n (self.loss, self.merged_summary_op, self.optimizer, self.Coef,\n self.z_diff, self.x_diff),\n feed_dict={self.x: X, self.learning_rate: lr})\n self.summary_writer.add_summary(summary, self.iter)\n self.iter = self.iter + 1\n return cost, Coef, z_diff, x_diff\n\n def initlization(self):\n self.sess.run(self.init)\n\n def reconstruct(self, X):\n return self.sess.run(self.x_r, feed_dict={self.x: X})\n\n def transform(self, X):\n return self.sess.run(self.z, feed_dict={self.x: X})\n\n def save_model(self):\n save_path = self.saver.save(self.sess, self.save_path)\n print(\"model saved in file: %s\" % save_path)\n\n def restore(self):\n self.saver.restore(self.sess, self.restore_path)\n print(\"model restored\")\n"
] | [
[
"tensorflow.summary.scalar",
"tensorflow.reshape",
"tensorflow.ones",
"tensorflow.matmul",
"tensorflow.InteractiveSession",
"tensorflow.squeeze",
"tensorflow.contrib.layers.xavier_initializer_conv2d",
"tensorflow.abs",
"tensorflow.reduce_sum",
"tensorflow.global_variables_initializer",
"tensorflow.image.per_image_standardization",
"tensorflow.norm",
"tensorflow.shape",
"tensorflow.diag_part",
"tensorflow.placeholder",
"tensorflow.zeros",
"tensorflow.summary.merge_all",
"tensorflow.sqrt",
"tensorflow.train.AdamOptimizer",
"tensorflow.nn.conv2d",
"tensorflow.trainable_variables",
"tensorflow.square",
"tensorflow.get_default_graph",
"tensorflow.nn.relu"
]
] |
raijin0704/models | [
"6906bfbdbf2ad628bb6aeca9989dc04f605b6a60"
] | [
"research/object_detection/metrics/coco_evaluation.py"
] | [
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Class for evaluating object detections with COCO metrics.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import zip\nimport tensorflow.compat.v1 as tf\n\nfrom object_detection.core import standard_fields\nfrom object_detection.metrics import coco_tools\nfrom object_detection.utils import json_utils\nfrom object_detection.utils import np_mask_ops\nfrom object_detection.utils import object_detection_evaluation\n\n\nclass CocoDetectionEvaluator(object_detection_evaluation.DetectionEvaluator):\n \"\"\"Class to evaluate COCO detection metrics.\"\"\"\n\n def __init__(self,\n categories,\n include_metrics_per_category=False,\n all_metrics_per_category=False):\n \"\"\"Constructor.\n\n Args:\n categories: A list of dicts, each of which has the following keys -\n 'id': (required) an integer id uniquely identifying this category.\n 'name': (required) string representing category name e.g., 'cat', 'dog'.\n include_metrics_per_category: If True, include metrics for each category.\n all_metrics_per_category: Whether to include all the summary metrics for\n each category in per_category_ap. Be careful with setting it to true if\n you have more than handful of categories, because it will pollute\n your mldash.\n \"\"\"\n super(CocoDetectionEvaluator, self).__init__(categories)\n # _image_ids is a dictionary that maps unique image ids to Booleans which\n # indicate whether a corresponding detection has been added.\n self._image_ids = {}\n self._groundtruth_list = []\n self._detection_boxes_list = []\n self._category_id_set = set([cat['id'] for cat in self._categories])\n self._annotation_id = 1\n self._metrics = None\n self._include_metrics_per_category = include_metrics_per_category\n self._all_metrics_per_category = all_metrics_per_category\n\n def clear(self):\n \"\"\"Clears the state to prepare for a fresh evaluation.\"\"\"\n self._image_ids.clear()\n self._groundtruth_list = []\n self._detection_boxes_list = []\n\n def add_single_ground_truth_image_info(self,\n image_id,\n groundtruth_dict):\n \"\"\"Adds groundtruth for a single image to be used for evaluation.\n\n If the image has already been added, a warning is logged, and groundtruth is\n ignored.\n\n Args:\n image_id: A unique string/integer identifier for the image.\n groundtruth_dict: A dictionary containing -\n InputDataFields.groundtruth_boxes: float32 numpy array of shape\n [num_boxes, 4] containing `num_boxes` groundtruth boxes of the format\n [ymin, xmin, ymax, xmax] in absolute image coordinates.\n InputDataFields.groundtruth_classes: integer numpy array of shape\n [num_boxes] containing 1-indexed groundtruth classes for the boxes.\n InputDataFields.groundtruth_is_crowd (optional): integer numpy array of\n shape [num_boxes] containing iscrowd flag for groundtruth boxes.\n InputDataFields.groundtruth_area (optional): float numpy array of\n shape [num_boxes] containing the area (in the original absolute\n coordinates) of the annotated object.\n InputDataFields.groundtruth_keypoints (optional): float numpy array of\n keypoints with shape [num_boxes, num_keypoints, 2].\n InputDataFields.groundtruth_keypoint_visibilities (optional): integer\n numpy array of keypoint visibilities with shape [num_gt_boxes,\n num_keypoints]. Integer is treated as an enum with 0=not labeled,\n 1=labeled but not visible and 2=labeled and visible.\n \"\"\"\n if image_id in self._image_ids:\n tf.logging.warning('Ignoring ground truth with image id %s since it was '\n 'previously added', image_id)\n return\n\n # Drop optional fields if empty tensor.\n groundtruth_is_crowd = groundtruth_dict.get(\n standard_fields.InputDataFields.groundtruth_is_crowd)\n groundtruth_area = groundtruth_dict.get(\n standard_fields.InputDataFields.groundtruth_area)\n groundtruth_keypoints = groundtruth_dict.get(\n standard_fields.InputDataFields.groundtruth_keypoints)\n groundtruth_keypoint_visibilities = groundtruth_dict.get(\n standard_fields.InputDataFields.groundtruth_keypoint_visibilities)\n if groundtruth_is_crowd is not None and not groundtruth_is_crowd.shape[0]:\n groundtruth_is_crowd = None\n if groundtruth_area is not None and not groundtruth_area.shape[0]:\n groundtruth_area = None\n if groundtruth_keypoints is not None and not groundtruth_keypoints.shape[0]:\n groundtruth_keypoints = None\n if groundtruth_keypoint_visibilities is not None and not groundtruth_keypoint_visibilities.shape[\n 0]:\n groundtruth_keypoint_visibilities = None\n\n self._groundtruth_list.extend(\n coco_tools.ExportSingleImageGroundtruthToCoco(\n image_id=image_id,\n next_annotation_id=self._annotation_id,\n category_id_set=self._category_id_set,\n groundtruth_boxes=groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_boxes],\n groundtruth_classes=groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_classes],\n groundtruth_is_crowd=groundtruth_is_crowd,\n groundtruth_area=groundtruth_area,\n groundtruth_keypoints=groundtruth_keypoints,\n groundtruth_keypoint_visibilities=groundtruth_keypoint_visibilities)\n )\n\n self._annotation_id += groundtruth_dict[standard_fields.InputDataFields.\n groundtruth_boxes].shape[0]\n # Boolean to indicate whether a detection has been added for this image.\n self._image_ids[image_id] = False\n\n def add_single_detected_image_info(self,\n image_id,\n detections_dict):\n \"\"\"Adds detections for a single image to be used for evaluation.\n\n If a detection has already been added for this image id, a warning is\n logged, and the detection is skipped.\n\n Args:\n image_id: A unique string/integer identifier for the image.\n detections_dict: A dictionary containing -\n DetectionResultFields.detection_boxes: float32 numpy array of shape\n [num_boxes, 4] containing `num_boxes` detection boxes of the format\n [ymin, xmin, ymax, xmax] in absolute image coordinates.\n DetectionResultFields.detection_scores: float32 numpy array of shape\n [num_boxes] containing detection scores for the boxes.\n DetectionResultFields.detection_classes: integer numpy array of shape\n [num_boxes] containing 1-indexed detection classes for the boxes.\n DetectionResultFields.detection_keypoints (optional): float numpy array\n of keypoints with shape [num_boxes, num_keypoints, 2].\n Raises:\n ValueError: If groundtruth for the image_id is not available.\n \"\"\"\n if image_id not in self._image_ids:\n raise ValueError('Missing groundtruth for image id: {}'.format(image_id))\n\n if self._image_ids[image_id]:\n tf.logging.warning('Ignoring detection with image id %s since it was '\n 'previously added', image_id)\n return\n\n # Drop optional fields if empty tensor.\n detection_keypoints = detections_dict.get(\n standard_fields.DetectionResultFields.detection_keypoints)\n if detection_keypoints is not None and not detection_keypoints.shape[0]:\n detection_keypoints = None\n self._detection_boxes_list.extend(\n coco_tools.ExportSingleImageDetectionBoxesToCoco(\n image_id=image_id,\n category_id_set=self._category_id_set,\n detection_boxes=detections_dict[\n standard_fields.DetectionResultFields.detection_boxes],\n detection_scores=detections_dict[\n standard_fields.DetectionResultFields.detection_scores],\n detection_classes=detections_dict[\n standard_fields.DetectionResultFields.detection_classes],\n detection_keypoints=detection_keypoints))\n self._image_ids[image_id] = True\n\n def dump_detections_to_json_file(self, json_output_path):\n \"\"\"Saves the detections into json_output_path in the format used by MS COCO.\n\n Args:\n json_output_path: String containing the output file's path. It can be also\n None. In that case nothing will be written to the output file.\n \"\"\"\n if json_output_path and json_output_path is not None:\n with tf.gfile.GFile(json_output_path, 'w') as fid:\n tf.logging.info('Dumping detections to output json file.')\n json_utils.Dump(\n obj=self._detection_boxes_list, fid=fid, float_digits=4, indent=2)\n\n def evaluate(self):\n \"\"\"Evaluates the detection boxes and returns a dictionary of coco metrics.\n\n Returns:\n A dictionary holding -\n\n 1. summary_metrics:\n 'DetectionBoxes_Precision/mAP': mean average precision over classes\n averaged over IOU thresholds ranging from .5 to .95 with .05\n increments.\n 'DetectionBoxes_Precision/[email protected]': mean average precision at 50% IOU\n 'DetectionBoxes_Precision/[email protected]': mean average precision at 75% IOU\n 'DetectionBoxes_Precision/mAP (small)': mean average precision for small\n objects (area < 32^2 pixels).\n 'DetectionBoxes_Precision/mAP (medium)': mean average precision for\n medium sized objects (32^2 pixels < area < 96^2 pixels).\n 'DetectionBoxes_Precision/mAP (large)': mean average precision for large\n objects (96^2 pixels < area < 10000^2 pixels).\n 'DetectionBoxes_Recall/AR@1': average recall with 1 detection.\n 'DetectionBoxes_Recall/AR@10': average recall with 10 detections.\n 'DetectionBoxes_Recall/AR@100': average recall with 100 detections.\n 'DetectionBoxes_Recall/AR@100 (small)': average recall for small objects\n with 100.\n 'DetectionBoxes_Recall/AR@100 (medium)': average recall for medium objects\n with 100.\n 'DetectionBoxes_Recall/AR@100 (large)': average recall for large objects\n with 100 detections.\n\n 2. per_category_ap: if include_metrics_per_category is True, category\n specific results with keys of the form:\n 'Precision mAP ByCategory/category' (without the supercategory part if\n no supercategories exist). For backward compatibility\n 'PerformanceByCategory' is included in the output regardless of\n all_metrics_per_category.\n \"\"\"\n tf.logging.info('Performing evaluation on %d images.', len(self._image_ids))\n groundtruth_dict = {\n 'annotations': self._groundtruth_list,\n 'images': [{'id': image_id} for image_id in self._image_ids],\n 'categories': self._categories\n }\n coco_wrapped_groundtruth = coco_tools.COCOWrapper(groundtruth_dict)\n coco_wrapped_detections = coco_wrapped_groundtruth.LoadAnnotations(\n self._detection_boxes_list)\n box_evaluator = coco_tools.COCOEvalWrapper(\n coco_wrapped_groundtruth, coco_wrapped_detections, agnostic_mode=False)\n box_metrics, box_per_category_ap = box_evaluator.ComputeMetrics(\n include_metrics_per_category=self._include_metrics_per_category,\n all_metrics_per_category=self._all_metrics_per_category)\n box_metrics.update(box_per_category_ap)\n box_metrics = {'DetectionBoxes_'+ key: value\n for key, value in iter(box_metrics.items())}\n return box_metrics\n\n def add_eval_dict(self, eval_dict):\n \"\"\"Observes an evaluation result dict for a single example.\n\n When executing eagerly, once all observations have been observed by this\n method you can use `.evaluate()` to get the final metrics.\n\n When using `tf.estimator.Estimator` for evaluation this function is used by\n `get_estimator_eval_metric_ops()` to construct the metric update op.\n\n Args:\n eval_dict: A dictionary that holds tensors for evaluating an object\n detection model, returned from\n eval_util.result_dict_for_single_example().\n\n Returns:\n None when executing eagerly, or an update_op that can be used to update\n the eval metrics in `tf.estimator.EstimatorSpec`.\n \"\"\"\n def update_op(\n image_id_batched,\n groundtruth_boxes_batched,\n groundtruth_classes_batched,\n groundtruth_is_crowd_batched,\n num_gt_boxes_per_image,\n detection_boxes_batched,\n detection_scores_batched,\n detection_classes_batched,\n num_det_boxes_per_image,\n is_annotated_batched):\n \"\"\"Update operation for adding batch of images to Coco evaluator.\"\"\"\n\n for (image_id, gt_box, gt_class, gt_is_crowd, num_gt_box, det_box,\n det_score, det_class, num_det_box, is_annotated) in zip(\n image_id_batched, groundtruth_boxes_batched,\n groundtruth_classes_batched, groundtruth_is_crowd_batched,\n num_gt_boxes_per_image,\n detection_boxes_batched, detection_scores_batched,\n detection_classes_batched, num_det_boxes_per_image,\n is_annotated_batched):\n if is_annotated:\n self.add_single_ground_truth_image_info(\n image_id, {\n 'groundtruth_boxes': gt_box[:num_gt_box],\n 'groundtruth_classes': gt_class[:num_gt_box],\n 'groundtruth_is_crowd': gt_is_crowd[:num_gt_box]\n })\n self.add_single_detected_image_info(\n image_id,\n {'detection_boxes': det_box[:num_det_box],\n 'detection_scores': det_score[:num_det_box],\n 'detection_classes': det_class[:num_det_box]})\n\n # Unpack items from the evaluation dictionary.\n input_data_fields = standard_fields.InputDataFields\n detection_fields = standard_fields.DetectionResultFields\n image_id = eval_dict[input_data_fields.key]\n groundtruth_boxes = eval_dict[input_data_fields.groundtruth_boxes]\n groundtruth_classes = eval_dict[input_data_fields.groundtruth_classes]\n groundtruth_is_crowd = eval_dict.get(\n input_data_fields.groundtruth_is_crowd, None)\n detection_boxes = eval_dict[detection_fields.detection_boxes]\n detection_scores = eval_dict[detection_fields.detection_scores]\n detection_classes = eval_dict[detection_fields.detection_classes]\n num_gt_boxes_per_image = eval_dict.get(\n 'num_groundtruth_boxes_per_image', None)\n num_det_boxes_per_image = eval_dict.get('num_det_boxes_per_image', None)\n is_annotated = eval_dict.get('is_annotated', None)\n\n if groundtruth_is_crowd is None:\n groundtruth_is_crowd = tf.zeros_like(groundtruth_classes, dtype=tf.bool)\n if not image_id.shape.as_list():\n # Apply a batch dimension to all tensors.\n image_id = tf.expand_dims(image_id, 0)\n groundtruth_boxes = tf.expand_dims(groundtruth_boxes, 0)\n groundtruth_classes = tf.expand_dims(groundtruth_classes, 0)\n groundtruth_is_crowd = tf.expand_dims(groundtruth_is_crowd, 0)\n detection_boxes = tf.expand_dims(detection_boxes, 0)\n detection_scores = tf.expand_dims(detection_scores, 0)\n detection_classes = tf.expand_dims(detection_classes, 0)\n\n if num_gt_boxes_per_image is None:\n num_gt_boxes_per_image = tf.shape(groundtruth_boxes)[1:2]\n else:\n num_gt_boxes_per_image = tf.expand_dims(num_gt_boxes_per_image, 0)\n\n if num_det_boxes_per_image is None:\n num_det_boxes_per_image = tf.shape(detection_boxes)[1:2]\n else:\n num_det_boxes_per_image = tf.expand_dims(num_det_boxes_per_image, 0)\n\n if is_annotated is None:\n is_annotated = tf.constant([True])\n else:\n is_annotated = tf.expand_dims(is_annotated, 0)\n else:\n if num_gt_boxes_per_image is None:\n num_gt_boxes_per_image = tf.tile(\n tf.shape(groundtruth_boxes)[1:2],\n multiples=tf.shape(groundtruth_boxes)[0:1])\n if num_det_boxes_per_image is None:\n num_det_boxes_per_image = tf.tile(\n tf.shape(detection_boxes)[1:2],\n multiples=tf.shape(detection_boxes)[0:1])\n if is_annotated is None:\n is_annotated = tf.ones_like(image_id, dtype=tf.bool)\n\n return tf.py_func(update_op, [image_id,\n groundtruth_boxes,\n groundtruth_classes,\n groundtruth_is_crowd,\n num_gt_boxes_per_image,\n detection_boxes,\n detection_scores,\n detection_classes,\n num_det_boxes_per_image,\n is_annotated], [])\n\n def get_estimator_eval_metric_ops(self, eval_dict):\n \"\"\"Returns a dictionary of eval metric ops.\n\n Note that once value_op is called, the detections and groundtruth added via\n update_op are cleared.\n\n This function can take in groundtruth and detections for a batch of images,\n or for a single image. For the latter case, the batch dimension for input\n tensors need not be present.\n\n Args:\n eval_dict: A dictionary that holds tensors for evaluating object detection\n performance. For single-image evaluation, this dictionary may be\n produced from eval_util.result_dict_for_single_example(). If multi-image\n evaluation, `eval_dict` should contain the fields\n 'num_groundtruth_boxes_per_image' and 'num_det_boxes_per_image' to\n properly unpad the tensors from the batch.\n\n Returns:\n a dictionary of metric names to tuple of value_op and update_op that can\n be used as eval metric ops in tf.estimator.EstimatorSpec. Note that all\n update ops must be run together and similarly all value ops must be run\n together to guarantee correct behaviour.\n \"\"\"\n update_op = self.add_eval_dict(eval_dict)\n metric_names = ['DetectionBoxes_Precision/mAP',\n 'DetectionBoxes_Precision/[email protected]',\n 'DetectionBoxes_Precision/[email protected]',\n 'DetectionBoxes_Precision/mAP (large)',\n 'DetectionBoxes_Precision/mAP (medium)',\n 'DetectionBoxes_Precision/mAP (small)',\n 'DetectionBoxes_Recall/AR@1',\n 'DetectionBoxes_Recall/AR@10',\n 'DetectionBoxes_Recall/AR@100',\n 'DetectionBoxes_Recall/AR@100 (large)',\n 'DetectionBoxes_Recall/AR@100 (medium)',\n 'DetectionBoxes_Recall/AR@100 (small)']\n if self._include_metrics_per_category:\n for category_dict in self._categories:\n metric_names.append('DetectionBoxes_PerformanceByCategory/mAP/' +\n category_dict['name'])\n\n def first_value_func():\n self._metrics = self.evaluate()\n self.clear()\n return np.float32(self._metrics[metric_names[0]])\n\n def value_func_factory(metric_name):\n def value_func():\n return np.float32(self._metrics[metric_name])\n return value_func\n\n # Ensure that the metrics are only evaluated once.\n first_value_op = tf.py_func(first_value_func, [], tf.float32)\n eval_metric_ops = {metric_names[0]: (first_value_op, update_op)}\n with tf.control_dependencies([first_value_op]):\n for metric_name in metric_names[1:]:\n eval_metric_ops[metric_name] = (tf.py_func(\n value_func_factory(metric_name), [], np.float32), update_op)\n return eval_metric_ops\n\n\ndef convert_masks_to_binary(masks):\n \"\"\"Converts masks to 0 or 1 and uint8 type.\"\"\"\n return (masks > 0).astype(np.uint8)\n\n\nclass CocoKeypointEvaluator(CocoDetectionEvaluator):\n \"\"\"Class to evaluate COCO keypoint metrics.\"\"\"\n\n def __init__(self,\n category_id,\n category_keypoints,\n class_text,\n oks_sigmas=None):\n \"\"\"Constructor.\n\n Args:\n category_id: An integer id uniquely identifying this category.\n category_keypoints: A list specifying keypoint mappings, with items:\n 'id': (required) an integer id identifying the keypoint.\n 'name': (required) a string representing the keypoint name.\n class_text: A string representing the category name for which keypoint\n metrics are to be computed.\n oks_sigmas: A dict of keypoint name to standard deviation values for OKS\n metrics. If not provided, default value of 0.05 will be used.\n \"\"\"\n self._category_id = category_id\n self._category_name = class_text\n self._keypoint_ids = sorted(\n [keypoint['id'] for keypoint in category_keypoints])\n kpt_id_to_name = {kpt['id']: kpt['name'] for kpt in category_keypoints}\n if oks_sigmas:\n self._oks_sigmas = np.array([\n oks_sigmas[kpt_id_to_name[idx]] for idx in self._keypoint_ids\n ])\n else:\n # Default all per-keypoint sigmas to 0.\n self._oks_sigmas = np.full((len(self._keypoint_ids)), 0.05)\n tf.logging.warning('No default keypoint OKS sigmas provided. Will use '\n '0.05')\n tf.logging.info('Using the following keypoint OKS sigmas: {}'.format(\n self._oks_sigmas))\n self._metrics = None\n super(CocoKeypointEvaluator, self).__init__([{\n 'id': self._category_id,\n 'name': class_text\n }])\n\n def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):\n \"\"\"Adds groundtruth for a single image with keypoints.\n\n If the image has already been added, a warning is logged, and groundtruth\n is ignored.\n\n Args:\n image_id: A unique string/integer identifier for the image.\n groundtruth_dict: A dictionary containing -\n InputDataFields.groundtruth_boxes: float32 numpy array of shape\n [num_boxes, 4] containing `num_boxes` groundtruth boxes of the format\n [ymin, xmin, ymax, xmax] in absolute image coordinates.\n InputDataFields.groundtruth_classes: integer numpy array of shape\n [num_boxes] containing 1-indexed groundtruth classes for the boxes.\n InputDataFields.groundtruth_is_crowd (optional): integer numpy array of\n shape [num_boxes] containing iscrowd flag for groundtruth boxes.\n InputDataFields.groundtruth_area (optional): float numpy array of\n shape [num_boxes] containing the area (in the original absolute\n coordinates) of the annotated object.\n InputDataFields.groundtruth_keypoints: float numpy array of\n keypoints with shape [num_boxes, num_keypoints, 2].\n InputDataFields.groundtruth_keypoint_visibilities (optional): integer\n numpy array of keypoint visibilities with shape [num_gt_boxes,\n num_keypoints]. Integer is treated as an enum with 0=not labels,\n 1=labeled but not visible and 2=labeled and visible.\n \"\"\"\n\n # Keep only the groundtruth for our category and its keypoints.\n groundtruth_classes = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_classes]\n groundtruth_boxes = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_boxes]\n groundtruth_keypoints = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_keypoints]\n class_indices = [\n idx for idx, gt_class_id in enumerate(groundtruth_classes)\n if gt_class_id == self._category_id\n ]\n filtered_groundtruth_classes = np.take(\n groundtruth_classes, class_indices, axis=0)\n filtered_groundtruth_boxes = np.take(\n groundtruth_boxes, class_indices, axis=0)\n filtered_groundtruth_keypoints = np.take(\n groundtruth_keypoints, class_indices, axis=0)\n filtered_groundtruth_keypoints = np.take(\n filtered_groundtruth_keypoints, self._keypoint_ids, axis=1)\n\n filtered_groundtruth_dict = {}\n filtered_groundtruth_dict[\n standard_fields.InputDataFields\n .groundtruth_classes] = filtered_groundtruth_classes\n filtered_groundtruth_dict[standard_fields.InputDataFields\n .groundtruth_boxes] = filtered_groundtruth_boxes\n filtered_groundtruth_dict[\n standard_fields.InputDataFields\n .groundtruth_keypoints] = filtered_groundtruth_keypoints\n\n if (standard_fields.InputDataFields.groundtruth_is_crowd in\n groundtruth_dict.keys()):\n groundtruth_is_crowd = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_is_crowd]\n filtered_groundtruth_is_crowd = np.take(groundtruth_is_crowd,\n class_indices, 0)\n filtered_groundtruth_dict[\n standard_fields.InputDataFields\n .groundtruth_is_crowd] = filtered_groundtruth_is_crowd\n if (standard_fields.InputDataFields.groundtruth_area in\n groundtruth_dict.keys()):\n groundtruth_area = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_area]\n filtered_groundtruth_area = np.take(groundtruth_area, class_indices, 0)\n filtered_groundtruth_dict[\n standard_fields.InputDataFields\n .groundtruth_area] = filtered_groundtruth_area\n if (standard_fields.InputDataFields.groundtruth_keypoint_visibilities in\n groundtruth_dict.keys()):\n groundtruth_keypoint_visibilities = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_keypoint_visibilities]\n filtered_groundtruth_keypoint_visibilities = np.take(\n groundtruth_keypoint_visibilities, class_indices, axis=0)\n filtered_groundtruth_keypoint_visibilities = np.take(\n filtered_groundtruth_keypoint_visibilities,\n self._keypoint_ids,\n axis=1)\n filtered_groundtruth_dict[\n standard_fields.InputDataFields.\n groundtruth_keypoint_visibilities] = filtered_groundtruth_keypoint_visibilities\n\n super(CocoKeypointEvaluator,\n self).add_single_ground_truth_image_info(image_id,\n filtered_groundtruth_dict)\n\n def add_single_detected_image_info(self, image_id, detections_dict):\n \"\"\"Adds detections for a single image and the specific category for which keypoints are evaluated.\n\n If a detection has already been added for this image id, a warning is\n logged, and the detection is skipped.\n\n Args:\n image_id: A unique string/integer identifier for the image.\n detections_dict: A dictionary containing -\n DetectionResultFields.detection_boxes: float32 numpy array of shape\n [num_boxes, 4] containing `num_boxes` detection boxes of the format\n [ymin, xmin, ymax, xmax] in absolute image coordinates.\n DetectionResultFields.detection_scores: float32 numpy array of shape\n [num_boxes] containing detection scores for the boxes.\n DetectionResultFields.detection_classes: integer numpy array of shape\n [num_boxes] containing 1-indexed detection classes for the boxes.\n DetectionResultFields.detection_keypoints: float numpy array of\n keypoints with shape [num_boxes, num_keypoints, 2].\n\n Raises:\n ValueError: If groundtruth for the image_id is not available.\n \"\"\"\n\n # Keep only the detections for our category and its keypoints.\n detection_classes = detections_dict[\n standard_fields.DetectionResultFields.detection_classes]\n detection_boxes = detections_dict[\n standard_fields.DetectionResultFields.detection_boxes]\n detection_scores = detections_dict[\n standard_fields.DetectionResultFields.detection_scores]\n detection_keypoints = detections_dict[\n standard_fields.DetectionResultFields.detection_keypoints]\n class_indices = [\n idx for idx, class_id in enumerate(detection_classes)\n if class_id == self._category_id\n ]\n filtered_detection_classes = np.take(\n detection_classes, class_indices, axis=0)\n filtered_detection_boxes = np.take(detection_boxes, class_indices, axis=0)\n filtered_detection_scores = np.take(detection_scores, class_indices, axis=0)\n filtered_detection_keypoints = np.take(\n detection_keypoints, class_indices, axis=0)\n filtered_detection_keypoints = np.take(\n filtered_detection_keypoints, self._keypoint_ids, axis=1)\n\n filtered_detections_dict = {}\n filtered_detections_dict[standard_fields.DetectionResultFields\n .detection_classes] = filtered_detection_classes\n filtered_detections_dict[standard_fields.DetectionResultFields\n .detection_boxes] = filtered_detection_boxes\n filtered_detections_dict[standard_fields.DetectionResultFields\n .detection_scores] = filtered_detection_scores\n filtered_detections_dict[standard_fields.DetectionResultFields.\n detection_keypoints] = filtered_detection_keypoints\n\n super(CocoKeypointEvaluator,\n self).add_single_detected_image_info(image_id,\n filtered_detections_dict)\n\n def evaluate(self):\n \"\"\"Evaluates the keypoints and returns a dictionary of coco metrics.\n\n Returns:\n A dictionary holding -\n\n 1. summary_metrics:\n 'Keypoints_Precision/mAP': mean average precision over classes\n averaged over OKS thresholds ranging from .5 to .95 with .05\n increments.\n 'Keypoints_Precision/[email protected]': mean average precision at 50% OKS\n 'Keypoints_Precision/[email protected]': mean average precision at 75% OKS\n 'Keypoints_Precision/mAP (medium)': mean average precision for medium\n sized objects (32^2 pixels < area < 96^2 pixels).\n 'Keypoints_Precision/mAP (large)': mean average precision for large\n objects (96^2 pixels < area < 10000^2 pixels).\n 'Keypoints_Recall/AR@1': average recall with 1 detection.\n 'Keypoints_Recall/AR@10': average recall with 10 detections.\n 'Keypoints_Recall/AR@100': average recall with 100 detections.\n 'Keypoints_Recall/AR@100 (medium)': average recall for medium objects with\n 100.\n 'Keypoints_Recall/AR@100 (large)': average recall for large objects with\n 100 detections.\n \"\"\"\n tf.logging.info('Performing evaluation on %d images.', len(self._image_ids))\n groundtruth_dict = {\n 'annotations': self._groundtruth_list,\n 'images': [{'id': image_id} for image_id in self._image_ids],\n 'categories': self._categories\n }\n coco_wrapped_groundtruth = coco_tools.COCOWrapper(\n groundtruth_dict, detection_type='bbox')\n coco_wrapped_detections = coco_wrapped_groundtruth.LoadAnnotations(\n self._detection_boxes_list)\n keypoint_evaluator = coco_tools.COCOEvalWrapper(\n coco_wrapped_groundtruth,\n coco_wrapped_detections,\n agnostic_mode=False,\n iou_type='keypoints',\n oks_sigmas=self._oks_sigmas)\n keypoint_metrics, _ = keypoint_evaluator.ComputeMetrics(\n include_metrics_per_category=False, all_metrics_per_category=False)\n keypoint_metrics = {\n 'Keypoints_' + key: value\n for key, value in iter(keypoint_metrics.items())\n }\n return keypoint_metrics\n\n def add_eval_dict(self, eval_dict):\n \"\"\"Observes an evaluation result dict for a single example.\n\n When executing eagerly, once all observations have been observed by this\n method you can use `.evaluate()` to get the final metrics.\n\n When using `tf.estimator.Estimator` for evaluation this function is used by\n `get_estimator_eval_metric_ops()` to construct the metric update op.\n\n Args:\n eval_dict: A dictionary that holds tensors for evaluating an object\n detection model, returned from\n eval_util.result_dict_for_single_example().\n\n Returns:\n None when executing eagerly, or an update_op that can be used to update\n the eval metrics in `tf.estimator.EstimatorSpec`.\n \"\"\"\n def update_op(\n image_id_batched,\n groundtruth_boxes_batched,\n groundtruth_classes_batched,\n groundtruth_is_crowd_batched,\n groundtruth_area_batched,\n groundtruth_keypoints_batched,\n groundtruth_keypoint_visibilities_batched,\n num_gt_boxes_per_image,\n detection_boxes_batched,\n detection_scores_batched,\n detection_classes_batched,\n detection_keypoints_batched,\n num_det_boxes_per_image,\n is_annotated_batched):\n \"\"\"Update operation for adding batch of images to Coco evaluator.\"\"\"\n\n for (image_id, gt_box, gt_class, gt_is_crowd, gt_area, gt_keyp,\n gt_keyp_vis, num_gt_box, det_box, det_score, det_class, det_keyp,\n num_det_box, is_annotated) in zip(\n image_id_batched, groundtruth_boxes_batched,\n groundtruth_classes_batched, groundtruth_is_crowd_batched,\n groundtruth_area_batched, groundtruth_keypoints_batched,\n groundtruth_keypoint_visibilities_batched,\n num_gt_boxes_per_image, detection_boxes_batched,\n detection_scores_batched, detection_classes_batched,\n detection_keypoints_batched, num_det_boxes_per_image,\n is_annotated_batched):\n if is_annotated:\n self.add_single_ground_truth_image_info(\n image_id, {\n 'groundtruth_boxes': gt_box[:num_gt_box],\n 'groundtruth_classes': gt_class[:num_gt_box],\n 'groundtruth_is_crowd': gt_is_crowd[:num_gt_box],\n 'groundtruth_area': gt_area[:num_gt_box],\n 'groundtruth_keypoints': gt_keyp[:num_gt_box],\n 'groundtruth_keypoint_visibilities': gt_keyp_vis[:num_gt_box]\n })\n self.add_single_detected_image_info(\n image_id, {\n 'detection_boxes': det_box[:num_det_box],\n 'detection_scores': det_score[:num_det_box],\n 'detection_classes': det_class[:num_det_box],\n 'detection_keypoints': det_keyp[:num_det_box],\n })\n\n # Unpack items from the evaluation dictionary.\n input_data_fields = standard_fields.InputDataFields\n detection_fields = standard_fields.DetectionResultFields\n image_id = eval_dict[input_data_fields.key]\n groundtruth_boxes = eval_dict[input_data_fields.groundtruth_boxes]\n groundtruth_classes = eval_dict[input_data_fields.groundtruth_classes]\n groundtruth_is_crowd = eval_dict.get(input_data_fields.groundtruth_is_crowd,\n None)\n groundtruth_area = eval_dict.get(input_data_fields.groundtruth_area, None)\n groundtruth_keypoints = eval_dict[input_data_fields.groundtruth_keypoints]\n groundtruth_keypoint_visibilities = eval_dict.get(\n input_data_fields.groundtruth_keypoint_visibilities, None)\n detection_boxes = eval_dict[detection_fields.detection_boxes]\n detection_scores = eval_dict[detection_fields.detection_scores]\n detection_classes = eval_dict[detection_fields.detection_classes]\n detection_keypoints = eval_dict[detection_fields.detection_keypoints]\n num_gt_boxes_per_image = eval_dict.get(\n 'num_groundtruth_boxes_per_image', None)\n num_det_boxes_per_image = eval_dict.get('num_det_boxes_per_image', None)\n is_annotated = eval_dict.get('is_annotated', None)\n\n if groundtruth_is_crowd is None:\n groundtruth_is_crowd = tf.zeros_like(groundtruth_classes, dtype=tf.bool)\n\n if groundtruth_area is None:\n groundtruth_area = tf.zeros_like(groundtruth_classes, dtype=tf.float32)\n\n if not image_id.shape.as_list():\n # Apply a batch dimension to all tensors.\n image_id = tf.expand_dims(image_id, 0)\n groundtruth_boxes = tf.expand_dims(groundtruth_boxes, 0)\n groundtruth_classes = tf.expand_dims(groundtruth_classes, 0)\n groundtruth_is_crowd = tf.expand_dims(groundtruth_is_crowd, 0)\n groundtruth_area = tf.expand_dims(groundtruth_area, 0)\n groundtruth_keypoints = tf.expand_dims(groundtruth_keypoints, 0)\n detection_boxes = tf.expand_dims(detection_boxes, 0)\n detection_scores = tf.expand_dims(detection_scores, 0)\n detection_classes = tf.expand_dims(detection_classes, 0)\n detection_keypoints = tf.expand_dims(detection_keypoints, 0)\n\n if num_gt_boxes_per_image is None:\n num_gt_boxes_per_image = tf.shape(groundtruth_boxes)[1:2]\n else:\n num_gt_boxes_per_image = tf.expand_dims(num_gt_boxes_per_image, 0)\n\n if num_det_boxes_per_image is None:\n num_det_boxes_per_image = tf.shape(detection_boxes)[1:2]\n else:\n num_det_boxes_per_image = tf.expand_dims(num_det_boxes_per_image, 0)\n\n if is_annotated is None:\n is_annotated = tf.constant([True])\n else:\n is_annotated = tf.expand_dims(is_annotated, 0)\n\n if groundtruth_keypoint_visibilities is None:\n groundtruth_keypoint_visibilities = tf.fill([\n tf.shape(groundtruth_boxes)[1],\n tf.shape(groundtruth_keypoints)[2]\n ], tf.constant(2, dtype=tf.int32))\n groundtruth_keypoint_visibilities = tf.expand_dims(\n groundtruth_keypoint_visibilities, 0)\n else:\n if num_gt_boxes_per_image is None:\n num_gt_boxes_per_image = tf.tile(\n tf.shape(groundtruth_boxes)[1:2],\n multiples=tf.shape(groundtruth_boxes)[0:1])\n if num_det_boxes_per_image is None:\n num_det_boxes_per_image = tf.tile(\n tf.shape(detection_boxes)[1:2],\n multiples=tf.shape(detection_boxes)[0:1])\n if is_annotated is None:\n is_annotated = tf.ones_like(image_id, dtype=tf.bool)\n if groundtruth_keypoint_visibilities is None:\n groundtruth_keypoint_visibilities = tf.fill([\n tf.shape(groundtruth_keypoints)[1],\n tf.shape(groundtruth_keypoints)[2]\n ], tf.constant(2, dtype=tf.int32))\n groundtruth_keypoint_visibilities = tf.tile(\n tf.expand_dims(groundtruth_keypoint_visibilities, 0),\n multiples=[tf.shape(groundtruth_keypoints)[0], 1, 1])\n\n return tf.py_func(update_op, [\n image_id, groundtruth_boxes, groundtruth_classes, groundtruth_is_crowd,\n groundtruth_area, groundtruth_keypoints,\n groundtruth_keypoint_visibilities, num_gt_boxes_per_image,\n detection_boxes, detection_scores, detection_classes,\n detection_keypoints, num_det_boxes_per_image, is_annotated\n ], [])\n\n def get_estimator_eval_metric_ops(self, eval_dict):\n \"\"\"Returns a dictionary of eval metric ops.\n\n Note that once value_op is called, the detections and groundtruth added via\n update_op are cleared.\n\n This function can take in groundtruth and detections for a batch of images,\n or for a single image. For the latter case, the batch dimension for input\n tensors need not be present.\n\n Args:\n eval_dict: A dictionary that holds tensors for evaluating object detection\n performance. For single-image evaluation, this dictionary may be\n produced from eval_util.result_dict_for_single_example(). If multi-image\n evaluation, `eval_dict` should contain the fields\n 'num_groundtruth_boxes_per_image' and 'num_det_boxes_per_image' to\n properly unpad the tensors from the batch.\n\n Returns:\n a dictionary of metric names to tuple of value_op and update_op that can\n be used as eval metric ops in tf.estimator.EstimatorSpec. Note that all\n update ops must be run together and similarly all value ops must be run\n together to guarantee correct behaviour.\n \"\"\"\n update_op = self.add_eval_dict(eval_dict)\n category = self._category_name\n metric_names = [\n 'Keypoints_Precision/mAP ByCategory/{}'.format(category),\n 'Keypoints_Precision/[email protected] ByCategory/{}'.format(category),\n 'Keypoints_Precision/[email protected] ByCategory/{}'.format(category),\n 'Keypoints_Precision/mAP (large) ByCategory/{}'.format(category),\n 'Keypoints_Precision/mAP (medium) ByCategory/{}'.format(category),\n 'Keypoints_Recall/AR@1 ByCategory/{}'.format(category),\n 'Keypoints_Recall/AR@10 ByCategory/{}'.format(category),\n 'Keypoints_Recall/AR@100 ByCategory/{}'.format(category),\n 'Keypoints_Recall/AR@100 (large) ByCategory/{}'.format(category),\n 'Keypoints_Recall/AR@100 (medium) ByCategory/{}'.format(category)\n ]\n\n def first_value_func():\n self._metrics = self.evaluate()\n self.clear()\n return np.float32(self._metrics[metric_names[0]])\n\n def value_func_factory(metric_name):\n def value_func():\n return np.float32(self._metrics[metric_name])\n return value_func\n\n # Ensure that the metrics are only evaluated once.\n first_value_op = tf.py_func(first_value_func, [], tf.float32)\n eval_metric_ops = {metric_names[0]: (first_value_op, update_op)}\n with tf.control_dependencies([first_value_op]):\n for metric_name in metric_names[1:]:\n eval_metric_ops[metric_name] = (tf.py_func(\n value_func_factory(metric_name), [], np.float32), update_op)\n return eval_metric_ops\n\n\nclass CocoMaskEvaluator(object_detection_evaluation.DetectionEvaluator):\n \"\"\"Class to evaluate COCO detection metrics.\"\"\"\n\n def __init__(self, categories, include_metrics_per_category=False):\n \"\"\"Constructor.\n\n Args:\n categories: A list of dicts, each of which has the following keys -\n 'id': (required) an integer id uniquely identifying this category.\n 'name': (required) string representing category name e.g., 'cat', 'dog'.\n include_metrics_per_category: If True, include metrics for each category.\n \"\"\"\n super(CocoMaskEvaluator, self).__init__(categories)\n self._image_id_to_mask_shape_map = {}\n self._image_ids_with_detections = set([])\n self._groundtruth_list = []\n self._detection_masks_list = []\n self._category_id_set = set([cat['id'] for cat in self._categories])\n self._annotation_id = 1\n self._include_metrics_per_category = include_metrics_per_category\n\n def clear(self):\n \"\"\"Clears the state to prepare for a fresh evaluation.\"\"\"\n self._image_id_to_mask_shape_map.clear()\n self._image_ids_with_detections.clear()\n self._groundtruth_list = []\n self._detection_masks_list = []\n\n def add_single_ground_truth_image_info(self,\n image_id,\n groundtruth_dict):\n \"\"\"Adds groundtruth for a single image to be used for evaluation.\n\n If the image has already been added, a warning is logged, and groundtruth is\n ignored.\n\n Args:\n image_id: A unique string/integer identifier for the image.\n groundtruth_dict: A dictionary containing -\n InputDataFields.groundtruth_boxes: float32 numpy array of shape\n [num_boxes, 4] containing `num_boxes` groundtruth boxes of the format\n [ymin, xmin, ymax, xmax] in absolute image coordinates.\n InputDataFields.groundtruth_classes: integer numpy array of shape\n [num_boxes] containing 1-indexed groundtruth classes for the boxes.\n InputDataFields.groundtruth_instance_masks: uint8 numpy array of shape\n [num_boxes, image_height, image_width] containing groundtruth masks\n corresponding to the boxes. The elements of the array must be in\n {0, 1}.\n \"\"\"\n if image_id in self._image_id_to_mask_shape_map:\n tf.logging.warning('Ignoring ground truth with image id %s since it was '\n 'previously added', image_id)\n return\n\n groundtruth_instance_masks = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_instance_masks]\n groundtruth_instance_masks = convert_masks_to_binary(\n groundtruth_instance_masks)\n self._groundtruth_list.extend(\n coco_tools.\n ExportSingleImageGroundtruthToCoco(\n image_id=image_id,\n next_annotation_id=self._annotation_id,\n category_id_set=self._category_id_set,\n groundtruth_boxes=groundtruth_dict[standard_fields.InputDataFields.\n groundtruth_boxes],\n groundtruth_classes=groundtruth_dict[standard_fields.\n InputDataFields.\n groundtruth_classes],\n groundtruth_masks=groundtruth_instance_masks))\n self._annotation_id += groundtruth_dict[standard_fields.InputDataFields.\n groundtruth_boxes].shape[0]\n self._image_id_to_mask_shape_map[image_id] = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_instance_masks].shape\n\n def add_single_detected_image_info(self,\n image_id,\n detections_dict):\n \"\"\"Adds detections for a single image to be used for evaluation.\n\n If a detection has already been added for this image id, a warning is\n logged, and the detection is skipped.\n\n Args:\n image_id: A unique string/integer identifier for the image.\n detections_dict: A dictionary containing -\n DetectionResultFields.detection_scores: float32 numpy array of shape\n [num_boxes] containing detection scores for the boxes.\n DetectionResultFields.detection_classes: integer numpy array of shape\n [num_boxes] containing 1-indexed detection classes for the boxes.\n DetectionResultFields.detection_masks: optional uint8 numpy array of\n shape [num_boxes, image_height, image_width] containing instance\n masks corresponding to the boxes. The elements of the array must be\n in {0, 1}.\n\n Raises:\n ValueError: If groundtruth for the image_id is not available or if\n spatial shapes of groundtruth_instance_masks and detection_masks are\n incompatible.\n \"\"\"\n if image_id not in self._image_id_to_mask_shape_map:\n raise ValueError('Missing groundtruth for image id: {}'.format(image_id))\n\n if image_id in self._image_ids_with_detections:\n tf.logging.warning('Ignoring detection with image id %s since it was '\n 'previously added', image_id)\n return\n\n groundtruth_masks_shape = self._image_id_to_mask_shape_map[image_id]\n detection_masks = detections_dict[standard_fields.DetectionResultFields.\n detection_masks]\n if groundtruth_masks_shape[1:] != detection_masks.shape[1:]:\n raise ValueError('Spatial shape of groundtruth masks and detection masks '\n 'are incompatible: {} vs {}'.format(\n groundtruth_masks_shape,\n detection_masks.shape))\n detection_masks = convert_masks_to_binary(detection_masks)\n self._detection_masks_list.extend(\n coco_tools.ExportSingleImageDetectionMasksToCoco(\n image_id=image_id,\n category_id_set=self._category_id_set,\n detection_masks=detection_masks,\n detection_scores=detections_dict[standard_fields.\n DetectionResultFields.\n detection_scores],\n detection_classes=detections_dict[standard_fields.\n DetectionResultFields.\n detection_classes]))\n self._image_ids_with_detections.update([image_id])\n\n def dump_detections_to_json_file(self, json_output_path):\n \"\"\"Saves the detections into json_output_path in the format used by MS COCO.\n\n Args:\n json_output_path: String containing the output file's path. It can be also\n None. In that case nothing will be written to the output file.\n \"\"\"\n if json_output_path and json_output_path is not None:\n tf.logging.info('Dumping detections to output json file.')\n with tf.gfile.GFile(json_output_path, 'w') as fid:\n json_utils.Dump(\n obj=self._detection_masks_list, fid=fid, float_digits=4, indent=2)\n\n def evaluate(self):\n \"\"\"Evaluates the detection masks and returns a dictionary of coco metrics.\n\n Returns:\n A dictionary holding -\n\n 1. summary_metrics:\n 'DetectionMasks_Precision/mAP': mean average precision over classes\n averaged over IOU thresholds ranging from .5 to .95 with .05 increments.\n 'DetectionMasks_Precision/[email protected]': mean average precision at 50% IOU.\n 'DetectionMasks_Precision/[email protected]': mean average precision at 75% IOU.\n 'DetectionMasks_Precision/mAP (small)': mean average precision for small\n objects (area < 32^2 pixels).\n 'DetectionMasks_Precision/mAP (medium)': mean average precision for medium\n sized objects (32^2 pixels < area < 96^2 pixels).\n 'DetectionMasks_Precision/mAP (large)': mean average precision for large\n objects (96^2 pixels < area < 10000^2 pixels).\n 'DetectionMasks_Recall/AR@1': average recall with 1 detection.\n 'DetectionMasks_Recall/AR@10': average recall with 10 detections.\n 'DetectionMasks_Recall/AR@100': average recall with 100 detections.\n 'DetectionMasks_Recall/AR@100 (small)': average recall for small objects\n with 100 detections.\n 'DetectionMasks_Recall/AR@100 (medium)': average recall for medium objects\n with 100 detections.\n 'DetectionMasks_Recall/AR@100 (large)': average recall for large objects\n with 100 detections.\n\n 2. per_category_ap: if include_metrics_per_category is True, category\n specific results with keys of the form:\n 'Precision mAP ByCategory/category' (without the supercategory part if\n no supercategories exist). For backward compatibility\n 'PerformanceByCategory' is included in the output regardless of\n all_metrics_per_category.\n \"\"\"\n groundtruth_dict = {\n 'annotations': self._groundtruth_list,\n 'images': [{'id': image_id, 'height': shape[1], 'width': shape[2]}\n for image_id, shape in self._image_id_to_mask_shape_map.\n items()],\n 'categories': self._categories\n }\n coco_wrapped_groundtruth = coco_tools.COCOWrapper(\n groundtruth_dict, detection_type='segmentation')\n coco_wrapped_detection_masks = coco_wrapped_groundtruth.LoadAnnotations(\n self._detection_masks_list)\n mask_evaluator = coco_tools.COCOEvalWrapper(\n coco_wrapped_groundtruth, coco_wrapped_detection_masks,\n agnostic_mode=False, iou_type='segm')\n mask_metrics, mask_per_category_ap = mask_evaluator.ComputeMetrics(\n include_metrics_per_category=self._include_metrics_per_category)\n mask_metrics.update(mask_per_category_ap)\n mask_metrics = {'DetectionMasks_'+ key: value\n for key, value in mask_metrics.items()}\n return mask_metrics\n\n def add_eval_dict(self, eval_dict):\n \"\"\"Observes an evaluation result dict for a single example.\n\n When executing eagerly, once all observations have been observed by this\n method you can use `.evaluate()` to get the final metrics.\n\n When using `tf.estimator.Estimator` for evaluation this function is used by\n `get_estimator_eval_metric_ops()` to construct the metric update op.\n\n Args:\n eval_dict: A dictionary that holds tensors for evaluating an object\n detection model, returned from\n eval_util.result_dict_for_single_example().\n\n Returns:\n None when executing eagerly, or an update_op that can be used to update\n the eval metrics in `tf.estimator.EstimatorSpec`.\n \"\"\"\n def update_op(image_id_batched, groundtruth_boxes_batched,\n groundtruth_classes_batched,\n groundtruth_instance_masks_batched,\n groundtruth_is_crowd_batched, num_gt_boxes_per_image,\n detection_scores_batched, detection_classes_batched,\n detection_masks_batched, num_det_boxes_per_image):\n \"\"\"Update op for metrics.\"\"\"\n\n for (image_id, groundtruth_boxes, groundtruth_classes,\n groundtruth_instance_masks, groundtruth_is_crowd, num_gt_box,\n detection_scores, detection_classes,\n detection_masks, num_det_box) in zip(\n image_id_batched, groundtruth_boxes_batched,\n groundtruth_classes_batched, groundtruth_instance_masks_batched,\n groundtruth_is_crowd_batched, num_gt_boxes_per_image,\n detection_scores_batched, detection_classes_batched,\n detection_masks_batched, num_det_boxes_per_image):\n self.add_single_ground_truth_image_info(\n image_id, {\n 'groundtruth_boxes':\n groundtruth_boxes[:num_gt_box],\n 'groundtruth_classes':\n groundtruth_classes[:num_gt_box],\n 'groundtruth_instance_masks':\n groundtruth_instance_masks[:num_gt_box],\n 'groundtruth_is_crowd':\n groundtruth_is_crowd[:num_gt_box]\n })\n self.add_single_detected_image_info(\n image_id, {\n 'detection_scores': detection_scores[:num_det_box],\n 'detection_classes': detection_classes[:num_det_box],\n 'detection_masks': detection_masks[:num_det_box]\n })\n\n # Unpack items from the evaluation dictionary.\n input_data_fields = standard_fields.InputDataFields\n detection_fields = standard_fields.DetectionResultFields\n image_id = eval_dict[input_data_fields.key]\n groundtruth_boxes = eval_dict[input_data_fields.groundtruth_boxes]\n groundtruth_classes = eval_dict[input_data_fields.groundtruth_classes]\n groundtruth_instance_masks = eval_dict[\n input_data_fields.groundtruth_instance_masks]\n groundtruth_is_crowd = eval_dict.get(\n input_data_fields.groundtruth_is_crowd, None)\n num_gt_boxes_per_image = eval_dict.get(\n input_data_fields.num_groundtruth_boxes, None)\n detection_scores = eval_dict[detection_fields.detection_scores]\n detection_classes = eval_dict[detection_fields.detection_classes]\n detection_masks = eval_dict[detection_fields.detection_masks]\n num_det_boxes_per_image = eval_dict.get(detection_fields.num_detections,\n None)\n\n if groundtruth_is_crowd is None:\n groundtruth_is_crowd = tf.zeros_like(groundtruth_classes, dtype=tf.bool)\n\n if not image_id.shape.as_list():\n # Apply a batch dimension to all tensors.\n image_id = tf.expand_dims(image_id, 0)\n groundtruth_boxes = tf.expand_dims(groundtruth_boxes, 0)\n groundtruth_classes = tf.expand_dims(groundtruth_classes, 0)\n groundtruth_instance_masks = tf.expand_dims(groundtruth_instance_masks, 0)\n groundtruth_is_crowd = tf.expand_dims(groundtruth_is_crowd, 0)\n detection_scores = tf.expand_dims(detection_scores, 0)\n detection_classes = tf.expand_dims(detection_classes, 0)\n detection_masks = tf.expand_dims(detection_masks, 0)\n\n if num_gt_boxes_per_image is None:\n num_gt_boxes_per_image = tf.shape(groundtruth_boxes)[1:2]\n else:\n num_gt_boxes_per_image = tf.expand_dims(num_gt_boxes_per_image, 0)\n\n if num_det_boxes_per_image is None:\n num_det_boxes_per_image = tf.shape(detection_scores)[1:2]\n else:\n num_det_boxes_per_image = tf.expand_dims(num_det_boxes_per_image, 0)\n else:\n if num_gt_boxes_per_image is None:\n num_gt_boxes_per_image = tf.tile(\n tf.shape(groundtruth_boxes)[1:2],\n multiples=tf.shape(groundtruth_boxes)[0:1])\n if num_det_boxes_per_image is None:\n num_det_boxes_per_image = tf.tile(\n tf.shape(detection_scores)[1:2],\n multiples=tf.shape(detection_scores)[0:1])\n\n return tf.py_func(update_op, [\n image_id, groundtruth_boxes, groundtruth_classes,\n groundtruth_instance_masks, groundtruth_is_crowd,\n num_gt_boxes_per_image, detection_scores, detection_classes,\n detection_masks, num_det_boxes_per_image\n ], [])\n\n def get_estimator_eval_metric_ops(self, eval_dict):\n \"\"\"Returns a dictionary of eval metric ops.\n\n Note that once value_op is called, the detections and groundtruth added via\n update_op are cleared.\n\n Args:\n eval_dict: A dictionary that holds tensors for evaluating object detection\n performance. For single-image evaluation, this dictionary may be\n produced from eval_util.result_dict_for_single_example(). If multi-image\n evaluation, `eval_dict` should contain the fields\n 'num_groundtruth_boxes_per_image' and 'num_det_boxes_per_image' to\n properly unpad the tensors from the batch.\n\n Returns:\n a dictionary of metric names to tuple of value_op and update_op that can\n be used as eval metric ops in tf.estimator.EstimatorSpec. Note that all\n update ops must be run together and similarly all value ops must be run\n together to guarantee correct behaviour.\n \"\"\"\n update_op = self.add_eval_dict(eval_dict)\n metric_names = ['DetectionMasks_Precision/mAP',\n 'DetectionMasks_Precision/[email protected]',\n 'DetectionMasks_Precision/[email protected]',\n 'DetectionMasks_Precision/mAP (large)',\n 'DetectionMasks_Precision/mAP (medium)',\n 'DetectionMasks_Precision/mAP (small)',\n 'DetectionMasks_Recall/AR@1',\n 'DetectionMasks_Recall/AR@10',\n 'DetectionMasks_Recall/AR@100',\n 'DetectionMasks_Recall/AR@100 (large)',\n 'DetectionMasks_Recall/AR@100 (medium)',\n 'DetectionMasks_Recall/AR@100 (small)']\n if self._include_metrics_per_category:\n for category_dict in self._categories:\n metric_names.append('DetectionMasks_PerformanceByCategory/mAP/' +\n category_dict['name'])\n\n def first_value_func():\n self._metrics = self.evaluate()\n self.clear()\n return np.float32(self._metrics[metric_names[0]])\n\n def value_func_factory(metric_name):\n def value_func():\n return np.float32(self._metrics[metric_name])\n return value_func\n\n # Ensure that the metrics are only evaluated once.\n first_value_op = tf.py_func(first_value_func, [], tf.float32)\n eval_metric_ops = {metric_names[0]: (first_value_op, update_op)}\n with tf.control_dependencies([first_value_op]):\n for metric_name in metric_names[1:]:\n eval_metric_ops[metric_name] = (tf.py_func(\n value_func_factory(metric_name), [], np.float32), update_op)\n return eval_metric_ops\n\n\nclass CocoPanopticSegmentationEvaluator(\n object_detection_evaluation.DetectionEvaluator):\n \"\"\"Class to evaluate PQ (panoptic quality) metric on COCO dataset.\n\n More details about this metric: https://arxiv.org/pdf/1801.00868.pdf.\n \"\"\"\n\n def __init__(self,\n categories,\n include_metrics_per_category=False,\n iou_threshold=0.5,\n ioa_threshold=0.5):\n \"\"\"Constructor.\n\n Args:\n categories: A list of dicts, each of which has the following keys -\n 'id': (required) an integer id uniquely identifying this category.\n 'name': (required) string representing category name e.g., 'cat', 'dog'.\n include_metrics_per_category: If True, include metrics for each category.\n iou_threshold: intersection-over-union threshold for mask matching (with\n normal groundtruths).\n ioa_threshold: intersection-over-area threshold for mask matching with\n \"is_crowd\" groundtruths.\n \"\"\"\n super(CocoPanopticSegmentationEvaluator, self).__init__(categories)\n self._groundtruth_masks = {}\n self._groundtruth_class_labels = {}\n self._groundtruth_is_crowd = {}\n self._predicted_masks = {}\n self._predicted_class_labels = {}\n self._include_metrics_per_category = include_metrics_per_category\n self._iou_threshold = iou_threshold\n self._ioa_threshold = ioa_threshold\n\n def clear(self):\n \"\"\"Clears the state to prepare for a fresh evaluation.\"\"\"\n self._groundtruth_masks.clear()\n self._groundtruth_class_labels.clear()\n self._groundtruth_is_crowd.clear()\n self._predicted_masks.clear()\n self._predicted_class_labels.clear()\n\n def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):\n \"\"\"Adds groundtruth for a single image to be used for evaluation.\n\n If the image has already been added, a warning is logged, and groundtruth is\n ignored.\n\n Args:\n image_id: A unique string/integer identifier for the image.\n groundtruth_dict: A dictionary containing -\n InputDataFields.groundtruth_classes: integer numpy array of shape\n [num_masks] containing 1-indexed groundtruth classes for the mask.\n InputDataFields.groundtruth_instance_masks: uint8 numpy array of shape\n [num_masks, image_height, image_width] containing groundtruth masks.\n The elements of the array must be in {0, 1}.\n InputDataFields.groundtruth_is_crowd (optional): integer numpy array of\n shape [num_boxes] containing iscrowd flag for groundtruth boxes.\n \"\"\"\n\n if image_id in self._groundtruth_masks:\n tf.logging.warning(\n 'Ignoring groundtruth with image %s, since it has already been '\n 'added to the ground truth database.', image_id)\n return\n\n self._groundtruth_masks[image_id] = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_instance_masks]\n self._groundtruth_class_labels[image_id] = groundtruth_dict[\n standard_fields.InputDataFields.groundtruth_classes]\n groundtruth_is_crowd = groundtruth_dict.get(\n standard_fields.InputDataFields.groundtruth_is_crowd)\n # Drop groundtruth_is_crowd if empty tensor.\n if groundtruth_is_crowd is not None and not groundtruth_is_crowd.size > 0:\n groundtruth_is_crowd = None\n if groundtruth_is_crowd is not None:\n self._groundtruth_is_crowd[image_id] = groundtruth_is_crowd\n\n def add_single_detected_image_info(self, image_id, detections_dict):\n \"\"\"Adds detections for a single image to be used for evaluation.\n\n If a detection has already been added for this image id, a warning is\n logged, and the detection is skipped.\n\n Args:\n image_id: A unique string/integer identifier for the image.\n detections_dict: A dictionary containing -\n DetectionResultFields.detection_classes: integer numpy array of shape\n [num_masks] containing 1-indexed detection classes for the masks.\n DetectionResultFields.detection_masks: optional uint8 numpy array of\n shape [num_masks, image_height, image_width] containing instance\n masks. The elements of the array must be in {0, 1}.\n\n Raises:\n ValueError: If results and groundtruth shape don't match.\n \"\"\"\n\n if image_id not in self._groundtruth_masks:\n raise ValueError('Missing groundtruth for image id: {}'.format(image_id))\n\n detection_masks = detections_dict[\n standard_fields.DetectionResultFields.detection_masks]\n self._predicted_masks[image_id] = detection_masks\n self._predicted_class_labels[image_id] = detections_dict[\n standard_fields.DetectionResultFields.detection_classes]\n groundtruth_mask_shape = self._groundtruth_masks[image_id].shape\n if groundtruth_mask_shape[1:] != detection_masks.shape[1:]:\n raise ValueError(\"The shape of results doesn't match groundtruth.\")\n\n def evaluate(self):\n \"\"\"Evaluates the detection masks and returns a dictionary of coco metrics.\n\n Returns:\n A dictionary holding -\n\n 1. summary_metric:\n 'PanopticQuality@%.2fIOU': mean panoptic quality averaged over classes at\n the required IOU.\n 'SegmentationQuality@%.2fIOU': mean segmentation quality averaged over\n classes at the required IOU.\n 'RecognitionQuality@%.2fIOU': mean recognition quality averaged over\n classes at the required IOU.\n 'NumValidClasses': number of valid classes. A valid class should have at\n least one normal (is_crowd=0) groundtruth mask or one predicted mask.\n 'NumTotalClasses': number of total classes.\n\n 2. per_category_pq: if include_metrics_per_category is True, category\n specific results with keys of the form:\n 'PanopticQuality@%.2fIOU_ByCategory/category'.\n \"\"\"\n # Evaluate and accumulate the iou/tp/fp/fn.\n sum_tp_iou, sum_num_tp, sum_num_fp, sum_num_fn = self._evaluate_all_masks()\n # Compute PQ metric for each category and average over all classes.\n mask_metrics = self._compute_panoptic_metrics(sum_tp_iou, sum_num_tp,\n sum_num_fp, sum_num_fn)\n return mask_metrics\n\n def get_estimator_eval_metric_ops(self, eval_dict):\n \"\"\"Returns a dictionary of eval metric ops.\n\n Note that once value_op is called, the detections and groundtruth added via\n update_op are cleared.\n\n Args:\n eval_dict: A dictionary that holds tensors for evaluating object detection\n performance. For single-image evaluation, this dictionary may be\n produced from eval_util.result_dict_for_single_example(). If multi-image\n evaluation, `eval_dict` should contain the fields\n 'num_gt_masks_per_image' and 'num_det_masks_per_image' to properly unpad\n the tensors from the batch.\n\n Returns:\n a dictionary of metric names to tuple of value_op and update_op that can\n be used as eval metric ops in tf.estimator.EstimatorSpec. Note that all\n update ops must be run together and similarly all value ops must be run\n together to guarantee correct behaviour.\n \"\"\"\n\n def update_op(image_id_batched, groundtruth_classes_batched,\n groundtruth_instance_masks_batched,\n groundtruth_is_crowd_batched, num_gt_masks_per_image,\n detection_classes_batched, detection_masks_batched,\n num_det_masks_per_image):\n \"\"\"Update op for metrics.\"\"\"\n for (image_id, groundtruth_classes, groundtruth_instance_masks,\n groundtruth_is_crowd, num_gt_mask, detection_classes,\n detection_masks, num_det_mask) in zip(\n image_id_batched, groundtruth_classes_batched,\n groundtruth_instance_masks_batched, groundtruth_is_crowd_batched,\n num_gt_masks_per_image, detection_classes_batched,\n detection_masks_batched, num_det_masks_per_image):\n\n self.add_single_ground_truth_image_info(\n image_id, {\n 'groundtruth_classes':\n groundtruth_classes[:num_gt_mask],\n 'groundtruth_instance_masks':\n groundtruth_instance_masks[:num_gt_mask],\n 'groundtruth_is_crowd':\n groundtruth_is_crowd[:num_gt_mask]\n })\n self.add_single_detected_image_info(\n image_id, {\n 'detection_classes': detection_classes[:num_det_mask],\n 'detection_masks': detection_masks[:num_det_mask]\n })\n\n # Unpack items from the evaluation dictionary.\n (image_id, groundtruth_classes, groundtruth_instance_masks,\n groundtruth_is_crowd, num_gt_masks_per_image, detection_classes,\n detection_masks, num_det_masks_per_image\n ) = self._unpack_evaluation_dictionary_items(eval_dict)\n\n update_op = tf.py_func(update_op, [\n image_id, groundtruth_classes, groundtruth_instance_masks,\n groundtruth_is_crowd, num_gt_masks_per_image, detection_classes,\n detection_masks, num_det_masks_per_image\n ], [])\n\n metric_names = [\n 'PanopticQuality@%.2fIOU' % self._iou_threshold,\n 'SegmentationQuality@%.2fIOU' % self._iou_threshold,\n 'RecognitionQuality@%.2fIOU' % self._iou_threshold\n ]\n if self._include_metrics_per_category:\n for category_dict in self._categories:\n metric_names.append('PanopticQuality@%.2fIOU_ByCategory/%s' %\n (self._iou_threshold, category_dict['name']))\n\n def first_value_func():\n self._metrics = self.evaluate()\n self.clear()\n return np.float32(self._metrics[metric_names[0]])\n\n def value_func_factory(metric_name):\n\n def value_func():\n return np.float32(self._metrics[metric_name])\n\n return value_func\n\n # Ensure that the metrics are only evaluated once.\n first_value_op = tf.py_func(first_value_func, [], tf.float32)\n eval_metric_ops = {metric_names[0]: (first_value_op, update_op)}\n with tf.control_dependencies([first_value_op]):\n for metric_name in metric_names[1:]:\n eval_metric_ops[metric_name] = (tf.py_func(\n value_func_factory(metric_name), [], np.float32), update_op)\n return eval_metric_ops\n\n def _evaluate_all_masks(self):\n \"\"\"Evaluate all masks and compute sum iou/TP/FP/FN.\"\"\"\n\n sum_num_tp = {category['id']: 0 for category in self._categories}\n sum_num_fp = sum_num_tp.copy()\n sum_num_fn = sum_num_tp.copy()\n sum_tp_iou = sum_num_tp.copy()\n\n for image_id in self._groundtruth_class_labels:\n # Separate normal and is_crowd groundtruth\n crowd_gt_indices = self._groundtruth_is_crowd.get(image_id)\n (normal_gt_masks, normal_gt_classes, crowd_gt_masks,\n crowd_gt_classes) = self._separate_normal_and_crowd_labels(\n crowd_gt_indices, self._groundtruth_masks[image_id],\n self._groundtruth_class_labels[image_id])\n\n # Mask matching to normal GT.\n predicted_masks = self._predicted_masks[image_id]\n predicted_class_labels = self._predicted_class_labels[image_id]\n (overlaps, pred_matched,\n gt_matched) = self._match_predictions_to_groundtruths(\n predicted_masks,\n predicted_class_labels,\n normal_gt_masks,\n normal_gt_classes,\n self._iou_threshold,\n is_crowd=False,\n with_replacement=False)\n\n # Accumulate true positives.\n for (class_id, is_matched, overlap) in zip(predicted_class_labels,\n pred_matched, overlaps):\n if is_matched:\n sum_num_tp[class_id] += 1\n sum_tp_iou[class_id] += overlap\n\n # Accumulate false negatives.\n for (class_id, is_matched) in zip(normal_gt_classes, gt_matched):\n if not is_matched:\n sum_num_fn[class_id] += 1\n\n # Match remaining predictions to crowd gt.\n remained_pred_indices = np.logical_not(pred_matched)\n remained_pred_masks = predicted_masks[remained_pred_indices, :, :]\n remained_pred_classes = predicted_class_labels[remained_pred_indices]\n _, pred_matched, _ = self._match_predictions_to_groundtruths(\n remained_pred_masks,\n remained_pred_classes,\n crowd_gt_masks,\n crowd_gt_classes,\n self._ioa_threshold,\n is_crowd=True,\n with_replacement=True)\n\n # Accumulate false positives\n for (class_id, is_matched) in zip(remained_pred_classes, pred_matched):\n if not is_matched:\n sum_num_fp[class_id] += 1\n return sum_tp_iou, sum_num_tp, sum_num_fp, sum_num_fn\n\n def _compute_panoptic_metrics(self, sum_tp_iou, sum_num_tp, sum_num_fp,\n sum_num_fn):\n \"\"\"Compute PQ metric for each category and average over all classes.\n\n Args:\n sum_tp_iou: dict, summed true positive intersection-over-union (IoU) for\n each class, keyed by class_id.\n sum_num_tp: the total number of true positives for each class, keyed by\n class_id.\n sum_num_fp: the total number of false positives for each class, keyed by\n class_id.\n sum_num_fn: the total number of false negatives for each class, keyed by\n class_id.\n\n Returns:\n mask_metrics: a dictionary containing averaged metrics over all classes,\n and per-category metrics if required.\n \"\"\"\n mask_metrics = {}\n sum_pq = 0\n sum_sq = 0\n sum_rq = 0\n num_valid_classes = 0\n for category in self._categories:\n class_id = category['id']\n (panoptic_quality, segmentation_quality,\n recognition_quality) = self._compute_panoptic_metrics_single_class(\n sum_tp_iou[class_id], sum_num_tp[class_id], sum_num_fp[class_id],\n sum_num_fn[class_id])\n if panoptic_quality is not None:\n sum_pq += panoptic_quality\n sum_sq += segmentation_quality\n sum_rq += recognition_quality\n num_valid_classes += 1\n if self._include_metrics_per_category:\n mask_metrics['PanopticQuality@%.2fIOU_ByCategory/%s' %\n (self._iou_threshold,\n category['name'])] = panoptic_quality\n mask_metrics['PanopticQuality@%.2fIOU' %\n self._iou_threshold] = sum_pq / num_valid_classes\n mask_metrics['SegmentationQuality@%.2fIOU' %\n self._iou_threshold] = sum_sq / num_valid_classes\n mask_metrics['RecognitionQuality@%.2fIOU' %\n self._iou_threshold] = sum_rq / num_valid_classes\n mask_metrics['NumValidClasses'] = num_valid_classes\n mask_metrics['NumTotalClasses'] = len(self._categories)\n return mask_metrics\n\n def _compute_panoptic_metrics_single_class(self, sum_tp_iou, num_tp, num_fp,\n num_fn):\n \"\"\"Compute panoptic metrics: panoptic/segmentation/recognition quality.\n\n More computation details in https://arxiv.org/pdf/1801.00868.pdf.\n Args:\n sum_tp_iou: summed true positive intersection-over-union (IoU) for a\n specific class.\n num_tp: the total number of true positives for a specific class.\n num_fp: the total number of false positives for a specific class.\n num_fn: the total number of false negatives for a specific class.\n\n Returns:\n panoptic_quality: sum_tp_iou / (num_tp + 0.5*num_fp + 0.5*num_fn).\n segmentation_quality: sum_tp_iou / num_tp.\n recognition_quality: num_tp / (num_tp + 0.5*num_fp + 0.5*num_fn).\n \"\"\"\n denominator = num_tp + 0.5 * num_fp + 0.5 * num_fn\n # Calculate metric only if there is at least one GT or one prediction.\n if denominator > 0:\n recognition_quality = num_tp / denominator\n if num_tp > 0:\n segmentation_quality = sum_tp_iou / num_tp\n else:\n # If there is no TP for this category.\n segmentation_quality = 0\n panoptic_quality = segmentation_quality * recognition_quality\n return panoptic_quality, segmentation_quality, recognition_quality\n else:\n return None, None, None\n\n def _separate_normal_and_crowd_labels(self, crowd_gt_indices,\n groundtruth_masks, groundtruth_classes):\n \"\"\"Separate normal and crowd groundtruth class_labels and masks.\n\n Args:\n crowd_gt_indices: None or array of shape [num_groundtruths]. If None, all\n groundtruths are treated as normal ones.\n groundtruth_masks: array of shape [num_groundtruths, height, width].\n groundtruth_classes: array of shape [num_groundtruths].\n\n Returns:\n normal_gt_masks: array of shape [num_normal_groundtruths, height, width].\n normal_gt_classes: array of shape [num_normal_groundtruths].\n crowd_gt_masks: array of shape [num_crowd_groundtruths, height, width].\n crowd_gt_classes: array of shape [num_crowd_groundtruths].\n Raises:\n ValueError: if the shape of groundtruth classes doesn't match groundtruth\n masks or if the shape of crowd_gt_indices.\n \"\"\"\n if groundtruth_masks.shape[0] != groundtruth_classes.shape[0]:\n raise ValueError(\n \"The number of masks doesn't match the number of labels.\")\n if crowd_gt_indices is None:\n # All gts are treated as normal\n crowd_gt_indices = np.zeros(groundtruth_masks.shape, dtype=np.bool)\n else:\n if groundtruth_masks.shape[0] != crowd_gt_indices.shape[0]:\n raise ValueError(\n \"The number of masks doesn't match the number of is_crowd labels.\")\n crowd_gt_indices = crowd_gt_indices.astype(np.bool)\n normal_gt_indices = np.logical_not(crowd_gt_indices)\n if normal_gt_indices.size:\n normal_gt_masks = groundtruth_masks[normal_gt_indices, :, :]\n normal_gt_classes = groundtruth_classes[normal_gt_indices]\n crowd_gt_masks = groundtruth_masks[crowd_gt_indices, :, :]\n crowd_gt_classes = groundtruth_classes[crowd_gt_indices]\n else:\n # No groundtruths available, groundtruth_masks.shape = (0, h, w)\n normal_gt_masks = groundtruth_masks\n normal_gt_classes = groundtruth_classes\n crowd_gt_masks = groundtruth_masks\n crowd_gt_classes = groundtruth_classes\n return normal_gt_masks, normal_gt_classes, crowd_gt_masks, crowd_gt_classes\n\n def _match_predictions_to_groundtruths(self,\n predicted_masks,\n predicted_classes,\n groundtruth_masks,\n groundtruth_classes,\n matching_threshold,\n is_crowd=False,\n with_replacement=False):\n \"\"\"Match the predicted masks to groundtruths.\n\n Args:\n predicted_masks: array of shape [num_predictions, height, width].\n predicted_classes: array of shape [num_predictions].\n groundtruth_masks: array of shape [num_groundtruths, height, width].\n groundtruth_classes: array of shape [num_groundtruths].\n matching_threshold: if the overlap between a prediction and a groundtruth\n is larger than this threshold, the prediction is true positive.\n is_crowd: whether the groundtruths are crowd annotation or not. If True,\n use intersection over area (IoA) as the overlapping metric; otherwise\n use intersection over union (IoU).\n with_replacement: whether a groundtruth can be matched to multiple\n predictions. By default, for normal groundtruths, only 1-1 matching is\n allowed for normal groundtruths; for crowd groundtruths, 1-to-many must\n be allowed.\n\n Returns:\n best_overlaps: array of shape [num_predictions]. Values representing the\n IoU\n or IoA with best matched groundtruth.\n pred_matched: array of shape [num_predictions]. Boolean value representing\n whether the ith prediction is matched to a groundtruth.\n gt_matched: array of shape [num_groundtruth]. Boolean value representing\n whether the ith groundtruth is matched to a prediction.\n Raises:\n ValueError: if the shape of groundtruth/predicted masks doesn't match\n groundtruth/predicted classes.\n \"\"\"\n if groundtruth_masks.shape[0] != groundtruth_classes.shape[0]:\n raise ValueError(\n \"The number of GT masks doesn't match the number of labels.\")\n if predicted_masks.shape[0] != predicted_classes.shape[0]:\n raise ValueError(\n \"The number of predicted masks doesn't match the number of labels.\")\n gt_matched = np.zeros(groundtruth_classes.shape, dtype=np.bool)\n pred_matched = np.zeros(predicted_classes.shape, dtype=np.bool)\n best_overlaps = np.zeros(predicted_classes.shape)\n for pid in range(predicted_classes.shape[0]):\n best_overlap = 0\n matched_gt_id = -1\n for gid in range(groundtruth_classes.shape[0]):\n if predicted_classes[pid] == groundtruth_classes[gid]:\n if (not with_replacement) and gt_matched[gid]:\n continue\n if not is_crowd:\n overlap = np_mask_ops.iou(predicted_masks[pid:pid + 1],\n groundtruth_masks[gid:gid + 1])[0, 0]\n else:\n overlap = np_mask_ops.ioa(groundtruth_masks[gid:gid + 1],\n predicted_masks[pid:pid + 1])[0, 0]\n if overlap >= matching_threshold and overlap > best_overlap:\n matched_gt_id = gid\n best_overlap = overlap\n if matched_gt_id >= 0:\n gt_matched[matched_gt_id] = True\n pred_matched[pid] = True\n best_overlaps[pid] = best_overlap\n return best_overlaps, pred_matched, gt_matched\n\n def _unpack_evaluation_dictionary_items(self, eval_dict):\n \"\"\"Unpack items from the evaluation dictionary.\"\"\"\n input_data_fields = standard_fields.InputDataFields\n detection_fields = standard_fields.DetectionResultFields\n image_id = eval_dict[input_data_fields.key]\n groundtruth_classes = eval_dict[input_data_fields.groundtruth_classes]\n groundtruth_instance_masks = eval_dict[\n input_data_fields.groundtruth_instance_masks]\n groundtruth_is_crowd = eval_dict.get(input_data_fields.groundtruth_is_crowd,\n None)\n num_gt_masks_per_image = eval_dict.get(\n input_data_fields.num_groundtruth_boxes, None)\n detection_classes = eval_dict[detection_fields.detection_classes]\n detection_masks = eval_dict[detection_fields.detection_masks]\n num_det_masks_per_image = eval_dict.get(detection_fields.num_detections,\n None)\n if groundtruth_is_crowd is None:\n groundtruth_is_crowd = tf.zeros_like(groundtruth_classes, dtype=tf.bool)\n\n if not image_id.shape.as_list():\n # Apply a batch dimension to all tensors.\n image_id = tf.expand_dims(image_id, 0)\n groundtruth_classes = tf.expand_dims(groundtruth_classes, 0)\n groundtruth_instance_masks = tf.expand_dims(groundtruth_instance_masks, 0)\n groundtruth_is_crowd = tf.expand_dims(groundtruth_is_crowd, 0)\n detection_classes = tf.expand_dims(detection_classes, 0)\n detection_masks = tf.expand_dims(detection_masks, 0)\n\n if num_gt_masks_per_image is None:\n num_gt_masks_per_image = tf.shape(groundtruth_classes)[1:2]\n else:\n num_gt_masks_per_image = tf.expand_dims(num_gt_masks_per_image, 0)\n\n if num_det_masks_per_image is None:\n num_det_masks_per_image = tf.shape(detection_classes)[1:2]\n else:\n num_det_masks_per_image = tf.expand_dims(num_det_masks_per_image, 0)\n else:\n if num_gt_masks_per_image is None:\n num_gt_masks_per_image = tf.tile(\n tf.shape(groundtruth_classes)[1:2],\n multiples=tf.shape(groundtruth_classes)[0:1])\n if num_det_masks_per_image is None:\n num_det_masks_per_image = tf.tile(\n tf.shape(detection_classes)[1:2],\n multiples=tf.shape(detection_classes)[0:1])\n return (image_id, groundtruth_classes, groundtruth_instance_masks,\n groundtruth_is_crowd, num_gt_masks_per_image, detection_classes,\n detection_masks, num_det_masks_per_image)\n"
] | [
[
"tensorflow.compat.v1.zeros_like",
"tensorflow.compat.v1.ones_like",
"numpy.zeros",
"numpy.take",
"tensorflow.compat.v1.shape",
"numpy.float32",
"tensorflow.compat.v1.gfile.GFile",
"tensorflow.compat.v1.py_func",
"numpy.logical_not",
"tensorflow.compat.v1.logging.warning",
"tensorflow.compat.v1.expand_dims",
"tensorflow.compat.v1.control_dependencies",
"tensorflow.compat.v1.constant",
"numpy.array",
"tensorflow.compat.v1.logging.info"
]
] |
yutiansut/menpo | [
"62af28606bc55985ab764f8ad38d239d1572bf1e"
] | [
"menpo/math/linalg.py"
] | [
"from itertools import islice\nimport numpy as np\nfrom menpo.visualize import print_progress, bytes_str, print_dynamic\n\n\ndef dot_inplace_left(a, b, block_size=1000):\n r\"\"\"\n Inplace dot product for memory efficiency. It computes ``a * b = c``, where\n ``a`` will be replaced inplace with ``c``.\n\n Parameters\n ----------\n a : ``(n_big, k)`` `ndarray`\n First array to dot - assumed to be large. Will be damaged by this\n function call as it is used to store the output inplace.\n b : ``(k, n_small)`` `ndarray`, ``n_small <= k``\n The second array to dot - assumed to be small. ``n_small`` must be\n smaller than ``k`` so the result can be stored within the memory space\n of ``a``.\n block_size : `int`, optional\n The size of the block of ``a`` that will be dotted against ``b`` in\n each iteration. larger block sizes increase the time performance of the\n dot product at the cost of a higher memory overhead for the operation.\n\n Returns\n -------\n c : ``(n_big, n_small)`` `ndarray`\n The output of the operation. Exactly the same as a memory view onto\n ``a`` (``a[:, :n_small]``) as ``a`` is modified inplace to store the\n result.\n \"\"\"\n (n_big, k_a), (k_b, n_small) = a.shape, b.shape\n if k_a != k_b:\n raise ValueError('Cannot dot {} * {}'.format(a.shape, b.shape))\n if n_small > k_a:\n raise ValueError('Cannot dot inplace left - '\n 'b.shape[1] ({}) > a.shape[1] '\n '({})'.format(n_small, k_a))\n for i in range(0, n_big, block_size):\n j = i + block_size\n a[i:j, :n_small] = a[i:j].dot(b)\n return a[:, :n_small]\n\n\ndef dot_inplace_right(a, b, block_size=1000):\n r\"\"\"\n Inplace dot product for memory efficiency. It computes ``a * b = c`` where\n ``b`` will be replaced inplace with ``c``.\n\n Parameters\n ----------\n a : ``(n_small, k)`` `ndarray`, n_small <= k\n The first array to dot - assumed to be small. ``n_small`` must be\n smaller than ``k`` so the result can be stored within the memory space\n of ``b``.\n b : ``(k, n_big)`` `ndarray`\n Second array to dot - assumed to be large. Will be damaged by this\n function call as it is used to store the output inplace.\n block_size : `int`, optional\n The size of the block of ``b`` that ``a`` will be dotted against\n in each iteration. larger block sizes increase the time performance of\n the dot product at the cost of a higher memory overhead for the\n operation.\n\n Returns\n -------\n c : ``(n_small, n_big)`` `ndarray`\n The output of the operation. Exactly the same as a memory view onto\n ``b`` (``b[:n_small]``) as ``b`` is modified inplace to store the\n result.\n \"\"\"\n (n_small, k_a), (k_b, n_big) = a.shape, b.shape\n if k_a != k_b:\n raise ValueError('Cannot dot {} * {}'.format(a.shape, b.shape))\n if n_small > k_b:\n raise ValueError('Cannot dot inplace right - '\n 'a.shape[1] ({}) > b.shape[0] '\n '({})'.format(n_small, k_b))\n for i in range(0, n_big, block_size):\n j = i + block_size\n b[:n_small, i:j] = a.dot(b[:, i:j])\n return b[:n_small]\n\n\ndef as_matrix(vectorizables, length=None, return_template=False, verbose=False):\n r\"\"\"\n Create a matrix from a list/generator of :map:`Vectorizable` objects.\n All the objects in the list **must** be the same size when vectorized.\n\n Consider using a generator if the matrix you are creating is large and\n passing the length of the generator explicitly.\n\n Parameters\n ----------\n vectorizables : `list` or generator if :map:`Vectorizable` objects\n A list or generator of objects that supports the vectorizable interface\n length : `int`, optional\n Length of the vectorizable list. Useful if you are passing a generator\n with a known length.\n verbose : `bool`, optional\n If ``True``, will print the progress of building the matrix.\n return_template : `bool`, optional\n If ``True``, will return the first element of the list/generator, which\n was used as the template. Useful if you need to map back from the\n matrix to a list of vectorizable objects.\n\n Returns\n -------\n M : (length, n_features) `ndarray`\n Every row is an element of the list.\n template : :map:`Vectorizable`, optional\n If ``return_template == True``, will return the template used to\n build the matrix `M`.\n\n Raises\n ------\n ValueError\n ``vectorizables`` terminates in fewer than ``length`` iterations\n \"\"\"\n # get the first element as the template and use it to configure the\n # data matrix\n if length is None:\n # samples is a list\n length = len(vectorizables)\n template = vectorizables[0]\n vectorizables = vectorizables[1:]\n else:\n # samples is an iterator\n template = next(vectorizables)\n n_features = template.n_parameters\n template_vector = template.as_vector()\n\n data = np.zeros((length, n_features), dtype=template_vector.dtype)\n if verbose:\n print('Allocated data matrix of size {} '\n '({} samples)'.format(bytes_str(data.nbytes), length))\n\n # now we can fill in the first element from the template\n data[0] = template_vector\n del template_vector\n\n # ensure we take at most the remaining length - 1 elements\n vectorizables = islice(vectorizables, length - 1)\n\n if verbose:\n vectorizables = print_progress(vectorizables, n_items=length, offset=1,\n prefix='Building data matrix',\n end_with_newline=False)\n\n # 1-based as we have the template vector set already\n i = 0\n for i, sample in enumerate(vectorizables, 1):\n data[i] = sample.as_vector()\n\n # we have exhausted the iterable, but did we get enough items?\n if i != length - 1: # -1\n raise ValueError('Incomplete data matrix due to early iterator '\n 'termination (expected {} items, got {})'.format(\n length, i + 1))\n\n if return_template:\n return data, template\n else:\n return data\n\n\ndef from_matrix(matrix, template):\n r\"\"\"\n Create a generator from a matrix given a template :map:`Vectorizable`\n objects as a template. The ``from_vector`` method will be used to\n reconstruct each object.\n\n If you want a list, warp the returned value in ``list()``.\n\n Parameters\n ----------\n matrix : (n_items, n_features) `ndarray`\n A matrix whereby every *row* represents the data of a vectorizable\n object.\n template : :map:`Vectorizable`\n The template object to use to reconstruct each row of the matrix with.\n\n Returns\n -------\n vectorizables : generator of :map:`Vectorizable`\n Every row of the matrix becomes an element of the list.\n \"\"\"\n return (template.from_vector(row) for row in matrix)\n"
] | [
[
"numpy.zeros"
]
] |
jdebacker/taxdata | [
"c32d401a10a6c8f6e889d87c6cc72fd4338017b2"
] | [
"taxdata/puf/preppuf.py"
] | [
"\"\"\"\nScripts to clean up the raw PUF before matching\n\"\"\"\nimport numpy as np\n\n# RECIDs for aggregate variables by PUF year\nAGG_VARS = {\n 2009: [999999],\n 2010: [999998, 999999],\n 2011: [999996, 999997, 999998, 999999],\n}\n\n\ndef preppuf(puf, year):\n \"\"\"Prepares the PUF for mathcing\n\n Args:\n puf (DataFrame): the raw PUF file\n \"\"\"\n puf.columns = map(str.lower, puf.columns)\n # drop aggregate variables\n puf = puf[~puf[\"recid\"].isin(AGG_VARS[year])].copy()\n puf[\"filer\"] = 1\n puf[\"depne\"] = puf[[\"xocah\", \"xocawh\", \"xoodep\", \"xopar\"]].sum(axis=1)\n\n adjust = (\n puf[\"e03150\"]\n + puf[\"e03210\"]\n + puf[\"e03220\"]\n + puf[\"e03230\"]\n + puf[\"e03260\"]\n + puf[\"e03270\"]\n + puf[\"e03240\"]\n + puf[\"e03290\"]\n + puf[\"e03300\"]\n + puf[\"e03400\"]\n + puf[\"e03500\"]\n )\n puf[\"totincx\"] = puf[\"e00100\"] + adjust\n\n puf[\"sequence\"] = puf.index + 1\n puf[\"soiseq\"] = puf.index + 1\n puf[\"s006\"] /= 100\n puf[\"s006\"] *= 1.03\n\n puf[\"dep_stat\"] = puf[\"dsi\"]\n puf[\"agede\"] = np.where(puf[\"e02400\"] > 0, 1, 0)\n\n return puf\n"
] | [
[
"numpy.where"
]
] |
nbonacchi/ibllib | [
"9066c00a8e9a65a1d209144a2ac54d0b87bec0b3",
"9066c00a8e9a65a1d209144a2ac54d0b87bec0b3"
] | [
"ibllib/tests/extractors/test_ephys_passive.py",
"brainbox/examples/docs_scatter_raster_plot.py"
] | [
"#!/usr/bin/env python\n# -*- coding:utf-8 -*-\n# @Author: Niccolò Bonacchi\n# @Date: Friday, October 30th 2020, 10:42:49 am\nimport unittest\n\nimport ibllib.io.extractors.ephys_passive as passive\nimport numpy as np\n\n\nclass TestsPassiveExtractor(unittest.TestCase):\n def setUp(self):\n pass\n\n def test_load_passive_stim_meta(self):\n meta = passive._load_passive_stim_meta()\n self.assertTrue(isinstance(meta, dict))\n\n def test_interpolate_rf_mapping_stimulus(self):\n idxs_up = np.array([0, 4, 8])\n idxs_dn = np.array([1, 5, 9])\n times = np.array([0, 1, 4, 5, 8, 9])\n Xq = np.arange(15)\n t_bin = 1 # Use 1 so can compare directly Xq and Tq\n Tq = passive._interpolate_rf_mapping_stimulus(\n idxs_up=idxs_up, idxs_dn=idxs_dn, times=times, Xq=Xq, t_bin=t_bin\n )\n self.assertTrue(np.array_equal(Tq, Xq))\n\n def tearDown(self):\n pass\n",
"\"\"\"\r\nPlot raster across session\r\n==========================\r\nExample of how to plot scatter plot of spike depths vs spike times with colour and size of scatter\r\npoints scaled by spike amplitude\r\n\"\"\"\r\n\r\nimport numpy as np\r\nfrom brainbox.ephys_plots import scatter_raster_plot\r\nfrom brainbox.plot_base import plot_scatter\r\nfrom oneibl.one import ONE\r\nimport matplotlib.pyplot as plt\r\nimport matplotlib\r\n\r\none = ONE()\r\n\r\neid = '671c7ea7-6726-4fbe-adeb-f89c2c8e489b'\r\nprobe = 'probe00'\r\n\r\nspikes = one.load_object(eid, obj='spikes', collection=f'alf/{probe}')\r\nmetrics = one.load_dataset(eid, dataset='clusters.metrics', collection=f'alf/{probe}')\r\n\r\n# Find the clusters that have been labelled as good and their corresponding spike indices\r\ngood_clusters = np.where(metrics.label == 1)\r\nspike_idx = np.where(np.isin(spikes['clusters'], good_clusters))[0]\r\n\r\n# Also filter for nans in amplitude and depth\r\nkp_idx = spike_idx[np.where(~np.isnan(spikes['depths'][spike_idx])\r\n & ~np.isnan(spikes['amps'][spike_idx]))[0]]\r\n\r\n# Get ScatterPlot object\r\ndata = scatter_raster_plot(spikes['amps'][kp_idx], spikes['depths'][kp_idx],\r\n spikes['times'][kp_idx])\r\n\r\n# Add v lines 10s after start and 10s before end or recording\r\nx1 = np.min(spikes['times'][kp_idx] + 100)\r\nx2 = np.max(spikes['times'][kp_idx] - 100)\r\ndata.add_lines(pos=x1, orientation='v', style='dashed', width=3, color='k')\r\ndata.add_lines(pos=x2, orientation='v', style='dashed', width=3, color='k')\r\n\r\n\r\nplot_dict = data.convert2dict()\r\n\r\nfig, ax = plot_scatter(plot_dict)\r\n\r\n"
] | [
[
"numpy.array",
"numpy.arange",
"numpy.array_equal"
],
[
"numpy.isin",
"numpy.max",
"numpy.min",
"numpy.isnan",
"numpy.where"
]
] |
lilyminium/openff-evaluator | [
"21da54363009d83110b54d57e4416ae31df3868b"
] | [
"openff/evaluator/datasets/curation/components/filtering.py"
] | [
"import functools\nimport itertools\nimport logging\nfrom collections import defaultdict\nfrom typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union\n\nimport numpy\nimport pandas\nfrom pydantic import Field, root_validator, validator\nfrom scipy.optimize import linear_sum_assignment\nfrom typing_extensions import Literal\n\nfrom openff.evaluator.datasets.curation.components import (\n CurationComponent,\n CurationComponentSchema,\n)\nfrom openff.evaluator.datasets.utilities import (\n data_frame_to_substances,\n reorder_data_frame,\n)\nfrom openff.evaluator.utils.checkmol import (\n ChemicalEnvironment,\n analyse_functional_groups,\n)\n\nif TYPE_CHECKING:\n\n conint = int\n confloat = float\n PositiveInt = int\n PositiveFloat = float\n\nelse:\n\n from pydantic import PositiveFloat, PositiveInt, confloat, conint, constr\n\nlogger = logging.getLogger(__name__)\n\nComponentEnvironments = List[List[ChemicalEnvironment]]\nMoleFractionRange = Tuple[confloat(ge=0.0, le=1.0), confloat(ge=0.0, le=1.0)]\n\n\nclass FilterDuplicatesSchema(CurationComponentSchema):\n\n type: Literal[\"FilterDuplicates\"] = \"FilterDuplicates\"\n\n temperature_precision: conint(ge=0) = Field(\n 2,\n description=\"The number of decimal places to compare temperatures (K) to \"\n \"within.\",\n )\n pressure_precision: conint(ge=0) = Field(\n 3,\n description=\"The number of decimal places to compare pressures (kPa) to \"\n \"within.\",\n )\n mole_fraction_precision: conint(ge=0) = Field(\n 6,\n description=\"The number of decimal places to compare mole fractions to within.\",\n )\n\n\nclass FilterDuplicates(CurationComponent):\n \"\"\"A component to remove duplicate data points (within a specified precision)\n from a data set.\n \"\"\"\n\n @classmethod\n def _apply(\n cls, data_frame: pandas.DataFrame, schema: FilterDuplicatesSchema, n_processes\n ) -> pandas.DataFrame:\n\n if len(data_frame) == 0:\n return data_frame\n\n data_frame = data_frame.copy()\n data_frame = reorder_data_frame(data_frame)\n\n minimum_n_components = data_frame[\"N Components\"].min()\n maximum_n_components = data_frame[\"N Components\"].max()\n\n filtered_data = []\n\n for n_components in range(minimum_n_components, maximum_n_components + 1):\n\n component_data = data_frame[\n data_frame[\"N Components\"] == n_components\n ].copy()\n\n component_data[\"Temperature (K)\"] = component_data[\"Temperature (K)\"].round(\n schema.temperature_precision\n )\n component_data[\"Pressure (kPa)\"] = component_data[\"Pressure (kPa)\"].round(\n schema.pressure_precision\n )\n\n subset_columns = [\"Temperature (K)\", \"Pressure (kPa)\", \"Phase\"]\n\n for index in range(n_components):\n\n component_data[f\"Mole Fraction {index + 1}\"] = component_data[\n f\"Mole Fraction {index + 1}\"\n ].round(schema.mole_fraction_precision)\n\n subset_columns.extend(\n [\n f\"Component {index + 1}\",\n f\"Role {index + 1}\",\n f\"Mole Fraction {index + 1}\",\n f\"Exact Amount {index + 1}\",\n ]\n )\n\n subset_columns = [x for x in subset_columns if x in component_data]\n value_headers = [x for x in component_data if x.find(\" Value \") >= 0]\n\n sorted_filtered_data = []\n\n for value_header in value_headers:\n\n uncertainty_header = value_header.replace(\"Value\", \"Uncertainty\")\n\n property_data = component_data[component_data[value_header].notna()]\n\n if uncertainty_header in component_data:\n property_data = property_data.sort_values(uncertainty_header)\n\n property_data = property_data.drop_duplicates(\n subset=subset_columns, keep=\"last\"\n )\n\n sorted_filtered_data.append(property_data)\n\n sorted_filtered_data = pandas.concat(\n sorted_filtered_data, ignore_index=True, sort=False\n )\n\n filtered_data.append(sorted_filtered_data)\n\n filtered_data = pandas.concat(filtered_data, ignore_index=True, sort=False)\n return filtered_data\n\n\nclass FilterByTemperatureSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByTemperature\"] = \"FilterByTemperature\"\n\n minimum_temperature: Optional[PositiveFloat] = Field(\n ...,\n description=\"Retain data points measured for temperatures above this value (K)\",\n )\n maximum_temperature: Optional[PositiveFloat] = Field(\n ...,\n description=\"Retain data points measured for temperatures below this value (K)\",\n )\n\n @root_validator\n def _min_max(cls, values):\n minimum_temperature = values.get(\"minimum_temperature\")\n maximum_temperature = values.get(\"maximum_temperature\")\n\n if minimum_temperature is not None and maximum_temperature is not None:\n assert maximum_temperature > minimum_temperature\n\n return values\n\n\nclass FilterByTemperature(CurationComponent):\n \"\"\"A component which will filter out data points which were measured outside of a\n specified temperature range\n \"\"\"\n\n @classmethod\n def _apply(\n cls,\n data_frame: pandas.DataFrame,\n schema: FilterByTemperatureSchema,\n n_processes,\n ) -> pandas.DataFrame:\n\n filtered_frame = data_frame\n\n if schema.minimum_temperature is not None:\n filtered_frame = filtered_frame[\n schema.minimum_temperature < filtered_frame[\"Temperature (K)\"]\n ]\n\n if schema.maximum_temperature is not None:\n filtered_frame = filtered_frame[\n filtered_frame[\"Temperature (K)\"] < schema.maximum_temperature\n ]\n\n return filtered_frame\n\n\nclass FilterByPressureSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByPressure\"] = \"FilterByPressure\"\n\n minimum_pressure: Optional[PositiveFloat] = Field(\n ...,\n description=\"Retain data points measured for pressures above this value (kPa)\",\n )\n maximum_pressure: Optional[PositiveFloat] = Field(\n ...,\n description=\"Retain data points measured for pressures below this value (kPa)\",\n )\n\n @root_validator\n def _min_max(cls, values):\n minimum_pressure = values.get(\"minimum_pressure\")\n maximum_pressure = values.get(\"maximum_pressure\")\n\n if minimum_pressure is not None and maximum_pressure is not None:\n assert maximum_pressure > minimum_pressure\n\n return values\n\n\nclass FilterByPressure(CurationComponent):\n \"\"\"A component which will filter out data points which were measured outside of a\n specified pressure range.\n \"\"\"\n\n @classmethod\n def _apply(\n cls, data_frame: pandas.DataFrame, schema: FilterByPressureSchema, n_processes\n ) -> pandas.DataFrame:\n\n filtered_frame = data_frame\n\n if schema.minimum_pressure is not None:\n filtered_frame = filtered_frame[\n schema.minimum_pressure < filtered_frame[\"Pressure (kPa)\"]\n ]\n\n if schema.maximum_pressure is not None:\n filtered_frame = filtered_frame[\n filtered_frame[\"Pressure (kPa)\"] < schema.maximum_pressure\n ]\n\n return filtered_frame\n\n\nclass FilterByMoleFractionSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByMoleFraction\"] = \"FilterByMoleFraction\"\n\n mole_fraction_ranges: Dict[conint(gt=1), List[List[MoleFractionRange]]] = Field(\n ...,\n description=\"The ranges of mole fractions to retain. Each key in the \"\n \"dictionary corresponds to a number of components in the system. Each value \"\n \"is a list of the allowed mole fraction ranges for all but one of the \"\n \"components, i.e for a binary system, the allowed mole fraction for only the \"\n \"first component must be specified.\",\n )\n\n @validator(\"mole_fraction_ranges\")\n def _validate_ranges(cls, value: Dict[int, List[List[MoleFractionRange]]]):\n\n for n_components, ranges in value.items():\n\n assert len(ranges) == n_components - 1\n\n assert all(\n mole_fraction_range[0] < mole_fraction_range[1]\n for component_ranges in ranges\n for mole_fraction_range in component_ranges\n )\n\n return value\n\n\nclass FilterByMoleFraction(CurationComponent):\n \"\"\"A component which will filter out data points which were measured outside of a\n specified mole fraction range.\n \"\"\"\n\n @classmethod\n def _apply(\n cls,\n data_frame: pandas.DataFrame,\n schema: FilterByMoleFractionSchema,\n n_processes,\n ) -> pandas.DataFrame:\n\n filtered_frame = data_frame\n\n full_query = ~filtered_frame[\"N Components\"].isin(schema.mole_fraction_ranges)\n\n for n_components, ranges in schema.mole_fraction_ranges.items():\n\n # Build the query to apply\n n_component_query = filtered_frame[\"N Components\"] == n_components\n\n for index, component_ranges in enumerate(ranges):\n\n component_query = None\n\n for mole_fraction_range in component_ranges:\n\n fraction_query = (\n filtered_frame[f\"Mole Fraction {index + 1}\"]\n > mole_fraction_range[0]\n ) & (\n filtered_frame[f\"Mole Fraction {index + 1}\"]\n < mole_fraction_range[1]\n )\n\n if component_query is None:\n component_query = fraction_query\n else:\n component_query |= fraction_query\n\n n_component_query &= component_query\n\n full_query |= n_component_query\n\n filtered_frame = filtered_frame[full_query]\n return filtered_frame\n\n\nclass FilterByRacemicSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByRacemic\"] = \"FilterByRacemic\"\n\n\nclass FilterByRacemic(CurationComponent):\n \"\"\"A component which will filter out data points which were measured for racemic\n mixtures.\n \"\"\"\n\n @classmethod\n def _apply(\n cls,\n data_frame: pandas.DataFrame,\n schema: FilterByMoleFractionSchema,\n n_processes,\n ) -> pandas.DataFrame:\n\n # Begin building the query. All pure substances should be\n # retained by default.\n query = data_frame[\"N Components\"] < 2\n\n for n_components in range(2, data_frame[\"N Components\"].max() + 1):\n\n component_data = data_frame[data_frame[\"N Components\"] == n_components]\n\n if len(component_data) == 0:\n continue\n\n component_combinations = itertools.combinations(range(n_components), 2)\n\n is_racemic = None\n\n for index_0, index_1 in component_combinations:\n\n components_racemic = component_data[\n f\"Component {index_0 + 1}\"\n ].str.replace(\"@\", \"\") == component_data[\n f\"Component {index_1 + 1}\"\n ].str.replace(\n \"@\", \"\"\n )\n\n is_racemic = (\n components_racemic\n if is_racemic is None\n else (is_racemic | components_racemic)\n )\n\n not_racemic = ~is_racemic\n query |= not_racemic\n\n filtered_frame = data_frame[query]\n return filtered_frame\n\n\nclass FilterByElementsSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByElements\"] = \"FilterByElements\"\n\n allowed_elements: Optional[List[constr(min_length=1)]] = Field(\n None,\n description=\"The only elements which must be present in the measured system \"\n \"for the data point to be retained. This option is mutually exclusive with \"\n \"`forbidden_elements`\",\n )\n forbidden_elements: Optional[List[constr(min_length=1)]] = Field(\n None,\n description=\"The elements which must not be present in the measured system for \"\n \"the data point to be retained. This option is mutually exclusive with \"\n \"`allowed_elements`\",\n )\n\n @root_validator\n def _validate_mutually_exclusive(cls, values):\n\n allowed_elements = values.get(\"allowed_elements\")\n forbidden_elements = values.get(\"forbidden_elements\")\n\n assert allowed_elements is not None or forbidden_elements is not None\n assert allowed_elements is None or forbidden_elements is None\n\n return values\n\n\nclass FilterByElements(CurationComponent):\n \"\"\"A component which will filter out data points which were measured for systems\n which contain specific elements.\"\"\"\n\n @classmethod\n def _apply(\n cls, data_frame: pandas.DataFrame, schema: FilterByElementsSchema, n_processes\n ) -> pandas.DataFrame:\n\n from openff.toolkit.topology import Molecule\n\n def filter_function(data_row):\n\n n_components = data_row[\"N Components\"]\n\n for index in range(n_components):\n\n smiles = data_row[f\"Component {index + 1}\"]\n molecule = Molecule.from_smiles(smiles, allow_undefined_stereo=True)\n\n if schema.allowed_elements is not None and not all(\n [\n x.element.symbol in schema.allowed_elements\n for x in molecule.atoms\n ]\n ):\n return False\n\n if schema.forbidden_elements is not None and any(\n [\n x.element.symbol in schema.forbidden_elements\n for x in molecule.atoms\n ]\n ):\n return False\n\n return True\n\n # noinspection PyTypeChecker\n return data_frame[data_frame.apply(filter_function, axis=1)]\n\n\nclass FilterByPropertyTypesSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByPropertyTypes\"] = \"FilterByPropertyTypes\"\n\n property_types: List[constr(min_length=1)] = Field(\n ...,\n description=\"The types of property to retain.\",\n )\n n_components: Dict[constr(min_length=1), List[PositiveInt]] = Field(\n default_factory=dict,\n description=\"Optionally specify the number of components that a property \"\n \"should have been measured for (e.g. pure, binary) in order for that data \"\n \"point to be retained.\",\n )\n\n strict: bool = Field(\n False,\n description=\"If true, only substances (defined without consideration for their \"\n \"mole fractions or exact amount) which have data available for all of the \"\n \"specified property types will be retained. Note that the data points aren't \"\n \"required to have been measured at the same state.\",\n )\n\n @root_validator\n def _validate_n_components(cls, values):\n\n property_types = values.get(\"property_types\")\n n_components = values.get(\"n_components\")\n\n assert all(x in property_types for x in n_components)\n\n return values\n\n\nclass FilterByPropertyTypes(CurationComponent):\n \"\"\"A component which will apply a filter which only retains properties of specified\n types.\"\"\"\n\n @classmethod\n def _apply(\n cls,\n data_frame: pandas.DataFrame,\n schema: FilterByPropertyTypesSchema,\n n_processes,\n ) -> pandas.DataFrame:\n\n property_headers = [\n header for header in data_frame if header.find(\" Value \") >= 0\n ]\n\n # Removes the columns for properties which are not of interest.\n for header in property_headers:\n\n property_type = header.split(\" \")[0]\n\n if property_type in schema.property_types:\n continue\n\n data_frame = data_frame.drop(header, axis=1)\n\n uncertainty_header = header.replace(\" Value \", \" Uncertainty \")\n\n if uncertainty_header in data_frame:\n data_frame = data_frame.drop(uncertainty_header, axis=1)\n\n # Drop any rows which do not contain any values for the property types of\n # interest.\n property_headers = [\n header\n for header in property_headers\n if header.split(\" \")[0] in schema.property_types\n ]\n\n data_frame = data_frame.dropna(subset=property_headers, how=\"all\")\n\n # Apply a more specific filter which only retain which contain values\n # for the specific property types, and which were measured for the\n # specified number of components.\n for property_type, n_components in schema.n_components.items():\n\n property_header = next(\n iter(x for x in property_headers if x.find(f\"{property_type} \") == 0),\n None,\n )\n\n if property_header is None:\n continue\n\n data_frame = data_frame[\n data_frame[property_header].isna()\n | data_frame[\"N Components\"].isin(n_components)\n ]\n\n # Apply the strict filter if requested\n if schema.strict:\n\n reordered_data_frame = reorder_data_frame(data_frame)\n\n # Build a dictionary of which properties should be present partitioned\n # by the number of components they should have been be measured for.\n property_types = defaultdict(list)\n\n if len(schema.n_components) > 0:\n\n for property_type, n_components in schema.n_components.items():\n\n for n_component in n_components:\n property_types[n_component].append(property_type)\n\n min_n_components = min(property_types)\n max_n_components = max(property_types)\n\n else:\n\n min_n_components = reordered_data_frame[\"N Components\"].min()\n max_n_components = reordered_data_frame[\"N Components\"].max()\n\n for n_components in range(min_n_components, max_n_components + 1):\n property_types[n_components].extend(schema.property_types)\n\n substances_with_data = set()\n components_with_data = {}\n\n # For each N component find substances which have data points for\n # all of the specified property types.\n for n_components in range(min_n_components, max_n_components + 1):\n\n component_data = reordered_data_frame[\n reordered_data_frame[\"N Components\"] == n_components\n ]\n\n if n_components not in property_types or len(component_data) == 0:\n continue\n\n n_component_headers = [\n header\n for header in property_headers\n if header.split(\" \")[0] in property_types[n_components]\n and header in component_data\n ]\n\n if len(n_component_headers) != len(property_types[n_components]):\n continue\n\n n_component_substances = set.intersection(\n *[\n data_frame_to_substances(\n component_data[component_data[header].notna()]\n )\n for header in n_component_headers\n ]\n )\n substances_with_data.update(n_component_substances)\n components_with_data[n_components] = {\n component\n for substance in n_component_substances\n for component in substance\n }\n\n if len(schema.n_components) > 0:\n components_with_all_data = set.intersection(\n *components_with_data.values()\n )\n\n # Filter out any smiles for don't appear in all of the N component\n # substances.\n data_frame = FilterBySmiles.apply(\n data_frame,\n FilterBySmilesSchema(smiles_to_include=[*components_with_all_data]),\n )\n\n # Filter out any substances which (within each N component) don't have\n # all of the specified data types.\n data_frame = FilterBySubstances.apply(\n data_frame,\n FilterBySubstancesSchema(substances_to_include=[*substances_with_data]),\n )\n\n data_frame = data_frame.dropna(axis=1, how=\"all\")\n return data_frame\n\n\nclass FilterByStereochemistrySchema(CurationComponentSchema):\n\n type: Literal[\"FilterByStereochemistry\"] = \"FilterByStereochemistry\"\n\n\nclass FilterByStereochemistry(CurationComponent):\n \"\"\"A component which filters out data points measured for systems whereby the\n stereochemistry of a number of components is undefined.\"\"\"\n\n @classmethod\n def _apply(\n cls,\n data_frame: pandas.DataFrame,\n schema: FilterByStereochemistrySchema,\n n_processes,\n ) -> pandas.DataFrame:\n\n from openff.toolkit.topology import Molecule\n from openff.toolkit.utils import UndefinedStereochemistryError\n\n def filter_function(data_row):\n\n n_components = data_row[\"N Components\"]\n\n for index in range(n_components):\n\n smiles = data_row[f\"Component {index + 1}\"]\n\n try:\n Molecule.from_smiles(smiles)\n except UndefinedStereochemistryError:\n return False\n\n return True\n\n # noinspection PyTypeChecker\n return data_frame[data_frame.apply(filter_function, axis=1)]\n\n\nclass FilterByChargedSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByCharged\"] = \"FilterByCharged\"\n\n\nclass FilterByCharged(CurationComponent):\n \"\"\"A component which filters out data points measured for substances where any of\n the constituent components have a net non-zero charge.\n \"\"\"\n\n @classmethod\n def _apply(\n cls, data_frame: pandas.DataFrame, schema: FilterByChargedSchema, n_processes\n ) -> pandas.DataFrame:\n\n from openff.toolkit.topology import Molecule\n from simtk import unit as simtk_unit\n\n def filter_function(data_row):\n\n n_components = data_row[\"N Components\"]\n\n for index in range(n_components):\n\n smiles = data_row[f\"Component {index + 1}\"]\n molecule = Molecule.from_smiles(smiles, allow_undefined_stereo=True)\n\n # noinspection PyUnresolvedReferences\n atom_charges = [\n atom.formal_charge\n if isinstance(atom.formal_charge, int)\n else atom.formal_charge.value_in_unit(simtk_unit.elementary_charge)\n for atom in molecule.atoms\n ]\n\n if numpy.isclose(sum(atom_charges), 0.0):\n continue\n\n return False\n\n return True\n\n # noinspection PyTypeChecker\n return data_frame[data_frame.apply(filter_function, axis=1)]\n\n\nclass FilterByIonicLiquidSchema(CurationComponentSchema):\n type: Literal[\"FilterByIonicLiquid\"] = \"FilterByIonicLiquid\"\n\n\nclass FilterByIonicLiquid(CurationComponent):\n \"\"\"A component which filters out data points measured for substances which\n contain or are classed as an ionic liquids.\n \"\"\"\n\n @classmethod\n def _apply(\n cls,\n data_frame: pandas.DataFrame,\n schema: FilterByIonicLiquidSchema,\n n_processes,\n ) -> pandas.DataFrame:\n def filter_function(data_row):\n\n n_components = data_row[\"N Components\"]\n\n for index in range(n_components):\n\n smiles = data_row[f\"Component {index + 1}\"]\n\n if \".\" in smiles:\n return False\n\n return True\n\n # noinspection PyTypeChecker\n return data_frame[data_frame.apply(filter_function, axis=1)]\n\n\nclass FilterBySmilesSchema(CurationComponentSchema):\n type: Literal[\"FilterBySmiles\"] = \"FilterBySmiles\"\n\n smiles_to_include: Optional[List[str]] = Field(\n None,\n description=\"The smiles patterns to retain. This option is mutually \"\n \"exclusive with `smiles_to_exclude`\",\n )\n smiles_to_exclude: Optional[List[str]] = Field(\n None,\n description=\"The smiles patterns to exclude. This option is mutually \"\n \"exclusive with `smiles_to_include`\",\n )\n allow_partial_inclusion: bool = Field(\n False,\n description=\"If False, all the components in a substance must appear in \"\n \"the `smiles_to_include` list, otherwise, only some must appear. \"\n \"This option only applies when `smiles_to_include` is set.\",\n )\n\n @root_validator\n def _validate_mutually_exclusive(cls, values):\n\n smiles_to_include = values.get(\"smiles_to_include\")\n smiles_to_exclude = values.get(\"smiles_to_exclude\")\n\n assert smiles_to_include is not None or smiles_to_exclude is not None\n assert smiles_to_include is None or smiles_to_exclude is None\n\n return values\n\n\nclass FilterBySmiles(CurationComponent):\n \"\"\"A component which filters the data set so that it only contains either a\n specific set of smiles, or does not contain any of a set of specifically excluded\n smiles.\n \"\"\"\n\n @classmethod\n def _apply(\n cls, data_frame: pandas.DataFrame, schema: FilterBySmilesSchema, n_processes\n ) -> pandas.DataFrame:\n\n smiles_to_include = schema.smiles_to_include\n smiles_to_exclude = schema.smiles_to_exclude\n\n if smiles_to_include is not None:\n smiles_to_exclude = []\n elif smiles_to_exclude is not None:\n smiles_to_include = []\n\n def filter_function(data_row):\n\n n_components = data_row[\"N Components\"]\n\n component_smiles = [\n data_row[f\"Component {index + 1}\"] for index in range(n_components)\n ]\n\n if any(x in smiles_to_exclude for x in component_smiles):\n return False\n elif len(smiles_to_exclude) > 0:\n return True\n\n if not schema.allow_partial_inclusion and not all(\n x in smiles_to_include for x in component_smiles\n ):\n return False\n\n if schema.allow_partial_inclusion and not any(\n x in smiles_to_include for x in component_smiles\n ):\n return False\n\n return True\n\n # noinspection PyTypeChecker\n return data_frame[data_frame.apply(filter_function, axis=1)]\n\n\nclass FilterBySmirksSchema(CurationComponentSchema):\n\n type: Literal[\"FilterBySmirks\"] = \"FilterBySmirks\"\n\n smirks_to_include: Optional[List[str]] = Field(\n None,\n description=\"The smirks patterns which must be matched by a substance in \"\n \"order to retain a measurement. This option is mutually exclusive with \"\n \"`smirks_to_exclude`\",\n )\n smirks_to_exclude: Optional[List[str]] = Field(\n None,\n description=\"The smirks patterns which must not be matched by a substance in \"\n \"order to retain a measurement. This option is mutually exclusive with \"\n \"`smirks_to_include`\",\n )\n allow_partial_inclusion: bool = Field(\n False,\n description=\"If False, all the components in a substance must match at least \"\n \"one pattern in `smirks_to_include` in order to retain a measurement, \"\n \"otherwise, only a least one component must match. This option only applies \"\n \"when `smirks_to_include` is set.\",\n )\n\n @root_validator\n def _validate_mutually_exclusive(cls, values):\n\n smirks_to_include = values.get(\"smirks_to_include\")\n smirks_to_exclude = values.get(\"smirks_to_exclude\")\n\n assert smirks_to_include is not None or smirks_to_exclude is not None\n assert smirks_to_include is None or smirks_to_exclude is None\n\n return values\n\n\nclass FilterBySmirks(CurationComponent):\n \"\"\"A component which filters a data set so that it only contains measurements made\n for molecules which contain (or don't) a set of chemical environments\n represented by SMIRKS patterns.\n \"\"\"\n\n @staticmethod\n @functools.lru_cache(1000)\n def _find_smirks_matches(smiles_pattern, *smirks_patterns):\n \"\"\"Determines which (if any) of the specified smirks match the specified\n molecule.\n\n Parameters\n ----------\n smiles_pattern: str\n The SMILES representation to try and match against.\n smirks_patterns: str\n The smirks patterns to try and match.\n\n Returns\n -------\n list of str\n The matched smirks patterns.\n \"\"\"\n\n from openff.toolkit.topology import Molecule\n\n if len(smirks_patterns) == 0:\n return []\n\n molecule = Molecule.from_smiles(smiles_pattern, allow_undefined_stereo=True)\n\n matches = [\n smirks\n for smirks in smirks_patterns\n if len(molecule.chemical_environment_matches(smirks)) > 0\n ]\n\n return matches\n\n @classmethod\n def _apply(\n cls, data_frame: pandas.DataFrame, schema: FilterBySmirksSchema, n_processes\n ) -> pandas.DataFrame:\n\n smirks_to_match = (\n schema.smirks_to_include\n if schema.smirks_to_include\n else schema.smirks_to_exclude\n )\n\n def filter_function(data_row):\n\n n_components = data_row[\"N Components\"]\n\n component_smiles = [\n data_row[f\"Component {index + 1}\"] for index in range(n_components)\n ]\n\n smirks_matches = {\n smiles: cls._find_smirks_matches(smiles, *smirks_to_match)\n for smiles in component_smiles\n }\n\n if schema.smirks_to_exclude is not None:\n return not any(len(x) > 0 for x in smirks_matches.values())\n\n if schema.allow_partial_inclusion:\n return any(len(x) > 0 for x in smirks_matches.values())\n\n return all(len(x) > 0 for x in smirks_matches.values())\n\n # noinspection PyTypeChecker\n return data_frame[data_frame.apply(filter_function, axis=1)]\n\n\nclass FilterByNComponentsSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByNComponents\"] = \"FilterByNComponents\"\n\n n_components: List[PositiveInt] = Field(\n ...,\n description=\"The number of components that measurements should have been \"\n \"measured for in order to be retained.\",\n )\n\n\nclass FilterByNComponents(CurationComponent):\n \"\"\"A component which filters out data points measured for systems with specified\n number of components.\n \"\"\"\n\n @classmethod\n def _apply(\n cls,\n data_frame: pandas.DataFrame,\n schema: FilterByNComponentsSchema,\n n_processes,\n ) -> pandas.DataFrame:\n\n return data_frame[data_frame[\"N Components\"].isin(schema.n_components)]\n\n\nclass FilterBySubstancesSchema(CurationComponentSchema):\n\n type: Literal[\"FilterBySubstances\"] = \"FilterBySubstances\"\n\n substances_to_include: Optional[List[Tuple[str, ...]]] = Field(\n None,\n description=\"The substances compositions to retain, where each tuple in the \"\n \"list contains the smiles patterns which make up the substance to include. \"\n \"This option is mutually exclusive with `substances_to_exclude`.\",\n )\n substances_to_exclude: Optional[List[Tuple[str, ...]]] = Field(\n None,\n description=\"The substances compositions to retain, where each tuple in the \"\n \"list contains the smiles patterns which make up the substance to exclude. \"\n \"This option is mutually exclusive with `substances_to_include`.\",\n )\n\n @root_validator\n def _validate_mutually_exclusive(cls, values):\n\n substances_to_include = values.get(\"substances_to_include\")\n substances_to_exclude = values.get(\"substances_to_exclude\")\n\n assert substances_to_include is not None or substances_to_exclude is not None\n assert substances_to_include is None or substances_to_exclude is None\n\n return values\n\n\nclass FilterBySubstances(CurationComponent):\n \"\"\"A component which filters the data set so that it only contains properties\n measured for particular substances.\n\n This method is similar to `filter_by_smiles`, however here we explicitly define\n the full substances compositions, rather than individual smiles which should\n either be included or excluded.\n\n Examples\n --------\n To filter the data set to only include measurements for pure methanol, pure\n benzene or an aqueous ethanol mix:\n\n >>> schema = FilterBySubstancesSchema(\n >>> substances_to_include=[\n >>> ('CO',),\n >>> ('C1=CC=CC=C1',),\n >>> ('CCO', 'O')\n >>> ]\n >>> )\n\n To filter out measurements made for an aqueous mix of benzene:\n\n >>> schema = FilterBySubstancesSchema(\n >>> substances_to_exclude=[('O', 'C1=CC=CC=C1')]\n >>> )\n \"\"\"\n\n @classmethod\n def _apply(\n cls, data_frame: pandas.DataFrame, schema: FilterBySubstancesSchema, n_processes\n ) -> pandas.DataFrame:\n def filter_function(data_row):\n\n n_components = data_row[\"N Components\"]\n\n substances_to_include = schema.substances_to_include\n substances_to_exclude = schema.substances_to_exclude\n\n if substances_to_include is not None:\n substances_to_include = [\n tuple(sorted(x)) for x in substances_to_include\n ]\n if substances_to_exclude is not None:\n substances_to_exclude = [\n tuple(sorted(x)) for x in substances_to_exclude\n ]\n\n substance = tuple(\n sorted(\n [\n data_row[f\"Component {index + 1}\"]\n for index in range(n_components)\n ]\n )\n )\n\n return (\n substances_to_exclude is not None\n and substance not in substances_to_exclude\n ) or (\n substances_to_include is not None and substance in substances_to_include\n )\n\n # noinspection PyTypeChecker\n return data_frame[data_frame.apply(filter_function, axis=1)]\n\n\nclass FilterByEnvironmentsSchema(CurationComponentSchema):\n\n type: Literal[\"FilterByEnvironments\"] = \"FilterByEnvironments\"\n\n per_component_environments: Optional[Dict[int, ComponentEnvironments]] = Field(\n None,\n description=\"The environments which should be present in the components of \"\n \"the substance for which the measurements were made. Each dictionary \"\n \"key corresponds to a number of components in the system, and each \"\n \"value the environments which should be matched by those n components. \"\n \"This option is mutually exclusive with `environments`.\",\n )\n environments: Optional[List[ChemicalEnvironment]] = Field(\n None,\n description=\"The environments which should be present in the substances for \"\n \"which measurements were made. This option is mutually exclusive with \"\n \"`per_component_environments`.\",\n )\n\n at_least_one_environment: bool = Field(\n True,\n description=\"If true, data points will only be retained if all of the \"\n \"components in the measured system contain at least one of the specified \"\n \"environments. This option is mutually exclusive with \"\n \"`strictly_specified_environments`.\",\n )\n strictly_specified_environments: bool = Field(\n False,\n description=\"If true, data points will only be retained if all of the \"\n \"components in the measured system strictly contain only the specified \"\n \"environments and no others. This option is mutually exclusive with \"\n \"`at_least_one_environment`.\",\n )\n\n @validator(\"per_component_environments\")\n def _validate_per_component_environments(cls, value):\n\n if value is None:\n return value\n\n assert all(len(y) == x for x, y in value.items())\n return value\n\n @root_validator\n def _validate_mutually_exclusive(cls, values):\n\n at_least_one_environment = values.get(\"at_least_one_environment\")\n strictly_specified_environments = values.get(\"strictly_specified_environments\")\n\n assert (\n at_least_one_environment is True or strictly_specified_environments is True\n )\n assert (\n at_least_one_environment is False\n or strictly_specified_environments is False\n )\n\n per_component_environments = values.get(\"per_component_environments\")\n environments = values.get(\"environments\")\n\n assert per_component_environments is not None or environments is not None\n assert per_component_environments is None or environments is None\n\n return values\n\n\nclass FilterByEnvironments(CurationComponent):\n \"\"\"A component which filters a data set so that it only contains measurements made\n for substances which contain specific chemical environments.\n \"\"\"\n\n @classmethod\n def _find_environments_per_component(cls, data_row: pandas.Series):\n\n n_components = data_row[\"N Components\"]\n\n component_smiles = [\n data_row[f\"Component {index + 1}\"] for index in range(n_components)\n ]\n component_moieties = [analyse_functional_groups(x) for x in component_smiles]\n\n if any(x is None for x in component_moieties):\n\n logger.info(\n f\"Checkmol was unable to parse the system with components=\"\n f\"{component_smiles} and so this data point was discarded.\"\n )\n\n return None\n\n return component_moieties\n\n @classmethod\n def _is_match(cls, component_environments, environments_to_match, schema):\n\n operator = all if schema.strictly_specified_environments else any\n\n return operator(\n environment in environments_to_match\n for environment in component_environments\n )\n\n @classmethod\n def _filter_by_environments(cls, data_row, schema: FilterByEnvironmentsSchema):\n\n environments_per_component = cls._find_environments_per_component(data_row)\n\n if environments_per_component is None:\n return False\n\n return all(\n cls._is_match(component_environments, schema.environments, schema)\n for component_environments in environments_per_component\n )\n\n @classmethod\n def _filter_by_per_component(cls, data_row, schema: FilterByEnvironmentsSchema):\n\n n_components = data_row[\"N Components\"]\n\n if (\n schema.per_component_environments is not None\n and n_components not in schema.per_component_environments\n ):\n # No filter was specified for this number of components.\n return True\n\n environments_per_component = cls._find_environments_per_component(data_row)\n\n if environments_per_component is None:\n return False\n\n match_matrix = numpy.zeros((n_components, n_components))\n\n for component_index, component_environments in enumerate(\n environments_per_component\n ):\n\n # noinspection PyUnresolvedReferences\n for environments_index, environments_to_match in enumerate(\n schema.per_component_environments[n_components]\n ):\n\n match_matrix[component_index, environments_index] = cls._is_match(\n component_environments, environments_to_match, schema\n )\n\n x_indices, y_indices = linear_sum_assignment(match_matrix, maximize=True)\n\n return numpy.all(match_matrix[x_indices, y_indices] > 0)\n\n @classmethod\n def _apply(\n cls,\n data_frame: pandas.DataFrame,\n schema: FilterByEnvironmentsSchema,\n n_processes,\n ) -> pandas.DataFrame:\n\n if schema.environments is not None:\n filter_function = functools.partial(\n cls._filter_by_environments, schema=schema\n )\n else:\n filter_function = functools.partial(\n cls._filter_by_per_component, schema=schema\n )\n\n # noinspection PyTypeChecker\n return data_frame[data_frame.apply(filter_function, axis=1)]\n\n\nFilterComponentSchema = Union[\n FilterDuplicatesSchema,\n FilterByTemperatureSchema,\n FilterByPressureSchema,\n FilterByMoleFractionSchema,\n FilterByRacemicSchema,\n FilterByElementsSchema,\n FilterByPropertyTypesSchema,\n FilterByStereochemistrySchema,\n FilterByChargedSchema,\n FilterByIonicLiquidSchema,\n FilterBySmilesSchema,\n FilterBySmirksSchema,\n FilterByNComponentsSchema,\n FilterBySubstancesSchema,\n FilterByEnvironmentsSchema,\n]\n"
] | [
[
"scipy.optimize.linear_sum_assignment",
"pandas.concat",
"numpy.zeros",
"numpy.all"
]
] |
s2812135/Data_Challenges_WiSe2122 | [
"a55372f444e7344af4e2e1f04e4244fb8cefeefe"
] | [
"otherCodeTaskSnippets/14.01.2022.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Fri Jan 14 16:03:32 2022\n\n@author: dariu\n\"\"\"\n\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Dec 7 12:43:25 2021\n\n@author: dariu\n\"\"\"\n\nimport numpy as np\nimport pandas as pd\nimport os\nfrom tqdm import tqdm\nimport pacmap\nimport matplotlib.pyplot as plt\nfrom sklearn.manifold import TSNE\nimport umap\nfrom sklearn.cluster import KMeans\nfrom sklearn.cluster import DBSCAN\n#import sklearn.cluster\nfrom sklearn.decomposition import PCA\nfrom sklearn import metrics\nfrom sklearn.cluster import OPTICS, cluster_optics_dbscan\nimport matplotlib.gridspec as gridspec\nfrom sklearn.cluster import SpectralCoclustering\nfrom sklearn.metrics import consensus_score\nfrom sklearn.cluster import SpectralBiclustering\nfrom sklearn import svm\nfrom sklearn.model_selection import train_test_split\nfrom imblearn.under_sampling import NearMiss\nfrom imblearn.pipeline import make_pipeline\nfrom imblearn.metrics import classification_report_imbalanced\n\n\n\n\npath = \"C:\\\\Users\\dariu\\\\Documents\\\\Master Wirtschaftsinformatik\\\\Data Challenges\\Data\\\\\"\n\ndirectorys = [\n ['training_setA/training/', 'p0'],\n ['training_setB/training_setB/', 'p1']\n]\n#%%\ndfs = []\n\nfor z, (directory, file_head) in enumerate(directorys):\n for i, filename in enumerate(tqdm(os.listdir(path + directory))):\n df_temp = pd.read_csv(path + directory + filename, skiprows=0, sep='|')\n# patient_gender = df_temp[\"Gender\"][1]\n# if df_temp[\"Age\"][1] >= 40:\n dfs.append(df_temp)\n\ndf = pd.concat(dfs)\nlabels_true = df[\"SepsisLabel\"].tolist()\n\n#%%\n\n'''\n\n#df = df[[\"HR\", \"O2Sat\", \"Temp\", \"SBP\", \"MAP\", \"DBP\", \"Resp\", \"EtCO2\"]]\n\ndf = df[[\"Age\", \"Gender\", \"Unit1\", \"Unit2\", \"HospAdmTime\", \"ICULOS\"]]\n\n\nlabels_gender = df[\"Gender\"].tolist()\nlabels_unit1 = df[\"Unit1\"].tolist()\nlabels_unit2 = df[\"Unit2\"].tolist()\n#############################################\n\n\n\n'''\n\n#%%\n'''\n\ndf = df[[\n \"BaseExcess\",\n \"HCO3\",\n \"FiO2\",\n \"pH\",\n \"PaCO2\",\n \"SaO2\",\n \"AST\",\n \"BUN\",\n \"Alkalinephos\",\n \"Calcium\",\n \"Chloride\",\n \"Creatinine\",\n \"Bilirubin_direct\",\n \"Glucose\",\n \"Lactate\",\n \"Magnesium\",\n \"Phosphate\",\n \"Potassium\",\n \"Bilirubin_total\",\n \"TroponinI\",\n \"Hct\",\n \"Hgb\",\n \"PTT\",\n \"WBC\",\n \"Fibrinogen\",\n \"Platelets\"\n ]]\n\n#%%\n'''\n\n#############################################\n\n\n\nimputation_dims = [\n 'DBP',\n 'HR',\n 'O2Sat',\n 'Temp',\n 'SBP',\n 'MAP',\n 'Resp',\n]\n\nfor d in imputation_dims:\n mean = round(df[d].sum()/df.shape[0], 2)\n df.loc[df[d].isna(), d] = mean\n \n \n\n#################################################### \n \ndf = df.drop(columns=[\"SepsisLabel\"])\n\ndf_current = df.fillna(df.mean())\n\n#df_current = df.fillna(2)\n\n###########################################################\n\n#df_current = df \n##############################\n\n#85 labels_pred?\n\n#%%\n\n'''\n\ndef calc_scores(X, labels_true, labels_pred):\n rand_score = metrics.rand_score(labels_true, labels_pred)\n adjusted_rand_score = metrics.adjusted_rand_score(labels_true, labels_pred)\n adjusted_mutual_info_score = metrics.cluster.adjusted_mutual_info_score(labels_true, labels_pred)\n silhouette_score = metrics.silhouette_score(X, labels_pred, metric='euclidean', sample_size=None, random_state=None)\n print(\"Rand Score: \" , str(rand_score) + \"\\n\" + \n \"Adjusted Rand Score: \" , str(adjusted_rand_score) + \"\\n\" \n \"Adjusted Mutual Information Score: \" + str(adjusted_mutual_info_score) + \"\\n\" \n \"Silhouette Score: \" , str(silhouette_score) + \"\\n\" \n )\n\n'''\n\n#%%\n\n\n'''\n############################################################\n# initializing the pacmap instance\n# Setting n_neighbors to \"None\" leads to a default choice shown below in \"parameter\" section\n\nembedding = pacmap.PaCMAP(n_dims=5, n_neighbors=None, MN_ratio=0.5, FP_ratio=2.0) \n\n# fit the data (The index of transformed data corresponds to the index of the original data)\n\nX_transformed = embedding.fit_transform(df_current.values, init=\"pca\")\n\n####################################################################\n'''\n\n\n#%%\n\n'''\nmodel = SpectralCoclustering(n_clusters=9, random_state=0)\n#model.fit(df_current.values)\nmodel.fit(X_transformed)\n#score = consensus_score(model.biclusters_, (rows[:, row_idx], columns[:, col_idx]))\n\n#print(\"consensus score: {:.3f}\".format(score))\n\n#fit_data = df_current.values[np.argsort(model.row_labels_)]\nfit_data = X_transformed[np.argsort(model.row_labels_)]\nfit_data = fit_data[:, np.argsort(model.column_labels_)]\n\nfit_data = fit_data[0:len(labels_true), 0:41]\n\n\n\n#plt.matshow(fit_data, cmap=plt.cm.Blues)\nplt.matshow(fit_data, cmap='Spectral')\n\n\n#plt.matshow(fit_data, cmap=plt.cm.RdYlGn)\n#plt.matshow(fit_data, cmap=plt.cm.YlOrRd)\n#plt.matshow(fit_data)\n#plt.matshow(fit_data, cmap='rainbow')\n#plt.matshow(fit_data, cmap='Set1')\n#plt.matshow(fit_data, cmap='tab20')\n#plt.matshow(fit_data, cmap='gist_rainbow')\n\n\nplt.gca().set_aspect('auto')\n#plt.gca().set_aspect('equal', adjustable='box')\n#plt.axis('scaled')\n#plt.title(\"After biclustering; rearranged to show biclusters\")\n\nplt.show()\n\n\n#%%\n\n'''\n\n#\n\n\n#%%\n\n'''\n\nmodel = SpectralBiclustering(n_clusters=(10, 5), method=\"log\", random_state=0)\n#model = SpectralBiclustering(n_clusters=(10, 5), method=\"bistochastic\", random_state=0)\nmodel.fit(df_current.values)\n#model.fit(X_transformed)\n\n\n#fit_data = df_current.values[np.argsort(model.row_labels_)]\nfit_data = df_current.values[np.argsort(model.row_labels_)]\n#fit_data = X_transformed[:, np.argsort(model.column_labels_)]\n\n#plt.matshow(fit_data, cmap=plt.cm.Blues)\nplt.matshow(fit_data, cmap='Spectral')\n\nplt.gca().set_aspect('auto')\n\n#plt.title(\"After biclustering; rearranged to show biclusters\")\n\n\n\n\n\n#plt.matshow(\n# np.outer(np.sort(model.row_labels_) + 1, np.sort(model.column_labels_) + 1),\n# cmap=plt.cm.Blues,\n#)\n\n\nplt.matshow(\n np.outer(np.sort(model.row_labels_) + 1, np.sort(model.column_labels_) + 1),\n cmap='Spectral',\n)\n\n\n\n\n\nplt.gca().set_aspect('auto')\n\n#plt.title(\"Checkerboard structure of rearranged data\")\n\nplt.show()\n\n\n\n'''\n\n#%%\n\n\nX_train, X_test, y_train, y_test = train_test_split(df_current, labels_true, test_size=0.2)\n\n#%%\n\n\n\nX_train_ss = X_train[0:int(0.1*len(X_train))]\ny_train_ss = y_train[0:int(0.1*len(y_train))]\n\n\n# Create a pipeline\npipeline = make_pipeline(\n NearMiss(version=2), svm.SVC())\n\npipeline.fit(X_train_ss, y_train_ss)\n\n# Classify and report the results\nprint(classification_report_imbalanced(y_test, pipeline.predict(X_test)))\n\n"
] | [
[
"sklearn.svm.SVC",
"sklearn.model_selection.train_test_split",
"pandas.concat",
"pandas.read_csv"
]
] |
arroqc/pandacancer_kaggle | [
"a6945dcac041dac744570d61ee630ee6f32e7117"
] | [
"archive/maketiles_old.py"
] | [
"import skimage.io\nimport numpy as np\nimport pandas as pd\nimport sys\nfrom pathlib import Path\nimport pickle\nimport argparse\nimport cv2\n\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"--base_dir\", default='G:/Datasets/panda', required=False)\nparser.add_argument(\"--out_dir\", default='D:/Datasets/panda', required=False)\nargs = parser.parse_args()\n\nBASE_PATH = Path(args.base_dir)\nOUTPUT_BASE = Path(args.out_dir)\n\nSIZE = 128\nNUM = 16\nLEVEL = 1\nSTRIDE = False\nTRAIN_PATH = BASE_PATH/'train_images/'\nMASKS_TRAIN_PATH = BASE_PATH/'train_label_masks/'\nOUTPUT_IMG_PATH = OUTPUT_BASE/f'train_tiles_{SIZE}_{LEVEL}/imgs/'\nOUTPUT_MASK_PATH = OUTPUT_BASE/f'train_tiles_{SIZE}_{LEVEL}/masks/'\nPICKLE_NAME = OUTPUT_BASE/f'stats_{SIZE}_{LEVEL}.pkl'\nCSV_PATH = BASE_PATH/'train.csv'\n\n\npen_marked_images = [\n 'fd6fe1a3985b17d067f2cb4d5bc1e6e1',\n 'ebb6a080d72e09f6481721ef9f88c472',\n 'ebb6d5ca45942536f78beb451ee43cc4',\n 'ea9d52d65500acc9b9d89eb6b82cdcdf',\n 'e726a8eac36c3d91c3c4f9edba8ba713',\n 'e90abe191f61b6fed6d6781c8305fe4b',\n 'fd0bb45eba479a7f7d953f41d574bf9f',\n 'ff10f937c3d52eff6ad4dd733f2bc3ac',\n 'feee2e895355a921f2b75b54debad328',\n 'feac91652a1c5accff08217d19116f1c',\n 'fb01a0a69517bb47d7f4699b6217f69d',\n 'f00ec753b5618cfb30519db0947fe724',\n 'e9a4f528b33479412ee019e155e1a197',\n 'f062f6c1128e0e9d51a76747d9018849',\n 'f39bf22d9a2f313425ee201932bac91a',\n]\n\n\ndef remove_pen_marks(img):\n # Define elliptic kernel\n kernel5x5 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))\n\n # use cv2.inRange to mask pen marks (hardcoded for now)\n lower = np.array([0, 0, 0])\n upper = np.array([200, 255, 255])\n img_mask1 = cv2.inRange(img, lower, upper)\n\n # Use erosion and findContours to remove masked tissue (side effect of above)\n img_mask1 = cv2.erode(img_mask1, kernel5x5, iterations=4)\n img_mask2 = np.zeros(img_mask1.shape, dtype=np.uint8)\n contours, _ = cv2.findContours(img_mask1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)\n for contour in contours:\n x, y = contour[:, 0, 0], contour[:, 0, 1]\n w, h = x.max() - x.min(), y.max() - y.min()\n if w > 100 and h > 100:\n cv2.drawContours(img_mask2, [contour], 0, 1, -1)\n # expand the area of the pen marks\n img_mask2 = cv2.dilate(img_mask2, kernel5x5, iterations=3)\n img_mask2 = (1 - img_mask2)\n\n # Mask out pen marks from original image\n img = cv2.bitwise_and(img, img, mask=img_mask2)\n\n img[img == 0] = 255\n\n return img, img_mask1, img_mask2\n\n\nclass TileMaker:\n\n def __init__(self, size, number):\n self.size = size\n self.number = number\n\n def make_multistride(self, image, mask):\n # Pad only once\n image, mask = self.__pad(image, mask)\n s0, _ = self.__get_tiles(image, mask)\n\n # For strided grids, need to also remove on the right/bottom\n s1, _ = self.__get_tiles(image[self.size // 2:-self.size // 2, :],\n mask[self.size // 2:-self.size // 2, :])\n s2, _ = self.__get_tiles(image[:, self.size // 2:-self.size // 2],\n image[:, self.size // 2:-self.size // 2])\n s3, _ = self.__get_tiles(image[self.size // 2:-self.size // 2, self.size // 2:-self.size // 2],\n image[self.size // 2:-self.size // 2, self.size // 2:-self.size // 2])\n\n all_tiles = np.concatenate([s0, s1, s2, s3], axis=0)\n # Find the images with the most stuff (the most red):\n red_channel = all_tiles[:, :, :, 0]\n tissue = np.where((red_channel < 230) & (red_channel > 200), red_channel, 0)\n sorted_tiles = np.argsort(np.sum(tissue, axis=(1, 2)))[::-1]\n sorted_tiles = sorted_tiles[:self.number * 4]\n\n return all_tiles[sorted_tiles], _\n\n def __pad(self, image, mask):\n h, w, c = image.shape\n horizontal_pad = 0 if (w % self.size) == 0 else self.size - (w % self.size)\n vertical_pad = 0 if (h % self.size) == 0 else self.size - (h % self.size)\n\n image = np.pad(image, pad_width=((vertical_pad // 2, vertical_pad - vertical_pad // 2),\n (horizontal_pad // 2, horizontal_pad - horizontal_pad // 2),\n (0, 0)),\n mode='constant', constant_values=255) # Empty is white in this data\n\n mask = np.pad(mask, pad_width=((vertical_pad // 2, vertical_pad - vertical_pad // 2),\n (horizontal_pad // 2, horizontal_pad - horizontal_pad // 2),\n (0, 0)),\n mode='constant', constant_values=0) # Empty is black in this data\n return image, mask\n\n def __get_tiles(self, image, mask):\n h, w, c = image.shape\n image = image.reshape(h // self.size, self.size, w // self.size, self.size, c)\n image = image.swapaxes(1, 2).reshape(-1, self.size, self.size, c)\n mask = mask.reshape(h // self.size, self.size, w // self.size, self.size, c)\n mask = mask.swapaxes(1, 2).reshape(-1, self.size, self.size, c)\n\n if image.shape[0] < self.number:\n image = np.pad(image, pad_width=((0, self.number - image.shape[0]), (0, 0), (0, 0), (0, 0)),\n mode='constant', constant_values=255)\n mask = np.pad(mask, pad_width=((0, self.number - mask.shape[0]), (0, 0), (0, 0), (0, 0)),\n mode='constant', constant_values=0)\n\n return image, mask\n\n def make(self, image, mask):\n image, mask = self.__pad(image, mask)\n image, mask = self.__get_tiles(image, mask)\n # Find the images with the most dark (epithelium) stuff\n red_channel = image[:, :, :, 0]\n tissue = np.where((red_channel < 230) & (red_channel > 200), red_channel, 0)\n sorted_tiles = np.argsort(np.sum(tissue, axis=(1, 2)))[::-1]\n sorted_tiles = sorted_tiles[:self.number]\n\n return image[sorted_tiles], mask[sorted_tiles]\n\n\nif __name__ == \"__main__\":\n\n OUTPUT_IMG_PATH.mkdir(exist_ok=True, parents=True)\n OUTPUT_MASK_PATH.mkdir(exist_ok=True, parents=True)\n\n tile_maker = TileMaker(SIZE, NUM)\n\n img_list = list(TRAIN_PATH.glob('**/*.tiff'))\n # img_list.pop(5765)\n bad_images = []\n bad_masks = []\n image_stats = []\n files = []\n for i, img_fn in enumerate(img_list):\n\n img_id = img_fn.stem\n mask_fn = MASKS_TRAIN_PATH / (img_id + '_mask.tiff')\n\n try:\n col = skimage.io.MultiImage(str(img_fn))\n image = col[-LEVEL]\n except:\n bad_images.append(img_id)\n continue\n\n if img_id in pen_marked_images:\n image, _, _ = remove_pen_marks(image)\n\n if mask_fn.exists():\n\n try:\n mask = skimage.io.MultiImage(str(mask_fn))[-LEVEL]\n except:\n bad_masks.append(img_id)\n mask = np.zeros_like(image)\n\n else:\n mask = np.zeros_like(image)\n\n if STRIDE:\n image, mask = tile_maker.make_multistride(image, mask)\n else:\n image, mask = tile_maker.make(image, mask)\n sys.stdout.write(f'\\r{i + 1}/{len(img_list)}')\n\n image_stats.append({'image_id': img_id, 'mean': image.mean(axis=(0, 1, 2)) / 255,\n 'mean_square': ((image / 255) ** 2).mean(axis=(0, 1, 2)),\n 'img_mean': (255 - image).mean()})\n\n for i, (tile_image, tile_mask) in enumerate(zip(image, mask)):\n a = (img_id + '_' + str(i) + '.png')\n b = (img_id + '_' + str(i) + '.png')\n files.append({'image_id': img_id, 'num': i, 'filename': a, 'maskname': b,\n 'value': (255-tile_image[:, :, 0]).mean()})\n skimage.io.imsave(OUTPUT_IMG_PATH / a, tile_image, check_contrast=False)\n skimage.io.imsave(OUTPUT_MASK_PATH / b, tile_mask, check_contrast=False)\n\n image_stats = pd.DataFrame(image_stats)\n df = pd.read_csv(CSV_PATH)\n df = pd.merge(df, image_stats, on='image_id', how='left')\n df[['image_id', 'img_mean']].to_csv(OUTPUT_BASE/f'img_mean_{SIZE}_{LEVEL}.csv', index=False)\n\n provider_stats = {}\n for provider in df['data_provider'].unique():\n mean = (df[df['data_provider'] == provider]['mean']).mean(0)\n std = np.sqrt((df[df['data_provider'] == provider]['mean_square']).mean(0) - mean ** 2)\n provider_stats[provider] = (mean, std)\n\n mean = (df['mean']).mean()\n std = np.sqrt((df['mean_square']).mean() - mean ** 2)\n provider_stats['all'] = (mean, std)\n\n with open(PICKLE_NAME, 'wb') as file:\n pickle.dump(provider_stats, file)\n\n pd.DataFrame(files).to_csv(OUTPUT_BASE/f'files_{SIZE}_{LEVEL}.csv', index=False)\n\n print(bad_images)\n print(bad_masks)\n print(provider_stats)\n"
] | [
[
"numpy.zeros_like",
"numpy.sum",
"numpy.zeros",
"pandas.read_csv",
"pandas.DataFrame",
"numpy.pad",
"numpy.where",
"pandas.merge",
"numpy.array",
"numpy.concatenate"
]
] |
grantseiter/Biden-Tax-Proposals | [
"c215ff845264f3fce9281c7fbb343ed10758a4b6"
] | [
"Tax-Calculator-3.0.0/taxcalc/calcfunctions.py"
] | [
"\"\"\"\nTax-Calculator functions that calculate payroll and individual income taxes.\n\nThese functions are imported into the Calculator class.\n\nNote: the parameter_indexing_CPI_offset policy parameter is the only\npolicy parameter that does not appear here; it is used in the policy.py\nfile to possibly adjust the price inflation rate used to index policy\nparameters (as would be done in a reform that introduces chained-CPI\nindexing).\n\"\"\"\n# CODING-STYLE CHECKS:\n# pycodestyle calcfunctions.py\n# pylint --disable=locally-disabled calcfunctions.py\n#\n# pylint: disable=too-many-lines\n# pylint: disable=invalid-name\n# pylint: disable=too-many-arguments\n# pylint: disable=too-many-locals\n\nimport math\nimport copy\nimport numpy as np\nfrom taxcalc.decorators import iterate_jit, JIT\n\n\ndef BenefitPrograms(calc):\n \"\"\"\n Calculate total government cost and consumption value of benefits\n delivered by non-repealed benefit programs.\n \"\"\"\n # zero out benefits delivered by repealed programs\n zero = np.zeros(calc.array_len)\n if calc.policy_param('BEN_housing_repeal'):\n calc.array('housing_ben', zero)\n if calc.policy_param('BEN_ssi_repeal'):\n calc.array('ssi_ben', zero)\n if calc.policy_param('BEN_snap_repeal'):\n calc.array('snap_ben', zero)\n if calc.policy_param('BEN_tanf_repeal'):\n calc.array('tanf_ben', zero)\n if calc.policy_param('BEN_vet_repeal'):\n calc.array('vet_ben', zero)\n if calc.policy_param('BEN_wic_repeal'):\n calc.array('wic_ben', zero)\n if calc.policy_param('BEN_mcare_repeal'):\n calc.array('mcare_ben', zero)\n if calc.policy_param('BEN_mcaid_repeal'):\n calc.array('mcaid_ben', zero)\n if calc.policy_param('BEN_oasdi_repeal'):\n calc.array('e02400', zero)\n if calc.policy_param('BEN_ui_repeal'):\n calc.array('e02300', zero)\n if calc.policy_param('BEN_other_repeal'):\n calc.array('other_ben', zero)\n # calculate government cost of all benefits\n cost = np.array(\n calc.array('housing_ben') +\n calc.array('ssi_ben') +\n calc.array('snap_ben') +\n calc.array('tanf_ben') +\n calc.array('vet_ben') +\n calc.array('wic_ben') +\n calc.array('mcare_ben') +\n calc.array('mcaid_ben') +\n calc.array('e02400') +\n calc.array('e02300') +\n calc.array('ubi') +\n calc.array('other_ben')\n )\n calc.array('benefit_cost_total', cost)\n # calculate consumption value of all benefits\n # (assuming that cash benefits have full value)\n value = np.array(\n calc.array('housing_ben') * calc.consump_param('BEN_housing_value') +\n calc.array('ssi_ben') +\n calc.array('snap_ben') * calc.consump_param('BEN_snap_value') +\n calc.array('tanf_ben') * calc.consump_param('BEN_tanf_value') +\n calc.array('vet_ben') * calc.consump_param('BEN_vet_value') +\n calc.array('wic_ben') * calc.consump_param('BEN_wic_value') +\n calc.array('mcare_ben') * calc.consump_param('BEN_mcare_value') +\n calc.array('mcaid_ben') * calc.consump_param('BEN_mcaid_value') +\n calc.array('e02400') +\n calc.array('e02300') +\n calc.array('ubi') +\n calc.array('other_ben') * calc.consump_param('BEN_other_value')\n )\n calc.array('benefit_value_total', value)\n\n\n@iterate_jit(nopython=True)\ndef EI_PayrollTax(SS_Earnings_c, e00200p, e00200s, pencon_p, pencon_s,\n FICA_ss_trt, FICA_mc_trt, ALD_SelfEmploymentTax_hc,\n SS_Earnings_thd, e00900p, e00900s, e02100p, e02100s, k1bx14p,\n k1bx14s, payrolltax, ptax_was, setax, c03260, ptax_oasdi,\n sey, earned, earned_p, earned_s,\n was_plus_sey_p, was_plus_sey_s):\n \"\"\"\n Compute part of total OASDI+HI payroll taxes and earned income variables.\n \"\"\"\n # compute sey and its individual components\n sey_p = e00900p + e02100p + k1bx14p\n sey_s = e00900s + e02100s + k1bx14s\n sey = sey_p + sey_s # total self-employment income for filing unit\n\n # compute gross wage and salary income ('was' denotes 'wage and salary')\n gross_was_p = e00200p + pencon_p\n gross_was_s = e00200s + pencon_s\n\n # compute taxable gross earnings for OASDI FICA\n txearn_was_p = min(SS_Earnings_c, gross_was_p)\n txearn_was_s = min(SS_Earnings_c, gross_was_s)\n\n # compute OASDI and HI payroll taxes on wage-and-salary income, FICA\n ptax_ss_was_p = FICA_ss_trt * txearn_was_p\n ptax_ss_was_s = FICA_ss_trt * txearn_was_s\n ptax_mc_was_p = FICA_mc_trt * gross_was_p\n ptax_mc_was_s = FICA_mc_trt * gross_was_s\n ptax_was = ptax_ss_was_p + ptax_ss_was_s + ptax_mc_was_p + ptax_mc_was_s\n\n # compute taxable self-employment income for OASDI SECA\n sey_frac = 1.0 - 0.5 * (FICA_ss_trt + FICA_mc_trt)\n txearn_sey_p = min(max(0., sey_p * sey_frac), SS_Earnings_c - txearn_was_p)\n txearn_sey_s = min(max(0., sey_s * sey_frac), SS_Earnings_c - txearn_was_s)\n\n # compute self-employment tax on taxable self-employment income, SECA\n setax_ss_p = FICA_ss_trt * txearn_sey_p\n setax_ss_s = FICA_ss_trt * txearn_sey_s\n setax_mc_p = FICA_mc_trt * max(0., sey_p * sey_frac)\n setax_mc_s = FICA_mc_trt * max(0., sey_s * sey_frac)\n setax_p = setax_ss_p + setax_mc_p\n setax_s = setax_ss_s + setax_mc_s\n setax = setax_p + setax_s\n\n # compute extra OASDI payroll taxes on the portion of the sum\n # of wage-and-salary income and taxable self employment income\n # that exceeds SS_Earnings_thd\n sey_frac = 1.0 - 0.5 * FICA_ss_trt\n was_plus_sey_p = gross_was_p + max(0., sey_p * sey_frac)\n was_plus_sey_s = gross_was_s + max(0., sey_s * sey_frac)\n extra_ss_income_p = max(0., was_plus_sey_p - SS_Earnings_thd)\n extra_ss_income_s = max(0., was_plus_sey_s - SS_Earnings_thd)\n extra_payrolltax = (extra_ss_income_p * FICA_ss_trt +\n extra_ss_income_s * FICA_ss_trt)\n\n # compute part of total payroll taxes for filing unit\n # (the ptax_amc part of total payroll taxes for the filing unit is\n # computed in the AdditionalMedicareTax function below)\n payrolltax = ptax_was + setax + extra_payrolltax\n\n # compute OASDI part of payroll taxes\n ptax_oasdi = (ptax_ss_was_p + ptax_ss_was_s +\n setax_ss_p + setax_ss_s +\n extra_payrolltax)\n\n # compute earned* variables and AGI deduction for\n # \"employer share\" of self-employment tax, c03260\n # Note: c03260 is the amount on 2015 Form 1040, line 27\n c03260 = (1. - ALD_SelfEmploymentTax_hc) * 0.5 * setax\n earned = max(0., e00200p + e00200s + sey - c03260)\n earned_p = max(0., (e00200p + sey_p -\n (1. - ALD_SelfEmploymentTax_hc) * 0.5 * setax_p))\n earned_s = max(0., (e00200s + sey_s -\n (1. - ALD_SelfEmploymentTax_hc) * 0.5 * setax_s))\n return (sey, payrolltax, ptax_was, setax, c03260, ptax_oasdi,\n earned, earned_p, earned_s, was_plus_sey_p, was_plus_sey_s)\n\n\n@iterate_jit(nopython=True)\ndef DependentCare(nu13, elderly_dependents, earned,\n MARS, ALD_Dependents_thd, ALD_Dependents_hc,\n ALD_Dependents_Child_c, ALD_Dependents_Elder_c,\n care_deduction):\n \"\"\"\n Computes dependent-care above-the-line deduction.\n\n Parameters\n ----------\n nu13: Number of dependents under 13 years old\n elderly_dependents: number of elderly dependents\n earned: Form 2441 earned income amount\n MARS: Marital Status\n ALD_Dependents_thd: Maximum income to qualify for deduction\n ALD_Dependents_hc: Deduction for dependent care haircut\n ALD_Dependents_Child_c: National weighted average cost of childcare\n ALD_Dependents_Elder_c: Eldercare deduction ceiling\n\n Returns\n -------\n care_deduction: Total above the line deductions for dependent care.\n \"\"\"\n\n if earned <= ALD_Dependents_thd[MARS - 1]:\n care_deduction = (((1. - ALD_Dependents_hc) * nu13 *\n ALD_Dependents_Child_c) +\n ((1. - ALD_Dependents_hc) * elderly_dependents *\n ALD_Dependents_Elder_c))\n else:\n care_deduction = 0.\n return care_deduction\n\n\n@iterate_jit(nopython=True)\ndef Adj(e03150, e03210, c03260,\n e03270, e03300, e03400, e03500, e00800,\n e03220, e03230, e03240, e03290, care_deduction,\n ALD_StudentLoan_hc, ALD_SelfEmp_HealthIns_hc, ALD_KEOGH_SEP_hc,\n ALD_EarlyWithdraw_hc, ALD_AlimonyPaid_hc, ALD_AlimonyReceived_hc,\n ALD_EducatorExpenses_hc, ALD_HSADeduction_hc, ALD_IRAContributions_hc,\n ALD_DomesticProduction_hc, ALD_Tuition_hc,\n c02900):\n \"\"\"\n Adj calculates Form 1040 AGI adjustments (i.e., Above-the-Line Deductions).\n\n Notes\n -----\n Taxpayer characteristics:\n\n e03210 : Student loan interest paid\n\n e03220 : Educator expenses\n\n e03150 : Total deductible IRA plan contributions\n\n e03230 : Tuition and fees (Form 8917)\n\n e03240 : Domestic production activity deduction (Form 8903)\n\n c03260 : Self-employment tax deduction (after haircut)\n\n e03270 : Self-employed health insurance premiums\n\n e03290 : HSA deduction (Form 8889)\n\n e03300 : Total deductible KEOGH/SEP/SIMPLE/etc. plan contributions\n\n e03400 : Penalty on early withdrawal of savings deduction\n\n e03500 : Alimony paid\n\n e00800 : Alimony received\n\n care_deduction : Dependent care expense deduction\n\n Tax law parameters:\n\n ALD_StudentLoan_hc : Student loan interest deduction haircut\n\n ALD_SelfEmp_HealthIns_hc : Self-employed h.i. deduction haircut\n\n ALD_KEOGH_SEP_hc : KEOGH/etc. plan contribution deduction haircut\n\n ALD_EarlyWithdraw_hc : Penalty on early withdrawal deduction haricut\n\n ALD_AlimonyPaid_hc : Alimony paid deduction haircut\n\n ALD_AlimonyReceived_hc : Alimony received deduction haircut\n\n ALD_EducatorExpenses_hc: Eductor expenses haircut\n\n ALD_HSADeduction_hc: HSA Deduction haircut\n\n ALD_IRAContributions_hc: IRA Contribution haircut\n\n ALD_DomesticProduction_hc: Domestic production haircut\n\n ALD_Tuition_hc: Tuition and fees haircut\n\n Returns\n -------\n c02900 : total Form 1040 adjustments, which are not included in AGI\n \"\"\"\n # Form 2555 foreign earned income exclusion is assumed to be zero\n # Form 1040 adjustments that are included in expanded income:\n c02900 = ((1. - ALD_StudentLoan_hc) * e03210 +\n c03260 +\n (1. - ALD_EarlyWithdraw_hc) * e03400 +\n (1. - ALD_AlimonyPaid_hc) * e03500 +\n (1. - ALD_AlimonyReceived_hc) * e00800 +\n (1. - ALD_EducatorExpenses_hc) * e03220 +\n (1. - ALD_Tuition_hc) * e03230 +\n (1. - ALD_DomesticProduction_hc) * e03240 +\n (1. - ALD_HSADeduction_hc) * e03290 +\n (1. - ALD_SelfEmp_HealthIns_hc) * e03270 +\n (1. - ALD_IRAContributions_hc) * e03150 +\n (1. - ALD_KEOGH_SEP_hc) * e03300 +\n care_deduction)\n return c02900\n\n\n@iterate_jit(nopython=True)\ndef ALD_InvInc_ec_base(p22250, p23250, sep,\n e00300, e00600, e01100, e01200,\n invinc_ec_base):\n \"\"\"\n Computes invinc_ec_base.\n \"\"\"\n # limitation on net short-term and long-term capital losses\n cgain = max((-3000. / sep), p22250 + p23250)\n # compute exclusion of investment income from AGI\n invinc_ec_base = e00300 + e00600 + cgain + e01100 + e01200\n return invinc_ec_base\n\n\n@iterate_jit(nopython=True)\ndef CapGains(p23250, p22250, sep, ALD_StudentLoan_hc,\n ALD_InvInc_ec_rt, invinc_ec_base,\n e00200, e00300, e00600, e00650, e00700, e00800,\n CG_nodiff, CG_ec, CG_reinvest_ec_rt,\n ALD_BusinessLosses_c, MARS,\n e00900, e01100, e01200, e01400, e01700, e02000, e02100,\n e02300, e00400, e02400, c02900, e03210, e03230, e03240,\n c01000, c23650, ymod, ymod1, invinc_agi_ec,\n gains_at_death, CG_death, CG_death_ec):\n \"\"\"\n CapGains function: ...\n \"\"\"\n # compute taxable portion of capital gains at death (gains_at_death - CG_death_ec)\n if CG_death is True:\n taxable_gains_at_death = max(0., gains_at_death - CG_death_ec[MARS-1])\n else:\n taxable_gains_at_death = 0.\n # net capital gain (long term + short term + gains at death) before exclusion\n c23650 = p23250 + p22250 + taxable_gains_at_death\n # limitation on capital losses\n c01000 = max((-3000. / sep), c23650)\n # compute total investment income\n invinc = e00300 + e00600 + c01000 + e01100 + e01200\n # compute exclusion of investment income from AGI\n invinc_agi_ec = ALD_InvInc_ec_rt * max(0., invinc_ec_base)\n # compute ymod1 variable that is included in AGI\n ymod1 = (e00200 + e00700 + e00800 + e01400 + e01700 +\n invinc - invinc_agi_ec + e02100 + e02300 +\n max(e00900 + e02000, -ALD_BusinessLosses_c[MARS - 1]))\n if CG_nodiff:\n # apply QDIV+CG exclusion if QDIV+LTCG receive no special tax treatment\n qdcg_pos = max(0., e00650 + c01000)\n qdcg_exclusion = (min(CG_ec, qdcg_pos) +\n CG_reinvest_ec_rt * max(0., qdcg_pos - CG_ec))\n ymod1 = max(0., ymod1 - qdcg_exclusion)\n invinc_agi_ec += qdcg_exclusion\n # compute ymod variable that is used in OASDI benefit taxation logic\n ymod2 = e00400 + (0.50 * e02400) - c02900\n ymod3 = (1. - ALD_StudentLoan_hc) * e03210 + e03230 + e03240\n ymod = ymod1 + ymod2 + ymod3\n return (c01000, c23650, ymod, ymod1, invinc_agi_ec,\n gains_at_death, taxable_gains_at_death)\n\n\n@iterate_jit(nopython=True)\ndef SSBenefits(MARS, ymod, e02400, SS_thd50, SS_thd85,\n SS_percentage1, SS_percentage2, c02500):\n \"\"\"\n Calculates OASDI benefits included in AGI, c02500.\n \"\"\"\n if ymod < SS_thd50[MARS - 1]:\n c02500 = 0.\n elif ymod < SS_thd85[MARS - 1]:\n c02500 = SS_percentage1 * min(ymod - SS_thd50[MARS - 1], e02400)\n else:\n c02500 = min(SS_percentage2 * (ymod - SS_thd85[MARS - 1]) +\n SS_percentage1 *\n min(e02400, SS_thd85[MARS - 1] -\n SS_thd50[MARS - 1]), SS_percentage2 * e02400)\n return c02500\n\n\n@iterate_jit(nopython=True)\ndef UBI(nu18, n1820, n21, UBI_u18, UBI_1820, UBI_21, UBI_ecrt,\n ubi, taxable_ubi, nontaxable_ubi):\n \"\"\"\n Calculates total and taxable Universal Basic Income (UBI) amount.\n\n Parameters\n ----------\n nu18: Number of people in the tax unit under 18\n\n n1820: Number of people in the tax unit age 18-20\n\n n21: Number of people in the tax unit age 21+\n\n UBI_u18: UBI benefit for those under 18\n\n UBI_1820: UBI benefit for those between 18 to 20\n\n UBI_21: UBI benefit for those 21 or more\n\n UBI_ecrt: Fraction of UBI benefits that are not included in AGI\n\n Returns\n -------\n ubi: total UBI received by the tax unit (is included in expanded_income)\n\n taxable_ubi: amount of UBI that is taxable (is added to AGI)\n\n nontaxable_ubi: amount of UBI that is nontaxable\n \"\"\"\n ubi = nu18 * UBI_u18 + n1820 * UBI_1820 + n21 * UBI_21\n taxable_ubi = ubi * (1. - UBI_ecrt)\n nontaxable_ubi = ubi - taxable_ubi\n return ubi, taxable_ubi, nontaxable_ubi\n\n\n@iterate_jit(nopython=True)\ndef AGI(ymod1, c02500, c02900, XTOT, MARS, sep, DSI, exact, nu18, taxable_ubi,\n II_em, II_em_ps, II_prt, II_no_em_nu18,\n c00100, pre_c04600, c04600):\n \"\"\"\n Computes Adjusted Gross Income (AGI), c00100, and\n compute personal exemption amount, c04600.\n \"\"\"\n # calculate AGI assuming no foreign earned income exclusion\n c00100 = ymod1 + c02500 - c02900 + taxable_ubi\n # calculate personal exemption amount\n if II_no_em_nu18: # repeal of personal exemptions for deps. under 18\n pre_c04600 = max(0, XTOT - nu18) * II_em\n else:\n pre_c04600 = XTOT * II_em\n if DSI:\n pre_c04600 = 0.\n # phase-out personal exemption amount\n if exact == 1: # exact calculation as on tax forms\n line5 = max(0., c00100 - II_em_ps[MARS - 1])\n line6 = math.ceil(line5 / (2500. / sep))\n line7 = II_prt * line6\n c04600 = max(0., pre_c04600 * (1. - line7))\n else: # smoothed calculation needed for sensible mtr calculation\n dispc_numer = II_prt * (c00100 - II_em_ps[MARS - 1])\n dispc_denom = 2500. / sep\n dispc = min(1., max(0., dispc_numer / dispc_denom))\n c04600 = pre_c04600 * (1. - dispc)\n return (c00100, pre_c04600, c04600)\n\n\n@iterate_jit(nopython=True)\ndef ItemDedCap(e17500, e18400, e18500, e19200, e19800, e20100, e20400, g20500,\n c00100, ID_AmountCap_rt, ID_AmountCap_Switch, e17500_capped,\n e18400_capped, e18500_capped, e19200_capped, e19800_capped,\n e20100_capped, e20400_capped, g20500_capped):\n \"\"\"\n Applies a cap to gross itemized deductions.\n\n Notes\n -----\n Tax Law Parameters:\n ID_AmountCap_Switch : Indicator for which itemized deductions are\n capped\n ID_AmountCap_rt : Cap on itemized deductions; decimal fraction of AGI\n\n Taxpayer Characteristics:\n e17500 : Medical expenses\n\n e18400 : State and local taxes\n\n e18500 : Real-estate taxes\n\n e19200 : Interest paid\n\n e19800 : Charity cash contributions\n\n e20100 : Charity noncash contributions\n\n e20400 : Total miscellaneous expenses\n\n g20500 : Gross casualty or theft loss (before disregard)\n\n c00100: Adjusted Gross Income\n\n Returns\n -------\n e17500_capped: Medical expenses, capped by ItemDedCap\n\n e18400_capped: State and local taxes, capped by ItemDedCap\n\n e18500_capped : Real-estate taxes, capped by ItemDedCap\n\n e19200_capped : Interest paid, capped by ItemDedCap\n\n e19800_capped : Charity cash contributions, capped by ItemDedCap\n\n e20100_capped : Charity noncash contributions, capped by ItemDedCap\n\n e20400_capped : Total miscellaneous expenses, capped by ItemDedCap\n\n g20500_capped : Gross casualty or theft loss (before disregard),\n capped by ItemDedCap\n \"\"\"\n # pylint: disable=too-many-branches\n\n cap = max(0., ID_AmountCap_rt * c00100)\n\n gross_ded_amt = 0\n if ID_AmountCap_Switch[0]: # medical\n gross_ded_amt += e17500\n if ID_AmountCap_Switch[1]: # statelocal\n gross_ded_amt += e18400\n if ID_AmountCap_Switch[2]: # realestate\n gross_ded_amt += e18500\n if ID_AmountCap_Switch[3]: # casualty\n gross_ded_amt += g20500\n if ID_AmountCap_Switch[4]: # misc\n gross_ded_amt += e20400\n if ID_AmountCap_Switch[5]: # interest\n gross_ded_amt += e19200\n if ID_AmountCap_Switch[6]: # charity\n gross_ded_amt += e19800 + e20100\n\n overage = max(0., gross_ded_amt - cap)\n\n e17500_capped = e17500\n e18400_capped = e18400\n e18500_capped = e18500\n g20500_capped = g20500\n e20400_capped = e20400\n e19200_capped = e19200\n e19800_capped = e19800\n e20100_capped = e20100\n\n if overage > 0. and c00100 > 0.:\n if ID_AmountCap_Switch[0]: # medical\n e17500_capped -= (e17500 / gross_ded_amt) * overage\n if ID_AmountCap_Switch[1]: # statelocal\n e18400_capped -= (e18400 / (gross_ded_amt) * overage)\n if ID_AmountCap_Switch[2]: # realestate\n e18500_capped -= (e18500 / gross_ded_amt) * overage\n if ID_AmountCap_Switch[3]: # casualty\n g20500_capped -= (g20500 / gross_ded_amt) * overage\n if ID_AmountCap_Switch[4]: # misc\n e20400_capped -= (e20400 / gross_ded_amt) * overage\n if ID_AmountCap_Switch[5]: # interest\n e19200_capped -= (e19200 / gross_ded_amt) * overage\n if ID_AmountCap_Switch[6]: # charity\n e19800_capped -= (e19800 / gross_ded_amt) * overage\n e20100_capped -= (e20100 / gross_ded_amt) * overage\n\n return (e17500_capped, e18400_capped, e18500_capped, g20500_capped,\n e20400_capped, e19200_capped, e19800_capped, e20100_capped)\n\n\n@iterate_jit(nopython=True)\ndef ItemDed(e17500_capped, e18400_capped, e18500_capped, e19200_capped,\n e19800_capped, e20100_capped, e20400_capped, g20500_capped,\n MARS, age_head, age_spouse, c00100, c04470, c21040, c21060,\n c17000, c18300, c19200, c19700, c20500, c20800,\n ID_ps, ID_Medical_frt, ID_Medical_frt_add4aged, ID_Medical_hc,\n ID_Casualty_frt, ID_Casualty_hc, ID_Miscellaneous_frt,\n ID_Miscellaneous_hc, ID_Charity_crt_all, ID_Charity_crt_noncash,\n ID_prt, ID_crt, ID_c, ID_StateLocalTax_hc, ID_Charity_frt,\n ID_Charity_hc, ID_InterestPaid_hc, ID_RealEstate_hc,\n ID_Medical_c, ID_StateLocalTax_c, ID_RealEstate_c,\n ID_InterestPaid_c, ID_Charity_c, ID_Casualty_c,\n ID_Miscellaneous_c, ID_AllTaxes_c, ID_AllTaxes_hc,\n ID_StateLocalTax_crt, ID_RealEstate_crt, ID_Charity_f):\n \"\"\"\n Calculates itemized deductions, Form 1040, Schedule A.\n\n Notes\n -----\n Tax Law Parameters:\n ID_ps : Itemized deduction phaseout AGI start (Pease)\n\n ID_crt : Itemized deduction maximum phaseout\n as a decimal fraction of total itemized deduction (Pease)\n\n ID_prt : Itemized deduction phaseout rate (Pease)\n\n ID_c: Dollar limit on itemized deductions\n\n ID_Medical_frt : Deduction for medical expenses;\n floor as a decimal fraction of AGI\n\n ID_Medical_frt_add4aged : Addon for medical expenses deduction for\n elderly; addon as a decimal fraction of AGI\n\n ID_Casualty_frt : Deduction for casualty loss;\n floor as a decimal fraction of AGI\n\n ID_Miscellaneous_frt : Deduction for miscellaneous expenses;\n floor as a decimal fraction of AGI\n\n ID_Charity_crt_all : Deduction for all charitable contributions;\n ceiling as a decimal fraction of AGI\n\n ID_Charity_crt_noncash : Deduction for noncash charitable\n contributions; ceiling as a decimal\n fraction of AGI\n\n ID_Charity_frt : Disregard for charitable contributions;\n floor as a decimal fraction of AGI\n\n ID_Medical_c : Ceiling on medical expense deduction\n\n ID_StateLocalTax_c : Ceiling on state and local tax deduction\n\n ID_RealEstate_c : Ceiling on real estate tax deduction\n\n ID_AllTaxes_c: Ceiling combined state and local income/sales and\n real estate tax deductions\n\n ID_InterestPaid_c : Ceiling on interest paid deduction\n\n ID_Charity_c : Ceiling on charity expense deduction\n\n ID_Charity_f: Floor on charity expense deduction\n\n ID_Casualty_c : Ceiling on casuality expense deduction\n\n ID_Miscellaneous_c : Ceiling on miscellaneous expense deduction\n\n ID_StateLocalTax_crt : Deduction for state and local taxes;\n ceiling as a decimal fraction of AGI\n\n ID_RealEstate_crt : Deduction for real estate taxes;\n ceiling as a decimal fraction of AGI\n\n Taxpayer Characteristics:\n e17500_capped : Medical expenses, capped by ItemDedCap\n\n e18400_capped : State and local taxes, capped by ItemDedCap\n\n e18500_capped : Real-estate taxes, capped by ItemDedCap\n\n e19200_capped : Interest paid, capped by ItemDedCap\n\n e19800_capped : Charity cash contributions, capped by ItemDedCap\n\n e20100_capped : Charity noncash contributions, capped by ItemDedCap\n\n e20400_capped : Total miscellaneous expenses, capped by ItemDedCap\n\n g20500_capped : Gross casualty or theft loss (before disregard),\n capped by ItemDedCap\n\n Returns\n -------\n c04470 : total itemized deduction amount (and other intermediate variables)\n \"\"\"\n posagi = max(c00100, 0.)\n # Medical\n medical_frt = ID_Medical_frt\n if age_head >= 65 or (MARS == 2 and age_spouse >= 65):\n medical_frt += ID_Medical_frt_add4aged\n c17750 = medical_frt * posagi\n c17000 = max(0., e17500_capped - c17750) * (1. - ID_Medical_hc)\n c17000 = min(c17000, ID_Medical_c[MARS - 1])\n # State and local taxes\n c18400 = min((1. - ID_StateLocalTax_hc) * max(e18400_capped, 0.),\n ID_StateLocalTax_c[MARS - 1])\n c18500 = min((1. - ID_RealEstate_hc) * e18500_capped,\n ID_RealEstate_c[MARS - 1])\n # following two statements implement a cap on c18400 and c18500 in a way\n # that those with negative AGI, c00100, are not capped under current law,\n # hence the 0.0001 rather than zero\n c18400 = min(c18400, ID_StateLocalTax_crt * max(c00100, 0.0001))\n c18500 = min(c18500, ID_RealEstate_crt * max(c00100, 0.0001))\n c18300 = (c18400 + c18500) * (1. - ID_AllTaxes_hc)\n c18300 = min(c18300, ID_AllTaxes_c[MARS - 1])\n # Interest paid\n c19200 = e19200_capped * (1. - ID_InterestPaid_hc)\n c19200 = min(c19200, ID_InterestPaid_c[MARS - 1])\n # Charity\n lim30 = min(ID_Charity_crt_noncash * posagi, e20100_capped)\n c19700 = min(ID_Charity_crt_all * posagi, lim30 + e19800_capped)\n # charity floor is zero in present law\n charity_floor = max(ID_Charity_frt * posagi, ID_Charity_f[MARS - 1])\n c19700 = max(0., c19700 - charity_floor) * (1. - ID_Charity_hc)\n c19700 = min(c19700, ID_Charity_c[MARS - 1])\n # Casualty\n c20500 = (max(0., g20500_capped - ID_Casualty_frt * posagi) *\n (1. - ID_Casualty_hc))\n c20500 = min(c20500, ID_Casualty_c[MARS - 1])\n # Miscellaneous\n c20400 = e20400_capped\n c20750 = ID_Miscellaneous_frt * posagi\n c20800 = max(0., c20400 - c20750) * (1. - ID_Miscellaneous_hc)\n c20800 = min(c20800, ID_Miscellaneous_c[MARS - 1])\n # Gross total itemized deductions\n c21060 = c17000 + c18300 + c19200 + c19700 + c20500 + c20800\n # Limitations on total itemized deductions\n # (no attempt to adjust c04470 components for limitations)\n nonlimited = c17000 + c20500\n limitstart = ID_ps[MARS - 1]\n if c21060 > nonlimited and c00100 > limitstart:\n dedmin = ID_crt * (c21060 - nonlimited)\n dedpho = ID_prt * max(0., posagi - limitstart)\n c21040 = min(dedmin, dedpho)\n c04470 = c21060 - c21040\n else:\n c21040 = 0.\n c04470 = c21060\n c04470 = min(c04470, ID_c[MARS - 1])\n # Return total itemized deduction amounts and components\n return (c17000, c18300, c19200, c19700, c20500, c20800,\n c21040, c21060, c04470)\n\n\n@iterate_jit(nopython=True)\ndef AdditionalMedicareTax(e00200, MARS,\n AMEDT_ec, sey, AMEDT_rt,\n FICA_mc_trt, FICA_ss_trt,\n ptax_amc, payrolltax):\n \"\"\"\n Computes Additional Medicare Tax (Form 8959) included in payroll taxes.\n\n Notes\n -----\n Tax Law Parameters:\n AMEDT_ec : Additional Medicare Tax earnings exclusion\n\n AMEDT_rt : Additional Medicare Tax rate\n\n FICA_ss_trt : FICA Social Security tax rate\n\n FICA_mc_trt : FICA Medicare tax rate\n\n Taxpayer Charateristics:\n e00200 : Wages and salaries\n\n sey : Self-employment income\n\n Returns\n -------\n ptax_amc : Additional Medicare Tax\n\n payrolltax : payroll tax augmented by Additional Medicare Tax\n \"\"\"\n line8 = max(0., sey) * (1. - 0.5 * (FICA_mc_trt + FICA_ss_trt))\n line11 = max(0., AMEDT_ec[MARS - 1] - e00200)\n ptax_amc = AMEDT_rt * (max(0., e00200 - AMEDT_ec[MARS - 1]) +\n max(0., line8 - line11))\n payrolltax += ptax_amc\n return (ptax_amc, payrolltax)\n\n\n@iterate_jit(nopython=True)\ndef StdDed(DSI, earned, STD, age_head, age_spouse, STD_Aged, STD_Dep,\n MARS, MIDR, blind_head, blind_spouse, standard, c19700,\n STD_allow_charity_ded_nonitemizers):\n \"\"\"\n Calculates standard deduction, including standard deduction for\n dependents, aged and bind.\n\n Notes\n -----\n Tax Law Parameters:\n STD : Standard deduction amount, filing status dependent\n\n STD_Dep : Standard deduction for dependents\n\n STD_Aged : Additional standard deduction for blind and aged\n\n Taxpayer Characteristics:\n earned : Form 2441 earned income amount\n\n e02400 : Gross Social Security Benefit\n\n DSI : Dependent Status Indicator:\n 0 - not being claimed as a dependent\n 1 - claimed as a dependent\n\n MIDR : Married filing separately itemized deductions\n requirement indicator:\n 0 - not necessary to itemize because of filing status\n 1 - necessary to itemize when filing separately\n\n Returns\n -------\n standard : the standard deduction amount for filing unit\n \"\"\"\n # calculate deduction for dependents\n if DSI == 1:\n c15100 = max(350. + earned, STD_Dep)\n basic_stded = min(STD[MARS - 1], c15100)\n else:\n c15100 = 0.\n if MIDR == 1:\n basic_stded = 0.\n else:\n basic_stded = STD[MARS - 1]\n # calculate extra standard deduction for aged and blind\n num_extra_stded = blind_head + blind_spouse\n if age_head >= 65:\n num_extra_stded += 1\n if MARS == 2 and age_spouse >= 65:\n num_extra_stded += 1\n extra_stded = num_extra_stded * STD_Aged[MARS - 1]\n # calculate the total standard deduction\n standard = basic_stded + extra_stded\n if MARS == 3 and MIDR == 1:\n standard = 0.\n if STD_allow_charity_ded_nonitemizers:\n standard += c19700\n return standard\n\n\n@iterate_jit(nopython=True)\ndef TaxInc(c00100, standard, c04470, c04600, MARS, e00900, e26270,\n e02100, e27200, e00650, c01000,\n PT_SSTB_income, PT_binc_w2_wages, PT_ubia_property,\n PT_qbid_rt, PT_qbid_taxinc_thd, PT_qbid_taxinc_gap,\n PT_qbid_w2_wages_rt,\n PT_qbid_alt_w2_wages_rt, PT_qbid_alt_property_rt,\n c04800, qbided, StudentLoan_em, studloan_debt, sldf):\n \"\"\"\n Calculates taxable income, c04800, and\n qualified business income deduction, qbided.\n \"\"\"\n # calculate taxable income before qualified business income deduction\n pre_qbid_taxinc = max(0., c00100 - max(c04470, standard) - c04600)\n # calculate qualified business income deduction\n qbided = 0.\n qbinc = max(0., e00900 + e26270 + e02100 + e27200)\n qbided_full = qbinc * PT_qbid_rt\n if PT_qbid_taxinc_thd[MARS-1] > 0:\n if pre_qbid_taxinc < PT_qbid_taxinc_thd[MARS-1]:\n qbided = qbided_full\n else:\n qbided = max(0., qbided_full * (1 - (pre_qbid_taxinc - PT_qbid_taxinc_thd[MARS-1])/ PT_qbid_taxinc_gap[MARS-1]))\n else:\n qbided = qbided_full\n \"\"\"\n if qbinc > 0. and PT_qbid_rt > 0.:\n qbid_before_limits = qbinc * PT_qbid_rt\n lower_thd = PT_qbid_taxinc_thd[MARS - 1]\n if pre_qbid_taxinc <= lower_thd:\n qbided = qbid_before_limits\n else:\n pre_qbid_taxinc_gap = PT_qbid_taxinc_gap[MARS - 1]\n upper_thd = lower_thd + pre_qbid_taxinc_gap\n if PT_SSTB_income == 1 and pre_qbid_taxinc >= upper_thd:\n qbided = 0.\n else:\n wage_cap = PT_binc_w2_wages * PT_qbid_w2_wages_rt\n alt_cap = (PT_binc_w2_wages * PT_qbid_alt_w2_wages_rt +\n PT_ubia_property * PT_qbid_alt_property_rt)\n full_cap = max(wage_cap, alt_cap)\n if PT_SSTB_income == 0 and pre_qbid_taxinc >= upper_thd:\n # apply full cap\n qbided = min(full_cap, qbid_before_limits)\n elif PT_SSTB_income == 0 and pre_qbid_taxinc < upper_thd:\n # apply adjusted cap as in Part III of Worksheet 12-A\n # in 2018 IRS Publication 535 (Chapter 12)\n prt = (pre_qbid_taxinc - lower_thd) / pre_qbid_taxinc_gap\n adj = prt * (qbid_before_limits - full_cap)\n qbided = qbid_before_limits - adj\n else: # PT_SSTB_income == 1 and pre_qbid_taxinc < upper_thd\n prti = (upper_thd - pre_qbid_taxinc) / pre_qbid_taxinc_gap\n qbid_adjusted = prti * qbid_before_limits\n cap_adjusted = prti * full_cap\n prt = (pre_qbid_taxinc - lower_thd) / pre_qbid_taxinc_gap\n adj = prt * (qbid_adjusted - cap_adjusted)\n qbided = qbid_adjusted - adj\n \"\"\"\n # apply taxinc cap (assuning cap rate is equal to PT_qbid_rt)\n net_cg = e00650 + c01000 # per line 34 in 2018 Pub 535 Worksheet 12-A\n taxinc_cap = PT_qbid_rt * max(0., pre_qbid_taxinc - net_cg)\n qbided = min(qbided, taxinc_cap)\n # exclude forgiven student loan debt from taxable income\n if StudentLoan_em is True:\n base_sldf = max(0., studloan_debt)\n else:\n base_sldf = 0.\n # exclusion is limited to tax inc\n sldf = max(0., min(pre_qbid_taxinc - qbided, base_sldf))\n # calculate taxable income after qualified business income deduction\n c04800 = max(0., pre_qbid_taxinc - qbided - sldf)\n return (c04800, qbided, sldf)\n\n\n@JIT(nopython=True)\ndef SchXYZ(taxable_income, MARS, e00900, e26270, e02000, e00200,\n PT_rt1, PT_rt2, PT_rt3, PT_rt4, PT_rt5,\n PT_rt6, PT_rt7, PT_rt8,\n PT_brk1, PT_brk2, PT_brk3, PT_brk4, PT_brk5,\n PT_brk6, PT_brk7,\n II_rt1, II_rt2, II_rt3, II_rt4, II_rt5,\n II_rt6, II_rt7, II_rt8,\n II_brk1, II_brk2, II_brk3, II_brk4, II_brk5,\n II_brk6, II_brk7, PT_EligibleRate_active,\n PT_EligibleRate_passive, PT_wages_active_income,\n PT_top_stacking):\n \"\"\"\n Returns Schedule X, Y, Z tax amount for specified taxable_income.\n \"\"\"\n # separate non-negative taxable income into two non-negative components,\n # doing this in a way so that the components add up to taxable income\n # define pass-through income eligible for PT schedule\n pt_passive = PT_EligibleRate_passive * (e02000 - e26270)\n pt_active_gross = e00900 + e26270\n if (pt_active_gross > 0) and PT_wages_active_income:\n pt_active_gross = pt_active_gross + e00200\n pt_active = PT_EligibleRate_active * pt_active_gross\n pt_active = min(pt_active, e00900 + e26270)\n pt_taxinc = max(0., pt_passive + pt_active)\n if pt_taxinc >= taxable_income:\n pt_taxinc = taxable_income\n reg_taxinc = 0.\n else:\n # pt_taxinc is unchanged\n reg_taxinc = taxable_income - pt_taxinc\n # determine stacking order\n if PT_top_stacking:\n reg_tbase = 0.\n pt_tbase = reg_taxinc\n else:\n reg_tbase = pt_taxinc\n pt_tbase = 0.\n # compute Schedule X,Y,Z tax using the two components of taxable income\n if reg_taxinc > 0.:\n reg_tax = Taxes(reg_taxinc, MARS, reg_tbase,\n II_rt1, II_rt2, II_rt3, II_rt4,\n II_rt5, II_rt6, II_rt7, II_rt8, II_brk1, II_brk2,\n II_brk3, II_brk4, II_brk5, II_brk6, II_brk7)\n else:\n reg_tax = 0.\n if pt_taxinc > 0.:\n pt_tax = Taxes(pt_taxinc, MARS, pt_tbase,\n PT_rt1, PT_rt2, PT_rt3, PT_rt4,\n PT_rt5, PT_rt6, PT_rt7, PT_rt8, PT_brk1, PT_brk2,\n PT_brk3, PT_brk4, PT_brk5, PT_brk6, PT_brk7)\n else:\n pt_tax = 0.\n return reg_tax + pt_tax\n\n\n@iterate_jit(nopython=True)\ndef SchXYZTax(c04800, MARS, e00900, e26270, e02000, e00200,\n PT_rt1, PT_rt2, PT_rt3, PT_rt4, PT_rt5,\n PT_rt6, PT_rt7, PT_rt8,\n PT_brk1, PT_brk2, PT_brk3, PT_brk4, PT_brk5,\n PT_brk6, PT_brk7,\n II_rt1, II_rt2, II_rt3, II_rt4, II_rt5,\n II_rt6, II_rt7, II_rt8,\n II_brk1, II_brk2, II_brk3, II_brk4, II_brk5,\n II_brk6, II_brk7, PT_EligibleRate_active,\n PT_EligibleRate_passive, PT_wages_active_income,\n PT_top_stacking, c05200):\n \"\"\"\n SchXYZTax calls SchXYZ function and sets c05200 to returned amount.\n \"\"\"\n c05200 = SchXYZ(c04800, MARS, e00900, e26270, e02000, e00200,\n PT_rt1, PT_rt2, PT_rt3, PT_rt4, PT_rt5,\n PT_rt6, PT_rt7, PT_rt8,\n PT_brk1, PT_brk2, PT_brk3, PT_brk4, PT_brk5,\n PT_brk6, PT_brk7,\n II_rt1, II_rt2, II_rt3, II_rt4, II_rt5,\n II_rt6, II_rt7, II_rt8,\n II_brk1, II_brk2, II_brk3, II_brk4, II_brk5,\n II_brk6, II_brk7, PT_EligibleRate_active,\n PT_EligibleRate_passive, PT_wages_active_income,\n PT_top_stacking)\n return c05200\n\n\n@iterate_jit(nopython=True)\ndef GainsTax(e00650, c01000, c23650, p23250, e01100, e58990, e00200,\n e24515, e24518, MARS, c04800, c05200, e00900, e26270, e02000,\n II_rt1, II_rt2, II_rt3, II_rt4, II_rt5, II_rt6, II_rt7, II_rt8,\n II_brk1, II_brk2, II_brk3, II_brk4, II_brk5, II_brk6, II_brk7,\n PT_rt1, PT_rt2, PT_rt3, PT_rt4, PT_rt5, PT_rt6, PT_rt7, PT_rt8,\n PT_brk1, PT_brk2, PT_brk3, PT_brk4, PT_brk5, PT_brk6, PT_brk7,\n CG_nodiff, PT_EligibleRate_active, PT_EligibleRate_passive,\n PT_wages_active_income, PT_top_stacking,\n CG_rt1, CG_rt2, CG_rt3, CG_rt4, CG_brk1, CG_brk2, CG_brk3,\n dwks10, dwks13, dwks14, dwks19, c05700, taxbc):\n \"\"\"\n GainsTax function implements (2015) Schedule D Tax Worksheet logic for\n the special taxation of long-term capital gains and qualified dividends\n if CG_nodiff is false.\n \"\"\"\n # pylint: disable=too-many-statements\n if c01000 > 0. or c23650 > 0. or p23250 > 0. or e01100 > 0. or e00650 > 0.:\n hasqdivltcg = 1 # has qualified dividends or long-term capital gains\n else:\n hasqdivltcg = 0 # no qualified dividends or long-term capital gains\n\n if CG_nodiff:\n hasqdivltcg = 0 # no special taxation of qual divids and l-t cap gains\n\n if hasqdivltcg == 1:\n\n dwks1 = c04800\n dwks2 = e00650\n dwks3 = e58990\n dwks4 = 0. # always assumed to be zero\n dwks5 = max(0., dwks3 - dwks4)\n dwks6 = max(0., dwks2 - dwks5)\n dwks7 = min(p23250, c23650) # SchD lines 15 and 16, respectively\n # dwks8 = min(dwks3, dwks4)\n # dwks9 = max(0., dwks7 - dwks8)\n # BELOW TWO STATEMENTS ARE UNCLEAR IN LIGHT OF dwks9=... COMMENT\n if e01100 > 0.:\n c24510 = e01100\n else:\n c24510 = max(0., dwks7) + e01100\n dwks9 = max(0., c24510 - min(0., e58990))\n # ABOVE TWO STATEMENTS ARE UNCLEAR IN LIGHT OF dwks9=... COMMENT\n dwks10 = dwks6 + dwks9\n dwks11 = e24515 + e24518 # SchD lines 18 and 19, respectively\n dwks12 = min(dwks9, dwks11)\n dwks13 = dwks10 - dwks12\n dwks14 = max(0., dwks1 - dwks13)\n dwks16 = min(CG_brk1[MARS - 1], dwks1)\n dwks17 = min(dwks14, dwks16)\n dwks18 = max(0., dwks1 - dwks10)\n dwks19 = max(dwks17, dwks18)\n dwks20 = dwks16 - dwks17\n lowest_rate_tax = CG_rt1 * dwks20\n # break in worksheet lines\n dwks21 = min(dwks1, dwks13)\n dwks22 = dwks20\n dwks23 = max(0., dwks21 - dwks22)\n dwks25 = min(CG_brk2[MARS - 1], dwks1)\n dwks26 = dwks19 + dwks20\n dwks27 = max(0., dwks25 - dwks26)\n dwks28 = min(dwks23, dwks27)\n dwks29 = CG_rt2 * dwks28\n dwks30 = dwks22 + dwks28\n dwks31 = dwks21 - dwks30\n dwks32 = CG_rt3 * dwks31\n hi_base = max(0., dwks31 - CG_brk3[MARS - 1])\n hi_incremental_rate = CG_rt4 - CG_rt3\n highest_rate_incremental_tax = hi_incremental_rate * hi_base\n # break in worksheet lines\n dwks33 = min(dwks9, e24518)\n dwks34 = dwks10 + dwks19\n dwks36 = max(0., dwks34 - dwks1)\n dwks37 = max(0., dwks33 - dwks36)\n dwks38 = 0.25 * dwks37\n # break in worksheet lines\n dwks39 = dwks19 + dwks20 + dwks28 + dwks31 + dwks37\n dwks40 = dwks1 - dwks39\n dwks41 = 0.28 * dwks40\n dwks42 = SchXYZ(dwks19, MARS, e00900, e26270, e02000, e00200,\n PT_rt1, PT_rt2, PT_rt3, PT_rt4, PT_rt5,\n PT_rt6, PT_rt7, PT_rt8,\n PT_brk1, PT_brk2, PT_brk3, PT_brk4, PT_brk5,\n PT_brk6, PT_brk7,\n II_rt1, II_rt2, II_rt3, II_rt4, II_rt5,\n II_rt6, II_rt7, II_rt8,\n II_brk1, II_brk2, II_brk3, II_brk4, II_brk5,\n II_brk6, II_brk7, PT_EligibleRate_active,\n PT_EligibleRate_passive, PT_wages_active_income,\n PT_top_stacking)\n dwks43 = (dwks29 + dwks32 + dwks38 + dwks41 + dwks42 +\n lowest_rate_tax + highest_rate_incremental_tax)\n dwks44 = c05200\n dwks45 = min(dwks43, dwks44)\n c24580 = dwks45\n\n else: # if hasqdivltcg is zero\n\n c24580 = c05200\n dwks10 = max(0., min(p23250, c23650)) + e01100\n dwks13 = 0.\n dwks14 = 0.\n dwks19 = 0.\n\n # final calculations done no matter what the value of hasqdivltcg\n c05100 = c24580 # because foreign earned income exclusion is assumed zero\n c05700 = 0. # no Form 4972, Lump Sum Distributions\n taxbc = c05700 + c05100\n return (dwks10, dwks13, dwks14, dwks19, c05700, taxbc)\n\n\n@iterate_jit(nopython=True)\ndef AGIsurtax(c00100, MARS, AGI_surtax_trt, AGI_surtax_thd, taxbc, surtax):\n \"\"\"\n Computes surtax on AGI above some threshold.\n \"\"\"\n if AGI_surtax_trt > 0.:\n hiAGItax = AGI_surtax_trt * max(c00100 - AGI_surtax_thd[MARS - 1], 0.)\n taxbc += hiAGItax\n surtax += hiAGItax\n return (taxbc, surtax)\n\n\n@iterate_jit(nopython=True)\ndef AMT(e07300, dwks13, standard, f6251, c00100, c18300, taxbc,\n c04470, c17000, c20800, c21040, e24515, MARS, sep, dwks19,\n dwks14, c05700, e62900, e00700, dwks10, age_head, age_spouse,\n earned, cmbtp,\n AMT_child_em_c_age, AMT_brk1,\n AMT_em, AMT_prt, AMT_rt1, AMT_rt2,\n AMT_child_em, AMT_em_ps, AMT_em_pe,\n AMT_CG_brk1, AMT_CG_brk2, AMT_CG_brk3, AMT_CG_rt1, AMT_CG_rt2,\n AMT_CG_rt3, AMT_CG_rt4, c05800, c09600, c62100):\n \"\"\"\n Computes Alternative Minimum Tax (AMT) taxable income and liability, where\n c62100 is AMT taxable income,\n c09600 is AMT tax liability, and\n c05800 is total (regular + AMT) income tax liability before credits.\n\n Note that line-number variable names refer to 2015 Form 6251.\n \"\"\"\n # pylint: disable=too-many-statements,too-many-branches\n # Form 6251, Part I\n if standard == 0.0:\n c62100 = (c00100 - e00700 - c04470 +\n max(0., min(c17000, 0.025 * c00100)) +\n c18300 + c20800 - c21040)\n if standard > 0.0:\n c62100 = c00100 - e00700\n c62100 += cmbtp # add income not in AGI but considered income for AMT\n if MARS == 3:\n amtsepadd = max(0.,\n min(AMT_em[MARS - 1], AMT_prt * (c62100 - AMT_em_pe)))\n else:\n amtsepadd = 0.\n c62100 = c62100 + amtsepadd # AMT taxable income, which is line28\n # Form 6251, Part II top\n line29 = max(0., AMT_em[MARS - 1] - AMT_prt *\n max(0., c62100 - AMT_em_ps[MARS - 1]))\n young_head = age_head != 0 and age_head < AMT_child_em_c_age\n no_or_young_spouse = age_spouse < AMT_child_em_c_age\n if young_head and no_or_young_spouse:\n line29 = min(line29, earned + AMT_child_em)\n line30 = max(0., c62100 - line29)\n line3163 = (AMT_rt1 * line30 +\n AMT_rt2 * max(0., (line30 - (AMT_brk1 / sep))))\n if dwks10 > 0. or dwks13 > 0. or dwks14 > 0. or dwks19 > 0. or e24515 > 0.:\n # complete Form 6251, Part III (line36 is equal to line30)\n line37 = dwks13\n line38 = e24515\n line39 = min(line37 + line38, dwks10)\n line40 = min(line30, line39)\n line41 = max(0., line30 - line40)\n line42 = (AMT_rt1 * line41 +\n AMT_rt2 * max(0., (line41 - (AMT_brk1 / sep))))\n line44 = dwks14\n line45 = max(0., AMT_CG_brk1[MARS - 1] - line44)\n line46 = min(line30, line37)\n line47 = min(line45, line46) # line47 is amount taxed at AMT_CG_rt1\n cgtax1 = line47 * AMT_CG_rt1\n line48 = line46 - line47\n line51 = dwks19\n line52 = line45 + line51\n line53 = max(0., AMT_CG_brk2[MARS - 1] - line52)\n line54 = min(line48, line53) # line54 is amount taxed at AMT_CG_rt2\n cgtax2 = line54 * AMT_CG_rt2\n line56 = line47 + line54 # total amount in lower two brackets\n if line41 == line56:\n line57 = 0. # line57 is amount taxed at AMT_CG_rt3\n linex2 = 0. # linex2 is amount taxed at AMT_CG_rt4\n else:\n line57 = line46 - line56\n linex1 = min(line48,\n max(0., AMT_CG_brk3[MARS - 1] - line44 - line45))\n linex2 = max(0., line54 - linex1)\n cgtax3 = line57 * AMT_CG_rt3\n cgtax4 = linex2 * AMT_CG_rt4\n if line38 == 0.:\n line61 = 0.\n else:\n line61 = 0.25 * max(0., line30 - line41 - line56 - line57 - linex2)\n line62 = line42 + cgtax1 + cgtax2 + cgtax3 + cgtax4 + line61\n line64 = min(line3163, line62)\n line31 = line64\n else: # if not completing Form 6251, Part III\n line31 = line3163\n # Form 6251, Part II bottom\n if f6251 == 1:\n line32 = e62900\n else:\n line32 = e07300\n line33 = line31 - line32\n c09600 = max(0., line33 - max(0., taxbc - e07300 - c05700))\n c05800 = taxbc + c09600\n return (c62100, c09600, c05800)\n\n\n@iterate_jit(nopython=True)\ndef NetInvIncTax(e00300, e00600, e02000, e26270, c01000,\n c00100, NIIT_thd, MARS, NIIT_PT_taxed, NIIT_rt, niit):\n \"\"\"\n Computes Net Investment Income Tax (NIIT) amount assuming that\n all annuity income is excluded from net investment income.\n \"\"\"\n modAGI = c00100 # no foreign earned income exclusion to add\n if not NIIT_PT_taxed:\n NII = max(0., e00300 + e00600 + c01000 + e02000 - e26270)\n else: # do not subtract e26270 from e02000\n NII = max(0., e00300 + e00600 + c01000 + e02000)\n niit = NIIT_rt * min(NII, max(0., modAGI - NIIT_thd[MARS - 1]))\n return niit\n\n\n@iterate_jit(nopython=True)\ndef F2441(MARS, earned_p, earned_s, f2441, CDCC_c, e32800,\n exact, c00100, CDCC_ps, CDCC_crt, c05800, e07300, c07180):\n \"\"\"\n Calculates Form 2441 child and dependent care expense credit, c07180.\n \"\"\"\n # credit for at most two cared-for individuals and for actual expenses\n max_credit = min(f2441, 2) * CDCC_c\n c32800 = max(0., min(e32800, max_credit))\n # credit is limited to minimum of individuals' earned income\n c32880 = earned_p # earned income of taxpayer\n if MARS == 2:\n c32890 = earned_s # earned income of spouse when present\n else:\n c32890 = earned_p\n c33000 = max(0., min(c32800, min(c32880, c32890)))\n # credit is limited by AGI-related fraction\n if exact == 1: # exact calculation as on tax forms\n tratio = math.ceil(max(((c00100 - CDCC_ps) / 2000.), 0.))\n c33200 = c33000 * 0.01 * max(20., CDCC_crt - min(15., tratio))\n else:\n c33200 = c33000 * 0.01 * max(20., CDCC_crt -\n max(((c00100 - CDCC_ps) / 2000.), 0.))\n # credit is limited by tax liability\n c07180 = min(max(0., c05800 - e07300), c33200)\n return c07180\n\n\n@JIT(nopython=True)\ndef EITCamount(basic_frac, phasein_rate, earnings, max_amount,\n phaseout_start, agi, phaseout_rate):\n \"\"\"\n Returns EITC amount given specified parameters.\n English parameter names are used in this function because the\n EITC formula is not available on IRS forms or in IRS instructions;\n the extensive IRS EITC look-up table does not reveal the formula.\n \"\"\"\n eitc = min((basic_frac * max_amount +\n (1.0 - basic_frac) * phasein_rate * earnings), max_amount)\n if earnings > phaseout_start or agi > phaseout_start:\n eitcx = max(0., (max_amount - phaseout_rate *\n max(0., max(earnings, agi) - phaseout_start)))\n eitc = min(eitc, eitcx)\n return eitc\n\n\n@iterate_jit(nopython=True)\ndef EITC(MARS, DSI, EIC, c00100, e00300, e00400, e00600, c01000,\n e02000, e26270, age_head, age_spouse, earned, earned_p, earned_s,\n EITC_ps, EITC_MinEligAge, EITC_MaxEligAge, EITC_ps_MarriedJ,\n EITC_rt, EITC_c, EITC_prt, EITC_basic_frac,\n EITC_InvestIncome_c, EITC_excess_InvestIncome_rt,\n EITC_indiv, EITC_sep_filers_elig,\n c59660):\n \"\"\"\n Computes EITC amount, c59660.\n \"\"\"\n # pylint: disable=too-many-branches\n if MARS != 2:\n eitc = EITCamount(EITC_basic_frac,\n EITC_rt[EIC], earned, EITC_c[EIC],\n EITC_ps[EIC], c00100, EITC_prt[EIC])\n if EIC == 0:\n # enforce age eligibility rule for those with no EITC-eligible\n # kids assuming that an unknown age_* value implies EITC age\n # eligibility\n h_age_elig = EITC_MinEligAge <= age_head <= EITC_MaxEligAge\n if (age_head == 0 or h_age_elig):\n c59660 = eitc\n else:\n c59660 = 0.\n else: # if EIC != 0\n c59660 = eitc\n\n if MARS == 2:\n po_start = EITC_ps[EIC] + EITC_ps_MarriedJ[EIC]\n if not EITC_indiv:\n # filing unit EITC rather than individual EITC\n eitc = EITCamount(EITC_basic_frac,\n EITC_rt[EIC], earned, EITC_c[EIC],\n po_start, c00100, EITC_prt[EIC])\n if EITC_indiv:\n # individual EITC rather than a filing-unit EITC\n eitc_p = EITCamount(EITC_basic_frac,\n EITC_rt[EIC], earned_p, EITC_c[EIC],\n po_start, earned_p, EITC_prt[EIC])\n eitc_s = EITCamount(EITC_basic_frac,\n EITC_rt[EIC], earned_s, EITC_c[EIC],\n po_start, earned_s, EITC_prt[EIC])\n eitc = eitc_p + eitc_s\n\n if EIC == 0:\n h_age_elig = EITC_MinEligAge <= age_head <= EITC_MaxEligAge\n s_age_elig = EITC_MinEligAge <= age_spouse <= EITC_MaxEligAge\n if (age_head == 0 or age_spouse == 0 or h_age_elig or s_age_elig):\n c59660 = eitc\n else:\n c59660 = 0.\n else:\n c59660 = eitc\n\n if (MARS == 3 and not EITC_sep_filers_elig) or DSI == 1:\n c59660 = 0.\n\n # reduce positive EITC if investment income exceeds ceiling\n if c59660 > 0.:\n invinc = (e00400 + e00300 + e00600 +\n max(0., c01000) + max(0., (e02000 - e26270)))\n if invinc > EITC_InvestIncome_c:\n eitc = (c59660 - EITC_excess_InvestIncome_rt *\n (invinc - EITC_InvestIncome_c))\n c59660 = max(0., eitc)\n return c59660\n\n\n@iterate_jit(nopython=True)\ndef RefundablePayrollTaxCredit(was_plus_sey_p, was_plus_sey_s,\n RPTC_c, RPTC_rt,\n rptc_p, rptc_s, rptc):\n \"\"\"\n Computes refundable payroll tax credit amounts.\n \"\"\"\n rptc_p = min(was_plus_sey_p * RPTC_rt, RPTC_c)\n rptc_s = min(was_plus_sey_s * RPTC_rt, RPTC_c)\n rptc = rptc_p + rptc_s\n return (rptc_p, rptc_s, rptc)\n\n\n@iterate_jit(nopython=True)\ndef ChildDepTaxCredit(n24, MARS, c00100, XTOT, num, c05800,\n e07260, CR_ResidentialEnergy_hc,\n e07300, CR_ForeignTax_hc,\n c07180,\n c07230,\n e07240, CR_RetirementSavings_hc,\n c07200,\n CTC_c, CTC_ps, CTC_prt, exact, ODC_c,\n CTC_c_under6_bonus, nu06,\n c07220, odc, codtc_limited):\n \"\"\"\n Computes amounts on \"Child Tax Credit and Credit for Other Dependents\n Worksheet\" in 2018 Publication 972, which pertain to these two\n nonrefundable tax credits.\n \"\"\"\n # Worksheet Part 1\n line1 = CTC_c * n24 + CTC_c_under6_bonus * nu06\n line2 = ODC_c * max(0, XTOT - n24 - num)\n line3 = line1 + line2\n modAGI = c00100 # no foreign earned income exclusion to add to AGI (line6)\n if line3 > 0. and modAGI > CTC_ps[MARS - 1]:\n excess = modAGI - CTC_ps[MARS - 1]\n if exact == 1: # exact calculation as on tax forms\n excess = 1000. * math.ceil(excess / 1000.)\n line10 = max(0., line3 - CTC_prt * excess)\n else:\n line10 = line3\n if line10 > 0.:\n # Worksheet Part 2\n line11 = c05800\n line12 = (e07260 * (1. - CR_ResidentialEnergy_hc) +\n e07300 * (1. - CR_ForeignTax_hc) +\n c07180 + # child & dependent care expense credit\n c07230 + # education credit\n e07240 * (1. - CR_RetirementSavings_hc) +\n c07200) # Schedule R credit\n line13 = line11 - line12\n line14 = 0.\n line15 = max(0., line13 - line14)\n line16 = min(line10, line15) # credit is capped by tax liability\n else:\n line16 = 0.\n # separate the CTC and ODTC amounts\n c07220 = 0. # nonrefundable CTC amount\n odc = 0. # nonrefundable ODTC amount\n if line16 > 0.:\n if line1 > 0.:\n c07220 = line16 * line1 / line3\n odc = max(0., line16 - c07220)\n # compute codtc_limited for use in AdditionalCTC function\n codtc_limited = max(0., line10 - line16)\n return (c07220, odc, codtc_limited)\n\n\n@iterate_jit(nopython=True)\ndef PersonalTaxCredit(MARS, c00100,\n II_credit, II_credit_ps, II_credit_prt,\n II_credit_nr, II_credit_nr_ps, II_credit_nr_prt,\n personal_refundable_credit,\n personal_nonrefundable_credit):\n \"\"\"\n Computes personal_refundable_credit and personal_nonrefundable_credit,\n neither of which are part of current-law policy.\n \"\"\"\n # calculate personal refundable credit amount with phase-out\n personal_refundable_credit = II_credit[MARS - 1]\n if II_credit_prt > 0. and c00100 > II_credit_ps[MARS - 1]:\n pout = II_credit_prt * (c00100 - II_credit_ps[MARS - 1])\n fully_phasedout = personal_refundable_credit - pout\n personal_refundable_credit = max(0., fully_phasedout)\n # calculate personal nonrefundable credit amount with phase-out\n personal_nonrefundable_credit = II_credit_nr[MARS - 1]\n if II_credit_nr_prt > 0. and c00100 > II_credit_nr_ps[MARS - 1]:\n pout = II_credit_nr_prt * (c00100 - II_credit_nr_ps[MARS - 1])\n fully_phasedout = personal_nonrefundable_credit - pout\n personal_nonrefundable_credit = max(0., fully_phasedout)\n return (personal_refundable_credit, personal_nonrefundable_credit)\n\n@iterate_jit(nopython=True)\ndef IRADCTaxCredit(e03150, e03300, IRADC_credit_c, IRADC_credit_rt, iradctc):\n \"\"\"\n Computes refundable retirement savings tax credit amount.\n \"\"\"\n # calculate refundable credit amount \n tot_retirement_contributions = e03150 + e03300\n if IRADC_credit_rt > 0.:\n iradctc = min(tot_retirement_contributions * IRADC_credit_rt, IRADC_credit_c)\n else:\n iradctc = 0.\n return (iradctc)\n\n@iterate_jit(nopython=True)\ndef FTHBTaxCredit(MARS, FTHB_credit, FTHB_credit_c, c00100,\n FTHB_credit_e, fthbc, fthb_credit_amt):\n \"\"\"\n Computes refundable first time homebuyers' tax credit amount.\n \"\"\"\n if FTHB_credit is True:\n # max credit\n fthbc = max(0., min(FTHB_credit_c, fthb_credit_amt))\n # eliminated based on agi\n positiveagiamt = max(c00100, 0.)\n fthb_max_agi = FTHB_credit_e[MARS - 1]\n if positiveagiamt <= fthb_max_agi:\n fthbc = fthbc\n else:\n fthbc = 0.\n return (fthbc)\n\n@iterate_jit(nopython=True)\ndef ICGTaxCredit(earned_p, earned_s, MARS, ICG_credit_c, ICG_credit_em,\n ICG_credit_rt, ICG_credit_thd, icg_expense, c05800, e07300,\n icgtc):\n \"\"\"\n Computes nonrefundable informal care giver tax credit.\n \"\"\"\n # not reflected in current law and records modified with imputation\n # earned income of taxpayer\n icg32880 = earned_p # earned income of taxpayer\n if MARS == 2:\n icg32890 = earned_s # earned income of spouse when present\n else:\n icg32890 = earned_p\n icg33000 = min(icg32880, icg32890)\n if icg33000 > ICG_credit_thd:\n # credit for actual expenses\n icg_max_credit = (icg_expense - ICG_credit_em) * ICG_credit_rt\n icg_credit = max(0., min(icg_max_credit, ICG_credit_c))\n # credit is limited to minimum of individuals' earned income\n icg_credit = max(0., min(icg_credit, icg33000))\n # credit is limited by tax liability\n icgtc = min(max(0., c05800 - e07300), icg_credit)\n else:\n icgtc = 0.\n return icgtc\n\n@iterate_jit(nopython=True)\ndef IRATaxCredit(earned_p, earned_s, MARS, AutoIRA_credit, ira_credit,\n c05800, e07300, iratc):\n \"\"\"\n Computes nonrefundable automatic enrollment in IRA tax credit.\n \"\"\"\n # not reflected in current law and records modified with imputation\n if AutoIRA_credit is True:\n iratc = max(0., ira_credit)\n else:\n iratc = 0.\n return iratc\n\n@iterate_jit(nopython=True)\ndef EVTaxCredit(EV_credit, ev_credit_amt, EV_credit_c, c00100, EV_credit_ps, MARS,\n EV_credit_prt, evtc):\n \"\"\"\n Computes nonrefundable full-electric vehicle tax credit.\n \"\"\"\n if EV_credit is True:\n # not reflected in current law and records modified with imputation\n elecv_credit = max(0., min(ev_credit_amt, EV_credit_c))\n # phaseout based on agi\n posevagi = max(c00100, 0.)\n ev_max = EV_credit_ps[MARS - 1]\n if posevagi < ev_max:\n evtc = elecv_credit\n else:\n evtc_reduced = max(0., evtc - EV_credit_prt * (posevagi - ev_max))\n evtc = min(evtc, evtc_reduced)\n return evtc\n\n@iterate_jit(nopython=True)\ndef AmOppCreditParts(exact, e87521, num, c00100, CR_AmOppRefundable_hc,\n CR_AmOppNonRefundable_hc, c10960, c87668):\n \"\"\"\n Applies a phaseout to the Form 8863, line 1, American Opportunity Credit\n amount, e87521, and then applies the 0.4 refundable rate.\n Logic corresponds to Form 8863, Part I.\n\n Notes\n -----\n Tax Law Parameters that are not parameterized:\n\n 90000 : American Opportunity Credit phaseout income base\n\n 10000 : American Opportunity Credit phaseout income range length\n\n 1/1000 : American Opportunity Credit phaseout rate\n\n 0.4 : American Opportunity Credit refundable rate\n\n Parameters\n ----------\n exact : whether or not to do rounding of phaseout fraction\n\n e87521 : total tentative American Opportunity Credit for all students,\n Form 8863, line 1\n\n num : number of people filing jointly\n\n c00100 : AGI\n\n CR_AmOppRefundable_hc: haircut for the refundable portion of the\n American Opportunity Credit\n\n CR_AmOppNonRefundable_hc: haircut for the nonrefundable portion of the\n American Opportunity Credit\n\n Returns\n -------\n c10960 : Refundable part of American Opportunity Credit\n\n c87668 : Tentative nonrefundable part of American Opportunity Credit\n \"\"\"\n if e87521 > 0.:\n c87658 = max(0., 90000. * num - c00100)\n c87660 = 10000. * num\n if exact == 1: # exact calculation as on tax forms\n c87662 = 1000. * min(1., round(c87658 / c87660, 3))\n else:\n c87662 = 1000. * min(1., c87658 / c87660)\n c87664 = c87662 * e87521 / 1000.\n c10960 = 0.4 * c87664 * (1. - CR_AmOppRefundable_hc)\n c87668 = c87664 - c10960 * (1. - CR_AmOppNonRefundable_hc)\n else:\n c10960 = 0.\n c87668 = 0.\n return (c10960, c87668)\n\n\n@iterate_jit(nopython=True)\ndef SchR(age_head, age_spouse, MARS, c00100,\n c05800, e07300, c07180, e02400, c02500, e01500, e01700, CR_SchR_hc,\n c07200):\n \"\"\"\n Calculates Schedule R credit for the elderly and the disabled, c07200.\n\n Note that no Schedule R policy parameters are inflation indexed.\n\n Note that all Schedule R policy parameters are hard-coded, and therefore,\n are not able to be changed using Policy class parameters.\n\n Note that the CR_SchR_hc policy parameter allows the user to eliminate\n or reduce total Schedule R credits.\n \"\"\"\n if age_head >= 65 or (MARS == 2 and age_spouse >= 65):\n # calculate credit assuming nobody is disabled (so line12 = line10)\n if MARS == 2:\n if age_head >= 65 and age_spouse >= 65:\n schr12 = 7500.\n else:\n schr12 = 5000.\n schr15 = 10000.\n elif MARS == 3:\n schr12 = 3750.\n schr15 = 5000.\n elif MARS in (1, 4):\n schr12 = 5000.\n schr15 = 7500.\n else:\n schr12 = 0.\n schr15 = 0.\n # nontaxable portion of OASDI benefits, line 13a\n schr13a = max(0., e02400 - c02500)\n # nontaxable portion of pension benefits, line 13b\n # NOTE: the following approximation (required because of inadequate IRS\n # data) will be accurate if all pensions are partially taxable\n # or if all pensions are fully taxable. But if a filing unit\n # receives at least one partially taxable pension and at least\n # one fully taxable pension, then the approximation in the\n # following line is not exactly correct.\n schr13b = max(0., e01500 - e01700)\n schr13c = schr13a + schr13b\n schr16 = max(0., c00100 - schr15)\n schr17 = 0.5 * schr16\n schr18 = schr13c + schr17\n schr19 = max(0., schr12 - schr18)\n schr20 = 0.15 * schr19\n schr21 = max(0., (c05800 - e07300 - c07180))\n c07200 = min(schr20, schr21) * (1. - CR_SchR_hc)\n else: # if not calculating Schedule R credit\n c07200 = 0.\n return c07200\n\n\n@iterate_jit(nopython=True)\ndef EducationTaxCredit(exact, e87530, MARS, c00100, num, c05800,\n e07300, c07180, c07200, c87668,\n LLC_Expense_c, ETC_pe_Single, ETC_pe_Married,\n CR_Education_hc,\n c07230):\n \"\"\"\n Computes Education Tax Credits (Form 8863) nonrefundable amount, c07230.\n Logic corresponds to Form 8863, Part II.\n\n Notes\n -----\n Tax Law Parameters that are not parameterized:\n\n 0.2 : Lifetime Learning Credit ratio against expense\n\n Tax Law Parameters that are parameterized:\n\n LLC_Expense_c : Lifetime Learning Credit expense limit\n\n ETC_pe_Married : Education Tax Credit phaseout end for married\n\n ETC_pe_Single : Education Tax Credit phaseout end for single\n\n Taxpayer Charateristics:\n\n exact : whether or not to do rounding of phaseout fraction\n\n e87530 : Lifetime Learning Credit total qualified expenses,\n Form 8863, line 10\n\n e07300 : Foreign tax credit - Form 1116\n\n c07180 : Child/dependent care expense credit - Form 2441\n\n c07200 : Schedule R credit\n\n Returns\n -------\n c07230 : Education Tax Credits (Form 8863) nonrefundable amount\n \"\"\"\n c87560 = 0.2 * min(e87530, LLC_Expense_c)\n if MARS == 2:\n c87570 = ETC_pe_Married * 1000.\n else:\n c87570 = ETC_pe_Single * 1000.\n c87590 = max(0., c87570 - c00100)\n c87600 = 10000. * num\n if exact == 1: # exact calculation as on tax forms\n c87610 = min(1., round(c87590 / c87600, 3))\n else:\n c87610 = min(1., c87590 / c87600)\n c87620 = c87560 * c87610\n xline4 = max(0., c05800 - (e07300 + c07180 + c07200))\n xline5 = min(c87620, xline4)\n xline9 = max(0., c05800 - (e07300 + c07180 + c07200 + xline5))\n xline10 = min(c87668, xline9)\n c87680 = xline5 + xline10\n c07230 = c87680 * (1. - CR_Education_hc)\n return c07230\n\n\n@iterate_jit(nopython=True)\ndef CharityCredit(e19800, e20100, c00100, CR_Charity_rt, CR_Charity_f,\n CR_Charity_frt, MARS, charity_credit):\n \"\"\"\n Computes nonrefundable charity credit, charity_credit.\n This credit is not part of current-law policy.\n \"\"\"\n total_charity = e19800 + e20100\n floor = max(CR_Charity_frt * c00100, CR_Charity_f[MARS - 1])\n charity_cr_floored = max(total_charity - floor, 0)\n charity_credit = CR_Charity_rt * (charity_cr_floored)\n return charity_credit\n\n\n@iterate_jit(nopython=True)\ndef NonrefundableCredits(c05800, e07240, e07260, e07300, e07400,\n e07600, p08000, odc,\n personal_nonrefundable_credit, icgtc, iratc, evtc,\n CR_RetirementSavings_hc, CR_ForeignTax_hc,\n CR_ResidentialEnergy_hc, CR_GeneralBusiness_hc,\n CR_MinimumTax_hc, CR_OtherCredits_hc, charity_credit,\n c07180, c07200, c07220, c07230, c07240,\n c07260, c07300, c07400, c07600, c08000):\n \"\"\"\n NonRefundableCredits function sequentially limits credits to tax liability.\n\n Parameters\n ----------\n CR_RetirementSavings_hc: Retirement savings credit haircut\n CR_ForeignTax_hc: Foreign tax credit haircut\n CR_ResidentialEnergy_hc: Residential energy credit haircut\n CR_GeneralBusiness_hc: General business credit haircut\n CR_MinimumTax_hc: Minimum tax credit haircut\n CR_OtherCredits_hc: Other credits haircut\n \"\"\"\n # limit tax credits to tax liability in order they are on 2015 1040 form\n avail = c05800\n # Foreign tax credit - Form 1116\n c07300 = min(e07300 * (1. - CR_ForeignTax_hc), avail)\n avail = avail - c07300\n # Child & dependent care expense credit\n c07180 = min(c07180, avail)\n avail = avail - c07180\n # Education tax credit\n c07230 = min(c07230, avail)\n avail = avail - c07230\n # Retirement savings credit - Form 8880\n c07240 = min(e07240 * (1. - CR_RetirementSavings_hc), avail)\n avail = avail - c07240\n # Child tax credit\n c07220 = min(c07220, avail)\n avail = avail - c07220\n # Other dependent credit\n odc = min(odc, avail)\n avail = avail - odc\n # Residential energy credit - Form 5695\n c07260 = min(e07260 * (1. - CR_ResidentialEnergy_hc), avail)\n avail = avail - c07260\n # General business credit - Form 3800\n c07400 = min(e07400 * (1. - CR_GeneralBusiness_hc), avail)\n avail = avail - c07400\n # Prior year minimum tax credit - Form 8801\n c07600 = min(e07600 * (1. - CR_MinimumTax_hc), avail)\n avail = avail - c07600\n # Schedule R credit\n c07200 = min(c07200, avail)\n avail = avail - c07200\n # Other credits\n c08000 = min(p08000 * (1. - CR_OtherCredits_hc), avail)\n avail = avail - c08000\n # Charity credit\n charity_credit = min(charity_credit, avail)\n avail = avail - charity_credit\n # Personal nonrefundable credit\n personal_nonrefundable_credit = min(personal_nonrefundable_credit, avail)\n avail = avail - personal_nonrefundable_credit\n # ICG credit\n icgtc = min(icgtc, avail)\n avail = avail - icgtc\n # IRA credit\n iratc = min(iratc, avail)\n avail = avail - iratc\n # EV credit\n evtc = min(evtc, avail)\n avail = avail - evtc \n return (c07180, c07200, c07220, c07230, c07240, odc,\n c07260, c07300, c07400, c07600, c08000, charity_credit,\n personal_nonrefundable_credit, icgtc, iratc, evtc)\n\n\n@iterate_jit(nopython=True)\ndef AdditionalCTC(codtc_limited, ACTC_c, n24, earned, ACTC_Income_thd,\n ACTC_rt, nu06, ACTC_rt_bonus_under6family, ACTC_ChildNum,\n ptax_was, c03260, e09800, c59660, e11200,\n c11070):\n \"\"\"\n Calculates refundable Additional Child Tax Credit (ACTC), c11070,\n following 2018 Form 8812 logic.\n \"\"\"\n # Part I\n line3 = codtc_limited\n line4 = ACTC_c * n24\n c11070 = 0. # line15\n if line3 > 0. and line4 > 0.:\n line5 = min(line3, line4)\n line7 = max(0., earned - ACTC_Income_thd)\n # accommodate ACTC rate bonus for families with children under 5\n if nu06 == 0:\n ACTC_rate = ACTC_rt\n else:\n ACTC_rate = ACTC_rt + ACTC_rt_bonus_under6family\n line8 = ACTC_rate * line7\n if n24 < ACTC_ChildNum:\n if line8 > 0.:\n c11070 = min(line5, line8)\n else: # if n24 >= ACTC_ChildNum\n if line8 >= line5:\n c11070 = line5\n else: # complete Part II\n line9 = 0.5 * ptax_was\n line10 = c03260 + e09800\n line11 = line9 + line10\n line12 = c59660 + e11200\n line13 = max(0., line11 - line12)\n line14 = max(line8, line13)\n c11070 = min(line5, line14)\n return c11070\n\n\n@iterate_jit(nopython=True)\ndef C1040(c05800, c07180, c07200, c07220, c07230, c07240, c07260, c07300,\n c07400, c07600, c08000, e09700, e09800, e09900, niit, othertaxes,\n c07100, c09200, odc, charity_credit,\n personal_nonrefundable_credit, icgtc, iratc, evtc):\n \"\"\"\n Computes total used nonrefundable credits, c07100, othertaxes, and\n income tax before refundable credits, c09200.\n \"\"\"\n # total used nonrefundable credits (as computed in NonrefundableCredits)\n c07100 = (c07180 + c07200 + c07600 + c07300 + c07400 + c07220 + c08000 +\n c07230 + c07240 + c07260 + odc + charity_credit +\n personal_nonrefundable_credit + icgtc + iratc + evtc)\n # tax after credits (2016 Form 1040, line 56)\n tax_net_nonrefundable_credits = max(0., c05800 - c07100)\n # tax (including othertaxes) before refundable credits\n othertaxes = e09700 + e09800 + e09900 + niit\n c09200 = othertaxes + tax_net_nonrefundable_credits\n return (c07100, othertaxes, c09200)\n\n\n@iterate_jit(nopython=True)\ndef CTC_new(CTC_new_c, CTC_new_rt, CTC_new_c_under6_bonus,\n CTC_new_ps, CTC_new_prt, CTC_new_for_all,\n CTC_new_refund_limited, CTC_new_refund_limit_payroll_rt,\n CTC_new_refund_limited_all_payroll, payrolltax,\n n24, nu06, c00100, MARS, ptax_oasdi, c09200,\n ctc_new):\n \"\"\"\n Computes new refundable child tax credit using specified parameters.\n \"\"\"\n if n24 > 0:\n posagi = max(c00100, 0.)\n ctc_new = CTC_new_c * n24 + CTC_new_c_under6_bonus * nu06\n if not CTC_new_for_all:\n ctc_new = min(CTC_new_rt * posagi, ctc_new)\n ymax = CTC_new_ps[MARS - 1]\n if posagi > ymax:\n ctc_new_reduced = max(0.,\n ctc_new - CTC_new_prt * (posagi - ymax))\n ctc_new = min(ctc_new, ctc_new_reduced)\n if ctc_new > 0. and CTC_new_refund_limited:\n refund_new = max(0., ctc_new - c09200)\n if not CTC_new_refund_limited_all_payroll:\n limit_new = CTC_new_refund_limit_payroll_rt * ptax_oasdi\n if CTC_new_refund_limited_all_payroll:\n limit_new = CTC_new_refund_limit_payroll_rt * payrolltax\n limited_new = max(0., refund_new - limit_new)\n ctc_new = max(0., ctc_new - limited_new)\n else:\n ctc_new = 0.\n return ctc_new\n\n@iterate_jit(nopython=True)\ndef CDCC_new(CDCC_new_c, CDCC_new_rt, CDCC_new_ps, CDCC_new_pe, CDCC_new_prt, cdcc_new,\n MARS, f2441, e32800, earned_s, earned_p, c05800, e07300, c00100):\n \"\"\"\n Calculates new refundable child and dependent care expense credit, cdcc_new.\n \"\"\"\n # credit for at most two cared-for individuals and for actual expenses\n cdcc_new_max_credit = min(f2441, 2) * CDCC_new_c\n cdcc_new_32800 = max(0., min(e32800 * CDCC_new_rt, cdcc_new_max_credit))\n # credit is limited to minimum of individuals' earned income\n cdcc_new_32880 = earned_p # earned income of taxpayer\n if MARS == 2:\n cdcc_new_32890 = earned_s # earned income of spouse when present\n else:\n cdcc_new_32890 = earned_p\n cdcc_new_33000 = max(0., min(cdcc_new_32800, min(cdcc_new_32880, cdcc_new_32890)))\n # credit is limited by tax liability\n cdcc_new = min(max(0., c05800 - e07300), cdcc_new_33000)\n # phaseout based on agi\n positiveagi = max(c00100, 0.)\n cdcc_min = CDCC_new_ps[MARS - 1]\n cdcc_max = CDCC_new_pe[MARS - 1]\n if positiveagi < cdcc_min:\n cdcc_new = cdcc_new\n elif positiveagi < cdcc_max:\n cdcc_new_reduced = max(0., cdcc_new - CDCC_new_prt * (positiveagi - cdcc_min))\n cdcc_new = min(cdcc_new, cdcc_new_reduced)\n else:\n cdcc_new = 0.\n return cdcc_new\n\n@iterate_jit(nopython=True)\ndef IITAX(c59660, c11070, c10960, personal_refundable_credit, ctc_new, rptc,\n c09200, payrolltax,\n eitc, refund, iitax, combined, iradctc, fthbc, cdcc_new,\n business_burden, estate_burden, Business_tax_combined):\n \"\"\"\n Computes final taxes.\n \"\"\"\n eitc = c59660\n refund = (eitc + c11070 + c10960 +\n personal_refundable_credit + ctc_new + rptc + iradctc + fthbc + cdcc_new)\n iitax = c09200 - refund\n if Business_tax_combined is True:\n combined = iitax + payrolltax + business_burden + estate_burden\n else:\n combined = iitax + payrolltax\n return (eitc, refund, iitax, combined)\n\n\n@JIT(nopython=True)\ndef Taxes(income, MARS, tbrk_base,\n rate1, rate2, rate3, rate4, rate5, rate6, rate7, rate8,\n tbrk1, tbrk2, tbrk3, tbrk4, tbrk5, tbrk6, tbrk7):\n \"\"\"\n Taxes function returns tax amount given the progressive tax rate\n schedule specified by the rate* and (upper) tbrk* parameters and\n given income, filing status (MARS), and tax bracket base (tbrk_base).\n \"\"\"\n if tbrk_base > 0.:\n brk1 = max(tbrk1[MARS - 1] - tbrk_base, 0.)\n brk2 = max(tbrk2[MARS - 1] - tbrk_base, 0.)\n brk3 = max(tbrk3[MARS - 1] - tbrk_base, 0.)\n brk4 = max(tbrk4[MARS - 1] - tbrk_base, 0.)\n brk5 = max(tbrk5[MARS - 1] - tbrk_base, 0.)\n brk6 = max(tbrk6[MARS - 1] - tbrk_base, 0.)\n brk7 = max(tbrk7[MARS - 1] - tbrk_base, 0.)\n else:\n brk1 = tbrk1[MARS - 1]\n brk2 = tbrk2[MARS - 1]\n brk3 = tbrk3[MARS - 1]\n brk4 = tbrk4[MARS - 1]\n brk5 = tbrk5[MARS - 1]\n brk6 = tbrk6[MARS - 1]\n brk7 = tbrk7[MARS - 1]\n return (rate1 * min(income, brk1) +\n rate2 * min(brk2 - brk1, max(0., income - brk1)) +\n rate3 * min(brk3 - brk2, max(0., income - brk2)) +\n rate4 * min(brk4 - brk3, max(0., income - brk3)) +\n rate5 * min(brk5 - brk4, max(0., income - brk4)) +\n rate6 * min(brk6 - brk5, max(0., income - brk5)) +\n rate7 * min(brk7 - brk6, max(0., income - brk6)) +\n rate8 * max(0., income - brk7))\n\n\ndef ComputeBenefit(calc, ID_switch):\n \"\"\"\n Calculates the value of the benefits accrued from itemizing.\n \"\"\"\n # compute income tax liability with no itemized deductions allowed for\n # the types of itemized deductions covered under the BenefitSurtax\n no_ID_calc = copy.deepcopy(calc)\n if ID_switch[0]:\n no_ID_calc.policy_param('ID_Medical_hc', [1.])\n if ID_switch[1]:\n no_ID_calc.policy_param('ID_StateLocalTax_hc', [1.])\n if ID_switch[2]:\n no_ID_calc.policy_param('ID_RealEstate_hc', [1.])\n if ID_switch[3]:\n no_ID_calc.policy_param('ID_Casualty_hc', [1.])\n if ID_switch[4]:\n no_ID_calc.policy_param('ID_Miscellaneous_hc', [1.])\n if ID_switch[5]:\n no_ID_calc.policy_param('ID_InterestPaid_hc', [1.])\n if ID_switch[6]:\n no_ID_calc.policy_param('ID_Charity_hc', [1.])\n no_ID_calc._calc_one_year() # pylint: disable=protected-access\n diff_iitax = no_ID_calc.array('iitax') - calc.array('iitax')\n benefit = np.where(diff_iitax > 0., diff_iitax, 0.)\n return benefit\n\n\ndef BenefitSurtax(calc):\n \"\"\"\n Computes itemized-deduction-benefit surtax and adds the surtax amount\n to income tax, combined tax, and surtax liabilities.\n \"\"\"\n if calc.policy_param('ID_BenefitSurtax_crt') != 1.:\n ben = ComputeBenefit(calc,\n calc.policy_param('ID_BenefitSurtax_Switch'))\n agi = calc.array('c00100')\n ben_deduct = calc.policy_param('ID_BenefitSurtax_crt') * agi\n ben_exempt_array = calc.policy_param('ID_BenefitSurtax_em')\n ben_exempt = ben_exempt_array[calc.array('MARS') - 1]\n ben_dedem = ben_deduct + ben_exempt\n ben_surtax = (calc.policy_param('ID_BenefitSurtax_trt') *\n np.where(ben > ben_dedem, ben - ben_dedem, 0.))\n # add ben_surtax to income & combined taxes and to surtax subtotal\n calc.incarray('iitax', ben_surtax)\n calc.incarray('combined', ben_surtax)\n calc.incarray('surtax', ben_surtax)\n\n\ndef BenefitLimitation(calc):\n \"\"\"\n Limits the benefits of select itemized deductions to a fraction of\n deductible expenses.\n \"\"\"\n if calc.policy_param('ID_BenefitCap_rt') != 1.:\n benefit = ComputeBenefit(calc,\n calc.policy_param('ID_BenefitCap_Switch'))\n # Calculate total deductible expenses under the cap\n deduct_exps = 0.\n if calc.policy_param('ID_BenefitCap_Switch')[0]: # medical\n deduct_exps += calc.array('c17000')\n if calc.policy_param('ID_BenefitCap_Switch')[1]: # statelocal\n one_minus_hc = 1. - calc.policy_param('ID_StateLocalTax_hc')\n deduct_exps += (one_minus_hc *\n np.maximum(calc.array('e18400_capped'), 0.))\n if calc.policy_param('ID_BenefitCap_Switch')[2]: # realestate\n one_minus_hc = 1. - calc.policy_param('ID_RealEstate_hc')\n deduct_exps += one_minus_hc * calc.array('e18500_capped')\n if calc.policy_param('ID_BenefitCap_Switch')[3]: # casualty\n deduct_exps += calc.array('c20500')\n if calc.policy_param('ID_BenefitCap_Switch')[4]: # misc\n deduct_exps += calc.array('c20800')\n if calc.policy_param('ID_BenefitCap_Switch')[5]: # interest\n deduct_exps += calc.array('c19200')\n if calc.policy_param('ID_BenefitCap_Switch')[6]: # charity\n deduct_exps += calc.array('c19700')\n # Calculate cap value for itemized deductions\n benefit_limit = deduct_exps * calc.policy_param('ID_BenefitCap_rt')\n # Add the difference between the actual benefit and capped benefit\n # to income tax and combined tax liabilities.\n excess_benefit = np.maximum(benefit - benefit_limit, 0)\n calc.incarray('iitax', excess_benefit)\n calc.incarray('surtax', excess_benefit)\n calc.incarray('combined', excess_benefit)\n\n\n@iterate_jit(nopython=True)\ndef FairShareTax(c00100, MARS, ptax_was, setax, ptax_amc,\n FST_AGI_trt, FST_AGI_thd_lo, FST_AGI_thd_hi,\n fstax, iitax, combined, surtax):\n \"\"\"\n Computes Fair Share Tax, or \"Buffet Rule\", types of reforms.\n\n Taxpayer Characteristics\n ------------------------\n\n c00100 : AGI\n\n MARS : filing (marital) status\n\n ptax_was : payroll tax on wages and salaries\n\n setax : self-employment tax\n\n ptax_amc : Additional Medicare Tax on high earnings\n\n Returns\n -------\n\n fstax : Fair Share Tax amount\n\n iitax : individual income tax augmented by fstax\n\n combined : individual income tax plus payroll taxes augmented by fstax\n\n surtax : individual income tax subtotal augmented by fstax\n \"\"\"\n if FST_AGI_trt > 0. and c00100 >= FST_AGI_thd_lo[MARS - 1]:\n employee_share = 0.5 * ptax_was + 0.5 * setax + ptax_amc\n fstax = max(c00100 * FST_AGI_trt - iitax - employee_share, 0.)\n thd_gap = max(FST_AGI_thd_hi[MARS - 1] - FST_AGI_thd_lo[MARS - 1], 0.)\n if thd_gap > 0. and c00100 < FST_AGI_thd_hi[MARS - 1]:\n fstax *= (c00100 - FST_AGI_thd_lo[MARS - 1]) / thd_gap\n iitax += fstax\n combined += fstax\n surtax += fstax\n else:\n fstax = 0.\n return (fstax, iitax, combined, surtax)\n\n\n@iterate_jit(nopython=True)\ndef LumpSumTax(DSI, num, XTOT,\n LST,\n lumpsum_tax, combined):\n \"\"\"\n Computes lump-sum tax and add it to combined taxes.\n \"\"\"\n if LST == 0.0 or DSI == 1:\n lumpsum_tax = 0.\n else:\n lumpsum_tax = LST * max(num, XTOT)\n combined += lumpsum_tax\n return (lumpsum_tax, combined)\n\n\n@iterate_jit(nopython=True)\ndef ExpandIncome(e00200, pencon_p, pencon_s, e00300, e00400, e00600,\n e00700, e00800, e00900, e01100, e01200, e01400, e01500,\n e02000, e02100, p22250, p23250, cmbtp, ptax_was,\n benefit_value_total, expanded_income):\n \"\"\"\n Calculates expanded_income from component income types.\n \"\"\"\n expanded_income = (\n e00200 + # wage and salary income net of DC pension contributions\n pencon_p + # tax-advantaged DC pension contributions for taxpayer\n pencon_s + # tax-advantaged DC pension contributions for spouse\n e00300 + # taxable interest income\n e00400 + # non-taxable interest income\n e00600 + # dividends\n e00700 + # state and local income tax refunds\n e00800 + # alimony received\n e00900 + # Sch C business net income/loss\n e01100 + # capital gain distributions not reported on Sch D\n e01200 + # Form 4797 other net gain/loss\n e01400 + # taxable IRA distributions\n e01500 + # total pension & annuity income (including DB-plan benefits)\n e02000 + # Sch E total rental, ..., partnership, S-corp income/loss\n e02100 + # Sch F farm net income/loss\n p22250 + # Sch D: net short-term capital gain/loss\n p23250 + # Sch D: net long-term capital gain/loss\n cmbtp + # other AMT taxable income items from Form 6251\n 0.5 * ptax_was + # employer share of FICA taxes on wages/salaries\n benefit_value_total # consumption value of all benefits received;\n # see the BenefitPrograms function in this file for details on\n # exactly how the benefit_value_total variable is computed\n )\n return expanded_income\n\n\n@iterate_jit(nopython=True)\ndef AfterTaxIncome(combined, expanded_income, aftertax_income,\n Business_tax_expinc, corp_taxliab):\n \"\"\"\n Calculates after-tax expanded income.\n\n Parameters\n ----------\n combined: combined tax liability\n expanded_income: expanded income\n corp_taxliab: imputed corporate tax liability\n\n Returns\n -------\n aftertax_income: expanded_income minus combined\n \"\"\"\n if Business_tax_expinc is True:\n expanded_income = expanded_income + corp_taxliab\n else:\n expanded_income = expanded_income\n aftertax_income = expanded_income - combined\n return aftertax_income\n"
] | [
[
"numpy.maximum",
"numpy.where",
"numpy.zeros"
]
] |
mpwiesner/sims_GCRCatSimInterface | [
"831e78ec8eb610983768d4657fbff9744cb17249"
] | [
"bin.src/generate_lensed_hosts_agn.py"
] | [
"import numpy as np\r\nimport os\r\nimport argparse\r\nimport pylab as pl\r\nimport subprocess as sp\r\nimport astropy.io.fits as pyfits\r\nimport pandas as pd\r\nimport scipy.special as ss\r\nimport om10_lensing_equations as ole\r\n\r\ndata_dir = os.path.join(os.environ['SIMS_GCRCATSIMINTERFACE_DIR'], 'data')\r\ntwinkles_data_dir = os.path.join(os.environ['TWINKLES_DIR'], 'data')\r\noutdefault = os.path.join(data_dir,'outputs')\r\n\r\nparser = argparse.ArgumentParser(description='The location of the desired output directory')\r\nparser.add_argument(\"--outdir\", dest='outdir1', type=str, default = outdefault,\r\n help='Output location for FITS stamps')\r\nargs = parser.parse_args()\r\noutdir = args.outdir1\r\n\r\ndef load_in_data_agn():\r\n\r\n \"\"\"\r\n Reads in catalogs of host galaxy bulge and disk as well as om10 lenses\r\n \"\"\"\r\n agn_host_bulge = pd.read_csv(os.path.join(data_dir,'agn_host_bulge.csv.gz'))\r\n agn_host_disk = pd.read_csv(os.path.join(data_dir, 'agn_host_disk.csv.gz'))\r\n\r\n idx = agn_host_bulge['image_number'] == 0\r\n ahb_purged = agn_host_bulge[:][idx]\r\n ahd_purged = agn_host_disk[:][idx]\r\n\r\n lens_list = pyfits.open(os.path.join(twinkles_data_dir,\r\n 'twinkles_lenses_v2.fits'))\r\n\r\n return lens_list, ahb_purged, ahd_purged\r\n\r\n\r\ndef create_cats_agns(index, hdu_list, ahb_list, ahd_list):\r\n \"\"\"\r\n Takes input catalogs and isolates lensing parameters as well as ra and dec of lens \r\n\r\n Parameters:\r\n -----------\r\n index: int\r\n Index for pandas data frame\r\n hdu_list:\r\n row of data frame that contains lens parameters\r\n ahb_list:\r\n row of data frame that contains lens galaxy parameters for the galactic bulge\r\n ahd_list:\r\n row of data frame that contains lens galaxy parameters for the galactic disk \"\"\"\r\n\r\n twinkles_ID = ahd['twinkles_system'][index]\r\n UID_lens = ahd['uniqueId_lens'][index]\r\n Ra_lens = ahd['raPhoSim_lens'][index]\r\n Dec_lens = ahd['decPhoSim_lens'][index]\r\n\r\n idx = hdu_list[1].data['twinklesId'] == twinkles_ID\r\n lid = hdu_list[1].data['LENSID'][idx][0]\r\n xl1 = 0.0\r\n xl2 = 0.0\r\n vd = hdu_list[1].data['VELDISP'][idx][0]\r\n zd = hdu_list[1].data['ZLENS'][idx][0]\r\n ql = 1.0 - hdu_list[1].data['ELLIP'][idx][0]\r\n phi= hdu_list[1].data['PHIE'][idx][0]\r\n\r\n ys1 = hdu_list[1].data['XSRC'][idx][0]\r\n ys2 = hdu_list[1].data['YSRC'][idx][0]\r\n\r\n ext_shr = hdu_list[1].data['GAMMA'][idx][0]\r\n ext_phi = hdu_list[1].data['PHIG'][idx][0]\r\n\r\n ximg = hdu_list[1].data['XIMG'][idx][0]\r\n yimg = hdu_list[1].data['YIMG'][idx][0]\r\n \r\n\r\n #----------------------------------------------------------------------------\r\n lens_cat = {'xl1' : xl1,\r\n 'xl2' : xl2,\r\n 'ql' : ql,\r\n 'vd' : vd,\r\n 'phl' : phi,\r\n 'gamma' : ext_shr,\r\n 'phg' : ext_phi,\r\n 'zl' : zd,\r\n 'ximg' : ximg,\r\n 'yimg' : yimg,\r\n 'twinklesid' : twinkles_ID,\r\n 'lensid' : lid,\r\n 'index' : index,\r\n 'UID_lens' : UID_lens,\r\n 'Ra_lens' : Ra_lens,\r\n 'Dec_lens' : Dec_lens}\r\n \r\n #----------------------------------------------------------------------------\r\n mag_src_b = ahb_list['phosimMagNorm'][index]\r\n qs_b = ahb_list['minorAxis'][index]/ahb_list['majorAxis'][index]\r\n Reff_src_b = np.sqrt(ahb_list['minorAxis'][index]*ahb_list['majorAxis'][index])\r\n phs_b = ahb_list['positionAngle'][index]\r\n ns_b = ahb_list['sindex'][index]\r\n zs_b = ahb_list['redshift'][index]\r\n sed_src_b = ahb_list['sedFilepath'][index]\r\n \r\n srcsP_bulge = {'ys1' : ys1,\r\n 'ys2' : ys2,\r\n 'mag_src' : mag_src_b,\r\n 'Reff_src' : Reff_src_b,\r\n 'qs' : qs_b,\r\n 'phs' : phs_b,\r\n 'ns' : ns_b,\r\n 'zs' : zs_b,\r\n 'sed_src' : sed_src_b, \r\n 'components' : 'bulge'}\r\n \r\n #----------------------------------------------------------------------------\r\n mag_src_d = ahd_list['phosimMagNorm'][index]\r\n qs_d = ahd_list['minorAxis'][index]/ahd_list['majorAxis'][index]\r\n Reff_src_d = np.sqrt(ahd_list['minorAxis'][index]*ahd_list['majorAxis'][index])\r\n phs_d = ahd_list['positionAngle'][index]\r\n ns_d = ahd_list['sindex'][index]\r\n zs_d = ahd_list['redshift'][index]\r\n sed_src_d = ahd_list['sedFilepath'][index]\r\n\r\n srcsP_disk = {'ys1' : ys1,\r\n 'ys2' : ys2,\r\n 'mag_src' : mag_src_d,\r\n 'Reff_src' : Reff_src_d,\r\n 'qs' : qs_d,\r\n 'phs' : phs_d,\r\n 'ns' : ns_d,\r\n 'zs' : zs_d,\r\n 'sed_src' : sed_src_d,\r\n 'components' : 'disk'}\r\n \r\n #----------------------------------------------------------------------------\r\n\r\n return lens_cat, srcsP_bulge, srcsP_disk\r\n\r\n\r\ndef lensed_sersic_2d(xi1, xi2, yi1, yi2, source_cat, lens_cat):\r\n #Defines a magnitude of lensed host galaxy using 2d Sersic profile\t\r\n #----------------------------------------------------------------------\r\n ysc1 = source_cat['ys1'] # x position of the source, arcseconds\r\n ysc2 = source_cat['ys2'] # y position of the source, arcseconds\r\n mag_tot = source_cat['mag_src'] # total magnitude of the source\r\n Reff_arc = source_cat['Reff_src'] # Effective Radius of the source, arcseconds\r\n qs = source_cat['qs'] # axis ratio of the source, b/a\r\n phs = source_cat['phs'] # orientation of the source, degree\r\n ns = source_cat['ns'] # index of the source\r\n\r\n #----------------------------------------------------------------------\r\n g_limage = ole.sersic_2d(yi1,yi2,ysc1,ysc2,Reff_arc,qs,phs,ns)\r\n g_source = ole.sersic_2d(xi1,xi2,ysc1,ysc2,Reff_arc,qs,phs,ns)\r\n\r\n mag_lensed = mag_tot - 2.5*np.log(np.sum(g_limage)/np.sum(g_source))\r\n\r\n return mag_lensed, g_limage\r\n\r\n\r\ndef generate_lensed_host(xi1, xi2, lens_P, srcP_b, srcP_d):\r\n \"\"\"Does ray tracing of light from host galaxies using\r\n a non-singular isothermal ellipsoid profile. \r\n Ultimately writes out a FITS image of the result of the ray tracing.\t\"\"\"\r\n dsx = 0.01\r\n xlc1 = lens_P['xl1'] # x position of the lens, arcseconds\r\n xlc2 = lens_P['xl2'] # y position of the lens, arcseconds\r\n rlc = 0.0 # core size of Non-singular Isothermal Ellipsoid\r\n vd = lens_P['vd'] # velocity dispersion of the lens\r\n zl = lens_P['zl'] # redshift of the lens\r\n zs = srcP_b['zs'] # redshift of the source\r\n rle = ole.re_sv(vd, zl, zs) # Einstein radius of lens, arcseconds.\r\n ql = lens_P['ql'] # axis ratio b/a\r\n le = ole.e2le(1.0 - ql) # scale factor due to projection of ellpsoid\r\n phl = lens_P['phl'] # position angle of the lens, degree\r\n eshr = lens_P['gamma'] # external shear\r\n eang = lens_P['phg'] # position angle of external shear\r\n ekpa = 0.0 # external convergence\r\n\r\n #----------------------------------------------------------------------\r\n ai1, ai2 = ole.alphas_sie(xlc1, xlc2, phl, ql, rle, le,\r\n eshr, eang, ekpa, xi1, xi2)\r\n\r\n yi1 = xi1 - ai1\r\n yi2 = xi2 - ai2\r\n #----------------------------------------------------------------------------\r\n\r\n lensed_mag_b, lensed_image_b = lensed_sersic_2d(xi1,xi2,yi1,yi2,srcP_b,lens_P)\r\n\r\n os.makedirs(os.path.join(outdir,'agn_lensed_bulges'), exist_ok=True)\r\n\r\n fits_limg_b = os.path.join(outdir,'agn_lensed_bulges/') + str(lens_P['UID_lens']) + \"_\" + str(lensed_mag_b) + \"_bulge.fits\" \r\n \r\n pyfits.writeto(fits_limg_b, lensed_image_b.astype(\"float32\"), overwrite=True)\r\n\r\n #----------------------------------------------------------------------------\r\n\r\n lensed_mag_d, lensed_image_d = lensed_sersic_2d(xi1,xi2,yi1,yi2,srcP_d,lens_P)\r\n\r\n os.makedirs(os.path.join(outdir,'agn_lensed_disks'), exist_ok=True)\r\n\r\n fits_limg_d = os.path.join(outdir,'agn_lensed_disks/') + str(lens_P['UID_lens']) + \"_\" + str(lensed_mag_d) + \"_disk.fits\"\r\n \r\n pyfits.writeto(fits_limg_d, lensed_image_d.astype(\"float32\"), overwrite=True)\r\n\r\n return 0\r\n\r\n\r\nif __name__ == '__main__':\r\n\r\n dsx = 0.01 # pixel size per side, arcseconds\r\n nnn = 1000 # number of pixels per side\r\n xi1, xi2 = ole.make_r_coor(nnn, dsx)\r\n\r\n hdulist, ahb, ahd = load_in_data_agn()\r\n\r\n message_row = 0\r\n message_freq = 50\r\n for i, row in ahb.iterrows():\r\n if i >= message_row:\r\n print (\"working on system \", i , \"of\", max(ahb.index))\r\n message_row += message_freq\r\n lensP, srcPb, srcPd = create_cats_agns(i, hdulist, ahb, ahd)\r\n generate_lensed_host(xi1, xi2, lensP, srcPb, srcPd) \r\n"
] | [
[
"numpy.sqrt",
"numpy.sum"
]
] |
thomasgibson/tabula-rasa | [
"85abf26d6604b5a9a4d356f07aeb90d5b6453f33"
] | [
"verification/HMM/rtcf-h-table.py"
] | [
"import os\nimport sys\nimport pandas as pd\n\n\ndata_set = [\"results/H-RTCF-degree-0.csv\",\n \"results/H-RTCF-degree-1.csv\",\n \"results/H-RTCF-degree-2.csv\",\n \"results/H-RTCF-degree-3.csv\"]\n\nfor data in data_set:\n if not os.path.exists(data):\n print(\"Cannot find data file '%s'\" % data)\n sys.exit(1)\n\ntable = r\"\"\"\\resizebox{\\textwidth}{!}{%\n\\begin{tabular}{| l | c| c | c | c | c | c | c |}\n\\hline\n\\multicolumn{8}{|c|}{RTCF-H method} \\\\\n\\hline\n\\multirow{2}{*}{$k$} & mesh &\n\\multicolumn{2}{|c|}{$\\norm{p-p_h}_{L^2(\\Omega)} \\leq \\mathcal{O}(h^{k+1})$} &\n\\multicolumn{2}{|c|}{\n$\\norm{\\boldsymbol{u}-\\boldsymbol{u}_h}_{\\boldsymbol{L}^2(\\Omega)} \\leq \\mathcal{O}(h^{k+1})$} &\n\\multicolumn{2}{|c|}{$\\norm{p-p_h^{\\star}}_{L^2(\\Omega)} \\leq \\mathcal{O}(h^{k+2})$} \\\\\n\\cline{2-8}\n& $r$ & $L^2$-error & rate & $L^2$-error & rate & $L^2$-error & rate \\\\\n\"\"\"\n\nlformat = r\"\"\"& {mesh: d} & {ScalarErrors:.3e} & {ScalarRates} & {FluxErrors:.3e} & {FluxRates} & {PPScalarErrors:.3e} & {PPScalarRates} \\\\\n\"\"\"\n\n\ndef rate(s):\n if s == '---':\n return s\n else:\n return \"{s:.3f}\".format(s=float(s))\n\n\nfor data in data_set:\n df = pd.read_csv(data)\n df = df.sort_values(\"Mesh\")\n degree = df.Degree.values[0]\n table += r\"\"\"\n \\hline\n \\multirow{5}{*}{%d}\n \"\"\" % degree\n for k in df.Mesh:\n sliced = df.loc[lambda x: x.Mesh == k]\n table += lformat.format(mesh=k,\n ScalarErrors=sliced.ScalarErrors.values[0],\n ScalarRates=rate(sliced.ScalarConvRates.values[0]),\n FluxErrors=sliced.FluxErrors.values[0],\n FluxRates=rate(sliced.FluxConvRates.values[0]),\n PPScalarErrors=sliced.PostProcessedScalarErrors.values[0],\n PPScalarRates=rate(sliced.PostProcessedScalarRates.values[0]))\n\ntable += r\"\"\"\\hline\n\\end{tabular}}\n\"\"\"\nprint(table)\n"
] | [
[
"pandas.read_csv"
]
] |
morteham/thermopack | [
"67deaf74a2ae974e880be25026738cc32e3a6c1e"
] | [
"addon/pycThermopack/pyctp/thermo.py"
] | [
"# Support for python2\nfrom __future__ import print_function\n\nimport sys\nfrom ctypes import *\nfrom os import path\nimport numpy as np\nfrom . import plotutils, utils, platform_specifics\n\nif utils.gcc_major_version_greater_than(7):\n c_len_type = c_size_t # c_size_t on GCC > 7\nelse:\n c_len_type = c_int\n\n\nclass thermopack(object):\n \"\"\"\n Interface to thermopack\n \"\"\"\n def __init__(self):\n \"\"\"\n Load libthermopack.(so/dll) and initialize function pointers\n \"\"\"\n pf_specifics = platform_specifics.get_platform_specifics()\n self.prefix = pf_specifics[\"prefix\"]\n self.module = pf_specifics[\"module\"]\n self.postfix = pf_specifics[\"postfix\"]\n self.postfix_nm = pf_specifics[\"postfix_no_module\"]\n dyn_lib_path = path.join(path.dirname(__file__), pf_specifics[\"dyn_lib\"])\n self.tp = cdll.LoadLibrary(dyn_lib_path)\n\n # Set phase flags\n self.s_get_phase_flags = self.tp.get_phase_flags_c\n self.get_phase_flags()\n\n # Model control\n self.s_add_eos = getattr(self.tp, self.get_export_name(\"thermopack_var\", \"add_eos\"))\n self.s_delete_eos = getattr(self.tp, self.get_export_name(\"thermopack_var\", \"delete_eos\"))\n self.s_activate_model = getattr(self.tp, self.get_export_name(\"thermopack_var\", \"activate_model\"))\n\n # Information\n self.s_get_model_id = getattr(self.tp, self.get_export_name(\"thermopack_var\", \"get_eos_identification\"))\n\n # Init methods\n self.eoslibinit_init_thermo = getattr(self.tp, self.get_export_name(\"eoslibinit\", \"init_thermo\"))\n self.Rgas = c_double.in_dll(self.tp, self.get_export_name(\"thermopack_constants\", \"rgas\")).value\n self.nc = None\n self.minimum_temperature_c = c_double.in_dll(self.tp, self.get_export_name(\"thermopack_constants\", \"tptmin\"))\n self.minimum_pressure_c = c_double.in_dll(self.tp, self.get_export_name(\"thermopack_constants\", \"tppmin\"))\n self.solideos_solid_init = getattr(self.tp, self.get_export_name(\"solideos\", \"solid_init\"))\n self.eoslibinit_init_volume_translation = getattr(self.tp, self.get_export_name(\"eoslibinit\", \"init_volume_translation\"))\n self.eoslibinit_redefine_critical_parameters = getattr(self.tp, self.get_export_name(\"eoslibinit\", \"redefine_critical_parameters\"))\n\n # Eos interface\n self.s_eos_specificvolume = getattr(self.tp, self.get_export_name(\"eos\", \"specificvolume\"))\n self.s_eos_zfac = getattr(self.tp, self.get_export_name(\"eos\", \"zfac\"))\n self.s_eos_thermo = getattr(self.tp, self.get_export_name(\"eos\", \"thermo\"))\n self.s_eos_entropy = getattr(self.tp, self.get_export_name(\"eos\", \"entropy\"))\n self.s_eos_enthalpy = getattr(self.tp, self.get_export_name(\"eos\", \"enthalpy\"))\n self.s_eos_compmoleweight = getattr(self.tp, self.get_export_name(\"eos\", \"compmoleweight\"))\n self.s_eos_idealenthalpysingle = getattr(self.tp, self.get_export_name(\"eos\", \"idealenthalpysingle\"))\n\n # Speed of sound\n #self.sos_singlePhaseSpeedOfSound = getattr(self.tp, '__speed_of_sound_MOD_singlephasespeedofsound')\n self.s_sos_sound_velocity_2ph = getattr(self.tp, self.get_export_name(\"speed_of_sound\", \"sound_velocity_2ph\"))\n\n # Component info\n self.s_compdata_compindex = getattr(self.tp, self.get_export_name(\"compdata\", \"comp_index_active\"))\n self.s_compdata_compname = getattr(self.tp, self.get_export_name(\"compdata\", \"comp_name_active\"))\n\n # Flashes\n self.s_set_ph_tolerance = getattr(self.tp, self.get_export_name(\"ph_solver\", \"setphtolerance\"))\n self.s_twophasetpflash = getattr(self.tp, self.get_export_name(\"tp_solver\", \"twophasetpflash\"))\n self.s_psflash_twophase = getattr(self.tp, self.get_export_name(\"ps_solver\", \"twophasepsflash\"))\n #self.tpflash_multiphase = getattr(self.tp, '__mp_tp_solver_MOD_mp_flash_tp')\n self.s_uvflash_twophase = getattr(self.tp, self.get_export_name(\"uv_solver\", \"twophaseuvflash\"))\n self.s_phflash_twophase = getattr(self.tp, self.get_export_name(\"ph_solver\", \"twophasephflash\"))\n #self.s_svflash_twophase = getattr(self.tp, self.get_export_name(\"sv_solver\", \"twophasesvflash\"))\n self.s_guess_phase = getattr(self.tp, self.get_export_name(\"thermo_utils\", \"guessphase\"))\n\n # TV interfaces\n self.s_internal_energy_tv = getattr(self.tp, self.get_export_name(\"eostv\", \"internal_energy\"))\n self.s_entropy_tv = getattr(self.tp, self.get_export_name(\"eostv\", \"entropytv\"))\n self.s_pressure_tv = getattr(self.tp, self.get_export_name(\"eostv\", \"pressure\"))\n self.s_lnphi_tv = getattr(self.tp, self.get_export_name(\"eostv\", \"thermotv\"))\n self.s_enthalpy_tv = getattr(self.tp, self.get_export_name(\"eostv\", \"enthalpytv\"))\n self.s_helmholtz_energy = getattr(self.tp, self.get_export_name(\"eostv\", \"free_energy\"))\n self.s_chempot = getattr(self.tp, self.get_export_name(\"eostv\", \"chemical_potential\"))\n\n # Saturation properties\n self.s_bubble_t = getattr(self.tp, self.get_export_name(\"saturation\", \"safe_bubt\"))\n self.s_bubble_p = getattr(self.tp, self.get_export_name(\"saturation\", \"safe_bubp\"))\n self.s_dew_t = getattr(self.tp, self.get_export_name(\"saturation\", \"safe_dewt\"))\n self.s_dew_p = getattr(self.tp, self.get_export_name(\"saturation\", \"safe_dewp\"))\n self.s_envelope_plot = getattr(self.tp, self.get_export_name(\"saturation_curve\", \"envelopeplot\"))\n self.s_binary_plot = getattr(self.tp, self.get_export_name(\"binaryplot\", \"vllebinaryxy\"))\n self.s_global_binary_plot = getattr(self.tp, self.get_export_name(\"binaryplot\", \"global_binary_plot\"))\n self.s_get_bp_term = getattr(self.tp, self.get_export_name(\"binaryplot\", \"get_bp_term\"))\n self.s_solid_envelope_plot = getattr(self.tp, self.get_export_name(\"solid_saturation\", \"solidenvelopeplot\"))\n self.s_isotherm = getattr(self.tp, self.get_export_name(\"isolines\", \"isotherm\"))\n self.s_isobar = getattr(self.tp, self.get_export_name(\"isolines\", \"isobar\"))\n self.s_isenthalp = getattr(self.tp, self.get_export_name(\"isolines\", \"isenthalp\"))\n self.s_isentrope = getattr(self.tp, self.get_export_name(\"isolines\", \"isentrope\"))\n # Stability\n self.s_crit_tv = getattr(self.tp, self.get_export_name(\"critical\", \"calccriticaltv\"))\n\n # Virials\n self.s_virial_coeffcients = getattr(self.tp, self.get_export_name(\"eostv\", \"virial_coefficients\"))\n self.s_second_virial_matrix = getattr(self.tp, self.get_export_name(\"eostv\", \"secondvirialcoeffmatrix\"))\n self.s_binary_third_virial_matrix = getattr(self.tp, self.get_export_name(\"eostv\", \"binarythirdvirialcoeffmatrix\"))\n\n self.add_eos()\n\n def __del__(self):\n \"\"\"Delete FORTRAN memory allocated for this instance\"\"\"\n self.delete_eos()\n\n def activate(self):\n \"\"\"Activate this instance of thermopack parameters for calculation\"\"\"\n self.s_activate_model.argtypes = [POINTER( c_int )]\n self.s_activate_model.restype = None\n self.s_activate_model(self.model_index_c)\n\n def add_eos(self):\n \"\"\"Allocate FORTRAN memory for this class instance\"\"\"\n self.s_add_eos.argtypes = None\n self.s_add_eos.restype = c_int\n self.model_index_c = c_int(self.s_add_eos())\n\n def delete_eos(self):\n \"\"\"de-allocate FORTRAN memory for this class instance\"\"\"\n self.activate()\n self.s_delete_eos.argtypes = [POINTER( c_int )]\n self.s_delete_eos.restype = None\n self.s_delete_eos(self.model_index_c)\n\n def get_model_id(self):\n \"\"\"Get model identification\n\n Returns:\n str: Eos name\n \"\"\"\n self.activate()\n\n eosid_len = 40\n eosid_c = c_char_p(b\" \" * eosid_len)\n eosid_len_c = c_len_type(eosid_len)\n self.s_get_model_id.argtypes = [c_char_p, c_len_type]\n self.s_get_model_id.restype = None\n self.s_get_model_id(eosid_c, eosid_len_c)\n\n eosid = eosid_c.value.decode('ascii').strip()\n return eosid\n\n def get_export_name(self, module, method):\n \"\"\"Generate library export name based on module and method name\n\n Args:\n module (str): Name of module\n method (str): Name of method\n\n Returns:\n str: Library export name\n \"\"\"\n if len(module) > 0:\n export_name = self.prefix + module + self.module + method + self.postfix\n else:\n export_name = method + self.postfix_nm\n return export_name\n\n #################################\n # Init\n #################################\n\n def init_thermo(self, eos, mixing, alpha, comps, nphases,\n liq_vap_discr_method=None, csp_eos=None, csp_ref_comp=None,\n kij_ref=\"Default\", alpha_ref=\"Default\", saft_ref=\"Default\",\n b_exponent=None, TrendEosForCp=None, cptype=None,\n silent=None):\n \"\"\"Initialize thermopack\n\n Args:\n eos (str): Equation of state\n mixing (str): Mixture model for cubic eos\n alpha (str): Alpha formulations for cubic EOS\n comps (string): Comma separated list of components\n nphases (int): Maximum number of phases considered during multi-phase flash calculations\n liq_vap_discr_method (int, optional): Method to discriminate between liquid and vapor in case of an undefined single phase. Defaults to None.\n csp_eos (str, optional): Corrensponding state equation. Defaults to None.\n csp_ref_comp (str, optional): CSP reference component. Defaults to None.\n kij_ref (str, optional): Data set identifiers. Defaults to \"Default\".\n alpha_ref (str, optional): Data set identifiers. Defaults to \"Default\".\n saft_ref (str, optional): Data set identifiers. Defaults to \"Default\".\n b_exponent (float, optional): Exponent used in co-volume mixing. Defaults to None.\n TrendEosForCp (str, optional): Option to init trend for ideal gas properties. Defaults to None.\n cptype (int array, optional): Equation type number for Cp. Defaults to None.\n silent (bool, optional): Supress messages during init?. Defaults to None.\n \"\"\"\n self.activate()\n self.nc = max(len(comps.split(\" \")), len(comps.split(\",\")))\n\n null_pointer = POINTER(c_int)()\n eos_c = c_char_p(eos.encode('ascii'))\n eos_len = c_len_type(len(eos))\n mixing_c = c_char_p(mixing.encode('ascii'))\n mixing_len = c_len_type(len(mixing))\n alpha_c = c_char_p(alpha.encode('ascii'))\n alpha_len = c_len_type(len(alpha))\n comp_string_c = c_char_p(comps.encode('ascii'))\n comp_string_len = c_len_type(len(comps))\n nphases_c = c_int(nphases)\n if liq_vap_discr_method is None:\n liq_vap_discr_method_c = null_pointer\n else:\n liq_vap_discr_method_c = POINTER(c_int)(c_int(liq_vap_discr_method))\n if csp_eos is None:\n csp_eos_c = c_char_p()\n csp_eos_len = c_len_type(0)\n else:\n csp_eos_c = c_char_p(csp_eos.encode('ascii'))\n csp_eos_len = c_len_type(len(csp_eos))\n if csp_ref_comp is None:\n csp_ref_comp_c = c_char_p()\n csp_ref_comp_len = c_len_type(0)\n else:\n csp_ref_comp_c = c_char_p(csp_ref_comp.encode('ascii'))\n csp_ref_comp_len = c_len_type(len(csp_ref_comp))\n kij_ref_len = c_len_type(len(kij_ref))\n kij_ref_c = c_char_p(kij_ref.encode('ascii'))\n alpha_ref_len = c_len_type(len(alpha_ref))\n alpha_ref_c = c_char_p(alpha_ref.encode('ascii'))\n saft_ref_len = c_len_type(len(saft_ref))\n saft_ref_c = c_char_p(saft_ref.encode('ascii'))\n if b_exponent is None:\n b_exponent_c = POINTER(c_double)()\n else:\n b_exponent_c = POINTER(c_double)(c_double(b_exponent))\n if TrendEosForCp is None:\n TrendEosForCp_c = c_char_p()\n TrendEosForCp_len = c_len_type(0)\n else:\n TrendEosForCp_c = c_char_p(TrendEosForCp.encode('ascii'))\n TrendEosForCp_len = c_len_type(len(TrendEosForCp))\n if cptype is None:\n cptype_c = null_pointer\n else:\n cptype_c = (c_int * self.nc)(*cptype)\n\n if silent is None:\n silent_c = null_pointer\n else:\n if silent:\n silent_int = 1\n else:\n silent_int = 0\n silent_c = POINTER(c_int)(c_int(silent_int))\n\n self.eoslibinit_init_thermo.argtypes = [c_char_p,\n c_char_p,\n c_char_p,\n c_char_p,\n POINTER( c_int ),\n POINTER( c_int ),\n c_char_p,\n c_char_p,\n c_char_p,\n c_char_p,\n c_char_p,\n POINTER( c_double ),\n c_char_p,\n POINTER( c_int ),\n POINTER( c_int ),\n c_len_type, c_len_type,\n c_len_type, c_len_type,\n c_len_type, c_len_type,\n c_len_type, c_len_type,\n c_len_type, c_len_type]\n\n\n self.eoslibinit_init_thermo.restype = None\n\n self.eoslibinit_init_thermo(eos_c,\n mixing_c,\n alpha_c,\n comp_string_c,\n byref(nphases_c),\n liq_vap_discr_method_c,\n csp_eos_c,\n csp_ref_comp_c,\n kij_ref_c,\n alpha_ref_c,\n saft_ref_c,\n b_exponent_c,\n TrendEosForCp_c,\n cptype_c,\n silent_c,\n eos_len,\n mixing_len,\n alpha_len,\n comp_string_len,\n csp_eos_len,\n csp_ref_comp_len,\n kij_ref_len,\n alpha_ref_len,\n saft_ref_len,\n TrendEosForCp_len)\n\n def init_peneloux_volume_translation(self, parameter_reference=\"Default\"):\n \"\"\"Initialialize Peneloux volume translations\n\n Args:\n parameter_reference (str): String defining parameter set, Defaults to \"Default\"\n \"\"\"\n self.activate()\n volume_trans_model = \"PENELOUX\"\n volume_trans_model_c = c_char_p(volume_trans_model.encode('ascii'))\n volume_trans_model_len = c_len_type(len(volume_trans_model))\n ref_string_c = c_char_p(parameter_reference.encode('ascii'))\n ref_string_len = c_len_type(len(parameter_reference))\n self.eoslibinit_init_volume_translation.argtypes = [c_char_p,\n c_char_p,\n c_len_type,\n c_len_type]\n\n self.eoslibinit_init_volume_translation.restype = None\n\n self.eoslibinit_init_volume_translation(volume_trans_model_c,\n ref_string_c,\n volume_trans_model_len,\n ref_string_len)\n\n def redefine_critical_parameters(self, silent=True):\n \"\"\"Recalculate critical properties of pure fluids\n\n Args:\n silent (bool): Ignore warnings? Defaults to True\n \"\"\"\n self.activate()\n if silent:\n silent_c = c_int(1)\n else:\n silent_c = c_int(0)\n\n self.eoslibinit_redefine_critical_parameters.argtypes = [ POINTER( c_int ) ]\n\n self.eoslibinit_redefine_critical_parameters.restype = None\n\n self.eoslibinit_redefine_critical_parameters(byref(silent_c))\n\n\n #################################\n # Solids\n #################################\n\n def init_solid(self, scomp):\n \"\"\"Initialize pure solid\n\n Args:\n scomp (str): Component name\n \"\"\"\n self.activate()\n scomp_c = c_char_p(scomp.encode('ascii'))\n scomp_len = c_len_type(len(scomp))\n self.solideos_solid_init.argtypes = [c_char_p, c_len_type]\n self.solideos_solid_init.restype = None\n self.solideos_solid_init(scomp_c, scomp_len)\n\n #################################\n # Utility\n #################################\n\n def getcompindex(self, comp):\n \"\"\"Get component index\n\n Args:\n comp (str): Component name\n\n Returns:\n int: Component FORTRAN index\n \"\"\"\n self.activate()\n comp_c = c_char_p(comp.encode('ascii'))\n comp_len = c_len_type(len(comp))\n self.s_compdata_compindex.argtypes = [c_char_p, c_len_type]\n self.s_compdata_compindex.restype = c_int\n idx = self.s_compdata_compindex(comp_c, comp_len)\n return idx\n\n def get_comp_name(self, index):\n \"\"\"Get component name\n\n Args:\n int: Component FORTRAN index\n\n Returns:\n comp (str): Component name\n \"\"\"\n self.activate()\n comp_len = 40\n comp_c = c_char_p(b\" \" * comp_len)\n comp_len_c = c_len_type(comp_len)\n index_c = c_int(index)\n self.s_compdata_compname.argtypes = [POINTER(c_int), c_char_p, c_len_type]\n self.s_compdata_compname.restype = None\n self.s_compdata_compname(byref(index_c), comp_c, comp_len_c)\n compname = comp_c.value.decode('ascii').strip()\n return compname\n\n def compmoleweight(self, comp):\n \"\"\"Get component mole weight (g/mol)\n\n Args:\n comp (int): Component FORTRAN index\n\n Returns:\n float: Component mole weight (g/mol)\n \"\"\"\n self.activate()\n comp_c = c_int(comp)\n self.s_eos_compmoleweight.argtypes = [POINTER( c_int )]\n self.s_eos_compmoleweight.restype = c_double\n mw_i = self.s_eos_compmoleweight(byref(comp_c))\n return mw_i\n\n def get_phase_flags(self):\n \"\"\"Get phase identifiers used by thermopack\n\n Returns:\n int: Phase int identifiers\n \"\"\"\n iTWOPH = c_int()\n iLIQPH = c_int()\n iVAPPH = c_int()\n iMINGIBBSPH = c_int()\n iSINGLEPH = c_int()\n iSOLIDPH = c_int()\n iFAKEPH = c_int()\n\n self.s_get_phase_flags.argtypes = [POINTER( c_int ),\n POINTER( c_int ),\n POINTER( c_int ),\n POINTER( c_int ),\n POINTER( c_int ),\n POINTER( c_int ),\n POINTER( c_int )]\n self.s_get_phase_flags.restype = None\n self.s_get_phase_flags(byref(iTWOPH),\n byref(iLIQPH),\n byref(iVAPPH),\n byref(iMINGIBBSPH),\n byref(iSINGLEPH),\n byref(iSOLIDPH),\n byref(iFAKEPH))\n self.TWOPH = iTWOPH.value\n self.LIQPH = iLIQPH.value\n self.VAPPH = iVAPPH.value\n self.MINGIBBSPH = iMINGIBBSPH.value\n self.SINGLEPH = iSINGLEPH.value\n self.SOLIDPH = iSOLIDPH.value\n self.FAKEPH = iFAKEPH.value\n\n def get_phase_type(self, i_phase):\n \"\"\"Get phase type\n\n Args:\n i_phase (int): Phase flag returned by thermopack\n\n Returns:\n str: Phase type\n \"\"\"\n phase_string_list = [\"TWO_PHASE\", \"LIQUID\", \"VAPOR\", \"MINIMUM_GIBBS\", \"SINGLE\", \"SOLID\", \"FAKE\"]\n return phase_string_list[i_phase]\n\n def set_tmin(self, temp):\n \"\"\"Set minimum temperature in Thermopack. Used to limit search\n domain for numerical solvers.\n\n Args:\n temp (float): Temperature (K)\n \"\"\"\n self.minimum_temperature_c.value = temp\n\n def get_tmin(self):\n \"\"\"Get minimum temperature in Thermopack. Used to limit search\n domain for numerical solvers.\n\n Returns:\n float: Temperature (K)\n \"\"\"\n temp = self.minimum_temperature_c.value\n return temp\n\n def set_pmin(self, press):\n \"\"\"Get minimum pressure in Thermopack. Used to limit search\n domain for numerical solvers.\n\n Args:\n press (float): Pressure (Pa)\n \"\"\"\n self.minimum_pressure_c.value = press\n\n #################################\n # Phase properties\n #################################\n\n def specific_volume(self, temp, press, x, phase, dvdt=None, dvdp=None, dvdn=None):\n \"\"\" Calculate single-phase specific volume\n Note that the order of the output match the default order of input for the differentials.\n Note further that dvdt, dvdp and dvdn only are flags to enable calculation.\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n x (array_like): Molar composition\n phase (int): Calcualte root for specified phase\n dvdt (logical, optional): Calculate volume differentials with respect to temperature while pressure and composition are held constant. Defaults to None.\n dvdp (logical, optional): Calculate volume differentials with respect to pressure while temperature and composition are held constant. Defaults to None.\n dvdn (logical, optional): Calculate volume differentials with respect to mol numbers while pressure and temperature are held constant. Defaults to None.\n\n Returns:\n float: Specific volume (m3/mol), and optionally differentials\n \"\"\"\n self.activate()\n null_pointer = POINTER(c_double)()\n\n temp_c = c_double(temp)\n press_c = c_double(press)\n x_c = (c_double * len(x))(*x)\n phase_c = c_int(phase)\n v_c = c_double(0.0)\n\n if dvdt is None:\n dvdt_c = null_pointer\n else:\n dvdt_c = POINTER(c_double)(c_double(0.0))\n if dvdp is None:\n dvdp_c = null_pointer\n else:\n dvdp_c = POINTER(c_double)(c_double(0.0))\n if dvdn is None:\n dvdn_c = null_pointer\n else:\n dvdn_c = (c_double * len(x))(0.0)\n\n self.s_eos_specificvolume.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_eos_specificvolume.restype = None\n\n self.s_eos_specificvolume(byref(temp_c),\n byref(press_c),\n x_c,\n byref(phase_c),\n byref(v_c),\n dvdt_c,\n dvdp_c,\n dvdn_c)\n return_tuple = (v_c.value, )\n if not dvdt is None:\n return_tuple += (dvdt_c[0], )\n if not dvdp is None:\n return_tuple += (dvdp_c[0], )\n if not dvdn is None:\n return_tuple += (np.array(dvdn_c), )\n\n return return_tuple\n\n def zfac(self,temp,press,x,phase,dzdt=None,dzdp=None,dzdn=None):\n \"\"\" Calculate single-phase compressibility\n Note that the order of the output match the default order of input for the differentials.\n Note further that dzdt, dzdp and dzdn only are flags to enable calculation.\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n x (array_like): Molar composition\n phase (int): Calcualte root for specified phase\n dzdt (logical, optional): Calculate compressibility differentials with respect to temperature while pressure and composition are held constant. Defaults to None.\n dzdp (logical, optional): Calculate compressibility differentials with respect to pressure while temperature and composition are held constant. Defaults to None.\n dzdn (logical, optional): Calculate compressibility differentials with respect to mol numbers while pressure and temperature are held constant. Defaults to None.\n\n Returns:\n float: Compressibility (-), and optionally differentials\n \"\"\"\n self.activate()\n null_pointer = POINTER(c_double)()\n\n temp_c = c_double(temp)\n press_c = c_double(press)\n x_c = (c_double * len(x))(*x)\n phase_c = c_int(phase)\n z_c = c_double(0.0)\n\n if dzdt is None:\n dzdt_c = null_pointer\n else:\n dzdt_c = POINTER(c_double)(c_double(0.0))\n if dzdp is None:\n dzdp_c = null_pointer\n else:\n dzdp_c = POINTER(c_double)(c_double(0.0))\n if dzdn is None:\n dzdn_c = null_pointer\n else:\n dzdn_c = (c_double * len(x))(0.0)\n\n self.s_eos_zfac.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_eos_zfac.restype = None\n\n self.s_eos_zfac(byref(temp_c),\n byref(press_c),\n x_c,\n byref(phase_c),\n byref(z_c),\n dzdt_c,\n dzdp_c,\n dzdn_c)\n return_tuple = (z_c.value, )\n if not dzdt is None:\n return_tuple += (dzdt_c[0], )\n if not dzdp is None:\n return_tuple += (dzdp_c[0], )\n if not dzdn is None:\n return_tuple += (np.array(dzdn_c), )\n\n return return_tuple\n\n def thermo(self,temp,press,x,phase,dlnfugdt=None,dlnfugdp=None,\n dlnfugdn=None,ophase=None,v=None):\n \"\"\" Calculate logarithm of fugacity coefficient given composition,\n temperature and pressure.\n Note that the order of the output match the default order of input for the differentials.\n Note further that dlnfugdt, dlnfugdp, dlnfugdn and ophase only are flags to enable calculation.\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n x (array_like): Molar composition (.)\n phase (int): Calcualte root for specified phase\n dlnfugdt (logical, optional): Calculate fugacity coefficient differentials with respect to temperature while pressure and composition are held constant. Defaults to None.\n dlnfugdp (logical, optional): Calculate fugacity coefficient differentials with respect to pressure while temperature and composition are held constant. Defaults to None.\n dlnfugdn (logical, optional): Calculate fugacity coefficient differentials with respect to mol numbers while pressure and temperature are held constant. Defaults to None.\n ophase (int, optional): Phase flag. Only set when phase=MINGIBBSPH.\n v (float, optional): Specific volume (m3/mol)\n Returns:\n ndarray: fugacity coefficient (-), and optionally differentials\n \"\"\"\n self.activate()\n null_pointer = POINTER(c_double)()\n temp_c = c_double(temp)\n press_c = c_double(press)\n x_c = (c_double * len(x))(*x)\n phase_c = c_int(phase)\n lnfug_c = (c_double * len(x))(0.0)\n\n if dlnfugdt is None:\n dlnfugdt_c = null_pointer\n else:\n dlnfugdt_c = (c_double * len(x))(0.0)\n if dlnfugdp is None:\n dlnfugdp_c = null_pointer\n else:\n dlnfugdp_c = (c_double * len(x))(0.0)\n if dlnfugdn is None:\n dlnfugdn_c = null_pointer\n else:\n dlnfugdn_c = (c_double * len(x)**2)(0.0)\n if ophase is None:\n ophase_c = POINTER(c_int)()\n else:\n ophase_c = POINTER(c_int)(c_int(0))\n metaExtremum_c = POINTER(c_int)()\n\n if v is None:\n v_c = null_pointer\n else:\n v_c = POINTER(c_double)(c_double(0.0))\n\n self.s_eos_thermo.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_int ),\n POINTER( c_double )]\n\n self.s_eos_thermo.restype = None\n\n self.s_eos_thermo(byref(temp_c),\n byref(press_c),\n x_c,\n byref(phase_c),\n lnfug_c,\n dlnfugdt_c,\n dlnfugdp_c,\n dlnfugdn_c,\n ophase_c,\n metaExtremum_c,\n v_c)\n\n return_tuple = (np.array(lnfug_c), )\n if not dlnfugdt is None:\n return_tuple += (np.array(dlnfugdt_c), )\n if not dlnfugdp is None:\n return_tuple += (np.array(dlnfugdp_c), )\n if not dlnfugdn is None:\n dlnfugdn_r = np.zeros((len(x),len(x)))\n for i in range(len(x)):\n for j in range(len(x)):\n dlnfugdn_r[i][j] = dlnfugdn_c[i+j*len(x)]\n return_tuple += (dlnfugdn_r, )\n if not ophase is None:\n return_tuple += (ophase_c[0], )\n if not v is None:\n return_tuple += (v_c[0], )\n\n return return_tuple\n\n def enthalpy(self,temp,press,x,phase,dhdt=None,dhdp=None,dhdn=None):\n \"\"\" Calculate specific single-phase enthalpy\n Note that the order of the output match the default order of input for the differentials.\n Note further that dhdt, dhdp and dhdn only are flags to enable calculation.\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n x (array_like): Molar composition\n phase (int): Calcualte root for specified phase\n dhdt (logical, optional): Calculate enthalpy differentials with respect to temperature while pressure and composition are held constant. Defaults to None.\n dhdp (logical, optional): Calculate enthalpy differentials with respect to pressure while temperature and composition are held constant. Defaults to None.\n dhdn (logical, optional): Calculate enthalpy differentials with respect to mol numbers while pressure and temperature are held constant. Defaults to None.\n\n Returns:\n float: Specific enthalpy (J/mol), and optionally differentials\n \"\"\"\n self.activate()\n null_pointer = POINTER(c_double)()\n\n temp_c = c_double(temp)\n press_c = c_double(press)\n x_c = (c_double * len(x))(*x)\n phase_c = c_int(phase)\n h_c = c_double(0.0)\n\n if dhdt is None:\n dhdt_c = null_pointer\n else:\n dhdt_c = POINTER(c_double)(c_double(0.0))\n if dhdp is None:\n dhdp_c = null_pointer\n else:\n dhdp_c = POINTER(c_double)(c_double(0.0))\n if dhdn is None:\n dhdn_c = null_pointer\n else:\n dhdn_c = (c_double * len(x))(0.0)\n\n residual_c = POINTER(c_int)()\n self.s_eos_enthalpy.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_eos_enthalpy.restype = None\n\n self.s_eos_enthalpy(byref(temp_c),\n byref(press_c),\n x_c,\n byref(phase_c),\n byref(h_c),\n dhdt_c,\n dhdp_c,\n dhdn_c,\n residual_c)\n\n return_tuple = (h_c.value, )\n if not dhdt is None:\n return_tuple += (dhdt_c[0], )\n if not dhdp is None:\n return_tuple += (dhdp_c[0], )\n if not dhdn is None:\n return_tuple += (np.array(dhdn_c), )\n\n return return_tuple\n\n def entropy(self,temp,press,x,phase,dsdt=None,dsdp=None,dsdn=None):\n \"\"\" Calculate specific single-phase entropy\n Note that the order of the output match the default order of input for the differentials.\n Note further that dsdt, dhsp and dsdn only are flags to enable calculation.\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n x (array_like): Molar composition\n phase (int): Calcualte root for specified phase\n dsdt (logical, optional): Calculate entropy differentials with respect to temperature while pressure and composition are held constant. Defaults to None.\n dsdp (logical, optional): Calculate entropy differentials with respect to pressure while temperature and composition are held constant. Defaults to None.\n dsdn (logical, optional): Calculate entropy differentials with respect to mol numbers while pressure and temperature are held constant. Defaults to None.\n\n Returns:\n float: Specific entropy (J/mol/K), and optionally differentials\n \"\"\"\n self.activate()\n null_pointer = POINTER(c_double)()\n\n temp_c = c_double(temp)\n press_c = c_double(press)\n x_c = (c_double * len(x))(*x)\n phase_c = c_int(phase)\n s_c = c_double(0.0)\n\n if dsdt is None:\n dsdt_c = null_pointer\n else:\n dsdt_c = POINTER(c_double)(c_double(0.0))\n if dsdp is None:\n dsdp_c = null_pointer\n else:\n dsdp_c = POINTER(c_double)(c_double(0.0))\n if dsdn is None:\n dsdn_c = null_pointer\n else:\n dsdn_c = (c_double * len(x))(0.0)\n residual_c = POINTER(c_int)()\n\n self.s_eos_entropy.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_eos_entropy.restype = None\n\n self.s_eos_entropy(byref(temp_c),\n byref(press_c),\n x_c,\n byref(phase_c),\n byref(s_c),\n dsdt_c,\n dsdp_c,\n dsdn_c,\n residual_c)\n return_tuple = (s_c.value, )\n if not dsdt is None:\n return_tuple += (dsdt_c[0], )\n if not dsdp is None:\n return_tuple += (dsdp_c[0], )\n if not dsdn is None:\n return_tuple += (np.array(dsdn_c), )\n\n return return_tuple\n\n def idealenthalpysingle(self,temp,press,j,dhdt=None,dhdp=None):\n \"\"\" Calculate specific ideal enthalpy\n Note that the order of the output match the default order of input for the differentials.\n Note further that dhdt, and dhdp only are flags to enable calculation.\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n x (array_like): Molar composition\n phase (int): Calcualte root for specified phase\n dhdt (logical, optional): Calculate ideal enthalpy differentials with respect to temperature while pressure and composition are held constant. Defaults to None.\n dhdp (logical, optional): Calculate ideal enthalpy differentials with respect to pressure while temperature and composition are held constant. Defaults to None.\n\n Returns:\n float: Specific ideal enthalpy (J/mol), and optionally differentials\n \"\"\"\n self.activate()\n null_pointer = POINTER(c_double)()\n\n temp_c = c_double(temp)\n press_c = c_double(press)\n j_c = c_int(j)\n h_c = c_double(0.0)\n\n if dhdt is None:\n dhdt_c = null_pointer\n else:\n dhdt_c = POINTER(c_double)(c_double(0.0))\n if dhdp is None:\n dhdp_c = null_pointer\n else:\n dhdp_c = POINTER(c_double)(c_double(0.0))\n\n self.s_eos_idealenthalpysingle.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_eos_idealenthalpysingle.restype = None\n\n self.s_eos_idealenthalpysingle(byref(temp_c),\n byref(press_c),\n byref(j_c),\n byref(h_c),\n dhdt_c,\n dhdp_c)\n return_tuple = (h_c.value, )\n if not dhdt is None:\n return_tuple += (dhdt_c[0], )\n if not dhdp is None:\n return_tuple += (dhdp_c[0], )\n\n return return_tuple\n\n def speed_of_sound(self,temp,press,x,y,z,betaV,betaL,phase):\n \"\"\"Calculate speed of sound for single phase or two phase mixture assuming\n mechanical, thermal and chemical equilibrium.\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n x (array_like): Liquid molar composition\n y (array_like): Gas molar composition\n z (array_like): Overall molar composition\n betaV (float): Molar gas phase fraction\n betaL (float): Molar liquid phase fraction\n phase (int): Calcualte root for specified phase\n\n Returns:\n float: Speed of sound (m/s)\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n press_c = c_double(press)\n x_c = (c_double * len(x))(*x)\n y_c = (c_double * len(y))(*y)\n z_c = (c_double * len(z))(*z)\n betaV_c = c_double(betaV)\n betaL_c = c_double(betaL)\n phase_c = c_int(phase)\n ph_c = POINTER(c_int)()\n\n self.s_sos_sound_velocity_2ph.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_int )]\n\n self.s_sos_sound_velocity_2ph.restype = c_double\n\n sos = self.s_sos_sound_velocity_2ph(byref(temp_c),\n byref(press_c),\n x_c,\n y_c,\n z_c,\n byref(betaV_c),\n byref(betaL_c),\n byref(phase_c),\n ph_c)\n\n return sos\n\n #################################\n # Flash interfaces\n #################################\n\n def set_ph_tolerance(self, tol):\n \"\"\"Set tolerance of isobaric-isentalpic (PH) flash\n\n Args:\n tol (float): Tolerance\n \"\"\"\n tol_c = c_double(tol)\n self.s_set_ph_tolerance.argtypes = [POINTER( c_double )]\n self.s_set_ph_tolerance.restype = None\n self.s_set_ph_tolerance(byref(tol_c))\n\n def two_phase_tpflash(self,temp,press,z):\n \"\"\"Do isothermal-isobaric (TP) flash\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n z (array_like): Overall molar composition\n\n Returns:\n x (ndarray): Liquid molar composition\n y (ndarray): Gas molar composition\n betaV (float): Molar gas phase fraction\n betaL (float): Molar liquid phase fraction\n phase (int): Phase identifier (iTWOPH/iLIQPH/iVAPPH)\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n press_c = c_double(press)\n z_c = (c_double * len(z))(*z)\n\n x_c = (c_double * len(z))(0.0)\n y_c = (c_double * len(z))(0.0)\n betaV_c = c_double(0.0)\n betaL_c = c_double(0.0)\n phase_c = c_int(0)\n\n self.s_twophasetpflash.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_twophasetpflash.restype = None\n\n self.s_twophasetpflash(byref(temp_c),\n byref(press_c),\n z_c,\n byref(betaV_c),\n byref(betaL_c),\n byref(phase_c),\n x_c,\n y_c)\n\n x = np.array(x_c)\n y = np.array(y_c)\n\n return x, y, betaV_c.value, betaL_c.value, phase_c.value\n\n\n def two_phase_psflash(self,press,z,entropy,temp=None):\n \"\"\"Do isentropic-isobaric (SP) flash\n\n Args:\n press (float): Pressure (Pa)\n z (array_like): Overall molar composition\n entropy (float): Specific entropy (J/mol/K)\n temp (float, optional): Initial guess for temperature (K)\n\n Returns:\n temp (float): Temperature (K)\n x (ndarray): Liquid molar composition\n y (ndarray): Gas molar composition\n betaV (float): Molar gas phase fraction\n betaL (float): Molar liquid phase fraction\n phase (int): Phase identifier (iTWOPH/iLIQPH/iVAPPH)\n \"\"\"\n self.activate()\n press_c = c_double(press)\n z_c = (c_double * len(z))(*z)\n s_c = c_double(entropy)\n\n if not temp is None:\n temp_c = POINTER( c_double )(c_double(temp))\n else:\n temp_c = POINTER( c_double )(c_double(0.0))\n\n x_c = (c_double * len(z))(0.0)\n y_c = (c_double * len(z))(0.0)\n betaV_c = c_double(0.0)\n betaL_c = c_double(0.0)\n phase_c = c_int(0)\n ierr_c = c_int(0)\n self.s_psflash_twophase.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_int )]\n\n self.s_psflash_twophase.restype = None\n\n self.s_psflash_twophase(temp_c,\n byref(press_c),\n z_c,\n byref(betaV_c),\n byref(betaL_c),\n x_c,\n y_c,\n byref(s_c),\n byref(phase_c),\n byref(ierr_c))\n\n if ierr_c.value != 0:\n raise Exception(\"PS flash calclualtion failed\")\n\n x = np.array(x_c)\n y = np.array(y_c)\n\n return temp_c[0], x, y, betaV_c.value, betaL_c.value, phase_c.value\n\n def two_phase_phflash(self,press,z,enthalpy,temp=None):\n \"\"\"Do isenthalpic-isobaric (HP) flash\n\n Args:\n press (float): Pressure (Pa)\n z (array_like): Overall molar composition\n enthalpy (float): Specific enthalpy (J/mol)\n temp (float, optional): Initial guess for temperature (K)\n\n Returns:\n temp (float): Temperature (K)\n x (ndarray): Liquid molar composition\n y (ndarray): Gas molar composition\n betaV (float): Molar gas phase fraction\n betaL (float): Molar liquid phase fraction\n phase (int): Phase identifier (iTWOPH/iLIQPH/iVAPPH)\n \"\"\"\n self.activate()\n press_c = c_double(press)\n z_c = (c_double * len(z))(*z)\n h_c = c_double(enthalpy)\n\n if not temp is None:\n temp_c = POINTER( c_double )(c_double(temp))\n else:\n temp_c = POINTER( c_double )(c_double(0.0))\n\n x_c = (c_double * len(z))(0.0)\n y_c = (c_double * len(z))(0.0)\n betaV_c = c_double(0.0)\n betaL_c = c_double(0.0)\n phase_c = c_int(0)\n ierr_c = c_int(0)\n\n self.s_phflash_twophase.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_int )]\n\n self.s_phflash_twophase.restype = None\n\n self.s_phflash_twophase(temp_c,\n byref(press_c),\n z_c,\n byref(betaV_c),\n byref(betaL_c),\n x_c,\n y_c,\n byref(h_c),\n byref(phase_c),\n byref(ierr_c))\n\n if ierr_c.value != 0:\n raise Exception(\"PH flash calclualtion failed\")\n\n x = np.array(x_c)\n y = np.array(y_c)\n\n return temp_c[0], x, y, betaV_c.value, betaL_c.value, phase_c.value\n\n def two_phase_uvflash(self,z,specific_energy,specific_volume,temp=None,press=None):\n \"\"\"Do isoenergetic-isochoric (UV) flash\n\n Args:\n press (float): Pressure (Pa)\n z (array_like): Overall molar composition\n specific_energy (float): Specific energy (J/mol)\n specific_volume (float): Specific volume (m3/mol)\n temp (float, optional): Initial guess for temperature (K)\n press (float, optional): Initial guess for pressure (Pa)\n\n Returns:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n x (ndarray): Liquid molar composition\n y (ndarray): Gas molar composition\n betaV (float): Molar gas phase fraction\n betaL (float): Molar liquid phase fraction\n phase (int): Phase identifier (iTWOPH/iLIQPH/iVAPPH)\n \"\"\"\n self.activate()\n z_c = (c_double * len(z))(*z)\n e_c = c_double(specific_energy)\n v_c = c_double(specific_volume)\n\n if not temp is None:\n temp_c = POINTER( c_double )(c_double(temp))\n else:\n temp_c = POINTER( c_double )(c_double(0.0))\n\n if not press is None:\n press_c = POINTER( c_double )(c_double(press))\n else:\n press_c = POINTER( c_double )(c_double(0.0))\n\n x_c = (c_double * len(z))(0.0)\n y_c = (c_double * len(z))(0.0)\n betaV_c = c_double(0.0)\n betaL_c = c_double(0.0)\n phase_c = c_int(0)\n\n self.s_uvflash_twophase.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_uvflash_twophase(temp_c,\n press_c,\n z_c,\n byref(betaV_c),\n byref(betaL_c),\n x_c,\n y_c,\n byref(e_c),\n byref(v_c),\n byref(phase_c))\n\n x = np.array(x_c)\n y = np.array(y_c)\n\n return temp_c[0], press_c[0], x, y, betaV_c.value, betaL_c.value, phase_c.value\n\n def guess_phase(self, temp, press, z):\n \"\"\"If only one root exsist for the equation of state the phase type can be\n determined from either the psedo-critical volume or a volume ratio to the co-volume\n\n Args:\n temp (float): Temperature (K)\n press (float): Pressure (Pa)\n\n Returns:\n int: Phase int (VAPPH or LIQPH)\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n press_c = c_double(press)\n z_c = (c_double * len(z))(*z)\n null_pointer = POINTER(c_double)()\n temp_comp_c = null_pointer\n press_comp_c = null_pointer\n vb_ratio_c = null_pointer\n\n self.s_guess_phase.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_guess_phase.restype = c_int\n\n phase = self.s_guess_phase(byref(temp_c),\n byref(press_c),\n z_c,\n temp_comp_c,\n press_comp_c,\n vb_ratio_c)\n\n return phase\n\n #################################\n # Temperature-volume property interfaces\n #################################\n\n def pressure_tv(self, temp, volume, n, dpdt=None, dpdv=None, dpdn=None):\n \"\"\"Calculate pressure given temperature, volume and mol numbers.\n\n Args:\n temp (float): Temperature (K)\n volume (float): Volume (m3)\n n (array_like): Mol numbers (mol)\n dpdt (No type, optional): Flag to activate calculation. Defaults to None.\n dpdv (No type, optional): Flag to activate calculation. Defaults to None.\n dpdn (No type, optional): Flag to activate calculation. Defaults to None.\n\n Returns:\n float: Pressure (Pa)\n Optionally pressure differentials\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n v_c = c_double(volume)\n n_c = (c_double * len(n))(*n)\n\n null_pointer = POINTER(c_double)()\n if dpdt is None:\n dpdt_c = null_pointer\n else:\n dpdt_c = POINTER(c_double)(c_double(0.0))\n if dpdv is None:\n dpdv_c = null_pointer\n else:\n dpdv_c = POINTER(c_double)(c_double(0.0))\n d2pdv2_c = null_pointer\n if dpdn is None:\n dpdn_c = null_pointer\n else:\n dpdn_c = (c_double * len(n))(0.0)\n\n recalculate_c = POINTER(c_int)(c_int(1))\n\n self.s_pressure_tv.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_pressure_tv.restype = c_double\n\n P = self.s_pressure_tv(byref(temp_c),\n byref(v_c),\n n_c,\n dpdv_c,\n dpdt_c,\n d2pdv2_c,\n dpdn_c,\n recalculate_c)\n\n return_tuple = (P, )\n if not dpdt is None:\n return_tuple += (dpdt_c[0], )\n if not dpdv is None:\n return_tuple += (dpdv_c[0], )\n if not dpdn is None:\n return_tuple += (np.array(dpdn_c), )\n\n return return_tuple\n\n def internal_energy_tv(self, temp, volume, n, dedt=None, dedv=None):\n \"\"\"Calculate internal energy given temperature, volume and mol numbers.\n\n Args:\n temp (float): Temperature (K)\n volume (float): Volume (m3)\n n (array_like): Mol numbers (mol)\n dedt (No type, optional): Flag to activate calculation. Defaults to None.\n dedv (No type, optional): Flag to activate calculation. Defaults to None.\n\n Returns:\n float: Energy (J)\n Optionally energy differentials\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n v_c = c_double(volume)\n e_c = c_double(0.0)\n n_c = (c_double * len(n))(*n)\n\n null_pointer = POINTER(c_double)()\n if dedt is None:\n dedt_c = null_pointer\n else:\n dedt_c = POINTER(c_double)(c_double(0.0))\n if dedv is None:\n dedv_c = null_pointer\n else:\n dedv_c = POINTER(c_double)(c_double(0.0))\n\n recalculate_c = POINTER(c_int)(c_int(1))\n\n self.s_internal_energy_tv.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_internal_energy_tv.restype = None\n\n self.s_internal_energy_tv(byref(temp_c),\n byref(v_c),\n n_c,\n byref(e_c),\n dedt_c,\n dedv_c,\n recalculate_c)\n\n return_tuple = (e_c.value, )\n if not dedt is None:\n return_tuple += (dedt_c[0], )\n if not dedv is None:\n return_tuple += (dedv_c[0], )\n\n return return_tuple\n\n def entropy_tv(self, temp, volume, n, dsdt=None, dsdv=None, dsdn=None):\n \"\"\"Calculate entropy given temperature, volume and mol numbers.\n\n Args:\n temp (float): Temperature (K)\n volume (float): Volume (m3)\n n (array_like): Mol numbers (mol)\n dsdt (No type, optional): Flag to activate calculation. Defaults to None.\n dsdv (No type, optional): Flag to activate calculation. Defaults to None.\n dsdn (No type, optional): Flag to activate calculation. Defaults to None.\n\n Returns:\n float: Entropy (J/K)\n Optionally entropy differentials\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n v_c = c_double(volume)\n s_c = c_double(0.0)\n n_c = (c_double * len(n))(*n)\n\n null_pointer = POINTER(c_double)()\n if dsdt is None:\n dsdt_c = null_pointer\n else:\n dsdt_c = POINTER(c_double)(c_double(0.0))\n if dsdv is None:\n dsdv_c = null_pointer\n else:\n dsdv_c = POINTER(c_double)(c_double(0.0))\n if dsdn is None:\n dsdn_c = null_pointer\n else:\n dsdn_c = (c_double * len(n))(0.0)\n\n residual_c = POINTER(c_int)(c_int(0))\n\n self.s_entropy_tv.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_entropy_tv.restype = None\n\n self.s_entropy_tv(byref(temp_c),\n byref(v_c),\n n_c,\n byref(s_c),\n dsdt_c,\n dsdv_c,\n dsdn_c,\n residual_c)\n\n return_tuple = (s_c.value, )\n if not dsdt is None:\n return_tuple += (dsdt_c[0], )\n if not dsdv is None:\n return_tuple += (dsdv_c[0], )\n if not dsdn is None:\n return_tuple += (np.array(dsdn_c), )\n\n return return_tuple\n\n def enthalpy_tv(self, temp, volume, n, dhdt=None, dhdv=None, dhdn=None):\n \"\"\"Calculate enthalpy given temperature, volume and mol numbers.\n\n Args:\n temp (float): Temperature (K)\n volume (float): Volume (m3)\n n (array_like): Mol numbers (mol)\n dhdt (No type, optional): Flag to activate calculation. Defaults to None.\n dhdv (No type, optional): Flag to activate calculation. Defaults to None.\n dhdn (No type, optional): Flag to activate calculation. Defaults to None.\n\n Returns:\n float: Enthalpy (J)\n Optionally enthalpy differentials\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n v_c = c_double(volume)\n h_c = c_double(0.0)\n n_c = (c_double * len(n))(*n)\n\n null_pointer = POINTER(c_double)()\n if dhdt is None:\n dhdt_c = null_pointer\n else:\n dhdt_c = POINTER(c_double)(c_double(0.0))\n if dhdv is None:\n dhdv_c = null_pointer\n else:\n dhdv_c = POINTER(c_double)(c_double(0.0))\n if dhdn is None:\n dhdn_c = null_pointer\n else:\n dhdn_c = (c_double * len(n))(0.0)\n\n residual_c = POINTER(c_int)(c_int(0))\n\n self.s_enthalpy_tv.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_enthalpy_tv.restype = None\n\n self.s_enthalpy_tv(byref(temp_c),\n byref(v_c),\n n_c,\n byref(h_c),\n dhdt_c,\n dhdv_c,\n dhdn_c,\n residual_c)\n\n return_tuple = (h_c.value, )\n if not dhdt is None:\n return_tuple += (dhdt_c[0], )\n if not dhdv is None:\n return_tuple += (dhdv_c[0], )\n if not dhdn is None:\n return_tuple += (np.array(dhdn_c), )\n\n return return_tuple\n\n def helmholtz_tv(self, temp, volume, n, dadt=None, dadv=None):\n \"\"\"Calculate Helmholtz energy given temperature, volume and mol numbers.\n\n Args:\n temp (float): Temperature (K)\n volume (float): Volume (m3)\n n (array_like): Mol numbers (mol)\n dadt (No type, optional): Flag to activate calculation. Defaults to None.\n dadv (No type, optional): Flag to activate calculation. Defaults to None.\n\n Returns:\n float: Helmholtz energy (J)\n Optionally energy differentials\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n v_c = c_double(volume)\n a_c = c_double(0.0)\n n_c = (c_double * len(n))(*n)\n\n null_pointer = POINTER(c_double)()\n if dadt is None:\n dadt_c = null_pointer\n else:\n dadt_c = POINTER(c_double)(c_double(0.0))\n if dadv is None:\n dadv_c = null_pointer\n else:\n dadv_c = POINTER(c_double)(c_double(0.0))\n d2adt2_c = null_pointer\n d2adv2_c = null_pointer\n d2advdt_c = null_pointer\n recalculate_c = POINTER(c_int)(c_int(1))\n\n self.s_helmholtz_energy.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_helmholtz_energy.restype = None\n\n self.s_helmholtz_energy(byref(temp_c),\n byref(v_c),\n n_c,\n byref(a_c),\n dadt_c,\n dadv_c,\n d2adt2_c,\n d2adv2_c,\n d2advdt_c,\n recalculate_c)\n\n return_tuple = (a_c.value, )\n if not dadt is None:\n return_tuple += (dadt_c[0], )\n if not dadv is None:\n return_tuple += (dadv_c[0], )\n\n return return_tuple\n\n def chemical_potential_tv(self, temp, volume, n, dmudt=None, dmudv=None, dmudn=None):\n \"\"\"Calculate chemical potential given temperature, volume and mol numbers.\n\n Args:\n temp (float): Temperature (K)\n volume (float): Volume (m3)\n n (array_like): Mol numbers (mol)\n dmudt (No type, optional): Flag to activate calculation. Defaults to None.\n dmudv (No type, optional): Flag to activate calculation. Defaults to None.\n dmudn (No type, optional): Flag to activate calculation. Defaults to None.\n\n Returns:\n float: Chemical potential (J/mol)\n Optionally chemical potential differentials\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n v_c = c_double(volume)\n mu_c = (c_double * len(n))(0.0)\n n_c = (c_double * len(n))(*n)\n\n null_pointer = POINTER(c_double)()\n if dmudt is None:\n dmudt_c = null_pointer\n else:\n dmudt_c = (c_double * len(n))(0.0)\n if dmudv is None:\n dmudv_c = null_pointer\n else:\n dmudv_c = (c_double * len(n))(0.0)\n if dmudn is None:\n dmudn_c = null_pointer\n else:\n dmudn_c = (c_double * len(n)**2)(0.0)\n\n recalculate_c = POINTER(c_int)(c_int(1))\n\n self.s_chempot.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_chempot.restype = None\n\n self.s_chempot(byref(temp_c),\n byref(v_c),\n n_c,\n mu_c,\n dmudv_c,\n dmudt_c,\n dmudn_c,\n recalculate_c)\n\n return_tuple = (np.array(mu_c), )\n if not dmudt is None:\n return_tuple += (np.array(dmudt_c), )\n if not dmudv is None:\n return_tuple += (np.array(dmudv_c), )\n if not dmudn is None:\n dmudn = np.zeros((len(n), len(n)))\n for i in range(len(n)):\n for j in range(len(n)):\n dmudn[i][j] = dmudn_c[i + j*len(n)]\n return_tuple += (np.array(dmudn), )\n\n return return_tuple\n\n def fugacity_tv(self, temp, volume, n, dlnphidt=None, dlnphidv=None, dlnphidn=None):\n \"\"\"Calculate natural logarithm of fugacity given temperature, volume and mol numbers.\n\n Args:\n temp (float): Temperature (K)\n volume (float): Volume (m3)\n n (array_like): Mol numbers (mol)\n dlnphidt (No type, optional): Flag to activate calculation. Defaults to None.\n dlnphidv (No type, optional): Flag to activate calculation. Defaults to None.\n dlnphidn (No type, optional): Flag to activate calculation. Defaults to None.\n\n Returns:\n ndarry: Natural logarithm of fugacity\n Optionally differentials\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n v_c = c_double(volume)\n lnphi_c = (c_double * len(n))(0.0)\n n_c = (c_double * len(n))(*n)\n\n null_pointer = POINTER(c_double)()\n if dlnphidt is None:\n dlnphidt_c = null_pointer\n else:\n dlnphidt_c = (c_double * len(n))(0.0)\n if dlnphidv is None:\n dlnphidv_c = null_pointer\n else:\n dlnphidv_c = (c_double * len(n))(0.0)\n if dlnphidn is None:\n dlnphidn_c = null_pointer\n else:\n dlnphidn_c = (c_double * len(n)**2)(0.0)\n\n self.s_lnphi_tv.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_lnphi_tv.restype = None\n\n self.s_lnphi_tv(byref(temp_c),\n byref(v_c),\n n_c,\n lnphi_c,\n dlnphidt_c,\n dlnphidv_c,\n dlnphidn_c)\n\n return_tuple = (np.array(lnphi_c), )\n if not dlnphidt is None:\n return_tuple += (np.array(dlnphidt_c), )\n if not dlnphidv is None:\n return_tuple += (np.array(dlnphidv_c), )\n if not dlnphidn is None:\n dlnphidn = np.zeros((len(n),len(n)))\n for i in range(len(n)):\n for j in range(len(n)):\n dlnphidn[i][j] = dlnphidn_c[i + j*len(n)]\n return_tuple += (dlnphidn, )\n\n return return_tuple\n\n #################################\n # Saturation interfaces\n #################################\n\n def bubble_temperature(self, press, z):\n \"\"\"Calculate bubble temperature given pressure and composition\n\n Args:\n press (float): Pressure (Pa)\n z (array_like): Composition (-)\n\n Raises:\n Exception: Faild to calculate\n\n Returns:\n float: Temperature (K)\n ndarray: Incipient phase composition\n \"\"\"\n self.activate()\n press_c = c_double(press)\n y_c = (c_double * len(z))(0.0)\n z_c = (c_double * len(z))(*z)\n ierr_c = c_int(0)\n\n self.s_bubble_t.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_bubble_t.restype = c_double\n\n temp = self.s_bubble_t(byref(press_c),\n z_c,\n y_c,\n byref(ierr_c))\n\n y = np.array(y_c)\n if ierr_c.value != 0:\n raise Exception(\"bubble_temperature calclualtion failed\")\n return temp, y\n\n def bubble_pressure(self, temp, z):\n \"\"\"Calculate bubble pressure given temperature and composition\n\n Args:\n temp (float): Temperature (K)\n z (array_like): Composition (-)\n\n Raises:\n Exception: Faild to calculate\n\n Returns:\n float: Pressure (Pa)\n ndarray: Incipient phase composition\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n y_c = (c_double * len(z))(0.0)\n z_c = (c_double * len(z))(*z)\n ierr_c = c_int(0)\n\n self.s_bubble_p.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_bubble_p.restype = c_double\n\n press = self.s_bubble_p(byref(temp_c),\n z_c,\n y_c,\n byref(ierr_c))\n\n y = np.array(y_c)\n if ierr_c.value != 0:\n raise Exception(\"bubble_pressure calclualtion failed\")\n return press, y\n\n def dew_temperature(self,press,z):\n \"\"\"Calculate dew temperature given pressure and composition\n\n Args:\n temp (float): Pressure (Pa)\n z (float): Compositon (-)\n\n Raises:\n Exception: Not able to solve for dew point\n\n Returns:\n float : Temperature (K)\n ndarray : Incipient phase composition (-)\n \"\"\"\n self.activate()\n press_c = c_double(press)\n x_c = (c_double * len(z))(0.0)\n z_c = (c_double * len(z))(*z)\n ierr_c = c_int(0)\n\n self.s_dew_t.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_dew_t.restype = c_double\n\n temp = self.s_dew_t(byref(press_c),\n x_c,\n z_c,\n byref(ierr_c))\n\n x = np.array(x_c)\n if ierr_c.value != 0:\n raise Exception(\"dew_temperature calclualtion failed\")\n return temp, x\n\n def dew_pressure(self,temp,z):\n \"\"\"Calculate dew pressure given temperature and composition\n\n Args:\n temp (float): Temperature (K)\n z (float): Compositon (-)\n\n Raises:\n Exception: Not able to solve for dew point\n\n Returns:\n float : Pressure (Pa)\n ndarray : Incipient phase composition (-)\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n x_c = (c_double * len(z))(0.0)\n z_c = (c_double * len(z))(*z)\n ierr_c = c_int(0)\n\n self.s_dew_p.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_dew_p.restype = c_double\n\n press = self.s_dew_p(byref(temp_c),\n x_c,\n z_c,\n byref(ierr_c))\n\n x = np.array(x_c)\n if ierr_c.value != 0:\n raise Exception(\"bubble_pressure calclualtion failed\")\n return press, x\n\n def get_envelope_twophase(self, initial_pressure, z, maximum_pressure=1.5e7,\n minimum_temperature=None, step_size=None,\n calc_v=False):\n \"\"\"Get the phase-envelope\n\n Args:\n initial_pressure (float): Start mapping form dew point at initial pressure (Pa).\n z (array_like): Composition (-)\n maximum_pressure (float , optional): Exit on maximum pressure (Pa). Defaults to 1.5e7.\n minimum_temperature (float , optional): Exit on minimum pressure (Pa). Defaults to None.\n step_size (float , optional): Tune step size of envelope trace. Defaults to None.\n calc_v (bool, optional): Calculate specifc volume of saturated phase? Defaults to False\n Returns:\n ndarray: Temperature values (K)\n ndarray: Pressure values (Pa)\n ndarray (optional): Specific volume (m3/mol)\n \"\"\"\n self.activate()\n nmax = 1000\n z_c = (c_double * len(z))(*z)\n temp_c = c_double(0.0)\n press_c = c_double(initial_pressure)\n spec_c = c_int(1)\n beta_in_c = c_double(1.0)\n max_press_c = c_double(maximum_pressure)\n nmax_c = c_int(nmax)\n Ta_c = (c_double * nmax)(0.0)\n Pa_c = (c_double * nmax)(0.0)\n Ki_c = (c_double * (nmax*len(z)))(0.0)\n beta_c = (c_double * nmax)(0.0)\n n_c = c_int(0)\n null_pointer = POINTER(c_double)()\n criconden_c = null_pointer\n crit_c = null_pointer\n if step_size is None:\n ds_c = null_pointer\n else:\n ds_c = POINTER(c_double)(c_double(step_size))\n exitOnTriplePoint_c = POINTER(c_int)()\n if minimum_temperature is None:\n tme_c = null_pointer\n else:\n tme_c = POINTER(c_double)(c_double(minimum_temperature))\n\n self.s_envelope_plot.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double )]\n\n self.s_envelope_plot.restype = None\n\n self.s_envelope_plot(z_c,\n byref(temp_c),\n byref(press_c),\n byref(spec_c),\n byref(beta_in_c),\n byref(max_press_c),\n byref(nmax_c),\n Ta_c,\n Pa_c,\n Ki_c,\n beta_c,\n byref(n_c),\n criconden_c,\n crit_c,\n ds_c,\n exitOnTriplePoint_c,\n tme_c)\n\n t_vals = np.array(Ta_c[0:n_c.value])\n p_vals = np.array(Pa_c[0:n_c.value])\n\n return_tuple = (t_vals, p_vals)\n\n if calc_v:\n # Special treatment for single phase\n if np.amax(z) == 1:\n t_vals_single = np.zeros(2*n_c.value)\n p_vals_single = np.zeros(2*n_c.value)\n v_vals_single = np.zeros_like(t_vals_single)\n for i in range(n_c.value):\n t_vals_single[i] = t_vals[i]\n t_vals_single[-i-1] = t_vals[i]\n p_vals_single[i] = p_vals[i]\n p_vals_single[-i-1] = p_vals[i]\n v_vals_single[i], = self.specific_volume(t_vals[i], p_vals[i], z, self.VAPPH)\n v_vals_single[-i-1], = self.specific_volume(t_vals[i], p_vals[i], z, self.LIQPH)\n return_tuple = (t_vals_single, p_vals_single, v_vals_single)\n else:\n v_vals = np.zeros_like(t_vals)\n for i in range(n_c.value):\n if beta_c[i] > 0.5:\n phase = self.VAPPH\n else:\n phase = self.LIQPH\n v_vals[i], = self.specific_volume(t_vals[i], p_vals[i], z, phase)\n return_tuple += (v_vals, )\n\n return return_tuple\n\n def get_binary_pxy(self,\n temp,\n maximum_pressure=1.5e7,\n minimum_pressure=1.0e5,\n maximum_dz = 0.003,\n maximum_dlns=0.01):\n \"\"\"Calculate binary three phase envelope\n\n Args:\n temp (float): Temperature (K)\n maximum_pressure (float, optional): Exit on maximum pressure (Pa). Defaults to 1.5e7.\n minimum_pressure (float, optional): Exit on minimum pressure (Pa). Defaults to 1.0e5.\n maximum_dz (float, optional): [description]. Defaults to 0.003.\n maximum_dlns (float, optional): [description]. Defaults to 0.01.\n\n Returns:\n tuple of arrays: LLE, L1VE, L2VE\n \"\"\"\n # Redefinition of module parameter:\n self.activate()\n nmax = 10000\n #c_int.in_dll(self.tp, self.get_export_name(\"binaryplot\", \"maxpoints\")).value\n\n temp_c = c_double(temp)\n min_temp_c = c_double(0.0)\n ispec_c = c_int(1)\n press_c = c_double(0.0)\n max_press_c = c_double(maximum_pressure)\n min_press_c = c_double(minimum_pressure)\n dz_max_c = c_double(maximum_dz)\n dlns_max_c = c_double(maximum_dlns)\n filename = \"binaryVLLE.dat\"\n filename_c = c_char_p(filename.encode('ascii'))\n filename_len = c_len_type(len(filename))\n res_c = (c_double * (nmax*9))(0.0)\n nres_c = (c_int * 3)(0)\n wsf_c = c_int(1)\n\n self.s_binary_plot.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_char_p ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_int ),\n POINTER( c_double ),\n c_len_type]\n\n self.s_binary_plot.restype = None\n\n self.s_binary_plot(byref(temp_c),\n byref(press_c),\n byref(ispec_c),\n byref(min_temp_c),\n byref(max_press_c),\n byref(dz_max_c),\n filename_c,\n byref(dlns_max_c),\n res_c,\n nres_c,\n byref(wsf_c),\n byref(min_press_c),\n filename_len)\n\n nLLE = nres_c[0]\n nL1VE = nres_c[1]\n nL2VE = nres_c[2]\n\n if nLLE > 0:\n xLLE = np.zeros(nLLE)\n wLLE = np.zeros(nLLE)\n pLLE = np.zeros(nLLE)\n for i in range(nLLE):\n xLLE[i] = res_c[i*9]\n wLLE[i] = res_c[i*9+1]\n pLLE[i] = res_c[i*9+2]\n LLE = (xLLE, wLLE, pLLE)\n else:\n LLE = (None, None, None)\n\n if nL1VE > 0:\n xL1VE = np.zeros(nL1VE)\n wL1VE = np.zeros(nL1VE)\n pL1VE = np.zeros(nL1VE)\n for i in range(nL1VE):\n xL1VE[i] = res_c[i*9+3]\n wL1VE[i] = res_c[i*9+4]\n pL1VE[i] = res_c[i*9+5]\n L1VE = (xL1VE, wL1VE, pL1VE)\n else:\n L1VE = (None, None, None)\n\n if nL2VE > 0:\n xL2VE = np.zeros(nL2VE)\n wL2VE = np.zeros(nL2VE)\n pL2VE = np.zeros(nL2VE)\n for i in range(nL2VE):\n xL2VE[i] = res_c[i*9+6]\n wL2VE[i] = res_c[i*9+7]\n pL2VE[i] = res_c[i*9+8]\n L2VE = (xL2VE, wL2VE, pL2VE)\n else:\n L2VE = (None, None, None)\n\n return LLE, L1VE, L2VE\n\n def get_bp_term(self,\n i_term):\n \"\"\"Get error description for binary plot error\n\n Args:\n i_term (int): binary plot error identifyer\n\n Returns:\n str: Error message\n \"\"\"\n message_len = 50\n message_c = c_char_p(b\" \" * message_len)\n message_len = c_len_type(message_len)\n i_term_c = c_int(i_term)\n\n self.s_get_bp_term.argtypes = [POINTER( c_int ),\n c_char_p,\n c_len_type]\n\n self.s_get_bp_term.restype = None\n\n self.s_get_bp_term(byref(i_term_c),\n message_c,\n message_len)\n message = message_c.value.decode('ascii')\n return message\n\n def global_binary_plot(self,\n maximum_pressure=1.5e7,\n minimum_pressure=1.0e5,\n minimum_temperature=150.0,\n maximum_temperature=500.0,\n include_azeotropes=False):\n \"\"\"Calculate global binary phase envelope\n\n Args:\n maximum_pressure (float, optional): Exit on maximum pressure (Pa). Defaults to 1.5e7.\n minimum_pressure (float, optional): Exit on minimum pressure (Pa). Defaults to 1.0e5.\n minimum_temperature (float, optional): Terminate phase line traceing at minimum temperature. Defaults to 150.0 K.\n maximum_temperature (float, optional): Terminate phase line traceing at maximum temperature. Defaults to 500.0 K.\n include_azeotropes (bool, optional): Include azeotropic lines. Defaults to False.\n\n Returns:\n tuple of arrays\n \"\"\"\n self.activate()\n max_press_c = c_double(maximum_pressure)\n min_press_c = c_double(minimum_pressure)\n max_temp_c = c_double(maximum_temperature)\n min_temp_c = c_double(minimum_temperature)\n az_bool_c = c_int(1 if include_azeotropes else 0)\n filename = \"global_binary.dat\"\n filename_c = c_char_p(filename.encode('ascii'))\n filename_len = c_len_type(len(filename))\n i_term_c = c_int(0)\n\n self.s_global_binary_plot.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n c_char_p,\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_int ),\n c_len_type]\n\n self.s_global_binary_plot.restype = None\n\n self.s_global_binary_plot(byref(min_press_c),\n byref(max_press_c),\n byref(min_temp_c),\n filename_c,\n byref(i_term_c),\n byref(max_temp_c),\n byref(az_bool_c),\n filename_len)\n\n if not i_term_c.value == 0:\n message = self.get_bp_term(i_term_c.value)\n print(message)\n\n # Load file with filename and read into arrays\n return plotutils.get_globa_binary_data(filename)\n\n def solid_envelope_plot(self, initial_pressure, z, maximum_pressure=1.5e7,\n minimum_temperature=170.0, calc_esv=False):\n \"\"\"Calculate phase envelope including solid lines\n\n Args:\n initial_pressure (float): Start mapping from initial pressure (Pa).\n z (array_like): Composition (-)\n maximum_pressure (float , optional): Exit on maximum pressure (Pa). Defaults to 1.5e7.\n calc_esv (bool, optional): Calculate specifc volume of saturated phase? Defaults to False\n\n Returns:\n tuple of arrays\n \"\"\"\n self.activate()\n z_c = (c_double * len(z))(*z)\n temp_c = c_double(0.0)\n press_c = c_double(initial_pressure)\n max_press_c = c_double(maximum_pressure)\n filename = \"solid_envelope.dat\"\n filename_c = c_char_p(filename.encode('ascii'))\n filename_len = c_len_type(len(filename))\n i_spec_c = c_int(1)\n esv_bool_c = c_int(1 if calc_esv else 0)\n\n min_t = self.get_tmin()\n self.set_tmin(minimum_temperature)\n\n self.s_solid_envelope_plot.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n c_char_p,\n POINTER( c_int ),\n c_len_type]\n\n self.s_solid_envelope_plot.restype = None\n\n self.s_solid_envelope_plot(z_c,\n byref(temp_c),\n byref(press_c),\n byref(i_spec_c),\n byref(max_press_c),\n filename_c,\n byref(esv_bool_c),\n filename_len)\n\n self.set_tmin(min_t)\n\n #if .not. i_term_c.value == 0:\n # message = self.get_bp_term(iTerm)\n # print(message)\n\n # Load file with filename and read into lists....\n return plotutils.get_solid_envelope_data(filename)\n\n def get_isotherm(self,\n temp,\n z,\n minimum_pressure=1.0e5,\n maximum_pressure=1.5e7,\n nmax=100):\n \"\"\"Get iso-therm at specified temperature\n\n Args:\n temp (float): Temperature (K)\n z (array_like): Composition (-)\n minimum_pressure (float, optional): Map to minimum pressure. Defaults to 1.0e5. (Pa)\n maximum_pressure (float, optional): Map to maximum pressure. Defaults to 1.5e7. (Pa)\n nmax (int, optional): Maximum number of points on iso-therm. Defaults to 100.\n\n Returns:\n Multiple numpy arrays.\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n minimum_pressure_c = c_double(minimum_pressure)\n maximum_pressure_c = c_double(maximum_pressure)\n z_c = (c_double * len(z))(*z)\n va_c = (c_double * nmax)(0.0)\n pa_c = (c_double * nmax)(0.0)\n sa_c = (c_double * nmax)(0.0)\n ha_c = (c_double * nmax)(0.0)\n nmax_c = c_int(nmax)\n na_c = c_int(0)\n\n self.s_isotherm.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_isotherm.restype = None\n\n self.s_isotherm(byref(temp_c),\n byref(minimum_pressure_c),\n byref(maximum_pressure_c),\n z_c,\n byref(nmax_c),\n pa_c,\n va_c,\n sa_c,\n ha_c,\n byref(na_c))\n\n p_vals = np.array(pa_c[0:na_c.value])\n v_vals = np.array(va_c[0:na_c.value])\n s_vals = np.array(sa_c[0:na_c.value])\n h_vals = np.array(ha_c[0:na_c.value])\n\n return p_vals, v_vals, s_vals, h_vals\n\n def get_isobar(self,\n press,\n z,\n minimum_temperature=200.0,\n maximum_temperature=500.0,\n nmax=100):\n \"\"\"Get isobar at specified pressure.\n\n Args:\n press (float): Pressure (Pa)\n z (array_like): Composition (-)\n minimum_temperature (float, optional): Minimum temperature. Defaults to 200.0. (K)\n maximum_temperature (float, optional): Maximum temperature. Defaults to 500.0. (K)\n nmax (int, optional): Maximum number of points on iso-bar. Defaults to 100.\n\n Returns:\n Multiple numpy arrays.\n \"\"\"\n self.activate()\n press_c = c_double(press)\n minimum_temperature_c = c_double(minimum_temperature)\n maximum_temperature_c = c_double(maximum_temperature)\n z_c = (c_double * len(z))(*z)\n va_c = (c_double * nmax)(0.0)\n ta_c = (c_double * nmax)(0.0)\n sa_c = (c_double * nmax)(0.0)\n ha_c = (c_double * nmax)(0.0)\n nmax_c = c_int(nmax)\n na_c = c_int(0)\n\n self.s_isobar.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_isobar.restype = None\n\n self.s_isobar(byref(press_c),\n byref(minimum_temperature_c),\n byref(maximum_temperature_c),\n z_c,\n byref(nmax_c),\n ta_c,\n va_c,\n sa_c,\n ha_c,\n byref(na_c))\n\n t_vals = np.array(ta_c[0:na_c.value])\n v_vals = np.array(va_c[0:na_c.value])\n s_vals = np.array(sa_c[0:na_c.value])\n h_vals = np.array(ha_c[0:na_c.value])\n\n return t_vals, v_vals, s_vals, h_vals\n\n def get_isenthalp(self,\n enthalpy,\n z,\n minimum_pressure=1.0e5,\n maximum_pressure=1.5e7,\n minimum_temperature=200.0,\n maximum_temperature=500.0,\n nmax=100):\n \"\"\"Get isenthalpy given specified enthalpy.\n\n Args:\n enthalpy (float): Enthalpy (J/mol)\n z (array_like): Composition (-)\n minimum_pressure (float, optional): Minimum pressure. Defaults to 1.0e5. (Pa)\n maximum_pressure (float, optional): Maximum pressure. Defaults to 1.5e7. (Pa)\n minimum_temperature (float, optional): Minimum temperature. Defaults to 200.0. (K)\n maximum_temperature (float, optional): Maximum temperature. Defaults to 500.0. (K)\n nmax (int, optional): Maximum number of points on isenthalp. Defaults to 100.\n\n Returns:\n Multiple numpy arrays.\n \"\"\"\n self.activate()\n enthalpy_c = c_double(enthalpy)\n minimum_pressure_c = c_double(minimum_pressure)\n maximum_pressure_c = c_double(maximum_pressure)\n minimum_temperature_c = c_double(minimum_temperature)\n maximum_temperature_c = c_double(maximum_temperature)\n z_c = (c_double * len(z))(*z)\n va_c = (c_double * nmax)(0.0)\n ta_c = (c_double * nmax)(0.0)\n sa_c = (c_double * nmax)(0.0)\n pa_c = (c_double * nmax)(0.0)\n nmax_c = c_int(nmax)\n na_c = c_int(0)\n\n self.s_isenthalp.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_isenthalp.restype = None\n\n self.s_isenthalp(byref(enthalpy_c),\n byref(minimum_pressure_c),\n byref(maximum_pressure_c),\n byref(minimum_temperature_c),\n byref(maximum_temperature_c),\n z_c,\n byref(nmax_c),\n pa_c,\n va_c,\n sa_c,\n ta_c,\n byref(na_c))\n\n t_vals = np.array(ta_c[0:na_c.value])\n v_vals = np.array(va_c[0:na_c.value])\n s_vals = np.array(sa_c[0:na_c.value])\n p_vals = np.array(pa_c[0:na_c.value])\n\n return t_vals, p_vals, v_vals, s_vals\n\n def get_isentrope(self,\n entropy,\n z,\n minimum_pressure=1.0e5,\n maximum_pressure=1.5e7,\n minimum_temperature=200.0,\n maximum_temperature=500.0,\n nmax=100):\n \"\"\"Get isentrope at specified entropy.\n\n Args:\n entropy (float): Entropy (J/mol/K)\n z (array_like): Composition (-)\n minimum_pressure (float, optional): Minimum pressure. Defaults to 1.0e5. (Pa)\n maximum_pressure (float, optional): Maximum pressure. Defaults to 1.5e7. (Pa)\n minimum_temperature (float, optional): Minimum temperature. Defaults to 200.0. (K)\n maximum_temperature (float, optional): Maximum temperature. Defaults to 500.0. (K)\n nmax (int, optional): Maximum number of points on isentrope. Defaults to 100.\n\n Returns:\n Multiple numpy arrays.\n \"\"\"\n self.activate()\n entropy_c = c_double(entropy)\n minimum_pressure_c = c_double(minimum_pressure)\n maximum_pressure_c = c_double(maximum_pressure)\n minimum_temperature_c = c_double(minimum_temperature)\n maximum_temperature_c = c_double(maximum_temperature)\n z_c = (c_double * len(z))(*z)\n va_c = (c_double * nmax)(0.0)\n ta_c = (c_double * nmax)(0.0)\n ha_c = (c_double * nmax)(0.0)\n pa_c = (c_double * nmax)(0.0)\n nmax_c = c_int(nmax)\n na_c = c_int(0)\n\n self.s_isentrope.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int )]\n\n self.s_isentrope.restype = None\n\n self.s_isentrope(byref(entropy_c),\n byref(minimum_pressure_c),\n byref(maximum_pressure_c),\n byref(minimum_temperature_c),\n byref(maximum_temperature_c),\n z_c,\n byref(nmax_c),\n pa_c,\n va_c,\n ha_c,\n ta_c,\n byref(na_c))\n\n t_vals = np.array(ta_c[0:na_c.value])\n v_vals = np.array(va_c[0:na_c.value])\n h_vals = np.array(ha_c[0:na_c.value])\n p_vals = np.array(pa_c[0:na_c.value])\n\n return t_vals, p_vals, v_vals, h_vals\n\n #################################\n # Stability interfaces\n #################################\n\n def critical(self, n, temp=0.0, v=0.0, tol=1.0e-7):\n \"\"\"Calculate critical point in variables T and V\n\n Args:\n n (array_like): Mol numbers (mol)\n temp (float, optional): Initial guess for temperature (K). Defaults to 0.0.\n v (float, optional): Initial guess for volume (m3). Defaults to 0.0.\n tol (float, optional): Error tolerance (-). Defaults to 1.0e-8.\n\n Raises:\n Exception: Failure to solve for critcal point\n\n Returns:\n float: Temperature (K)\n float: Volume (m3)\n float: Pressure (Pa)\n \"\"\"\n self.activate()\n temp_c = c_double(temp)\n v_c = c_double(v)\n n_c = (c_double * len(n))(*n)\n ierr_c = c_int(0)\n P_c = c_double(0.0)\n tol_c = c_double(tol)\n self.s_crit_tv.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_int ),\n POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_crit_tv.restype = None\n\n self.s_crit_tv(byref(temp_c),\n byref(v_c),\n n_c,\n byref(ierr_c),\n byref(tol_c),\n byref(P_c))\n\n if ierr_c.value != 0:\n raise Exception(\"critical calclualtion failed\")\n\n return temp_c.value, v_c.value, P_c.value\n\n #################################\n # Virial interfaces\n #################################\n\n def virial_coeffcients(self, temp, n):\n \"\"\"Calculate (composition-dependent) virial coefficients B and C,\n defined as P/RT = rho + B*rho**2 + C*rho**3 + O(rho**4) as rho->0.\n\n Args:\n temp (float): Temperature\n n (array_like): Mol numbers (mol)\n\n Returns:\n float: B (m3/mol)\n float: C (m6/mol2)\n \"\"\"\n self.activate()\n temp_c = POINTER( c_double )(c_double(temp))\n n_c = (c_double * len(n))(*n)\n B_c = c_double(0.0)\n C_c = c_double(0.0)\n self.s_virial_coeffcients.argtypes = [POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_virial_coeffcients.restype = None\n\n self.s_virial_coeffcients(temp_c,\n n_c,\n byref(B_c),\n byref(C_c))\n\n return B_c.value, C_c.value\n\n def second_virial_matrix(self, temp):\n \"\"\"Calculate composition-independent virial coefficients B,\n defined as P = RT*rho + B*rho**2 + C*rho**3 + O(rho**4) as rho->0.\n Including cross coefficients.\n\n Args:\n temp (float): Temperature (K)\n\n Returns:\n ndarray: B - Second virial coefficient matrix (m3/mol)\n \"\"\"\n self.activate()\n temp_c = POINTER( c_double )(c_double(temp))\n bmat_c = (c_double * self.nc**2)(0.0)\n\n self.s_second_virial_matrix.argtypes = [POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_second_virial_matrix.restype = None\n\n self.s_second_virial_matrix(temp_c, bmat_c)\n\n bmat = np.zeros((self.nc,self.nc))\n for i in range(self.nc):\n for j in range(self.nc):\n bmat[i][j] = bmat_c[i+j*self.nc]\n\n return bmat\n\n def binary_third_virial_matrix(self, temp):\n \"\"\"Calculate composition-independent virial coefficients C,\n defined as P = RT*rho + B*rho**2 + C*rho**3 + O(rho**4) as rho->0.\n Including cross coefficients\n Currently the code only support binary mixtures\n\n Args:\n temp (float): Temperature (K)\n\n Returns:\n ndarray: C - Third virial coefficient matrix (m6/mol2)\n \"\"\"\n self.activate()\n assert self.nc == 2\n temp_c = POINTER( c_double )(c_double(temp))\n cmat_c = (c_double * self.nc**2)(0.0)\n\n self.s_binary_third_virial_matrix.argtypes = [POINTER( c_double ),\n POINTER( c_double )]\n\n self.s_binary_third_virial_matrix.restype = None\n\n self.s_binary_third_virial_matrix(temp_c, cmat_c)\n\n cmat = np.zeros((self.nc,self.nc))\n for i in range(self.nc):\n for j in range(self.nc):\n cmat[i][j] = cmat_c[i+j*self.nc]\n\n return cmat\n"
] | [
[
"numpy.array",
"numpy.amax",
"numpy.zeros_like",
"numpy.zeros"
]
] |
shubham-goel/pytorch3d | [
"e5e6e90af6f81b3eccb35bbdfdc7e64ec6a4df21"
] | [
"tests/bm_interpolate_face_attributes.py"
] | [
"# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.\n\nfrom itertools import product\n\nimport torch\nfrom fvcore.common.benchmark import benchmark\nfrom pytorch3d.ops.interp_face_attrs import (\n interpolate_face_attributes,\n interpolate_face_attributes_python,\n)\n\n\ndef _generate_data(N, S, K, F, D, device, requires_grad=False):\n pix_to_face = torch.randint(-10, F, (N, S, S, K), device=device)\n barycentric_coords = torch.randn(\n N, S, S, K, 3, device=device, requires_grad=requires_grad\n )\n face_attrs = torch.randn(F, 3, D, device=device, requires_grad=requires_grad)\n grad_pix_attrs = torch.randn(N, S, S, K, D, device=device)\n return pix_to_face, barycentric_coords, face_attrs, grad_pix_attrs\n\n\ndef _bm_forward(N, S, F, K, D, impl):\n # The runtime depends on the values of pix_to_face. So for proper\n # benchmarking we should probably take the average of multiple\n # values of pix to face. But this doesn't easily fit into fvcore\n # benchmarking, so instead we'll just set a manual seed to make sure\n # that different impls will use the same data.\n torch.manual_seed(0)\n device = torch.device(\"cuda\")\n data = _generate_data(N, S, K, F, D, device, requires_grad=False)\n args = data[:3]\n torch.cuda.synchronize()\n if impl == \"cuda\":\n fun = interpolate_face_attributes\n elif impl == \"python\":\n fun = interpolate_face_attributes_python\n return lambda: fun(*args)\n\n\ndef _bm_forward_backward(N, S, F, K, D, impl):\n torch.manual_seed(0)\n device = torch.device(\"cuda\")\n data = _generate_data(N, S, K, F, D, device, requires_grad=True)\n args, grad = data[:3], data[3]\n torch.cuda.synchronize()\n if impl == \"cuda\":\n fun = interpolate_face_attributes\n elif impl == \"python\":\n fun = interpolate_face_attributes_python\n\n def run():\n out = fun(*args)\n out.backward(gradient=grad)\n\n return run\n\n\ndef bm_interpolate_face_attribues() -> None:\n # For now only benchmark on GPU\n if not torch.cuda.is_available():\n return\n\n Ns = [1, 4]\n Ss = [128]\n Ks = [1, 10, 40]\n Fs = [5000]\n Ds = [1, 3, 16]\n impls = [\"python\", \"cuda\"]\n test_cases = product(Ns, Ss, Ks, Fs, Ds, impls)\n kwargs_list = []\n for case in test_cases:\n N, S, K, F, D, impl = case\n kwargs_list.append({\"N\": N, \"S\": S, \"K\": K, \"F\": F, \"D\": D, \"impl\": impl})\n benchmark(_bm_forward, \"FORWARD\", kwargs_list, warmup_iters=3)\n benchmark(_bm_forward_backward, \"FORWARD+BACKWARD\", kwargs_list, warmup_iters=3)\n\n\nif __name__ == \"__main__\":\n bm_interpolate_face_attribues()\n"
] | [
[
"torch.randint",
"torch.randn",
"torch.manual_seed",
"torch.cuda.synchronize",
"torch.cuda.is_available",
"torch.device"
]
] |
minminfly68/Song-recommendation-Project-CAPP-30122- | [
"9f97d6accdfd33c5bac267980b6c10d6d5b93bc7"
] | [
"ui/sentiment.py"
] | [
"'''\nConduct Sentiment Analysis\nChun Hu, Yimin Li, Tianyue Niu\n'''\n\nimport os\nimport json\nimport re\nimport pandas as pd\nimport nltk\nnltk.download('punkt')\nnltk.download('wordnet')\nnltk.download('stopwords')\nfrom nltk import word_tokenize, sent_tokenize\nfrom nltk.corpus import stopwords\nfrom nltk.stem import WordNetLemmatizer\nfrom textblob import TextBlob\n\n# turn off warnings\npd.set_option('mode.chained_assignment', None)\n\ncwd = os.path.dirname(__file__)\ntop_10s_path = os.path.join(cwd, 'top10s.csv')\n\n\ndef merge_two_df(top_songs, lyrics):\n '''\n Input:\n top_songs (pandas data frame): kaggle data\n lyrics (json file): lyrics scraped\n Output:\n a merged data containing lyrics (pandas data frame)\n '''\n\n # merge two df\n top_songs['lyrics'] = ''\n for index, row in top_songs.iterrows():\n tit = top_songs.title[index]\n if tit in lyrics:\n top_songs['lyrics'][index] = lyrics[tit]\n\n return top_songs\n\n\ndef process_words(words, stop):\n '''\n Input:\n words (list): a list of words\n stop (list): extra stop words we want to remove\n Output:\n new_words (list): a list of normalized words\n '''\n lemmatizer = WordNetLemmatizer()\n new_words = []\n for word in words:\n new_word = re.sub(r'[^\\w\\s]', '', word)\n if new_word != '':\n new_word = new_word.lower()\n if new_word not in stop and new_word not in stopwords.words('english'):\n new_word = lemmatizer.lemmatize(new_word, pos='v')\n new_words.append(new_word)\n return new_words\n\n\ndef add_sentiment(top_songs):\n '''\n Input:\n top_songs (pandas df): raw version\n Output:\n top_songs (pandas df): with sentiment analysis result\n '''\n\n # tokenize words\n top_songs['tokenized'] = top_songs['lyrics'].apply(\\\n lambda x: [word_tokenize(s) for s in sent_tokenize(x)])\n\n # normalize words\n top_songs['normalized'] = top_songs['tokenized']\n stop = ['chorus', 'verse', 'intro', 'pre', 'outro', 'interlude']\n for index, row in top_songs['tokenized'].items():\n new_sent = []\n for sent in row:\n new_sent += process_words(sent, stop)\n top_songs['normalized'][index] = new_sent\n\n # calculate sentiment\n top_songs['sentiment'] = ''\n for index, row in top_songs.iterrows():\n obj = TextBlob(' '.join(top_songs['normalized'][index]))\n sentiment = obj.sentiment.polarity\n top_songs['sentiment'][index] = sentiment\n\n return top_songs\n\n\ndef create_final_top_songs ():\n '''\n Input:\n None\n Output:\n top_songs (pandas df): final cleaned & processed data frame\n '''\n\n top_songs = pd.read_csv(top_10s_path)\n\n with open('lyrics_file.json') as f:\n lyrics = json.load(f)\n\n top_songs = merge_two_df(top_songs, lyrics)\n df = add_sentiment(top_songs)\n\n df.to_csv('top_songs.csv')\n\n return\n\n\nif __name__ == \"__main__\":\n create_final_top_songs()\n"
] | [
[
"pandas.read_csv",
"pandas.set_option"
]
] |
OleguerCanal/transplanter | [
"854fa727747a484dedde9092eeee6884d7d1b44b"
] | [
"test_models/data.py"
] | [
"from typing import Optional\nimport pytorch_lightning as pl\nimport torchvision\nimport torchvision.transforms as transforms\nfrom torchvision.datasets import CIFAR10\nfrom torch.utils.data import DataLoader, random_split\n\n\nclass CIFARDataModule(pl.LightningDataModule):\n def __init__(self, data_dir: str = \"./data\", batch_size: int = 32):\n super().__init__()\n self.data_dir = data_dir\n self.batch_size = batch_size\n\n def setup(self, stage: Optional[str] = None):\n transform = transforms.Compose(\n [transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n\n # Train/val\n cifar_full = CIFAR10(root=self.data_dir, train=True, download=True, transform=transform)\n n_train, n_val = int(len(cifar_full)*0.9), int(len(cifar_full)*0.1)\n self.cifar_train, self.cifar_val = random_split(cifar_full, [n_train, n_val])\n \n # Test\n self.cifar_test = CIFAR10(self.data_dir, train=False)\n\n def train_dataloader(self):\n return DataLoader(self.cifar_train, batch_size=self.batch_size)\n\n def val_dataloader(self):\n return DataLoader(self.cifar_val, batch_size=self.batch_size)\n\n def test_dataloader(self):\n return DataLoader(self.cifar_test, batch_size=self.batch_size)\n"
] | [
[
"torch.utils.data.DataLoader",
"torch.utils.data.random_split"
]
] |
mlline00/pandas | [
"4071dde86e33434e1bee8304fa62074949f813cc",
"4071dde86e33434e1bee8304fa62074949f813cc"
] | [
"pandas/tests/series/test_cumulative.py",
"pandas/core/indexers.py"
] | [
"\"\"\"\nTests for Series cumulative operations.\n\nSee also\n--------\ntests.frame.test_cumulative\n\"\"\"\nfrom itertools import product\n\nimport numpy as np\nimport pytest\n\nimport pandas as pd\nimport pandas.util.testing as tm\n\n\ndef _check_accum_op(name, series, check_dtype=True):\n func = getattr(np, name)\n tm.assert_numpy_array_equal(\n func(series).values, func(np.array(series)), check_dtype=check_dtype,\n )\n\n # with missing values\n ts = series.copy()\n ts[::2] = np.NaN\n\n result = func(ts)[1::2]\n expected = func(np.array(ts.dropna()))\n\n tm.assert_numpy_array_equal(result.values, expected, check_dtype=False)\n\n\nclass TestSeriesCumulativeOps:\n def test_cumsum(self, datetime_series):\n _check_accum_op(\"cumsum\", datetime_series)\n\n def test_cumprod(self, datetime_series):\n _check_accum_op(\"cumprod\", datetime_series)\n\n def test_cummin(self, datetime_series):\n tm.assert_numpy_array_equal(\n datetime_series.cummin().values,\n np.minimum.accumulate(np.array(datetime_series)),\n )\n ts = datetime_series.copy()\n ts[::2] = np.NaN\n result = ts.cummin()[1::2]\n expected = np.minimum.accumulate(ts.dropna())\n\n tm.assert_series_equal(result, expected)\n\n def test_cummax(self, datetime_series):\n tm.assert_numpy_array_equal(\n datetime_series.cummax().values,\n np.maximum.accumulate(np.array(datetime_series)),\n )\n ts = datetime_series.copy()\n ts[::2] = np.NaN\n result = ts.cummax()[1::2]\n expected = np.maximum.accumulate(ts.dropna())\n\n tm.assert_series_equal(result, expected)\n\n @pytest.mark.parametrize(\"tz\", [None, \"US/Pacific\"])\n def test_cummin_datetime64(self, tz):\n s = pd.Series(\n pd.to_datetime(\n [\"NaT\", \"2000-1-2\", \"NaT\", \"2000-1-1\", \"NaT\", \"2000-1-3\"]\n ).tz_localize(tz)\n )\n\n expected = pd.Series(\n pd.to_datetime(\n [\"NaT\", \"2000-1-2\", \"NaT\", \"2000-1-1\", \"NaT\", \"2000-1-1\"]\n ).tz_localize(tz)\n )\n result = s.cummin(skipna=True)\n tm.assert_series_equal(expected, result)\n\n expected = pd.Series(\n pd.to_datetime(\n [\"NaT\", \"2000-1-2\", \"2000-1-2\", \"2000-1-1\", \"2000-1-1\", \"2000-1-1\"]\n ).tz_localize(tz)\n )\n result = s.cummin(skipna=False)\n tm.assert_series_equal(expected, result)\n\n @pytest.mark.parametrize(\"tz\", [None, \"US/Pacific\"])\n def test_cummax_datetime64(self, tz):\n s = pd.Series(\n pd.to_datetime(\n [\"NaT\", \"2000-1-2\", \"NaT\", \"2000-1-1\", \"NaT\", \"2000-1-3\"]\n ).tz_localize(tz)\n )\n\n expected = pd.Series(\n pd.to_datetime(\n [\"NaT\", \"2000-1-2\", \"NaT\", \"2000-1-2\", \"NaT\", \"2000-1-3\"]\n ).tz_localize(tz)\n )\n result = s.cummax(skipna=True)\n tm.assert_series_equal(expected, result)\n\n expected = pd.Series(\n pd.to_datetime(\n [\"NaT\", \"2000-1-2\", \"2000-1-2\", \"2000-1-2\", \"2000-1-2\", \"2000-1-3\"]\n ).tz_localize(tz)\n )\n result = s.cummax(skipna=False)\n tm.assert_series_equal(expected, result)\n\n def test_cummin_timedelta64(self):\n s = pd.Series(pd.to_timedelta([\"NaT\", \"2 min\", \"NaT\", \"1 min\", \"NaT\", \"3 min\"]))\n\n expected = pd.Series(\n pd.to_timedelta([\"NaT\", \"2 min\", \"NaT\", \"1 min\", \"NaT\", \"1 min\"])\n )\n result = s.cummin(skipna=True)\n tm.assert_series_equal(expected, result)\n\n expected = pd.Series(\n pd.to_timedelta([\"NaT\", \"2 min\", \"2 min\", \"1 min\", \"1 min\", \"1 min\"])\n )\n result = s.cummin(skipna=False)\n tm.assert_series_equal(expected, result)\n\n def test_cummax_timedelta64(self):\n s = pd.Series(pd.to_timedelta([\"NaT\", \"2 min\", \"NaT\", \"1 min\", \"NaT\", \"3 min\"]))\n\n expected = pd.Series(\n pd.to_timedelta([\"NaT\", \"2 min\", \"NaT\", \"2 min\", \"NaT\", \"3 min\"])\n )\n result = s.cummax(skipna=True)\n tm.assert_series_equal(expected, result)\n\n expected = pd.Series(\n pd.to_timedelta([\"NaT\", \"2 min\", \"2 min\", \"2 min\", \"2 min\", \"3 min\"])\n )\n result = s.cummax(skipna=False)\n tm.assert_series_equal(expected, result)\n\n def test_cummethods_bool(self):\n # GH#6270\n\n a = pd.Series([False, False, False, True, True, False, False])\n b = ~a\n c = pd.Series([False] * len(b))\n d = ~c\n methods = {\n \"cumsum\": np.cumsum,\n \"cumprod\": np.cumprod,\n \"cummin\": np.minimum.accumulate,\n \"cummax\": np.maximum.accumulate,\n }\n args = product((a, b, c, d), methods)\n for s, method in args:\n expected = pd.Series(methods[method](s.values))\n result = getattr(s, method)()\n tm.assert_series_equal(result, expected)\n\n e = pd.Series([False, True, np.nan, False])\n cse = pd.Series([0, 1, np.nan, 1], dtype=object)\n cpe = pd.Series([False, 0, np.nan, 0])\n cmin = pd.Series([False, False, np.nan, False])\n cmax = pd.Series([False, True, np.nan, True])\n expecteds = {\"cumsum\": cse, \"cumprod\": cpe, \"cummin\": cmin, \"cummax\": cmax}\n\n for method in methods:\n res = getattr(e, method)()\n tm.assert_series_equal(res, expecteds[method])\n",
"\"\"\"\nLow-dependency indexing utilities.\n\"\"\"\nimport numpy as np\n\nfrom pandas.core.dtypes.common import is_list_like\nfrom pandas.core.dtypes.generic import ABCIndexClass, ABCSeries\n\n# -----------------------------------------------------------\n# Indexer Identification\n\n\ndef is_list_like_indexer(key) -> bool:\n \"\"\"\n Check if we have a list-like indexer that is *not* a NamedTuple.\n\n Parameters\n ----------\n key : object\n\n Returns\n -------\n bool\n \"\"\"\n # allow a list_like, but exclude NamedTuples which can be indexers\n return is_list_like(key) and not (isinstance(key, tuple) and type(key) is not tuple)\n\n\ndef is_scalar_indexer(indexer, arr_value) -> bool:\n \"\"\"\n Return True if we are all scalar indexers.\n\n Returns\n -------\n bool\n \"\"\"\n if arr_value.ndim == 1:\n if not isinstance(indexer, tuple):\n indexer = tuple([indexer])\n return any(isinstance(idx, np.ndarray) and len(idx) == 0 for idx in indexer)\n return False\n\n\ndef is_empty_indexer(indexer, arr_value: np.ndarray) -> bool:\n \"\"\"\n Check if we have an empty indexer.\n\n Parameters\n ----------\n indexer : object\n arr_value : np.ndarray\n\n Returns\n -------\n bool\n \"\"\"\n if is_list_like(indexer) and not len(indexer):\n return True\n if arr_value.ndim == 1:\n if not isinstance(indexer, tuple):\n indexer = tuple([indexer])\n return any(isinstance(idx, np.ndarray) and len(idx) == 0 for idx in indexer)\n return False\n\n\n# -----------------------------------------------------------\n# Indexer Validation\n\n\ndef check_setitem_lengths(indexer, value, values) -> None:\n \"\"\"\n Validate that value and indexer are the same length.\n\n An special-case is allowed for when the indexer is a boolean array\n and the number of true values equals the length of ``value``. In\n this case, no exception is raised.\n\n Parameters\n ----------\n indexer : sequence\n Key for the setitem.\n value : array-like\n Value for the setitem.\n values : array-like\n Values being set into.\n\n Returns\n -------\n None\n\n Raises\n ------\n ValueError\n When the indexer is an ndarray or list and the lengths don't match.\n \"\"\"\n # boolean with truth values == len of the value is ok too\n if isinstance(indexer, (np.ndarray, list)):\n if is_list_like(value) and len(indexer) != len(value):\n if not (\n isinstance(indexer, np.ndarray)\n and indexer.dtype == np.bool_\n and len(indexer[indexer]) == len(value)\n ):\n raise ValueError(\n \"cannot set using a list-like indexer \"\n \"with a different length than the value\"\n )\n\n elif isinstance(indexer, slice):\n # slice\n if is_list_like(value) and len(values):\n if len(value) != length_of_indexer(indexer, values):\n raise ValueError(\n \"cannot set using a slice indexer with a \"\n \"different length than the value\"\n )\n\n\ndef validate_indices(indices: np.ndarray, n: int) -> None:\n \"\"\"\n Perform bounds-checking for an indexer.\n\n -1 is allowed for indicating missing values.\n\n Parameters\n ----------\n indices : ndarray\n n : int\n Length of the array being indexed.\n\n Raises\n ------\n ValueError\n\n Examples\n --------\n >>> validate_indices([1, 2], 3)\n # OK\n >>> validate_indices([1, -2], 3)\n ValueError\n >>> validate_indices([1, 2, 3], 3)\n IndexError\n >>> validate_indices([-1, -1], 0)\n # OK\n >>> validate_indices([0, 1], 0)\n IndexError\n \"\"\"\n if len(indices):\n min_idx = indices.min()\n if min_idx < -1:\n msg = f\"'indices' contains values less than allowed ({min_idx} < -1)\"\n raise ValueError(msg)\n\n max_idx = indices.max()\n if max_idx >= n:\n raise IndexError(\"indices are out-of-bounds\")\n\n\n# -----------------------------------------------------------\n# Indexer Conversion\n\n\ndef maybe_convert_indices(indices, n: int):\n \"\"\"\n Attempt to convert indices into valid, positive indices.\n\n If we have negative indices, translate to positive here.\n If we have indices that are out-of-bounds, raise an IndexError.\n\n Parameters\n ----------\n indices : array-like\n Array of indices that we are to convert.\n n : int\n Number of elements in the array that we are indexing.\n\n Returns\n -------\n array-like\n An array-like of positive indices that correspond to the ones\n that were passed in initially to this function.\n\n Raises\n ------\n IndexError\n One of the converted indices either exceeded the number of,\n elements (specified by `n`), or was still negative.\n \"\"\"\n if isinstance(indices, list):\n indices = np.array(indices)\n if len(indices) == 0:\n # If `indices` is empty, np.array will return a float,\n # and will cause indexing errors.\n return np.empty(0, dtype=np.intp)\n\n mask = indices < 0\n if mask.any():\n indices = indices.copy()\n indices[mask] += n\n\n mask = (indices >= n) | (indices < 0)\n if mask.any():\n raise IndexError(\"indices are out-of-bounds\")\n return indices\n\n\n# -----------------------------------------------------------\n# Unsorted\n\n\ndef length_of_indexer(indexer, target=None) -> int:\n \"\"\"\n Return the length of a single non-tuple indexer which could be a slice.\n\n Returns\n -------\n int\n \"\"\"\n if target is not None and isinstance(indexer, slice):\n target_len = len(target)\n start = indexer.start\n stop = indexer.stop\n step = indexer.step\n if start is None:\n start = 0\n elif start < 0:\n start += target_len\n if stop is None or stop > target_len:\n stop = target_len\n elif stop < 0:\n stop += target_len\n if step is None:\n step = 1\n elif step < 0:\n start, stop = stop + 1, start + 1\n step = -step\n return (stop - start + step - 1) // step\n elif isinstance(indexer, (ABCSeries, ABCIndexClass, np.ndarray, list)):\n return len(indexer)\n elif not is_list_like_indexer(indexer):\n return 1\n raise AssertionError(\"cannot find the length of the indexer\")\n"
] | [
[
"pandas.Series",
"pandas.util.testing.assert_numpy_array_equal",
"pandas.to_datetime",
"pandas.util.testing.assert_series_equal",
"numpy.array",
"pandas.to_timedelta"
],
[
"numpy.array",
"pandas.core.dtypes.common.is_list_like",
"numpy.empty"
]
] |
Shivanisen16/vtulabs | [
"2bc41d856612840cf035b570e6256ffc5bcbab5d"
] | [
"15CSL76_Machine_Learning/lab/8-em-kmeans.py"
] | [
"import copy\r\nimport numpy as np\r\nimport pandas as pd\r\nfrom matplotlib import pyplot as plt\r\nfrom sklearn.mixture import GaussianMixture\r\nfrom sklearn.cluster import KMeans\r\n\r\n# Importing the dataset\r\ndata = pd.read_csv(\"ex.csv\")\r\nprint(\"Input Data and Shape:\")\r\nprint(data.head(3))\r\nprint(\"Shape:\", data.shape)\r\n\r\n# Getting the values and plotting it\r\nf1 = data['V1'].values\r\nf2 = data['V2'].values\r\nX = np.array(list(zip(f1, f2)))\r\nprint('Graph for whole dataset')\r\nplt.scatter(f1, f2, c='black', s=50)\r\nplt.show()\r\n\r\n##########################################\r\nkmeans = KMeans(2, random_state=0)\r\nlabels = kmeans.fit(X).predict(X)\r\ncentroids = kmeans.cluster_centers_\r\nprint(\"Labels KMeans:\", labels)\r\n\r\nprint('Graph using Kmeans Algorithm')\r\n# plot all points, color the labels\r\nplt.scatter(X[:, 0], X[:, 1], c=labels, s=50)\r\n# mark centroids\r\nplt.scatter(centroids[:, 0], centroids[:, 1], marker='*', s=200, c='black')\r\nplt.show()\r\n\r\n\r\n# gmm demo\r\ngmm = GaussianMixture(n_components=2)\r\nlabels = gmm.fit(X).predict(X)\r\nprint(\"\\nLabels EM:\", labels)\r\nprint('Graph using EM Algorithm')\r\nplt.scatter(X[:, 0], X[:, 1], c=labels, s=40)\r\nplt.show()\r\n"
] | [
[
"pandas.read_csv",
"sklearn.cluster.KMeans",
"matplotlib.pyplot.show",
"sklearn.mixture.GaussianMixture",
"matplotlib.pyplot.scatter"
]
] |
moha31x/SESAME | [
"0956cbf081d1a033855173e989da6e21f0a13215"
] | [
"sesame/train_model.py"
] | [
"'''\nThis is a script to train a model with a variety of estimators\n'''\nimport pickle\nimport pandas as pd\nfrom sklearn.neural_network import MLPRegressor\nfrom config import Config\n\n# Creating a path to save our model\nConfig.models_path.mkdir(parents=True, exist_ok=True)\n\n# Loading the training and testing features into a pandas DataFrame\nx_train = pd.read_csv(str(Config.features_path / 'train_features.csv'))\ny_train = pd.read_csv(str(Config.features_path / 'train_target.csv'))\n\n# Instantiating and fitting the algorithm\nmodel = MLPRegressor(max_iter=800, alpha=0.4371)\nmodel = model.fit(x_train, y_train.to_numpy().ravel())\n\n# Saving the model into a pickle file\npickle.dump(model, open('model.pickle', 'wb'))\n"
] | [
[
"sklearn.neural_network.MLPRegressor"
]
] |
darynarr/CV_UKMA | [
"2d0e5fe42c539b441e45c4281f7dc5d42939dd89"
] | [
"ComputerVision_HW/3B-L3/match_two_strips.py"
] | [
"import cv2\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\n# We will use the function implemented in the last quiz\n# Find best match\ndef find_best_match(patch, strip):\n # TODO: Find patch in strip and return column index (x value) of topleft corner\n best_id = None\n min_diff = np.inf\n strip_n, patch_n = strip.shape[1], patch.shape[1]\n for i in range(strip_n-patch_n):\n temp = strip[:, i: i + patch_n]\n ssd = np.sum(np.power(temp - patch, 2))\n if ssd < min_diff:\n best_id, min_diff = i, ssd\n return best_id\n\n\ndef match_strips(strip_left, strip_right, b):\n # For each non-overlapping patch/block of width b in the left strip,\n # find the best matching position (along X-axis) in the right strip.\n # Return a vector of disparities (left X-position - right X-position).\n # Note: Only consider whole blocks that fit within image bounds.\n disparities = []\n\n for x_left in range(0, strip_left.shape[1]+1, b):\n patch_left = strip_left[:, x_left: x_left + b]\n x_right = find_best_match(patch_left, strip_right)\n disparities.append(x_left - x_right)\n\n return np.array([disparities])\n\n\n# Test code:\n\n# Load images\nleft = cv2.imread('images/flowers-left.png')\nright = cv2.imread('images/flowers-right.png')\ncv2.imshow('Left', left)\ncv2.imshow('Right', right)\n\n# Convert to grayscale, double, [0, 1] range for easier computation\nleft_gray = cv2.cvtColor(left, cv2.COLOR_BGR2GRAY) / 255.\nright_gray = cv2.cvtColor(right, cv2.COLOR_BGR2GRAY) / 255.\n\n# Define strip row (y) and square block size (b)\ny = 120\nb = 100\n\n# Extract strip from left image\nstrip_left = left_gray[y: y + b, :]\ncv2.imshow('Strip Left', strip_left)\n\n# Extract strip from right image\nstrip_right = right_gray[y: y + b, :]\ncv2.imshow('Strip Right', strip_right)\n\n# Now match these two strips to compute disparity values\ndisparity = match_strips(strip_left, strip_right, b)\nprint( disparity)\n\n# Finally we plot the disparity values. Note that there may be some differences\n# in the results shown in the quiz because we had to adapt the index values.\nplt.plot(range(disparity.shape[1]), disparity[0])\nplt.show()\nplt.close('all')\n"
] | [
[
"numpy.array",
"numpy.power",
"matplotlib.pyplot.show",
"matplotlib.pyplot.close"
]
] |
ryought/3d-dna | [
"caa187a272c2c3d5720727d846489d628092b680"
] | [
"scaffold/infer-distribution.py"
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\nimport dask.dataframe as ddf\nimport pandas as pd\nimport time\nfrom sklearn.neighbors.kde import KernelDensity\nfrom scipy.optimize import curve_fit\nimport numpy as np\n\ndef infer_distribution_from_contig(contacts, K, K0):\n \"\"\"\n \"\"\"\n longest_contig_name = contacts.loc[contacts.P1.idxmax()].N1\n inter_contacts = contacts[\n (contacts.N1 == longest_contig_name)\n & (contacts.N2 == longest_contig_name)]\n inter = np.abs(inter_contacts.P1.values - inter_contacts.P2.values)\n\n kde = KernelDensity(kernel='gaussian', bandwidth=200).fit(inter.reshape(-1, 1))\n f = lambda x: kde.score_samples(x.reshape(-1, 1))\n\n # distant\n x1 = np.logspace(np.log10(K0), np.log10(K), 500)\n p = lambda x, a, b: a + b * np.log(x)\n param1, cov = curve_fit(p, x1, f(x1))\n\n # proximal\n # degree = 30\n # x0 = np.logspace(0, np.log10(K0), 500)\n # param0 = np.polyfit(x0, f(x0), degree)\n\n # P = (lambda x: np.where(\n # x < K0,\n # np.poly1d(param0)(x),\n # np.where(\n # x < K,\n # param1[0] + param1[1] * np.log(x),\n # param1[0] + param1[1] * np.log(K))\n # ))\n return param1[0], param1[1]\n\ndef main():\n import sys\n if len(sys.argv) != 4:\n print('not enough arguments')\n print('usage: python infer-distribution.py foo.mnd K K0')\n return -1\n\n mnd_filename = sys.argv[1]\n K = int(sys.argv[2])\n K0 = int(sys.argv[3])\n\n # print('parsing mnd by dask.dataframe.read_csv', time.time())\n df = ddf.read_csv(\n mnd_filename,\n sep=' ',\n header=None,\n names=['N1', 'P1', 'N2', 'P2'],\n usecols=[1, 2, 5, 6],\n engine='c',\n ).compute()\n # reorder index\n # print('reset indexing', time.time())\n df = df.reset_index(drop=True)\n\n # print('fitting')\n p = infer_distribution_from_contig(df, K=K, K0=K0)\n print(p[0])\n print(p[1])\n\nmain()\n"
] | [
[
"numpy.log10",
"numpy.log",
"numpy.abs",
"sklearn.neighbors.kde.KernelDensity"
]
] |
abhikbhattacharjee/Motifizer | [
"ee816690f71325e3e17a554d43a7711f08a8c3a9"
] | [
"Peak_calling_length_python_code.py"
] | [
"import pandas as pd\nimport sys\n\npeak_calling=pd.read_excel(str(sys.argv[1]), str(sys.argv[4]))\npeak_calling['Length'] = peak_calling['End'] - peak_calling['Start'] \n\npeak_calling1=pd.read_excel(str(sys.argv[1]), str(sys.argv[3]))\npeak_calling1['Length'] = peak_calling1['End'] - peak_calling1['Start'] \n\npeak_calling2=pd.read_excel(str(sys.argv[1]), str(sys.argv[2]))\npeak_calling2['Length'] = peak_calling2['End'] - peak_calling2['Start'] \n\nwith pd.ExcelWriter('Excel/Peak_calling_length.xlsx') as writer:\n peak_calling.to_excel(writer, sheet_name='not_diff')\n peak_calling1.to_excel(writer, sheet_name='down_toptags')\n peak_calling2.to_excel(writer, sheet_name='up_toptags')\n\n"
] | [
[
"pandas.ExcelWriter"
]
] |
kilinmao/sarl_star | [
"3b9b2521436ef7f364a250da71a01e915d840296"
] | [
"navigation/arena_local_planner/model_based/crowdnav_ros/scripts/crowd_nav/utils/explorer.py"
] | [
"import logging\nimport copy\nimport torch\nfrom crowd_sim.envs.utils.info import *\n\n\nclass Explorer(object):\n def __init__(self, env, robot, device, memory=None, gamma=None, target_policy=None):\n self.env = env\n self.robot = robot\n self.device = device\n self.memory = memory\n self.gamma = gamma\n self.target_policy = target_policy\n self.target_model = None\n\n def update_target_model(self, target_model):\n self.target_model = copy.deepcopy(target_model)\n\n # @profile\n def run_k_episodes(self, k, phase, update_memory=False, imitation_learning=False, episode=None,\n print_failure=False):\n self.robot.policy.set_phase(phase)\n success_times = []\n collision_times = []\n timeout_times = []\n success = 0\n collision = 0\n timeout = 0\n too_close = 0\n min_dist = []\n cumulative_rewards = []\n collision_cases = []\n timeout_cases = []\n for i in range(k):\n ob = self.env.reset(phase)\n done = False\n states = []\n actions = []\n rewards = []\n while not done:\n action = self.robot.act(ob)\n ob, reward, done, info = self.env.step(action)\n states.append(self.robot.policy.last_state)\n actions.append(action)\n rewards.append(reward)\n\n if isinstance(info, Danger):\n too_close += 1\n min_dist.append(info.min_dist)\n\n if isinstance(info, ReachGoal):\n success += 1\n success_times.append(self.env.global_time)\n elif isinstance(info, Collision):\n collision += 1\n collision_cases.append(i)\n collision_times.append(self.env.global_time)\n elif isinstance(info, Timeout):\n timeout += 1\n timeout_cases.append(i)\n timeout_times.append(self.env.time_limit)\n else:\n raise ValueError('Invalid end signal from environment')\n\n if update_memory:\n if isinstance(info, ReachGoal) or isinstance(info, Collision):\n # only add positive(success) or negative(collision) experience in experience set\n self.update_memory(states, actions, rewards, imitation_learning)\n\n cumulative_rewards.append(sum([pow(self.gamma, t * self.robot.time_step * self.robot.v_pref)\n * reward for t, reward in enumerate(rewards)]))\n\n success_rate = success / k\n collision_rate = collision / k\n assert success + collision + timeout == k\n avg_nav_time = sum(success_times) / len(success_times) if success_times else self.env.time_limit\n\n extra_info = '' if episode is None else 'in episode {} '.format(episode)\n logging.info('{:<5} {}has success rate: {:.2f}, collision rate: {:.2f}, nav time: {:.2f}, total reward: {:.4f}'.\n format(phase.upper(), extra_info, success_rate, collision_rate, avg_nav_time,\n average(cumulative_rewards)))\n if phase in ['val', 'test']:\n total_time = sum(success_times + collision_times + timeout_times) * self.robot.time_step\n logging.info('Frequency of being in danger: %.2f and average min separate distance in danger: %.2f',\n too_close / total_time, average(min_dist))\n\n if print_failure:\n logging.info('Collision cases: ' + ' '.join([str(x) for x in collision_cases]))\n logging.info('Timeout cases: ' + ' '.join([str(x) for x in timeout_cases]))\n\n def update_memory(self, states, actions, rewards, imitation_learning=False):\n if self.memory is None or self.gamma is None:\n raise ValueError('Memory or gamma value is not set!')\n\n for i, state in enumerate(states):\n reward = rewards[i]\n\n # VALUE UPDATE\n if imitation_learning:\n # define the value of states in IL as cumulative discounted rewards, which is the same in RL\n state = self.target_policy.transform(state)\n # value = pow(self.gamma, (len(states) - 1 - i) * self.robot.time_step * self.robot.v_pref)\n value = sum([pow(self.gamma, max(t - i, 0) * self.robot.time_step * self.robot.v_pref) * reward\n * (1 if t >= i else 0) for t, reward in enumerate(rewards)])\n else:\n if i == len(states) - 1:\n # terminal state\n value = reward\n else:\n next_state = states[i + 1]\n gamma_bar = pow(self.gamma, self.robot.time_step * self.robot.v_pref)\n value = reward + gamma_bar * self.target_model(next_state.unsqueeze(0)).data.item()\n value = torch.Tensor([value]).to(self.device)\n\n # # transform state of different human_num into fixed-size tensor\n # if len(state.size()) == 1:\n # human_num = 1\n # feature_size = state.size()[0]\n # else:\n # human_num, feature_size = state.size()\n # if human_num != 5:\n # padding = torch.zeros((5 - human_num, feature_size))\n # state = torch.cat([state, padding])\n self.memory.push((state, value))\n\n\ndef average(input_list):\n if input_list:\n return sum(input_list) / len(input_list)\n else:\n return 0\n"
] | [
[
"torch.Tensor"
]
] |
shreyaspotnis/rampage | [
"e2565aef7ee16ee06523de975e8aa41aca14e3b2"
] | [
"rampage/daq/gpib.py"
] | [
"import visa\nimport numpy as np\nimport logging\nfrom datetime import datetime\n\nresource_manager = visa.ResourceManager()\n\n\nclass Aglient33250A(object):\n\n def __init__(self):\n self.instr = self.open_instrument()\n\n def open_instrument(self):\n resource_list = resource_manager.list_resources()\n gpib_address_list = filter(lambda x: x[:4] == 'GPIB', resource_list)\n\n for addr in gpib_address_list:\n instr = resource_manager.open_resource(addr)\n idn = instr.query('*IDN?')\n if 'Agilent Technologies,33250A' in idn:\n return instr\n else:\n raise GPIBError('Aglient33250A function generator not in GPIB device list')\n # device not round raise exception\n\n def set_output(self, state):\n \"\"\"Sets whether the function generator is outputting a voltage.\"\"\"\n if state:\n self.instr.write('OUTP ON')\n else:\n self.instr.write('OUTP OFF')\n\n def set_fm_ext(self, freq, amplitude, peak_freq_dev=None,\n output_state=True):\n \"\"\"Sets the func generator to frequency modulation with external modulation.\n freq is the carrier frequency in Hz.\"\"\"\n\n if peak_freq_dev is None:\n peak_freq_dev = freq\n commands = ['FUNC SIN', # set to output sine functions\n 'FM:STAT ON',\n 'FREQ {0}'.format(freq),\n 'FM:SOUR EXT',\n # 'FM:FREQ {0}'.format(freq),\n 'FM:DEV {0}'.format(peak_freq_dev),\n 'VOLT {0}'.format(amplitude),\n 'VOLT:OFFS 0'] # set to frequency modulation\n if output_state is True:\n commands.append('OUTP ON')\n else:\n commands.append('OUTP OFF')\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n # self.read_all_errors()\n\n def set_burst(self, freq, amplitude, period, output_state=True):\n \"\"\"Sets the func generator to burst mode with external trigerring.\"\"\"\n\n ncyc = int(period*freq)\n commands = ['FUNC SIN',\n 'BURS:STAT ON',\n 'BURS:MODE TRIG', # external trigger\n 'TRIG:SOUR EXT',\n 'TRIG:SLOP POS',\n 'FREQ {0}'.format(freq),\n 'VOLT {0}'.format(amplitude),\n 'VOLT:OFFS 0',\n 'BURS:NCYC {0}'.format(ncyc)]\n if output_state is True:\n commands.append('OUTP ON')\n else:\n commands.append('OUTP OFF')\n\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\n # self.read_all_errors()\n\n def set_continuous(self, freq, amplitude, offset, output_state=True):\n \"\"\"Programs the function generator to output a continuous sine wave.\"\"\"\n commands = ['FUNC SIN',\n 'BURS:STAT OFF',\n 'SWE:STAT OFF',\n 'FM:STAT OFF',\n 'FREQ {0}'.format(freq),\n 'VOLT {0}'.format(amplitude),\n 'VOLT:OFFS {0}'.format(offset),\n ]\n if output_state is True:\n commands.append('OUTP ON')\n else:\n commands.append('OUTP OFF')\n\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\n # self.read_all_errors()\n\n def set_freq_sweep(self, start_freq, stop_freq, sweep_time, amplitude,\n output_state=True):\n commands = ['FUNC SIN',\n 'TRIG:SOUR EXT',\n 'TRIG:SLOP POS',\n 'SWE:STAT ON',\n 'FREQ:STAR {0}'.format(start_freq),\n 'FREQ:STOP {0}'.format(stop_freq),\n 'SWE:TIME {0}'.format(sweep_time),\n 'VOLT {0}'.format(amplitude),\n 'VOLT:OFFS 0',\n 'SWE:STAT ON']\n if output_state is True:\n commands.append('OUTP ON')\n else:\n commands.append('OUTP OFF')\n\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\n def set_arbitrary(self, freq, low_volt, high_volt, output_state=True):\n \"\"\"Programs the function generator to output the arbitrary waveform.\"\"\"\n commands = ['FUNC USER',\n 'BURS:STAT OFF',\n 'SWE:STAT OFF',\n 'FM:STAT OFF',\n 'FREQ {0}'.format(freq),\n 'VOLT:HIGH {0}'.format(high_volt),\n 'VOLT:LOW {0}'.format(low_volt),\n ]\n if output_state is True:\n commands.append('OUTP ON')\n else:\n commands.append('OUTP OFF')\n\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\n def read_all_errors(self):\n done = False\n while not done:\n err = self.instr.query('SYST:ERR?')\n print(err)\n if err[:2] == '+0':\n done = True\n\nclass TektronixTDS1002(object):\n\n def __init__(self):\n self.instr = self.open_instrument()\n\n def open_instrument(self):\n resource_list = resource_manager.list_resources()\n gpib_address_list = filter(lambda x: x[:4] == 'GPIB', resource_list)\n\n for addr in gpib_address_list:\n instr = resource_manager.open_resource(addr)\n idn = instr.query('*IDN?')\n if 'TEKTRONIX,TDS 1002' in idn:\n return instr\n else:\n raise GPIBError('TektronicsTDS1002 oscilloscope not in GPIB device list')\n # device not round raise exception\n\n def get_data(self, channel=1):\n hor_pos = float(self.instr.query('HOR:MAI:POS?'))\n hor_scale = float(self.instr.query('HOR:MAI:SCA?'))\n ch1_pos = float(self.instr.query('CH{0}:POS?'.format(channel)))\n ch1_sca = float(self.instr.query('CH{0}:SCA?'.format(channel)))\n commands = ['DATA:WIDTH 1',\n 'DATA:STAR 1',\n 'DATA:STOP 2500',\n 'DATA:SOU CH{0}'.format(channel),\n 'CURV?']\n command_string = '\\r\\n'.join(commands)\n self.instr.write(command_string)\n # the first 6 bytes are #42500 and the last byte is \\n\n # ignore those\n data = self.instr.read_raw()[6:-1]\n data = np.fromstring(data, dtype=np.int8)\n data_scaled = (np.array(data, dtype='float')*(10.0/2**8) - ch1_pos)*ch1_sca\n time_array = np.arange(len(data_scaled), dtype='float')*10.0*hor_scale/len(data_scaled)\n return time_array, data_scaled\n\n def get_save_data(self, file_path, channel=1):\n hor_pos = float(self.instr.query('HOR:MAI:POS?'))\n hor_scale = float(self.instr.query('HOR:MAI:SCA?'))\n ch1_pos = float(self.instr.query('CH{0}:POS?'.format(channel)))\n ch1_sca = float(self.instr.query('CH{0}:SCA?'.format(channel)))\n commands = ['DATA:WIDTH 1',\n 'DATA:STAR 1',\n 'DATA:STOP 2500',\n 'DATA:SOU CH{0}'.format(channel),\n 'CURV?']\n command_string = '\\r\\n'.join(commands)\n self.instr.write(command_string)\n # the first 6 bytes are #42500 and the last byte is \\n\n # ignore those\n data = self.instr.read_raw()[6:-1]\n data = np.fromstring(data, dtype=np.int8)\n data_scaled = (np.array(data, dtype='float')*(10.0/2**8) - ch1_pos)*ch1_sca\n time_array = np.arange(len(data_scaled), dtype='float')*10.0*hor_scale/len(data_scaled)\n np.savetxt(file_path + '\\\\' + datetime.now().strftime('%Y_%m_%d_%H_%M_%S') + '.txt', (time_array, data_scaled), fmt='%1.4e')\n #return time_array, data_scaled\n\nclass TektronixTDS2012C(TektronixTDS1002):\n\n def __init__(self):\n self.instr = self.open_instrument()\n super(TektronixTDS2012C, self).__init__()\n\n def open_instrument(self):\n resource_list = resource_manager.list_resources()\n gpib_address_list = filter(lambda x: x[:3] == 'USB', resource_list)\n\n for addr in gpib_address_list:\n instr = resource_manager.open_resource(addr)\n idn = instr.query('*IDN?')\n if 'TEKTRONIX,TDS 2012C' in idn:\n return instr\n else:\n raise GPIBError('TektronixTDS2012C oscilloscope not in USB device list')\n # device not round raise exception\n\nclass NewportESP300(object):\n\n def __init__(self):\n self.instr = self.open_instrument()\n\n def open_instrument(self):\n resource_list = resource_manager.list_resources()\n gpib_address_list = filter(lambda x: x[:4] == 'GPIB', resource_list)\n\n for addr in gpib_address_list:\n instr = resource_manager.open_resource(addr)\n idn = instr.query('*IDN?')\n if 'ESP300 Version' in idn:\n return instr\n else:\n raise GPIBError('ESP300 Motion Controller not in GPIB device list')\n # device not round raise exception\n\n def read_position(self, num_axes=2):\n for i in range(num_axes-1):\n pos = self.instr.query(str(i+1)+'TP?')\n print('Pos' + str(i+1) + ' ' + pos[:8])\n\n def move_absposition(self, abs_pos, axis):\n self.instr.write(str(int(axis))+'PA'+str(np.around(abs_pos, decimals=3)))\n print('Set Axis ' + str(axis) + ' to ' + str(np.around(abs_pos, decimals=3)))\n\n def read_all_errors(self):\n done = False\n while not done:\n err = self.instr.query('TB?')\n print(err)\n if 'NO ERROR DETECTED' in err:\n done = True\n\nclass AgilentN900A(object):\n\n def __init__(self):\n self.instr = self.open_instrument()\n\n def open_instrument(self):\n\n IP = '192.168.0.109'\n instr = resource_manager.get_instrument('TCPIP::' + IP + '::INSTR')\n return instr\n\n def get_n_save_marker_pos(self, file_path, channel=1):\n self.instr.write(':CALC:MARK1:X?')\n freq = np.float(self.instr.read())\n self.instr.write(':CALC:MARK1:Y?')\n amp = np.float(self.instr.read())\n self.instr.write(':AVER:STAT OFF')\n arr_write = np.array([freq, amp])\n f_handle = open(file_path + '\\\\' + datetime.now().strftime('%Y_%m_%d_%H_%M_%S') + '.txt', 'ab')\n np.savetxt(f_handle, arr_write.reshape(1, arr_write.shape[0]))\n f_handle.close()\n\n def trigger_marker_avg(self,num_avg=100,freq=6.83468,span=25,ref_lev=15):\n commands = [':FREQ:CENT {0}'.format(freq) + ' GHz',\n ':FREQ:SPAN {0}'.format(span) + ' MHz',\n ':DISP:WIND:TRAC:Y:RLEV {0}'.format(ref_lev) + ' dBm',\n ':CALC:MARK:MODE POS',\n ':CALC:MARK:CPS ON',\n ':TRIG:SOUR EXT1',\n ':TRIG:EXT1:LEV 1.0V',\n ':AVER:STAT ON',\n ':AVER:COUNT {0}'.format(num_avg)\n ]\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\nclass SRSSG384(object):\n\n def __init__(self):\n self.instr = self.open_instrument()\n\n def open_instrument(self):\n resource_list = resource_manager.list_resources()\n gpib_address_list = filter(lambda x: x[:4] == 'GPIB', resource_list)\n\n for addr in gpib_address_list:\n instr = resource_manager.open_resource(addr)\n idn = instr.query('*IDN?')\n if 'Stanford Research Systems,SG384' in idn:\n return instr\n else:\n raise GPIBError('SRS SG384 function generator not in GPIB device list')\n # device not found raise exception\n\n def read_all_errors(self):\n done = False\n while not done:\n err = self.instr.query('LERR?')\n print(err)\n if err[:1] == '0':\n done = True\n\n def set_continuous(self, freq, amplitude, offset, output_state=True):\n \"\"\"Programs the Stanford MW function generator to output a continuous sine wave.\n External 'triggering' is accomplished using the MW switch.\"\"\"\n commands = ['MODL 0', #disable any modulation\n 'FREQ {0}'.format(freq)\n ]\n\n if freq > 4.05e9:\n commands.append('AMPH {0}'.format(amplitude)) #set rear RF doubler amplitude\n if offset > 0.0:\n print('HIGH FREQUENCY OUTPUT IS AC ONLY')\n if output_state is True:\n commands.append('ENBH 1') #enable output\n else:\n commands.append('ENBH 0')\n elif freq < 62.5e6:\n commands.extend(['AMPL {0}'.format(amplitude), 'OFSL {0}'.format(offset)]) #set front BNC amplitude\n if output_state is True:\n commands.append('ENBL 1') #enable output\n else:\n commands.append('ENBL 0')\n\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\n # print(print_string)\n # self.read_all_errors()\n\n def set_continuous_Vpp(self, freq, amplitude, offset, output_state=True):\n \"\"\"Programs the Stanford MW function generator to output a continuous sine wave.\n External 'triggering' is accomplished using the MW switch.\"\"\"\n commands = ['MODL 0', #disable any modulation\n 'FREQ {0}'.format(freq)\n ]\n\n if freq > 4.05e9:\n commands.append('AMPH {0} VPP'.format(amplitude)) #set rear RF doubler amplitude\n if offset > 0.0:\n print('HIGH FREQUENCY OUTPUT IS AC ONLY')\n if output_state is True:\n commands.append('ENBH 1') #enable output\n else:\n commands.append('ENBH 0')\n elif freq < 62.5e6:\n commands.extend(['AMPL {0} VPP'.format(amplitude), 'OFSL {0}'.format(offset)]) #set front BNC amplitude\n if output_state is True:\n commands.append('ENBL 1') #enable output\n else:\n commands.append('ENBL 0')\n\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\n def set_fm_ext(self, freq, amplitude, offset=0.0, peak_fm_deviation=None, output_state=True):\n \"\"\"Sets the Stanford MW function generator to freq modulation with external modulation.\n freq is the carrier frequency in Hz.\"\"\"\n if peak_fm_deviation is None:\n peak_fm_deviation = freq\n commands = ['TYPE 1', #set to FM\n 'MFNC 5', #external modulation\n 'FREQ {0}'.format(freq),\n 'FDEV {0}'.format(peak_fm_deviation),\n 'MODL 1' #enable modulation\n ]\n if freq > 4.05e9:\n commands.append('AMPH {0}'.format(amplitude)) #set rear RF doubler amplitude\n if offset > 0.0:\n print('HIGH FREQUENCY OUTPUT IS AC ONLY')\n if output_state is True:\n commands.append('ENBH 1') #enable output\n else:\n commands.append('ENBH 0')\n elif freq < 62.5e6:\n commands.extend(['AMPL {0}'.format(amplitude), 'OFSL {0}'.format(offset)]) #set front BNC amplitude\n if output_state is True:\n commands.append('ENBL 1') #enable output\n else:\n commands.append('ENBL 0')\n\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\n #print(print_string)\n #self.read_all_errors()\n\n def set_freqsweep_ext(self, amplitude, sweep_low_end, sweep_high_end, offset=0.0, output_state=True):\n \"\"\"Sets the Stanford MW function generator to freq modulation with external modulation.\n freq is the carrier frequency in Hz.\"\"\"\n\n sweep_deviation = round(abs(sweep_low_end - sweep_high_end)/2.0,6)\n freq = sweep_low_end + sweep_deviation\n commands = ['TYPE 3', #set to sweep\n 'SFNC 5', #external modulation\n 'FREQ {0}'.format(freq),\n 'SDEV {0}'.format(sweep_deviation),\n 'MODL 1' #enable modulation\n ]\n if freq > 4.05e9:\n commands.append('AMPH {0}'.format(amplitude)) #set rear RF doubler amplitude\n if offset > 0.0:\n print('HIGH FREQUENCY OUTPUT IS AC ONLY')\n if output_state is True:\n commands.append('ENBH 1') #enable output\n else:\n commands.append('ENBH 0')\n elif freq < 62.5e6:\n commands.extend(['AMPL {0}'.format(amplitude), 'OFSL {0}'.format(offset)]) #set front BNC amplitude\n if output_state is True:\n commands.append('ENBL 1') #enable output\n else:\n commands.append('ENBL 0')\n\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n self.instr.write(command_string)\n\n #print(print_string)\n #self.read_all_errors()\n\n def set_output(self, state):\n \"\"\"Sets whether the function generator is outputting a voltage.\"\"\"\n freq = float(self.instr.query('FREQ?'))\n if freq > 4.05e9:\n if state:\n self.instr.write('ENBH 1') #enable output\n else:\n self.instr.write('ENBH 0')\n elif freq < 62.5e6:\n if state:\n self.instr.write('ENBL 1') #enable output\n else:\n self.instr.write('ENBL 0')\n\n def trigger_ListMode(self):\n \"\"\"Iterates the function generator to the next state in ListMode\n NOTE: ListMode does not enable outputs, but only writes the function\n generator state. Output must be enabled separately\"\"\"\n self.instr.write('*TRG')\n\n def disable_all(self, disable):\n \"\"\"Disables all modulation and outputs of the Standford MW func. generator\"\"\"\n commands = ['ENBH 0', #disable high freq. rear output\n 'ENBL 0', #disable low freq. front bnc\n 'MODL 0' #disable modulation\n ]\n command_string = '\\n'.join(commands)\n print_string = '\\n\\t' + command_string.replace('\\n', '\\n\\t')\n logging.info(print_string)\n if disable:\n self.instr.write(command_string)\n\n # self.read_all_errors()\n\n\n # def set_MWinstr_freq_sweep(self, mod_type, freq, amplitude, mod_rate, mod_deviation, list_size=2, list_enable=True):\n # \"\"\"Sets the Stanford MW device to an instrument to be triggered later.\"\"\"\n # #create list of instrument states\n # self.instr.query('LSTC? {0}'.format(list_size))\n\n # for j in range(list_size):\n\n\n # #enable to list for triggering\n # cur_enable_state = self.instr.query('LSTE?')\n # if cur_enable_state == False:\n # self.instr.write('LSTE 1')\n\nclass RigolDG1022Z(object):\n\n def __init__(self):\n self.instr = self.open_instrument()\n\n def open_instrument(self):\n resource_list = resource_manager.list_resources()\n gpib_address_list = filter(lambda x: x[:3] == 'USB', resource_list)\n\n for addr in gpib_address_list:\n instr = resource_manager.open_resource(addr)\n idn = instr.query('*IDN?')\n if 'Rigol Technologies,DG1022Z,DG1ZA184750979' in idn:\n return instr\n else:\n raise GPIBError('Rigol DG1022Z function generator not in USB device list')\n # device not round raise exception\n\n def set_output(self, state, channel=2):\n \"\"\"Sets whether the function generator is outputting a voltage.\"\"\"\n if state:\n self.instr.write(':OUTP{0} ON'.format(channel))\n else:\n self.instr.write(':OUTP{0} OFF'.format(channel))\n\n def set_continuous(self, freq, amplitude, offset, phase, channel=2):\n \"\"\"Programs the function generator to output a continuous sine wave.\"\"\"\n commands = [':SOUR{0}:APPL:SIN '.format(channel),\n '{0},'.format(freq),\n '{0},'.format(amplitude),\n '{0},'.format(offset),\n '{0}'.format(phase),\n ]\n\n command_string = ''.join(commands)\n logging.info(command_string)\n self.instr.write(command_string)\n\n def read_all_errors(self):\n done = False\n while not done:\n err = self.instr.query('SYST:ERR?')\n print(err)\n if err[:2] == '+0':\n done = True\n\n\nclass GPIBError(Exception):\n def __init__(self, value):\n self.value = value\n\n def __str__(self):\n return repr(self.value)\n\n#globals\nagilent_33250a = Aglient33250A()\ntektronixTDS1002 = TektronixTDS1002()\n# agilentN900A = AgilentN900A()\n#tektronixTDS2012C = TektronixTDS2012C()\nstanfordSG384 = SRSSG384()\n# newportesp300 = NewportESP300()\nrigolDG1022Z = RigolDG1022Z()"
] | [
[
"numpy.array",
"numpy.around",
"numpy.fromstring"
]
] |
heydude1337/pyshield | [
"8f103ccc160e6208c8a6754264168416f62373cb"
] | [
"pyshield/io.py"
] | [
"\"\"\" Functions to read resource files (.yml, .xls/.xlsx and images) \"\"\"\n\n# -*- coding: utf-8 -*-\n\n\nfrom os import path\nimport pandas as pd\nimport matplotlib.image as mpimg\nimport numpy as np\nimport yaml\n\n\n\nimport pyshield as ps\n\n\ndef load_item(item):\n \"\"\" Load yaml, image or excel or return value as is. \"\"\"\n if isinstance(item, str):\n if is_yaml(item):\n try:\n item = read_yaml(item)\n except FileNotFoundError:\n item = {}\n if is_img(item):\n item = read_img(item)\n if is_excel(item):\n item = read_excel(item)\n \n if isinstance(item, dict):\n return dict(zip(item.keys(), map(load_item, item.values())))\n else:\n return item\n \ndef _file_ext(file):\n return path.splitext(file)[1].lower()\n\ndef is_yaml(file):\n YAML = ('.yml','.yaml')\n return isinstance(file, str) and _file_ext(file) in YAML\n\ndef is_img(file):\n IMG = ('.png', '.jpeg', '.jpg', '.bmp')\n return isinstance(file, str) and _file_ext(file) in IMG\n\ndef is_excel(file):\n XLS = ('.csv', '.xls', '.xlsx')\n return isinstance(file, str) and _file_ext(file) in XLS\n\ndef read_excel(file):\n return pd.read_excel(file, sheet_name=None)\n\ndef read_img(file):\n return np.flipud(mpimg.imread(file))\n\ndef read_yaml(file):\n \"\"\" \n Read yaml file and include files that are defined with the INCLUDE tag\n \"\"\"\n if not is_yaml(file):\n raise IOError('File {0} is not a yaml file'.format(file))\n\n folder = path.dirname(path.abspath(file))\n\n stream = open(file, 'r')\n yaml_dict = yaml.load(stream)\n\n if yaml_dict is None: yaml_dict = {}\n\n # append include files to dict\n files = yaml_dict.pop('INCLUDE', [])\n\n # read all included files and add items to dict\n for file in files:\n\n # take care of relative path\n if not(path.isabs(file)):\n file = path.join(folder, file)\n\n append_dict = read_yaml(file) # recursive call\n\n # check if key already existed warn if key will be overwritten\n for key in append_dict.keys():\n if key in yaml_dict.keys():\n ps.logger.warning('Duplicate data found in file' + \\\n\t\t\t\t '{0} for key {1}'.format(file, key))\n\n # append data (append_dict keys overwrite yaml_dict keys if duplicates)\n yaml_dict = {**yaml_dict, **append_dict}\n\n return yaml_dict\n\ndef write_yaml(file_name, dict_obj):\n stream = open(file_name, 'w')\n yaml.dump(dict_obj, stream=stream, default_flow_style=False)\n\n\n\n\n\n"
] | [
[
"pandas.read_excel",
"matplotlib.image.imread"
]
] |
EricElmoznino/OrthogonalLowrankEmbedding | [
"cce12ca5cb34f7cb888b04739724bdbbd18b1e2d"
] | [
"stl10/utee/misc.py"
] | [
"from __future__ import print_function\nimport cv2\nimport os\nimport shutil\nimport pickle as pkl\nimport time\nimport numpy as np\nimport hashlib\n\nfrom IPython import embed\n\nclass Logger(object):\n def __init__(self):\n self._logger = None\n\n def init(self, logdir, name='log'):\n if self._logger is None:\n import logging\n if not os.path.exists(logdir):\n os.makedirs(logdir)\n log_file = os.path.join(logdir, name)\n if os.path.exists(log_file):\n os.remove(log_file)\n self._logger = logging.getLogger()\n self._logger.setLevel('INFO')\n fh = logging.FileHandler(log_file)\n ch = logging.StreamHandler()\n self._logger.addHandler(fh)\n self._logger.addHandler(ch)\n\n def info(self, str_info):\n self.init('/tmp', 'tmp.log')\n self._logger.info(str_info)\nlogger = Logger()\n\nprint = logger.info\ndef ensure_dir(path, erase=False):\n if os.path.exists(path) and erase:\n print(\"Removing old folder {}\".format(path))\n shutil.rmtree(path)\n if not os.path.exists(path):\n print(\"Creating folder {}\".format(path))\n os.makedirs(path)\n\ndef load_pickle(path):\n begin_st = time.time()\n with open(path, 'rb') as f:\n print(\"Loading pickle object from {}\".format(path))\n v = pkl.load(f)\n print(\"=> Done ({:.4f} s)\".format(time.time() - begin_st))\n return v\n\ndef dump_pickle(obj, path):\n with open(path, 'wb') as f:\n print(\"Dumping pickle object to {}\".format(path))\n pkl.dump(obj, f, protocol=pkl.HIGHEST_PROTOCOL)\n\ndef auto_select_gpu(mem_bound=500, utility_bound=0, gpus=(0, 1, 2, 3, 4, 5, 6, 7), num_gpu=1, selected_gpus=None):\n import sys\n import os\n import subprocess\n import re\n import time\n import numpy as np\n if 'CUDA_VISIBLE_DEVCIES' in os.environ:\n sys.exit(0)\n if selected_gpus is None:\n mem_trace = []\n utility_trace = []\n for i in range(5): # sample 5 times\n info = subprocess.check_output('nvidia-smi', shell=True).decode('utf-8')\n mem = [int(s[:-5]) for s in re.compile('\\d+MiB\\s/').findall(info)]\n utility = [int(re.compile('\\d+').findall(s)[0]) for s in re.compile('\\d+%\\s+Default').findall(info)]\n mem_trace.append(mem)\n utility_trace.append(utility)\n time.sleep(0.1)\n mem = np.mean(mem_trace, axis=0)\n utility = np.mean(utility_trace, axis=0)\n assert(len(mem) == len(utility))\n nGPU = len(utility)\n ideal_gpus = [i for i in range(nGPU) if mem[i] <= mem_bound and utility[i] <= utility_bound and i in gpus]\n\n if len(ideal_gpus) < num_gpu:\n print(\"No sufficient resource, available: {}, require {} gpu\".format(ideal_gpus, num_gpu))\n sys.exit(0)\n else:\n selected_gpus = list(map(str, ideal_gpus[:num_gpu]))\n else:\n selected_gpus = selected_gpus.split(',')\n\n print(\"Setting GPU: {}\".format(selected_gpus))\n os.environ['CUDA_VISIBLE_DEVICES'] = ','.join(selected_gpus)\n return selected_gpus\n\ndef expand_user(path):\n return os.path.abspath(os.path.expanduser(path))\n\ndef model_snapshot(model, new_file, old_file=None, verbose=False):\n from collections import OrderedDict\n import torch\n if isinstance(model, torch.nn.DataParallel):\n model = model.module\n if old_file and os.path.exists(expand_user(old_file)):\n if verbose:\n print(\"Removing old model {}\".format(expand_user(old_file)))\n os.remove(expand_user(old_file))\n if verbose:\n print(\"Saving model to {}\".format(expand_user(new_file)))\n\n state_dict = OrderedDict()\n for k, v in model.state_dict().items():\n if v.is_cuda:\n v = v.cpu()\n state_dict[k] = v\n torch.save(state_dict, expand_user(new_file))\n\n\ndef load_lmdb(lmdb_file, n_records=None):\n import lmdb\n import numpy as np\n lmdb_file = expand_user(lmdb_file)\n if os.path.exists(lmdb_file):\n data = []\n env = lmdb.open(lmdb_file, readonly=True, max_readers=512)\n with env.begin() as txn:\n cursor = txn.cursor()\n begin_st = time.time()\n print(\"Loading lmdb file {} into memory\".format(lmdb_file))\n for key, value in cursor:\n _, target, _ = key.decode('ascii').split(':')\n target = int(target)\n img = cv2.imdecode(np.fromstring(value, np.uint8), cv2.IMREAD_COLOR)\n data.append((img, target))\n if n_records is not None and len(data) >= n_records:\n break\n env.close()\n print(\"=> Done ({:.4f} s)\".format(time.time() - begin_st))\n return data\n else:\n print(\"Not found lmdb file\".format(lmdb_file))\n\ndef str2img(str_b):\n return cv2.imdecode(np.fromstring(str_b, np.uint8), cv2.IMREAD_COLOR)\n\ndef img2str(img):\n return cv2.imencode('.jpg', img)[1].tostring()\n\ndef md5(s):\n m = hashlib.md5()\n m.update(s)\n return m.hexdigest()\n\ndef eval_model(model, ds, n_sample=None, ngpu=1, is_imagenet=False):\n import tqdm\n import torch\n from torch import nn\n from torch.autograd import Variable\n\n class ModelWrapper(nn.Module):\n def __init__(self, model):\n super(ModelWrapper, self).__init__()\n self.model = model\n self.mean = [0.485, 0.456, 0.406]\n self.std = [0.229, 0.224, 0.225]\n\n def forward(self, input):\n input.data.div_(255.)\n input.data[:, 0, :, :].sub_(self.mean[0]).div_(self.std[0])\n input.data[:, 1, :, :].sub_(self.mean[1]).div_(self.std[1])\n input.data[:, 2, :, :].sub_(self.mean[2]).div_(self.std[2])\n return self.model(input)\n\n correct1, correct5 = 0, 0\n n_passed = 0\n if is_imagenet:\n model = ModelWrapper(model)\n model = model.eval()\n model = torch.nn.DataParallel(model, device_ids=range(ngpu)).cuda()\n\n n_sample = len(ds) if n_sample is None else n_sample\n for idx, (data, target) in enumerate(tqdm.tqdm(ds, total=n_sample)):\n n_passed += len(data)\n data = Variable(torch.FloatTensor(data)).cuda()\n indx_target = torch.LongTensor(target)\n output = model(data)\n bs = output.size(0)\n idx_pred = output.data.sort(1, descending=True)[1]\n\n idx_gt1 = indx_target.expand(1, bs).transpose_(0, 1)\n idx_gt5 = idx_gt1.expand(bs, 5)\n\n correct1 += idx_pred[:, :1].cpu().eq(idx_gt1).sum()\n correct5 += idx_pred[:, :5].cpu().eq(idx_gt5).sum()\n\n if idx >= n_sample - 1:\n break\n\n acc1 = correct1 * 1.0 / n_passed\n acc5 = correct5 * 1.0 / n_passed\n return acc1, acc5\n\ndef load_state_dict(model, model_urls, model_root):\n from torch.utils import model_zoo\n from torch import nn\n import re\n from collections import OrderedDict\n own_state_old = model.state_dict()\n own_state = OrderedDict() # remove all 'group' string\n for k, v in own_state_old.items():\n k = re.sub('group\\d+\\.', '', k)\n own_state[k] = v\n\n state_dict = model_zoo.load_url(model_urls, model_root)\n\n for name, param in state_dict.items():\n if name not in own_state:\n print(own_state.keys())\n raise KeyError('unexpected key \"{}\" in state_dict'\n .format(name))\n if isinstance(param, nn.Parameter):\n # backwards compatibility for serialized parameters\n param = param.data\n own_state[name].copy_(param)\n\n missing = set(own_state.keys()) - set(state_dict.keys())\n if len(missing) > 0:\n raise KeyError('missing keys in state_dict: \"{}\"'.format(missing))\n\n"
] | [
[
"torch.FloatTensor",
"torch.utils.model_zoo.load_url",
"torch.LongTensor",
"numpy.fromstring",
"numpy.mean"
]
] |
TraceOnBrainOff/pytorch-dc-tts | [
"993a0fbace561729b04df2179b41a0a7ea502e93"
] | [
"train-text2mel.py"
] | [
"#!/usr/bin/env python\n\"\"\"Train the Text2Mel network. See: https://arxiv.org/abs/1710.08969\"\"\"\n__author__ = 'Erdene-Ochir Tuguldur'\n\nimport sys\nimport time\nimport argparse\nfrom tqdm import *\n\nimport numpy as np\n\nimport torch\nimport torch.nn.functional as F\n\n# project imports\nfrom models import Text2Mel\nfrom hyperparams import HParams as hp\nfrom logger import Logger\nfrom utils import get_last_checkpoint_file_name, load_checkpoint, save_checkpoint, load_checkpoint_test\nfrom datasets.data_loader import Text2MelDataLoader\n\nparser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter)\nparser.add_argument(\"--dataset\", required=True, choices=['ljspeech', 'mbspeech','emovdb'], help='dataset name')\nargs = parser.parse_args()\n\nif args.dataset == 'ljspeech':\n from datasets.lj_speech import vocab, LJSpeech as SpeechDataset\nelif args.dataset == 'emovdb':\n from datasets.emovdb import vocab, Emovdb as SpeechDataset\nelse:\n from datasets.mb_speech import vocab, MBSpeech as SpeechDataset\n\nuse_gpu = torch.cuda.is_available()\nprint('use_gpu', use_gpu)\nif use_gpu:\n torch.backends.cudnn.benchmark = True\n\ntrain_data_loader = Text2MelDataLoader(text2mel_dataset=SpeechDataset(['texts', 'mels', 'mel_gates']), batch_size=64,\n mode='train')\nvalid_data_loader = Text2MelDataLoader(text2mel_dataset=SpeechDataset(['texts', 'mels', 'mel_gates']), batch_size=64,\n mode='valid')\n\ntext2mel = Text2Mel(vocab).cpu()\n\n\nstart_timestamp = int(time.time() * 1000)\nstart_epoch = 0\nglobal_step = 0\n\nlogger = Logger(args.dataset, 'text2mel')\n\n# load the last checkpoint if exists\nlast_checkpoint_file_name = get_last_checkpoint_file_name(logger.logdir)\nif last_checkpoint_file_name:\n print(\"loading the last checkpoint: %s\" % last_checkpoint_file_name)\n start_epoch, global_step = load_checkpoint(last_checkpoint_file_name, text2mel, None)\n\noptimizer = torch.optim.Adam(text2mel.parameters(), lr=hp.text2mel_lr)\n\ndef get_lr():\n return optimizer.param_groups[0]['lr']\n\n\ndef lr_decay(step, warmup_steps=4000):\n new_lr = hp.text2mel_lr * warmup_steps ** 0.5 * min((step + 1) * warmup_steps ** -1.5, (step + 1) ** -0.5)\n optimizer.param_groups[0]['lr'] = new_lr\n\n\ndef train(train_epoch, phase='train'):\n global global_step\n\n lr_decay(global_step)\n print(\"epoch %3d with lr=%.02e\" % (train_epoch, get_lr()))\n\n text2mel.train() if phase == 'train' else text2mel.eval()\n torch.set_grad_enabled(True) if phase == 'train' else torch.set_grad_enabled(False)\n data_loader = train_data_loader if phase == 'train' else valid_data_loader\n\n it = 0\n running_loss = 0.0\n running_l1_loss = 0.0\n running_att_loss = 0.0\n\n pbar = tqdm(data_loader, unit=\"audios\", unit_scale=data_loader.batch_size, disable=hp.disable_progress_bar)\n for batch in pbar:\n L, S, gates = batch['texts'], batch['mels'], batch['mel_gates']\n S = S.permute(0, 2, 1) # TODO: because of pre processing\n\n B, N = L.size() # batch size and text count\n _, n_mels, T = S.size() # number of melspectrogram bins and time\n\n assert gates.size(0) == B # TODO: later remove\n assert gates.size(1) == T\n\n S_shifted = torch.cat((S[:, :, 1:], torch.zeros(B, n_mels, 1)), 2)\n\n S.requires_grad = False\n S_shifted.requires_grad = False\n gates.requires_grad = False\n\n def W_nt(_, n, t, g=0.2):\n return 1.0 - np.exp(-((n / float(N) - t / float(T)) ** 2) / (2 * g ** 2))\n\n W = np.fromfunction(W_nt, (B, N, T), dtype=np.float32)\n W = torch.from_numpy(W)\n\n L = L.cpu()\n S = S.cpu()\n S_shifted = S_shifted.cpu()\n W = W.cpu()\n gates = gates.cpu()\n\n Y_logit, Y, A = text2mel(L, S, monotonic_attention=True)\n\n l1_loss = F.l1_loss(Y, S_shifted)\n masks = gates.reshape(B, 1, T).float()\n att_loss = (A * W * masks).mean()\n\n loss = l1_loss + att_loss\n\n if phase == 'train':\n lr_decay(global_step)\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n global_step += 1\n\n it += 1\n\n loss, l1_loss, att_loss = loss.item(), l1_loss.item(), att_loss.item()\n running_loss += loss\n running_l1_loss += l1_loss\n running_att_loss += att_loss\n\n if phase == 'train':\n # update the progress bar\n pbar.set_postfix({\n 'l1': \"%.05f\" % (running_l1_loss / it),\n 'att': \"%.05f\" % (running_att_loss / it)\n })\n logger.log_step(phase, global_step, {'loss_l1': l1_loss, 'loss_att': att_loss},\n {'mels-true': S[:1, :, :], 'mels-pred': Y[:1, :, :], 'attention': A[:1, :, :]})\n if global_step % 1000 == 0:\n # checkpoint at every 1000th step\n save_checkpoint(logger.logdir, train_epoch, global_step, text2mel, optimizer)\n\n epoch_loss = running_loss / it\n epoch_l1_loss = running_l1_loss / it\n epoch_att_loss = running_att_loss / it\n\n logger.log_epoch(phase, global_step, {'loss_l1': epoch_l1_loss, 'loss_att': epoch_att_loss})\n\n return epoch_loss\n\n\nsince = time.time()\nepoch = start_epoch\nwhile True:\n train_epoch_loss = train(epoch, phase='train')\n time_elapsed = time.time() - since\n time_str = 'total time elapsed: {:.0f}h {:.0f}m {:.0f}s '.format(time_elapsed // 3600, time_elapsed % 3600 // 60,\n time_elapsed % 60)\n print(\"train epoch loss %f, step=%d, %s\" % (train_epoch_loss, global_step, time_str))\n\n valid_epoch_loss = train(epoch, phase='valid')\n print(\"valid epoch loss %f\" % valid_epoch_loss)\n\n epoch += 1\n if global_step >= hp.text2mel_max_iteration:\n print(\"max step %d (current step %d) reached, exiting...\" % (hp.text2mel_max_iteration, global_step))\n sys.exit(0)\n\n"
] | [
[
"numpy.fromfunction",
"torch.set_grad_enabled",
"torch.nn.functional.l1_loss",
"torch.cuda.is_available",
"torch.from_numpy",
"torch.zeros"
]
] |
Koen-AI/world-model-as-a-graph | [
"cafde59ef7159d1b62ca508568c85c6498c1342c"
] | [
"rl/replay/planner.py"
] | [
"import threading\nimport numpy as np\nimport torch\nimport os.path as osp\n\nfrom rl.utils import mpi_utils\n\n#Replay buffer!!!\n\ndef sample_her_transitions(buffer, reward_func, batch_size, future_step, future_p=1.0):\n assert all(k in buffer for k in ['ob', 'ag', 'bg', 'a'])\n buffer['o2'] = buffer['ob'][:, 1:, :]\n buffer['ag2'] = buffer['ag'][:, 1:, :]\n \n n_trajs = buffer['a'].shape[0]\n horizon = buffer['a'].shape[1]\n ep_idxes = np.random.randint(0, n_trajs, size=batch_size)\n t_samples = np.random.randint(0, horizon, size=batch_size)\n batch = {key: buffer[key][ep_idxes, t_samples].copy() for key in buffer.keys()}\n \n her_indexes = np.where(np.random.uniform(size=batch_size) < future_p)\n \n future_offset = (np.random.uniform(size=batch_size) * np.minimum(horizon - t_samples, future_step)).astype(int)\n future_t = (t_samples + 1 + future_offset)\n \n batch['bg'][her_indexes] = buffer['ag'][ep_idxes[her_indexes], future_t[her_indexes]]\n batch['future_ag'] = buffer['ag'][ep_idxes, future_t].copy()\n batch['offset'] = future_offset.copy()\n batch['r'] = reward_func(batch['ag2'], batch['bg'], None)\n \n assert all(batch[k].shape[0] == batch_size for k in batch.keys())\n assert all(k in batch for k in ['ob', 'ag', 'bg', 'a', 'o2', 'ag2', 'r', 'future_ag', 'offset'])\n return batch\n\n\ndef sample_transitions(buffer, batch_size):\n n_trajs = buffer['a'].shape[0]\n horizon = buffer['a'].shape[1]\n ep_idxes = np.random.randint(0, n_trajs, size=batch_size)\n t_samples = np.random.randint(0, horizon, size=batch_size)\n batch = {key: buffer[key][ep_idxes, t_samples].copy() for key in buffer.keys()}\n assert all(batch[k].shape[0] == batch_size for k in batch.keys())\n return batch\n\n\nclass Replay:\n def __init__(self, env_params, args, reward_func, name='replay'):\n self.env_params = env_params\n self.args = args\n self.reward_func = reward_func\n \n self.horizon = env_params['max_timesteps']\n self.size = args.buffer_size // self.horizon\n \n self.current_size = 0\n self.n_transitions_stored = 0\n \n self.buffers = dict(ob=np.zeros((self.size, self.horizon + 1, self.env_params['obs'])),\n ag=np.zeros((self.size, self.horizon + 1, self.env_params['goal'])),\n bg=np.zeros((self.size, self.horizon, self.env_params['goal'])),\n a=np.zeros((self.size, self.horizon, self.env_params['action'])))\n \n self.lock = threading.Lock()\n self._save_file = str(name) + '_' + str(mpi_utils.get_rank()) + '.pt'\n \n def store(self, episodes):\n ob_list, ag_list, bg_list, a_list = episodes['ob'], episodes['ag'], episodes['bg'], episodes['a']\n batch_size = ob_list.shape[0]\n with self.lock:\n idxs = self._get_storage_idx(batch_size=batch_size)\n self.buffers['ob'][idxs] = ob_list.copy() # State\n self.buffers['ag'][idxs] = ag_list.copy() # Achieved state after N steps\n self.buffers['bg'][idxs] = bg_list.copy() # Desired goal\n self.buffers['a'][idxs] = a_list.copy() # Action taken from state\n self.n_transitions_stored += self.horizon * batch_size\n \n def sample(self, batch_size):\n temp_buffers = {}\n with self.lock:\n for key in self.buffers.keys():\n temp_buffers[key] = self.buffers[key][:self.current_size]\n transitions = sample_her_transitions(temp_buffers, self.reward_func, batch_size,\n future_step=self.args.future_step,\n future_p=self.args.future_p)\n return transitions\n \n def _get_storage_idx(self, batch_size):\n if self.current_size + batch_size <= self.size:\n idx = np.arange(self.current_size, self.current_size + batch_size)\n elif self.current_size < self.size:\n idx_a = np.arange(self.current_size, self.size)\n idx_b = np.random.randint(0, self.current_size, batch_size - len(idx_a))\n idx = np.concatenate([idx_a, idx_b])\n else:\n idx = np.random.randint(0, self.size, batch_size)\n self.current_size = min(self.size, self.current_size + batch_size)\n if batch_size == 1:\n idx = idx[0]\n return idx\n \n def get_all_data(self):\n temp_buffers = {}\n with self.lock:\n for key in self.buffers.keys():\n temp_buffers[key] = self.buffers[key][:self.current_size]\n return temp_buffers\n \n def sample_regular_batch(self, batch_size):\n temp_buffers = {}\n with self.lock:\n for key in self.buffers.keys():\n temp_buffers[key] = self.buffers[key][:self.current_size]\n transitions = sample_transitions(temp_buffers, batch_size)\n return transitions\n \n def state_dict(self):\n return dict(\n current_size=self.current_size,\n n_transitions_stored=self.n_transitions_stored,\n buffers=self.buffers,\n )\n \n def load_state_dict(self, state_dict):\n self.current_size = state_dict['current_size']\n self.n_transitions_stored = state_dict['n_transitions_stored']\n self.buffers = state_dict['buffers']\n \n def save(self, path):\n state_dict = self.state_dict()\n save_path = osp.join(path, self._save_file)\n torch.save(state_dict, save_path)\n \n def load(self, path):\n load_path = osp.join(path, self._save_file)\n try:\n state_dict = torch.load(load_path)\n except RuntimeError:\n state_dict = torch.load(load_path, map_location=torch.device('cpu'))\n self.load_state_dict(state_dict)\n"
] | [
[
"numpy.random.uniform",
"torch.load",
"numpy.zeros",
"torch.save",
"numpy.arange",
"numpy.concatenate",
"numpy.random.randint",
"torch.device",
"numpy.minimum"
]
] |
pnsafari/speechbrain | [
"3a6956a838f3796ff6d041ee6a20bcdea55794cb"
] | [
"recipes/VoxCeleb/SpeakerRec/speaker_verification_plda.py"
] | [
"#!/usr/bin/python3\n\"\"\"Recipe for training a speaker verification system based on PLDA using the voxceleb dataset.\nThe system employs a pre-trained model followed by a PLDA transformation.\nThe pre-trained model is automatically downloaded from the web if not specified.\n\nTo run this recipe, run the following command:\n > python speaker_verification_plda.py hyperparams/verification_plda_xvector.yaml\n\nAuthors\n * Nauman Dawalatabad 2020\n * Mirco Ravanelli 2020\n\"\"\"\n\nimport os\nimport sys\nimport torch\nimport torchaudio\nimport logging\nimport speechbrain as sb\nimport numpy\nimport pickle\nfrom tqdm.contrib import tqdm\nfrom hyperpyyaml import load_hyperpyyaml\nfrom speechbrain.utils.metric_stats import EER, minDCF\nfrom speechbrain.processing.PLDA_LDA import StatObject_SB\nfrom speechbrain.processing.PLDA_LDA import Ndx\nfrom speechbrain.processing.PLDA_LDA import fast_PLDA_scoring\nfrom speechbrain.utils.data_utils import download_file\nfrom speechbrain.utils.distributed import run_on_main\n\n\n# Compute embeddings from the waveforms\ndef compute_embeddings(wavs, wav_lens):\n \"\"\"Compute speaker embeddings.\n\n Arguments\n ---------\n wavs : Torch.Tensor\n Tensor containing the speech waveform (batch, time).\n Make sure the sample rate is fs=16000 Hz.\n wav_lens: Torch.Tensor\n Tensor containing the relative length for each sentence\n in the length (e.g., [0.8 0.6 1.0])\n \"\"\"\n wavs = wavs.to(params[\"device\"])\n wav_lens = wav_lens.to(params[\"device\"])\n with torch.no_grad():\n feats = params[\"compute_features\"](wavs)\n feats = params[\"mean_var_norm\"](feats, wav_lens)\n embeddings = params[\"embedding_model\"](feats, wav_lens)\n embeddings = params[\"mean_var_norm_emb\"](\n embeddings, torch.ones(embeddings.shape[0]).to(embeddings.device)\n )\n return embeddings.squeeze(1)\n\n\ndef emb_computation_loop(split, set_loader, stat_file):\n \"\"\"Computes the embeddings and saves the in a stat file\"\"\"\n # Extract embeddings (skip if already done)\n if not os.path.isfile(stat_file):\n embeddings = numpy.empty(\n shape=[0, params[\"emb_dim\"]], dtype=numpy.float64\n )\n modelset = []\n segset = []\n with tqdm(set_loader, dynamic_ncols=True) as t:\n for batch in t:\n ids = batch.id\n wavs, lens = batch.sig\n mod = [x for x in ids]\n seg = [x for x in ids]\n modelset = modelset + mod\n segset = segset + seg\n\n # Enrollment and test embeddings\n embs = compute_embeddings(wavs, lens)\n xv = embs.squeeze().cpu().numpy()\n embeddings = numpy.concatenate((embeddings, xv), axis=0)\n\n modelset = numpy.array(modelset, dtype=\"|O\")\n segset = numpy.array(segset, dtype=\"|O\")\n\n # Intialize variables for start, stop and stat0\n s = numpy.array([None] * embeddings.shape[0])\n b = numpy.array([[1.0]] * embeddings.shape[0])\n\n # Stat object (used to collect embeddings)\n stat_obj = StatObject_SB(\n modelset=modelset,\n segset=segset,\n start=s,\n stop=s,\n stat0=b,\n stat1=embeddings,\n )\n logger.info(f\"Saving stat obj for {split}\")\n stat_obj.save_stat_object(stat_file)\n\n else:\n logger.info(f\"Skipping embedding Extraction for {split}\")\n logger.info(f\"Loading previously saved stat_object for {split}\")\n\n with open(stat_file, \"rb\") as input:\n stat_obj = pickle.load(input)\n\n return stat_obj\n\n\ndef verification_performance(scores_plda):\n \"\"\"Computes the Equal Error Rate give the PLDA scores\"\"\"\n\n # Create ids, labels, and scoring list for EER evaluation\n ids = []\n labels = []\n positive_scores = []\n negative_scores = []\n for line in open(veri_file_path):\n lab = int(line.split(\" \")[0].rstrip().split(\".\")[0].strip())\n enrol_id = line.split(\" \")[1].rstrip().split(\".\")[0].strip()\n test_id = line.split(\" \")[2].rstrip().split(\".\")[0].strip()\n\n # Assuming enrol_id and test_id are unique\n i = int(numpy.where(scores_plda.modelset == enrol_id)[0][0])\n j = int(numpy.where(scores_plda.segset == test_id)[0][0])\n\n s = float(scores_plda.scoremat[i, j])\n labels.append(lab)\n ids.append(enrol_id + \"<>\" + test_id)\n if lab == 1:\n positive_scores.append(s)\n else:\n negative_scores.append(s)\n\n # Clean variable\n del scores_plda\n\n # Final EER computation\n eer, th = EER(torch.tensor(positive_scores), torch.tensor(negative_scores))\n min_dcf, th = minDCF(\n torch.tensor(positive_scores), torch.tensor(negative_scores)\n )\n return eer, min_dcf\n\n\n# Function to get mod and seg\ndef get_utt_ids_for_test(ids, data_dict):\n mod = [data_dict[x][\"wav1\"][\"data\"] for x in ids]\n seg = [data_dict[x][\"wav2\"][\"data\"] for x in ids]\n\n return mod, seg\n\n\ndef dataio_prep(params):\n \"Creates the dataloaders and their data processing pipelines.\"\n\n data_folder = params[\"data_folder\"]\n\n # 1. Declarations:\n\n # Train data (used for normalization)\n train_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\n csv_path=params[\"train_data\"], replacements={\"data_root\": data_folder},\n )\n train_data = train_data.filtered_sorted(\n sort_key=\"duration\", select_n=params[\"n_train_snts\"]\n )\n\n # Enrol data\n enrol_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\n csv_path=params[\"enrol_data\"], replacements={\"data_root\": data_folder},\n )\n enrol_data = enrol_data.filtered_sorted(sort_key=\"duration\")\n\n # Test data\n test_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\n csv_path=params[\"test_data\"], replacements={\"data_root\": data_folder},\n )\n test_data = test_data.filtered_sorted(sort_key=\"duration\")\n\n datasets = [train_data, enrol_data, test_data]\n\n # 2. Define audio pipeline:\n @sb.utils.data_pipeline.takes(\"wav\", \"start\", \"stop\")\n @sb.utils.data_pipeline.provides(\"sig\")\n def audio_pipeline(wav, start, stop):\n start = int(start)\n stop = int(stop)\n num_frames = stop - start\n sig, fs = torchaudio.load(\n wav, num_frames=num_frames, frame_offset=start\n )\n sig = sig.transpose(0, 1).squeeze(1)\n return sig\n\n sb.dataio.dataset.add_dynamic_item(datasets, audio_pipeline)\n\n # 3. Set output:\n sb.dataio.dataset.set_output_keys(datasets, [\"id\", \"sig\", \"spk_id\"])\n\n # 4 Create dataloaders\n train_dataloader = sb.dataio.dataloader.make_dataloader(\n train_data, **params[\"train_dataloader_opts\"]\n )\n enrol_dataloader = sb.dataio.dataloader.make_dataloader(\n enrol_data, **params[\"enrol_dataloader_opts\"]\n )\n test_dataloader = sb.dataio.dataloader.make_dataloader(\n test_data, **params[\"test_dataloader_opts\"]\n )\n\n return train_dataloader, enrol_dataloader, test_dataloader\n\n\nif __name__ == \"__main__\":\n\n # Logger setup\n logger = logging.getLogger(__name__)\n current_dir = os.path.dirname(os.path.abspath(__file__))\n sys.path.append(os.path.dirname(current_dir))\n\n # Load hyperparameters file with command-line overrides\n params_file, run_opts, overrides = sb.core.parse_arguments(sys.argv[1:])\n with open(params_file) as fin:\n params = load_hyperpyyaml(fin, overrides)\n \n # Download verification list (to exlude verification sentences from train)\n veri_file_path = os.path.join(\n params[\"save_folder\"], os.path.basename(params[\"verification_file\"])\n )\n download_file(params[\"verification_file\"], veri_file_path)\n\n from voxceleb_prepare import prepare_voxceleb # noqa E402\n\n # Create experiment directory\n sb.core.create_experiment_directory(\n experiment_directory=params[\"output_folder\"],\n hyperparams_to_save=params_file,\n overrides=overrides,\n )\n\n # Prepare data from dev of Voxceleb1\n logger.info(\"Data preparation\")\n prepare_voxceleb(\n data_folder=params[\"data_folder\"],\n save_folder=params[\"save_folder\"],\n verification_pairs_file=veri_file_path,\n splits=[\"train\", \"test\"],\n split_ratio=[90, 10],\n seg_dur=3,\n )\n\n # here we create the datasets objects as well as tokenization and encoding\n train_dataloader, enrol_dataloader, test_dataloader = dataio_prep(params)\n\n # Initialize PLDA vars\n modelset, segset = [], []\n embeddings = numpy.empty(shape=[0, params[\"emb_dim\"]], dtype=numpy.float64)\n\n # Embedding file for train data\n xv_file = os.path.join(\n params[\"save_folder\"], \"VoxCeleb1_train_embeddings_stat_obj.pkl\"\n )\n \n # We download the pretrained LM from HuggingFace (or elsewhere depending on\n # the path given in the YAML file). The tokenizer is loaded at the same time.\n run_on_main(params[\"pretrainer\"].collect_files)\n params[\"pretrainer\"].load_collected()\n\n params[\"embedding_model\"].eval()\n params[\"embedding_model\"].to(params[\"device\"])\n \n # Computing training embeddings (skip it of if already extracted)\n if not os.path.exists(xv_file):\n logger.info(\"Extracting embeddings from Training set..\")\n with tqdm(train_dataloader, dynamic_ncols=True) as t:\n for batch in t:\n snt_id = batch.id\n wav, lens = batch.sig\n spk_ids = batch.spk_id\n\n # Flattening speaker ids\n modelset = modelset + spk_ids\n\n # For segset\n segset = segset + snt_id\n # Compute embeddings\n emb = compute_embeddings(wav, lens)\n xv = emb.squeeze(1).cpu().numpy()\n embeddings = numpy.concatenate((embeddings, xv), axis=0)\n\n # Speaker IDs and utterance IDs\n modelset = numpy.array(modelset, dtype=\"|O\")\n segset = numpy.array(segset, dtype=\"|O\")\n\n # Intialize variables for start, stop and stat0\n s = numpy.array([None] * embeddings.shape[0])\n b = numpy.array([[1.0]] * embeddings.shape[0])\n\n embeddings_stat = StatObject_SB(\n modelset=modelset,\n segset=segset,\n start=s,\n stop=s,\n stat0=b,\n stat1=embeddings,\n )\n\n del embeddings\n\n # Save TRAINING embeddings in StatObject_SB object\n embeddings_stat.save_stat_object(xv_file)\n\n else:\n # Load the saved stat object for train embedding\n logger.info(\"Skipping embedding Extraction for training set\")\n logger.info(\n \"Loading previously saved stat_object for train embeddings..\"\n )\n with open(xv_file, \"rb\") as input:\n embeddings_stat = pickle.load(input)\n\n # Training Gaussian PLDA model\n logger.info(\"Training PLDA model\")\n params[\"compute_plda\"].plda(embeddings_stat)\n logger.info(\"PLDA training completed\")\n\n # Set paths for enrol/test embeddings\n enrol_stat_file = os.path.join(params[\"save_folder\"], \"stat_enrol.pkl\")\n test_stat_file = os.path.join(params[\"save_folder\"], \"stat_test.pkl\")\n ndx_file = os.path.join(params[\"save_folder\"], \"ndx.pkl\")\n\n # Compute enrol and Test embeddings\n enrol_obj = emb_computation_loop(\"enrol\", enrol_dataloader, enrol_stat_file)\n test_obj = emb_computation_loop(\"test\", test_dataloader, test_stat_file)\n\n # Prepare Ndx Object\n if not os.path.isfile(ndx_file):\n models = enrol_obj.modelset\n testsegs = test_obj.modelset\n\n logger.info(\"Preparing Ndx\")\n ndx_obj = Ndx(models=models, testsegs=testsegs)\n logger.info(\"Saving ndx obj...\")\n ndx_obj.save_ndx_object(ndx_file)\n else:\n logger.info(\"Skipping Ndx preparation\")\n logger.info(\"Loading Ndx from disk\")\n with open(ndx_file, \"rb\") as input:\n ndx_obj = pickle.load(input)\n\n # PLDA scoring\n logger.info(\"PLDA scoring...\")\n scores_plda = fast_PLDA_scoring(\n enrol_obj,\n test_obj,\n ndx_obj,\n params[\"compute_plda\"].mean,\n params[\"compute_plda\"].F,\n params[\"compute_plda\"].Sigma,\n )\n\n logger.info(\"Computing EER... \")\n\n # Cleaning variable\n del enrol_dataloader\n del test_dataloader\n del enrol_obj\n del test_obj\n del embeddings_stat\n\n # Final EER computation\n eer, min_dcf = verification_performance(scores_plda)\n logger.info(\"EER(%%)=%f\", eer * 100)\n logger.info(\"min_dcf=%f\", min_dcf * 100)\n"
] | [
[
"torch.ones",
"numpy.empty",
"torch.no_grad",
"torch.tensor",
"numpy.where",
"numpy.array",
"numpy.concatenate"
]
] |
aforren1/ratcave | [
"e3862cdaba100ac2c6c78c08c4b09638e0c88fd4"
] | [
"ratcave/utils/vertices.py"
] | [
"import itertools\nimport numpy as np\n\ndef pairwise(iterable):\n \"s -> (s0,s1), (s1,s2), (s2, s3), ...\"\n a, b = itertools.tee(iterable)\n next(b, None)\n return zip(a, b)\n\n\ndef struct_to_ndarray(array):\n \"\"\"Turns returns a view of a structured array as a regular ndarray.\"\"\"\n return array.view(array.dtype[0]).reshape((array.shape[0], -1))\n\n\ndef reindex_vertices(arrays=None):\n\n all_arrays = np.hstack(arrays)\n array_ncols = tuple(array.shape[1] for array in arrays)\n\n # Build a new array list, composed of only the unique combinations (no redundant data)\n row_searchable_array = all_arrays.view(all_arrays.dtype.descr * all_arrays.shape[1])\n unique_combs = np.sort(np.unique(row_searchable_array))\n\n new_indices = np.array([np.searchsorted(unique_combs, vert) for vert in row_searchable_array]).flatten().astype(np.uint32)\n\n ucombs = struct_to_ndarray(unique_combs)\n new_arrays = tuple(ucombs[:, start:end] for start, end in pairwise(np.append(0, np.cumsum(array_ncols))))\n new_arrays = tuple(np.array(array, dtype=np.float32) for array in new_arrays)\n return new_arrays, new_indices\n\n\ndef calculate_normals(vertices):\n \"\"\"Return Nx3 normal array from Nx3 vertex array.\"\"\"\n verts = np.array(vertices, dtype=float)\n normals = np.zeros_like(verts)\n for start, end in pairwise(np.arange(0, verts.shape[0] + 1, 3)):\n vecs = np.vstack((verts[start + 1] - verts[start], verts[start + 2] - verts[start])) # Get triangle of vertices and calculate 2-1 and 3-1\n vecs /= np.linalg.norm(vecs, axis=1, keepdims=True) # normalize vectors\n normal = np.cross(*vecs) # normal is the cross products of vectors.\n normals[start:end, :] = normal / np.linalg.norm(normal)\n return normals\n"
] | [
[
"numpy.vstack",
"numpy.zeros_like",
"numpy.cumsum",
"numpy.searchsorted",
"numpy.cross",
"numpy.arange",
"numpy.hstack",
"numpy.array",
"numpy.linalg.norm",
"numpy.unique"
]
] |
sungcheolkim78/py_kbible | [
"3a576c20e5e49f5e85be6ddede20accb6df14663"
] | [
"py_kbible/kbible.py"
] | [
"\"\"\"\nkbible.py - base bible object and commands\n\"\"\"\n\nimport pandas as pd\nimport yaml\nimport os\nimport subprocess\n\n__author__ = \"Sungcheol Kim <[email protected]>\"\n__docformat__ = \"restructuredtext en\"\n\nclass KBible(object):\n \"\"\" Bible text object \"\"\"\n\n def __init__(self, version=\"개역한글판성경\", debug=False, **kwargs):\n \"\"\" read or parse bible text \"\"\"\n\n self._biblelist = []\n self._versionlist = {}\n\n this_dir, this_filename = os.path.split(__file__)\n listname = os.path.join(this_dir, \"data\", u\"book_names.csv\")\n self._table = pd.read_csv(listname, index_col=0)\n\n self.add(version, **kwargs)\n\n def add(self, version, **kwargs):\n \"\"\" add different version \"\"\"\n b = read_full_bible(version_name=version, **kwargs)\n self._biblelist.append(b)\n self._versionlist[version] = len(self._biblelist) - 1\n\n def delete(self, version):\n \"\"\" remove version \"\"\"\n if (version in self._versionlist) and (len(self._versionlist) > 1):\n i = self._versionlist[version]\n del self._versionlist[version]\n del self._biblelist[i]\n else:\n print('... not found or only have one bible version: {}'.format(version))\n\n def save(self, version=\"개역한글판성경\"):\n \"\"\" save bible text as compressed csv \"\"\"\n\n if version in self._versionlist:\n this_dir, this_filename = os.path.split(__file__)\n filename = os.path.join(this_dir, \"data\", version + \".csv.gz\")\n\n b = self._biblelist[self._versionlist[version]]\n b.to_csv(filename, compression='gzip')\n print('... save file: {}'.format(filename))\n\n def get(self, version=\"\"):\n \"\"\" return bible as pandas \"\"\"\n\n if version == \"\":\n return self._biblelist[0]\n\n try:\n return self._biblelist[self._versionlist[version]]\n except:\n print('... no bible version: {}'.format(version))\n return []\n\n def bystr(self, sstr, form=\"md\"):\n \"\"\" extract bible verse \"\"\"\n\n if form == \"pd\":\n res = pd.DataFrame()\n for b in self._biblelist:\n res = pd.concat([res, extract_bystr(b, sstr, form=\"pd\")], axis=0)\n return res\n else:\n msg = \"\"\n for b in self._biblelist:\n msg = msg + extract_bystr(b, sstr, form=form) + '\\n'\n return msg\n\n def search(self, sstr, form=\"md\", regex=False):\n \"\"\" search string in bible \"\"\"\n\n res = pd.DataFrame()\n for b in self._biblelist:\n b_res_idx = b.text.str.contains(sstr, regex=regex)\n if sum(b_res_idx) > 0:\n res = pd.concat([res, b[b_res_idx]], axis=0)\n\n if len(res) > 0:\n return get_texts(res, form=form)\n else:\n print('... no matched results')\n return []\n\n def read(self, sstr, form='mdlines'):\n \"\"\" search by short index string and show in markdown file \"\"\"\n\n msg = self.bystr(sstr, form=form)\n\n with open('.temp.md', 'w') as f:\n f.writelines(msg)\n\n cmd = ['open', '.temp.md']\n subprocess.call(cmd)\n\n\ndef bible_parser(version_name=\"개역한글판성경\"):\n \"\"\" read bible text and return panda database\n inputs:\n version_name : available versions 개역한글판성경, 개역개정판성경\n output:\n bible panda dataframe as short version\n \"\"\"\n\n # read bible txt file\n this_dir, this_filename = os.path.split(__file__)\n filename = os.path.join(this_dir, \"data\", version_name + \".txt\")\n with open(filename, \"r\") as f:\n lines = f.readlines()\n\n # prepare data container\n books = []\n chapters = []\n verses = []\n texts = []\n\n for i, line in enumerate(lines):\n line = line.strip('\\n\\r')\n\n # check comment line\n if len(line) == 0:\n continue\n if line[0] == \"#\":\n continue\n if line.find(':') == -1:\n continue\n\n # find header\n hp = line.find(' ')\n if hp > 1 and hp < 25:\n header = line[:hp]\n text = line[hp+1:]\n\n # find book, chapter, verse, text\n try:\n tmp = header.split(':')[0]\n if tmp.find('.') > 0: # english bible short name\n book = tmp.split('.')[0]\n chapter = tmp.split('.')[1]\n elif tmp[:2] in [\"1_\", \"2_\", \"3_\"]: # english bible long name\n book = tmp[:2] + ''.join(filter(str.isalpha, tmp[2:]))\n chapter = ''.join(filter(str.isdigit, tmp[2:]))\n else: # korean bible\n book = ''.join(filter(str.isalpha, tmp))\n chapter = ''.join(filter(str.isdigit, tmp))\n verse = header.split(':')[1]\n except:\n print('... header error: ({}) {}'.format(i, header))\n continue\n\n # convert data\n try:\n verse = int(verse)\n chapter = int(chapter)\n except:\n print(\"... conversion error: ({}) {} {}\".format(i, verse, chapter))\n continue\n\n # collect\n books.append(book)\n chapters.append(chapter)\n verses.append(verse)\n texts.append(text)\n else:\n print(\"... unrecognized line: ({}) {}\".format(i, line))\n\n df_bible = {'book':books, 'chapter':chapters, 'verse':verses, 'text':texts}\n idx = range(len(books))\n bible = pd.DataFrame(data=df_bible, index=idx)\n\n return bible\n\n\ndef read_full_bible(version_name=\"개역한글판성경\", save=False):\n \"\"\" read bible version and combine book data\n inputs:\n version_name: bible version\n save: [True|False]\n output:\n bible panda dataframe\n \"\"\"\n\n try:\n this_dir, this_filename = os.path.split(__file__)\n filename = os.path.join(this_dir, \"data\", version_name + \".csv.gz\")\n full_bible = pd.read_csv(filename, index_col=0, compression = \"gzip\")\n return full_bible\n except FileNotFoundError:\n print('... generate bible database: {}'.format(filename))\n\n bible = bible_parser(version_name=version_name)\n\n listname = os.path.join(this_dir, \"data\", u\"book_names.csv\")\n table = pd.read_csv(listname, index_col=0)\n\n if bible['book'][0] == 'Gen':\n table['book'] = table['eng_short']\n elif bible['book'][0] == 'Genesis':\n table['book'] = table['eng']\n else:\n table['book'] = table['kor_short']\n\n full_bible = pd.merge(bible, table, on='book', how='left')\n\n if save:\n full_bible.to_csv(filename, compression='gzip')\n\n return full_bible\n\n\ndef find_id(bible, book=[], chapter=[], verse=[], verb=False):\n \"\"\" find index on full bible database\n inputs:\n bible: bible panda database\n book: book names as list\n chapter: chapters as list\n verse: verses as list\n verb: [True|False] show details\n output:\n panda dataframe filtered by all combination of book, chapter, verses\n \"\"\"\n\n isfullbible = False\n\n # check books\n books = set(bible['book'])\n if \"code\" in bible.columns:\n isfullbible = True\n\n if len(book) == 0:\n book = books[0]\n if isinstance(book, str):\n book = [book]\n\n if verb: print('... search book:{}'.format(book))\n if isfullbible:\n result = bible.loc[bible.kor.isin(book) | bible.kor_short.isin(book) | bible.eng.isin(book) | bible.eng_short.isin(book) | bible.book.isin(book)]\n else:\n result = bible.loc[bible.book.isin(book)]\n\n # check chapter\n if isinstance(chapter, int):\n chapter = [chapter]\n if len(chapter) == 0:\n return result\n\n if verb: print('... search chapter: {}'.format(chapter))\n result = result.loc[bible.chapter.isin(chapter)]\n\n # check verse\n if isinstance(verse, int):\n verse = [verse]\n if len(verse) == 0:\n return result\n\n if verb: print('... search verse: {}'.format(verse))\n result = result.loc[bible.verse.isin(verse)]\n\n if len(result) > 0:\n return result\n else:\n print(\"... not found: {}, {}, {}\".format(book, chapter, verse))\n return []\n\n\ndef extract_bystr(bible, sstr, form=\"pd\"):\n \"\"\" extract verse by short search string\n inputs:\n bible: panda database of bible version\n sstr: search pattern\n - example \"창3:16\", \"고후5:3\", '요일1:1', \"창세기1:1\"\n - no spaces\n - one separator :\n - ',' and '-' is possible (창3:16,17) (창1:1-5)\n form: output format\n - \"md\" one line sentence with markdowm\n - \"string\" text string\n - \"pd\" panda dataframe\n output:\n object determined by form variable\n \"\"\"\n\n # remove all spaces\n sstr = sstr.replace(\" \", \"\")\n\n # find components\n if sstr.find(\":\") > 0:\n head = sstr.split(':')[0]\n verses = sstr.split(':')[1]\n else:\n head = sstr\n verses = []\n\n book = ''.join(filter(str.isalpha, head))\n chapter = ''.join(filter(str.isdigit, head))\n\n # if there is no chapter\n if len(chapter) == 0:\n chapter = []\n else:\n chapter = int(chapter)\n\n # check , in verse\n if len(verses) > 0:\n if verses.find(',') > 0:\n verses = verses.split(',')\n # check - in verse\n elif verses.find('-') > 0:\n start = verses.split('-')[0]\n end = verses.split('-')[1]\n try:\n verses = list(range(int(start), int(end)+1))\n except:\n print('... wrong format: {}'.format(sstr))\n return 0\n else:\n verses = [int(verses)]\n\n verses = [int(v) for v in verses]\n\n #print(book, chapter, verses)\n\n # return verses\n res = find_id(bible, book=book, chapter=chapter, verse=verses)\n if len(res) == 0:\n return []\n\n return get_texts(res, form=form, sstr=sstr)\n\n\ndef get_texts(bible_pd, form=\"md\", sstr=\"\", sep=\"\", text_width=0):\n \"\"\" print verses using different format \"\"\"\n\n if form == \"pd\":\n return bible_pd\n\n if len(bible_pd[\"book\"]) == 0:\n return \"\"\n\n # show id as kor_short\n bible_pd.loc[:, \"id\"] = bible_pd.loc[:, \"kor_short\"] + sep + bible_pd[\"chapter\"].astype(str) + \":\" + bible_pd[\"verse\"].astype(str)\n bible_pd = tidy_footnote(bible_pd)\n\n if (len(set(bible_pd[\"book\"])) == 1) and (sstr.find(\":\") == -1):\n min_v = bible_pd[\"verse\"].min()\n max_v = bible_pd[\"verse\"].max()\n sstr = \"{}:{}-{}\".format(sstr, min_v, max_v)\n\n if form == \"string\":\n if sstr == \"\":\n bible_pd[form] = bible_pd[\"id\"] + \" - \" + bible_pd[form].astype(str)\n msg = '\\n'.join(bible_pd[form].values)\n else:\n msg = sstr + ' ' + ' '.join(bible_pd[form].values)\n return msg\n\n if form == \"md\":\n if sstr == \"\":\n bible_pd[form] = \"`\" + bible_pd[\"id\"] + \"` \" + bible_pd[form].astype(str)\n msg = '\\n'.join(bible_pd[form].values)\n else:\n verse_string_list = [ '<sup>{}</sup> {}'.format(v, l) for v,l in zip(bible_pd['verse'], bible_pd[form]) ]\n msg = '`{}` '.format(sstr) + ' '.join(verse_string_list)\n\n if sum(bible_pd[\"footnote\"] != \"\") > 0:\n return msg + '\\n' + ''.join(bible_pd[\"footnote\"].values)\n else:\n return msg\n\n if form == \"mdlines\":\n bible_pd[\"md\"] = \"`\" + bible_pd[\"id\"] + \"` \" + bible_pd[\"md\"].astype(str)\n msg = '\\n'.join(bible_pd[\"md\"].values)\n\n if sum(bible_pd[\"footnote\"] != \"\") > 0:\n return msg + '\\n' + ''.join(bible_pd[\"footnote\"].values)\n else:\n return msg\n\n print('... {} format is not implemented: [\"pd\", \"md\", \"string\"]'.format(form))\n return []\n\n\ndef tidy_footnote(bible_pd, keyword=\"FOOTNOTE\"):\n \"\"\" remove footnote \"\"\"\n\n bible_pd[\"md\"] = bible_pd[\"text\"]\n bible_pd[\"string\"] = bible_pd[\"text\"]\n bible_pd[\"footnote\"] = \"\"\n\n start_word = \"__a__{}__a__\".format(keyword)\n end_word = \"__b__{}__b__\".format(keyword)\n fn_idx = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n\n # search different verses\n for i in bible_pd.index[bible_pd.text.str.contains(start_word)]:\n # search in one verse\n text = bible_pd.at[i, \"text\"]\n tmp = text.replace(\"_b_\", \"_a_\").split(start_word)\n\n bible_pd.at[i, \"string\"] = tmp[0] + ''.join(tmp[2::2])\n\n # check multiple footnotes\n md = tmp[0]\n fn = \"\"\n for j in range(int(len(tmp)/2)):\n md = md + \"[^{}{}]\".format(bible_pd.at[i, \"id\"], fn_idx[j]) + tmp[j*2 + 2]\n fn = fn + \"[^{}{}]:\".format(bible_pd.at[i, \"id\"], fn_idx[j]) + tmp[j*2 + 1].replace(\"TR\",\"\") + '\\n'\n\n bible_pd.at[i, \"md\"] = md\n bible_pd.at[i, \"footnote\"] = fn\n\n return bible_pd\n\n\ndef make_mdpage(bible, day_info, save_dir=None):\n \"\"\" print all verses in list using markdown format\n inputs:\n bible: name of version or panda dataframe\n day_info: name of day information file or yaml data\n save: [True|False]\n output:\n text strings of markdown page\n \"\"\"\n\n # check day_info.yml file\n if isinstance(day_info, str):\n try:\n with open(day_info, \"r\") as f:\n day_info = yaml.load(f, yaml.BaseLoader)\n except:\n print(\"... file: {} parser error!\".format(day_info))\n return 0\n\n bible_version = \"\"\n # check bible version\n if isinstance(bible, str):\n try:\n bible_version = \"-\" + bible\n bible = read_full_bible(bible)\n except:\n print(\"... read bible error: {}\".format(bible_version[1:]))\n return 0\n\n msg = \"# {}일차 - {}\\n\\n\".format(day_info[\"day\"],day_info[\"title\"])\n msg = msg + \"찬양 : {}\\n\\n\".format(day_info[\"song\"])\n msg = msg + \"기도 : {}\\n\\n\".format(day_info[\"prayer\"])\n msg = msg + \"요약 : {}\\n\\n\".format(day_info[\"summary\"])\n msg = msg + \"성경 버전 : {}\\n\\n\".format(bible_version[1:])\n\n for v in day_info[\"verses\"]:\n msg = msg + '- {}\\n\\n'.format(extract_bystr(bible, v, form=\"md\"))\n\n msg = msg + \"### info\\n\\n\"\n msg = msg + \"- 성경 구절 갯수 : {}\".format(len(day_info[\"verses\"]))\n\n if save_dir is not None:\n filename = '{}/day{}-{}{}.md'.format(save_dir, day_info[\"day\"], day_info[\"title\"].replace(\" \", \"\"), bible_version)\n with open(filename, \"w\") as f:\n f.write(msg)\n print('... save to {}'.format(filename))\n\n return msg\n"
] | [
[
"pandas.read_csv",
"pandas.DataFrame",
"pandas.merge",
"pandas.concat"
]
] |
imaroger/sot-talos-balance | [
"5e56700b4e105273ecf6feb3474789beac469a77"
] | [
"src/sot_talos_balance/test/test_zmpEstimator.py"
] | [
"from time import sleep\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom sot_talos_balance.utils.run_test_utils import evalCommandClient, run_ft_calibration, run_test, runCommandClient\n\ntry:\n # Python 2\n input = raw_input # noqa\nexcept NameError:\n pass\n\nrun_test('appli_zmpEstimator.py')\n\nrun_ft_calibration('robot.ftc')\ninput(\"Wait before running the test\")\n\n# plug ZMP emergency signal\nrunCommandClient('plug(robot.zmp_estimator.emergencyStop,robot.cm.emergencyStop_zmp)')\nsleep(2.0)\nrunCommandClient('robot.comTrajGen.move(1,-0.025,1.0)')\nsleep(20.0)\nrunCommandClient('robot.comTrajGen.startSinusoid(1,0.05,2.0)')\nsleep(20.0)\n\nrunCommandClient('dump_tracer(robot.tracer)')\n\n# --- DISPLAY\nzmpEst_data = np.loadtxt('/tmp/dg_' + evalCommandClient('robot.zmp_estimator.name') + '-zmp.dat')\nzmpDyn_data = np.loadtxt('/tmp/dg_' + evalCommandClient('robot.dynamic.name') + '-zmp.dat')\ncom_data = np.loadtxt('/tmp/dg_' + evalCommandClient('robot.dynamic.name') + '-com.dat')\nforceRLEG_data = np.loadtxt('/tmp/dg_' + evalCommandClient('robot.device.name') + '-forceRLEG.dat')\nforceLLEG_data = np.loadtxt('/tmp/dg_' + evalCommandClient('robot.device.name') + '-forceLLEG.dat')\n\nplt.ion()\n\nplt.figure()\nplt.plot(zmpEst_data[:, 1], 'b-')\nplt.plot(zmpDyn_data[:, 1], 'b--')\nplt.plot(com_data[:, 1], 'b:')\nplt.plot(zmpEst_data[:, 2], 'r-')\nplt.plot(zmpDyn_data[:, 2], 'r--')\nplt.plot(com_data[:, 2], 'r:')\nplt.title('ZMP estimate vs dynamic vs CoM (planar)')\nplt.legend(['x estimate', 'x dynamic', 'x CoM', 'y estimate', 'y dynamic', 'y CoM'])\n\nplt.figure()\nplt.plot(com_data[:, 1], 'b-')\nplt.plot(com_data[:, 2], 'r-')\nplt.plot(com_data[:, 3], 'g-')\nplt.title('COM')\nplt.legend(['x', 'y', 'z'])\n\nplt.figure()\nplt.plot(zmpDyn_data[:, 1], 'b-')\nplt.plot(zmpDyn_data[:, 2], 'r-')\nplt.plot(zmpDyn_data[:, 3], 'g-')\nplt.title('ZMP dynamic')\nplt.legend(['x', 'y', 'z'])\n\nplt.figure()\nplt.plot(zmpEst_data[:, 1], 'b-')\nplt.plot(zmpEst_data[:, 2], 'r-')\nplt.plot(zmpEst_data[:, 3], 'g-')\nplt.title('ZMP estimate')\nplt.legend(['x', 'y', 'z'])\n\nplt.figure()\nplt.plot(forceLLEG_data[:, 1], 'b-')\nplt.plot(forceLLEG_data[:, 2], 'r-')\nplt.plot(forceLLEG_data[:, 3], 'g-')\nplt.plot(forceLLEG_data[:, 4], 'b--')\nplt.plot(forceLLEG_data[:, 5], 'r--')\nplt.plot(forceLLEG_data[:, 6], 'g--')\nplt.title('forceLLEG')\nplt.legend(['fx', 'fy', 'fz', 'tx', 'ty', 'tz'])\n\nplt.figure()\nplt.plot(forceRLEG_data[:, 1], 'b-')\nplt.plot(forceRLEG_data[:, 2], 'r-')\nplt.plot(forceRLEG_data[:, 3], 'g-')\nplt.plot(forceRLEG_data[:, 4], 'b--')\nplt.plot(forceRLEG_data[:, 5], 'r--')\nplt.plot(forceRLEG_data[:, 6], 'g--')\nplt.title('forceRLEG')\nplt.legend(['fx', 'fy', 'fz', 'tx', 'ty', 'tz'])\n\ninput(\"Wait before leaving the simulation\")\n"
] | [
[
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.title",
"matplotlib.pyplot.ion"
]
] |
jonathan-sung/Hexapod-GA-Gait | [
"5e82c2f141f6bd88d8b6c0a7b658c8ce0c5be8f4"
] | [
"hexapodengine2.py"
] | [
"import pybullet as p\nimport math\nimport pybullet_data\nimport time\nimport random\nimport numpy as np\nimport serial\n\n\ndef radToPwm(angle):\n return ((2000 * angle) / math.pi) + 1500\n\n\n# t in ms; the closer t is to 0, more accuracy but less smooth motion\ndef updateRealServos(ser, t):\n # right legs\n ser.write(\n f'#0P{radToPwm(-p.getJointState(hexapod_ID, 8)[0])}T{t}#1P{radToPwm(p.getJointState(hexapod_ID, 9)[0])}T{t}#2P{radToPwm(-p.getJointState(hexapod_ID, 10)[0])-100}T{t}\\r'.encode(\n 'utf-8'))\n ser.write(\n f'#4P{radToPwm(-p.getJointState(hexapod_ID, 4)[0])}T{t}#5P{radToPwm(p.getJointState(hexapod_ID, 5)[0])}T{t}#6P{radToPwm(-p.getJointState(hexapod_ID, 6)[0])+100}T{t}\\r'.encode(\n 'utf-8'))\n ser.write(\n f'#8P{radToPwm(-p.getJointState(hexapod_ID, 0)[0])}T{t}#9P{radToPwm(p.getJointState(hexapod_ID, 1)[0])}T{t}#10P{radToPwm(-p.getJointState(hexapod_ID, 2)[0])}T{t}\\r'.encode(\n 'utf-8'))\n\n # left legs\n ser.write(\n f'#24P{radToPwm(-p.getJointState(hexapod_ID, 12)[0])}T{t}#25P{radToPwm(p.getJointState(hexapod_ID, 13)[0])}T{t}#26P{radToPwm(-p.getJointState(hexapod_ID, 14)[0])+100}T{t}\\r'.encode(\n 'utf-8'))\n ser.write(\n f'#20P{radToPwm(-p.getJointState(hexapod_ID, 16)[0])}T{t}#21P{radToPwm(p.getJointState(hexapod_ID, 17)[0])}T{t}#22P{radToPwm(-p.getJointState(hexapod_ID, 18)[0])}T{t}\\r'.encode(\n 'utf-8'))\n ser.write(\n f'#16P{radToPwm(-p.getJointState(hexapod_ID, 20)[0])}T{t}#17P{radToPwm(p.getJointState(hexapod_ID, 21)[0])}T{t}#18P{radToPwm(-p.getJointState(hexapod_ID, 22)[0])-50}T{t}\\r'.encode(\n 'utf-8'))\n\n\ndef init_debug_parameters():\n for j in list(range(0, 6)):\n control_IDs.append(p.addUserDebugParameter(f\"Pelvis {j}\", -servoRangeOfMotion, servoRangeOfMotion, 0))\n control_IDs.append(p.addUserDebugParameter(f\"Hip {j}\", -servoRangeOfMotion, servoRangeOfMotion, 0))\n control_IDs.append(p.addUserDebugParameter(f\"Knee {j}\", -servoRangeOfMotion, servoRangeOfMotion, 0))\n\n\ndef read_debug_parameters():\n angles = []\n for x in control_IDs:\n angles.append(p.readUserDebugParameter(x))\n return angles\n\n\ndef chromosomeCreator():\n pos = []\n duration = 1\n force = 200\n # pos.extend([duration] + [0] * NUM_OF_SERVOS)\n for j in range(LENGTH_OF_SEQUENCE - 1):\n gaitState = [0] * NUM_OF_SERVOS\n gaitState[j] = servoRangeOfMotion\n pos.extend([duration] + gaitState)\n print(len(pos))\n return [duration] + [force] + pos\n\n\ndef readGait(progress, chromosome):\n global firstCycleComplete\n end_index = LENGTH_OF_SEQUENCE\n if not firstCycleComplete and progress >= sum([chromosome[x] for x in range(0, len(chromosome), LENGTH_OF_GAIT_STATE)]):\n firstCycleComplete = True\n if firstCycleComplete:\n progress = progress - sum([chromosome[x] for x in range(0, ((LENGTH_OF_START_SEQUENCE - 1) * LENGTH_OF_GAIT_STATE) + 1, LENGTH_OF_GAIT_STATE)])\n chromosome = chromosome[LENGTH_OF_START_SEQUENCE * LENGTH_OF_GAIT_STATE:]\n end_index = LENGTH_OF_CYCLE\n start_index = 0\n total_duration = sum([chromosome[x] for x in range(0, len(chromosome), LENGTH_OF_GAIT_STATE)])\n # duration_of_start_sequence = sum([chromosome[x] for x in range(0, ((LENGTH_OF_START_SEQUENCE - 1) * LENGTH_OF_GAIT_STATE) + 1, LENGTH_OF_GAIT_STATE)])\n # duration_of_cycle = total_duration - duration_of_start_sequence\n progress = progress % total_duration\n current_duration_index = 0\n next_duration_index = 0\n sum_of_durations = 0\n for j in range(start_index, end_index):\n current_position_index = j * LENGTH_OF_GAIT_STATE\n sum_of_durations = sum([chromosome[x] for x in range(start_index, current_position_index + 1, LENGTH_OF_GAIT_STATE)])\n if progress < sum_of_durations:\n current_duration_index = current_position_index\n next_duration_index = (j + 1) * LENGTH_OF_GAIT_STATE\n if (j + 1) >= end_index:\n next_duration_index = start_index * LENGTH_OF_GAIT_STATE\n break\n current_gait_state = chromosome[current_duration_index + 1: current_duration_index + LENGTH_OF_GAIT_STATE]\n next_gait_state = chromosome[next_duration_index + 1: next_duration_index + LENGTH_OF_GAIT_STATE]\n if not firstCycleComplete and current_duration_index == (LENGTH_OF_SEQUENCE - 1) * LENGTH_OF_GAIT_STATE:\n next_gait_state = chromosome[(LENGTH_OF_START_SEQUENCE * LENGTH_OF_GAIT_STATE) + 1: (LENGTH_OF_START_SEQUENCE * LENGTH_OF_GAIT_STATE) + LENGTH_OF_GAIT_STATE]\n alpha = (progress - (sum_of_durations - chromosome[current_duration_index])) / chromosome[current_duration_index]\n interpolated_gait_state = [interpolate(a, b, alpha) for a, b in zip(current_gait_state, next_gait_state)]\n # print(progress, alpha, sum_of_durations, chromosome[current_duration_index])\n return interpolated_gait_state\n\n\ndef interpolate(a, b, alpha):\n return a * (1 - alpha) + b * alpha\n\n\ndef resetLegJoints():\n p.resetJointStatesMultiDof(hexapod_ID, JOINT_INDEXES, [[0]] * 18, targetVelocities=[[0]] * 18)\n p.setJointMotorControlArray(hexapod_ID, JOINT_INDEXES, p.POSITION_CONTROL, targetPositions=([0] * 18), forces=([150] * 18))\n\n\ndef resetEnvironment():\n resetLegJoints()\n p.resetBasePositionAndOrientation(hexapod_ID, [0, STARTING_Y, STARTING_HEIGHT + random.uniform(0, 0.002)], [0, 0, 0, 1])\n p.stepSimulation()\n\n\ndef resetPyBulletSimulation():\n global plane_ID\n global hexapod_ID\n p.resetSimulation()\n p.setGravity(0, 0, -9.8)\n plane_ID = p.loadURDF(\"plane.urdf\", globalScaling=4)\n # testAngle = p.getQuaternionFromEuler([0, math.pi/2, math.pi])\n hexapod_ID = p.loadURDF(\"robot3.urdf\", [0, STARTING_Y, STARTING_HEIGHT + random.uniform(0, 0.002)], [0, 0, 0, 1])\n print(p.getEulerFromQuaternion(p.getBasePositionAndOrientation(hexapod_ID)[1]))\n\n\ndef gaitScore(bodyID):\n current_position = p.getBasePositionAndOrientation(bodyID)[0]\n distance = distanceFromOrigin(bodyID)\n angle = angleBetweenVectors(np.array([0, 1]), np.array([current_position[0], current_position[1]]))\n return distance, abs(angle)\n\n\ndef distanceFromOrigin(bodyID):\n return p.getBasePositionAndOrientation(bodyID)[0][1]\n\n\ndef angleBetweenVectors(a, b):\n unit_vector_1 = a / np.linalg.norm(a)\n unit_vector_2 = b / np.linalg.norm(b)\n dot_product = np.dot(unit_vector_1, unit_vector_2)\n angle = np.arccos(dot_product)\n return angle\n\n\ndef inverseCurve(x, a):\n # 1/e^2 = 0.135\n # a = 0.135\n # a = 1\n # (pi/2.0)^2 = 2.467\n # a = 2.467\n y = a / (a + (x * x))\n return y\n\n\ndef collidingLegs():\n # numOfCollisions = 0\n for j in range(24):\n aabb = (p.getAABB(hexapod_ID, j))\n familyOfLinks = [x for x in range(24) if math.floor(j / 4) == math.floor(x / 4)] + [-1]\n # collisionObjects = [x[1] for x in p.getOverlappingObjects(aabb[0], aabb[1]) if x[1] not in familyOfLinks and (j not in FEET_INDEXES or x[0] == hexapod_ID)]\n collisionObjects = [x[1] for x in p.getOverlappingObjects(aabb[0], aabb[1]) if (j not in FEET_INDEXES and (x[1] not in familyOfLinks or x[0] != hexapod_ID)) or (j in FEET_INDEXES and x[1] not in familyOfLinks and x[0] == hexapod_ID)]\n if len(collisionObjects) > 0:\n return True\n return False\n\n\ndef runGait(individual):\n global REAL_HEXAPOD_CONNECTED\n lastTime = time.time()\n global firstCycleComplete\n dt = 0\n firstCycleComplete = False\n initDuration = individual[0]\n force = individual[1]\n gaitChromosome = individual[2:]\n gaitChromosome = ([initDuration] + [0] * NUM_OF_SERVOS) + gaitChromosome\n resetEnvironment()\n stabilityScore = 0\n heightScore = 0\n collisionScore = 0\n sampleCounter = 0\n p.setRealTimeSimulation(1)\n while True:\n if CONFIG_MODE:\n p.setJointMotorControlArray(hexapod_ID, JOINT_INDEXES, p.POSITION_CONTROL, targetPositions=read_debug_parameters(), forces=([force] * 18))\n else:\n p.setJointMotorControlArray(hexapod_ID, JOINT_INDEXES, p.POSITION_CONTROL, targetPositions=readGait(dt, gaitChromosome), forces=([force] * 18))\n if REAL_HEXAPOD_CONNECTED:\n updateRealServos(ssc32, 100)\n\n # Evaluation Metrics\n hexapodBasePosAndOrn = p.getBasePositionAndOrientation(hexapod_ID)\n currentStability = sum([abs(angle) for angle in list(p.getEulerFromQuaternion(hexapodBasePosAndOrn[1]))])\n currentHeight = abs(1.375 - hexapodBasePosAndOrn[0][2])\n stabilityScore += currentStability\n heightScore += currentHeight\n #collisionScore += collidingLegs()\n sampleCounter += 1\n\n # timing variables\n now = time.time()\n dt += now - lastTime\n lastTime = now\n\n # Finish evaluation after 12.5 seconds\n if dt >= 12.5:\n break\n\n hexapodBasePosAndOrn = p.getBasePositionAndOrientation(hexapod_ID)\n currentPosition = hexapodBasePosAndOrn[0]\n distance = hexapodBasePosAndOrn[0][1]\n straightness = abs(angleBetweenVectors(np.array([0, 1]), np.array([currentPosition[0], currentPosition[1]])))\n avgHeight = abs(heightScore / sampleCounter)\n avgStability = stabilityScore / sampleCounter\n avgNumOfCollisions = collisionScore / sampleCounter\n fitness_distance = distance / 100.0\n fitness_straight = 1.0 - (straightness / math.pi)\n fitness_stability = inverseCurve(avgStability, 1)\n fitness_height = inverseCurve(avgHeight, 1)\n fitness_collisions = round(1 - avgNumOfCollisions, 2)\n fitness_total = (fitness_distance + fitness_straight + fitness_stability + fitness_height + fitness_collisions) / 5.0\n line = f'ID: {UNIQUE_THREAD_ID} | Time Elapsed: {dt} | Evaluation: {fitness_distance, fitness_straight, fitness_stability, fitness_height, fitness_collisions, fitness_total} | Chromosome: {individual}'\n print(line)\n with open('C:/Users/Jonathan/Desktop/results_normal_cyclic.txt', 'a') as f:\n f.write(line)\n f.write('\\n')\n return fitness_total\n\n\ndef sinusoidalTestGait(t):\n coxa0 = (math.pi / 4) * math.sin((2 * t) + math.pi)\n femur0 = 0.2 * math.sin((2 * t) + ((5 * math.pi) / 2))\n tibia0 = 1.3 * math.sin((0 * t) + ((3 * math.pi) / 2))\n coxa1 = (math.pi / 4) * math.sin((2 * t) + 0)\n femur1 = 0.2 * math.sin((2 * t) + ((3 * math.pi) / 2))\n tibia1 = 1.3 * math.sin((0 * t) + ((3 * math.pi) / 2))\n return [coxa0, femur0, tibia0, coxa1, femur1, tibia1, coxa0, femur0, tibia0] + [-coxa0, -femur0, -tibia0, -coxa1, -femur1, -tibia1, -coxa0, -femur0, -tibia0]\n\n\ndef evaluateGait(individual):\n lastTime = time.time()\n numOfPhysicsSteps = 3000\n samplesPerEval = 100\n stabilityUpdateRate = int(numOfPhysicsSteps / samplesPerEval)\n stabilityScore = 0\n heightScore = 0\n collisionScore = 0\n global firstCycleComplete\n while True:\n dt = 0\n firstCycleComplete = False\n initDuration = individual[0]\n force = individual[1]\n gaitChromosome = individual[2:]\n gaitChromosome = ([initDuration] + [0] * NUM_OF_SERVOS) + gaitChromosome\n resetEnvironment()\n for ii in range(numOfPhysicsSteps):\n if ii % stabilityUpdateRate == 0:\n hexapodBasePosAndOrn = p.getBasePositionAndOrientation(hexapod_ID)\n currentStability = sum([abs(angle) for angle in list(p.getEulerFromQuaternion(hexapodBasePosAndOrn[1]))])\n currentHeight = abs(TARGET_HEIGHT - hexapodBasePosAndOrn[0][2])\n stabilityScore += currentStability\n heightScore += currentHeight\n collisionScore += collidingLegs()\n p.setJointMotorControlArray(hexapod_ID, JOINT_INDEXES, p.POSITION_CONTROL, targetPositions=readGait(dt, gaitChromosome), forces=([force] * 18))\n p.stepSimulation()\n dt += 1. / 240.\n # time.sleep(1. / 30.)\n hexapodBasePosAndOrn = p.getBasePositionAndOrientation(hexapod_ID)\n currentPosition = hexapodBasePosAndOrn[0]\n distance = hexapodBasePosAndOrn[0][1]\n # straightness = abs(p.getEulerFromQuaternion(hexapodBasePosAndOrn[1])[2])\n straightness = abs(angleBetweenVectors(np.array([0, 1]), np.array([currentPosition[0], currentPosition[1]])))\n avgHeight = abs(heightScore / samplesPerEval)\n avgStability = stabilityScore / samplesPerEval\n avgNumOfCollisions = collisionScore / samplesPerEval\n fitness_distance = distance / 100.0\n fitness_straight = 1.0 - (straightness / math.pi)\n fitness_stability = inverseCurve(avgStability, 1)\n fitness_height = inverseCurve(avgHeight, 1)\n fitness_collisions = round(1 - avgNumOfCollisions, 2)\n fitness_total = (fitness_distance + fitness_straight + fitness_stability + fitness_height + fitness_collisions) / 5.0\n print(f'ID: {UNIQUE_THREAD_ID} | Time Elapsed: {time.time() - lastTime} | Evaluation: {fitness_distance, fitness_straight, fitness_stability, fitness_height, fitness_collisions, fitness_total} | Chromosome: {individual}')\n if not math.isnan(distance):\n break\n else:\n print(\"PyBullet Glitch\")\n resetPyBulletSimulation()\n return fitness_total,\n\n\n# start of main program\nMAX_MOTIONS_IN_SEQUENCE = 4\nNUM_OF_LEGS = 6\nNUM_OF_JOINTS_PER_LEG = 3\nNUM_OF_SERVOS = NUM_OF_LEGS * NUM_OF_JOINTS_PER_LEG\nUNIQUE_THREAD_ID = random.randint(1, 10000)\nLENGTH_OF_CYCLE = 12\nLENGTH_OF_START_SEQUENCE = 2 + 1\nLENGTH_OF_SEQUENCE = LENGTH_OF_START_SEQUENCE + LENGTH_OF_CYCLE\nLENGTH_OF_GAIT_STATE = NUM_OF_SERVOS + 1\nSTARTING_HEIGHT = 1.375\nSTARTING_Y = 0.01\nTARGET_HEIGHT = STARTING_HEIGHT\nfirstCycleComplete = False\nREAL_HEXAPOD_CONNECTED = False\nCONFIG_MODE = False\nssc32 = None\nif REAL_HEXAPOD_CONNECTED:\n ssc32 = serial.Serial('COM3', 115200, timeout=2) # open serial port\n\ncontrol_IDs = []\n\n# PyBullet Init\nphysicsClient = None\nif __name__ == \"__main__\":\n physicsClient = p.connect(p.GUI)\nelse:\n physicsClient = p.connect(p.DIRECT)\np.setAdditionalSearchPath(pybullet_data.getDataPath())\nplane_ID = None\nhexapod_ID = None\nresetPyBulletSimulation()\nprogramStartTime = time.time()\nservoRangeOfMotion = (math.pi * 3 / 8)\nJOINT_INDEXES = [x for x in range(0, 24) if (x + 1) % 4 != 0]\nFEET_INDEXES = [x for x in range(0, 24) if (x + 1) % 4 == 0]\np.setRealTimeSimulation(0)\n\nprint(f'PyBullet Instance ID: {UNIQUE_THREAD_ID}')\n\n\ndef main():\n init_debug_parameters()\n print(\"START\")\n\n # Back-flipper 400 Gen (use robot2.URDF)\n # runGait([0.18403936561894646, 300, 0.1549125676230881, -1.0737228551789968, 1.1074034854568302, -0.5075648311566827, 0.9410632472797863, -0.034075539924461766, 0.04087326062084187, 0.016970270367710892, 1.0693994730213368, 1.155687813177694, 0.8737522824643122, -0.8647752630675463, 0.34299370658943856, -1.0211653604035968, 0.9327693440640767, -1.1011770525732225, 0.9557766462321559, 0.12072049734526494, 0.6379668000414453, 0.38230918565376665, 0.38766472211677316, -0.23345728123331336, 0.42693206671590045, 0.7481283759819202, -1.0035764425332458, -0.37743247317618395, 0.09703593626443223, 0.4096524242490998, 0.5659367640154525, -0.48634980239282366, 0.9997166523571077, 0.9918650566996552, 0.3533658070404414, 1.0175827219942823, 0.18743930901921652, -0.4458899131062403, 0.4201947524885313, 0.9657458794711107, 0.44323639067960297, 0.8503041963843176, -1.1368206866652761, -0.5949936064673491, 0.8431072036023203, -0.8259446127674113, -1.0362372103175401, 0.15060262481341474, -0.9859007911949546, -0.21962601316827257, 0.09533520637849181, -0.640348357362408, -0.8041160416557014, -0.7812025840957206, 0.11151372791644286, 0.8274774721561737, -0.587046978534175, -0.32808303668861744, 0.2379704057869646, 0.18775280488712448, -0.4377264809328173, 0.5907623805366229, 0.05202338940205825, -0.2451747086887523, 0.8470984599764407, -0.7682503206243262, 0.3612923441372827, 0.6886023359929412, -0.9693524777736018, 0.304702690167437, -1.1660144413974514, -0.8249616411604217, 0.8945052164694315, 0.17544939809574825, -0.8272460898178078, 1.1407934664917578, -0.2000536217205298, 0.18640987180335764, 0.2679299333926803, 1.145665972340061, 0.9764033023740143, -1.0945467100291453, 0.521372365408202, -0.08805314721161141, -0.38934451999230035, 1.1416905493697052, 0.9003889322068577, -0.8129184705562436, 0.3440473274506305, -0.72472648064133, 0.05399471861877388, 0.5194134990647563, 0.6874785346278812, -0.8122596509146587, -0.650730661490093, -0.7272921738378133, 0.4576376839803699, 0.3904171653145497, -0.9810005319300584, -0.00285443936171912, -0.36535172159131735, 0.6144096327192144, -0.15837248303352225, -0.8994195620240998, -0.550954584675316, 0.6429230964102726, 0.8005796647490672, 0.06531222692534534, 0.34974094724817234, 1.176172791792436, -0.5252710369532949, 0.2649227929594751, 1.175606830532634, 0.9455873746485913, 1.0932290476666615, -0.5309007757921452, 0.2682629673178282, -1.019068207596018, 0.7873164405123094, 0.47109953022389206, 0.9043790189976995, -0.4554792669173991, -0.7129058230136001, 0.06376465587541758, 0.8334084349886761, 0.4891839072422823, -0.8195171322070331, 0.355909241507946, -0.45439362049140547, 0.7612376551762988, -0.05436372347589597, -0.8253395241105608, 0.5353956017148908, -1.1278223769955171, -0.2672704939182695, 0.08236845953569603, -0.3944515835531134, 1.0532839324087664, 0.2152014313163344, -0.32115401363252016, -0.4401831731301486, -0.8316311944948868, -0.8204912647642763, -0.20684288623086328, 0.656586992390969, 1.040632220799805, -0.5681960529259297, -0.8935973924071543, -0.5523442578187371, 1.019030749112957, -0.9889777010534911, -0.7813891126298407, -0.31025456229208886, 0.21737299067653276, 0.11975606760923985, 1.1489133897234511, -0.732747722798833, 0.46248225304712504, 0.8367764473513415, -1.1345064996816838, 0.8487271456519844, 0.47079084546084493, -0.3880313224602788, 0.5726640163660738, 0.3169122624606709, 0.3125375497368141, 1.0725665493127594, 0.04471119068333991, 1.1194888957575166, -0.694350406505744, -0.3409595779421505, 0.6171251620061712, 0.22135934758297232, 0.21247623650675107, 0.8669374876359844, -0.31535073366399385, 0.5538889770906046, 0.3757263311055013, -0.597927592864876, -0.6925085946018497, 0.34871269014582607, -0.7181727784647577, -0.9959175484190584, -0.3941241000777373, 0.5843467229636823, -0.1298465717484976, 1.1265371185410973, 0.10481709067861797, -0.6208804733701672, -0.23209634549660108, 0.09164363735575871, -0.5218291197106613, 0.13407195016157047, -1.0811880597442607, 0.6537001639909427, -0.9112100951312594, 1.1331704450421252, 0.09526547721035253, 1.0691734422557067, 0.28286325422558284, 0.2155840511857598, 0.34219576355889947, -0.06858382641835256, 0.6352320740995255, -0.8534759393001677, -0.30215311605080114, 0.4825461632485498, -0.7878025062942408, 1.1767649332440155, -0.36658719987216254, 0.614083134565041, 0.017395772324190255, -0.8141910253664506, -0.9789440851674488, -0.760947748240976, 0.10514245629454896, -0.012445121344935495, 0.8955364949519948, -0.9407396155918096, -0.5059512257000718, 1.0169038534816517, -0.5661662987702231, 1.0472948411801215, 0.9527469422382762, -1.0438693320196037, -1.0197514641091732, 0.5923565043667608, -1.1513518068819006, 1.1426265213356581, 0.7314115693481198, 0.035878365067006056, 1.1268253186061643, 1.1381898892090025, 0.050668047659784055, -0.3374091279069584, 0.7307081467526516, 0.026235117587053144, 0.5330659472771377, -0.03700545752962979, -0.23289865423067055, -0.03238468060810259, -0.8203158342693152, 0.5683798195792417, -1.1246799094062077, -0.758692396093738, 0.21847165129039725, 0.5696240201910205, -0.3529263485054064, 1.0260220368312303, 0.01224911889098179, -0.1809953840590205, 0.16439486454032642, -1.0079506314517355, -0.7339119466544526, -0.796638067199314, -1.0901440827406046, 0.6979503548178353, 0.7015791939518996, -0.07233693177751095, 0.5560875159234098, 1.1110141779625964, -0.15396573755282433, -1.1582494805739991, -0.12961450456604595, -0.651868837749322, -0.31774126871869124, -0.26337831137926265, 1.1722112677888488])\n\n # Experimenting with stability\n # runGait([0.29107088383373003, 156.78061666398597, 0.5353900646350714, -1.1333425119926464, 1.0829260730302332, -1.1640892198484636, -0.38152815636010307, -0.7197641554363123, -0.5865711046576539, -0.7927045883259933, 0.00438855244070635, -0.6432876760380152, 0.08594928155643794, 1.0817177784301633, -0.5378762158033574, 0.6930352009582383, 0.3152893767243987, -0.8955744085304733, -0.19691910222378564, -0.6131664945408353, 0.5512774089140886, 0.6670518195451283, -0.19309128337814246, -0.39607435850701944, 0.47480066743434857, -0.37028244976875146, -1.0989195356925148, 0.30442539638418725, -0.9337728215237907, 0.30406338012158807, 1.0455043322618425, -0.06789772225569224, 0.5806250136267157, -1.0375724064199314, -0.3543513598059251, 0.1989952263373842, 0.23561168218655393, 1.0508947475484427, -0.5301435173978837, 0.954111551885351, 0.17938815590296145, 0.12832022231695767, -0.1490689385957007, 1.0330605104523767, -1.0623171252199062, 0.8445117720781832, -0.36027189597546316, 0.5443268480270156, -0.1000204487317421, 0.8404845535139747, 0.7974970727477276, 0.7264552844874479, -0.7000730851293409, -0.759341129282885, 0.7648050158369193, -0.7522289855617343, -0.9984554385243157, 0.08999817877211987, 0.9363902863024169, 0.7202283975791759, -0.3961247258926616, -0.36531006526282306, 0.6003213302935796, 0.38400973936199784, 0.07770508777397611, -0.4360267539477962, -0.5751568134137885, 0.43883791069800354, -0.18052901071260805, -0.20490900220420233, 0.18186013658998493, 0.692889951182456, 1.1009750256518542, -0.5280637382212376, 0.9864059841841444, 0.735701606227071, 0.8506684523432434, 0.19014925787028816, 0.02734747647350761, -0.14246780172817314, -0.16363487369520202, -0.9807750892297045, -0.5974559893332009, 0.7052210645249009, -0.5722152424030353, 0.4150366036529538, 0.8451537180291235, 0.4434838540550997, -0.20824516651145206, 0.6091705295348645, -0.9590250992142602, 0.9808724317974076, 0.4183489440801338, 0.3607884449764098, 0.06383687946190619, 0.5937967791598316, 0.24274029229005406, 0.29029702682807396, -0.603878266910079, -0.08806950361411958, 0.7212683704190836, 0.6724813333613975, -0.18666038908670848, -1.103082059804687, 0.8768587952536211, 0.1404761787154466, -1.0478894200143816, -1.1437694960941056, -1.03754562219342, 0.9085399008442834, 1.1227743423279155, 0.498537990420221, -0.8371826748208432, -0.09808959558757369, -1.0626830441409378, 0.5380159945100353, 0.06381426021825665, -0.5683621599007505, -0.8656452557602182, -0.3593917993503882, -0.33715498495122065, -0.7801978053428386, 0.9153213044740255, -0.7555054418695308, 0.26788356436185146, -0.06902203453873508, 0.25274353461079657, -0.6944626972070734, -1.0430307172162676, 0.01812578724476625, 0.02313415896879832, -0.6806192043426953, 1.100081799618252, 0.827785090927609, 0.3269284020247252, 0.03206468028287163, 0.3034997439357618, -0.2990653227916562, 0.7397771966931967, -0.8780480762102226, -0.08487561447549834, -0.577616393319167, 1.0833921351724336, -0.45990422848121937, -0.6346960024499542, 0.7918294091829395, 0.027155163465394427, 0.19054579609590222, 0.21557173632598228, 0.2980525771157228, -0.7559737274895846, -0.97517502765191, 0.06865090400328322, -0.5031462207447848, 0.10497243089263641, -0.7965555365903747, -1.0373626266104656, -1.0533096615397561, 0.10728070263954059, 0.796368793127805, 0.0718344507091692, -0.9989396260631868, 0.6356575989158342, -0.6255437988888762, 0.9131334879875902, 0.45646847811471414, -1.0169463676260804, -0.3933819058755607, -0.5997997874897212, 0.17878990565350586, -1.1569178781134557, 0.10159645335836587, 0.7154971633906789, 0.17032819164387833, -0.01835367286864094, -0.9505402084183495, 0.9691636502442869, -1.0866819107494512, 0.19673356296061473, -1.0813009593788294, 0.6727946528411259, 1.177458334902635, 1.1463233157921833, 0.145360816245766, -0.7110332186361785, 1.1672615674161702, -0.3210995288856508, -0.3412206078486237, -1.1150104372864078, 0.41469339605306227, -0.2438596429359537, 0.539355647844741, 0.12085515871084321, -0.9647547341312186, 1.0521097335095957, 0.38872376706386774, 0.12699195498661892, -0.1666314031269644, -0.1452609089409052, -0.9161542968661167, -0.0576685820645067, -1.0362064288895902, -0.5438335521979928, 0.6421961281435908, -0.8782675763606693, -0.32039420495397747, 0.6517605169997935, -0.34461234725989986, 1.0265223840919862, -0.9642919006925839, 0.6343523074380544, 0.01045648767965579, 0.3839206068543592, 0.3625094480567086, 0.5988029218201046, -0.8066055092585431, 0.8291837194941895, 0.9966471145724585, -0.5512131701360924, 0.558229602974704, 0.6430208438139704, -0.36772966559972137, 0.9071931330847132, -0.30657207454292457, 0.18015360737564146, -1.1574946716164571, 0.6901959363107916, 0.786073839325254, 1.0524799852271292, -0.48261528673935933, 0.3021126071842598, 0.6780681739932523, 0.2650223276064161, -1.006069056570006, -0.37549673659808014, -0.8831740449899401, 0.6404770888288831, -0.29655423133316006, -0.30248718319006307, 0.2914366205771275, -0.26389183625692514, -1.0895101207281785, 1.0340066693226782, 0.9883010962564867, 0.13283052185185668, -1.0053930692545063, 0.9173399063162657, -1.1359574713434795, -0.9135848528331729, 0.05275828150306455, -0.8544265299335544, -0.6004625904664892, 0.7568333265679985, -0.11361613904339729, -1.0251203832530935, -1.1051123528377, 1.104096469074662, -0.4090842273664589, 0.23362094428508276, 1.122749227526524, 0.2089305257744809, -0.07565225626772398, -0.19006931939016714, 0.9450976678385695, -0.25602949043929973, 0.8979865614568747, -0.7508855781432413, -0.468020831328862])\n\n # NSGA\n # runGait([0.18229659766382353, 155.6458409097608, 0.9083504748793311, 0.14110476724188775, 1.093443926606583, 0.8999005754220708, 0.8149729234408216, -0.6359985441288066, 0.5861105866627622, 0.9646599108012346, 1.132867106787237, 0.7918013480335797, 1.146016728309355, 1.166593885399247, -1.0830432373628303, -0.9263478251771459, 1.0107748178924647, 0.4646106439794383, -1.169978052196896, 0.0749939582085001, 0.4339923743202392, 0.4579402086767843, 0.4206199667029586, 0.1397555030784438, 1.1401145649029063, 0.09302868565904275, 0.4914790880995965, -0.4651971857366567, 1.1659566230018072, 0.3706345064730484, 0.07552351079101301, -1.1232067067347673, 0.2222935344062407, 0.7748993910829708, 0.13034880610013827, -0.4806035746604289, 0.3172527997840071, 0.5068224937104546, -0.46511584843166, -0.3467931766616326, 0.3427084205149607, -0.32737952333572434, -0.90724945399064, -0.5250338620208708, 0.6880580209305295, -0.5448070713760786, -0.18858065144794406, 0.014731130802321182, 0.05906164696150665, 0.5284225601490862, 0.2234470472115875, -0.6232032858763568, -0.90751250478335, -0.9199446731694133, 0.24647114606718526, 1.1071349261385088, -0.22236693394071033, 0.49967256016722467, 0.8997056992139608, 0.2047903228421882, 0.9318238130993908, -1.1170109958568422, 0.3134441187993395, -0.7308917666312805, -1.069328123854823, -0.8079594196034741, -0.8413209463842631, 1.1062445646940164, -0.03586696528282618, 0.9654148851126274, -0.9432680014273601, 0.5234582594311347, -0.7471694311620266, -1.022219081571329, -1.0800214764917782, 0.7474112702428726, 0.20819166616338916, 0.7215699077419591, 0.38031567283758844, -0.5238628816347054, 1.0770153104321716, -0.6397760818081154, -0.22435045232641265, 1.0706893179893495, -0.5518655141151997, -0.19087636009819303, -0.3512479711738529, -0.6606861068197772, -0.8685585946822181, 0.3604633384909186, 1.0275382741711763, 0.06655444813978417, 0.9935834582186229, 0.7279386983043616, -1.0070347596788973, -0.2442584535361799, -0.3012388201961493, 0.7247939705316814, 0.6269234457029824, -0.009873626827067952, 0.482981540629763, 0.8598378851596727, 0.4741322053329257, 0.675550009524477, 0.346302537230719, -1.1243070756199751, 0.22681429162070263, -0.3097657746518692, 0.6778382742087453, 0.814184670743237, -1.010608111150304, -0.27376846268023297, -0.9948460491716468, 0.5069784751074181, -1.119671608976601, -0.9303075410380663, 0.7246078940736616, -0.6722076482955358, 0.37757103600219066, -0.313874069830721, -0.43472066633036216, -1.1278978108552458, -0.9970308936270744, -0.5565800651858721, -0.9069457748848149, 0.8230975287693061, -0.41294547922588815, 1.1712915826924468, 0.5098575610704372, -0.9343470208547747, -0.7502818925909562, 0.8572882565769667, 1.1527965107091545, -0.5985576253107086, 0.9812633011454751, 0.43198678500041227, 0.5217073857233142, 0.9761183062018322, 0.14128704712955387, -0.2776161554656262, 0.7504777433267875, 1.0294036660645036, 0.09622107476155035, 1.084571969315032, 0.5909472984707462, 0.21678827645458928, -0.20873040261437428, -0.8425470304835826, -0.5794336238166817, -0.7224193962610191, 0.7320581158158446, -0.3615401506592452, 1.1405747073218429, -0.3039589800092729, 0.2894225332294616, 0.26050649010553945, 0.681767611672782, -0.5129831573243372, -0.19268708535592294, 0.2842271081958875, -0.4316514377659478, 0.1747797126503924, 0.16177042672268072, -0.9595387421298439, -0.8913796116466794, -0.2835623569393363, -0.9021243233987757, 0.04675926339236765, 0.5877718252549794, -0.020728046886497195, 0.1960504582672131, 0.828348254755653, -0.3256674408706686, 0.6430416383221862, -0.20525504926868066, -0.8518231015695202, -1.0599288641751397, 0.6287112429011469, 0.12367108041799399, -1.0720406710260566, -0.22472210546705562, 0.8706060321838783, 0.5291724611088444, 0.10250068539672591, 0.7278411385365671, -1.1566550009574674, -0.48415340513814353, -0.14201813891013926, -0.42454015353898894, -0.5588938960807662, -0.3294006824868001, -0.804967243168935, 0.8162080012175026, 0.18496746845666612, 0.3891323361310516, -0.7744570170530798, 0.11870436656346904, 0.9500286012565656, 1.091687566807378, 0.3307255383169255, 0.7118468053052446, -0.9013453096963969, 0.1945196784104959, -0.7862302171325798, 1.0371600096585611, 0.8279744386055418, 0.5349665267082687, -1.0492245155619515, 0.24063714267361025, -0.5253103025206994, -0.6958371376482045, 0.5127663834795291, -0.5668633184192481, 0.028756495211944066, -0.8180067305130339, -0.7325151144334637, 1.0874568313948747, -0.6204051504490435, 0.16734526054734847, 0.9079945409597623, -0.1605782825625574, -0.9493435726574494, 0.9729771352267385, -1.041240909006733, 0.8207784518169133, 0.2019719768666147, -1.1386639991254925, -0.6372470497638072, -0.5284328510489867, -1.1424013728720803, 0.31553420746729177, 1.0380382961752586, -1.1411444021812454, 0.09246165325365872, 0.1706564355825929, -0.6346966931891327, -1.0909483051470628, -0.06566436851792082, -0.2776209741481568, 0.41899201957450416, -0.18759177838803043, 1.1555756485784177, -0.5822077172996798, -0.9193289683677482, -1.0371716158033841, 1.1423430653663564, 0.8779681991740422, 0.7805125432142439, -0.7721653288915576, 0.5155584453512811, 0.14486889941392897, 0.8446819611612648, 0.05327295198343703, -0.33865091333049985, -0.14899995870829524, 0.1953458127677415, 0.8939023739574229, 0.07623855879466708, 0.6130493982347537, 1.0918462763933745, -0.8759140979104185, -0.9919552795899489, 0.531399920610189, 1.035948455011811, -0.6346835942687693, -0.9522149883706655, 0.12740143026457326, 0.9609495300188751])\n\n # 3000 Pop\n # runGait([0.904983046733017, 159.59983729578843, 0.060696523522925525, -0.30971496430036916, 0.7353270535594881, -0.6505978383780697, 1.1023304598221446, -0.30768612827725195, -1.0234200031222016, 0.0034031598955847732, 0.21330511114420406, 0.9254559265553964, -0.6604354617020531, 0.15158813875789579, -0.7854467191411058, -0.9925929220629403, -0.2080119772713885, 0.9748408255452494, 0.32631902985278716, -1.1409334395171054, 1.0693652898105703, 0.12206649342856929, -0.2847542804409562, 0.4801514292150744, 1.0332765953216592, -0.7938197444031939, 0.2563131442452105, -0.14869709222993316, -0.9347675501625538, -0.524006106702254, -0.11909684998489307, 0.8400278760972555, -0.23718061034206372, -0.337660742691555, -1.1686283476437243, -1.1031105878405127, -0.7646199378803564, 0.6354804367029614, 0.8837680367321205, 0.15899423130435295, 0.6712575159053917, 0.4215958247199955, -0.3373087437071557, -0.9305356508955385, 0.9082056114784287, -0.9284716662471378, -0.04940610858174345, -0.06555931514262112, -0.09399768472542123, 1.1247909715839755, -0.48379285974626773, 0.570525480919135, -0.02569623444311407, 0.10714561439371209, -0.10783544772282928, 0.7051584770708194, -1.0406922832593428, 0.06343296206551907, -0.8505979742277806, 0.10694125521184705, 0.16935548980784373, 1.1420837333010894, 0.24204597235287523, 0.6475736003934104, 0.17055212844135192, 0.49474061804168407, -1.1398076486306385, -0.03973245191392927, -0.939386769890378, -0.402476064224687, 0.025119711897026987, -1.05440268787099, -0.2752953135618634, 1.1685995968528273, 1.1257083961904089, 0.29732029639677987, -0.17567621997968294, 0.9564892264662193, 0.751911791222228, 0.18761642526516176, -0.3232472318368491, 0.7932493092806446, -1.1052582188288498, 0.5487840041424124, -0.70316267873878, 0.5857454028700838, -0.30104018247011155, 0.3990877589811526, -0.27622278756255064, 0.5007368227279884, -0.34255158345432923, 0.7860783873697565, 0.3299290546401101, 0.4212830410670498, -0.5000823971778967, 0.20211647698962795, -0.5954542100162727, 0.7891262765370252, 0.8398523515973949, 0.04208448038937486, -0.24762466260929505, -0.18298569176248317, -0.36744847594043806, 0.11711890578959555, 0.6784909064918407, 0.043547048965568554, 0.915347385672616, 0.1943537417670627, 0.1961032921533715, 0.27380381570388196, -0.6925505753816085, 0.13409295730737364, 0.9238606281112889, 0.7232290263266692, -0.08475645900857555, 1.0918689969424247, 0.11494102395735217, 0.13564497247063464, 0.07791390649505298, 0.09101847685593711, 1.0802565634925867, 0.008017176336832414, -0.40863001168996127, -0.4349722126523693, 0.34453158076792034, -0.6910315034834699, -0.8948888951214328, 0.36598368092354766, -0.43159001817612835, -0.09136672190834433, -0.8265804981583658, -0.41569623861994176, 0.7235977966485335, -0.2699267245166663, 1.0160916486038205, 0.05956580763846824, -0.553446262414352, -0.9234155272540824, -0.5105546990572772, -0.634441156000243, -0.40216456144001933, -0.659878523232472, 0.016898776661833703, 0.04370343683036865, -1.0525099132085054, -0.1360717628812732, 0.5358560458811824, 0.052683861773873776, -0.953171635298017, -0.15148360309076792, 0.8695124128462544, -0.33150174271113014, 1.1018672681161934, 0.8122315339180584, 0.05632606046036302, 0.4062446410358813, 0.9032403720408388, -0.4898652953167396, 0.5547542361296853, 0.34407051580411596, -0.9688368827468914, 0.9051281478921898, -0.382672404368127, -1.0351659289591528, -0.28339507478975706, 0.2604244554458595, 1.141276061674245, 0.9511590958810777, 0.030865821870599747, 0.25589416378172836, -0.899230741333316, -0.6890771547052199, -0.36098686027424987, 0.2046761115043388, -0.003370011028005335, -1.0326969178585779, -0.6399760361033779, 0.2945889455809976, -0.5693772211328435, 0.5190623470719792, 0.9594447543339326, 0.6647471001461713, 0.1765304159915148, 0.43139180526620574, -0.7827997940081548, -0.3212428257056203, 1.08691662804371, 0.5724684958868459, -0.8190711895017851, -0.21893910988788873, 0.43754121343708036, 0.7761978329434286, 0.023307117981586058, -0.8196812812240051, 0.18349841454177002, -0.03275888140948699, -0.9354688626764325, -0.29752922729690606, 0.1038144707355869, 1.157887360987824, -0.012635618639992992, 1.1772296247879417, 1.0476346313277654, 0.10969465515895042, 0.9315375765707544, 0.4127446193866228, 1.027376379551766, -0.21108693714197815, -0.6492523615384952, -0.1992276005394296, 0.9471808298697213, 0.003879051139011558, -1.007300896674733, -0.8988174362275243, 0.4571936981359096, -0.3114735176334528, -1.0288979365415865, 0.21589235355521563, 1.1668173760981395, -1.0513185987779647, 0.12533634979511898, 1.0255130494459233, 0.748872451843244, 0.09667778038896534, -0.984941038411984, -0.07093582524591927, 0.5164103929817825, -0.27201410547664984, -0.3729048874293173, -1.1149579500690774, 0.8813975424355013, 0.621449531061543, -0.6997908270429463, 0.5020729261400154, 1.0064048881599486, -0.7789049856237727, 0.1128585572848923, -0.19354726814305145, -0.464830471290481, 1.093822978982704, -0.7444302566691616, 0.5228503281130006, 1.0127816296546253, -1.1495705447930669, 1.1634921469729014, 1.017059004992762, 0.6538475673570939, 0.2985847382952567, 0.44100054350476847, 0.20413700406627103, -0.7151778221967301, 0.40107695707208585, -0.7845232708359956, 1.126462565607725, -0.7541211894437213, 0.28493713718804164, -0.5111505775098296, 0.053487615522491705, -0.5972630106930484, 0.867696699744679, -0.591697544975821, 0.393417762872977, -0.36433296593800835, -0.8484271043364143, -0.7889442880625308, 0.5526505308931524, 0.36476343329950656, -0.010331075612058583])\n\n # 407 Gen\n # runGait([0.8781196143633982, 157.10313398974353, 0.33682254295973746, 0.28781781595826333, 0.1860859338114289, -0.20420881621380305, -0.12123927275926893, 0.4063033014361015, -0.20359193737052045, -0.6840192443790235, -0.28254702343692906, 0.5940254747152814, -0.29777220678601746, -0.07426962639294979, 0.9652159747014115, 0.2473752294851017, -0.6107793773528992, -0.13244976914336656, 0.5280864171637462, -0.059421386701237325, -0.07844527791237588, 0.6322545653056038, 0.4724601535718872, -0.3287282121853098, 0.5434097111921933, -0.12151448936067652, -0.06979580112172787, -0.2961931277705389, -0.4805882127012387, 0.3364130911622725, 1.0005701725869078, -0.21847954935067443, 0.1323700155317861, -0.32215689673367087, 0.14430331665049628, 0.09917150470049849, -0.5170401624287033, 0.5409236317536736, -1.02363228425136, -0.5320260643642395, 0.9218582075166826, 0.2807391864517396, -0.5941315102406781, -0.7080454310389085, -0.31585622472883196, -0.009146624918177084, -0.2012219697627285, -0.4409244609725404, 0.8768753147403492, 0.9343776617888977, -0.02141775939762952, -0.26104580922522647, -0.24705414040844845, 0.34300112955081297, -0.3356925840764099, -0.6775278951424454, 0.632154513923834, -0.5828623947214877, -0.5182796152392433, 0.606350185900368, 0.3246392910354486, 0.8302757207728939, -0.0023731755697271803, -0.16107561586683852, -0.5441686853739696, -0.8288171478401807, -0.397679027844255, 1.0145087733378917, 0.5771456856002078, 0.1928252929176832, 0.2801312178087099, -0.424024932102493, 0.028490342932658078, 0.5663828653801755, -0.2578226202044432, 0.4758103361385356, 0.11262059630304765, 0.17852984636877395, 0.7819886760768826, 0.4777904992793935, 1.1215684250587168, 0.7012165047082592, 0.08680724775780826, -0.12794232943092734, -0.02749916734935132, -0.45447494760953283, 0.39467736190532837, 0.556999354112899, -0.47790256532634695, 0.15041111386454983, 1.0555134056088191, 0.1949848324658606, -0.1334691560253397, 0.8282086290450636, 0.41689095269036547, 0.3213829957559171, -0.45920978149223457, 0.6474648195495811, 0.6759097856561475, -1.0097973227736488, 0.5730950969137286, -0.4092749722577607, -0.039674737074665734, 0.18021687378702161, -0.6615793121935327, 0.03142374866540614, -0.7336966171880697, -0.3283666283009425, -0.7807776498788782, 0.04535750599480415, 0.1704720716786568, 0.07139750224822779, -0.39506187566783524, 0.5372040246741976, -1.1473534956177283, -0.4013147582043887, 0.38703856371800294, 0.3971836501834768, 1.1715304273819858, 0.5442662829228595, -0.0980978149061639, -0.4344320237816741, 0.7384324675711982, -0.6187275059274405, -0.3575034072195102, -1.1288861687148302, -0.3261414464285166, 0.7523726891212104, -0.15988727327072425, 0.1131072052563967, 0.34829181401975273, -0.6281159632389499, 0.7689620896680501, -0.12006262327557764, 0.9842080944836419, 0.26578776890675115, 0.5127275308397158, 0.6177831879058816, 0.6136850718675044, -0.7101342612681036, 0.22667486103048795, -0.6637649111191182, -0.49116115181432607, 1.1778110294059096, 0.6536538976088225, 0.337894833822659, -0.8418763216442848, -0.11767229020786187, 0.3713509801518212, -1.062628223739996, -0.6364809135462092, 0.25314885600822956, -0.4532780204714063, -0.9156058815025188, 0.38398735762219094, 0.6504528410510488, -0.8483565675469873, -0.19248354081194868, -0.10272402672891327, -0.21538792572640295, -0.19546972821258218, -0.9483484869960997, 0.022956480787546467, 0.10722697400615173, -0.5339228101100632, -0.35402855681089174, -0.4909015301740968, -0.18175978846992896, 0.6859271886866835, -0.5159021239613567, -0.4536971124614899, 0.33596686235547757, -0.8380097153759376, 0.2564768448158085, -0.17784663515089585, 0.8848479741072743, 0.45734330263531453, -0.09873367668089586, -0.7500713258217162, -0.25406396619910043, -0.9054849581453508, -0.41576987655001807, 0.39503507766193025, -0.5857624014296016, 0.4560242643397691, 0.23900721343893294, 0.4454950080559121, -0.008251391139937114, -0.5778461849029692, 0.49439432908178516, -0.08522125551940313, 0.9544048902657116, 0.26600604145504003, 0.3367464085720411, 1.0096321755173974, 0.5254892106771129, -0.09967034763491985, -0.21229560617239768, 0.5697413449479685, -0.33752083603028504, 0.1099730086514387, 0.6135896282792587, -0.2316015516647347, 0.27698810246217326, -0.41050437696734554, 0.27114015297957794, 0.5172821702323088, -0.8557836333808082, 0.1431613671576169, 0.26614523302465865, -0.9784779658422884, 0.22069893362397217, 0.4698093606975688, -0.3444787910995501, 0.3215750648265838, -0.1275396420123813, -0.16744367567541496, -0.2865130786194499, -0.203914306582315, 0.09531066543160083, -1.0473530567418816, -0.43792746630963003, -0.8246099035388195, -0.1995013012675149, -0.05971337685132197, 0.07864737594828375, -0.7640329802075775, 0.7133374177394672, 0.3450741117987123, -0.6613122911561858, 0.2175616273524131, 0.39585440284780726, -0.6045817099745175, -1.1406619528893633, 0.06642553919379446, 0.17478825655989105, -0.48174098942017146, -0.5192782669857927, -1.1714093392113059, 0.5938325737824399, -0.482930381615228, 1.078819781022143, -0.8684695968207783, -0.15775647868438034, -0.19836857010162148, 0.12721713278404426, 0.20363848723966207, 0.11179394420943511, 0.49603448462048155, 0.3600952668625213, 0.3128222724984558, 0.404650588027724, 0.0840823881356966, 0.19944902798724976, 0.12426183303095407, -0.6113147369273974, -0.40558552009503623, 0.4393747149838387, 1.0064976254947864, 0.02535220524117529, 0.6867814865985039, -0.4423754966018487, 0.20201446246914118, -0.697738158333364, -0.9883884469952561, 0.4564284783687155, -0.9310257794603739, -0.7670742706760328])\n\n # 6000 Pop\n # runGait([0.5833710183294218, 159.94477382941363, 0.274991231117698, 0.238089263008252, -0.1417409643619611, -0.12761521449834923, -0.19289461538039873, -0.10856112933014755, 0.15968577636162862, -0.17368631551323016, 0.07203736702130702, 0.881941236232128, -0.49131125475461257, 0.41963359660824545, 1.0286266905353563, 0.08461166310190373, -0.0930092118460774, 0.6688730971003121, -0.5272671341802382, 0.3759165556754689, 1.0284225286200426, 0.281022494747565, 0.0009195019049819536, -0.0879260351696233, 0.36182544936252586, 0.1544240116221797, -0.3379165966729512, -0.07107860607401342, -0.35347372811378175, 0.24474628711192828, -0.9554210776881508, -0.2446425071911576, -0.21834542364787896, 0.02941224160898587, 0.19860309964710376, 0.32015885118565973, -0.38463037767537034, 0.2721652517032083, 0.4498871803091191, 0.2843738257583236, 0.501327523282536, 0.669013035550511, -0.37715689084783993, -0.7193636388118547, -0.2383013342521316, -0.17489396233602697, 0.06083890600102712, -0.4034525364101677, -0.24583511137643727, 0.05016350547975096, -0.5231072760701854, 0.0920601174252217, -0.3798879187489547, -0.06425162833626528, 0.1175629295006112, 0.02682125752619795, 0.5075090858782456, -0.16206766607753353, -0.9027943006438802, 0.5191380547248162, 0.1922772367714138, 0.3722573359482723, 0.27824784135917774, -0.36599087581441164, -0.06620007679763394, -0.37707864764924415, -0.3432745401212583, 0.1890972969239655, 0.9771314779636118, -0.6379190437437263, 0.5327515128308239, 1.1266802573644779, 0.4853618562003829, 0.03715655903182573, 0.07311510274068314, 0.5423300464375319, -0.0658356136420452, 0.6733211262326829, 0.5412515512543659, 0.475841545559648, -0.5369352656406974, -0.026774867624149132, -0.27366768812094183, -0.21535394823513682, 1.1272641607914005, -0.6324828192170618, 0.22992240750612652, -0.8332942275738103, -0.4448812583609043, -0.5639998583724821, -0.28504303170819406, -0.13715306369785674, 0.3349484025718961, -0.3700368781101578, 0.20300787227134326, 0.22374862961672667, 0.027970795265832554, 0.7014861172229404, -0.04926493320095343, 0.4402290874741377, 0.3860194514832391, 0.11569030596073443, -0.06036997313965854, 0.1497256975919505, -0.377481545800565, 0.08298090520892161, 0.9438244188255105, -0.48021805376469584, 0.4543715274216308, 0.8678356926851799, -0.003915278924756722, 0.10352872557178089, 0.3358865719916397, 0.4211155579389066, -0.030249314775129762, -0.5658285551195321, 0.2548939424634452, 0.5745275199121783, -0.7796534931283465, 0.3451123282022226, -0.5444761756627212, 0.12200790829540269, -0.25898916669720645, -0.6724214809633824, 0.34635133694786935, -1.0685493620290625, -0.166454962800517, -0.8051985252291386, -0.4306033386198576, 0.3621432335285329, 0.014468787338504891, 0.141080510173102, 0.13964744684544284, -0.15421615523049945, -0.4317859615807832, 0.225587551388641, 0.693207792900198, 0.5533948757767216, 0.20097437713556277, 0.23256665133179352, -0.4990635733731684, 0.37724815041759296, -0.8484710927328951, 0.052329062943848995, -0.6454186305205749, 0.01709338435440333, 0.1426615820133712, -0.7496362823830726, -0.024592492969917387, 0.07160640453502068, -0.2474844962946594, 0.5941575845367926, -0.20960304431184107, 0.6424578239764861, 0.2920273219156567, 0.7036560308915455, -0.8121144845665177, -0.2789410770162129, -0.7413476580353197, 0.08188596178827257, 0.07931227840034549, -0.7207975890283618, -0.6065813517836143, 0.3983191376566657, -0.5635381703226274, 0.4088177741187736, 0.8161358908559947, 0.6554301845419963, 0.04547395492205422, 0.08051995385752733, 0.7945827746307063, 0.11087351442670304, -0.590752837198396, 0.2065658076101474, 0.0751712923684167, 0.6709125887262557, 0.1373187383960103, -0.18183312802940133, -0.4350057499267376, -0.3766430661862623, -0.8199596582372628, -0.14153603961297806, 0.590381220135425, -0.16508543450631305, -0.20708569485397604, -0.34591459093209215, -0.16651848898298874, 0.5178287410957361, -0.03657852374819068, 0.7219509009910949, -0.22937310869060928, 1.1464596068133195, 0.21233031874020497, -0.3609307120798186, -0.41136793770748015, 0.16347336752562386, -0.04569336581669571, -0.12320285070861678, 0.08240315222323638, 0.4579164525630148, 0.10194743670878537, 0.5748048740706077, -0.38484763478500494, 0.8009525610955103, 0.7333605699869847, 0.37124845323434263, -0.03501117975518403, 0.012948485735009754, 0.29139932552493186, 0.34343670572619495, 0.8542624160112243, 0.2047939987143607, 0.3903803959743837, -0.20493239305818473, -1.1287011492813999, -0.32936672671984124, -0.36581898984821176, 0.2451494881151558, -0.5756460181132672, -0.030221322542399086, 0.16449751038968874, -0.3567999251278406, -0.1618212236300447, -0.11207687799559582, 0.05735981109003743, 0.9415542138674963, -0.3554473551841668, 0.5357750527639715, 0.21498207309781378, 0.4532008047694893, 0.21329882952215284, 0.5859846457864504, -0.16362093353740018, 0.1319546289160159, -0.2194715016448026, -0.266878066809855, 0.19007538470038587, -0.6214579041470789, 0.07758190484905561, -0.7515667963793465, 0.24700843522334995, -0.292447662725082, -0.4181253106644778, 0.19564903243421003, 0.19724000917384554, -0.2063833311816462, 0.46455125472211967, -0.0899164519697946, -0.4859666940225116, 0.2204956850628324, 0.5537344147667811, 0.3710020504693896, 0.42084808456566025, 0.22826893049722402, -0.3009973798887208, 0.3133299056345898, -0.5362470634819437, -0.07363025268708201, -0.4903844709824772, -0.4212031706808154, 0.593200663984306, 0.03428638943992187, 0.24491294188014479, 0.46221509482741235, -0.20849095803967968, 0.6337473393725238, -0.05747450930384633, 0.8875435750416844])\n\n # 0\n runGait([0.7387319894185713, 147.82355001579506, 0.6305372633499426, -0.6089588304954848, 0.8912756231059142, 0.2812261582743101, -0.5713260153151064, -0.17272091345083518, -0.011128621604706623, -0.802059235021269, -0.07153954960452258, -0.5428904527014263, -0.04381109750503209, 0.09113787494874881, 0.7723570365515549, 0.1241992107232388, 0.8337401506855846, 1.115458030805498, -0.013540807256189336, -0.5839520097163835, -0.7340746975491128, 0.5868023045338302, -0.9298983610216932, 0.5438917235683132, -0.05782837894738324, 0.4198029392031244, -1.0399101725816757, -0.06612708025138092, -0.5082125750188753, 0.9201548240864632, 0.06444257109533891, 0.3314957278066273, 0.43523252410016, 0.0101257284239189, -0.3455692282668785, -0.11991854934521307, 0.8938694635098376, -0.5612059600360004, -1.1311528570896223, -0.5932545380125831, 0.4344991139274895, 0.3428898066225319, -0.2906991777632436, 0.48606253534779564, 0.5357348004370723, 0.08998319318443504, -0.9267085738943713, -0.8937243514792317, 1.0577416788427096, -0.37068573549717954, 0.9165099103165408, -0.8428317356586791, 0.6907079780081538, -0.763945038433602, 1.0409972769402867, -0.7930695812727582, -0.45187653759465174, -0.5161324587418127, -0.7914439627122227, 0.833033591113862, 1.0408039580092332, -0.05381107166535859, 0.8438281153722502, -0.0387362598590002, 0.6164861225837377, -0.6286851880995831, 0.8640915900752995, -0.7744000726632477, -1.1733643185821832, -0.09815300085455836, -0.2477118609768313, 1.024101066375414, -1.147511226358933, 0.35649235792115364, 1.1024258715004915, -1.011618835769622, 0.5915335712528709, -0.030590833481361157, 0.21394935583673327, 0.2677965469007608, 0.5549362872301691, 0.2695802858891776, -0.8655473520001171, -0.13250526441705102, 0.17727687014444649, -1.070467039423309, 0.09651563983885625, -0.9558246154936185, 1.1511036912990131, 0.8111082334542412, -0.3165391333624401, -1.1028022950228613, -0.8702156791239426, -1.1681706777717666, -0.652290858655339, 1.003148181057313, -0.10090114268197192, 0.23187888015208769, 0.5941647728264801, -0.43999609085011204, -0.11509272070881571, -1.0798002236171276, 0.018290046530861526, -0.7279320899826196, -0.498825849932375, 0.5922026329566983, 1.1770495895717317, 1.1658461699766112, 0.5387616073370702, 0.6762210875494419, 0.564309749770725, -0.3035549596906124, -0.23885528257994526, 1.1072615720375825, 0.5666318535111361, -0.45569851974439834, 0.8338190610059566, -0.6359449813770147, 0.2596402577409722, -0.7767216770530929, -0.90418267806025, 0.113288160612949, 0.39315211887973467, 0.15879221931780196, 0.758361875600458, 0.8700712002631037, 0.306520197643136, 0.7532325435435356, -1.0353300637178853, -0.4455790005356547, 0.33046558165864237, -0.41986999994668306, 0.773773975624336, -0.5730775662391308, -0.32242207870145256, 0.5695427482221903, 0.06540060708986029, -1.1068765041634638, 0.8444999211248407, 0.04543079459398691, 0.4642442589105744, -0.6039790052127436, -0.892455957263908, 1.1129699696404938, 0.342772182719143, -1.115584864083039, 1.0625540212723195, -0.057194100238716405, -0.5879196602166177, 0.5790752639491412, 0.6440806383356259, -0.7481329504140624, 0.20534187872140564, -1.0990982256561714, 0.2791331755311888, 0.20300461353714883, -0.8197464538582441, -0.7741517445104196, 0.36122048253607164, 0.813782786457911, 0.39582928554897623, -0.02580819987456784, -1.1628778529586477, 1.0745713708553488, -0.5089798478319643, 1.0062303026439694, 0.6478357664888437, -1.1138156319365986, -0.4955658167644643, 0.01673202498902171, 0.9162968925255734, 1.1449260986124963, 0.45197676369281314, 0.4913407885919339, 0.9059066063082057, -0.6513168739283108, 0.08060475225758434, -0.8062943072398908, -0.5854814411007928, 0.8888342908698426, -0.9445568643031321, -0.7753945536759548, -0.3003503278781188, 0.6951193721206237, 1.0356586073990068, 0.8830749880175515, -1.0664223102877843, -0.609899276809712, 0.8167470737757756, 1.038925181199521, -0.5200440777902839, 0.4128415160980885, 0.8988517426568858, 0.23012308000225246, -0.981407304217973, -0.6000864286294282, -0.8302474366129275, 0.3022460425741058, -0.7232702813935017, 0.3225916050209834, 0.1690591643089261, -0.731263207027456, 1.0793778048303206, 0.6724712011076479, -0.7393802772190122, 0.52180702196962, 0.653704773120031, -0.8435500860065721, -0.503370357216786, 1.0089409411880252, 0.8239113158523748, 0.5789158304017497, 0.8017043064577623, -0.81666613981439, 0.4674783795387365, -0.44533480654686275, -0.4893466194479631, 0.9007928200059672, 0.02483073138245584, -0.5944238649035959, 0.28518215854040774, -0.24733421237552355, -0.8505607276413669, 0.5571358775523416, 0.9045395124615454, -0.6657820640979742, -0.9652597006250097, -0.4591179819423816, 0.05481742210849316, 0.28907992231884405, 0.7124381991670108, -0.6030190226588272, 0.3369808339189879, 0.3038297672106993, -0.995236450812498, 1.0777162746217996, -1.1439340008569936, -0.7047632734591232, -0.532467147310556, -0.7640334064115123, 0.9758524528369246, -0.24433882388927364, -1.019693761734842, -0.11397606855688958, -0.26140300759258983, -0.5755519362573679, 0.15416561480192903, 0.8157008073605059, -0.988078686018823, 0.7532529999268318, 0.31269649944522704, -0.34261705061474756, -0.8905985767822926, 0.6096508828791698, -1.0668100653950248, -0.379130418894862, 0.9096912331462104, -1.001701666565123, 0.6416783457901682, 0.14610426544728483, 0.7031005674547539, 0.4247842879063306, 0.4021107592425244, 0.8928714878416208, -1.089585355806771, 0.5386513324462168, 1.043195877742578, -0.9701398946532979])\n # 50\n runGait([0.6109376305551025, 147.5781875317787, 0.8620634914832349, -0.5626015076241742, 0.9150007577136691, -0.20417512686545095, 0.6544359094278946, -0.31327506130394855, 0.8452968857390276, 0.13887431059938735, 1.1771529929786608, -0.9178071433237085, 0.21286308614656976, -0.6984312985937364, 0.8250658263071654, 0.38678895878185166, -0.8386364979015601, -0.8324431895189177, -0.31964574670169177, -0.9513705765809792, 0.7833723510749697, 0.9633303649676936, -1.077086285278876, -0.5823511574760045, -0.24329005344133708, 0.36075110180937114, -0.8737875239530779, -0.7120336903431772, 0.9694421297627523, -0.681817972163381, -0.7263666665964092, 0.04202279641735396, 0.5376884588766628, 0.5528900104757648, -0.3762309750477318, -0.5347146669245599, 0.30309856425260817, 0.02701219403931735, -1.1761371301420371, -0.3097959495083542, 0.637250448114133, 0.45383108548435047, -1.0293681131385823, -0.34337946728402396, -0.20240409776563223, -0.30376152527443845, 0.18856656091055635, 0.13958997918335925, 0.14259244107987795, -0.3669671234254508, -0.1371355859726133, -0.3999333309862724, 0.08190816860672162, 0.9531999241577855, 0.4305115008592596, -0.15969404241405846, -0.10706207687230784, -0.5875234717318174, -0.8888652093021814, 0.7018823816096099, 0.0097155460541066, -0.31852823774787353, -0.7161533552571332, -0.6946183251839217, -0.44771872458142625, -0.8020418614747353, 0.08697562850763507, -0.33670122865676794, -0.016255823485752413, -0.44553776220063407, 0.7067040729755709, -0.3305529141109416, -0.12353152419246438, -0.06405724257227025, -0.4289379681288039, 1.0169932699634694, 0.9219679687362414, -0.07926430997569933, 0.8461155106368546, -0.5108459915920485, 0.01721461698106075, 0.25640166227431, -0.0012638280470829346, -0.32081211955480904, 0.965518227098844, 0.07977377006028907, 0.9914084076788008, 0.9368602392194756, 0.79622005627768, -0.12120211619815363, -0.07642712418177038, 0.15250148243132808, 0.8820133072304428, -0.15324005900457768, -0.012947970781577268, 0.5314107654179234, 0.2657806659207431, 0.21867155408318162, -0.5645131510256867, -0.16370059560939496, 0.2210581088064703, 0.39055811273202895, 0.2826802498295499, -0.4229943862011821, -0.835900738908754, 0.9612898958738532, 0.9962752356339487, -0.053303884261599155, 0.30951330649963815, 0.34386442126447203, 0.3167278260159818, 1.0850909905354877, 1.0088643013546652, 0.6148040192088533, -0.32713499022688375, 0.13265347253599408, 0.729050651796031, 0.4385817170037452, -0.8104814221892234, -0.08204642341024995, -0.429968478624448, -1.1469995240847928, 0.05053455747353239, -0.6868806082011671, -0.7681702363623998, -0.6240472813916106, 0.8999904570363008, -0.5540755976757679, -0.1395815200095187, 0.7216419755694113, 0.00341887019974102, -1.1314219417339941, 0.47079825372218626, 0.38634641962439187, -0.4969326894940178, 0.9700897618329442, 0.31738524085942643, 0.5918654468120178, 0.0649345288163781, 0.9223422749742548, -1.062672657821793, 0.30896020749191433, -0.28885102187939604, 0.5103642056497637, 1.1586385214620625, 0.47011741255653366, 0.7362591411689603, 0.695808261288789, -0.6331424834334121, -0.6156728717869878, -0.6958300056305404, -1.1223768304439534, -1.1079218078030504, 0.4832955305303133, 0.7872713684414188, 0.23742695514821588, -1.0325192716558655, -0.5035525254625557, -0.11125895540865731, -0.06707968995471164, -1.0901891398628312, -0.05185746626132734, 0.17939884745186596, -0.7629342237736646, -0.25568469662030346, -0.3436266275846107, 0.5234963038843524, 0.532265503526556, -0.6045831852953002, 0.9974128911214244, -0.17925607028201557, 0.5791020459001643, 0.6873833790287516, 0.21880371572846155, 0.11009481032702205, 0.12865186069194162, -0.3268975846759916, 0.02259596959226029, 0.5559932137864555, 0.5932843214246097, -0.3710969455539212, 0.14529725265287333, 0.7044006452814845, -0.008852974292849092, -0.6124416737681215, 0.9682131380447476, 1.1375649719691259, 0.37091879445775916, 0.9352732490378375, 0.1539095660283667, 0.777440000897248, 0.22606717389632985, 0.6069013838761509, 0.30093397706517244, 1.1442039256026204, -0.7161426712243226, 0.588887225888025, 0.6972839960175987, -0.3500160949784321, 0.5128375679350539, 0.7935689766031192, -0.19559794779993978, -0.6253604887410248, 1.0145936629813255, -0.6706586307879839, 0.003436295592896238, -0.417246076528322, 0.8556308147276876, -0.209938526431461, -1.049104873280623, -0.33207489467651996, 0.6814354585137341, 0.3417057443470919, -0.059172559496654564, -0.8715300782572717, -0.2556518530893984, -1.0671471245233821, 0.3614377209651649, -0.15680078741943126, 1.166195067305183, 0.32081449773971193, 0.18756280575004247, -0.19985672490920128, 0.7805915689741869, -1.0536988894142132, 1.0857317947415768, -0.48900363536886143, -0.425774798688516, 0.17741903723193003, -0.1303947078559029, 0.9502549942826287, 0.5361055442035286, 0.7290061426453971, 0.29795698418990374, 0.26959259813541037, -0.8620031075888178, -1.0011321698786917, -0.48116523293039026, -0.3455270947267371, 0.4655510054575944, 0.21073592473488212, -0.7393279519987309, -0.7331986835493073, -0.19722904469418162, -1.0802395643312521, 0.2934313950761999, 1.1402520649753152, -0.9086071535929683, 0.02395654499079075, 0.3684164909317418, 0.5614399969048851, 0.9946642592430968, 1.124476487906898, 0.19575442149823322, -0.24851818064192416, 0.3905054965095121, -1.0073781554239616, 0.44320833092972917, -1.167994336275549, 0.6853930357205337, 0.09224681578137976, -0.9244241472672434, 0.32327571642704045, -0.08511712913634017, -0.1417785078648055, 1.0629206015460837, 0.3359763967683185, -0.30410336954697426])\n # 100\n runGait([0.6640463205265905, 140.52675516067927, 0.8199810222722016, -0.25481952456604723, -0.3425457104430286, -0.29895559122008386, -0.03691952728541809, -0.2926749796378846, 0.32589540084946145, -0.917897553277117, -0.1788579132316635, -1.1021614115353857, 0.16879565842355682, 0.9654926553955153, -0.8262395642035657, -0.032366000748803886, -1.035706777515601, 0.421355764319076, 0.7572712816111169, 0.20885822322721553, 0.4327161270350611, 0.9459811540427878, 0.8261945712691102, -1.1252075254946101, 0.47151105047328135, -0.20370646005147414, -0.17791531392877594, -0.1951822044066674, -0.3347713397441206, -0.8437477462605121, 0.6043792513174889, 0.8135465977213642, 0.1161484116712968, 0.2520589879602344, -0.013875994605011654, 0.6015180797865725, -0.6176009285822545, 0.12004417622115887, -0.9961965091337416, -0.3125071727309118, 0.8937107026868603, 0.08912944387701997, -0.06790816311341702, 0.22325347059753536, -0.09025762128409298, -0.011920073737759995, 0.35752949513101395, -0.45906903012374745, -0.788562694194514, -1.0050198450114056, -0.0361372172292605, -0.5954885246272503, 0.26895619166201407, 0.27184604863769407, -0.37353950677917513, 0.40112354341843237, 0.6375471269499228, 0.3141153522934928, -0.9509274229231759, 0.8779304554614856, 0.04594048324209277, 0.2495420932435201, 0.08241559351660238, -0.17642988998764342, -0.4447938485357037, -0.29330972785416387, -1.1174363806073722, -0.9616482147806933, -0.11200817025193116, -0.2108973739829038, 0.7633783825024583, -0.3175711563677784, -0.055385576075883194, -0.23831266165748738, 0.08104352235723783, 0.023356401512964642, -0.24320747848452665, 0.5859836965526846, 0.5423632994485224, -0.1667373762787313, 0.28209152742387117, 0.57278826903801, -0.2032795427955932, -0.4025112301636612, -0.5183539956075682, -0.19265157313585188, 0.17583720556492372, -0.5476355988504892, -0.6627234804934719, -0.11118988812304811, -0.7805070621113364, -0.4529826769989489, 0.7097466060065737, -0.620126964770608, 0.17005073215107458, -0.310351639008707, 0.7097004232177474, 0.6271790085262221, 0.619307086397858, 0.8131713488548474, 0.1497738579998278, 0.02526583014944417, -0.20005273447658806, -0.5474277783268228, -0.9924782021468856, 0.5028217189827595, -0.19263703499936438, 0.20588243107956172, 1.1385437676064627, 0.23883082558624708, 0.004571684392304376, 0.44876050879385027, 0.12812072388391504, -0.24208052529798593, -0.11013899281343525, -1.1196512365364517, 0.9507652902470094, 0.4545046069675115, 0.011125408478537602, 0.6549444015747156, -0.9034580752892476, -0.816680671954233, 0.42267629830319997, -0.610277202583551, 0.5500134814297155, -1.0434024414406398, -0.1937217218579826, 0.5755930968565269, -0.3839059765475241, 0.5719780788906925, 1.0347321090545003, 0.44370082946255346, 0.876765248918222, 0.2923665942100978, 0.9325649935073932, 0.5916765606714397, -0.8204301829871634, 0.5375111299520478, -0.9513662298918846, -0.48330360663587535, -0.014861243621365067, -0.7494281866976655, -0.08825309305806134, -0.9149440954101552, 1.1656564955027569, -0.319007800832239, 0.24788655005464028, -0.3902252669018448, 0.37813696098203525, 1.0257086358944083, -0.22782064462614982, 1.0142953972331836, -0.09326047201660298, -0.9608786031964357, 0.7922821770960228, -0.5752078753307402, -0.8741277024150452, 0.42074556397962476, -0.17088790293716782, -0.27812595030330334, 0.16024650373276178, -0.9015926997014683, 0.16765286991610046, 1.0745410173910972, -0.6109232086797313, -0.6866105711698087, 0.9586175739077698, 0.36069963154315404, -0.8179673245547332, 0.28221064021521486, 0.07881056395367772, 0.9621841067996804, 0.32611659794735176, 0.44963057094757963, 0.07055641109546117, -1.0165648669301155, -0.03825226786436686, -0.2562167100164272, 0.7081096623524648, 1.0925864874641888, 0.7985534527556107, -0.576117648391484, 1.128905296865967, -0.6836316776207304, -0.2843403105351967, -0.2875350090436179, -0.8884226806370785, 1.0867043497721995, 0.15936102064610103, 0.7213678990932757, 0.20189075328906597, 0.21909012756117713, 0.35081305063305934, -0.5533491342604271, -0.39139018059751557, -0.6063198386438513, -0.5324644497030327, -0.9211774284351677, 0.8014720982812371, -0.5110042508153627, 0.9729234799472499, 0.6198329213846822, -0.7172777918874114, 0.71393306635313, -0.8845569787211464, 0.8037248436039608, -0.4005762723352054, -0.41068663652781295, -0.12408256332477458, 0.2156827075982222, -0.5842278773022845, 0.5993604325472786, -0.1714832792903668, -1.073883900675711, 0.5300023789111741, -0.393565753380665, -1.1077691155993767, -0.19722587955218868, -0.10417172968555885, 0.6584848022547337, -0.5329152183955796, -0.3950555151941949, -0.10882724704645816, 1.1644009182829218, 0.1641879666963921, -0.6681618516093505, -0.927583868963644, -1.132447578431215, 0.9601897942960477, -0.3719235237813504, 0.568283689266319, 0.30050241478858897, -0.40449584730595933, 0.4561858885619927, 0.2909602044742249, 0.32523163443121184, 0.42755122870221796, -0.43174561514948073, -0.6752553468030823, 0.4204116282761027, -0.33022122289804556, -0.10054716261882779, -0.4499960947229804, 0.5718195749224134, -0.7769045028417172, 1.119286880787453, 1.0339119406352926, 0.05274713166468337, -0.6460257891457617, 0.8332178051984421, 0.03159851737606184, 0.4659457011446515, -1.1466040486387152, 0.40969329358334694, -0.055850231800543215, 1.0507510732129994, -0.05830916713550008, 0.6673647072199382, -0.93841995086702, -0.5252036523060817, -0.4085500615196542, -0.04419643170246719, 0.5892251042672283, -0.07265048037271993, 0.6495073424232363, 0.41894378985827774, -0.12136863342675985, 1.0354604832131513])\n # 150\n runGait([0.9676294826559563, 150.70882987508452, 0.7774265785769597, 0.30438411789744857, -1.0457358937004009, 0.06569446508772794, -0.15498365774078185, -0.2377622141182121, -0.5523307256530675, -0.08686467446610878, -1.0526089743219282, 0.8693892350692811, -0.17802396330235765, 0.984292423423254, -0.2150566341031429, 0.06941172841331614, -0.3042670031127815, 0.9739683090160918, 0.3387525680108089, 0.16403610960584877, 0.3348632802624376, 0.726765357781341, -0.9126961896061363, -0.7229583630620422, -0.3051251400627612, -0.18571836602256658, -0.31864411222929206, -0.19706640874261128, -0.11173710313723983, 0.3565369869153394, 0.1971428113859381, -0.2763605210478526, -0.10988448914397031, 0.4865331848012372, 0.19579861099733442, 0.0985008925024958, 0.10508611443908723, -0.5180802186096138, 0.602575401604621, -0.8201174052127542, 0.9018628672824313, 0.0498784872337901, -0.521071153653444, 0.4481479231233141, -0.2524266051402479, -0.253402947342113, -0.3651587489535104, -0.04675187762525251, -0.5284469398758529, 0.2654544927821044, 0.46605508251848005, 0.04966663957014836, 0.2745167545365336, 0.4868187826011344, -0.1497691281628623, -0.19339266529087248, 0.24136863629471383, -0.43924814954512725, -0.6263279786320504, 0.8484699492362705, 0.1585129887321573, -0.2588768245023081, 0.4805335508720735, -0.23474437738054899, -0.33209420118866895, -0.8818001009909548, -0.3070185272881074, 0.32004109284523, 0.6027386544692759, -0.6121775505303508, 0.4490581540464468, 0.5642596329992625, -0.04982483368519975, 0.12126979404157245, 1.03751465671718, 0.3745312020424947, -0.047861781623897426, 0.23215652576049822, 0.48636218211863, -0.1235050817634415, -0.43294538682063655, 0.25467725985917183, -0.3065392897369155, -0.1557890602814631, -0.1535446617220671, -0.594059819196811, 0.2979599287648182, -0.47393639849675195, -0.1498269458086204, -0.5013840640153254, -0.4272045457213613, 0.41099576969282453, 0.435974275195693, -0.4947517141811753, 0.5589410579791683, 0.1652474308641266, 0.40923547743201916, 0.8096533414423498, -0.1614737073645072, 0.1666180159560079, 0.11988387794171795, -0.07807848102820575, -0.7442135781834419, -0.34406828342523743, -0.05221941010307851, 0.3010681255245467, -0.5477604345796725, -0.48790074433118147, 0.5210477108826119, 0.8054612805115671, -0.06963557072433436, -0.15839013687807313, -0.8487419175268571, 0.10322897440577106, 0.28014718041568193, -0.34631485812371793, 0.9430752549792686, 0.47027663953356336, -0.5794821932554436, 0.4692452807674205, -0.11158040045677747, 0.27992277267081245, 0.3776130667252946, -0.6369352430800613, -0.2996620853089707, 0.15891663821065996, -0.2687942812407239, -0.4471464630512332, 0.12797248611817225, 0.03778787082978413, -0.04817441866063496, -0.14364337110596323, 0.2456276684919766, -0.2193460148147342, 0.309322461049816, 0.8838971330552886, 0.9139067446448306, 0.7520794039116794, 0.3506023525822065, -0.25510377807771967, 0.16331308210797202, 0.8879935062411524, -0.5959693041241926, -0.20759495151814522, 0.2108418708456552, -0.7452310360910046, 0.12664881554927482, -0.047080807460529284, 0.4692849434023498, 0.7458543281348985, 0.8107049435101739, 0.7656829635908563, 0.2585428684080011, 0.9841469724781623, 0.8620949405960008, 0.4870555312544564, -1.122938689793093, -0.35529359973828545, -0.327327233145238, -0.3160934335831116, 0.39591363428761267, -1.0579727707301056, -0.31077112675144547, -0.7938933327626483, -0.3590902641595922, 0.19493924076014235, 0.5890886736882655, -0.009036129790468118, 0.596132945850858, -0.03994141013499769, 0.07806084523888342, 0.5692918377135482, 0.4974953937971758, 0.3775889672978954, 0.12873405457093853, 0.3895539355393124, -0.014462890465162359, -0.55425962690001, -0.6132736305766234, -0.41102081373534033, 0.10835255920191245, -0.39706623995337986, -0.05463237156533987, -0.8821361662438925, -0.4293498179030984, -0.44754327412891415, -0.1880089783045697, -0.7609470792799706, -0.3607734401106461, 0.7228114557048017, -0.32350458406045907, 0.003881601223850173, 0.4645169228853948, 0.30933674367871833, -0.5511008060190785, 0.019215497706641993, -0.1901675903409386, -0.2365943643295504, -0.8261367539601678, -0.5582895426381002, 0.8430889595735926, -0.10476902705139379, -0.7224029312799556, 0.27571772103786507, 0.0885536238095041, 0.015217124065685712, 0.3616330436036972, 0.4495807925732856, -0.25846532959546853, 0.02789168870877641, -0.30766351675851644, 0.4048762627077507, 0.27121677550071394, -0.15171546326311514, -0.7757535339112696, 0.07895603889692605, 0.3394112118661255, 0.2762139076230077, -0.8609718868797998, 0.6072119320035823, 0.5713716255007126, -0.6528469102896424, -0.10679737275320846, 0.05933745485535778, 1.0330880833994396, 0.3798427665421174, -0.05376631490501693, 0.35154721956479057, -0.2278546286708691, 1.1215415803557947, 0.37551720594302973, 0.20578900503472414, -1.101421780287494, -0.16904074302935618, -0.3137973325657055, -0.31107743259952253, -0.5054336950181983, -0.6015459471353947, -0.30583499460877933, -0.5710653400947024, -0.9093940918050203, 0.4258975120803453, -0.21935467585339385, 0.7752057901473814, 0.9048914510700778, -0.7846269882405049, 0.42094152311983585, 0.579829888624975, -0.17584369852195275, 0.3434019156849982, 0.4575688137719436, -0.14604013456644133, -0.3645678519465499, 0.369472539160814, 0.8790080502109889, -0.19650675936686374, -0.18752237139683797, 0.5586386030306622, 0.9508801265095614, 0.9411240544168558, -0.345415755136577, -0.14676816884141242, -0.6025122074152638, 1.0662310264379242, 0.18388246055206153, -0.07562722289757418, -0.6679498245650091, 0.18818487201688333])\n # 200\n runGait([0.9348218778087588, 146.91267362984482, 0.8744564653177251, -0.2311034676019011, -0.0162125073980263, 0.23441739730394234, -0.04068722081101439, -0.01314909472419457, 0.4223694738439635, -0.25574717281863013, 0.11241756397861355, 0.863412621923713, -0.5039035218187172, 0.8097751196961653, 0.5091863473931626, -0.10148835532593689, -0.28922562386776374, 0.5858340382268268, 0.43524750474759666, 0.23821865739642933, 0.46385381613992593, 0.9239038510623541, -0.4014932024069757, -0.7366198054221755, -0.26224195420212393, -0.26567675307257604, -0.6406999273924185, -0.3947291539512541, -0.13202897393736873, -0.36868075869905625, -0.05946923101403889, -0.27726495980956967, -0.5626455668474689, -0.011352949007235264, 0.229512162107839, 0.39705904834877165, -0.4006127993614362, 0.45741277302226363, -0.04872220530283761, 0.939231875796499, 0.9244874997661925, 0.421354026869032, -0.30719169912092076, -0.28374626104543155, 0.036224616108006924, -0.25044075786835196, 0.45388624765306124, -0.2717804606894174, -0.4275921887976257, -0.6646840055520035, -0.14474013946854764, 0.13888294858271502, -0.6177532030009414, 0.2746798600901093, -0.12203515742935869, -0.2628136886221271, 0.38679528157113163, -0.19822470557065894, -0.8884013180032637, 0.9228748319499014, -0.4928839251159022, 0.27037805010739346, -0.36086268564047347, -0.24969367306344575, -0.3336638120272727, -0.19129594916608794, -0.5412798207097986, -0.16378037787753816, 0.8380380076966655, -0.5602998817983854, 0.18838739261107923, 0.5039137894474521, 0.21024282762391727, 0.08436579427566918, 0.6355601001466065, 0.5267180582633789, 0.15087882211657277, 0.2588579542917172, 0.8159804644068003, -0.38735187036573715, -0.40374868821921456, 0.3176228472810542, -0.29327017193023885, -0.5501866453799408, -0.7389217625605805, -0.5615715453807273, 0.3712336142992907, -0.41428358751812816, -0.10726134390360059, -0.4099102222197733, -0.09159826087452744, 0.19893389971361133, -0.13132545262706974, -0.7570399899916764, -0.04170327254544387, 0.6914142826643184, 0.398856999424931, 0.9233641685403612, 0.3554904000885851, 0.07458506209142986, 0.21135000375679375, -0.23744305079600145, -0.013330649851585474, 0.01157025728448935, -0.7142922193662176, -0.057521311631223385, -0.6442594978866643, 0.1356536272774043, 0.9557393672331027, 0.5233808828963422, 0.11374875444427712, 0.09649391854350325, -0.4504172430652743, 0.6539212469538538, 0.1418178498877025, -1.0285250393762446, 0.8140662921364629, 0.22032729153232467, -0.3131857222772149, -0.48190358196718097, -0.6137839859402877, 0.4530943681506018, -0.24490264309157425, -0.7036205243667922, 0.22880630883881176, -0.9353768616975839, -0.22729920059617795, -0.3986687624180637, 0.3771370805444293, 0.2962185862198067, 0.2904151502090839, 0.41187261747985526, 0.5568412571554673, -0.12906786905832562, -0.29816090327711275, 0.6695654120828216, 0.6511164416374783, 0.2354423280825553, -0.2735118074560536, -0.09228336036973724, -0.8324667409784399, -0.5181961380658293, -0.29006499483710846, 0.20790847562845022, -0.5417341319611597, 0.38491216942962997, -0.26276464862820204, -0.4194681593642782, 0.18074940042710627, 0.3028577666580481, 0.7988109336459481, 0.3168960795244507, -0.06708903960865052, 1.065337334032617, 0.5121231247483485, 0.4516447688051512, -1.1319252709654564, 0.36013046523298803, -0.34875120783540486, -0.4784054810104189, -0.6383425055163587, -0.6044113298680207, 0.44898870301162985, -0.8409890804695659, -0.13518983270380686, 0.7206151228912457, 0.6402573302424278, 0.10412067706361405, 0.054761428387725804, 0.7078674741419084, 0.6835347252533357, 0.21226096258043248, -0.3590529214883623, 0.4262896753265209, -0.048765644390856705, 0.38707830574861446, 0.084150534306334, -0.3647673644633279, -0.33591157304158037, 0.543209090584881, -0.9227930221772509, 0.2793779445429621, 0.11437608190319354, -0.7320684310072323, -0.6016577518295898, -0.45131872796737754, 0.05815823303022799, 0.8858937450029887, -0.0019911283316581506, 0.9972537913440365, -0.03610523718702252, 0.7079473862344268, 0.2573924393198488, -0.04475989790206414, -0.046463632383485554, -0.5773905293012538, -0.21619326250264764, -0.18188721111452147, -0.07658954437605886, -0.7681077839396901, 0.09322698951176928, 0.1445427413363699, -0.26358485945073823, -0.35945630531652395, 0.6607553408730602, 0.5395749627096668, -0.06565247358481555, -0.13117986498165218, 0.6166842950843242, 0.4062530279955314, -0.32413286459352975, 0.3382214897259326, 0.060478191467047124, -0.30111192010527943, -0.6852023659365898, -0.6491951557870825, -0.6082929168718781, 1.0411226013092971, -0.6704184953876647, 0.2345803856056618, 0.4849343305291035, -0.18728401603681968, -0.19357983579761226, 0.6070055818353226, -0.1077936670840348, 0.7443380029642911, -0.17385870614262244, 0.4822669757853692, 0.389397991023952, -0.5111936026821581, 0.20633197759969002, 0.1718434261981503, -0.4672185062811099, -0.17236565565445167, -0.13557244311953168, 0.15571859432119767, -0.7500101603166999, -0.23515066300234422, 0.13714967863221472, -0.5267606306271126, 0.13519136956396957, 0.02524328959004487, 0.5235642763509845, 0.8384859468187118, 0.8448970827991501, 0.8107454533312748, 0.5496009157719298, -0.7861009121069743, -0.6234808705813863, 0.4696984323447554, 0.47429018972121284, 0.623971023164932, 0.19594794245176425, -0.08196145489238126, -0.44583013816552275, 0.331803658493219, -0.8110909742267071, -0.21348457194384118, -0.2793726604175222, 0.14931602985100503, 0.12574273195266228, -0.09011644679991501, 0.42322007305737674, 0.4167395715073748, -0.6212842551478526, 0.7246903575782073, -0.06965771001708732, 0.6997039268852637])\n # 300\n runGait([0.9580170156701137, 156.55023833080287, 0.8697263186451583, 0.41527680177951753, -0.3091878185605595, -0.6992501726886724, -0.3621632626756743, -0.08866639808357406, 0.04011602722874327, 0.07026709630165444, 0.08310069123845333, 0.9771964256154151, -0.400666267244531, 1.0176212186192009, 0.4686604002686661, -0.05444682325152628, -0.3446318452762033, 1.167921573447584, -0.24084550251954484, 0.11520414858809458, -0.9064091144422616, 0.6287846280182579, 0.4042274363728242, -0.17984894184261202, 1.1430310808904414, 0.12829599754811477, -0.2870163134708252, -0.18392037110494033, -0.1249514559839385, 0.40824155792459593, -1.0366104970327679, -0.21924341218226873, -0.10471741599076292, -0.039709787387529435, 0.24308506785995695, 0.5029106171652411, 0.00735981801132328, 0.46310261520766255, 0.2962573675541653, 0.5716571352437573, 0.9229307062858603, 0.4495458291143761, -0.32374844918493895, -0.5428033664800668, -0.1061657887085444, 0.09327418752618749, 0.1360933416106767, -0.05729803839333989, -0.5721972886843723, -0.7501829092993302, -0.15349800908427572, 0.18791462737535045, -0.5470482537350623, 0.0694805637919472, 0.11109949906739805, -0.05080609217009568, -0.10310782753879975, -0.11306331572492027, -0.7342942829959108, 0.5899346008666371, 0.15418825045439946, -0.02081659679571593, 0.23629696966788344, -0.20051899964600228, -0.1124416281658899, -0.2846997071631564, -0.7192552571252601, 0.37433250100587284, 0.4563424915786525, -0.6333746841090807, 0.48199161211899844, 0.7988546437125186, 0.3226337048037727, 0.08751293246797012, 0.6319836666961702, 0.5183905403464221, -0.03681080646589069, 0.32577945075501186, 0.6121356022112711, 0.3422973617966078, -0.38300865284018476, 0.3869972769037436, -0.3438931711267918, -0.2925667840718638, 0.02073915908080158, -0.6601106786744819, 0.18786226365552441, -0.4674216311409396, -0.20596050805709923, -0.6805376409410507, -0.11035629757866405, 0.128064195205727, 0.25006628117465546, -0.3911802588296395, 0.2206671476325982, 0.09977946265209521, -0.8307214146667822, 0.9171381291965639, -0.4940453191512136, 0.1984116913539024, 0.16554188896519878, -0.1928373027542588, 0.035841851144624626, 0.19266064738694355, -0.5850119457302836, 0.2215164403315185, -0.5896064710472241, -0.5102020534325775, 0.7417367519970856, 0.6225121973006423, 0.19164293014838338, -0.05737129492026963, 0.6121162351865662, 0.6866768284728066, 0.14965833690587552, -0.4193640570236367, 0.8160069586540502, 0.4684910259589942, -0.3030223187406086, -0.22660524229484055, -0.26703340415352106, 0.2211243087352533, -0.34540536962148954, -0.49431357086808453, 0.4597744966917602, -1.1664564277056044, -0.42563404464543353, -0.2676448037922594, 0.10874078586225963, 0.30510521880764874, 0.0201911678551102, 0.06799655432754058, 0.2696266035980911, -0.022093390708932178, -0.23885757257157703, 0.23240754800646202, 0.3154235780471931, 0.41222261068120575, 0.21621816215661968, -0.49383086489683936, 0.22028919935866093, 0.3085302761259844, -0.7607054242258245, -0.05524612679499659, -0.4005994571597372, -0.0005409548233603068, 0.09356401716698916, -0.28019790711798187, 0.11366960643707247, 0.11455280438074295, 0.23238882534231647, 0.38151138367739235, -0.6805858547100075, 1.0336614238387605, 0.3031048722576475, 0.3326128459698742, -0.4841094623424372, -0.14572762596592148, -0.6989095508218981, 0.08856510384007225, -0.7833815783352288, -0.6051206720201369, 0.05183879858837576, 0.8525690594373536, -0.21238052918801256, 0.3064353096452067, 0.5227279651783818, -0.26970368473406214, 0.30040315174676463, 0.8044560092955977, -0.31738694194412304, -0.03793873042044421, -0.43780967817899613, 0.44695577264660596, 0.07431440259337181, 0.30468167123379775, -0.17018353015014637, -0.3717841160485929, -0.38018867550367835, -0.8319113906639981, -0.3172654371086346, 0.19103501813376841, 0.7907537210342017, -0.9089959391273528, -0.296319135720049, -0.3417512761829329, -0.023084343039717133, 0.4040896098348129, -0.31660229354210917, 0.20977471047292015, 0.06648686941410495, 0.569876899843004, 0.21573326092963024, 0.12794663668726255, 0.13345639453704178, 0.06166211393616905, -0.03240968584900304, 0.5204613173650747, -0.054310331255427405, -0.606521604737881, 0.1468424637174045, -0.10111301306428899, -0.28436289560722927, 0.8017857089530022, 0.31257612218556174, 0.1945880804760491, -0.6089705211035303, -0.14618931754382708, 0.39343797880425146, -0.5405366749846467, -0.8955466868745385, 0.24857173830306561, -0.18623545173861095, -0.3623886194435283, -0.09699504056721092, -0.3486736104159766, -0.5453068629962625, -0.04010192714300855, -0.5306328827959214, -0.1354335299516863, 0.44670333258196254, -0.29490113171676874, -0.09463147398839705, 0.874510578425735, -0.08994591375239581, 0.9780471833760542, -0.5336783066507795, 0.44298379683008876, -0.44674080020159146, -0.31978046647941477, 0.4387881341782599, 0.5350973549899811, -0.27423388863198106, -0.39599195531628345, -0.17873234672818766, -0.3297290606571569, 0.4175261890217202, -0.41268092911177146, -0.22703685041841498, -0.274965576004083, 0.18191455558091849, -0.4939031672186963, -0.5349104573630611, 0.11079268810336479, 0.29357806459055, -0.7619449431049254, 0.712338129607013, -0.10469146069165344, -0.6452483516150597, 0.27405977939835985, 0.3831614384076198, 0.5368152956549854, 0.1178851135066101, 0.4460847058945193, -0.3883316848615107, 0.29727456716368683, -0.9048653966482885, -0.014346612174598924, -0.30126039008201877, -0.4640418178366639, 0.7986905413889673, -0.07702758460544154, 0.2259118808338296, 0.04026857681135493, -0.26928463274492503, 0.3490075592061821, -0.0973833708982666, 0.6135129639803163])\n # 500\n runGait([0.7788908289099306, 159.1275018887873, 0.3675002143633652, 0.29358082034076927, -0.15802555334813242, -0.10120259171082222, -0.30648918293561567, -0.05565177235370438, 0.3049336061735364, 0.019485785927701088, 0.07832249749716115, 0.7871716752724793, -0.11324944128855793, 0.33911735703936136, 0.5918403744719638, 0.023601544667689423, -0.28854114361833516, 0.3817510406516811, -0.7632588163737368, 0.022344201194842275, -0.9273228127530271, 0.23720909885208666, 0.15504539382606097, -0.06533263447758221, 0.6586022121665115, -0.29344233757111227, -0.6100745589428764, 0.17959646981207406, -0.2567640532742428, 0.3822693241621865, -0.7185816271396638, -0.17076272358383804, -0.19398205231627866, 0.030812971237587354, 0.13867994513962895, 0.3166621409958447, 0.22733110475404655, 0.5283963851565332, 0.3000850798497766, 0.6660952670105973, 0.78894440862353, 0.5157348667100712, -0.38489800997374557, -0.5993480088686595, -0.18953762119493234, -0.142888877844017, -0.2487995360903048, -0.2553184465203176, -0.6835072531097912, -0.08818770700477133, -0.36234611577801024, 0.1882081759188938, -0.5403677941379689, 0.12135448182929069, 0.13736905269298347, -0.19255224947663963, 0.40446549296965023, -0.12911247255617248, -0.8830555265743198, 0.5421547081545663, 0.19311176458866605, 0.32721151153007055, 0.2615659111455483, -0.3394759597454976, -0.06908691052009064, -0.4945679102133535, -0.664437236127388, 0.455900172021705, 0.9711538928263904, -0.6122014695612167, 0.5055842831599157, 1.0056138878174767, -0.12461961762482054, 0.07270199762420153, 0.1945368404538606, 0.6057165296982737, -0.036218178124653, 0.47457880179122397, 0.561082214156418, 0.5518568617850256, -0.5389721874824412, 0.018553983034344634, -0.33762141187925576, -0.2910578505162613, 0.14535357070447755, -0.5450888267216742, 0.3147936923887069, -0.8630308630441204, -0.35532598921412856, -0.6465004633853288, -0.13894664477940558, -0.05983048923837514, 0.365281504661632, -0.5068437133042195, 0.27739826556422653, 0.19813563846913917, 0.4204274997035509, 0.8205768952006834, 0.20430739373514373, 0.3485830076102606, 0.19097357428020537, 0.11039935013513971, -0.05699918798476541, 0.17873025134016074, -0.5020918329264104, 0.06913567443773855, 0.824576743344076, -0.5181143051990277, 0.5324747932677494, 0.4047169187725307, 0.17512694920182592, 0.09027062872679636, -0.020184312316256805, 0.45759775735791614, 0.3541811364432514, -0.42810856403905084, 0.34330793691017164, 0.37803887536859593, -0.6335568031247926, 0.7451449971471023, -0.422905787574568, 0.1108746870208986, -0.48281598513746043, -0.8845798783329725, 0.2848773437400216, -1.024048537916983, -0.3564009884656577, -0.12474613038765203, -0.20868110635282452, 0.34321844967647513, 0.026989145418742592, 0.0056243347284405665, 0.2157974836543368, -0.13733758298445253, -0.33659375632067434, 0.22898564273416638, 0.5087202771881477, 0.5372813556304213, 0.2763875601801632, -0.0931809119638537, -0.15966469444157633, 0.6929648835534945, -0.6910669985856048, -0.19389406110887974, -0.3902847322396408, 0.14551156290910644, 0.16618646822053293, -0.8039787804703373, 0.15428898913228964, 0.2190997039624487, 0.6297767323586855, 0.679561926817978, -0.25269142672699957, 1.073396465709869, 0.29029445313069896, 0.3205284197358836, -0.8690640106312963, -0.28879170523811604, -0.3779137324309013, 0.11936316568503534, 0.12976155632213082, -0.6265683661237571, -0.4855309257343185, -0.5955282235528421, -0.6845815418683121, 0.4737288107745596, 0.9252056200075451, 0.34567749439018725, 0.0363068008180909, 0.5036072080080863, 0.7640949628326337, 0.23505279305957724, -0.7167717818166955, 0.22850447613489278, -0.030879680605631232, 0.8293535643185203, -0.12780675301767844, -0.4412923860207338, -0.4755533837206397, -0.7447986150788337, -0.351029516667939, 0.14495494618770427, 0.4535847436338252, -0.3531591185986031, -0.3501206760556444, -0.34008350299413603, -0.1719031304459102, 0.5791280201924914, -0.1307266287188878, 0.5722057672119683, -0.15710148018631528, 0.8971534994186912, 0.2136354954365922, 0.10736052402292397, -0.09859594062374435, 0.029800704664000633, -0.036340884369813475, 0.13376827373262254, 0.06508877177327688, 0.3209725597538162, 0.25401652110289125, 0.306412096915022, -0.4062443766586342, 0.8116135654848087, 0.5038625296989976, 0.31304069230057774, 0.27907345633577596, -0.0628432232149184, 0.7488103240677573, 0.26866161782653364, -0.3422913295247829, 0.2620956604170435, 0.3869320718994709, -0.31031616120110883, -0.6430657281164895, -0.22156900833723173, -0.38501223572432874, 0.253328681493752, -0.43126896631860384, 0.13122580788583768, 0.38236533839599784, -0.41315518332835866, -0.06881562913283318, -0.06011531751913962, -0.1786891777692833, 0.5379347036881686, -0.40503481008181036, 0.5715406089598921, 0.09206279188231829, -0.06971523980576558, 0.2873942092356773, 0.5853487864435241, -0.2276481518074298, 0.024954174691643023, -0.45483892434063, -0.24065990358463835, 0.009443952578838826, -0.4484870705490043, 0.020876918478014064, -0.3827342793037868, 0.08765966633266016, -0.27582852508027256, -0.31975146101964735, 0.23584006084015846, 0.29568147715946885, -0.8673046059997449, 0.731200312180833, 0.023929423446759857, -0.573758689689352, 0.20993143702530428, 0.47001185232098075, 0.5565009861719601, 0.4404197794305241, 0.185040383009213, -0.4131600591525496, 0.16851972924086844, -0.4306339258923647, -0.08726456746018109, -0.4968797363532158, 0.11631152950365159, 0.12129503091276284, -0.2797069038719245, 0.28964257172500313, 0.30047606726857523, 0.7797290276248695, 0.6214545112158738, -0.05292732565014542, 0.7730879197180376])\n # 750\n runGait([0.5798525952403486, 159.40058262811087, 0.2565373666541486, 0.4318803359566548, -0.12670809771496028, -0.18389697331663157, -0.2107828186822762, -0.08822530542530635, 0.22285787517794267, -0.14626266057699905, -0.010708372490804578, 0.8284588168920229, -0.4722713879921887, 0.19208169499854316, 0.7411503431106623, 0.040109802039862204, -0.09388586098031043, 0.3021068442167352, -0.7632253195827811, 0.7506268013480695, 0.9817795923219715, 0.24702479164747443, 0.18619723055382778, -0.01944816101487032, 0.48047453154015674, 0.044027151050185204, -0.3811611523444315, 0.07043423693100055, -0.3519428921487882, 0.06993952938115677, -0.5223378593335369, -0.22654293849301965, -0.3119867211980983, 0.02203965621516251, 0.13948563872031947, 0.303700575374144, -0.38645242345574016, 0.28023524831943847, 0.48072548736928467, 0.23302786453056437, 0.5986122931605656, 0.6980983847283087, -0.34928346917889913, -0.7471794250508657, -0.17324487759716678, -0.17474742917438432, -0.016090144920211283, -0.3939766926275115, -0.22629036214619017, 0.16700221777337937, -0.37273771647989734, 0.09062261530742664, -0.37891402716818134, -0.06917514694333406, 0.17291180959585456, -0.04844904642867835, 0.4909898309834386, -0.12380149375214647, -0.9111999943893617, 0.5239305389825415, 0.18171587810764148, 0.38432773481912763, 0.2485646260803057, -0.34491165699137327, 0.006209690525156852, -0.37412477201907574, -0.4604269737237233, 0.18972851127462684, 0.9223517018397529, -0.6210098084521306, 0.49640907383479516, 1.0891123792650426, 0.49418162637573465, 0.06420244660188437, -0.12089596773664718, 0.550748464763964, -0.06108552913804381, 0.5552559735763302, 0.5522750091665136, 0.4683531478559523, -0.49173267096532985, -0.03517143099932757, 0.06100743363377523, -0.1902922529235461, 1.1122974946275956, -0.6276776253711288, 0.18178541719252822, -0.8132832667298763, -0.4537338576551622, -0.5808862777121856, -0.23668011060600833, 0.09569218539264038, 0.304579054169755, -0.4494551817405288, 0.15870763199473473, 0.3069755905115654, 0.3959705547451262, 0.7213258637748241, 0.3763728637422603, 0.40391108748034943, 0.37339498399229337, 0.01831140131395486, -0.07811735353228262, 0.13357830561871784, -0.3758537743243868, 0.05195547431005445, 0.9379615461508354, -0.5620520288627262, 0.4539455849665125, 0.8143570677050026, 0.004283675773725867, 0.11729610271034435, 0.25800504348420195, 0.3861845305371114, 0.041281706706534374, -0.5754739036307105, 0.25496830847083185, 0.5497065484163852, -0.6197402288256176, 0.4497922477657804, -0.4509130489838098, 0.08492188046586338, -0.3745067142483794, -0.6326481434329293, 0.35798335360645445, -1.0756026955774058, -0.1658013536974587, -0.7407148571190698, -0.4210965495924469, 0.31622190189278027, -0.037060520648369094, 0.027025421714000526, 0.12225503371751616, -0.1873821138347538, -0.39270249305607063, 0.20600245925762312, 0.6985349231049772, 0.538141419017502, 0.28367589673434807, 0.2408451341677153, -0.4857764076187511, 0.3515662648369627, -0.5970692688174171, 0.02074320821791737, -0.4780204081199166, 0.1369717613278151, 0.1389681583857107, -0.7410246577802894, -0.026563078155500804, 0.15750473450145544, -0.13448669931945875, 0.6551277580017717, -0.15601141002050287, 0.7448104569077326, 0.2902755482562471, 0.5364234542988243, -0.7792137180797938, -0.2846168758998948, -0.5839320530147617, 0.0628617276240415, 0.04002665260768596, -0.5479117597172838, -0.34196183099322613, 0.7056701204997842, -0.6647297748826204, 0.42806286178547925, 1.036676035059638, 0.642474334419992, -0.007131427190290577, 0.4639036629286082, 0.7267327436184402, 0.10043705596129168, -0.6440769086811172, 0.21343864782202604, -0.10329009445544304, 0.6425250240843889, 0.05230900542901544, -0.11251073882320739, -0.35085266645906615, -0.4199713623669293, -0.3351922780693797, -0.1672466366670506, 0.5379892464340184, -0.16330627356393349, -0.056804450777555304, -0.4017389922325012, -0.1611244393278351, 0.5367215850055974, 0.26665926782883664, 0.7219467754507272, -0.23576690967651864, 0.9079195952027548, 0.2062387616905374, -0.46534175178439574, -0.10399688011724603, 0.03668728875610021, -0.036926473584827625, -0.10113397006234737, -0.0394881387655676, 0.350606385291519, 0.13403276401659836, 0.5123948398917316, -0.35772789686003825, 0.9668024245923357, 1.027298011515463, 0.48938829842316445, -0.016483670605963077, -0.11757722414303058, 0.2537310530675592, 0.2784246188624572, 0.7695997113771061, 0.20066387160146376, 0.41486141094226053, -0.41256985585307027, -1.0477965177073278, -0.3200262420965195, -0.4739320902039974, 0.1565114856750497, -0.4241862276994479, -0.014128604687211607, 0.16050204319589437, -0.40332695432173227, -0.17516701158934914, -0.11260377701162964, -0.13167892785497093, 0.7970663227025759, -0.5351328770237976, 0.5899558689297649, 0.23041684659804587, -0.15627868369477282, 0.2137694705032495, 0.5696194997458192, -0.17336701928954443, 0.10876003399835937, -0.17072054408485435, -0.329611678752721, -0.14558125057844667, -0.5971107203993231, 0.09088625634430318, -0.9113803135864458, 0.20662562476533045, -0.1850266147294778, -0.3839648611252884, -0.06266604342717771, 0.32620231538556216, -0.4511759755602935, 0.46462930437425676, -0.19098144950012377, -0.45748534958561105, 0.21835806888483988, 0.375990472674876, 0.3152963988042483, 0.4174992880580025, 0.2417839091584328, -0.24397794422280902, 0.35917942428087724, -0.3968249675417042, -0.020614707571517774, -0.5895590906441834, -0.4121546533845332, 0.7169006234784104, 0.00017719522626339322, -0.009118568606292298, 0.43285003350721596, 0.9231244888866221, 0.6350781716028882, 0.025592267149331688, 0.8892290172542283])\n # best\n runGait([0.5833710183294218, 159.94477382941363, 0.274991231117698, 0.238089263008252, -0.1417409643619611, -0.12761521449834923, -0.19289461538039873, -0.10856112933014755, 0.15968577636162862, -0.17368631551323016, 0.07203736702130702, 0.881941236232128, -0.49131125475461257, 0.41963359660824545, 1.0286266905353563, 0.08461166310190373, -0.0930092118460774, 0.6688730971003121, -0.5272671341802382, 0.3759165556754689, 1.0284225286200426, 0.281022494747565, 0.0009195019049819536, -0.0879260351696233, 0.36182544936252586, 0.1544240116221797, -0.3379165966729512, -0.07107860607401342, -0.35347372811378175, 0.24474628711192828, -0.9554210776881508, -0.2446425071911576, -0.21834542364787896, 0.02941224160898587, 0.19860309964710376, 0.32015885118565973, -0.38463037767537034, 0.2721652517032083, 0.4498871803091191, 0.2843738257583236, 0.501327523282536, 0.669013035550511, -0.37715689084783993, -0.7193636388118547, -0.2383013342521316, -0.17489396233602697, 0.06083890600102712, -0.4034525364101677, -0.24583511137643727, 0.05016350547975096, -0.5231072760701854, 0.0920601174252217, -0.3798879187489547, -0.06425162833626528, 0.1175629295006112, 0.02682125752619795, 0.5075090858782456, -0.16206766607753353, -0.9027943006438802, 0.5191380547248162, 0.1922772367714138, 0.3722573359482723, 0.27824784135917774, -0.36599087581441164, -0.06620007679763394, -0.37707864764924415, -0.3432745401212583, 0.1890972969239655, 0.9771314779636118, -0.6379190437437263, 0.5327515128308239, 1.1266802573644779, 0.4853618562003829, 0.03715655903182573, 0.07311510274068314, 0.5423300464375319, -0.0658356136420452, 0.6733211262326829, 0.5412515512543659, 0.475841545559648, -0.5369352656406974, -0.026774867624149132, -0.27366768812094183, -0.21535394823513682, 1.1272641607914005, -0.6324828192170618, 0.22992240750612652, -0.8332942275738103, -0.4448812583609043, -0.5639998583724821, -0.28504303170819406, -0.13715306369785674, 0.3349484025718961, -0.3700368781101578, 0.20300787227134326, 0.22374862961672667, 0.027970795265832554, 0.7014861172229404, -0.04926493320095343, 0.4402290874741377, 0.3860194514832391, 0.11569030596073443, -0.06036997313965854, 0.1497256975919505, -0.377481545800565, 0.08298090520892161, 0.9438244188255105, -0.48021805376469584, 0.4543715274216308, 0.8678356926851799, -0.003915278924756722, 0.10352872557178089, 0.3358865719916397, 0.4211155579389066, -0.030249314775129762, -0.5658285551195321, 0.2548939424634452, 0.5745275199121783, -0.7796534931283465, 0.3451123282022226, -0.5444761756627212, 0.12200790829540269, -0.25898916669720645, -0.6724214809633824, 0.34635133694786935, -1.0685493620290625, -0.166454962800517, -0.8051985252291386, -0.4306033386198576, 0.3621432335285329, 0.014468787338504891, 0.141080510173102, 0.13964744684544284, -0.15421615523049945, -0.4317859615807832, 0.225587551388641, 0.693207792900198, 0.5533948757767216, 0.20097437713556277, 0.23256665133179352, -0.4990635733731684, 0.37724815041759296, -0.8484710927328951, 0.052329062943848995, -0.6454186305205749, 0.01709338435440333, 0.1426615820133712, -0.7496362823830726, -0.024592492969917387, 0.07160640453502068, -0.2474844962946594, 0.5941575845367926, -0.20960304431184107, 0.6424578239764861, 0.2920273219156567, 0.7036560308915455, -0.8121144845665177, -0.2789410770162129, -0.7413476580353197, 0.08188596178827257, 0.07931227840034549, -0.7207975890283618, -0.6065813517836143, 0.3983191376566657, -0.5635381703226274, 0.4088177741187736, 0.8161358908559947, 0.6554301845419963, 0.04547395492205422, 0.08051995385752733, 0.7945827746307063, 0.11087351442670304, -0.590752837198396, 0.2065658076101474, 0.0751712923684167, 0.6709125887262557, 0.1373187383960103, -0.18183312802940133, -0.4350057499267376, -0.3766430661862623, -0.8199596582372628, -0.14153603961297806, 0.590381220135425, -0.16508543450631305, -0.20708569485397604, -0.34591459093209215, -0.16651848898298874, 0.5178287410957361, -0.03657852374819068, 0.7219509009910949, -0.22937310869060928, 1.1464596068133195, 0.21233031874020497, -0.3609307120798186, -0.41136793770748015, 0.16347336752562386, -0.04569336581669571, -0.12320285070861678, 0.08240315222323638, 0.4579164525630148, 0.10194743670878537, 0.5748048740706077, -0.38484763478500494, 0.8009525610955103, 0.7333605699869847, 0.37124845323434263, -0.03501117975518403, 0.012948485735009754, 0.29139932552493186, 0.34343670572619495, 0.8542624160112243, 0.2047939987143607, 0.3903803959743837, -0.20493239305818473, -1.1287011492813999, -0.32936672671984124, -0.36581898984821176, 0.2451494881151558, -0.5756460181132672, -0.030221322542399086, 0.16449751038968874, -0.3567999251278406, -0.1618212236300447, -0.11207687799559582, 0.05735981109003743, 0.9415542138674963, -0.3554473551841668, 0.5357750527639715, 0.21498207309781378, 0.4532008047694893, 0.21329882952215284, 0.5859846457864504, -0.16362093353740018, 0.1319546289160159, -0.2194715016448026, -0.266878066809855, 0.19007538470038587, -0.6214579041470789, 0.07758190484905561, -0.7515667963793465, 0.24700843522334995, -0.292447662725082, -0.4181253106644778, 0.19564903243421003, 0.19724000917384554, -0.2063833311816462, 0.46455125472211967, -0.0899164519697946, -0.4859666940225116, 0.2204956850628324, 0.5537344147667811, 0.3710020504693896, 0.42084808456566025, 0.22826893049722402, -0.3009973798887208, 0.3133299056345898, -0.5362470634819437, -0.07363025268708201, -0.4903844709824772, -0.4212031706808154, 0.593200663984306, 0.03428638943992187, 0.24491294188014479, 0.46221509482741235, -0.20849095803967968, 0.6337473393725238, -0.05747450930384633, 0.8875435750416844])\n p.disconnect(physicsClient)\n\n\nif __name__ == \"__main__\":\n main()\n"
] | [
[
"numpy.array",
"numpy.dot",
"numpy.linalg.norm",
"numpy.arccos"
]
] |
didriknielsen/pixelcnn_flow | [
"9030f6a66d5ff83d7d299541ed55b20b20bb9a15",
"9030f6a66d5ff83d7d299541ed55b20b20bb9a15"
] | [
"pixelflow/distributions/normal.py",
"experiments/train/exact_pixelcnn_quad.py"
] | [
"import math\nimport torch\nfrom pixelflow.distributions import Distribution\nfrom pixelflow.utils import sum_except_batch\nfrom torch.distributions import Normal\n\n\nclass StandardNormal(Distribution):\n \"\"\"A multivariate Normal with zero mean and unit covariance.\"\"\"\n\n def __init__(self, shape):\n super(StandardNormal, self).__init__()\n self.shape = torch.Size(shape)\n self.register_buffer('base_measure', - 0.5 * self.shape.numel() * torch.log(torch.tensor(2 * math.pi)))\n\n def log_prob(self, x):\n return self.base_measure - 0.5 * sum_except_batch(x**2)\n\n def sample(self, num_samples):\n return torch.randn((num_samples,) + self.shape, device=self.base_measure.device, dtype=self.base_measure.dtype)\n\n def sample_shape(self, num_samples):\n return (num_samples,) + self.shape\n",
"# General\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n# Setup\nfrom setups import CategoricalImageFlowSetup\n\n# Data\nfrom pixelflow.data import CategoricalCIFAR10\n\n# Model\nfrom pixelflow.flows import AutoregressiveSubsetFlow2d\nfrom pixelflow.transforms.subset import QuadraticSplineAutoregressiveSubsetTransform2d\nfrom pixelflow.networks.autoregressive import PixelCNN\n\n# Optim\nimport torch.optim as optim\n\n###################\n## Specify setup ##\n###################\n\nsetup = CategoricalImageFlowSetup()\n\nparser = setup.get_parser()\n\n# Model params\nparser.add_argument('--num_bins', type=int, default=16)\nparser.add_argument('--filters', type=int, default=128)\nparser.add_argument('--num_blocks', type=int, default=15)\nparser.add_argument('--kernel_size', type=int, default=3)\nparser.add_argument('--kernel_size_in', type=int, default=7)\nparser.add_argument('--output_filters', type=int, default=1024)\n\n# Optim params\nparser.add_argument('--lr', type=float, default=1e-3)\nparser.add_argument('--milestones', type=eval, default=[])\nparser.add_argument('--gamma', type=float, default=0.1)\n\nargs = parser.parse_args()\nsetup.prepare_env(args)\n\n##################\n## Specify data ##\n##################\n\ndata = CategoricalCIFAR10()\n\nsetup.register_data(data.train, data.test)\n\n###################\n## Specify model ##\n###################\n\nmodel = AutoregressiveSubsetFlow2d(base_shape = (3,32,32,),\n transforms = [\n QuadraticSplineAutoregressiveSubsetTransform2d(PixelCNN(3, num_params=2*args.num_bins+1,\n num_blocks=args.num_blocks,\n filters=args.filters,\n kernel_size=args.kernel_size,\n kernel_size_in=args.kernel_size_in,\n output_filters=args.output_filters,\n init_transforms=lambda x: 2*x-1), num_bins=args.num_bins),\n ])\n\nsetup.register_model(model)\n\n#######################\n## Specify optimizer ##\n#######################\n\noptimizer = optim.Adam(model.parameters(), lr=args.lr)\nscheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.milestones, gamma=args.gamma)\n\nsetup.register_optimizer(optimizer, scheduler)\n\n###############\n## Run setup ##\n###############\n\nsetup.run(args)\n"
] | [
[
"torch.randn",
"torch.tensor",
"torch.Size"
],
[
"torch.optim.lr_scheduler.MultiStepLR"
]
] |
srimanthtenneti/Deep-Learning-NanoDegree | [
"d99b09530a96f4aeca7adf3b9188e1d5fc4104d4"
] | [
"AWS_Deployment/serve/predict.py"
] | [
"import argparse\nimport json\nimport os\nimport pickle\nimport sys\nimport sagemaker_containers\nimport pandas as pd\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.utils.data\n\nfrom model import LSTMClassifier\n\nfrom utils import review_to_words, convert_and_pad\n\ndef model_fn(model_dir):\n \"\"\"Load the PyTorch model from the `model_dir` directory.\"\"\"\n print(\"Loading model.\")\n\n # First, load the parameters used to create the model.\n model_info = {}\n model_info_path = os.path.join(model_dir, 'model_info.pth')\n with open(model_info_path, 'rb') as f:\n model_info = torch.load(f)\n\n print(\"model_info: {}\".format(model_info))\n\n # Determine the device and construct the model.\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n model = LSTMClassifier(model_info['embedding_dim'], model_info['hidden_dim'], model_info['vocab_size'])\n\n # Load the store model parameters.\n model_path = os.path.join(model_dir, 'model.pth')\n with open(model_path, 'rb') as f:\n model.load_state_dict(torch.load(f))\n\n # Load the saved word_dict.\n word_dict_path = os.path.join(model_dir, 'word_dict.pkl')\n with open(word_dict_path, 'rb') as f:\n model.word_dict = pickle.load(f)\n\n model.to(device).eval()\n\n print(\"Done loading model.\")\n return model\n\ndef input_fn(serialized_input_data, content_type):\n print('Deserializing the input data.')\n if content_type == 'text/plain':\n data = serialized_input_data.decode('utf-8')\n return data\n raise Exception('Requested unsupported ContentType in content_type: ' + content_type)\n\ndef output_fn(prediction_output, accept):\n print('Serializing the generated output.')\n return str(prediction_output)\n\ndef predict_fn(input_data, model):\n print('Inferring sentiment of input data.')\n\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n \n if model.word_dict is None:\n raise Exception('Model has not been loaded properly, no word_dict.')\n \n # TODO: Process input_data so that it is ready to be sent to our model.\n # You should produce two variables:\n # data_X - A sequence of length 500 which represents the converted review\n # data_len - The length of the review\n\n data_X , data_len = convert_and_pad(model.word_dict, review_to_words(input_data))\n\n # Using data_X and data_len we construct an appropriate input tensor. Remember\n # that our model expects input data of the form 'len, review[500]'.\n data_pack = np.hstack((data_len, data_X))\n data_pack = data_pack.reshape(1, -1)\n \n data = torch.from_numpy(data_pack)\n data = data.to(device)\n\n # Make sure to put the model into evaluation mode\n model.eval()\n\n # TODO: Compute the result of applying the model to the input data. The variable `result` should\n # be a numpy array which contains a single integer which is either 1 or 0\n \n with torch.no_grad():\n y = model.forward(data)\n \n result = np.round(y.numpy())\n return result\n"
] | [
[
"torch.load",
"torch.no_grad",
"numpy.hstack",
"torch.from_numpy",
"torch.cuda.is_available"
]
] |
jandremarais/TabularLearner | [
"7905b06a31fc6e0b0adf6a13a0fb445bdfe00c96"
] | [
"code/fastai_ext/fastai_ext/hyperparameter.py"
] | [
"import pandas as pd\nimport itertools\nfrom functools import partial\nfrom fastai.callbacks import CSVLogger\n\ndef get_config_df(config):\n df = pd.DataFrame(list(itertools.product(*config.values())), columns=config.keys())\n df.index = [f'model_{i+1}' for i in range(len(df))]\n return df\n\n\ndef create_experiment(nm, path, folder='results'):\n exp_path = (path/folder/nm)\n exp_path.mkdir(exist_ok=True)\n return nm, exp_path\n\ndef record_experiment(learn, fn, exp_path):\n learn.callback_fns.append(partial(CSVLogger, filename=exp_path/fn))\n\n\ndef load_results(exp_path):\n config_df = pd.read_csv(exp_path/'config.csv', index_col=0)\n param_names = config_df.columns.values\n recorder_df=[]\n for p in exp_path.ls():\n if p.name.startswith(tuple(config_df.index.values)):\n df = pd.read_csv(p)\n ind_name, fold_name = p.stem.split('-')\n df['index']=ind_name\n df['fold']=int(fold_name.split('_')[-1].split('.')[0])\n recorder_df.append(df)\n recorder_df = pd.concat(recorder_df)\n metric_names = list(set(recorder_df.columns).symmetric_difference(['index', 'epoch', 'train_loss', 'fold']))\n recorder_df = recorder_df.merge(config_df.reset_index())\n return config_df, recorder_df, param_names, metric_names\n\ndef summarise_results(recorder_df, param_names, metric_names):\n return (recorder_df.groupby(['index', *param_names, 'epoch'], as_index=False)\n .agg({k:['mean', 'std'] for k in metric_names}))"
] | [
[
"pandas.read_csv",
"pandas.concat"
]
] |
ParthivNaresh/Facilyst | [
"786932b0afcf07cd300b2e6ce55ccf7f9e4c49d9"
] | [
"facilyst/mocks/mock_types/features.py"
] | [
"\"\"\"A mock type that returns features data.\"\"\"\nimport pandas as pd\nimport woodwork as ww\n\nfrom facilyst.mocks import MockBase\nfrom facilyst.mocks.mock_types.utils import mock_features_dtypes\n\n\nclass Features(MockBase):\n \"\"\"Class to manage mock data creation of features.\n\n :param num_rows: The number of observations in the final dataset. Defaults to 100.\n :type num_rows: int, optional\n :param library: The library of which the final dataset should be, options are 'pandas' and 'numpy'. Defaults to 'pandas'.\n :type library: str, optional\n :param ints: Flag that includes column with monotonically increasing incremental set of negative and positive integers. Defaults to True.\n :type ints: bool, optional\n :param rand_ints: Flag that includes column with randomly selected integers between -5 and 5. Defaults to True.\n :type rand_ints: bool, optional\n :param floats: Flag that includes column which is the float version of the 'ints' column. Defaults to True.\n :type floats: bool, optional\n :param rand_floats: Flag that includes column with randomly selected floats between -5 and 5. Defaults to True.\n :type rand_floats: bool, optional\n :param booleans: Flag that includes column with randomly selected boolean values. Defaults to False.\n :type booleans: bool, optional\n :param categoricals: Flag that includes column with four categoriesL 'First', 'Second', 'Third', and 'Fourth'. Defaults to False.\n :type categoricals: bool, optional\n :param dates: Flag that includes column with monotonically increasing dates from 01/01/2001 with a daily frequency. Defaults to False.\n :type dates: bool, optional\n :param texts: Flag that includes column with different text on each line. Defaults to False.\n :type texts: bool, optional\n :param ints_nullable: Flag that includes column which is the same as the 'ints' column with pd.NA included. Defaults to False.\n :type ints_nullable: bool, optional\n :param floats_nullable: Flag that includes column which is the same as the 'floats' column with pd.NA included. Defaults to False.\n :type floats_nullable: bool, optional\n :param booleans_nullable: Flag that includes column which is a randomly selected column with boolean values and pd.NA included. Defaults to False.\n :type booleans_nullable: bool, optional\n :param full_names: Flag that includes column with first and last names. Defaults to False.\n :type full_names: bool, optional\n :param phone_numbers: Flag that includes column with US-based phone numbers. Defaults to True.\n :type phone_numbers: bool, optional\n :param addresses: Flag that includes column with addresses. Defaults to True.\n :type addresses: bool, optional\n :param countries: Flag that includes column with country names. Defaults to False.\n :type countries: bool, optional\n :param email_addresses: Flag that includes column with email addresses. Defaults to True.\n :type email_addresses: bool, optional\n :param urls: Flag that includes column with URLs. Defaults to True.\n :type urls: bool, optional\n :param currencies: Flag that includes column with US dollar based amounts. Defaults to False.\n :type currencies: bool, optional\n :param file_paths: Flag that includes column with file paths at a depth of 3. Defaults to False.\n :type file_paths: bool, optional\n :param ipv4: Flag that includes column with different IPv4 addresses. Defaults to False.\n :type ipv4: bool, optional\n :param ipv6: Flag that includes column with different IPv6 addresses. Defaults to False.\n :type ipv6: bool, optional\n :param lat_longs: Flag that includes column with latitude and longitude values in a tuple. Defaults to False.\n :type lat_longs: bool, optional\n :param all_dtypes: Flag that includes all columns. Defaults to False.\n :type all_dtypes: bool, optional\n :return: Mock features data.\n :rtype: pd.DataFrame by default, can also return np.ndarray\n \"\"\"\n\n name = \"Features\"\n\n def __init__(\n self,\n num_rows=100,\n library=\"pandas\",\n ints=True,\n rand_ints=True,\n floats=True,\n rand_floats=True,\n booleans=False,\n categoricals=False,\n dates=False,\n texts=False,\n ints_nullable=False,\n floats_nullable=False,\n booleans_nullable=False,\n full_names=False,\n phone_numbers=False,\n addresses=False,\n countries=False,\n email_addresses=False,\n urls=False,\n currencies=False,\n file_paths=False,\n ipv4=False,\n ipv6=False,\n lat_longs=False,\n all_dtypes=False,\n ):\n kw_args = locals()\n\n if all_dtypes:\n parameters = {\n k: True\n for k, v in kw_args.items()\n if k not in [\"self\", \"library\", \"num_rows\", \"__class__\"]\n }\n else:\n parameters = {\n k: v\n for k, v in kw_args.items()\n if k not in [\"self\", \"library\", \"num_rows\", \"__class__\"] and v\n }\n if not any(\n parameters.values()\n ): # All False flags results in all dtypes being included\n parameters = {k: True for k, v in kw_args.items()}\n\n super().__init__(library, num_rows, parameters)\n\n def create_data(self):\n \"\"\"Main function to be called to create features data.\n\n :return: The final features data created.\n \"\"\"\n data, dtypes_to_keep = self.get_data_from_dict()\n data = self.handle_library(data, dtypes_to_keep)\n return data\n\n def get_data_from_dict(self):\n \"\"\"Returns the data based on the dtypes specified during class instantiation.\n\n :return: The final data created from the appropriate library as a pd.DataFrame or ndarray.\n \"\"\"\n dtypes_to_keep = list(self.parameters.keys())\n mocked = Features._refine_dtypes(dtypes_to_keep, self.num_rows)\n\n mocked_df = pd.DataFrame.from_dict(mocked)\n return mocked_df, dtypes_to_keep\n\n def handle_library(self, data, dtypes_to_keep):\n \"\"\"Handles the library that was selected to determine the format in which the data will be returned.\n\n :param data: The final data to be returned.\n :type data: pd.DataFrame\n :param dtypes_to_keep: All data format options from the class initialization. Defaults to returning the full dataset.\n :type dtypes_to_keep: list\n :return: The final data created from the appropriate library as a pd.DataFrame or ndarray.\n \"\"\"\n if self.library == \"numpy\":\n return data.to_numpy()\n else:\n if \"ints_nullable\" in dtypes_to_keep:\n data[\"ints_nullable\"] = data[\"ints_nullable\"].astype(\"Int64\")\n if \"floats_nullable\" in dtypes_to_keep:\n data[\"floats_nullable\"] = data[\"floats_nullable\"].astype(\"Float64\")\n data.ww.init()\n return data\n\n @staticmethod\n def _refine_dtypes(dtypes, num_rows=100):\n \"\"\"Internal function that selects the dtypes to be kept from the full dataset.\n\n :param dtypes: All data format options from the class initialization. Defaults to returning the full dataset.\n :type dtypes: list\n :param num_rows : The number of observations in the final dataset. Defaults to 100.\n :type num_rows: int\n :return: A refined form of the full set of columns available.\n \"\"\"\n full_mock = mock_features_dtypes(num_rows)\n return {k: v for k, v in full_mock.items() if k in dtypes}\n"
] | [
[
"pandas.DataFrame.from_dict"
]
] |
simassakenis/CausalMediationAnalysis | [
"ad46c02cdda88e13e2e891e9968c365e093ecc99"
] | [
"attention_intervention_winobias.py"
] | [
"\"\"\"Performs attention intervention on Winobias samples and saves results to JSON file.\"\"\"\n\nimport json\n\nimport fire\nfrom pandas import DataFrame\nfrom transformers import (\n GPT2Tokenizer, TransfoXLTokenizer, XLNetTokenizer,\n BertTokenizer, DistilBertTokenizer, RobertaTokenizer\n)\n\nimport winobias\nfrom attention_utils import perform_interventions, get_odds_ratio\nfrom experiment import Model\n\n\ndef get_interventions_winobias(gpt2_version, do_filter, split, model, tokenizer,\n device='cuda', filter_quantile=0.25):\n if split == 'dev':\n examples = winobias.load_dev_examples()\n elif split == 'test':\n examples = winobias.load_test_examples()\n else:\n raise ValueError(f\"Invalid split: {split}\")\n json_data = {'model_version': gpt2_version,\n 'do_filter': do_filter,\n 'split': split,\n 'num_examples_loaded': len(examples)}\n if do_filter:\n interventions = [ex.to_intervention(tokenizer) for ex in examples]\n df = DataFrame({'odds_ratio': [get_odds_ratio(intervention, model) for intervention in interventions]})\n df_expected = df[df.odds_ratio > 1]\n threshold = df_expected.odds_ratio.quantile(filter_quantile)\n filtered_examples = []\n assert len(examples) == len(df)\n for i in range(len(examples)):\n ex = examples[i]\n odds_ratio = df.iloc[i].odds_ratio\n if odds_ratio > threshold:\n filtered_examples.append(ex)\n\n print(f'Num examples with odds ratio > 1: {len(df_expected)} / {len(examples)}')\n print(\n f'Num examples with odds ratio > {threshold:.4f} ({filter_quantile} quantile): {len(filtered_examples)} / {len(examples)}')\n json_data['num_examples_aligned'] = len(df_expected)\n json_data['filter_quantile'] = filter_quantile\n json_data['threshold'] = threshold\n examples = filtered_examples\n json_data['num_examples_analyzed'] = len(examples)\n interventions = [ex.to_intervention(tokenizer) for ex in examples]\n return interventions, json_data\n\ndef intervene_attention(gpt2_version, do_filter, split, device='cuda',\n filter_quantile=0.25, random_weights=False,\n masking_approach=1):\n model = Model(output_attentions=True, gpt2_version=gpt2_version,\n device=device, random_weights=random_weights,\n masking_approach=masking_approach)\n tokenizer = (GPT2Tokenizer if model.is_gpt2 else\n TransfoXLTokenizer if model.is_txl else\n XLNetTokenizer if model.is_xlnet else\n BertTokenizer if model.is_bert else\n DistilBertTokenizer if model.is_distilbert else\n RobertaTokenizer).from_pretrained(gpt2_version)\n\n interventions, json_data = get_interventions_winobias(gpt2_version, do_filter, split, model, tokenizer,\n device, filter_quantile)\n results = perform_interventions(interventions, model)\n json_data['mean_total_effect'] = DataFrame(results).total_effect.mean()\n json_data['mean_model_indirect_effect'] = DataFrame(results).indirect_effect_model.mean()\n json_data['mean_model_direct_effect'] = DataFrame(results).direct_effect_model.mean()\n filter_name = 'filtered' if do_filter else 'unfiltered'\n if random_weights:\n gpt2_version += '_random'\n if model.is_gpt2 or model.is_txl or model.is_xlnet:\n fname = f\"winobias_data/attention_intervention_{gpt2_version}_{filter_name}_{split}.json\"\n else:\n fname = f\"winobias_data/attention_intervention_{gpt2_version}_{filter_name}_{split}_{masking_approach}.json\"\n json_data['results'] = results\n with open(fname, 'w') as f:\n json.dump(json_data, f)\n\n\nif __name__ == \"__main__\":\n fire.Fire(intervene_attention)\n"
] | [
[
"pandas.DataFrame"
]
] |
justinshenk/simba | [
"a58ccd0ceeda201c1452d186033ce6b25fbab564",
"a58ccd0ceeda201c1452d186033ce6b25fbab564"
] | [
"simba/features_scripts/extract_features_16bp.py",
"simba/process_data_log_old.py"
] | [
"from __future__ import division\r\nimport os, glob\r\nimport pandas as pd\r\nimport math\r\nimport numpy as np\r\nfrom scipy.spatial import ConvexHull\r\nimport scipy\r\nfrom configparser import ConfigParser, NoOptionError, NoSectionError\r\nfrom numba import jit\r\nfrom simba.rw_dfs import *\r\nimport re\r\n\r\n\r\ndef extract_features_wotarget_16(inifile):\r\n config = ConfigParser()\r\n configFile = str(inifile)\r\n config.read(configFile)\r\n projectPath = config.get('General settings', 'project_path')\r\n csv_dir_in, csv_dir_out = os.path.join(projectPath, 'csv', 'outlier_corrected_movement_location'), os.path.join(projectPath,'csv', 'features_extracted')\r\n vidInfPath = os.path.join(projectPath, 'logs', 'video_info.csv')\r\n try:\r\n wfileType = config.get('General settings', 'workflow_file_type')\r\n except NoOptionError:\r\n wfileType = 'csv'\r\n vidinfDf = pd.read_csv(vidInfPath)\r\n #change videos name to str\r\n vidinfDf.Video = vidinfDf.Video.astype('str')\r\n\r\n def count_values_in_range(series, values_in_range_min, values_in_range_max):\r\n return series.between(left=values_in_range_min, right=values_in_range_max).sum()\r\n\r\n def angle3pt(ax, ay, bx, by, cx, cy):\r\n ang = math.degrees(\r\n math.atan2(cy - by, cx - bx) - math.atan2(ay - by, ax - bx))\r\n return ang + 360 if ang < 0 else ang\r\n\r\n @jit(nopython=True, cache=True)\r\n def EuclidianDistCald(bp1xVals, bp1yVals, bp2xVals, bp2yVals, currPixPerMM):\r\n series = (np.sqrt((bp1xVals - bp2xVals) ** 2 + (bp1yVals - bp2yVals) ** 2)) / currPixPerMM\r\n return series\r\n\r\n roll_windows, loopy = [], 0\r\n roll_windows_values = [2, 5, 6, 7.5, 15]\r\n\r\n #REMOVE WINDOWS THAT ARE TOO SMALL\r\n minimum_fps = vidinfDf['fps'].min()\r\n for win in range(len(roll_windows_values)):\r\n if minimum_fps < roll_windows_values[win]:\r\n roll_windows_values[win] = minimum_fps\r\n else:\r\n pass\r\n roll_windows_values = list(set(roll_windows_values))\r\n\r\n ########### FIND CSV FILES ###########\r\n print(csv_dir_in)\r\n filesFound = glob.glob(csv_dir_in + '/*.' + wfileType)\r\n print('Extracting features from ' + str(len(filesFound)) + ' files...')\r\n\r\n ########### CREATE PD FOR RAW DATA AND PD FOR MOVEMENT BETWEEN FRAMES ###########\r\n for currentFile in filesFound:\r\n M1_hull_large_euclidean_list, M1_hull_small_euclidean_list, M1_hull_mean_euclidean_list, M1_hull_sum_euclidean_list, M2_hull_large_euclidean_list, M2_hull_small_euclidean_list, M2_hull_mean_euclidean_list, M2_hull_sum_euclidean_list = [], [], [], [], [], [], [], []\r\n currVidName = os.path.basename(currentFile).replace('.' +wfileType, '')\r\n\r\n # get current pixels/mm\r\n currVideoSettings = vidinfDf.loc[vidinfDf['Video'] == currVidName]\r\n try:\r\n currPixPerMM = float(currVideoSettings['pixels/mm'])\r\n except TypeError:\r\n print('Error: make sure all the videos that are going to be analyzed are represented in the project_folder/logs/video_info.csv file')\r\n\r\n fps = float(currVideoSettings['fps'])\r\n print('Processing ' + '\"' + str(currVidName) + '\".' + ' Fps: ' + str(fps) + \". mm/ppx: \" + str(currPixPerMM))\r\n\r\n\r\n\r\n\r\n\r\n for i in range(len(roll_windows_values)):\r\n roll_windows.append(int(fps / roll_windows_values[i]))\r\n loopy += 1\r\n columnHeaders = [\"Ear_left_1_x\", \"Ear_left_1_y\", \"Ear_left_1_p\", \"Ear_right_1_x\", \"Ear_right_1_y\",\r\n \"Ear_right_1_p\", \"Nose_1_x\", \"Nose_1_y\", \"Nose_1_p\", \"Center_1_x\", \"Center_1_y\", \"Center_1_p\",\r\n \"Lat_left_1_x\", \"Lat_left_1_y\",\r\n \"Lat_left_1_p\", \"Lat_right_1_x\", \"Lat_right_1_y\", \"Lat_right_1_p\", \"Tail_base_1_x\",\r\n \"Tail_base_1_y\", \"Tail_base_1_p\", \"Tail_end_1_x\", \"Tail_end_1_y\", \"Tail_end_1_p\",\r\n \"Ear_left_2_x\",\r\n \"Ear_left_2_y\", \"Ear_left_2_p\", \"Ear_right_2_x\", \"Ear_right_2_y\", \"Ear_right_2_p\",\r\n \"Nose_2_x\", \"Nose_2_y\", \"Nose_2_p\", \"Center_2_x\", \"Center_2_y\", \"Center_2_p\", \"Lat_left_2_x\",\r\n \"Lat_left_2_y\",\r\n \"Lat_left_2_p\", \"Lat_right_2_x\", \"Lat_right_2_y\", \"Lat_right_2_p\", \"Tail_base_2_x\",\r\n \"Tail_base_2_y\", \"Tail_base_2_p\", \"Tail_end_2_x\", \"Tail_end_2_y\", \"Tail_end_2_p\"]\r\n csv_df = read_df(currentFile, wfileType)\r\n try:\r\n csv_df = csv_df.set_index('scorer')\r\n except KeyError:\r\n pass\r\n csv_df.columns = columnHeaders\r\n csv_df = csv_df.fillna(0)\r\n #csv_df = csv_df.drop(csv_df.index[[0]])\r\n csv_df = csv_df.apply(pd.to_numeric)\r\n csv_df = csv_df.reset_index()\r\n csv_df = csv_df.reset_index(drop=True)\r\n\r\n print('Evaluating convex hulls...')\r\n ########### MOUSE AREAS ###########################################\r\n\r\n try:\r\n csv_df['Mouse_1_poly_area'] = csv_df.apply(lambda x: ConvexHull(np.array(\r\n [[x['Ear_left_1_x'], x[\"Ear_left_1_y\"]],\r\n [x['Ear_right_1_x'], x[\"Ear_right_1_y\"]],\r\n [x['Nose_1_x'], x[\"Nose_1_y\"]],\r\n [x['Lat_left_1_x'], x[\"Lat_left_1_y\"]], \\\r\n [x['Lat_right_1_x'], x[\"Lat_right_1_y\"]],\r\n [x['Tail_base_1_x'], x[\"Tail_base_1_y\"]],\r\n [x['Center_1_x'], x[\"Center_1_y\"]]])).area, axis=1)\r\n except scipy.spatial.qhull.QhullError as e:\r\n print(e)\r\n print('ERROR: For more information, go to https://github.com/sgoldenlab/simba/blob/SimBA_no_TF/docs/FAQ.md#i-get-a-qhull-eg-qh6154-or-6013-error-when-extracting-the-features')\r\n\r\n csv_df['Mouse_1_poly_area'] = csv_df.eval('Mouse_1_poly_area / @currPixPerMM')\r\n\r\n try:\r\n csv_df['Mouse_2_poly_area'] = csv_df.apply(lambda x: ConvexHull(np.array(\r\n [[x['Ear_left_2_x'], x[\"Ear_left_2_y\"]],\r\n [x['Ear_right_2_x'], x[\"Ear_right_2_y\"]],\r\n [x['Nose_2_x'], x[\"Nose_2_y\"]],\r\n [x['Lat_left_2_x'], x[\"Lat_left_2_y\"]], \\\r\n [x['Lat_right_2_x'], x[\"Lat_right_2_y\"]],\r\n [x['Tail_base_2_x'], x[\"Tail_base_2_y\"]],\r\n [x['Center_2_x'], x[\"Center_2_y\"]]])).area, axis=1)\r\n except scipy.spatial.qhull.QhullError as e:\r\n print(e)\r\n print('ERROR: For more information, check https://github.com/sgoldenlab/simba/blob/SimBA_no_TF/docs/FAQ.md#i-get-a-qhull-eg-qh6154-or-6013-error-when-extracting-the-features')\r\n\r\n ########### CREATE SHIFTED DATAFRAME FOR DISTANCE CALCULATIONS ###########################################\r\n csv_df_shifted = csv_df.shift(periods=1)\r\n csv_df_shifted = csv_df_shifted.rename(\r\n columns={'Ear_left_1_x': 'Ear_left_1_x_shifted', 'Ear_left_1_y': 'Ear_left_1_y_shifted',\r\n 'Ear_left_1_p': 'Ear_left_1_p_shifted', 'Ear_right_1_x': 'Ear_right_1_x_shifted', \\\r\n 'Ear_right_1_y': 'Ear_right_1_y_shifted', 'Ear_right_1_p': 'Ear_right_1_p_shifted',\r\n 'Nose_1_x': 'Nose_1_x_shifted', 'Nose_1_y': 'Nose_1_y_shifted', \\\r\n 'Nose_1_p': 'Nose_1_p_shifted', 'Center_1_x': 'Center_1_x_shifted',\r\n 'Center_1_y': 'Center_1_y_shifted', 'Center_1_p': 'Center_1_p_shifted', 'Lat_left_1_x': \\\r\n 'Lat_left_1_x_shifted', 'Lat_left_1_y': 'Lat_left_1_y_shifted',\r\n 'Lat_left_1_p': 'Lat_left_1_p_shifted', 'Lat_right_1_x': 'Lat_right_1_x_shifted',\r\n 'Lat_right_1_y': 'Lat_right_1_y_shifted', \\\r\n 'Lat_right_1_p': 'Lat_right_1_p_shifted', 'Tail_base_1_x': 'Tail_base_1_x_shifted',\r\n 'Tail_base_1_y': 'Tail_base_1_y_shifted', \\\r\n 'Tail_base_1_p': 'Tail_base_1_p_shifted', 'Tail_end_1_x': 'Tail_end_1_x_shifted',\r\n 'Tail_end_1_y': 'Tail_end_1_y_shifted', 'Tail_end_1_p': 'Tail_end_1_p_shifted',\r\n 'Ear_left_2_x': 'Ear_left_2_x_shifted', 'Ear_left_2_y': 'Ear_left_2_y_shifted',\r\n 'Ear_left_2_p': 'Ear_left_2_p_shifted', 'Ear_right_2_x': 'Ear_right_2_x_shifted', \\\r\n 'Ear_right_2_y': 'Ear_right_2_y_shifted', 'Ear_right_2_p': 'Ear_right_2_p_shifted',\r\n 'Nose_2_x': 'Nose_2_x_shifted', 'Nose_2_y': 'Nose_2_y_shifted', \\\r\n 'Nose_2_p': 'Nose_2_p_shifted', 'Center_2_x': 'Center_2_x_shifted',\r\n 'Center_2_y': 'Center_2_y_shifted', 'Center_2_p': 'Center_2_p_shifted', 'Lat_left_2_x': \\\r\n 'Lat_left_2_x_shifted', 'Lat_left_2_y': 'Lat_left_2_y_shifted',\r\n 'Lat_left_2_p': 'Lat_left_2_p_shifted', 'Lat_right_2_x': 'Lat_right_2_x_shifted',\r\n 'Lat_right_2_y': 'Lat_right_2_y_shifted', \\\r\n 'Lat_right_2_p': 'Lat_right_2_p_shifted', 'Tail_base_2_x': 'Tail_base_2_x_shifted',\r\n 'Tail_base_2_y': 'Tail_base_2_y_shifted', \\\r\n 'Tail_base_2_p': 'Tail_base_2_p_shifted', 'Tail_end_2_x': 'Tail_end_2_x_shifted',\r\n 'Tail_end_2_y': 'Tail_end_2_y_shifted', 'Tail_end_2_p': 'Tail_end_2_p_shifted',\r\n 'Mouse_1_poly_area': 'Mouse_1_poly_area_shifted',\r\n 'Mouse_2_poly_area': 'Mouse_2_poly_area_shifted'})\r\n csv_df_combined = pd.concat([csv_df, csv_df_shifted], axis=1, join='inner')\r\n csv_df_combined = csv_df_combined.fillna(0)\r\n csv_df_combined = csv_df_combined.reset_index(drop=True)\r\n\r\n print('Calculating euclidean distances...')\r\n ########### EUCLIDEAN DISTANCES ###########################################\r\n csv_df['Mouse_1_nose_to_tail'] = EuclidianDistCald(csv_df['Nose_1_x'].values, csv_df['Nose_1_y'].values, csv_df['Tail_base_1_x'].values, csv_df['Tail_base_1_y'].values, currPixPerMM)\r\n csv_df['Mouse_2_nose_to_tail'] = EuclidianDistCald(csv_df['Nose_2_x'].values, csv_df['Nose_2_y'].values, csv_df['Tail_base_2_x'].values, csv_df['Tail_base_2_y'].values, currPixPerMM)\r\n csv_df['Mouse_1_width'] = EuclidianDistCald(csv_df['Lat_left_1_x'].values, csv_df['Lat_left_1_y'].values, csv_df['Lat_right_1_x'].values, csv_df['Lat_right_1_y'].values, currPixPerMM)\r\n csv_df['Mouse_2_width'] = EuclidianDistCald(csv_df['Lat_left_2_x'].values, csv_df['Lat_left_2_y'].values, csv_df['Lat_right_2_x'].values, csv_df['Lat_right_2_y'].values, currPixPerMM)\r\n csv_df['Mouse_1_Ear_distance'] = EuclidianDistCald(csv_df['Ear_left_1_x'].values, csv_df['Ear_left_1_y'].values, csv_df['Ear_right_1_x'].values, csv_df['Ear_right_1_y'].values, currPixPerMM)\r\n csv_df['Mouse_2_Ear_distance'] = EuclidianDistCald(csv_df['Ear_left_2_x'].values, csv_df['Ear_left_2_y'].values, csv_df['Ear_right_2_x'].values, csv_df['Ear_right_2_y'].values, currPixPerMM)\r\n csv_df['Mouse_1_Nose_to_centroid'] = EuclidianDistCald(csv_df['Nose_1_x'].values, csv_df['Nose_1_y'].values, csv_df['Center_1_x'].values, csv_df['Center_1_y'].values, currPixPerMM)\r\n csv_df['Mouse_2_Nose_to_centroid'] = EuclidianDistCald(csv_df['Nose_2_x'].values, csv_df['Nose_2_y'].values,csv_df['Center_2_x'].values, csv_df['Center_2_y'].values, currPixPerMM)\r\n csv_df['Mouse_1_Nose_to_lateral_left'] = EuclidianDistCald(csv_df['Nose_1_x'].values, csv_df['Nose_1_y'].values,csv_df['Lat_left_1_x'].values, csv_df['Lat_left_1_y'].values, currPixPerMM)\r\n csv_df['Mouse_2_Nose_to_lateral_left'] = EuclidianDistCald(csv_df['Nose_2_x'].values, csv_df['Nose_2_y'].values,csv_df['Lat_left_2_x'].values, csv_df['Lat_left_2_y'].values, currPixPerMM)\r\n csv_df['Mouse_1_Nose_to_lateral_right'] = EuclidianDistCald(csv_df['Nose_1_x'].values, csv_df['Nose_1_y'].values,csv_df['Lat_right_1_x'].values, csv_df['Lat_right_1_y'].values, currPixPerMM)\r\n csv_df['Mouse_2_Nose_to_lateral_right'] = EuclidianDistCald(csv_df['Nose_2_x'].values, csv_df['Nose_2_y'].values,csv_df['Lat_right_2_x'].values, csv_df['Lat_right_2_y'].values, currPixPerMM)\r\n csv_df['Mouse_1_Centroid_to_lateral_left'] = EuclidianDistCald(csv_df['Center_1_x'].values, csv_df['Center_1_y'].values,csv_df['Lat_left_1_x'].values, csv_df['Lat_left_1_y'].values, currPixPerMM)\r\n csv_df['Mouse_2_Centroid_to_lateral_left'] = EuclidianDistCald(csv_df['Center_2_x'].values, csv_df['Center_2_y'].values,csv_df['Lat_left_2_x'].values, csv_df['Lat_left_2_y'].values, currPixPerMM)\r\n csv_df['Mouse_1_Centroid_to_lateral_right'] = EuclidianDistCald(csv_df['Center_1_x'].values, csv_df['Center_1_y'].values,csv_df['Lat_right_1_x'].values, csv_df['Lat_right_1_y'].values, currPixPerMM)\r\n csv_df['Mouse_2_Centroid_to_lateral_right'] = EuclidianDistCald(csv_df['Center_2_x'].values, csv_df['Center_2_y'].values,csv_df['Lat_right_2_x'].values, csv_df['Lat_right_2_y'].values, currPixPerMM)\r\n csv_df['Centroid_distance'] = EuclidianDistCald(csv_df['Center_2_x'].values, csv_df['Center_2_y'].values,csv_df['Center_1_x'].values, csv_df['Center_1_y'].values, currPixPerMM)\r\n csv_df['Nose_to_nose_distance'] = EuclidianDistCald(csv_df['Nose_1_x'].values, csv_df['Nose_1_y'].values,csv_df['Nose_2_x'].values, csv_df['Nose_2_y'].values, currPixPerMM)\r\n csv_df['M1_Nose_to_M2_lat_left'] = EuclidianDistCald(csv_df['Nose_1_x'].values, csv_df['Nose_1_y'].values,csv_df['Lat_left_2_x'].values, csv_df['Lat_left_2_y'].values, currPixPerMM)\r\n csv_df['M1_Nose_to_M2_lat_right'] = EuclidianDistCald(csv_df['Nose_1_x'].values, csv_df['Nose_1_y'].values,csv_df['Lat_right_2_x'].values, csv_df['Lat_right_2_y'].values, currPixPerMM)\r\n csv_df['M2_Nose_to_M1_lat_left'] = EuclidianDistCald(csv_df['Nose_2_x'].values, csv_df['Nose_2_y'].values,csv_df['Lat_left_1_x'].values, csv_df['Lat_left_1_y'].values, currPixPerMM)\r\n csv_df['M2_Nose_to_M1_lat_right'] = EuclidianDistCald(csv_df['Nose_2_x'].values, csv_df['Nose_2_y'].values,csv_df['Lat_right_1_x'].values, csv_df['Lat_right_1_y'].values, currPixPerMM)\r\n csv_df['M1_Nose_to_M2_tail_base'] = EuclidianDistCald(csv_df['Nose_1_x'].values, csv_df['Nose_1_y'].values,csv_df['Tail_base_2_x'].values, csv_df['Tail_base_2_y'].values, currPixPerMM)\r\n csv_df['M2_Nose_to_M1_tail_base'] = EuclidianDistCald(csv_df['Nose_2_x'].values, csv_df['Nose_2_y'].values,csv_df['Tail_base_1_x'].values, csv_df['Tail_base_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_1_centroid'] = EuclidianDistCald(csv_df_combined['Center_1_x_shifted'].values, csv_df_combined['Center_1_y_shifted'].values,csv_df_combined['Center_1_x'].values, csv_df_combined['Center_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_2_centroid'] = EuclidianDistCald(csv_df_combined['Center_2_x_shifted'].values, csv_df_combined['Center_2_y_shifted'].values,csv_df_combined['Center_2_x'].values, csv_df_combined['Center_2_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_1_nose'] = EuclidianDistCald(csv_df_combined['Nose_1_x_shifted'].values, csv_df_combined['Nose_1_y_shifted'].values,csv_df_combined['Nose_1_x'].values, csv_df_combined['Nose_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_2_nose'] = EuclidianDistCald(csv_df_combined['Nose_2_x_shifted'].values, csv_df_combined['Nose_2_y_shifted'].values,csv_df_combined['Nose_2_x'].values, csv_df_combined['Nose_2_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_1_tail_base'] = EuclidianDistCald(csv_df_combined['Tail_base_1_x_shifted'].values, csv_df_combined['Tail_base_1_y_shifted'].values,csv_df_combined['Tail_base_1_x'].values, csv_df_combined['Tail_base_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_2_tail_base'] = EuclidianDistCald(csv_df_combined['Tail_base_2_x_shifted'].values, csv_df_combined['Tail_base_2_y_shifted'].values,csv_df_combined['Tail_base_2_x'].values, csv_df_combined['Tail_base_2_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_1_tail_end'] = EuclidianDistCald(csv_df_combined['Tail_end_1_x_shifted'].values, csv_df_combined['Tail_end_1_y_shifted'].values,csv_df_combined['Tail_end_1_x'].values, csv_df_combined['Tail_end_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_2_tail_end'] = EuclidianDistCald(csv_df_combined['Tail_end_2_x_shifted'].values, csv_df_combined['Tail_end_2_y_shifted'].values,csv_df_combined['Tail_end_2_x'].values, csv_df_combined['Tail_end_2_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_1_left_ear'] = EuclidianDistCald(csv_df_combined['Ear_left_1_x_shifted'].values, csv_df_combined['Ear_left_1_y_shifted'].values,csv_df_combined['Ear_left_1_x'].values, csv_df_combined['Ear_left_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_2_left_ear'] = EuclidianDistCald(csv_df_combined['Ear_left_2_x_shifted'].values, csv_df_combined['Ear_left_2_y_shifted'].values,csv_df_combined['Ear_left_2_x'].values, csv_df_combined['Ear_left_2_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_1_right_ear'] = EuclidianDistCald(csv_df_combined['Ear_right_1_x_shifted'].values, csv_df_combined['Ear_right_1_y_shifted'].values,csv_df_combined['Ear_right_1_x'].values, csv_df_combined['Ear_right_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_2_right_ear'] = EuclidianDistCald(csv_df_combined['Ear_right_2_x_shifted'].values, csv_df_combined['Ear_right_2_y_shifted'].values,csv_df_combined['Ear_right_2_x'].values, csv_df_combined['Ear_right_2_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_1_lateral_left'] = EuclidianDistCald(csv_df_combined['Lat_left_1_x_shifted'].values, csv_df_combined['Lat_left_1_y_shifted'].values,csv_df_combined['Lat_left_1_x'].values, csv_df_combined['Lat_left_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_2_lateral_left'] = EuclidianDistCald(csv_df_combined['Lat_left_2_x_shifted'].values, csv_df_combined['Lat_left_2_y_shifted'].values,csv_df_combined['Lat_left_2_x'].values, csv_df_combined['Lat_left_2_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_1_lateral_right'] = EuclidianDistCald(csv_df_combined['Lat_right_1_x_shifted'].values, csv_df_combined['Lat_right_1_y_shifted'].values,csv_df_combined['Lat_right_1_x'].values, csv_df_combined['Lat_right_1_y'].values, currPixPerMM)\r\n csv_df['Movement_mouse_2_lateral_right'] = EuclidianDistCald(csv_df_combined['Lat_right_2_x_shifted'].values, csv_df_combined['Lat_right_2_y_shifted'].values,csv_df_combined['Lat_right_2_x'].values, csv_df_combined['Lat_right_2_y'].values, currPixPerMM)\r\n csv_df['Mouse_1_polygon_size_change'] = pd.eval(\"csv_df_combined.Mouse_1_poly_area_shifted - csv_df_combined.Mouse_1_poly_area\")\r\n csv_df['Mouse_2_polygon_size_change'] = pd.eval(\"csv_df_combined.Mouse_2_poly_area_shifted - csv_df_combined.Mouse_2_poly_area\")\r\n\r\n print('Calculating hull variables...')\r\n ########### HULL - EUCLIDEAN DISTANCES ###########################################\r\n for index, row in csv_df.iterrows():\r\n M1_np_array = np.array(\r\n [[row['Ear_left_1_x'], row[\"Ear_left_1_y\"]], [row['Ear_right_1_x'], row[\"Ear_right_1_y\"]],\r\n [row['Nose_1_x'], row[\"Nose_1_y\"]], [row['Center_1_x'], row[\"Center_1_y\"]],\r\n [row['Lat_left_1_x'], row[\"Lat_left_1_y\"]], [row['Lat_right_1_x'], row[\"Lat_right_1_y\"]],\r\n [row['Tail_base_1_x'], row[\"Tail_base_1_y\"]]]).astype(int)\r\n M2_np_array = np.array(\r\n [[row['Ear_left_2_x'], row[\"Ear_left_2_y\"]], [row['Ear_right_2_x'], row[\"Ear_right_2_y\"]],\r\n [row['Nose_2_x'], row[\"Nose_2_y\"]], [row['Center_2_x'], row[\"Center_2_y\"]],\r\n [row['Lat_left_2_x'], row[\"Lat_left_2_y\"]], [row['Lat_right_2_x'], row[\"Lat_right_2_y\"]],\r\n [row['Tail_base_2_x'], row[\"Tail_base_2_y\"]]]).astype(int)\r\n M1_dist_euclidean = scipy.spatial.distance.cdist(M1_np_array, M1_np_array, metric='euclidean')\r\n M1_dist_euclidean = M1_dist_euclidean[M1_dist_euclidean != 0]\r\n M1_hull_large_euclidean = np.amax(M1_dist_euclidean)\r\n M1_hull_small_euclidean = np.min(M1_dist_euclidean)\r\n M1_hull_mean_euclidean = np.mean(M1_dist_euclidean)\r\n M1_hull_sum_euclidean = np.sum(M1_dist_euclidean)\r\n M1_hull_large_euclidean_list.append(M1_hull_large_euclidean)\r\n M1_hull_small_euclidean_list.append(M1_hull_small_euclidean)\r\n M1_hull_mean_euclidean_list.append(M1_hull_mean_euclidean)\r\n M1_hull_sum_euclidean_list.append(M1_hull_sum_euclidean)\r\n M2_dist_euclidean = scipy.spatial.distance.cdist(M2_np_array, M2_np_array, metric='euclidean')\r\n M2_dist_euclidean = M2_dist_euclidean[M2_dist_euclidean != 0]\r\n M2_hull_large_euclidean = np.amax(M2_dist_euclidean)\r\n M2_hull_small_euclidean = np.min(M2_dist_euclidean)\r\n M2_hull_mean_euclidean = np.mean(M2_dist_euclidean)\r\n M2_hull_sum_euclidean = np.sum(M2_dist_euclidean)\r\n M2_hull_large_euclidean_list.append(M2_hull_large_euclidean)\r\n M2_hull_small_euclidean_list.append(M2_hull_small_euclidean)\r\n M2_hull_mean_euclidean_list.append(M2_hull_mean_euclidean)\r\n M2_hull_sum_euclidean_list.append(M2_hull_sum_euclidean)\r\n csv_df['M1_largest_euclidean_distance_hull'] = list(map(lambda x: x / currPixPerMM, M1_hull_large_euclidean_list))\r\n csv_df['M1_smallest_euclidean_distance_hull'] = list(map(lambda x: x / currPixPerMM, M1_hull_small_euclidean_list))\r\n csv_df['M1_mean_euclidean_distance_hull'] = list(map(lambda x: x / currPixPerMM, M1_hull_mean_euclidean_list))\r\n csv_df['M1_sum_euclidean_distance_hull'] = list(map(lambda x: x / currPixPerMM, M1_hull_sum_euclidean_list))\r\n csv_df['M2_largest_euclidean_distance_hull'] = list(map(lambda x: x / currPixPerMM, M2_hull_large_euclidean_list))\r\n csv_df['M2_smallest_euclidean_distance_hull'] = list(map(lambda x: x / currPixPerMM, M2_hull_small_euclidean_list))\r\n csv_df['M2_mean_euclidean_distance_hull'] = list(map(lambda x: x / currPixPerMM, M2_hull_mean_euclidean_list))\r\n csv_df['M2_sum_euclidean_distance_hull'] = list(map(lambda x: x / currPixPerMM, M2_hull_sum_euclidean_list))\r\n csv_df['Sum_euclidean_distance_hull_M1_M2'] = (csv_df['M1_sum_euclidean_distance_hull'] + csv_df['M2_sum_euclidean_distance_hull'])\r\n\r\n\r\n ########### COLLAPSED MEASURES ###########################################\r\n csv_df['Total_movement_centroids'] = csv_df.eval(\"Movement_mouse_1_centroid + Movement_mouse_2_centroid\")\r\n csv_df['Total_movement_tail_ends'] = csv_df.eval('Movement_mouse_1_tail_end + Movement_mouse_2_tail_end')\r\n csv_df['Total_movement_all_bodyparts_M1'] = csv_df.eval('Movement_mouse_1_nose + Movement_mouse_1_tail_end + Movement_mouse_1_tail_base + Movement_mouse_1_left_ear + Movement_mouse_1_right_ear + Movement_mouse_1_lateral_left + Movement_mouse_1_lateral_right')\r\n csv_df['Total_movement_all_bodyparts_M2'] = csv_df.eval('Movement_mouse_2_nose + Movement_mouse_2_tail_end + Movement_mouse_2_tail_base + Movement_mouse_2_left_ear + Movement_mouse_2_right_ear + Movement_mouse_2_lateral_left + Movement_mouse_2_lateral_right')\r\n csv_df['Total_movement_all_bodyparts_both_mice'] = csv_df.eval('Total_movement_all_bodyparts_M1 + Total_movement_all_bodyparts_M2')\r\n\r\n ########### CALC ROLLING WINDOWS MEDIANS AND MEANS ###########################################\r\n print('Calculating rolling windows: medians, medians, and sums...')\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Sum_euclid_distances_hull_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Sum_euclidean_distance_hull_M1_M2'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Sum_euclid_distances_hull_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Sum_euclidean_distance_hull_M1_M2'].rolling(roll_windows[i],\r\n min_periods=1).mean()\r\n currentColName = 'Sum_euclid_distances_hull_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Sum_euclidean_distance_hull_M1_M2'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Movement_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_centroids'].rolling(roll_windows[i], min_periods=1).median()\r\n currentColName = 'Movement_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_centroids'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Movement_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_centroids'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Distance_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Centroid_distance'].rolling(roll_windows[i], min_periods=1).median()\r\n currentColName = 'Distance_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Centroid_distance'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Distance_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Centroid_distance'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_width_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Mouse_1_width'].rolling(roll_windows[i], min_periods=1).median()\r\n currentColName = 'Mouse1_width_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Mouse_1_width'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Mouse1_width_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Mouse_1_width'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse2_width_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Mouse_2_width'].rolling(roll_windows[i], min_periods=1).median()\r\n currentColName = 'Mouse2_width_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Mouse_2_width'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Mouse2_width_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Mouse_2_width'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_mean_euclid_distances_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_mean_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Mouse1_mean_euclid_distances_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_mean_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).mean()\r\n currentColName = 'Mouse1_mean_euclid_distances_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_mean_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse2_mean_euclid_distances_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_mean_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Mouse2_mean_euclid_distances_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_mean_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).mean()\r\n currentColName = 'Mouse2_mean_euclid_distances_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_mean_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_smallest_euclid_distances_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_smallest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Mouse1_smallest_euclid_distances_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_smallest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).mean()\r\n currentColName = 'Mouse1_smallest_euclid_distances_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_smallest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse2_smallest_euclid_distances_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_smallest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Mouse2_smallest_euclid_distances_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_smallest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).mean()\r\n currentColName = 'Mouse2_smallest_euclid_distances_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_smallest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_largest_euclid_distances_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_largest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Mouse1_largest_euclid_distances_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_largest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).mean()\r\n currentColName = 'Mouse1_largest_euclid_distances_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M1_largest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse2_largest_euclid_distances_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_largest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Mouse2_largest_euclid_distances_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_largest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).mean()\r\n currentColName = 'Mouse2_largest_euclid_distances_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['M2_largest_euclidean_distance_hull'].rolling(roll_windows[i],\r\n min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Total_movement_all_bodyparts_both_mice_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_all_bodyparts_both_mice'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Total_movement_all_bodyparts_both_mice_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_all_bodyparts_both_mice'].rolling(roll_windows[i],\r\n min_periods=1).mean()\r\n currentColName = 'Total_movement_all_bodyparts_both_mice_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_all_bodyparts_both_mice'].rolling(roll_windows[i],\r\n min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Total_movement_centroids_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_centroids'].rolling(roll_windows[i], min_periods=1).median()\r\n currentColName = 'Total_movement_centroids_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_centroids'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Total_movement_centroids_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_movement_centroids'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Tail_base_movement_M1_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_tail_base'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Tail_base_movement_M1_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_tail_base'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Tail_base_movement_M1_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_tail_base'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Tail_base_movement_M2_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_tail_base'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Tail_base_movement_M2_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_tail_base'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Tail_base_movement_M2_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_tail_base'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Centroid_movement_M1_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_centroid'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Centroid_movement_M1_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_centroid'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Centroid_movement_M1_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_centroid'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Centroid_movement_M2_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_centroid'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Centroid_movement_M2_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_centroid'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Centroid_movement_M2_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_centroid'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Tail_end_movement_M1_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_tail_end'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Tail_end_movement_M1_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_tail_end'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Tail_end_movement_M1_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_tail_end'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Tail_end_movement_M2_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_tail_end'].rolling(roll_windows[i],\r\n min_periods=1).median()\r\n currentColName = 'Tail_end_movement_M2_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_tail_end'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Tail_end_movement_M2_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_tail_end'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Nose_movement_M1_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_nose'].rolling(roll_windows[i], min_periods=1).median()\r\n currentColName = 'Nose_movement_M1_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_nose'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Nose_movement_M1_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_1_nose'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Nose_movement_M2_median_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_nose'].rolling(roll_windows[i], min_periods=1).median()\r\n currentColName = 'Nose_movement_M2_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_nose'].rolling(roll_windows[i], min_periods=1).mean()\r\n currentColName = 'Nose_movement_M2_sum_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Movement_mouse_2_nose'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n ########### BODY PARTS RELATIVE TO EACH OTHER ##################\r\n csv_df['Tail_end_relative_to_tail_base_centroid_nose'] = csv_df['Movement_mouse_1_tail_end'] - (\r\n csv_df['Movement_mouse_1_tail_base'] + csv_df['Movement_mouse_1_centroid'] + csv_df[\r\n 'Movement_mouse_1_nose'])\r\n for i in range(len(roll_windows_values)):\r\n currentColName_M1 = 'Tail_end_relative_to_tail_base_centroid_nose_M1_' + str(roll_windows_values[i])\r\n tail_end_col_name = 'Tail_end_movement_M1_mean_' + str(roll_windows_values[i])\r\n tail_base_col_name = 'Tail_base_movement_M1_mean_' + str(roll_windows_values[i])\r\n centroid_col_name = 'Centroid_movement_M1_mean_' + str(roll_windows_values[i])\r\n nose_col_name = 'Nose_movement_M1_mean_' + str(roll_windows_values[i])\r\n currentColName_M2 = 'Tail_end_relative_to_tail_base_centroid_nose_M2_mean_' + str(roll_windows_values[i])\r\n tail_end_col_name_M2 = 'Tail_end_movement_M2_mean_' + str(roll_windows_values[i])\r\n tail_base_col_name_M2 = 'Tail_base_movement_M2_mean_' + str(roll_windows_values[i])\r\n centroid_col_name_M2 = 'Centroid_movement_M2_mean_' + str(roll_windows_values[i])\r\n nose_col_name_M2 = 'Nose_movement_M2_mean_' + str(roll_windows_values[i])\r\n csv_df[currentColName_M1] = csv_df[tail_end_col_name] - (\r\n csv_df[tail_base_col_name] + csv_df[centroid_col_name] + csv_df[nose_col_name])\r\n csv_df[currentColName_M2] = csv_df[tail_end_col_name_M2] - (\r\n csv_df[tail_base_col_name_M2] + csv_df[centroid_col_name_M2] + csv_df[nose_col_name_M2])\r\n\r\n ########### ANGLES ###########################################\r\n print('Calculating angles...')\r\n csv_df['Mouse_1_angle'] = csv_df.apply(\r\n lambda x: angle3pt(x['Nose_1_x'], x['Nose_1_y'], x['Center_1_x'], x['Center_1_y'], x['Tail_base_1_x'],\r\n x['Tail_base_1_y']), axis=1)\r\n csv_df['Mouse_2_angle'] = csv_df.apply(\r\n lambda x: angle3pt(x['Nose_2_x'], x['Nose_2_y'], x['Center_2_x'], x['Center_2_y'], x['Tail_base_2_x'],\r\n x['Tail_base_2_y']), axis=1)\r\n csv_df['Total_angle_both_mice'] = csv_df['Mouse_1_angle'] + csv_df['Mouse_2_angle']\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Total_angle_both_mice_' + str(roll_windows_values[i])\r\n csv_df[currentColName] = csv_df['Total_angle_both_mice'].rolling(roll_windows[i], min_periods=1).sum()\r\n\r\n ########### DEVIATIONS ###########################################\r\n print('Calculating deviations...')\r\n csv_df['Total_movement_all_bodyparts_both_mice_deviation'] = csv_df.eval('Total_movement_all_bodyparts_both_mice.mean() - Total_movement_all_bodyparts_both_mice')\r\n csv_df['Sum_euclid_distances_hull_deviation'] = csv_df.eval('Sum_euclidean_distance_hull_M1_M2.mean() - Sum_euclidean_distance_hull_M1_M2')\r\n csv_df['M1_smallest_euclid_distances_hull_deviation'] = csv_df.eval('M1_smallest_euclidean_distance_hull.mean() - M1_smallest_euclidean_distance_hull')\r\n csv_df['M1_largest_euclid_distances_hull_deviation'] = csv_df.eval('M1_largest_euclidean_distance_hull.mean() - M1_largest_euclidean_distance_hull')\r\n csv_df['M1_mean_euclid_distances_hull_deviation'] = csv_df.eval('M1_mean_euclidean_distance_hull.mean() - M1_mean_euclidean_distance_hull')\r\n csv_df['Centroid_distance_deviation'] = csv_df.eval('Centroid_distance.mean() - Centroid_distance')\r\n csv_df['Total_angle_both_mice_deviation'] = csv_df.eval('Total_angle_both_mice - Total_angle_both_mice')\r\n csv_df['Movement_mouse_1_deviation_centroid'] = csv_df.eval('Movement_mouse_1_centroid.mean() - Movement_mouse_1_centroid')\r\n csv_df['Movement_mouse_2_deviation_centroid'] = csv_df.eval('Movement_mouse_2_centroid.mean() - Movement_mouse_2_centroid')\r\n csv_df['Mouse_1_polygon_deviation'] = csv_df.eval('Mouse_1_poly_area.mean() - Mouse_1_poly_area')\r\n csv_df['Mouse_2_polygon_deviation'] = csv_df.eval('Mouse_2_poly_area.mean() - Mouse_2_poly_area')\r\n\r\n for i in roll_windows_values:\r\n currentColName = 'Total_movement_all_bodyparts_both_mice_mean_' + str(i)\r\n currentDev_colName = currentColName + '_deviation'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Sum_euclid_distances_hull_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_deviation'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_smallest_euclid_distances_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_deviation'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_largest_euclid_distances_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_deviation'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_mean_euclid_distances_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_deviation'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Movement_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_deviation'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Distance_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_deviation'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Total_angle_both_mice_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_deviation'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n ########### PERCENTILE RANK ###########################################\r\n print('Calculating percentile ranks...')\r\n csv_df['Movement_percentile_rank'] = csv_df['Total_movement_centroids'].rank(pct=True)\r\n csv_df['Distance_percentile_rank'] = csv_df['Centroid_distance'].rank(pct=True)\r\n csv_df['Movement_mouse_1_percentile_rank'] = csv_df['Movement_mouse_1_centroid'].rank(pct=True)\r\n csv_df['Movement_mouse_2_percentile_rank'] = csv_df['Movement_mouse_1_centroid'].rank(pct=True)\r\n csv_df['Movement_mouse_1_deviation_percentile_rank'] = csv_df['Movement_mouse_1_deviation_centroid'].rank(\r\n pct=True)\r\n csv_df['Movement_mouse_2_deviation_percentile_rank'] = csv_df['Movement_mouse_2_deviation_centroid'].rank(\r\n pct=True)\r\n csv_df['Centroid_distance_percentile_rank'] = csv_df['Centroid_distance'].rank(pct=True)\r\n csv_df['Centroid_distance_deviation_percentile_rank'] = csv_df['Centroid_distance_deviation'].rank(pct=True)\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Total_movement_all_bodyparts_both_mice_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_percentile_rank'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Sum_euclid_distances_hull_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_percentile_rank'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_mean_euclid_distances_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_percentile_rank'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_smallest_euclid_distances_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_percentile_rank'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Mouse1_largest_euclid_distances_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_percentile_rank'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Movement_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_percentile_rank'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n for i in range(len(roll_windows_values)):\r\n currentColName = 'Distance_mean_' + str(roll_windows_values[i])\r\n currentDev_colName = currentColName + '_percentile_rank'\r\n csv_df[currentDev_colName] = (csv_df[currentColName].mean() - csv_df[currentColName])\r\n\r\n ########### CALCULATE STRAIGHTNESS OF POLYLINE PATH: tortuosity ###########################################\r\n print('Calculating path tortuosities...')\r\n as_strided = np.lib.stride_tricks.as_strided\r\n win_size = 3\r\n centroidList_Mouse1_x = as_strided(csv_df.Center_1_x, (len(csv_df) - (win_size - 1), win_size),\r\n (csv_df.Center_1_x.values.strides * 2))\r\n centroidList_Mouse1_y = as_strided(csv_df.Center_1_y, (len(csv_df) - (win_size - 1), win_size),\r\n (csv_df.Center_1_y.values.strides * 2))\r\n centroidList_Mouse2_x = as_strided(csv_df.Center_2_x, (len(csv_df) - (win_size - 1), win_size),\r\n (csv_df.Center_2_x.values.strides * 2))\r\n centroidList_Mouse2_y = as_strided(csv_df.Center_2_y, (len(csv_df) - (win_size - 1), win_size),\r\n (csv_df.Center_2_y.values.strides * 2))\r\n\r\n for k in range(len(roll_windows_values)):\r\n start = 0\r\n end = start + int(roll_windows_values[k])\r\n tortuosity_M1 = []\r\n tortuosity_M2 = []\r\n for y in range(len(csv_df)):\r\n tortuosity_List_M1 = []\r\n tortuosity_List_M2 = []\r\n CurrCentroidList_Mouse1_x = centroidList_Mouse1_x[start:end]\r\n CurrCentroidList_Mouse1_y = centroidList_Mouse1_y[start:end]\r\n CurrCentroidList_Mouse2_x = centroidList_Mouse2_x[start:end]\r\n CurrCentroidList_Mouse2_y = centroidList_Mouse2_y[start:end]\r\n for i in range(len(CurrCentroidList_Mouse1_x)):\r\n currMovementAngle_mouse1 = (\r\n angle3pt(CurrCentroidList_Mouse1_x[i][0], CurrCentroidList_Mouse1_y[i][0],\r\n CurrCentroidList_Mouse1_x[i][1], CurrCentroidList_Mouse1_y[i][1],\r\n CurrCentroidList_Mouse1_x[i][2], CurrCentroidList_Mouse1_y[i][2]))\r\n currMovementAngle_mouse2 = (\r\n angle3pt(CurrCentroidList_Mouse2_x[i][0], CurrCentroidList_Mouse2_y[i][0],\r\n CurrCentroidList_Mouse2_x[i][1], CurrCentroidList_Mouse2_y[i][1],\r\n CurrCentroidList_Mouse2_x[i][2], CurrCentroidList_Mouse2_y[i][2]))\r\n tortuosity_List_M1.append(currMovementAngle_mouse1)\r\n tortuosity_List_M2.append(currMovementAngle_mouse2)\r\n tortuosity_M1.append(sum(tortuosity_List_M1) / (2 * math.pi))\r\n tortuosity_M2.append(sum(tortuosity_List_M2) / (2 * math.pi))\r\n start += 1\r\n end += 1\r\n currentColName1 = str('Tortuosity_Mouse1_') + str(roll_windows_values[k])\r\n #currentColName2 = str('Tortuosity_Mouse2_') + str(roll_windows_values[k])\r\n csv_df[currentColName1] = tortuosity_M1\r\n #csv_df[currentColName2] = tortuosity_M2\r\n\r\n ########### CALC THE NUMBER OF LOW PROBABILITY DETECTIONS & TOTAL PROBABILITY VALUE FOR ROW###########################################\r\n print('Calculating pose probability scores...')\r\n csv_df['Sum_probabilities'] = csv_df.eval('Ear_left_1_p + Ear_right_1_p + Nose_1_p + Center_1_p + Lat_left_1_p + Lat_right_1_p + Tail_base_1_p + Tail_end_1_p + Ear_left_2_p + Ear_right_2_p + Nose_2_p + Center_2_p + Lat_left_2_p + Lat_right_2_p + Tail_base_2_p + Tail_end_2_p')\r\n csv_df['Sum_probabilities_deviation'] = csv_df.eval('Sum_probabilities.mean() - Sum_probabilities')\r\n csv_df['Sum_probabilities_deviation_percentile_rank'] = csv_df['Sum_probabilities_deviation'].rank(pct=True)\r\n csv_df['Sum_probabilities_percentile_rank'] = csv_df['Sum_probabilities_deviation_percentile_rank'].rank(pct=True)\r\n csv_df_probability = csv_df.filter(\r\n ['Ear_left_1_p', 'Ear_right_1_p', 'Nose_1_p', 'Center_1_p', 'Lat_left_1_p', 'Lat_right_1_p',\r\n 'Tail_base_1_p', 'Tail_end_1_p', 'Ear_left_2_p', 'Ear_right_2_p', 'Nose_2_p', 'Center_2_p', 'Lat_left_2_p',\r\n 'Lat_right_2_p', 'Tail_base_2_p', 'Tail_end_2_p'])\r\n values_in_range_min, values_in_range_max = 0.0, 0.1\r\n csv_df[\"Low_prob_detections_0.1\"] = csv_df_probability.apply(func=lambda row: count_values_in_range(row, values_in_range_min, values_in_range_max), axis=1)\r\n values_in_range_min, values_in_range_max = 0.000000000, 0.5\r\n csv_df[\"Low_prob_detections_0.5\"] = csv_df_probability.apply(\r\n func=lambda row: count_values_in_range(row, values_in_range_min, values_in_range_max), axis=1)\r\n values_in_range_min, values_in_range_max = 0.000000000, 0.75\r\n csv_df[\"Low_prob_detections_0.75\"] = csv_df_probability.apply(\r\n func=lambda row: count_values_in_range(row, values_in_range_min, values_in_range_max), axis=1)\r\n\r\n ########### DROP COORDINATE COLUMNS ###########################################\r\n csv_df = csv_df.reset_index(drop=True)\r\n csv_df = csv_df.fillna(0)\r\n csv_df = csv_df.drop(columns=['index'], axis=1, errors='ignore')\r\n fileName = os.path.basename(currentFile)\r\n saveFN = os.path.join(csv_dir_out, fileName)\r\n save_df(csv_df, wfileType, saveFN)\r\n print('Feature extraction complete for ' + '\"' + str(currVidName) + '\".')\r\n print('All feature extraction complete.')",
"import pandas as pd\r\nimport os\r\nfrom configparser import ConfigParser\r\nfrom datetime import datetime\r\nimport numpy as np\r\n\r\n\r\ndef analyze_process_data_log(configini,chosenlist):\r\n\r\n dateTime = datetime.now().strftime('%Y%m%d%H%M%S')\r\n config = ConfigParser()\r\n configFile = str(configini)\r\n config.read(configFile)\r\n csv_dir = config.get('General settings', 'csv_path')\r\n csv_dir_in = os.path.join(csv_dir, 'machine_results')\r\n no_targets = config.getint('SML settings', 'No_targets')\r\n boutEnd = 0\r\n boutEnd_list = [0]\r\n boutStart_list = []\r\n filesFound = []\r\n target_names = []\r\n vidInfPath = config.get('General settings', 'project_path')\r\n vidInfPath = os.path.join(vidInfPath, 'logs')\r\n vidInfPath = os.path.join(vidInfPath, 'video_info.csv')\r\n vidinfDf = pd.read_csv(vidInfPath)\r\n loop = 0\r\n loopy = 0\r\n\r\n ########### FIND CSV FILES ###########\r\n for i in os.listdir(csv_dir_in):\r\n if i.endswith(\".csv\"):\r\n file = os.path.join(csv_dir_in, i)\r\n filesFound.append(file)\r\n\r\n ########### GET TARGET COLUMN NAMES ###########\r\n for ff in range(no_targets):\r\n currentModelNames = 'target_name_' + str(ff+1)\r\n currentModelNames = config.get('SML settings', currentModelNames)\r\n target_names.append(currentModelNames)\r\n print('Analyzing ' + str(len(target_names)) + ' classifier result(s) in ' + str(len(filesFound)) + ' video file(s).')\r\n\r\n ########### logfile path ###########\r\n log_fn = 'sklearn_' + str(dateTime) + '.csv'\r\n log_path = config.get('General settings', 'project_path')\r\n log_path = os.path.join(log_path, 'logs')\r\n log_fn = os.path.join(log_path, log_fn)\r\n if not os.path.exists(log_path):\r\n os.makedirs(log_path)\r\n\r\n headers = ['Video']\r\n for i in target_names:\r\n head1 = str(i) + ' events'\r\n head2 = str(i) + ' sum duration (s)'\r\n head3 = str(i) + ' mean duration (s)'\r\n head4 = str(i) + ' median duration (s)'\r\n head5 = str(i) + ' first occurance (s)'\r\n head6 = str(i) + ' mean interval (s)'\r\n head7 = str(i) + ' median interval (s)'\r\n headers.extend([head1, head2, head3, head4, head5, head6, head7])\r\n log_df = pd.DataFrame(columns=headers)\r\n\r\n for i in filesFound:\r\n boutsDf = pd.DataFrame(columns=['Event', 'Start_frame', 'End_frame'])\r\n currentFile = i\r\n currVidName = os.path.basename(currentFile)\r\n currVidName = currVidName.replace('.csv', '')\r\n fps = vidinfDf.loc[vidinfDf['Video'] == currVidName]\r\n try:\r\n fps = int(fps['fps'])\r\n except TypeError:\r\n print('Error: make sure all the videos that are going to be analyzed are represented in the project_folder/logs/video_info.csv file')\r\n loopy+=1\r\n print('Analyzing video ' + str(loopy) + '/' + str(len(filesFound)) + '...')\r\n dataDf = pd.read_csv(currentFile)\r\n dataDf['frames'] = np.arange(len(dataDf))\r\n folderNm = os.path.basename(currentFile)\r\n logFolderNm = str(folderNm.split('.')[0])\r\n for bb in target_names:\r\n currTarget = bb\r\n for indexes, rows in dataDf[dataDf['frames'] >= boutEnd].iterrows():\r\n if rows[currTarget] == 1:\r\n boutStart = rows['frames']\r\n for index, row in dataDf[dataDf['frames'] >= boutStart].iterrows():\r\n if row[currTarget] == 0:\r\n boutEnd = row['frames']\r\n if boutEnd_list[-1] != boutEnd:\r\n boutStart_list.append(boutStart)\r\n boutEnd_list.append(boutEnd)\r\n values = [currTarget, boutStart, boutEnd]\r\n boutsDf.loc[(len(boutsDf))] = values\r\n break\r\n break\r\n boutStart_list = [0]\r\n boutEnd_list = [0]\r\n boutEnd = 0\r\n\r\n #Convert to time\r\n boutsDf['Start_time'] = boutsDf['Start_frame'] / fps\r\n boutsDf['End_time'] = boutsDf['End_frame'] / fps\r\n boutsDf['Bout_time'] = boutsDf['End_time'] - boutsDf['Start_time']\r\n\r\n #record logs\r\n log_list = []\r\n log_list.append(logFolderNm)\r\n for i in target_names:\r\n currDf = boutsDf.loc[boutsDf['Event'] == i]\r\n try:\r\n firstOccur = round(currDf['Start_time'].iloc[0], 4)\r\n except IndexError:\r\n firstOccur = 0\r\n eventNOs = len(currDf)\r\n TotEventDur = round(currDf['Bout_time'].sum(), 4)\r\n try:\r\n MeanEventDur = round(TotEventDur / eventNOs, 4)\r\n except ZeroDivisionError:\r\n MeanEventDur = 0\r\n try:\r\n MedianEventDur = round(currDf['Bout_time'].median(), 10)\r\n\r\n except ZeroDivisionError:\r\n MedianEventDur = 0\r\n currDf_shifted = currDf.shift(periods=-1)\r\n currDf_shifted = currDf_shifted.drop(columns=['Event', 'Start_frame', 'End_frame', 'End_time', 'Bout_time'])\r\n currDf_shifted = currDf_shifted.rename(columns={'Start_time': 'Start_time_shifted'})\r\n currDf_combined = pd.concat([currDf, currDf_shifted], axis=1, join='inner')\r\n currDf_combined['Event_interval'] = currDf_combined['Start_time_shifted'] - currDf_combined['End_time']\r\n meanEventInterval = currDf_combined[\"Event_interval\"].mean()\r\n medianEventInterval = currDf_combined['Event_interval'].median()\r\n log_list.append(eventNOs)\r\n log_list.append(TotEventDur)\r\n log_list.append(MeanEventDur)\r\n log_list.append(MedianEventDur)\r\n log_list.append(firstOccur)\r\n log_list.append(meanEventInterval)\r\n log_list.append(medianEventInterval)\r\n log_df.loc[loop] = log_list\r\n loop += 1\r\n print('File # processed for machine predictions: ' + str(loop) + '/' + str(len(filesFound)))\r\n log_df.fillna(0, inplace=True)\r\n # drop columns not chosen\r\n for i in chosenlist:\r\n log_df = log_df[log_df.columns.drop(list(log_df.filter(regex=str(i))))]\r\n\r\n\r\n log_df.to_csv(log_fn, index=False)\r\n print('All files processed for machine predictions: data file saved @' + str(log_fn))\r\n\r\n\r\n\r\n"
] | [
[
"numpy.sum",
"scipy.spatial.distance.cdist",
"pandas.read_csv",
"numpy.amax",
"pandas.concat",
"numpy.min",
"numpy.sqrt",
"pandas.eval",
"numpy.array",
"numpy.mean"
],
[
"pandas.read_csv",
"pandas.DataFrame",
"pandas.concat"
]
] |
johannbrehmer/rl-6-nimmt | [
"8bc504e0372bb4bc99a3d69e77418991092ffdac"
] | [
"rl_6_nimmt/play.py"
] | [
"import torch\nimport numpy as np\nimport logging\nfrom .env import SechsNimmtEnv\n\nlogger = logging.getLogger(__name__)\n\n\nclass GameSession:\n def __init__(self, *agents, device=torch.device(\"cpu\"), dtype=torch.float):\n \"\"\" Initializes a game session, which consists of an arbitrary number of games between the given agents \"\"\"\n\n self.device = device\n self.dtype = dtype\n self.agents = [agent.to(self.device, self.dtype) for agent in agents]\n self.num_agents = len(agents)\n self.env = SechsNimmtEnv(self.num_agents)\n self.results = [] # List of total scores (negative Hornochsen) for each game\n self.game = 0\n\n self._set_env_player_names()\n\n def play_game(self, render=False):\n \"\"\" Play one game, i.e. until one player hits 66 Hornochsen or whatever it is \"\"\"\n\n states, all_legal_actions = self.env.reset()\n states = self._tensorize(states)\n done = False\n rewards = np.zeros(self.num_agents, dtype=np.int)\n scores = np.zeros(self.num_agents, dtype=np.int)\n\n if render:\n self.env.render()\n\n while not done:\n # Agent turns\n actions, agent_infos = [], []\n for agent, state, legal_actions in zip(self.agents, states, all_legal_actions):\n action, agent_info = agent(state, legal_actions=legal_actions)\n actions.append(int(action))\n agent_infos.append(agent_info)\n # TODO: gently enforce legality of actions by giving a negative reward and asking again\n\n # Environment steps\n (next_states, next_all_legal_actions), next_rewards, done, info = self.env.step(actions)\n next_states = self._tensorize(next_states)\n\n if render:\n self.env.render()\n\n # Learning\n for agent, action, state, next_state, reward, next_reward, agent_info, legal_actions, next_legal_actions, in zip(\n self.agents, actions, states, next_states, rewards, next_rewards, agent_infos, all_legal_actions, next_all_legal_actions\n ):\n agent.learn(\n state=state,\n legal_actions=legal_actions.copy(),\n reward=reward,\n action=action,\n done=done,\n next_state=next_state,\n next_legal_actions=next_legal_actions.copy(),\n next_reward=next_reward,\n num_episode=self.game,\n episode_end=done,\n **agent_info,\n )\n\n scores += np.array(next_rewards)\n states = next_states\n all_legal_actions = next_all_legal_actions\n rewards = next_rewards\n\n self.results.append(scores)\n self.game += 1\n\n def _tensorize(self, inputs):\n return [torch.tensor(input).to(self.device, self.dtype) for input in inputs]\n\n def _set_env_player_names(self):\n names = []\n for agent in self.agents:\n try:\n names.append(agent.__name__)\n except:\n names.append(type(agent).__name__)\n self.env._player_names = names\n"
] | [
[
"numpy.array",
"torch.tensor",
"torch.device",
"numpy.zeros"
]
] |
mrbermell/seed_rl | [
"9562e178fb8c16d2551d9e5d59594a7f908655dd"
] | [
"agents/policy_gradient/modules/generalized_onpolicy_loss.py"
] | [
"# coding=utf-8\n# Copyright 2019 The SEED Authors\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\n\"\"\"Implements a generalized onpolicy loss.\"\"\"\n\nimport abc\nimport inspect\nimport gin\nfrom seed_rl.agents.policy_gradient.modules import logging_module\nimport tensorflow as tf\n\n\[email protected]\nclass GeneralizedOnPolicyLoss(tf.Module, logging_module.LoggingModule):\n \"\"\"TensorFlow module implementing the generalized onpolicy loss.\"\"\"\n\n def __init__(self, agent, reward_normalizer, parametric_action_distribution,\n advantage_estimator, policy_loss, discount_factor,\n regularizer=None, max_abs_reward=None,\n handle_abandoned_episodes_properly=True,\n huber_delta=None, value_ppo_style_clip_eps=None,\n baseline_cost=1., include_regularization_in_returns=False,\n frame_skip=1, reward_scaling=1.0):\n \"\"\"Creates a GeneralizedOnPolicyLoss.\"\"\"\n self._agent = agent\n self._reward_normalizer = reward_normalizer\n self._parametric_action_distribution = parametric_action_distribution\n self._advantage_estimator = advantage_estimator\n self._policy_loss = policy_loss\n self._regularizer = regularizer\n self._max_abs_reward = max_abs_reward\n self._reward_scaling = reward_scaling\n self._baseline_cost = baseline_cost\n # Provided here so that it is shared.\n self._discount_factor = discount_factor\n self._frame_skip = frame_skip\n self._handle_abandoned_episodes_properly = handle_abandoned_episodes_properly\n self._value_ppo_style_clip_eps = value_ppo_style_clip_eps\n self._include_regularization_in_returns = include_regularization_in_returns\n if huber_delta is not None:\n self.v_loss_fn = tf.keras.losses.Huber(\n delta=huber_delta, reduction=tf.keras.losses.Reduction.NONE)\n else:\n self.v_loss_fn = tf.keras.losses.MeanSquaredError(\n reduction=tf.keras.losses.Reduction.NONE)\n\n def init(self):\n for module in self.submodules:\n if hasattr(module, 'init'):\n if not inspect.signature(module.init).parameters:\n module.init()\n\n def compute_advantages(self, agent_state, prev_actions, env_outputs,\n agent_outputs, return_learner_outputs=False):\n # Extract rewards and done information.\n rewards, done, _, abandoned, _ = tf.nest.map_structure(lambda t: t[1:],\n env_outputs)\n if self._max_abs_reward is not None:\n rewards = tf.clip_by_value(rewards, -self._max_abs_reward, \n self._max_abs_reward)\n rewards *= self._reward_scaling\n\n # Compute the outputs of the neural networks on the learner.\n learner_outputs, _ = self._agent((prev_actions, env_outputs),\n agent_state,\n unroll=True,\n is_training=True)\n\n # At this point, we have unroll length + 1 steps. The last step is only used\n # as bootstrap value, so it's removed.\n agent_outputs = tf.nest.map_structure(lambda t: t[:-1], agent_outputs)\n learner_v = learner_outputs.baseline # current value function\n learner_outputs = tf.nest.map_structure(lambda t: t[:-1], learner_outputs)\n\n target_action_log_probs = self._parametric_action_distribution(\n learner_outputs.policy_logits).log_prob(agent_outputs.action)\n behaviour_action_log_probs = self._parametric_action_distribution(\n agent_outputs.policy_logits).log_prob(agent_outputs.action)\n\n # Compute the advantages.\n\n if self._reward_normalizer:\n corrected_predictions = self._reward_normalizer.correct_prediction(\n learner_v)\n unnormalized_predictions = self._reward_normalizer.unnormalize_prediction(\n corrected_predictions)\n else:\n corrected_predictions = learner_v\n unnormalized_predictions = learner_v\n if not self._handle_abandoned_episodes_properly:\n abandoned = tf.zeros_like(abandoned)\n done_terminated = tf.logical_and(done, ~abandoned)\n done_abandoned = tf.logical_and(done, abandoned)\n\n if self._include_regularization_in_returns and self._regularizer:\n additional_rewards, _ = self._regularizer(\n self._parametric_action_distribution,\n learner_outputs.policy_logits,\n agent_outputs.policy_logits,\n agent_outputs.action, with_logging=False)\n assert rewards.shape == additional_rewards.shape\n rewards += additional_rewards\n\n # tf.math.pow does not work on TPU so we compute it manually.\n adjusted_discount_factor = 1.\n for _ in range(self._frame_skip):\n adjusted_discount_factor *= self._discount_factor\n\n vs, advantages = self._advantage_estimator(\n unnormalized_predictions,\n rewards, done_terminated,\n done_abandoned,\n adjusted_discount_factor,\n target_action_log_probs,\n behaviour_action_log_probs)\n\n if self._reward_normalizer:\n normalized_targets = self._reward_normalizer.normalize_target(vs)\n normalized_advantages = self._reward_normalizer.normalize_advantage(\n advantages)\n self._reward_normalizer.update_normalization_statistics(vs)\n else:\n normalized_targets = vs\n normalized_advantages = advantages\n\n outputs = (normalized_targets, normalized_advantages)\n if return_learner_outputs:\n outputs += (learner_outputs,)\n return outputs\n\n def __call__(self, agent_state, prev_actions, env_outputs, agent_outputs,\n normalized_targets=None, normalized_advantages=None):\n \"\"\"Computes the loss.\"\"\"\n if normalized_targets is None:\n normalized_targets, normalized_advantages, learner_outputs = \\\n self.compute_advantages( \n agent_state, prev_actions, env_outputs, agent_outputs,\n return_learner_outputs=True)\n # The last timestep is only used for computing advantages so we\n # remove it here.\n agent_state, prev_actions, env_outputs, agent_outputs = \\\n tf.nest.map_structure(\n lambda t: t[:-1],\n (agent_state, prev_actions, env_outputs, agent_outputs))\n else: # Advantages are already precomputed.\n learner_outputs, _ = self._agent((prev_actions, env_outputs),\n agent_state,\n unroll=True,\n is_training=True)\n\n target_action_log_probs = self._parametric_action_distribution(\n learner_outputs.policy_logits).log_prob(agent_outputs.action)\n behaviour_action_log_probs = self._parametric_action_distribution(\n agent_outputs.policy_logits).log_prob(agent_outputs.action)\n\n # Compute the advantages.\n if self._reward_normalizer:\n corrected_predictions = self._reward_normalizer.correct_prediction(\n learner_outputs.baseline)\n old_corrected_predictions = self._reward_normalizer.correct_prediction(\n agent_outputs.baseline)\n else:\n corrected_predictions = learner_outputs.baseline\n old_corrected_predictions = agent_outputs.baseline\n\n # Compute the advantage-based loss.\n policy_loss = tf.reduce_mean(\n self._policy_loss(\n normalized_advantages,\n target_action_log_probs,\n behaviour_action_log_probs,\n actions=agent_outputs.action,\n target_logits=learner_outputs.policy_logits,\n behaviour_logits=agent_outputs.policy_logits,\n parametric_action_distribution=self._parametric_action_distribution)\n )\n\n # Value function loss\n v_error = normalized_targets - corrected_predictions\n self.log('GeneralizedOnPolicyLoss/V_error', v_error)\n self.log('GeneralizedOnPolicyLoss/abs_V_error', tf.abs(v_error))\n self.log('GeneralizedOnPolicyLoss/corrected_predictions',\n corrected_predictions)\n # Huber loss reduces the last dimension so we add a dummy one here.\n normalized_targets = normalized_targets[..., tf.newaxis]\n corrected_predictions = corrected_predictions[..., tf.newaxis]\n v_loss = self.v_loss_fn(normalized_targets, corrected_predictions)\n\n # PPO-style value loss clipping\n if self._value_ppo_style_clip_eps is not None:\n old_corrected_predictions = old_corrected_predictions[..., tf.newaxis]\n clipped_corrected_predictions = tf.clip_by_value(\n corrected_predictions,\n old_corrected_predictions - self._value_ppo_style_clip_eps,\n old_corrected_predictions + self._value_ppo_style_clip_eps)\n clipped_v_loss = self.v_loss_fn(normalized_targets,\n clipped_corrected_predictions)\n v_loss = tf.maximum(v_loss, clipped_v_loss)\n v_loss = tf.reduce_mean(v_loss)\n\n # Compute the regularization loss.\n if self._regularizer:\n per_step_regularization, regularization_loss = self._regularizer(\n self._parametric_action_distribution,\n learner_outputs.policy_logits,\n agent_outputs.policy_logits,\n agent_outputs.action)\n if not self._include_regularization_in_returns:\n regularization_loss += tf.reduce_mean(per_step_regularization)\n else:\n regularization_loss = 0.\n\n total_loss = policy_loss + self._baseline_cost*v_loss + regularization_loss\n return total_loss\n\n\nclass PolicyLoss(tf.Module, metaclass=abc.ABCMeta):\n \"\"\"Abstract base class for policy losses.\"\"\"\n\n @abc.abstractmethod\n def __call__(self, advantages, target_action_log_probs,\n behaviour_action_log_probs):\n r\"\"\"Computes policy loss.\n\n Args:\n advantages: A float32 tensor of shape [T, B] of advantages.\n target_action_log_probs: A float32 tensor of shape [T, B] with\n log-probabilities of taking the action by the current policy\n behaviour_action_log_probs: A float32 tensor of shape [T, B] with\n log-probabilities of taking the action by the behavioural policy\n\n\n Returns:\n A float32 tensor of shape [T, B] with the policy loss.\n \"\"\"\n raise NotImplementedError('`__call__()` is not implemented!')\n\n\nclass RegularizationLoss(tf.Module, metaclass=abc.ABCMeta):\n \"\"\"Abstract base class for policy losses.\"\"\"\n\n @abc.abstractmethod\n def __call__(self, parametric_action_distribution, target_action_logits,\n behaviour_action_logits, actions):\n r\"\"\"Computes regularization loss.\n\n Args:\n parametric_action_distribution: Parametric action distribution.\n target_action_logits: A float32 tensor of shape [T, B, A] with\n the logits of the target policy.\n behaviour_action_logits: A float32 tensor of shape [T, B, A] with\n the logits of the behavioural policy.\n actions: A float32 tensor of shape [T, B, A] with the actions taken by the\n behaviour policy.\n\n Returns:\n A float32 tensor of shape [T, B] with the regularization loss.\n \"\"\"\n raise NotImplementedError('`__call__()` is not implemented!')\n"
] | [
[
"tensorflow.keras.losses.MeanSquaredError",
"tensorflow.keras.losses.Huber",
"tensorflow.nest.map_structure",
"tensorflow.logical_and",
"tensorflow.reduce_mean",
"tensorflow.zeros_like",
"tensorflow.abs",
"tensorflow.clip_by_value",
"tensorflow.maximum"
]
] |
jorgemarpa/lightkurve | [
"86320a67eabb3a93f60e9faff0447e4b235bccf2"
] | [
"tests/io/test_k2sff.py"
] | [
"import pytest\n\nfrom astropy.io import fits\nimport numpy as np\nfrom numpy.testing import assert_array_equal\n\nfrom lightkurve.io.k2sff import read_k2sff_lightcurve\nfrom lightkurve import search_lightcurve\n\n\[email protected]_data\ndef test_read_k2sff():\n \"\"\"Can we read K2SFF files?\"\"\"\n url = \"http://archive.stsci.edu/hlsps/k2sff/c16/212100000/00236/hlsp_k2sff_k2_lightcurve_212100236-c16_kepler_v1_llc.fits\"\n f = fits.open(url)\n # Verify different extensions\n fluxes = []\n for ext in [\"BESTAPER\", \"CIRC_APER9\"]:\n lc = read_k2sff_lightcurve(url, ext=ext)\n assert type(lc).__name__ == \"KeplerLightCurve\"\n # Are `time` and `flux` consistent with the FITS file?\n assert_array_equal(f[ext].data[\"T\"], lc.time.value)\n assert_array_equal(f[ext].data[\"FCOR\"], lc.flux.value)\n fluxes.append(lc.flux)\n # Different extensions should show different fluxes\n assert not np.array_equal(fluxes[0], fluxes[1])\n\n\[email protected]_data\ndef test_search_k2sff():\n \"\"\"Can we search and download a K2SFF light curve?\"\"\"\n # Try an early campaign\n search = search_lightcurve(\"K2-18\", author=\"K2SFF\", campaign=1)\n assert len(search) == 1\n assert search.table[\"author\"][0] == \"K2SFF\"\n lc = search.download()\n assert type(lc).__name__ == \"KeplerLightCurve\"\n assert lc.campaign == 1\n # Try a late campaign\n lc = search_lightcurve(\"GJ 9827\", author=\"K2SFF\", campaign=19).download()\n assert type(lc).__name__ == \"KeplerLightCurve\"\n assert lc.targetid == 246389858\n assert lc.campaign == 19\n"
] | [
[
"numpy.testing.assert_array_equal",
"numpy.array_equal"
]
] |
vpisarev/onnxruntime | [
"bab9b80f1f2330d3a115e0abbb4d8278c2be3f44"
] | [
"onnxruntime/python/tools/transformers/quantize_helper.py"
] | [
"# -------------------------------------------------------------------------\n# Copyright (c) Microsoft Corporation. All rights reserved.\n# Licensed under the MIT License. See License.txt in the project root for\n# license information.\n# --------------------------------------------------------------------------\n\nimport logging\nimport torch\nimport onnx\nimport os\nfrom transformers.modeling_utils import Conv1D\n\nlogger = logging.getLogger(__name__)\n\n\ndef _conv1d_to_linear(module):\n in_size, out_size = module.weight.shape\n linear = torch.nn.Linear(in_size, out_size)\n linear.weight.data = module.weight.data.T.contiguous()\n linear.bias.data = module.bias.data\n return linear\n\n\ndef conv1d_to_linear(model):\n '''in-place\n This is for Dynamic Quantization, as Conv1D is not recognized by PyTorch, convert it to nn.Linear\n '''\n logger.debug(\"replace Conv1D with Linear\")\n for name in list(model._modules):\n module = model._modules[name]\n if isinstance(module, Conv1D):\n linear = _conv1d_to_linear(module)\n model._modules[name] = linear\n else:\n conv1d_to_linear(module)\n\n\ndef _get_size_of_pytorch_model(model):\n torch.save(model.state_dict(), \"temp.p\")\n size = os.path.getsize(\"temp.p\") / (1024 * 1024)\n os.remove('temp.p')\n return size\n\n\nclass QuantizeHelper:\n @staticmethod\n def quantize_torch_model(model, dtype=torch.qint8):\n '''\n Usage: model = quantize_model(model)\n\n TODO: mix of in-place and return, but results are different\n '''\n conv1d_to_linear(model)\n quantized_model = torch.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=dtype)\n logger.info(f'Size of full precision Torch model(MB):{_get_size_of_pytorch_model(model)}')\n logger.info(f'Size of quantized Torch model(MB):{_get_size_of_pytorch_model(quantized_model)}')\n return quantized_model\n\n @staticmethod\n def quantize_onnx_model(onnx_model_path, quantized_model_path, use_external_data_format=False):\n from onnxruntime.quantization import quantize_dynamic\n from pathlib import Path\n Path(quantized_model_path).parent.mkdir(parents=True, exist_ok=True)\n logger.info(f'Size of full precision ONNX model(MB):{os.path.getsize(onnx_model_path)/(1024*1024)}')\n quantize_dynamic(onnx_model_path,\n quantized_model_path,\n use_external_data_format = use_external_data_format)\n logger.info(f\"quantized model saved to:{quantized_model_path}\")\n #TODO: inlcude external data in total model size.\n logger.info(f'Size of quantized ONNX model(MB):{os.path.getsize(quantized_model_path)/(1024*1024)}')\n"
] | [
[
"torch.quantization.quantize_dynamic",
"torch.nn.Linear"
]
] |
CryptoTheSuperDog/fds | [
"12795290f5784eb5d218a648aee4edbcfa890078"
] | [
"assignments/assignment2/my_NB_hint.py"
] | [
"import pandas as pd\nimport numpy as np\nfrom collections import Counter\n\nclass my_NB:\n\n def __init__(self, alpha=1):\n # alpha: smoothing factor\n # P(xi = t | y = c) = (N(t,c) + alpha) / (N(c) + n(i)*alpha)\n # where n(i) is the number of available categories (values) of feature i\n # Setting alpha = 1 is called Laplace smoothing\n self.alpha = alpha\n\n def fit(self, X, y):\n # X: pd.DataFrame, independent variables, str\n # y: list, np.array or pd.Series, dependent variables, int or str\n # list of classes for this model\n self.classes_ = list(set(list(y)))\n # for calculation of P(y)\n self.P_y = Counter(y)\n # self.P[yj][Xi][xi] = P(xi|yj) where Xi is the feature name and xi is the feature value, yj is a specific class label\n # make sure to use self.alpha in the __init__() function as the smoothing factor when calculating P(xi|yj)\n self.P = {}\n\n\n\n\n\n \n return\n\n def predict_proba(self, X):\n # X: pd.DataFrame, independent variables, str\n # prob is a dict of prediction probabilities belonging to each categories\n # return probs = pd.DataFrame(list of prob, columns = self.classes_)\n # P(yj|x) = P(x|yj)P(yj)/P(x)\n # P(x|yj) = P(x1|yj)P(x2|yj)...P(xk|yj) = self.P[yj][X1][x1]*self.P[yj][X2][x2]*...*self.P[yj][Xk][xk]\n probs = {}\n for label in self.classes_:\n p = self.P_y[label]\n for key in X:\n p *= X[key].apply(lambda value: self.P[label][key][value] if value in self.P[label][key] else 1)\n probs[label] = p\n probs = pd.DataFrame(probs, columns=self.classes_)\n sums = probs.sum(axis=1)\n probs = probs.apply(lambda v: v / sums)\n return probs\n\n def predict(self, X):\n # X: pd.DataFrame, independent variables, str\n # return predictions: list\n # Hint: predicted class is the class with highest prediction probability (from self.predict_proba)\n probs = self.predict_proba(X)\n predictions = \"Write your own code\"\n return predictions\n\n\n\n\n\n"
] | [
[
"pandas.DataFrame"
]
] |
laurentmackay/3d-vertex | [
"6d6e124ecfaca018d979c5ef17d0b83d1cc0f96c",
"6d6e124ecfaca018d979c5ef17d0b83d1cc0f96c"
] | [
"Validation/Viscoelastic/PeriodicTimeseriesAnalysis.py",
"VertexTissue/validate.py"
] | [
"import string\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom VertexTissue import globals as const\nfrom VertexTissue.Analysis import *\n\nfrom VertexTissue.funcs import euclidean_distance\n\nfrom periodic_2D import forces, omegas\n\n\nif __name__ == '__main__':\n\n square_length = lambda G, t : euclidean_distance(G.nodes[0]['pos'], G.nodes[2]['pos'])\n\n fig, axs = plt.subplots(2,int(np.ceil(len(omegas)*len(forces)/2)))\n fig.set_size_inches(12, 8)\n axs = axs.flatten()\n\n patterns=[]\n i=0\n\n ke=const.mu_apical\n kv = ke*60\n eta = const.eta\n kappa = eta + 2*kv\n\n alphabet_string = string.ascii_lowercase\n alphabet_list = list(alphabet_string)\n\n\n linewidth=3\n for f in forces:\n for omega in omegas:\n\n\n\n\n\n ax=axs[i]\n lbl = alphabet_list[i]\n i+=1\n\n arg = (kappa*ke/(omega*kv**2)+omega*eta/ke)/2\n delta = -np.arctan(arg)\n\n num = ke**2+(omega*kv)**2\n denom = (kappa*omega*ke)**2+(kv*eta*omega**2)**2\n\n\n denom2 = (kappa*ke)**3+kappa*ke*(omega*kv*eta)**2\n \n res = analyze_network_evolution(path='./data/viscoelastic/',\n pattern=f'periodic_force_{f}_freq_{omega}_*.pickle',\n func=square_length)\n\n res=np.array(res)\n t=res[:,0]\n ax.plot(t, res[:,1],linewidth=linewidth, label='numerical')\n A=f\n lam = 2*ke/eta + 1/60\n gamma = ke/eta * (2*A)\n B=(2.0/(lam*eta))*(0+gamma/lam)\n sol = (3.4+B)+gamma*(1/const.mu_apical-2.0/(const.eta*lam))*t - B*np.exp(-lam*t)\n\n \n\n num2 = -kv*2*A*omega*ke*eta*kv**2\n l_final = const.l_apical + 2*A/(2*omega*kv+omega*eta)\n l_trans = -2*np.exp(-lam*t)*(num2)/denom2\n amp = 2*A*np.sqrt(num/denom)\n sol = l_final+amp*np.sin(omega*t+delta) +l_trans\n\n\n ax.plot(t, sol, '--',linewidth=linewidth, label='theoretical')\n \n ax.set_xlabel('t (seconds)', fontsize=14)\n ax.set_ylabel('length', fontsize=14)\n ax.title.set_text(f'({lbl}) Force={f}, max error = {np.max(np.abs(sol-res[:,1])):.3e}')\n ax.title.set_fontsize(16)\n ax.legend(loc='right')\n\n \n \n \n\n\n\n\n\n\n \n plt.tight_layout()\n plt.show()",
"import os\n\nimport networkx as nx\nimport numpy as np\n\n\n\n\n\n\n\ndef validate(n,attr='pos'): \n try:\n G=nx.read_gpickle(f't{n}.pickle')\n G1=nx.read_gpickle(f't_fast{n}.pickle')\n\n vals = nx.get_node_attributes(G,attr)\n vals1 = nx.get_node_attributes(G1,attr)\n\n max_diff = np.max([np.max(np.abs(v-v1)) for v,v1 in zip(vals.values(),vals1.values()) ])\n print(f'{n}: {max_diff}')\n\n\n return True\n except:\n return False\n\n\nfor i in range(300):\n cont= validate(i)\n if not cont:\n break"
] | [
[
"numpy.sqrt",
"matplotlib.pyplot.tight_layout",
"numpy.arctan",
"numpy.abs",
"numpy.exp",
"matplotlib.pyplot.show",
"numpy.array",
"numpy.sin"
],
[
"numpy.abs"
]
] |
harunpehlivan/tensorflow | [
"d87a9fbbc5f49ec5ae8eb52c62628f0b1a0bf67f"
] | [
"tensorflow/contrib/factorization/python/ops/gmm.py"
] | [
"# Copyright 2016 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Implementation of Gaussian mixture model (GMM) clustering using tf.Learn.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport time\nimport numpy as np\n\nfrom tensorflow.contrib import framework\nfrom tensorflow.contrib.factorization.python.ops import gmm_ops\nfrom tensorflow.contrib.framework.python.framework import checkpoint_utils\nfrom tensorflow.python.training import training_util\nfrom tensorflow.contrib.learn.python.learn.estimators import estimator\nfrom tensorflow.contrib.learn.python.learn.estimators import model_fn as model_fn_lib\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import logging_ops as logging\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import state_ops\nfrom tensorflow.python.ops.control_flow_ops import with_dependencies\nfrom tensorflow.python.training import session_run_hook\n\n\ndef _streaming_sum(scalar_tensor):\n \"\"\"Create a sum metric and update op.\"\"\"\n sum_metric = framework.local_variable(constant_op.constant(0.0))\n sum_update = sum_metric.assign_add(scalar_tensor)\n return sum_metric, sum_update\n\n\nclass _InitializeClustersHook(session_run_hook.SessionRunHook):\n \"\"\"Initializes clusters or waits for cluster initialization.\"\"\"\n\n def __init__(self, init_op, is_initialized_op, is_chief):\n self._init_op = init_op\n self._is_chief = is_chief\n self._is_initialized_op = is_initialized_op\n\n def after_create_session(self, session, _):\n assert self._init_op.graph == ops.get_default_graph()\n assert self._is_initialized_op.graph == self._init_op.graph\n while True:\n try:\n if session.run(self._is_initialized_op):\n break\n elif self._is_chief:\n session.run(self._init_op)\n else:\n time.sleep(1)\n except RuntimeError as e:\n logging.info(e)\n\n\nclass GMM(estimator.Estimator):\n \"\"\"An estimator for GMM clustering.\"\"\"\n SCORES = 'scores'\n ASSIGNMENTS = 'assignments'\n ALL_SCORES = 'all_scores'\n\n def __init__(self,\n num_clusters,\n model_dir=None,\n random_seed=0,\n params='wmc',\n initial_clusters='random',\n covariance_type='full',\n config=None):\n \"\"\"Creates a model for running GMM training and inference.\n\n Args:\n num_clusters: number of clusters to train.\n model_dir: the directory to save the model results and log files.\n random_seed: Python integer. Seed for PRNG used to initialize centers.\n params: Controls which parameters are updated in the training process.\n Can contain any combination of \"w\" for weights, \"m\" for means,\n and \"c\" for covars.\n initial_clusters: specifies how to initialize the clusters for training.\n See gmm_ops.gmm for the possible values.\n covariance_type: one of \"full\", \"diag\".\n config: See Estimator\n \"\"\"\n self._num_clusters = num_clusters\n self._params = params\n self._training_initial_clusters = initial_clusters\n self._covariance_type = covariance_type\n self._training_graph = None\n self._random_seed = random_seed\n super(GMM, self).__init__(\n model_fn=self._model_builder(), model_dir=model_dir, config=config)\n\n def predict_assignments(self, input_fn=None, batch_size=None, outputs=None):\n \"\"\"See BaseEstimator.predict.\"\"\"\n results = self.predict(input_fn=input_fn,\n batch_size=batch_size,\n outputs=outputs)\n for result in results:\n yield result[GMM.ASSIGNMENTS]\n\n def score(self, input_fn=None, batch_size=None, steps=None):\n \"\"\"Predict total sum of distances to nearest clusters.\n\n Note that this function is different from the corresponding one in sklearn\n which returns the negative of the sum of distances.\n\n Args:\n input_fn: see predict.\n batch_size: see predict.\n steps: see predict.\n\n Returns:\n Total sum of distances to nearest clusters.\n \"\"\"\n results = self.evaluate(input_fn=input_fn, batch_size=batch_size,\n steps=steps)\n return np.sum(results[GMM.SCORES])\n\n def weights(self):\n \"\"\"Returns the cluster weights.\"\"\"\n return checkpoint_utils.load_variable(\n self.model_dir, gmm_ops.GmmAlgorithm.CLUSTERS_WEIGHT)\n\n def clusters(self):\n \"\"\"Returns cluster centers.\"\"\"\n clusters = checkpoint_utils.load_variable(\n self.model_dir, gmm_ops.GmmAlgorithm.CLUSTERS_VARIABLE)\n return np.squeeze(clusters, 1)\n\n def covariances(self):\n \"\"\"Returns the covariances.\"\"\"\n return checkpoint_utils.load_variable(\n self.model_dir, gmm_ops.GmmAlgorithm.CLUSTERS_COVS_VARIABLE)\n\n def _parse_tensor_or_dict(self, features):\n if isinstance(features, dict):\n return array_ops.concat([features[k] for k in sorted(features.keys())],\n 1)\n return features\n\n def _model_builder(self):\n \"\"\"Creates a model function.\"\"\"\n\n def _model_fn(features, labels, mode, config):\n \"\"\"Model function.\"\"\"\n assert labels is None, labels\n (all_scores,\n model_predictions,\n losses, training_op,\n init_op,\n is_initialized) = gmm_ops.gmm(self._parse_tensor_or_dict(features),\n self._training_initial_clusters,\n self._num_clusters, self._random_seed,\n self._covariance_type,\n self._params)\n incr_step = state_ops.assign_add(training_util.get_global_step(), 1)\n loss = math_ops.reduce_sum(losses)\n training_op = with_dependencies([training_op, incr_step], loss)\n training_hooks = [_InitializeClustersHook(\n init_op, is_initialized, config.is_chief)]\n predictions = {\n GMM.ALL_SCORES: all_scores[0],\n GMM.ASSIGNMENTS: model_predictions[0][0],\n }\n eval_metric_ops = {\n GMM.SCORES: _streaming_sum(loss),\n }\n return model_fn_lib.ModelFnOps(mode=mode, predictions=predictions,\n eval_metric_ops=eval_metric_ops,\n loss=loss, train_op=training_op,\n training_hooks=training_hooks)\n\n return _model_fn\n"
] | [
[
"numpy.sum",
"numpy.squeeze",
"tensorflow.python.framework.ops.get_default_graph",
"tensorflow.contrib.framework.python.framework.checkpoint_utils.load_variable",
"tensorflow.python.ops.math_ops.reduce_sum",
"tensorflow.python.training.training_util.get_global_step",
"tensorflow.contrib.learn.python.learn.estimators.model_fn.ModelFnOps",
"tensorflow.python.ops.logging_ops.info",
"tensorflow.python.ops.control_flow_ops.with_dependencies",
"tensorflow.python.framework.constant_op.constant"
]
] |
meewa1/BrukerGUI | [
"f71211557f3a61322a8a8bc9bdb1f70f3cc82969"
] | [
"MRIAssimilator/MRIAThreads.py"
] | [
"from PyQt5 import QtCore\n\nimport os, tempfile\nfrom scipy.misc import toimage\nimport brukerWriter as bw\n\nimport utils\n\nfrom FilesTreeWidget import *\n\n__all__ = [\"FilesTreeThread\", \"SaveThread\"]\n\n\nclass FilesTreeThread(QtCore.QThread):\n def __init__(self, parent = None, mode = \"create\", dirnames = \"\"):\n super().__init__()\n self.parent = parent\n self.fail = 0\n self.mode = mode\n self.dirnames = dirnames\n\n def run(self):\n if not self.dirnames:\n self.parent.tree.manageTree(self.parent.curDir, self.mode)\n else:\n #for dirname in self.dirnames:\n self.parent.tree.manageTree(self.dirnames, self.mode)\n\nclass CANCELThread(Exception):\n pass\n\nclass SaveThread(QtCore.QThread):\n \"\"\" \nCreate thread for saving experiment in the text format\nif self.trigger == \"all\" then each experiment will be saved as \n a single text file in the folder corresponding to the experiment name\nelse self.trigger == \"single\" then only one experiment will be saved without creating folder\n\n \"\"\"\n progressText = QtCore.pyqtSignal(str)\n progress = QtCore.pyqtSignal(int)\n suggestedTypes = [\"Image\", \"XML\", \"Text\"]\n def __init__(self, parent, savepath, saveType, form = \"\", filename = \"\"):\n super().__init__()\n\n self.saveType = saveType\n if self.saveType not in self.suggestedTypes:\n raise CANCELThread(\"Uncorrect function type\")\n\n self.parent = parent\n self.SaveDir = savepath\n self.form = \"xml\" if self.saveType==\"XML\" else form\n self.trigger = \"all\"\n self.cancelThread = False\n self.filename = filename\n\n def _SaveAllChecked(self):\n\n completed = 0\n data = self.parent.tree.ImageData\n\n checkedItemList = []\n self.parent.tree.findCheckedItems(self.parent.tree.invisibleRootItem(), checkedItemList)\n\n allDim = 0\n self.progressText.emit(self.tr(\"Data size counting\"))\n for expNumItem in checkedItemList:\n allDim += int(utils.num_pattern.findall(expNumItem.text(0))[1])\n\n for expNumItem in checkedItemList:\n exp_name = self.parent.tree.getExpNameItem(expNumItem).text(0)\n exp_num = utils.num_pattern.findall(expNumItem.text(0))[0]\n\n saveDir = os.path.join(self.tmp_folder.name, exp_name)\n utils.checkdir(saveDir)\n\n if self.saveType == \"Image\":\n saveDir = os.path.join(saveDir, exp_num)\n utils.checkdir(saveDir)\n\n if self.saveType != \"Image\":\n fname = '{0}{1}Experiment_{2}.{3}'.format(saveDir,\n os.sep,\n exp_num,\n self.form)\n\n img_data = data[exp_name][exp_num][\"data\"]\n for i in range(img_data.Dimension[0]):\n if self.cancelThread:\n raise CANCELThread()\n\n if self.saveType == \"Image\":\n fname = '{0}{1}Image_{2}.{3}'.format(saveDir, \n os.sep, \n i+1, \n self.form)\n self.progressText.emit(\n self.tr(\"Writting Image_{0}.{1} to the folder /{2}/{3}\").format(\n i+1,\n self.form,\n exp_name,\n exp_num))\n toimage(img_data.IntenseData[i,:,:], \n cmin=img_data.min_val, cmax=img_data.max_val).save(fname)\n\n else: \n self.progressText.emit(\n self.tr(\"Writting Image {0}\\{1} to the Experiment_{2}.{3}\").format(\n i+1,\n img_data.Dimension[0],\n exp_num,\n self.form))\n\n eval(\"bw.SingleWriteTo{}File\".format(self.saveType))(fname,\n img_data,\n i,\n i==0)\n\n completed += 100/allDim\n self.progress.emit(completed)\n\n def _SaveSingle(self):\n \"\"\"\n Saving current experiment number\n \"\"\"\n completed = 0\n allDim = self.parent.scroll.maximum()\n saveDir = self.tmp_folder.name\n img_data = self.parent.tree.ImageData[self.parent.curExpName][self.parent.curExpNum][\"data\"]\n\n # add \".xml\" postfix if it's not presented for XML files\n if self.saveType == \"XML\":\n try:\n self.filename = re.search(r\".+\\.xml$\", self.filename).group()\n except AttributeError:\n self.filename += \".xml\"\n\n fname = '{0}{1}{2}'.format(saveDir, \n os.sep, \n self.filename)\n\n for i in range(allDim):\n if self.cancelThread:\n raise CANCELThread()\n\n if self.saveType == \"Image\":\n fname = '{0}{1}{2}_{3}.{4}'.format(saveDir,\n os.sep,\n self.filename,\n i+1,\n self.form)\n self.progressText.emit(\n self.tr(\"Writting {0}_{1}.{2}\").format(self.filename, \n i+1,\n self.form))\n\n toimage(img_data.IntenseData[i,:,:], \n cmin=img_data.min_val, cmax=img_data.max_val).save(fname)\n\n else:\n self.progressText.emit(\n self.tr(\"Writting Image {0}\\{1} to the {2}\").format(i+1,\n allDim + 1, \n self.filename))\n\n eval(\"bw.SingleWriteTo{}File\".format(self.saveType))(fname, \n img_data,\n i,\n i==0)\n completed += 100/allDim\n self.progress.emit(completed)\n\n def run(self):\n\n try:\n utils.checkdir(self.SaveDir)\n\n # create a temporary folder\n self.tmp_folder = tempfile.TemporaryDirectory(suffix = \".TMP\",\n prefix=\"_MRIAssimilator_\",\n dir = self.SaveDir)\n if self.trigger == \"all\":\n self._SaveAllChecked()\n\n elif self.trigger == \"single\":\n self._SaveSingle()\n\n except CANCELThread: \n self.quit()\n"
] | [
[
"scipy.misc.toimage"
]
] |
BrunoKM/station-b-libraries | [
"ea3591837e4a33f0bef789d905467754c27913b3",
"ea3591837e4a33f0bef789d905467754c27913b3"
] | [
"PyStationB/libraries/StaticCharacterization/tests/notebooks/test_introduction.py",
"PyStationB/libraries/StaticCharacterization/tests/test_integrals.py"
] | [
"# # Introduction\n# In this notebook, we will load an example time series, fit a growth model\n# and plot the signals.\n#\n# ## Load example time series\n#\n# Let's start by loading example time series data.\n# -------------------------------------------------------------------------------------------\n# Copyright (c) Microsoft Corporation. All rights reserved.\n# Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.\n# -------------------------------------------------------------------------------------------\n\nfrom typing import Iterable, List, Optional, cast\n\nimport matplotlib.pyplot as plt\nimport pytest\nimport seaborn as sns\nimport staticchar as ch\nfrom psbutils.filecheck import Plottable, figure_found\nfrom psbutils.misc import find_subrepo_directory\nfrom staticchar.plotting.core import AnnotationSpec\n\nSUBREPO_DIR = find_subrepo_directory()\nS_SHAPE_FOLDER = SUBREPO_DIR / \"tests/test_data/S-shape\"\n\n\ndef plot_figure(name: str, ax: Optional[Plottable] = None) -> List[str]:\n sns.despine()\n found = figure_found(ax, f\"test_introduction/{name}\")\n plt.clf()\n return [] if found else [name]\n\n\[email protected](10)\ndef test_introduction():\n dataset = ch.datasets.Dataset(S_SHAPE_FOLDER) # type: ignore # auto\n\n raw_timeseries = dataset.get_a_frame()\n rth = raw_timeseries.head()\n\n # As we can see, there is some non-zero signal at the beginning, which we attribute to\n # the media absorbance and media fluorescence (as initially we have very low cell density).\n assert sorted(rth.keys().to_list()) == sorted([ch.TIME, \"EYFP\", \"OD\", \"ECFP\", \"OD700\", \"mRFP1\"])\n\n colors = {\"EYFP\": \"yellow\", \"ECFP\": \"cyan\", \"mRFP1\": \"red\", \"OD\": \"black\"}\n\n plt.figure(figsize=(6.4, 4.8))\n ax = cast(plt.Axes, plt.subplot())\n ch.plot_signals_against_time(raw_timeseries, signals=colors.keys(), time_column=\"time\", ax=ax, colors=colors)\n ax.legend()\n figures_not_found = []\n figures_not_found += plot_figure(\"plot1_raw_timeseries\", ax)\n\n # ## Pre-processing\n # Let's assume this is the background and subtract it.\n # (A more precise, but also costly alternative is to estimate this using several blanks).\n\n # In[ ]:\n\n subtracted = ch.subtract_background(\n raw_timeseries, columns=[\"OD\", \"ECFP\", \"EYFP\", \"mRFP1\"], strategy=ch.BackgroundChoices.Minimum\n )\n ax = cast(plt.Axes, plt.subplot())\n ch.plot_signals_against_time(subtracted, signals=colors.keys(), time_column=\"time\", ax=ax, colors=colors)\n ax.legend()\n figures_not_found += plot_figure(\"plot2_subtracted_timeseries\", ax)\n\n # ## Run characterization on an example\n\n # In[ ]:\n\n yaml_path = find_subrepo_directory() / \"tests/configs/integral_basic.yml\"\n config = ch.config.load(yaml_path, ch.config.CharacterizationConfig)\n # config\n\n # ### Fitting a growth model\n #\n # Let's fit a growth model to the OD signal.\n\n model_params = ch.LogisticModel.fit(subtracted[\"time\"], subtracted[config.growth_signal]) # type: ignore # auto\n model = ch.LogisticModel(model_params)\n\n # model_params = ch.GompertzModel.fit(subtracted[\"time\"], subtracted[config.growth_signal])\n # model = ch.GompertzModel(model_params)\n\n print(f\"Inferred parameters: {model_params}\")\n print(f\"Growth phase: {model.growth_period}\")\n print(f\"Time of maximal activity: {model.time_maximal_activity}\")\n print(f\"Inferred (log of) initial density: {model.initial_density(log=True)}\")\n\n ch.plot_growth_model(subtracted[\"time\"], subtracted[config.growth_signal], model=model) # type: ignore # auto\n figures_not_found += plot_figure(\"plot3_growth_model_fit\")\n\n # ### Plotting the data\n #\n # Some time after the growth phase, we should observe a similar exponential production\n # of the proteins. Suppose that this maturation time is about 50 minutes,\n # that is about 0.85 hours.\n #\n # Then, fluorescence signals should be linear when drawn with respect to each other.\n\n # Add offset to the growth phase\n production_phase = model.growth_period + config.maturation_offset\n\n f, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) # type: ignore\n ch.plot_signals_against_time(subtracted, signals=colors.keys(), time_column=\"time\", ax=ax1, colors=colors)\n\n # Visualise the production phase\n ch.mark_phase(ax1, interval=production_phase, color=\"green\", alpha=0.1)\n\n ch.plot_signals_against_reference(subtracted, signals=(\"EYFP\", \"ECFP\"), reference=\"mRFP1\", colors=colors, ax=ax2)\n\n figures_not_found += plot_figure(\"plot4_fluorescence_signals\", f)\n\n # ### Truncate the time-series\n #\n # We see that this very well captures the growth phase of mRFP1 (the reference signal),\n # but is a bit too late for EYFP and ECFP -- we won't have a linear dependence between\n # the signals...\n #\n # Let's choose a more narrow interval.\n\n another_production_phase = ch.TimePeriod(reference=12, left=2, right=2)\n truncated_timeseries = ch.select_time_interval(subtracted, interval=another_production_phase)\n\n f, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) # type: ignore\n ch.plot_signals_against_time(subtracted, signals=colors.keys(), time_column=\"time\", ax=ax1, colors=colors)\n\n # Visualise the production phase\n ch.mark_phase(ax1, interval=another_production_phase, color=\"green\", alpha=0.1)\n\n ch.plot_signals_against_reference(\n truncated_timeseries, signals=(\"EYFP\", \"ECFP\"), reference=\"mRFP1\", colors=colors, ax=ax2 # type: ignore # auto\n )\n figures_not_found += plot_figure(\"plot5_truncated\")\n\n # Run method\n\n gradient, gradient_error = ch.transcriptional_activity_ratio(\n truncated_timeseries, # type: ignore # auto\n config.signals,\n config.reference,\n config.signal_properties,\n model_params.growth_rate,\n model.growth_period,\n maturation_offset=config.maturation_offset,\n )\n # gradient\n\n # ### Integration-based characterization\n # Now assume that we want to integrate the signals over the production period.\n\n signals = [\"EYFP\", \"ECFP\"]\n ch.integrate(data=subtracted, signals=signals, interval=config.time_window)\n\n # Now plot the output\n\n f, axs = plt.subplots(1, len(config.signals), figsize=(12, 4))\n for signal, ax in zip(config.signals, cast(Iterable, axs)):\n ch.plot_integration(\n subtracted,\n signal,\n config.time_window,\n ax,\n fillcolor=colors[signal],\n annotation_spec=AnnotationSpec(title=True),\n )\n\n figures_not_found += plot_figure(\"plot6_integration\", f)\n assert figures_not_found == [], f\"Figures not found: {', '.join(figures_not_found)}\"\n",
"# -------------------------------------------------------------------------------------------\n# Copyright (c) Microsoft Corporation. All rights reserved.\n# Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.\n# -------------------------------------------------------------------------------------------\nfrom pandas import DataFrame\nfrom staticchar.basic_types import TIME, TimePeriod\nfrom staticchar.integrals import integrate\n\n\ndef test_integrate():\n dct = {TIME: [0, 1, 2, 3], \"gfp\": [2.0, 3.0, 2.5, 2.0], \"rfp\": [1.0, 2.0, 1.5, 1.0]}\n df = DataFrame(dct)\n results = integrate(df, signals=[\"gfp\", \"rfp\"])\n assert results[\"gfp\"] == 7.5\n assert results[\"rfp\"] == 4.5\n results2 = integrate(df, signals=[\"gfp\", \"rfp\"], interval=TimePeriod(reference=1.5, left=0.5, right=0.5))\n assert results2[\"gfp\"] == 2.75\n assert results2[\"rfp\"] == 1.75\n"
] | [
[
"matplotlib.pyplot.figure",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.clf"
],
[
"pandas.DataFrame"
]
] |
mir-group/nequip | [
"4e6a0914a289cf000da57a6b6e79678efdf3347f"
] | [
"nequip/nn/embedding/_one_hot.py"
] | [
"import torch\nimport torch.nn.functional\n\nfrom e3nn.o3 import Irreps\nfrom e3nn.util.jit import compile_mode\n\nfrom nequip.data import AtomicDataDict\nfrom .._graph_mixin import GraphModuleMixin\n\n\n@compile_mode(\"script\")\nclass OneHotAtomEncoding(GraphModuleMixin, torch.nn.Module):\n num_types: int\n set_features: bool\n\n # TODO: use torch.unique?\n # TODO: type annotation\n # Docstrings\n def __init__(\n self,\n num_types: int,\n set_features: bool = True,\n irreps_in=None,\n ):\n super().__init__()\n self.num_types = num_types\n self.set_features = set_features\n # Output irreps are num_types even (invariant) scalars\n irreps_out = {AtomicDataDict.NODE_ATTRS_KEY: Irreps([(self.num_types, (0, 1))])}\n if self.set_features:\n irreps_out[AtomicDataDict.NODE_FEATURES_KEY] = irreps_out[\n AtomicDataDict.NODE_ATTRS_KEY\n ]\n self._init_irreps(irreps_in=irreps_in, irreps_out=irreps_out)\n\n def forward(self, data: AtomicDataDict.Type):\n type_numbers = data[AtomicDataDict.ATOM_TYPE_KEY].squeeze(-1)\n one_hot = torch.nn.functional.one_hot(\n type_numbers, num_classes=self.num_types\n ).to(device=type_numbers.device, dtype=data[AtomicDataDict.POSITIONS_KEY].dtype)\n data[AtomicDataDict.NODE_ATTRS_KEY] = one_hot\n if self.set_features:\n data[AtomicDataDict.NODE_FEATURES_KEY] = one_hot\n return data\n"
] | [
[
"torch.nn.functional.one_hot"
]
] |
swami1995/SimuRLacra | [
"795e6ea45fbb722242ddb0c0ea5c62432826411e"
] | [
"Pyrado/pyrado/environments/mujoco/openai_half_cheetah.py"
] | [
"# Copyright (c) 2020, Fabio Muratore, Honda Research Institute Europe GmbH, and\n# Technical University of Darmstadt.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n# 1. Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n# 2. Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in the\n# documentation and/or other materials provided with the distribution.\n# 3. Neither the name of Fabio Muratore, Honda Research Institute Europe GmbH,\n# or Technical University of Darmstadt, nor the names of its contributors may\n# be used to endorse or promote products derived from this software without\n# specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL FABIO MURATORE, HONDA RESEARCH INSTITUTE EUROPE GMBH,\n# OR TECHNICAL UNIVERSITY OF DARMSTADT BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\n# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER\n# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.\n\nimport os.path as osp\nfrom typing import Optional\n\nimport numpy as np\nfrom init_args_serializer import Serializable\n\nimport pyrado\nfrom pyrado.environments.mujoco.base import MujocoSimEnv\nfrom pyrado.spaces.base import Space\nfrom pyrado.spaces.box import BoxSpace\nfrom pyrado.tasks.base import Task\nfrom pyrado.tasks.goalless import GoallessTask\nfrom pyrado.tasks.reward_functions import ForwardVelocityRewFcn\n\n\nclass HalfCheetahSim(MujocoSimEnv, Serializable):\n \"\"\"\n The Half-Cheetah (v3) MuJoCo simulation environment where a planar cheetah-like robot tries to run forward.\n\n .. note::\n The OpenAI Gym variant considers this task solved at a reward over 4800\n (https://github.com/openai/gym/blob/master/gym/envs/__init__.py).\n\n .. seealso::\n https://github.com/openai/gym/blob/master/gym/envs/mujoco/half_cheetah_v3.py\n \"\"\"\n\n name: str = \"cth\"\n\n def __init__(\n self,\n frame_skip: int = 5,\n dt: Optional[float] = None,\n max_steps: int = 1000,\n task_args: Optional[dict] = None,\n ):\n \"\"\"\n Constructor\n\n :param frame_skip: number of simulation frames for which the same action is held, results in a multiplier of\n the time step size `dt`\n :param dt: by default the time step size is the one from the mujoco config file multiplied by the number of\n frame skips (legacy from OpenAI environments). By passing an explicit `dt` value, this can be\n overwritten. Possible use case if if you know that you recorded a trajectory with a specific `dt`.\n :param max_steps: max number of simulation time steps\n :param task_args: arguments for the task construction, e.g `dict(fwd_rew_weight=1.)`\n \"\"\"\n # Call MujocoSimEnv's constructor\n model_path = osp.join(osp.dirname(__file__), \"assets\", \"openai_half_cheetah.xml\")\n super().__init__(model_path, frame_skip, dt, max_steps, task_args)\n\n # Initial state\n noise_halfspan = self.domain_param[\"reset_noise_halfspan\"]\n min_init_qpos = self.init_qpos - np.full_like(self.init_qpos, noise_halfspan)\n max_init_qpos = self.init_qpos + np.full_like(self.init_qpos, noise_halfspan)\n min_init_qvel = self.init_qvel - np.full_like(self.init_qpos, noise_halfspan)\n max_init_qvel = self.init_qvel + np.full_like(self.init_qpos, noise_halfspan)\n min_init_state = np.concatenate([min_init_qpos, min_init_qvel]).ravel()\n max_init_state = np.concatenate([max_init_qpos, max_init_qvel]).ravel()\n self._init_space = BoxSpace(min_init_state, max_init_state)\n\n self.camera_config = dict(distance=5.0)\n\n @property\n def state_space(self) -> Space:\n state_shape = np.concatenate([self.sim.data.qpos, self.sim.data.qvel]).shape\n return BoxSpace(-pyrado.inf, pyrado.inf, shape=state_shape)\n\n @property\n def obs_space(self) -> Space:\n obs_shape = self.observe(self.state_space.bound_up).shape\n return BoxSpace(-pyrado.inf, pyrado.inf, shape=obs_shape)\n\n @property\n def act_space(self) -> Space:\n act_bounds = self.model.actuator_ctrlrange.copy().T\n return BoxSpace(*act_bounds, labels=[\"bthigh\", \"bshin\", \"bfoot\", \"fthigh\", \"fshin\", \"ffoot\"])\n\n @classmethod\n def get_nominal_domain_param(cls) -> dict:\n return dict(\n reset_noise_halfspan=0.0, # fixed initial state by default\n total_mass=14,\n tangential_friction_coeff=0.4,\n torsional_friction_coeff=0.1,\n rolling_friction_coeff=0.1,\n )\n\n def _create_task(self, task_args: dict) -> Task:\n if \"fwd_rew_weight\" not in task_args:\n task_args[\"fwd_rew_weight\"] = 1.0\n if \"ctrl_cost_weight\" not in task_args:\n task_args[\"ctrl_cost_weight\"] = 0.1\n\n return GoallessTask(self.spec, ForwardVelocityRewFcn(self._dt, idx_fwd=0, **task_args))\n\n def _mujoco_step(self, act: np.ndarray) -> dict:\n self.sim.data.ctrl[:] = act\n self.sim.step()\n\n pos = self.sim.data.qpos.copy()\n vel = self.sim.data.qvel.copy()\n self.state = np.concatenate([pos, vel])\n\n return dict()\n\n def observe(self, state: np.ndarray) -> np.ndarray:\n # Ignore horizontal position to maintain translational invariance\n return state[1:].copy()\n"
] | [
[
"numpy.full_like",
"numpy.concatenate"
]
] |
guidj/attx | [
"6a17ed393ab1f1723e7a9d8890da6313bb96c75f"
] | [
"py/tests/test_tensor_ops.py"
] | [
"import pytest\nimport tensorflow as tf\nimport numpy as np\n\nfrom attx import tensor_ops\n\n\ndef test_single_example_batch_single_step_sequence_with_high_dimension():\n # (?, k, dk) = (1, 1, 4)\n query_1 = [[1, 2, 3, 4]]\n key_1 = [[1, 1, 1, 1]]\n value_1 = [[10, 10, 10, 10]]\n\n query = tf.cast([query_1], tf.float32)\n key = tf.cast([key_1], tf.float32)\n value = tf.cast([value_1], tf.float32)\n\n expected_att_1 = [[1.0]]\n expected_output_1 = [[10.0, 10.0, 10.0, 10.0]]\n\n expected_attention = np.array([expected_att_1])\n expected_value = np.array([expected_output_1])\n\n output_attention, output_value = tensor_ops.attention(query, key, value)\n\n np.testing.assert_array_almost_equal(\n output_attention, expected_attention, decimal=3,\n )\n np.testing.assert_array_almost_equal(output_value, expected_value, decimal=3)\n\n\ndef test_single_example_batch_multi_step_sequence_with_high_dimension():\n # (?, k, dk) = (1, 2, 4)\n query_1 = [[1, 3, 5, 7], [2, 4, 6, 8]]\n key_1 = [[1, 1, 1, 1], [1, 1, 1, 1]]\n value_1 = [[10, 10, 10, 10], [50, 50, 50, 50]]\n\n query = tf.cast([query_1], tf.float32)\n key = tf.cast([key_1], tf.float32)\n value = tf.cast([value_1], tf.float32)\n\n expected_att_1 = [[0.5, 0.5], [0.5, 0.5]]\n expected_output_1 = [[30.0, 30.0, 30.0, 30.0], [30.0, 30.0, 30.0, 30.0]]\n\n expected_attention = np.array([expected_att_1])\n expected_value = np.array([expected_output_1])\n\n output_attention, output_value = tensor_ops.attention(query, key, value)\n\n np.testing.assert_array_almost_equal(\n output_attention, expected_attention, decimal=3,\n )\n np.testing.assert_array_almost_equal(output_value, expected_value, decimal=3)\n\n\ndef test_single_example_batch_multi_step_sequence_with_single_dimension():\n # (?, k, dk) = (1, 4, 1)\n query_1 = [[1], [2], [3], [4]]\n key_1 = [[1], [1], [1], [1]]\n value_1 = [10], [10], [10], [10]\n\n query = tf.cast([query_1], tf.float32)\n key = tf.cast([key_1], tf.float32)\n value = tf.cast([value_1], tf.float32)\n\n expected_att_1 = [\n [1 / 4, 1 / 4, 1 / 4, 1 / 4],\n [1 / 4, 1 / 4, 1 / 4, 1 / 4],\n [1 / 4, 1 / 4, 1 / 4, 1 / 4],\n [1 / 4, 1 / 4, 1 / 4, 1 / 4],\n ]\n expected_output_1 = [[10], [10], [10], [10]]\n\n expected_attention = np.array([expected_att_1])\n expected_value = np.array([expected_output_1])\n\n output_attention, output_value = tensor_ops.attention(query, key, value)\n\n np.testing.assert_array_almost_equal(\n output_attention, expected_attention, decimal=3,\n )\n np.testing.assert_array_almost_equal(output_value, expected_value, decimal=3)\n\n\ndef test_multi_example_batch_multi_step_sequence_with_high_dimension():\n # (?, k, dk) = (2, 2, 4)\n query_1 = [[1, 3, 5, 7], [2, 4, 6, 8]]\n query_2 = [[1, 3, 5, 7], [2, 4, 6, 8]]\n key_1 = [[1, 1, 1, 1], [1, 1, 1, 1]]\n key_2 = [[1, 2, 1, 2], [2, 1, 2, 1]]\n value_1 = [[10, 10, 10, 10], [50, 50, 50, 50]]\n value_2 = [[10, 10, 10, 10], [50, 50, 50, 50]]\n\n query = tf.cast([query_1, query_2], tf.float32)\n key = tf.cast([key_1, key_2], tf.float32)\n value = tf.cast([value_1, value_2], tf.float32,)\n\n expected_att_1 = [[0.5, 0.5], [0.5, 0.5]]\n expected_att_2 = [[0.881, 0.119], [0.881, 0.119]]\n expected_output_1 = [[30.0, 30.0, 30.0, 30.0], [30.0, 30.0, 30.0, 30.0]]\n expected_output_2 = [\n [369 / 25, 369 / 25, 369 / 25, 369 / 25],\n [369 / 25, 369 / 25, 369 / 25, 369 / 25],\n ]\n\n expected_attention = np.array([expected_att_1, expected_att_2])\n expected_value = np.array([expected_output_1, expected_output_2])\n\n output_attention, output_value = tensor_ops.attention(query, key, value)\n\n np.testing.assert_array_almost_equal(\n output_attention, expected_attention, decimal=3,\n )\n np.testing.assert_array_almost_equal(output_value, expected_value, decimal=2)\n\n\ndef test_single_example_batch_multi_step_sequence_with_high_dimension_and_different_value_dimension():\n # (?, k, dk) = (1, 2, 4)\n query_1 = [[1, 3, 5, 7], [2, 4, 6, 8]]\n key_1 = [[1, 1, 1, 1], [1, 1, 1, 1]]\n # (?, k, dv) = (1, 2, 5)\n value_1 = [[10, 10, 10, 10, 10], [50, 50, 50, 50, 50]]\n\n query = tf.cast([query_1], tf.float32)\n key = tf.cast([key_1], tf.float32)\n value = tf.cast([value_1], tf.float32)\n\n expected_att_1 = [[0.5, 0.5], [0.5, 0.5]]\n expected_output_1 = [[30.0, 30.0, 30.0, 30.0, 30.0], [30.0, 30.0, 30.0, 30.0, 30.0]]\n\n expected_attention = np.array([expected_att_1])\n expected_value = np.array([expected_output_1])\n\n output_attention, output_value = tensor_ops.attention(query, key, value)\n\n np.testing.assert_array_almost_equal(\n output_attention, expected_attention, decimal=3,\n )\n np.testing.assert_array_almost_equal(output_value, expected_value, decimal=3)\n"
] | [
[
"numpy.array",
"tensorflow.cast",
"numpy.testing.assert_array_almost_equal"
]
] |
PolarNick239/Triangulum3D | [
"85c6a44f5c8f620bdc58164bd50ff89e1897f59d"
] | [
"tests/triangulum_test/test_support.py"
] | [
"#\n# Copyright (c) 2015, Nikolay Polyarnyi\n# All rights reserved.\n#\n\nimport yaml\nimport asyncio\nimport logging\nimport numpy as np\nimport pkg_resources\nfrom pathlib import Path\nfrom unittest import TestCase\n\nfrom triangulum.utils import support\nfrom triangulum.utils.support import str_dict, deep_merge\nfrom triangulum.rendering.gl import RenderingAsyncExecutor\n\n\nlogger = logging.getLogger(__name__)\n\n\nlogging.basicConfig(level=logging.DEBUG,\n format='%(relativeCreated)d [%(threadName)s]\\t%(name)s [%(levelname)s]:\\t %(message)s')\n\n\nresources_dir_path = Path(pkg_resources.get_provider('triangulum_test.resources').get_resource_filename(__name__, '.'))\n\n_default_test_config = {\n 'debug_output_dir': None,\n}\n\n\ndef load_config():\n config_path = str(resources_dir_path / \"test_config.yml\")\n try:\n with open(config_path) as f:\n user_config = yaml.load(f)\n config = deep_merge(_default_test_config, user_config)\n logger.debug(\"Using test config:\\n{}\".format(str_dict(config)))\n except FileNotFoundError:\n config = _default_test_config\n logger.debug(\"No config file found at '{}'.\".format(config_path))\n logger.debug(\"Using test config (default one):\\n{}\".format(str_dict(config)))\n return config\n\n\nclass TestBase(TestCase):\n\n def setUp(self):\n super().setUp()\n self.config = load_config()\n\n self.gl_executor = None\n self.releasables = []\n\n support.silent_make_dir(self.debug_dir())\n\n def get_gl_executor(self):\n if self.gl_executor is None:\n self.gl_executor = RenderingAsyncExecutor()\n return self.gl_executor\n\n def gl_executor_map(self, foo, *args):\n gl_executor = self.get_gl_executor()\n result = asyncio.get_event_loop().run_until_complete(gl_executor.map(foo, *args))\n return result\n\n def register_releasable(self, releasable):\n self.releasables.append(releasable)\n\n def with_debug_output(self):\n return self.config['debug_output_dir'] is not None\n\n def debug_dir(self):\n return Path(self.config['debug_output_dir']) / self.__class__.__name__\n\n def dump_debug_img(self, path, img):\n if self.with_debug_output():\n path = self.debug_dir() / path\n support.silent_make_dir(path.parent)\n support.save_image(path, img)\n\n def dump_debug_matrix_by_hue(self, path, mat):\n if self.with_debug_output():\n path = self.debug_dir() / path\n support.silent_make_dir(path.parent)\n img = support.array_to_rgb_by_hue(mat)[:, :, ::-1]\n img = np.uint8(img)\n support.save_image(path, img)\n\n def tearDown(self):\n super().tearDown()\n for releasable in self.releasables:\n self.gl_executor_map(releasable.release)\n"
] | [
[
"numpy.uint8"
]
] |
itsliupeng/automl | [
"a02038aa60bdf54e689758e5860e19c574d3638f"
] | [
"efficientdet/horovod_estimator/hooks.py"
] | [
"import io\nimport itertools\nimport os\nimport time\n\nimport cv2\n\ntry:\n import horovod.tensorflow as hvd\nexcept ImportError:\n hvd = None\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport tensorflow.compat.v1 as tf\nfrom PIL import Image\nfrom PIL import ImageDraw, ImageFont\nfrom sklearn.metrics import confusion_matrix\nfrom tensorflow.core.framework.summary_pb2 import Summary\nfrom tensorflow.python import pywrap_tensorflow\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.training import basic_session_run_hooks\nfrom tensorflow.python.training import checkpoint_management\nfrom tensorflow.python.training import training_util\nfrom tensorflow.python.training.session_run_hook import SessionRunArgs\nfrom collections import OrderedDict\n\nfrom horovod_estimator.utis import hvd_info_rank0, is_rank0\n\nmpl.use('Agg')\nnp.seterr(divide='ignore', invalid='ignore')\n\n\nclass BroadcastGlobalVariablesHook(tf.train.SessionRunHook):\n \"\"\"\n SessionRunHook that will broadcast all global variables from root rank\n to all other processes during initialization.\n\n This is necessary to ensure consistent initialization of all workers when\n training is started with random weights or restored from a checkpoint.\n \"\"\"\n\n def __init__(self, root_rank, pretrained_model_path=None, exclusions=[], device='', model_dir=None):\n \"\"\"Construct a new BroadcastGlobalVariablesHook that will broadcast all\n global variables from root rank to all other processes during initialization.\n\n Args:\n root_rank:\n Rank that will send data, other ranks will receive data.\n device:\n Device to be used for broadcasting. Uses GPU by default\n if Horovod was build with HOROVOD_GPU_BROADCAST.\n \"\"\"\n super(BroadcastGlobalVariablesHook, self).__init__()\n self.root_rank = root_rank\n self.bcast_op = None\n self.device = device\n self._pretrained_model_path = pretrained_model_path\n self._saver = None\n self._exclusions = set(exclusions)\n self._variables_to_restore = []\n self._model_dir = model_dir\n\n def begin(self):\n if not self.bcast_op or self.bcast_op.graph != tf.get_default_graph():\n with tf.device(self.device):\n self.bcast_op = hvd.broadcast_global_variables(self.root_rank)\n\n if self._model_dir is not None:\n checkpoint_path = checkpoint_management.latest_checkpoint(self._model_dir)\n if checkpoint_path is not None and not checkpoint_path.endswith('model.ckpt-0'):\n hvd_info_rank0('>>>>> model_dir {} has checkpoint {}, not using pretrained_model_path <<<<<'.\n format(self._model_dir, checkpoint_path))\n return\n\n if self._pretrained_model_path is not None and len(self._pretrained_model_path) > 0 and is_rank0():\n reader = pywrap_tensorflow.NewCheckpointReader(self._pretrained_model_path)\n var_to_shape_map = sorted(reader.get_variable_to_shape_map())\n\n self._exclusions.add('global_step')\n\n for var in tf.global_variables():\n if var.op.name in var_to_shape_map:\n excluded = False\n for exclusion in self._exclusions:\n if var.op.name.startswith(exclusion):\n excluded = True\n break\n if not excluded:\n self._variables_to_restore.append(var)\n\n self._saver = tf.train.Saver(var_list=self._variables_to_restore)\n\n def after_create_session(self, session, coord):\n if self._saver:\n hvd_info_rank0('>>>>> begin to load weights from {}, restore variables length {}, without variables {}'\n .format(self._pretrained_model_path, len(self._variables_to_restore), self._exclusions))\n self._saver.restore(session, self._pretrained_model_path)\n hvd_info_rank0('<<<<< end to load weights')\n\n hvd_info_rank0('>>>>> broadcast global variables begin during after_create_session')\n session.run(self.bcast_op)\n hvd_info_rank0('<<<<< broadcast global variables end during after_create_session ')\n\n\nclass LoggingTensorHook(tf.train.SessionRunHook):\n def __init__(self, named_tensor, summary_dir=None, every_n_iter=100, use_all_reduce=False):\n super(LoggingTensorHook, self).__init__()\n self._named_tensor = named_tensor\n self._every_n_iter = every_n_iter\n self._summary_dir = summary_dir\n self._step = 0\n self._use_all_reduce = use_all_reduce\n\n self._tic = time.time()\n self._avg_ops = {}\n self._global_step_tensor = None\n\n def begin(self):\n if self._use_all_reduce:\n self._avg_ops = OrderedDict({'{}'.format(tag): hvd.allreduce(basic_session_run_hooks._as_graph_element(tensor))\n for (tag, tensor) in self._named_tensor.items()})\n else:\n self._avg_ops = OrderedDict({'{}'.format(tag): basic_session_run_hooks._as_graph_element(tensor)\n for (tag, tensor) in self._named_tensor.items()})\n\n self._global_step_tensor = tf.train.get_or_create_global_step()\n self._avg_ops['step'] = self._global_step_tensor\n\n def before_run(self, run_context): # pylint: disable=unused-argument\n if self._step % self._every_n_iter == 0:\n return SessionRunArgs(fetches=self._avg_ops)\n\n self._tic = time.time()\n\n def _log_tensors(self, tensor_values):\n original = np.get_printoptions()\n np.set_printoptions(suppress=True)\n\n stats = []\n for tag, tensor in tensor_values.items():\n stats.append('%s = %s' % (tag, tensor))\n\n stats.append('%s = %s' % ('step_time', time.time() - self._tic))\n\n if self._use_all_reduce:\n logging_head = 'logging all reduce tensors'\n else:\n logging_head = 'logging tensors'\n\n hvd_info_rank0(\"{}: {}\".format(logging_head, \", \".join(stats)))\n np.set_printoptions(**original)\n\n def _summary(self, tensor_values):\n if self._summary_dir:\n writer = tf.summary.FileWriterCache.get(self._summary_dir)\n this_summary = tf.Summary()\n for tag, value in tensor_values.items():\n this_summary.value.add(tag='avg/{}'.format(tag), simple_value=value)\n writer.add_summary(this_summary, tensor_values['step'])\n\n writer.flush()\n\n def after_run(self, run_context, run_values):\n if self._step % self._every_n_iter == 0:\n if is_rank0() or not self._use_all_reduce:\n avg_values = run_values.results\n self._log_tensors(avg_values)\n self._summary(avg_values)\n\n self._step += 1\n\n\ndef make_image(tensor):\n \"\"\"Convert an numpy representation image to Image protobuf\"\"\"\n from PIL import Image\n height, width, channel = tensor.shape\n image = Image.fromarray(tensor)\n import io\n output = io.BytesIO()\n image.save(output, format='PNG')\n image_string = output.getvalue()\n output.close()\n return Summary.Image(height=height,\n width=width,\n colorspace=channel,\n encoded_image_string=image_string)\n\n\ndef to_fix_format(i):\n if isinstance(i, int) or isinstance(i, np.int32) or isinstance(i, np.int64):\n return str(i)\n else:\n return '{:.2f}'.format(i)\n\n\ndef draw_text_image(text, size=(224, 224)):\n # make a blank image for the text, initialized to transparent text color\n img = Image.new('RGB', size, (0, 0, 0))\n d = ImageDraw.Draw(img)\n\n # to-do: how to align\n # if len(text) <= 2:\n # font_size = 100\n # xy = (80, 60)\n # else:\n # font_size = 40\n # xy = (60, 90)\n\n xy = (10, 10)\n font_size = 20\n\n # get a font\n fnt = ImageFont.truetype('assets/fonts/FreeMono.ttf', size=font_size)\n # get a drawing context\n d.text(xy, text, font=fnt, fill=(255, 255, 255))\n return img\n\n\ndef scale_to_uint8(features_tensor):\n if len(features_tensor) > 0:\n min_f = np.min(features_tensor)\n max_f = np.max(features_tensor)\n features_tensor = (features_tensor - min_f) / (max_f - min_f) * 255\n features_tensor = features_tensor.astype(np.uint8)\n return features_tensor\n\n\ndef top_k_text(prob_array, k):\n sort_idx = np.argsort(prob_array)[-k:][::-1]\n top_k_prob = prob_array[sort_idx]\n top_k_idx = sort_idx\n\n result = ''\n for i in range(k):\n result += '{}: {}\\n'.format(top_k_idx[i], to_fix_format(top_k_prob[i]))\n\n return result.strip()\n\n\ndef find_xy(img, threshold=0.8, percentile=False):\n x_offset = 3\n y_offset = 3\n img = img[x_offset: -x_offset, y_offset: -y_offset]\n threshold = threshold * np.max(img)\n idx = np.argwhere(img > threshold)\n x_min = np.min(idx[:, 1]) + x_offset\n x_max = np.max(idx[:, 1]) + x_offset\n\n y_min = np.min(idx[:, 0]) + y_offset\n y_max = np.max(idx[:, 0]) + y_offset\n\n if percentile:\n h, w = img.shape\n x_min = x_min / w\n x_max = x_max / w\n y_min = y_min / h\n y_max = y_max / h\n\n x_max = min(1.0, x_max)\n y_max = min(1.0, y_max)\n\n return x_min, y_min, x_max, y_max\n\n\ndef draw_box(img_tensor, box):\n img = Image.fromarray(img_tensor)\n d = ImageDraw.Draw(img)\n x_min, y_min, x_max, y_max = box\n d.rectangle(((x_min, y_min), (x_max, y_max)), fill='white', outline=3)\n return np.asarray(img, dtype=np.uint8)\n\n\ndef show_images(filenames, images, raw_images, heat_map_features, labels, probs, global_step, max_images,\n summary_writer, prefix='train'):\n if summary_writer is not None:\n assert images is not None and labels is not None and probs is not None\n n, height, width, channel = images.shape\n padding_255 = np.ones([height, 1, channel], dtype=np.uint8) * 255\n padding_1 = np.ones([height, 1, channel], dtype=np.float32)\n\n filenames_tensor_list = []\n raw_images_tensor_list = []\n images_tensor_list = []\n heat_map_tensor_list = []\n label_tensor_list = []\n max_images = min(max_images, n)\n\n for i in range(max_images):\n images_tensor_list.append(images[i])\n images_tensor_list.append(padding_1)\n\n if raw_images is not None:\n raw_images_tensor_list.append(raw_images[i])\n raw_images_tensor_list.append(padding_1)\n\n if heat_map_features is not None:\n cam = heat_map_features[i][:, :, labels[i]]\n cam = cam - np.min(cam)\n cam_img = cam / np.max(cam)\n cam_img = np.uint8(255 * cam_img)\n heat_map = cv2.applyColorMap(cv2.resize(cam_img, (height, width)), cv2.COLORMAP_JET)\n blue_map = heat_map[:, :, -1]\n box = find_xy(blue_map)\n heat_map = draw_box(heat_map, box)\n heat_map = heat_map / 255.0\n heat_img = heat_map * 0.7 + images[i] * 0.3\n\n heat_map_tensor_list.append(heat_img)\n heat_map_tensor_list.append(padding_1)\n\n # labes & predicts\n probs_show_num = min(5, probs.shape[-1])\n text = '{}: {}\\n'.format(to_fix_format(labels[i]), to_fix_format(probs[i][labels[i]])) \\\n + top_k_text(probs[i], probs_show_num)\n label_image = draw_text_image(text, (height, width))\n label_tensor_list.append(np.asarray(label_image, dtype=np.uint8))\n label_tensor_list.append(padding_255)\n\n filename = filenames[i]\n if isinstance(filename, bytes):\n filename = filename.decode('utf-8')\n\n filename = filename.split('/')[-1]\n filename_image = draw_text_image(filename, (height, width))\n filenames_tensor_list.append(np.asarray(filename_image, dtype=np.uint8))\n filenames_tensor_list.append(padding_255)\n\n # scale float32 to unit8\n all_tensor_list = [scale_to_uint8(np.concatenate(filenames_tensor_list, axis=1))]\n if raw_images is not None:\n all_tensor_list.append(scale_to_uint8(np.concatenate(raw_images_tensor_list, axis=1)))\n\n all_tensor_list.append(scale_to_uint8(np.concatenate(images_tensor_list, axis=1)))\n\n if heat_map_features is not None:\n all_tensor_list.append(scale_to_uint8(np.concatenate(heat_map_tensor_list, axis=1)))\n\n all_tensor_list.append(np.concatenate(label_tensor_list, axis=1))\n\n feature_heatmap_label_tensor = np.concatenate(all_tensor_list, axis=0)\n summary = Summary(value=[Summary.Value(tag='{}/features_heatmap_labels'.format(prefix),\n image=make_image(feature_heatmap_label_tensor))])\n\n summary_writer.add_summary(summary, global_step)\n\n\ndef plt_to_image_summary(plt):\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n image = Image.open(buf).convert('RGB')\n tensor = np.asarray(image, dtype=np.uint8)\n image = make_image(tensor)\n return image\n\n\ndef confusion_matrix_summary(tag, cm, classes, normalize=False, recall=True, title='Confusion matrix',\n cmap=plt.cm.Blues):\n \"\"\"\n This function prints and plots the confusion matrix.\n Normalization can be applied by setting `normalize=True`.\n \"\"\"\n if normalize:\n if recall:\n s = cm.sum(axis=1)[:, np.newaxis] + np.finfo(np.float32).eps\n else:\n s = cm.sum(axis=0)[:, np.newaxis] + np.finfo(np.float32).eps\n\n cm = cm.astype('float') / s\n\n plt.close('all')\n\n f_size = max(5, int(0.6 * len(classes)))\n plt.figure(figsize=(f_size, f_size))\n plt.imshow(cm, interpolation='nearest', cmap=cmap)\n plt.title(title)\n plt.colorbar()\n tick_marks = np.arange(len(classes))\n plt.xticks(tick_marks, classes)\n plt.yticks(tick_marks, classes)\n\n fmt = '.2f' if normalize else 'd'\n thresh = cm.max() / 2.\n for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n plt.text(j, i, format(cm[i, j], fmt), horizontalalignment=\"center\",\n color=\"white\" if cm[i, j] > thresh else \"black\")\n\n plt.ylabel('True label')\n plt.xlabel('Predicted label')\n plt.tight_layout()\n\n image = plt_to_image_summary(plt)\n return Summary(value=[Summary.Value(tag=tag, image=image)])\n\n\ndef roc_summary(tag, y_true, y_pred, n_classes):\n import numpy as np\n import matplotlib.pyplot as plt\n from itertools import cycle\n from sklearn.metrics import roc_curve, auc\n from sklearn.preprocessing import label_binarize\n from scipy import interp\n\n classes = [i for i in range(n_classes)]\n y_true = label_binarize(y_true, classes=classes)\n y_pred = label_binarize(y_pred, classes=classes)\n\n fpr = dict()\n tpr = dict()\n roc_auc = dict()\n for i in range(n_classes):\n fpr[i], tpr[i], _ = roc_curve(y_true[:, i], y_pred[:, i])\n roc_auc[i] = auc(fpr[i], tpr[i])\n\n # Compute micro-average ROC curve and ROC area\n fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(y_true.ravel(), y_pred.ravel())\n roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n\n lw = 2\n\n # plt.figure(0)\n # plt.plot(fpr[2], tpr[2], color='darkorange',\n # lw=lw, label='ROC curve (area = %0.2f)' % roc_auc[2])\n # plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n # plt.xlim([0.0, 1.0])\n # plt.ylim([0.0, 1.05])\n # plt.xlabel('False Positive Rate')\n # plt.ylabel('True Positive Rate')\n # plt.title('Receiver operating characteristic example')\n # plt.legend(loc=\"lower right\")\n # plt.show()\n\n # Compute macro-average ROC curve and ROC area\n\n # First aggregate all false positive rates\n all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)]))\n\n # Then interpolate all ROC curves at this points\n mean_tpr = np.zeros_like(all_fpr)\n for i in range(n_classes):\n mean_tpr += interp(all_fpr, fpr[i], tpr[i])\n\n # Finally average it and compute AUC\n mean_tpr /= n_classes\n\n fpr[\"macro\"] = all_fpr\n tpr[\"macro\"] = mean_tpr\n roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])\n\n # Plot all ROC curves\n plt.close('all')\n f_size = max(5, int(0.6 * len(classes)))\n plt.figure(figsize=(f_size, f_size))\n\n plt.plot(fpr[\"micro\"], tpr[\"micro\"],\n label='micro-average ROC curve (area = {0:0.2f})'\n ''.format(roc_auc[\"micro\"]),\n color='deeppink', linestyle=':', linewidth=4)\n\n plt.plot(fpr[\"macro\"], tpr[\"macro\"],\n label='macro-average ROC curve (area = {0:0.2f})'\n ''.format(roc_auc[\"macro\"]),\n color='navy', linestyle=':', linewidth=4)\n\n colors = cycle(['aqua', 'darkorange', 'cornflowerblue'])\n for i, color in zip(range(n_classes), colors):\n plt.plot(fpr[i], tpr[i], color=color, lw=lw,\n label='ROC curve of class {0} (area = {1:0.2f})'\n ''.format(i, roc_auc[i]))\n\n plt.plot([0, 1], [0, 1], 'k--', lw=lw)\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Some extension of Receiver operating characteristic to multi-class')\n plt.legend(loc=\"lower right\")\n\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n image = Image.open(buf).convert('RGB')\n tensor = np.asarray(image, dtype=np.uint8)\n image = make_image(tensor)\n\n return Summary(value=[Summary.Value(tag=tag, image=image)])\n\n\nclass EvalImageVisualizationHook(tf.train.SessionRunHook):\n def __init__(self, images_name, labels_name, filenames_name, probs_name, raw_images_name=None,\n heat_map_features_name=None, every_n_steps=100, summary_dir=None, max_images=8):\n self._images_name = images_name\n self._labels_name = labels_name\n self._heat_map_features_name = heat_map_features_name\n self._probs_name = probs_name\n self._every_n_steps = every_n_steps\n self._summary_dir = summary_dir\n self._step = 0\n self._run_begin = 0\n self._run_end = 0\n self._max_images = max_images\n self._duration = 0.0\n self._raw_images_name = raw_images_name\n self._filenames_name = filenames_name\n\n def begin(self):\n self._summary_writer = tf.summary.FileWriterCache.get(self._summary_dir)\n self._global_step_tensor = training_util._get_or_create_global_step_read()\n\n def before_run(self, run_context):\n self._run_begin = time.time()\n if self._step > 0 and self._step % self._every_n_steps == 0:\n arg_map = {}\n\n for name in [self._images_name, self._labels_name, self._filenames_name, self._raw_images_name,\n self._heat_map_features_name, self._probs_name]:\n if name is not None:\n try:\n arg_map[name] = basic_session_run_hooks._as_graph_element(name)\n except Exception as e:\n if not self.is_logged:\n tf.logging.error('{} error {}'.format(name, e))\n self.is_logged = True\n\n arg_map['global_step'] = self._global_step_tensor\n return SessionRunArgs(arg_map)\n\n def _log_and_record(self, step):\n if self._summary_writer is not None:\n if self._total_batch_size:\n img_per_sec_tag = 'eval/img_per_sec'\n img_per_sec_tag_value = self._total_batch_size / (self._run_end - self._run_begin)\n sec_per_img_tag = 'eval/sec_per_img'\n sec_per_img_tag_value = 1 / img_per_sec_tag_value * 1000\n summary = Summary(value=[Summary.Value(tag=img_per_sec_tag, simple_value=img_per_sec_tag_value),\n Summary.Value(tag=sec_per_img_tag, simple_value=sec_per_img_tag_value)])\n logging.info(\"%s: %g, %s: %g ms, step: %g\",\n img_per_sec_tag, img_per_sec_tag_value, sec_per_img_tag, sec_per_img_tag_value, step)\n self._summary_writer.add_summary(summary, step)\n\n def after_run(self, run_context, run_values):\n self._run_end = time.time()\n self._duration += self._run_end - self._run_begin\n # not use step 0 to warmup\n if self._step > 0 and self._step % self._every_n_steps == 0:\n results = run_values.results\n global_step = results['global_step']\n\n images = get_key_or_none(results, self._images_name)\n labels = get_key_or_none(results, self._labels_name)\n filenames = get_key_or_none(results, self._filenames_name)\n raw_images = get_key_or_none(results, self._raw_images_name)\n heat_map_features = get_key_or_none(results, self._heat_map_features_name)\n probs = get_key_or_none(results, self._probs_name)\n\n self._total_batch_size = len(images) * hvd.size()\n\n self._log_and_record(self._step + global_step)\n show_images(filenames, images, raw_images, heat_map_features, labels, probs, self._step + global_step,\n self._max_images, self._summary_writer, prefix='eval')\n\n self._step += 1\n\n def end(self, session):\n total_image_count = self._step * self._total_batch_size\n image_per_second = total_image_count / self._duration\n second_per_image = self._duration / total_image_count * 1000\n logging.info('total {}: {}, {}: {}, {}: {}, {}: {} ms'.format('duration', self._duration, 'total_image_count',\n total_image_count, 'image_per_second',\n image_per_second, 'second_per_image',\n second_per_image))\n\n\nclass SpeedHook(basic_session_run_hooks.StepCounterHook):\n def __init__(self, summary_dir, batch_size, every_n_steps=100):\n super(SpeedHook, self).__init__(every_n_steps=every_n_steps, output_dir=summary_dir)\n self._total_batch_size = batch_size * hvd.size()\n\n def _log_and_record(self, elapsed_steps, elapsed_time, global_step):\n steps_per_sec = elapsed_steps / elapsed_time\n if self._summary_writer is not None:\n if self._total_batch_size:\n image_tag = 'images_sec'\n image_count = float(steps_per_sec) * self._total_batch_size\n summary = Summary(value=[Summary.Value(tag=self._summary_tag, simple_value=steps_per_sec),\n Summary.Value(tag=image_tag, simple_value=image_count)])\n logging.info(\"%s: %g, %s: %g, step: %g\", self._summary_tag, steps_per_sec, image_tag, image_count,\n global_step)\n else:\n summary = Summary(value=[Summary.Value(tag=self._summary_tag, simple_value=steps_per_sec)])\n logging.info(\"%s: %g, step: %g\", self._summary_tag, steps_per_sec, global_step)\n\n self._summary_writer.add_summary(summary, global_step)\n\n\ndef get_key_or_none(d, key):\n if key in d:\n return d[key]\n else:\n return None\n\nclass PrefillStagingAreasHook(tf.train.SessionRunHook):\n def after_create_session(self, session, coord):\n # TODO: This assumes TF collections are ordered; is this safe?\n enqueue_ops = tf.get_collection('STAGING_AREA_PUTS')\n for i in range(len(enqueue_ops)):\n session.run(enqueue_ops[:i + 1])\n\n\nclass OomReportingHook(tf.train.SessionRunHook):\n def before_run(self, run_context):\n return SessionRunArgs(fetches=[], # no extra fetches\n options=tf.RunOptions(report_tensor_allocations_upon_oom=True))\n"
] | [
[
"numpy.ones",
"tensorflow.compat.v1.RunOptions",
"numpy.argwhere",
"matplotlib.pyplot.tight_layout",
"numpy.argsort",
"numpy.asarray",
"matplotlib.pyplot.imshow",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.plot",
"tensorflow.python.training.checkpoint_management.latest_checkpoint",
"tensorflow.compat.v1.train.Saver",
"matplotlib.pyplot.xticks",
"sklearn.metrics.roc_curve",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.figure",
"sklearn.metrics.auc",
"numpy.set_printoptions",
"matplotlib.pyplot.xlim",
"numpy.seterr",
"matplotlib.pyplot.title",
"scipy.interp",
"tensorflow.python.pywrap_tensorflow.NewCheckpointReader",
"tensorflow.core.framework.summary_pb2.Summary.Image",
"tensorflow.compat.v1.device",
"matplotlib.use",
"tensorflow.compat.v1.get_default_graph",
"tensorflow.python.training.session_run_hook.SessionRunArgs",
"numpy.uint8",
"tensorflow.python.platform.tf_logging.info",
"tensorflow.compat.v1.summary.FileWriterCache.get",
"numpy.max",
"numpy.min",
"matplotlib.pyplot.close",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.colorbar",
"numpy.finfo",
"tensorflow.python.training.basic_session_run_hooks._as_graph_element",
"tensorflow.core.framework.summary_pb2.Summary.Value",
"numpy.zeros_like",
"sklearn.preprocessing.label_binarize",
"matplotlib.pyplot.legend",
"numpy.get_printoptions",
"tensorflow.python.training.training_util._get_or_create_global_step_read",
"tensorflow.compat.v1.global_variables",
"tensorflow.compat.v1.Summary",
"numpy.concatenate",
"tensorflow.compat.v1.train.get_or_create_global_step",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.xlabel",
"tensorflow.compat.v1.get_collection"
]
] |
belakaria/USeMO | [
"063fbd8b8c39c3cc54f9abd8c79ff01eda9dc803"
] | [
"benchmarks.py"
] | [
"import math\nimport numpy as np\nfrom scipy.interpolate import interp1d\nfrom copy import deepcopy\n\ndef Rosen(x1, d):\n x=list(4*np.asarray(x1)-2)\n sum_i = 0\n for i in range(d-1):\n sum_i =sum_i + (100 * ((x[i]**2) - x[i+1])**2 + (x[i] - 1)**2)\n return sum_i\n\n\ndef Sphere(x1,d):\n x=list(4*np.asarray(x1)-2)\n sum_i = 0\n for i in range(d):\n sum_i =sum_i + (x[i]**2)\n return sum_i\n\n\ndef AckleyD(x1, d):\n x=list(4*np.asarray(x1)-2)\n sum_i = 0\n for i in range(d):\n sum_i = sum_i + x[i]*x[i]\n square_sum = sum_i/d\n sum_i = 0\n for i in range(d):\n sum_i = sum_i + math.cos(2*3.1416*x[i])\n cos_sum = sum_i/d\n f_original = -20.0*math.exp(-0.2*math.sqrt(square_sum)) - math.exp(cos_sum) + 20 + math.exp(1)\n return f_original\n################################################\n\ndef Currin(x, d):\n return float(((1 - math.exp(-0.5*(1/x[1]))) * ((2300*pow(x[0],3) + 1900*x[0]*x[0] + 2092*x[0] + 60)/(100*pow(x[0],3) + 500*x[0]*x[0] + 4*x[0] + 20))))\n\ndef branin(x1,d):\n x=deepcopy(x1)\n x[0]= 15* x[0]-5\n x[1]=15*x[1]\n return float(np.square(x[1] - (5.1/(4*np.square(math.pi)))*np.square(x[0]) + (5/math.pi)*x[0]- 6) + 10*(1-(1./(8*math.pi)))*np.cos(x[0]) + 10)\n################################################\ndef Powell(xx,d):\n\n vmin=-4\n vmax=5\n x=[None]+list(vmin + np.asarray(xx) * (vmax-vmin))\n f_original=0\n for i in range(1,int(math.floor(d/4)+1)):\n f_original=f_original+pow(x[4*i-3]+10*x[4*i-2],2)+5*pow(x[4*i-1]-x[4*i],2)+pow(x[4*i-2]-2*x[4*i-1],4)+10*pow(x[4*i-3]-2*x[4*i],4)\n return float(f_original)\n\ndef Perm(xx,d):\n \n vmin=-1*d\n vmax=d\n beta=10\n x=[None]+list(vmin + np.asarray(xx) * (vmax-vmin))\n f_original=0\n for i in range(1,d+1):\n sum1=0\n for j in range(1,d+1):\n sum1=sum1+(j+beta)*(x[j]-math.pow(j,-1*i)) \n f_original=f_original+math.pow(sum1,2)\n return f_original\n\ndef Dixon(xx,d):\n vmin=-10\n vmax=10\n x=[None]+list(vmin + np.asarray(xx) * (vmax-vmin))\n f_original=0\n for i in range(2,d+1): \n f_original=f_original+i*math.pow(2*math.pow(x[i],2)-x[i-1],2)\n f_original=f_original+math.pow(x[1]-1,1)\n return f_original\ndef ZAKHAROV(xx,d):\n vmin=-5\n vmax=10\n x=[None]+list(vmin + np.asarray(xx) * (vmax-vmin))\n term1=0\n term2=0\n for i in range(1,d+1):\n term1=term1+x[i]**2\n term2=term2+0.5*i*x[i]\n f_original=term1+math.pow(term2,2)+math.pow(term2,4)\n return f_original\ndef RASTRIGIN(xx,d):\n vmin=-5.12\n vmax=5.12\n x=[None]+list(vmin + np.asarray(xx) * (vmax-vmin))\n f_original=0\n for i in range(1,d+1):\n f_original=f_original+(x[i]**2-10*math.cos(2*x[i]*math.pi))\n f_original=f_original+10*d\n return f_original\ndef SumSquares(xx,d):\n vmin=-5.12\n vmax=5.12\n x=[None]+list(vmin + np.asarray(xx) * (vmax-vmin))\n f_original=0\n for i in range(1,d+1):\n f_original=f_original+(i*math.pow(x[i],2))\n return f_original\n################################################\ndef DTLZ14f_1(x, d):\n g=0\n for i in range(d):\n g=g+pow(x[i]-0.5,2)-math.cos(20*math.pi*(x[i]-0.5)) \n g=100*(d+g)\n y1=(1+g)*0.5*x[0]*x[1]*x[2]\n return y1\ndef DTLZ14f_2(x, d):\n g=0\n for i in range(d):\n g=g+pow(x[i]-0.5,2)-math.cos(20*math.pi*(x[i]-0.5)) \n g=100*(d+g)\n y2=(1+g)*0.5*(1-x[2])*x[0]*x[1]\n return y2\ndef DTLZ14f_3(x, d):\n g=0\n for i in range(d):\n g=g+pow(x[i]-0.5,2)-math.cos(20*math.pi*(x[i]-0.5)) \n g=100*(d+g)\n y3=(1+g)*0.5*(1-x[1])*x[0]\n return y3\ndef DTLZ14f_4(x, d):\n g=0\n for i in range(d):\n g=g+pow(x[i]-0.5,2)-math.cos(20*math.pi*(x[i]-0.5)) \n g=100*(d+g)\n y4=(1+g)*0.5*(1-x[0])\n return y4\n\n#########################################\n#d=4\ndef ZDT1_1(x, d):\n y1=x[0]\n return y1\ndef ZDT1_2(x, d):\n y1=x[0]\n g=0\n for i in range(1,d):\n g=g+x[i] \n g=g*(9./(d-1))+1\n h=1-math.sqrt(y1)/math.sqrt(g)\n y2=g*h\n return y2 \n###########################################"
] | [
[
"numpy.square",
"numpy.asarray",
"numpy.cos"
]
] |
ryota2425/zed-yolo | [
"a5672d30e7d11b7542b8cdb0ac1cd882741fb150"
] | [
"zed_python_sample/darknet_zed.py"
] | [
"#!python3\n\"\"\"\nPython 3 wrapper for identifying objects in images\n\nRequires DLL compilation\n\nOriginal *nix 2.7: https://github.com/pjreddie/darknet/blob/0f110834f4e18b30d5f101bf8f1724c34b7b83db/python/darknet.py\nWindows Python 2.7 version: https://github.com/AlexeyAB/darknet/blob/fc496d52bf22a0bb257300d3c79be9cd80e722cb/build/darknet/x64/darknet.py\n\n@author: Philip Kahn, Aymeric Dujardin\n@date: 20180911\n\"\"\"\n# pylint: disable=R, W0401, W0614, W0703\nimport os\nimport sys\nimport time\nimport logging\nimport random\nfrom random import randint\nimport math\nimport statistics\nimport getopt\nfrom ctypes import *\nimport numpy as np\nimport cv2\nimport pyzed.sl as sl\n\n# Get the top-level logger object\nlog = logging.getLogger(__name__)\nlogging.basicConfig(level=logging.INFO)\n\n\ndef sample(probs):\n s = sum(probs)\n probs = [a/s for a in probs]\n r = random.uniform(0, 1)\n for i in range(len(probs)):\n r = r - probs[i]\n if r <= 0:\n return i\n return len(probs)-1\n\n\ndef c_array(ctype, values):\n arr = (ctype*len(values))()\n arr[:] = values\n return arr\n\n\nclass BOX(Structure):\n _fields_ = [(\"x\", c_float),\n (\"y\", c_float),\n (\"w\", c_float),\n (\"h\", c_float)]\n\n\nclass DETECTION(Structure):\n _fields_ = [(\"bbox\", BOX),\n (\"classes\", c_int),\n (\"prob\", POINTER(c_float)),\n (\"mask\", POINTER(c_float)),\n (\"objectness\", c_float),\n (\"sort_class\", c_int)]\n\n\nclass IMAGE(Structure):\n _fields_ = [(\"w\", c_int),\n (\"h\", c_int),\n (\"c\", c_int),\n (\"data\", POINTER(c_float))]\n\n\nclass METADATA(Structure):\n _fields_ = [(\"classes\", c_int),\n (\"names\", POINTER(c_char_p))]\n\n\n#lib = CDLL(\"/home/pjreddie/documents/darknet/libdarknet.so\", RTLD_GLOBAL)\n#lib = CDLL(\"darknet.so\", RTLD_GLOBAL)\nhasGPU = True\nif os.name == \"nt\":\n cwd = os.path.dirname(__file__)\n os.environ['PATH'] = cwd + ';' + os.environ['PATH']\n winGPUdll = os.path.join(cwd, \"yolo_cpp_dll.dll\")\n winNoGPUdll = os.path.join(cwd, \"yolo_cpp_dll_nogpu.dll\")\n envKeys = list()\n for k, v in os.environ.items():\n envKeys.append(k)\n try:\n try:\n tmp = os.environ[\"FORCE_CPU\"].lower()\n if tmp in [\"1\", \"true\", \"yes\", \"on\"]:\n raise ValueError(\"ForceCPU\")\n else:\n log.info(\"Flag value '\"+tmp+\"' not forcing CPU mode\")\n except KeyError:\n # We never set the flag\n if 'CUDA_VISIBLE_DEVICES' in envKeys:\n if int(os.environ['CUDA_VISIBLE_DEVICES']) < 0:\n raise ValueError(\"ForceCPU\")\n try:\n global DARKNET_FORCE_CPU\n if DARKNET_FORCE_CPU:\n raise ValueError(\"ForceCPU\")\n except NameError:\n pass\n # log.info(os.environ.keys())\n # log.warning(\"FORCE_CPU flag undefined, proceeding with GPU\")\n if not os.path.exists(winGPUdll):\n raise ValueError(\"NoDLL\")\n lib = CDLL(winGPUdll, RTLD_GLOBAL)\n except (KeyError, ValueError):\n hasGPU = False\n if os.path.exists(winNoGPUdll):\n lib = CDLL(winNoGPUdll, RTLD_GLOBAL)\n log.warning(\"Notice: CPU-only mode\")\n else:\n # Try the other way, in case no_gpu was\n # compile but not renamed\n lib = CDLL(winGPUdll, RTLD_GLOBAL)\n log.warning(\"Environment variables indicated a CPU run, but we didn't find `\" +\n winNoGPUdll+\"`. Trying a GPU run anyway.\")\nelse:\n lib = CDLL(\"../libdarknet/libdarknet.so\", RTLD_GLOBAL)\nlib.network_width.argtypes = [c_void_p]\nlib.network_width.restype = c_int\nlib.network_height.argtypes = [c_void_p]\nlib.network_height.restype = c_int\n\npredict = lib.network_predict\npredict.argtypes = [c_void_p, POINTER(c_float)]\npredict.restype = POINTER(c_float)\n\nif hasGPU:\n set_gpu = lib.cuda_set_device\n set_gpu.argtypes = [c_int]\n\nmake_image = lib.make_image\nmake_image.argtypes = [c_int, c_int, c_int]\nmake_image.restype = IMAGE\n\nget_network_boxes = lib.get_network_boxes\nget_network_boxes.argtypes = [c_void_p, c_int, c_int, c_float, c_float, POINTER(\n c_int), c_int, POINTER(c_int), c_int]\nget_network_boxes.restype = POINTER(DETECTION)\n\nmake_network_boxes = lib.make_network_boxes\nmake_network_boxes.argtypes = [c_void_p]\nmake_network_boxes.restype = POINTER(DETECTION)\n\nfree_detections = lib.free_detections\nfree_detections.argtypes = [POINTER(DETECTION), c_int]\n\nfree_ptrs = lib.free_ptrs\nfree_ptrs.argtypes = [POINTER(c_void_p), c_int]\n\nnetwork_predict = lib.network_predict\nnetwork_predict.argtypes = [c_void_p, POINTER(c_float)]\n\nreset_rnn = lib.reset_rnn\nreset_rnn.argtypes = [c_void_p]\n\nload_net = lib.load_network\nload_net.argtypes = [c_char_p, c_char_p, c_int]\nload_net.restype = c_void_p\n\nload_net_custom = lib.load_network_custom\nload_net_custom.argtypes = [c_char_p, c_char_p, c_int, c_int]\nload_net_custom.restype = c_void_p\n\ndo_nms_obj = lib.do_nms_obj\ndo_nms_obj.argtypes = [POINTER(DETECTION), c_int, c_int, c_float]\n\ndo_nms_sort = lib.do_nms_sort\ndo_nms_sort.argtypes = [POINTER(DETECTION), c_int, c_int, c_float]\n\nfree_image = lib.free_image\nfree_image.argtypes = [IMAGE]\n\nletterbox_image = lib.letterbox_image\nletterbox_image.argtypes = [IMAGE, c_int, c_int]\nletterbox_image.restype = IMAGE\n\nload_meta = lib.get_metadata\nlib.get_metadata.argtypes = [c_char_p]\nlib.get_metadata.restype = METADATA\n\nload_image = lib.load_image_color\nload_image.argtypes = [c_char_p, c_int, c_int]\nload_image.restype = IMAGE\n\nrgbgr_image = lib.rgbgr_image\nrgbgr_image.argtypes = [IMAGE]\n\npredict_image = lib.network_predict_image\npredict_image.argtypes = [c_void_p, IMAGE]\npredict_image.restype = POINTER(c_float)\n\n\ndef array_to_image(arr):\n import numpy as np\n # need to return old values to avoid python freeing memory\n arr = arr.transpose(2, 0, 1)\n c = arr.shape[0]\n h = arr.shape[1]\n w = arr.shape[2]\n arr = np.ascontiguousarray(arr.flat, dtype=np.float32) / 255.0\n data = arr.ctypes.data_as(POINTER(c_float))\n im = IMAGE(w, h, c, data)\n return im, arr\n\n\ndef classify(net, meta, im):\n out = predict_image(net, im)\n res = []\n for i in range(meta.classes):\n if altNames is None:\n name_tag = meta.names[i]\n else:\n name_tag = altNames[i]\n res.append((name_tag, out[i]))\n res = sorted(res, key=lambda x: -x[1])\n return res\n\n\ndef detect(net, meta, image, thresh=.5, hier_thresh=.5, nms=.45, debug=False):\n \"\"\"\n Performs the detection\n \"\"\"\n custom_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n custom_image = cv2.resize(custom_image, (lib.network_width(\n net), lib.network_height(net)), interpolation=cv2.INTER_LINEAR)\n im, arr = array_to_image(custom_image)\n num = c_int(0)\n pnum = pointer(num)\n predict_image(net, im)\n dets = get_network_boxes(\n net, image.shape[1], image.shape[0], thresh, hier_thresh, None, 0, pnum, 0)\n num = pnum[0]\n if nms:\n do_nms_sort(dets, num, meta.classes, nms)\n res = []\n if debug:\n log.debug(\"about to range\")\n for j in range(num):\n for i in range(meta.classes):\n if dets[j].prob[i] > 0:\n b = dets[j].bbox\n if altNames is None:\n name_tag = meta.names[i]\n else:\n name_tag = altNames[i]\n res.append((name_tag, dets[j].prob[i], (b.x, b.y, b.w, b.h), i))\n res = sorted(res, key=lambda x: -x[1])\n free_detections(dets, num)\n return res\n\n\nnetMain = None\nmetaMain = None\naltNames = None\n\n\ndef get_object_depth(depth, bounds):\n '''\n Calculates the median x, y, z position of top slice(area_div) of point cloud\n in camera frame.\n Arguments:\n depth: Point cloud data of whole frame.\n bounds: Bounding box for object in pixels.\n bounds[0]: x-center\n bounds[1]: y-center\n bounds[2]: width of bounding box.\n bounds[3]: height of bounding box.\n\n Return:\n x, y, z: Location of object in meters.\n '''\n area_div = 2\n\n x_vect = []\n y_vect = []\n z_vect = []\n\n for j in range(int(bounds[0] - area_div), int(bounds[0] + area_div)):\n for i in range(int(bounds[1] - area_div), int(bounds[1] + area_div)):\n z = depth[i, j, 2]\n if not np.isnan(z) and not np.isinf(z):\n x_vect.append(depth[i, j, 0])\n y_vect.append(depth[i, j, 1])\n z_vect.append(z)\n try:\n x_median = statistics.median(x_vect)\n y_median = statistics.median(y_vect)\n z_median = statistics.median(z_vect)\n except Exception:\n x_median = -1\n y_median = -1\n z_median = -1\n pass\n\n return x_median, y_median, z_median\n\n\ndef generate_color(meta_path):\n '''\n Generate random colors for the number of classes mentioned in data file.\n Arguments:\n meta_path: Path to .data file.\n\n Return:\n color_array: RGB color codes for each class.\n '''\n random.seed(42)\n with open(meta_path, 'r') as f:\n content = f.readlines()\n class_num = int(content[0].split(\"=\")[1])\n color_array = []\n for x in range(0, class_num):\n color_array.append((randint(0, 255), randint(0, 255), randint(0, 255)))\n return color_array\n\n\ndef main(argv):\n\n thresh = 0.25\n darknet_path=\"../libdarknet/\"\n config_path = darknet_path + \"cfg/yolov3-tiny.cfg\"\n weight_path = \"yolov3-tiny.weights\"\n meta_path = \"coco.data\"\n svo_path = None\n zed_id = 0\n\n help_str = 'darknet_zed.py -c <config> -w <weight> -m <meta> -t <threshold> -s <svo_file> -z <zed_id>'\n try:\n opts, args = getopt.getopt(\n argv, \"hc:w:m:t:s:z:\", [\"config=\", \"weight=\", \"meta=\", \"threshold=\", \"svo_file=\", \"zed_id=\"])\n except getopt.GetoptError:\n log.exception(help_str)\n sys.exit(2)\n for opt, arg in opts:\n if opt == '-h':\n log.info(help_str)\n sys.exit()\n elif opt in (\"-c\", \"--config\"):\n config_path = arg\n elif opt in (\"-w\", \"--weight\"):\n weight_path = arg\n elif opt in (\"-m\", \"--meta\"):\n meta_path = arg\n elif opt in (\"-t\", \"--threshold\"):\n thresh = float(arg)\n elif opt in (\"-s\", \"--svo_file\"):\n svo_path = arg\n elif opt in (\"-z\", \"--zed_id\"):\n zed_id = int(arg)\n\n input_type = sl.InputType()\n if svo_path is not None:\n log.info(\"SVO file : \" + svo_path)\n input_type.set_from_svo_file(svo_path)\n else:\n # Launch camera by id\n input_type.set_from_camera_id(zed_id)\n\n init = sl.InitParameters(input_t=input_type)\n init.coordinate_units = sl.UNIT.METER\n\n cam = sl.Camera()\n if not cam.is_opened():\n log.info(\"Opening ZED Camera...\")\n status = cam.open(init)\n if status != sl.ERROR_CODE.SUCCESS:\n log.error(repr(status))\n exit()\n\n runtime = sl.RuntimeParameters()\n # Use STANDARD sensing mode\n runtime.sensing_mode = sl.SENSING_MODE.STANDARD\n mat = sl.Mat()\n point_cloud_mat = sl.Mat()\n\n # Import the global variables. This lets us instance Darknet once,\n # then just call performDetect() again without instancing again\n global metaMain, netMain, altNames # pylint: disable=W0603\n assert 0 < thresh < 1, \"Threshold should be a float between zero and one (non-inclusive)\"\n if not os.path.exists(config_path):\n raise ValueError(\"Invalid config path `\" +\n os.path.abspath(config_path)+\"`\")\n if not os.path.exists(weight_path):\n raise ValueError(\"Invalid weight path `\" +\n os.path.abspath(weight_path)+\"`\")\n if not os.path.exists(meta_path):\n raise ValueError(\"Invalid data file path `\" +\n os.path.abspath(meta_path)+\"`\")\n if netMain is None:\n netMain = load_net_custom(config_path.encode(\n \"ascii\"), weight_path.encode(\"ascii\"), 0, 1) # batch size = 1\n if metaMain is None:\n metaMain = load_meta(meta_path.encode(\"ascii\"))\n if altNames is None:\n # In thon 3, the metafile default access craps out on Windows (but not Linux)\n # Read the names file and create a list to feed to detect\n try:\n with open(meta_path) as meta_fh:\n meta_contents = meta_fh.read()\n import re\n match = re.search(\"names *= *(.*)$\", meta_contents,\n re.IGNORECASE | re.MULTILINE)\n if match:\n result = match.group(1)\n else:\n result = None\n try:\n if os.path.exists(result):\n with open(result) as names_fh:\n names_list = names_fh.read().strip().split(\"\\n\")\n altNames = [x.strip() for x in names_list]\n except TypeError:\n pass\n except Exception:\n pass\n\n color_array = generate_color(meta_path)\n\n log.info(\"Running...\")\n\n key = ''\n while key != 113: # for 'q' key\n start_time = time.time() # start time of the loop\n err = cam.grab(runtime)\n if err == sl.ERROR_CODE.SUCCESS:\n cam.retrieve_image(mat, sl.VIEW.LEFT)\n image = mat.get_data()\n\n cam.retrieve_measure(\n point_cloud_mat, sl.MEASURE.XYZRGBA)\n depth = point_cloud_mat.get_data()\n\n # Do the detection\n detections = detect(netMain, metaMain, image, thresh)\n\n log.info(chr(27) + \"[2J\"+\"**** \" + str(len(detections)) + \" Results ****\")\n for detection in detections:\n label = detection[0]\n confidence = detection[1]\n pstring = label+\": \"+str(np.rint(100 * confidence))+\"%\"\n log.info(pstring)\n bounds = detection[2]\n y_extent = int(bounds[3])\n x_extent = int(bounds[2])\n # Coordinates are around the center\n x_coord = int(bounds[0] - bounds[2]/2)\n y_coord = int(bounds[1] - bounds[3]/2)\n #boundingBox = [[x_coord, y_coord], [x_coord, y_coord + y_extent], [x_coord + x_extent, y_coord + y_extent], [x_coord + x_extent, y_coord]]\n thickness = 1\n x, y, z = get_object_depth(depth, bounds)\n distance = math.sqrt(x * x + y * y + z * z)\n distance = \"{:.2f}\".format(distance)\n cv2.rectangle(image, (x_coord - thickness, y_coord - thickness),\n (x_coord + x_extent + thickness, y_coord + (18 + thickness*4)),\n color_array[detection[3]], -1)\n cv2.putText(image, label + \" \" + (str(distance) + \" m\"),\n (x_coord + (thickness * 4), y_coord + (10 + thickness * 4)),\n cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)\n cv2.rectangle(image, (x_coord - thickness, y_coord - thickness),\n (x_coord + x_extent + thickness, y_coord + y_extent + thickness),\n color_array[detection[3]], int(thickness*2))\n\n cv2.imshow(\"ZED\", image)\n key = cv2.waitKey(5)\n log.info(\"FPS: {}\".format(1.0 / (time.time() - start_time)))\n else:\n key = cv2.waitKey(5)\n cv2.destroyAllWindows()\n\n cam.close()\n log.info(\"\\nFINISH\")\n\n\nif __name__ == \"__main__\":\n main(sys.argv[1:])\n"
] | [
[
"numpy.rint",
"numpy.ascontiguousarray",
"numpy.isinf",
"numpy.isnan"
]
] |
ljbuaa/HLDAGN | [
"787462a43d6c0f47dc1ebfd6ef9bfbd1eb5246a7"
] | [
"torchFunc.py"
] | [
"from torch.autograd import Variable\nimport torch.nn.functional as F\nfrom torch import nn\nfrom torch import Tensor\nfrom torch.nn import Parameter\n\ndef l2normalize(v, eps=1e-12):\n return v / (v.norm() + eps)\n\n\nclass SpectralNorm(nn.Module):\n def __init__(self, module, name='weight', power_iterations=1):\n super(SpectralNorm, self).__init__()\n self.module = module\n self.name = name\n self.power_iterations = power_iterations\n if not self._made_params():\n self._make_params()\n\n def _update_u_v(self):\n u = getattr(self.module, self.name + \"_u\")\n v = getattr(self.module, self.name + \"_v\")\n w = getattr(self.module, self.name + \"_bar\")\n\n height = w.data.shape[0]\n for _ in range(self.power_iterations):\n v.data = l2normalize(torch.mv(torch.t(w.view(height,-1).data), u.data))\n u.data = l2normalize(torch.mv(w.view(height,-1).data, v.data))\n\n # sigma = torch.dot(u.data, torch.mv(w.view(height,-1).data, v.data))\n sigma = u.dot(w.view(height, -1).mv(v))\n setattr(self.module, self.name, w / sigma.expand_as(w))\n\n def _made_params(self):\n try:\n u = getattr(self.module, self.name + \"_u\")\n v = getattr(self.module, self.name + \"_v\")\n w = getattr(self.module, self.name + \"_bar\")\n return True\n except AttributeError:\n return False\n\n\n def _make_params(self):\n w = getattr(self.module, self.name)\n\n height = w.data.shape[0]\n width = w.view(height, -1).data.shape[1]\n\n u = Parameter(w.data.new(height).normal_(0, 1), requires_grad=False)\n v = Parameter(w.data.new(width).normal_(0, 1), requires_grad=False)\n u.data = l2normalize(u.data)\n v.data = l2normalize(v.data)\n w_bar = Parameter(w.data)\n\n del self.module._parameters[self.name]\n\n self.module.register_parameter(self.name + \"_u\", u)\n self.module.register_parameter(self.name + \"_v\", v)\n self.module.register_parameter(self.name + \"_bar\", w_bar)\n\n\n def forward(self, *args):\n self._update_u_v()\n return self.module.forward(*args)"
] | [
[
"torch.nn.Parameter"
]
] |
yuzhd/Text2Scene | [
"a357b7d869f559f7d09a5ac6002757ec705b2a76"
] | [
"lib/modules/composites_simulator.py"
] | [
"#!/usr/bin/env python\n\nimport numpy as np\nfrom copy import deepcopy\nimport matplotlib.pyplot as plt\nfrom nntable import AllCategoriesTables\n\nfrom composites_utils import *\n\n\nclass simulator(object):\n def __init__(self, db, batch_size=None, nn_table=None):\n self.db = db\n self.cfg = db.cfg\n self.batch_size = batch_size if batch_size is not None else self.cfg.batch_size\n if nn_table is None:\n self.nn_table = AllCategoriesTables(db)\n self.nn_table.build_nntables_for_all_categories()\n else:\n self.nn_table = nn_table\n\n def reset(self):\n self.scenes = []\n frames = []\n if self.cfg.use_color_volume:\n channel_dim = 3 * self.cfg.output_vocab_size\n else:\n channel_dim = 4 + self.cfg.output_vocab_size\n for i in range(self.batch_size):\n scene = {}\n scene['out_inds'] = []\n scene['out_vecs'] = []\n scene['out_patches'] = []\n frame = np.zeros(\n ( self.cfg.input_image_size[1],\n self.cfg.input_image_size[0],\n channel_dim\n )\n )\n scene['last_frame'] = frame\n scene['last_label'] = np.zeros(\n ( self.cfg.input_image_size[1],\n self.cfg.input_image_size[0]\n ), dtype=np.int32\n )\n scene['last_mask'] = np.zeros(\n ( self.cfg.input_image_size[1],\n self.cfg.input_image_size[0]\n ), dtype=np.float32\n )\n self.scenes.append(scene)\n frames.append(frame)\n frames = np.stack(frames, axis=0)\n return torch.from_numpy(frames)\n\n def batch_render_to_pytorch(self, out_inds, out_vecs):\n assert(len(out_inds) == self.batch_size)\n outputs = []\n for i in range(self.batch_size):\n frame = self.update_scene(self.scenes[i],\n {'out_inds': out_inds[i], 'out_vec': out_vecs[i]})\n outputs.append(frame)\n outputs = np.stack(outputs, 0)\n return torch.from_numpy(outputs)\n\n def batch_redraw(self, return_sequence=False):\n out_frames, out_noises, out_masks, out_labels, out_scenes = [], [], [], [], []\n for i in range(len(self.scenes)):\n predicted_scene = self.db.prediction_outputs_to_scene(self.scenes[i], self.nn_table)\n predicted_scene['patches'] = self.scenes[i]['out_patches']\n frames, noises, masks, labels = self.render_predictions_as_output(predicted_scene, return_sequence)\n if not return_sequence:\n frames = frames[None, ...]\n noises = noises[None, ...]\n masks = masks[None, ...]\n labels = labels[None, ...]\n out_frames.append(frames)\n out_noises.append(noises)\n out_masks.append(masks)\n out_labels.append(labels)\n out_scenes.append(predicted_scene)\n return out_frames, out_noises, out_masks, out_labels, out_scenes\n\n def render_predictions_as_output(self, scene, return_sequence):\n width = scene['width']\n height = scene['height']\n clses = scene['clses']\n boxes = scene['boxes']\n patches = scene['patches']\n\n if self.cfg.use_color_volume:\n channel_dim = 3 * self.cfg.output_vocab_size\n else:\n channel_dim = 4 + self.cfg.output_vocab_size\n\n frame = np.zeros((height, width, channel_dim))\n noise = np.zeros((height, width, channel_dim))\n label = np.zeros((height, width), dtype=np.int32)\n mask = np.zeros((height, width), dtype=np.float32)\n\n out_frames, out_noises, out_labels, out_masks = [], [], [], []\n for i in range(len(clses)):\n cls_ind = clses[i]\n xywh = boxes[i]\n patch = patches[i]\n xyxy = xywh_to_xyxy(xywh, width, height)\n if self.cfg.use_color_volume:\n frame[:,:,3*cls_ind:3*(cls_ind+1)], mask, _, label, noise[:,:,3*cls_ind:3*(cls_ind+1)] = \\\n patch_compose_and_erose(frame[:,:,3*cls_ind:3*(cls_ind+1)], mask, label, \\\n xyxy, patch, self.db, noise[:,:,3*cls_ind:3*(cls_ind+1)])\n else:\n frame[:,:,-3:], mask, _, label, noise[:,:,-3:] = \\\n patch_compose_and_erose(frame[:,:,-3:], mask, label, xyxy, patch, self.db, noise[:,:,-3:])\n frame[:,:,-4] = np.maximum(mask*255, frame[:,:,-4])\n frame[:,:,cls_ind] = np.maximum(mask*255, frame[:,:,cls_ind])\n out_frames.append(frame.copy())\n out_noises.append(noise.copy())\n out_labels.append(label.copy())\n out_masks.append(mask.copy())\n\n if len(clses) == 0:\n out_frames.append(frame.copy())\n out_noises.append(noise.copy())\n out_labels.append(label.copy())\n out_masks.append(mask.copy())\n\n if return_sequence:\n return np.stack(out_frames, 0), np.stack(out_noises, 0), np.stack(out_masks, 0), np.stack(out_labels, 0)\n else:\n return out_frames[-1], out_noises[-1], out_masks[-1], out_labels[-1]\n\n def update_scene(self, scene, step_prediction):\n ##############################################################\n # Update the scene and the last instance of the scene\n ##############################################################\n out_inds = step_prediction['out_inds'].flatten()\n out_vec = step_prediction['out_vec'].flatten()\n scene['out_inds'].append(out_inds)\n scene['out_vecs'].append(out_vec)\n scene['last_frame'], scene['last_mask'], scene['last_label'], current_patch = \\\n self.update_frame(scene['last_frame'], scene['last_mask'], scene['last_label'], out_inds, out_vec)\n scene['out_patches'].append(current_patch)\n return scene['last_frame']\n\n def update_frame(self, input_frame, input_mask, input_label, input_inds, input_vec):\n if input_inds[0] <= self.cfg.EOS_idx:\n return input_frame, input_mask, input_label, None\n w = input_frame.shape[-2]\n h = input_frame.shape[-3]\n cls_ind = input_inds[0]\n xywh = self.db.index2box(input_inds[1:])\n xywh = xywh * np.array([w, h, w, h])\n xyxy = xywh_to_xyxy(xywh, w, h)\n patch = self.nn_table.retrieve(cls_ind, input_vec)[0]\n # print(patch)\n # print(patch['name'])\n\n # update the frame\n if self.cfg.use_color_volume:\n input_frame[:,:,3*cls_ind:3*(cls_ind+1)], input_mask, _, input_label, _ = \\\n patch_compose_and_erose(input_frame[:,:,3*cls_ind:3*(cls_ind+1)], input_mask, input_label, xyxy, patch, self.db)\n else:\n input_frame[:,:,-3:], input_mask, _, input_label, _ = \\\n patch_compose_and_erose(input_frame[:,:,-3:], input_mask, input_label, xyxy, patch, self.db)\n input_frame[:,:,-4] = np.maximum(255*input_mask, input_frame[:,:,-4])\n input_frame[:,:,cls_ind] = np.maximum(255*input_mask, input_frame[:,:,cls_ind])\n return input_frame, input_mask, input_label, patch\n"
] | [
[
"numpy.stack",
"numpy.array",
"numpy.zeros",
"numpy.maximum"
]
] |
PratyushaMaiti/gtsfm | [
"0d03dca0b6fb9293c9a3fb619a2141903168269a"
] | [
"gtsfm/utils/viz.py"
] | [
"\"\"\"Functions to visualize outputs at different stages of GTSFM.\n\nAuthors: Ayush Baid\n\"\"\"\nimport os\nfrom typing import List, Optional, Tuple\n\nimport cv2 as cv\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom gtsam import Pose3\nfrom matplotlib.axes._axes import Axes\n\nimport gtsfm.utils.geometry_comparisons as comp_utils\nimport gtsfm.utils.images as image_utils\nimport gtsfm.utils.io as io_utils\nfrom gtsfm.common.gtsfm_data import GtsfmData\nfrom gtsfm.common.image import Image\nfrom gtsfm.common.keypoints import Keypoints\n\n\nCOLOR_RED = (255, 0, 0)\nCOLOR_GREEN = (0, 255, 0)\n\n\ndef set_axes_equal(ax: Axes):\n \"\"\"\n Make axes of 3D plot have equal scale so that spheres appear as spheres, cubes as cubes, etc.. This is one\n possible solution to Matplotlib's ax.set_aspect('equal') and ax.axis('equal') not working for 3D.\n\n Ref: https://github.com/borglab/gtsam/blob/develop/python/gtsam/utils/plot.py#L13\n\n Args:\n ax: axis for the plot.\n \"\"\"\n # get the min and max value for each of (x, y, z) axes as 3x2 matrix.\n # This gives us the bounds of the minimum volume cuboid encapsulating all\n # data.\n limits = np.array([ax.get_xlim3d(), ax.get_ylim3d(), ax.get_zlim3d()])\n\n # find the centroid of the cuboid\n centroid = np.mean(limits, axis=1)\n\n # pick the largest edge length for this cuboid\n largest_edge_length = np.max(np.abs(limits[:, 1] - limits[:, 0]))\n\n # set new limits to draw a cube using the largest edge length\n radius = 0.5 * largest_edge_length\n ax.set_xlim3d([centroid[0] - radius, centroid[0] + radius])\n ax.set_ylim3d([centroid[1] - radius, centroid[1] + radius])\n ax.set_zlim3d([centroid[2] - radius, centroid[2] + radius])\n\n\ndef draw_circle_cv2(image: Image, x: int, y: int, color: Tuple[int, int, int], circle_size: int = 10) -> Image:\n \"\"\"Draw a solid circle on the image.\n\n Args:\n image: image to draw the circle on.\n x: x coordinate of the center of the circle.\n y: y coordinate of the center of the circle.\n color: RGB color of the circle.\n circle_size (optional): the size of the circle (in pixels). Defaults to 10.\n\n Returns:\n Image: image with the circle drawn on it.\n \"\"\"\n return Image(\n cv.circle(image.value_array, center=(x, y), radius=circle_size, color=color, thickness=-1) # solid circle\n )\n\n\ndef draw_line_cv2(\n image: Image, x1: int, y1: int, x2: int, y2: int, line_color: Tuple[int, int, int], line_thickness: int = 10,\n) -> Image:\n \"\"\"Draw a line on the image from coordinates (x1, y1) to (x2, y2).\n\n Args:\n image: image to draw the line on.\n x1: x coordinate of start of the line.\n y1: y coordinate of start of the line.\n x2: x coordinate of end of the line.\n y2: y coordinate of end of the line.\n line_color: color of the line.\n line_thickness (optional): line thickness. Defaults to 10.\n\n Returns:\n Image: image with the line drawn on it.\n \"\"\"\n return Image(cv.line(image.value_array, (x1, y1), (x2, y2), line_color, line_thickness, cv.LINE_AA))\n\n\ndef plot_twoview_correspondences(\n image_i1: Image,\n image_i2: Image,\n kps_i1: Keypoints,\n kps_i2: Keypoints,\n corr_idxs_i1i2: np.ndarray,\n inlier_mask: Optional[np.ndarray] = None,\n dot_color: Optional[Tuple[int, int, int]] = None,\n max_corrs: Optional[int] = 50,\n) -> Image:\n \"\"\"Plot correspondences between two images as lines between two circles.\n\n Args:\n image_i1: first image.\n image_i2: second image.\n kps_i1: keypoints for image_i1.\n kps_i2: keypoints for image_i2.\n corr_idxs_i1i2: indices of correspondences between i1 and i2.\n inlier_mask (optional): inlier mask for correspondences as boolean array. Defaults to None.\n dot_color (optional): color for keypoints. Defaults to (0, 0, 0).\n max_corrs (optional): max number of correspondences to plot. Defaults to 50.\n\n Returns:\n image visualizing correspondences between two images.\n \"\"\"\n image_i1, image_i2, scale_i1, scale_i2 = image_utils.match_image_widths(image_i1, image_i2)\n\n result = image_utils.vstack_image_pair(image_i1, image_i2)\n\n if max_corrs is not None and corr_idxs_i1i2.shape[0] > max_corrs:\n # subsample matches\n corr_idxs_i1i2 = corr_idxs_i1i2[np.random.choice(corr_idxs_i1i2.shape[0], max_corrs)]\n\n for corr_idx in range(corr_idxs_i1i2.shape[0]):\n # mark the points in both images as circles, and draw connecting line\n idx_i1, idx_i2 = corr_idxs_i1i2[corr_idx]\n\n x_i1 = (kps_i1.coordinates[idx_i1, 0] * scale_i1[0]).astype(np.int32)\n y_i1 = (kps_i1.coordinates[idx_i1, 1] * scale_i1[1]).astype(np.int32)\n x_i2 = (kps_i2.coordinates[idx_i2, 0] * scale_i2[0]).astype(np.int32)\n y_i2 = (kps_i2.coordinates[idx_i2, 1] * scale_i2[1]).astype(np.int32) + image_i1.height\n\n # drawing correspondences with optional inlier mask\n if inlier_mask is None:\n line_color = tuple([int(c) for c in np.random.randint(0, 255 + 1, 3)])\n elif inlier_mask[corr_idx]:\n line_color = COLOR_GREEN\n else:\n line_color = COLOR_RED\n\n result = draw_line_cv2(result, x_i1, y_i1, x_i2, y_i2, line_color, line_thickness=2)\n\n if dot_color is None:\n dot_color = line_color\n result = draw_circle_cv2(result, x_i1, y_i1, dot_color, circle_size=2)\n result = draw_circle_cv2(result, x_i2, y_i2, dot_color, circle_size=2)\n\n return result\n\n\ndef plot_sfm_data_3d(sfm_data: GtsfmData, ax: Axes, max_plot_radius: float = 50) -> None:\n \"\"\"Plot the camera poses and landmarks in 3D matplotlib plot.\n\n Args:\n sfm_data: SfmData object with camera and tracks.\n ax: axis to plot on.\n max_plot_radius: maximum distance threshold away from any camera for which a point\n will be plotted\n \"\"\"\n camera_poses = [sfm_data.get_camera(i).pose() for i in sfm_data.get_valid_camera_indices()]\n plot_poses_3d(camera_poses, ax)\n\n num_tracks = sfm_data.number_tracks()\n # Restrict 3d points to some radius of camera poses\n points_3d = np.array([list(sfm_data.get_track(j).point3()) for j in range(num_tracks)])\n\n nearby_points_3d = comp_utils.get_points_within_radius_of_cameras(camera_poses, points_3d, max_plot_radius)\n\n # plot 3D points\n for landmark in nearby_points_3d:\n ax.plot(landmark[0], landmark[1], landmark[2], \"g.\", markersize=1)\n\n\ndef plot_poses_3d(\n wTi_list: List[Pose3], ax: Axes, center_marker_color: str = \"k\", label_name: Optional[str] = None\n) -> None:\n \"\"\"Plot poses in 3D as dots for centers and lines denoting the orthonormal\n coordinate system for each camera.\n\n Color convention: R -> x axis, G -> y axis, B -> z axis.\n\n Args:\n wTi_list: list of poses to plot.\n ax: axis to plot on.\n center_marker_color (optional): color for camera center marker. Defaults to \"k\".\n name:\n \"\"\"\n spec = \"{}.\".format(center_marker_color)\n\n for i, wTi in enumerate(wTi_list):\n x, y, z = wTi.translation().squeeze()\n\n if i > 0:\n # for the first loop iteration, add the label to the plot\n # for the rest of iterations, set label to None (otherwise would be duplicated in legend)\n label_name = None\n ax.plot(x, y, z, spec, markersize=10, label=label_name)\n\n R = wTi.rotation().matrix()\n\n # getting the direction of the coordinate system (x, y, z axes)\n default_axis_length = 0.5\n v1 = R[:, 0] * default_axis_length\n v2 = R[:, 1] * default_axis_length\n v3 = R[:, 2] * default_axis_length\n\n ax.plot3D([x, x + v1[0]], [y, y + v1[1]], [z, z + v1[2]], c=\"r\")\n ax.plot3D([x, x + v2[0]], [y, y + v2[1]], [z, z + v2[2]], c=\"g\")\n ax.plot3D([x, x + v3[0]], [y, y + v3[1]], [z, z + v3[2]], c=\"b\")\n\n\ndef plot_and_compare_poses_3d(wTi_list: List[Pose3], wTi_list_: List[Pose3]) -> None:\n \"\"\"Plots two sets poses in 3D with different markers to compare.\n\n The markers are colored black (k) and cyan (c) for the two lists.\n\n Args:\n wTi_list: first set of poses.\n wTi_list_: second set of poses.\n \"\"\"\n fig = plt.figure()\n ax = fig.gca(projection=\"3d\")\n\n plot_poses_3d(wTi_list, ax, center_marker_color=\"k\")\n plot_poses_3d(wTi_list_, ax, center_marker_color=\"c\")\n set_axes_equal(ax)\n\n plt.show()\n\n\ndef save_twoview_correspondences_viz(\n image_i1: Image,\n image_i2: Image,\n keypoints_i1: Keypoints,\n keypoints_i2: Keypoints,\n corr_idxs_i1i2: np.ndarray,\n file_path: str,\n) -> None:\n \"\"\"Visualize correspondences between pairs of images.\n\n Args:\n image_i1: image #i1.\n image_i2: image #i2.\n keypoints_i1: detected Keypoints for image #i1.\n keypoints_i2: detected Keypoints for image #i2.\n corr_idxs_i1i2: correspondence indices.\n file_path: file path to save the visualization.\n \"\"\"\n plot_img = plot_twoview_correspondences(image_i1, image_i2, keypoints_i1, keypoints_i2, corr_idxs_i1i2)\n\n io_utils.save_image(plot_img, file_path)\n\n\ndef save_sfm_data_viz(sfm_data: GtsfmData, folder_name: str) -> None:\n \"\"\"Visualize the camera poses and 3d points in SfmData.\n\n Args:\n sfm_data: data to visualize.\n folder_name: folder to save the visualization at.\n \"\"\"\n fig = plt.figure()\n ax = fig.add_subplot(projection=\"3d\")\n\n plot_sfm_data_3d(sfm_data, ax)\n set_axes_equal(ax)\n\n # save the 3D plot in the original view\n fig.savefig(os.path.join(folder_name, \"3d.png\"))\n\n # save the BEV representation\n default_camera_elevation = 100 # in metres above ground\n ax.view_init(azim=0, elev=default_camera_elevation)\n fig.savefig(os.path.join(folder_name, \"bev.png\"))\n\n plt.close(fig)\n\n\ndef save_camera_poses_viz(\n pre_ba_sfm_data: GtsfmData, post_ba_sfm_data: GtsfmData, gt_pose_graph: Optional[List[Pose3]], folder_name: str\n) -> None:\n \"\"\"Visualize the camera pose and save to disk.\n\n Args:\n pre_ba_sfm_data: data input to bundle adjustment.\n post_ba_sfm_data: output of bundle adjustment.\n gt_pose_graph: ground truth poses.\n folder_name: folder to save the visualization at.\n \"\"\"\n # extract camera poses\n pre_ba_poses = []\n for i in pre_ba_sfm_data.get_valid_camera_indices():\n pre_ba_poses.append(pre_ba_sfm_data.get_camera(i).pose())\n\n post_ba_poses = []\n for i in post_ba_sfm_data.get_valid_camera_indices():\n post_ba_poses.append(post_ba_sfm_data.get_camera(i).pose())\n\n fig = plt.figure()\n ax = fig.add_subplot(projection=\"3d\")\n\n if gt_pose_graph is not None:\n plot_poses_3d(gt_pose_graph, ax, center_marker_color=\"m\", label_name=\"GT\")\n\n plot_poses_3d(pre_ba_poses, ax, center_marker_color=\"c\", label_name=\"Pre-BA\")\n plot_poses_3d(post_ba_poses, ax, center_marker_color=\"k\", label_name=\"Post-BA\")\n\n ax.legend(loc=\"upper left\")\n set_axes_equal(ax)\n\n # save the 3D plot in the original view\n fig.savefig(os.path.join(folder_name, \"poses_3d.png\"))\n\n # save the BEV representation\n default_camera_elevation = 100 # in metres above ground\n ax.view_init(azim=0, elev=default_camera_elevation)\n fig.savefig(os.path.join(folder_name, \"poses_bev.png\"))\n\n plt.close(fig)\n"
] | [
[
"matplotlib.pyplot.figure",
"numpy.abs",
"numpy.random.choice",
"matplotlib.pyplot.show",
"matplotlib.pyplot.close",
"numpy.random.randint",
"numpy.mean"
]
] |
aidiary/freesound-audio-tagging | [
"71093fdc838214f4ec2dc5b29b00e7de72ad36d0"
] | [
"dataset.py"
] | [
"import os\nimport librosa\nimport numpy as np\nimport torch.utils.data\n\n\ndef random_crop(y, max_length=176400):\n \"\"\"音声波形を固定長にそろえる\n\n max_lengthより長かったらランダムに切り取る\n max_lengthより短かったらランダムにパディングする\n \"\"\"\n if len(y) > max_length:\n max_offset = len(y) - max_length\n offset = np.random.randint(max_offset)\n y = y[offset:max_length + offset]\n else:\n if max_length > len(y):\n max_offset = max_length - len(y)\n offset = np.random.randint(max_offset)\n else:\n offset = 0\n y = np.pad(y, (offset, max_length - len(y) - offset), 'constant')\n return y\n\n\nclass AudioDataset(torch.utils.data.Dataset):\n\n def __init__(self, df, wav_dir, test=False,\n sr=None, max_length=4.0, window_size=0.02, hop_size=0.01,\n n_feature=64, feature='mfcc', model_type='alex2d'):\n if not os.path.exists(wav_dir):\n print('ERROR: not found %s' % wav_dir)\n exit(1)\n self.df = df\n self.wav_dir = wav_dir\n self.test = test\n self.sr = sr\n self.max_length = max_length # sec\n self.window_size = window_size # sec\n self.hop_size = hop_size # sec\n self.n_feature = n_feature\n self.feature = feature\n self.model_type = model_type\n\n def __len__(self):\n return len(self.df)\n\n def __getitem__(self, index):\n fpath = os.path.join(self.wav_dir, self.df.fname[index])\n y, sr = librosa.load(fpath, sr=self.sr)\n if sr is None:\n print('WARNING:', fpath)\n sr = 44100\n\n # ランダムクロップ\n y = random_crop(y, int(self.max_length * sr))\n\n # 特徴抽出\n n_fft = int(self.window_size * sr)\n hop_length = int(self.hop_size * sr)\n\n if self.feature == 'mfcc':\n feature = librosa.feature.mfcc(y=y, sr=sr, n_fft=n_fft, hop_length=hop_length, n_mfcc=self.n_feature)\n elif self.feature == 'melgram':\n feature = librosa.feature.melspectrogram(y, sr=sr, n_fft=n_fft, hop_length=hop_length, n_mels=self.n_feature)\n else:\n print('Invalid feature name: %s' % self.feature)\n exit(1)\n\n data = torch.from_numpy(feature).float()\n s = data.size()\n\n if self.model_type == 'alex2d' or self.model_type == 'resnet':\n # Conv2dの場合は (channel, features, frames)\n data.resize_(1, s[0], s[1])\n elif self.model_type == 'alex1d' or self.model_type == 'lstm':\n # Conv1dの場合は (features, frames)\n data.resize_(s[0], s[1])\n else:\n print('Invalid conv type: %s' % self.model_type)\n exit(1)\n\n mean = data.mean()\n std = data.std()\n if std != 0:\n data.add_(-mean)\n data.div_(std)\n\n if self.test:\n # テストモードのときは正解ラベルがないのでデータだけ返す\n return data\n else:\n # label\n label = self.df.label_idx[index]\n\n return data, label\n"
] | [
[
"numpy.random.randint"
]
] |
Hardcode84/dpbench | [
"e6bc1fc6493cb80a1b5a2ffcca4cc1348dd3ad99"
] | [
"numba/knn/GPU/base_knn.py"
] | [
"# *****************************************************************************\n# Copyright (c) 2020, Intel Corporation All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# Redistributions of source code must retain the above copyright notice,\n# this list of conditions and the following disclaimer.\n#\n# Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,\n# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\n# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\n# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\n# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\n# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,\n# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n# *****************************************************************************\n\nimport argparse\nimport sys\nimport numpy as np\n\nDATA_DIM = 16\n\n\ntry:\n import itimer as it\n\n now = it.itime\n get_mops = it.itime_mops_now\nexcept:\n from timeit import default_timer\n\n now = default_timer\n get_mops = lambda t0, t1, n: (n / (t1 - t0),t1-t0)\n\n######################################################\n# GLOBAL DECLARATIONS THAT WILL BE USED IN ALL FILES #\n######################################################\n\n# make xrange available in python 3\ntry:\n xrange\nexcept NameError:\n xrange = range\n\n\n###############################################\ndef gen_data_x(nopt, data_dim=DATA_DIM):\n data = np.random.rand(nopt, data_dim)\n return data\n\n\ndef gen_data_y(nopt, classes_num=3):\n data = np.random.randint(classes_num, size=nopt)\n return data\n\n\n##############################################\n\ndef run(name, alg, sizes=10, step=2, nopt=2**10):\n parser = argparse.ArgumentParser()\n parser.add_argument('--steps', type=int, default=sizes,\n help='Number of steps')\n parser.add_argument('--step', type=int, default=step,\n help='Factor for each step')\n parser.add_argument('--size', type=int, default=nopt,\n help='Initial data size')\n parser.add_argument('--repeat', type=int, default=100,\n help='Iterations inside measured region')\n parser.add_argument('--text', default='', help='Print with each result')\n\n args = parser.parse_args()\n nopt = args.size\n repeat = args.repeat\n train_data_size = 2**10\n\n with open('perf_output.csv', 'w', 1) as fd, open(\"runtimes.csv\", 'w', 1) as fd2:\n for _ in xrange(args.steps):\n\n print(\"TRAIN_DATA_SIZE: \", train_data_size)\n print(\"TEST_DATA_SIZE: \", nopt)\n\n x_train, y_train = gen_data_x(train_data_size), gen_data_y(train_data_size)\n x_test = gen_data_x(nopt)\n\n n_neighbors = 5\n\n print('ERF: {}: Size: {}'.format(name, nopt), end=' ', flush=True)\n sys.stdout.flush()\n\n predictions = alg(x_train, y_train, x_test, k=n_neighbors) # warmup\n\n t0 = now()\n for _ in xrange(repeat):\n predictions = alg(x_train, y_train, x_test, k=n_neighbors)\n mops, time = get_mops(t0, now(), nopt)\n\n result_mops = mops * repeat\n print('MOPS:', result_mops, args.text)\n fd.write('{},{}\\n'.format(nopt, result_mops))\n fd2.write('{},{}\\n'.format(nopt, time))\n print(\"TIME: \", time)\n\n nopt *= args.step\n repeat = max(repeat - args.step, 1)\n"
] | [
[
"numpy.random.randint",
"numpy.random.rand"
]
] |
OminiaVincit/scale-variant-topo | [
"6945bc42aacd0d71a6fb472c87e09da223821e1e"
] | [
"graph-kernels2/calculate_kernels.py"
] | [
"import numpy as np\nimport os\n\nimport time\n\nfrom sklearn import svm\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.model_selection import cross_val_predict\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.metrics import accuracy_score\n\nfrom grakel import datasets\nfrom grakel import GraphKernel\nfrom grakel.kernels import VertexHistogram, ShortestPath, WeisfeilerLehman, RandomWalkLabeled, MultiscaleLaplacianFast\n\nfrom six import itervalues, iteritems\n\nimport argparse\n\ndef sec_to_time(sec):\n \"\"\"Print time in a correct format.\"\"\"\n dt = list()\n days = int(sec // 86400)\n if days > 0:\n sec -= 86400*days\n dt.append(str(days) + \" d\")\n\n hrs = int(sec // 3600)\n if hrs > 0:\n sec -= 3600*hrs\n dt.append(str(hrs) + \" h\")\n\n mins = int(sec // 60)\n if mins > 0:\n sec -= 60*mins\n dt.append(str(mins) + \" m\")\n\n if sec > 0:\n dt.append(str(round(sec, 2)) + \" s\")\n return \" \".join(dt)\n\nlb_kernels = {\n \"GraphletSampling\": [{\"name\": \"graphlet_sampling\", \"sampling\": {\"n_samples\": 150}}],\n \"WL-Subtree\": [{\"name\": \"weisfeiler_lehman\", \"niter\": 5}, {\"name\": \"subtree_wl\"}],\n \"WL-ShortestPath\": [{\"name\": \"weisfeiler_lehman\", \"niter\": 5}, {\"name\": \"shortest_path\"}]\n}\n\nulb_kernels = {\n \"ShortestPath\" : [{\"name\": \"shortest_path\", \"with_labels\": False}],\n \"GraphletSampling\": [{\"name\": \"graphlet_sampling\", \"sampling\": {\"n_samples\": 150}}],\n \"GeometricRandomWalk\" : [{\"name\": \"random_walk\", \"method_type\": \"fast\", \"with_labels\": False, \"kernel_type\": \"geometric\"}], #ill defined, donot normalize\n \"ExponentialRandomWalk\" : [{\"name\": \"random_walk\", \"method_type\": \"fast\", \"with_labels\": False, \"kernel_type\": \"exponential\"}],\n # Must have node attribute \"MultiScaleLaplacianFast\" : [{\"name\": \"multiscale_laplacian\", \"which\": \"fast\"}],\n \"LovaszTheta\" : [{\"name\": \"lovasz_theta\"}], #slow\n #\"SvmTheta\" : [{\"name\": \"svm_theta\"}] #fast\n}\n#gk = WeisfeilerLehman(niter=1, normalize=True, base_kernel=VertexHistogram)\n#gk = VertexHistogram(normalize=True)\n\ndef save_kernel(G, gk, outpath, dataname, kername, b, handle=False):\n start = time.time()\n print('Compute kernel {} use handle = {}'.format(kername, handle))\n n = len(G)\n #TODO: Let's use multi-processing but need to handle with large memory consuming problem\n K = np.zeros((n,n))\n if handle == True:\n for i in range(0, n, b):\n ib = min(n, i+b)\n Gs = G[i:ib]\n Ks = gk.fit_transform(Gs)\n K[i:ib, i:ib] = Ks\n for j in range(ib, n, b):\n jb = min(n, j+b)\n Gn = G[j:jb]\n Kn = gk.transform(Gn)\n K[i:ib, j:jb] = Kn.T\n K[j:jb, i:ib] = Kn\n elapse = sec_to_time(round(time.time()-start, 2))\n print('i={}, j={}, b={}, {}'.format(i, j, b, elapse))\n else:\n K = gk.fit_transform(G)\n # P = gk.fit_transform(G)\n # print('K')\n # print(K)\n # print('P')\n # print(P)\n # print('K-P')\n # print(np.max(np.abs(P-K)))\n\n outfile = os.path.join(outpath, '{}_{}.txt'.format(dataname, kername))\n end = time.time()\n elapse = sec_to_time(round(end-start, 2))\n print('Calculate kernel {} in {} '.format(kername, elapse))\n np.savetxt(outfile, K)\n print('Saved kernel ', kername, K.shape)\n print('')\n\ndef to_one_hot(G):\n # Index all discrete labels\n mp = {dl: i for (i, dl) in enumerate(set(l for g in G for l in itervalues(g[1])))}\n def make_vec(k):\n vec = np.zeros((len(mp),), dtype=float)\n vec[k] = 1.0\n return vec\n return [(g[0], {i: make_vec(mp[k]) for (i, k) in iteritems(g[1])}) for g in G]\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('--exppath', '-e', type=str, required=True)\n parser.add_argument('--folder', '-f', type=str, default='gkernel')\n parser.add_argument('--njobs', '-j', type=int, default=-1)\n parser.add_argument('--norm', '-n', type=int, default=1)\n parser.add_argument('--handle', type=int, default=0)\n parser.add_argument('--batchsize', '-b', type=int, default=128)\n parser.add_argument('--label', type=int, default=0)\n parser.add_argument('--dataname', '-d', type=str, default='')\n parser.add_argument('--kername', '-k', type=str, default='')\n \n args = parser.parse_args()\n print(args)\n njobs = None\n norm, handle, b, label = args.norm, args.handle, args.batchsize, args.label\n if args.njobs > 0:\n njobs = args.njobs\n\n dname, kname = args.dataname, args.kername\n\n lb_datalist = ['MUTAG', 'BZR', 'COX2', 'DHFR', 'ENZYMES', 'PROTEINS', 'NCI1', 'NCI109', 'DD', 'MSRC_9']\n ulb_datalist = ['IMDB-BINARY', 'IMDB-MULTI', 'REDDIT-BINARY','FRANKENSTEIN', 'COLLAB']\n\n if label > 0:\n datalist = lb_datalist\n kernels = lb_kernels\n else:\n datalist = ulb_datalist\n kernels = ulb_kernels\n\n rows = sorted(list(kernels.keys()))\n\n if dname != '' and dname not in datalist:\n raise ValueError('Not found specified data: {}'.format(dname))\n \n if kname != '' and kname not in kernels:\n raise ValueError('Not found specified kernel: {}'.format(kname))\n\n for dataname in datalist:\n if dname != '' and dataname != dname:\n continue\n outpath = os.path.join(args.exppath,dataname)\n outpath = os.path.join(outpath, args.folder)\n if not os.path.isdir(outpath):\n os.makedirs(outpath)\n \n dat = datasets.fetch_dataset(dataname, as_graphs=True)\n G, y = dat.data, dat.target\n print(dataname, y.shape)\n \n # Need to run each of below kernels separately\n if False and label > 0:\n gk = VertexHistogram(normalize=norm, n_jobs=njobs)\n save_kernel(G, gk, outpath, dataname, 'VertexHist', b, handle=handle)\n\n gk = ShortestPath(normalize=norm, n_jobs=njobs)\n save_kernel(G, gk, outpath, dataname, 'ShortestPath', b, handle=handle)\n\n if False and label > 0:\n gk = WeisfeilerLehman(niter=5, normalize=norm, base_kernel=VertexHistogram, n_jobs=None)\n save_kernel(G, gk, outpath, dataname, 'WL-VertexHist', b, handle=handle)\n\n # if False:\n # for rwtype in ['geometric', 'exponential']:\n # gk = RandomWalkLabeled(normalize=True, kernel_type=rwtype)\n # save_kernel(G, gk, outpath, dataname, 'randomwalk_{}'.format(rwtype))\n\n if True:\n for (i, kername) in enumerate(rows):\n if kname != '' and kername != kname:\n continue\n print(kername, end=\" \")\n gk = GraphKernel(kernel=kernels[kername], normalize=norm, n_jobs=njobs)\n print(\"\", end=\".\")\n use_handy = False\n if 'WL' in kername and len(G) > 256:\n use_handy = True\n save_kernel(G, gk, outpath, dataname, kername.replace('/', '-'), b, handle=use_handy)\n \n"
] | [
[
"numpy.savetxt",
"numpy.zeros"
]
] |
sdpython/mlprodic | [
"9367dacc91d35ec670c8a8a76708300a75bbc993"
] | [
"_unittests/ut_onnxrt/test_rt_valid_model_gaussian_mixture.py"
] | [
"\"\"\"\n@brief test log(time=16s)\n\"\"\"\nimport unittest\nfrom logging import getLogger\nfrom pandas import DataFrame\nfrom pyquickhelper.loghelper import fLOG\nfrom pyquickhelper.pycode import ExtTestCase\nfrom pyquickhelper.pandashelper import df2rst\nfrom sklearn.exceptions import ConvergenceWarning\ntry:\n from sklearn.utils._testing import ignore_warnings\nexcept ImportError:\n from sklearn.utils.testing import ignore_warnings\nfrom skl2onnx import __version__ as skl2onnx_version\nfrom mlprodict.onnxrt.validate import enumerate_validated_operator_opsets, summary_report\nfrom mlprodict.onnxrt.doc.doc_write_helper import split_columns_subsets\n\n\nclass TestRtValidateGaussianMixture(ExtTestCase):\n\n @ignore_warnings(category=(UserWarning, ConvergenceWarning, RuntimeWarning))\n def test_rt_GaussianMixture_python(self):\n fLOG(__file__, self._testMethodName, OutputPrint=__name__ == \"__main__\")\n logger = getLogger('skl2onnx')\n logger.disabled = True\n verbose = 1 if __name__ == \"__main__\" else 0\n\n debug = False\n buffer = []\n\n def myprint(*args, **kwargs):\n buffer.append(\" \".join(map(str, args)))\n\n rows = list(enumerate_validated_operator_opsets(\n verbose, models={\"GaussianMixture\"}, opset_min=9,\n opset_max=11, fLOG=myprint,\n runtime='python', debug=debug,\n filter_exp=lambda m, p: 'mix' in p))\n self.assertGreater(len(rows), 1)\n self.assertIn('skl_nop', rows[-1])\n keys = set()\n for row in rows:\n keys.update(set(row))\n self.assertIn('onx_size', keys)\n piv = summary_report(DataFrame(rows))\n opset = [c for c in piv.columns if 'opset' in c]\n self.assertTrue('opset11' in opset or 'opset10' in opset)\n self.assertGreater(len(buffer), 1 if debug else 0)\n common, subsets = split_columns_subsets(piv)\n try:\n conv = df2rst(piv, split_col_common=common, # pylint: disable=E1123\n split_col_subsets=subsets)\n self.assertIn('| GaussianMixture |', conv)\n except TypeError as e:\n if \"got an unexpected keyword argument 'split_col_common'\" in str(e):\n return\n raise e\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
] | [
[
"pandas.DataFrame",
"sklearn.utils.testing.ignore_warnings"
]
] |
biolins/frivolous_dnns | [
"23d9a057ac517770cdfe9d8ac71543c328fcf76d"
] | [
"resnet/official/utils/misc/distribution_utils_test.py"
] | [
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\" Tests for distribution util functions.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport tensorflow as tf # pylint: disable=g-bad-import-order\n\nfrom official.utils.misc import distribution_utils\n\n\nclass GetDistributionStrategyTest(tf.test.TestCase):\n \"\"\"Tests for get_distribution_strategy.\"\"\"\n\n def test_one_device_strategy_cpu(self):\n ds = distribution_utils.get_distribution_strategy(num_gpus=0)\n self.assertEquals(ds.num_replicas_in_sync, 1)\n self.assertEquals(len(ds.extended.worker_devices), 1)\n self.assertIn('CPU', ds.extended.worker_devices[0])\n\n def test_one_device_strategy_gpu(self):\n ds = distribution_utils.get_distribution_strategy(num_gpus=1)\n self.assertEquals(ds.num_replicas_in_sync, 1)\n self.assertEquals(len(ds.extended.worker_devices), 1)\n self.assertIn('GPU', ds.extended.worker_devices[0])\n\n def test_mirrored_strategy(self):\n ds = distribution_utils.get_distribution_strategy(num_gpus=5)\n self.assertEquals(ds.num_replicas_in_sync, 5)\n self.assertEquals(len(ds.extended.worker_devices), 5)\n for device in ds.extended.worker_devices:\n self.assertIn('GPU', device)\n\n\nclass PerReplicaBatchSizeTest(tf.test.TestCase):\n \"\"\"Tests for per_replica_batch_size.\"\"\"\n\n def test_batch_size(self):\n self.assertEquals(\n distribution_utils.per_replica_batch_size(147, num_gpus=0), 147)\n self.assertEquals(\n distribution_utils.per_replica_batch_size(147, num_gpus=1), 147)\n self.assertEquals(\n distribution_utils.per_replica_batch_size(147, num_gpus=7), 21)\n\n def test_batch_size_with_remainder(self):\n with self.assertRaises(ValueError):\n distribution_utils.per_replica_batch_size(147, num_gpus=5)\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n"
] | [
[
"tensorflow.test.main"
]
] |
manueltonneau/simpletransformers | [
"7374b786857008e023604789e89c1690ad8bde97"
] | [
"simpletransformers/conv_ai/conv_ai_utils.py"
] | [
"# Copyright (c) 2019-present, HuggingFace Inc.\n# All rights reserved. This source code is licensed under the BSD-style license found in the\n# LICENSE file in the root directory of this source tree.\nimport json\nimport logging\nimport os\nimport socket\nimport tarfile\nimport tempfile\nfrom datetime import datetime\nfrom multiprocessing import Pool\n\nimport torch\nfrom tqdm.auto import tqdm\nfrom transformers import cached_path\n\nPERSONACHAT_URL = \"https://s3.amazonaws.com/datasets.huggingface.co/personachat/personachat_self_original.json\"\nHF_FINETUNED_MODEL = (\n \"https://s3.amazonaws.com/models.huggingface.co/transfer-learning-chatbot/gpt_personachat_cache.tar.gz\" # noqa\n)\n\nlogger = logging.getLogger(__file__)\n\n\ndef download_pretrained_model():\n \"\"\" Download and extract finetuned model from S3 \"\"\"\n resolved_archive_file = cached_path(HF_FINETUNED_MODEL)\n tempdir = tempfile.mkdtemp()\n logger.info(\"extracting archive file {} to temp dir {}\".format(resolved_archive_file, tempdir))\n with tarfile.open(resolved_archive_file, \"r:gz\") as archive:\n archive.extractall(tempdir)\n return tempdir\n\n\ndef tokenize_multi(data):\n obj, tokenizer = data\n if isinstance(obj, str):\n return tokenizer.convert_tokens_to_ids(tokenizer.tokenize(obj))\n if isinstance(obj, dict):\n return dict((n, tokenize_multi((o, tokenizer))) for n, o in obj.items())\n return list(tokenize_multi((o, tokenizer)) for o in obj)\n\n\ndef get_dataset(\n tokenizer,\n dataset_path,\n dataset_cache,\n process_count,\n proxies,\n evaluate=False,\n interact=False,\n no_cache=False,\n args=None,\n):\n \"\"\" Get tokenized PERSONACHAT dataset from S3 or cache.\"\"\"\n dataset_path = dataset_path or PERSONACHAT_URL\n\n mode = \"eval\" if evaluate else \"train\"\n if interact:\n mode = \"interact\"\n\n dataset_cache = (\n dataset_cache + \"_\" + type(tokenizer).__name__ + \"_\" + mode\n ) # To avoid using GPT cache for GPT-2 and vice-versa\n if dataset_cache and os.path.isfile(dataset_cache) and not no_cache:\n logger.info(\"Load tokenized dataset from cache at %s\", dataset_cache)\n dataset = torch.load(dataset_cache)\n else:\n logger.info(\"Download dataset from %s\", dataset_path)\n personachat_file = cached_path(dataset_path, proxies=proxies)\n with open(personachat_file, \"r\", encoding=\"utf-8\") as f:\n dataset = json.loads(f.read())\n\n logger.info(\"Tokenize and encode the dataset\")\n\n def tokenize(obj):\n if isinstance(obj, str):\n return tokenizer.convert_tokens_to_ids(tokenizer.tokenize(obj))\n if isinstance(obj, dict):\n return dict((n, tokenize(o)) for n, o in obj.items())\n\n data = [(d, tokenizer) for d in obj]\n\n if args.multiprocessing_chunksize == -1:\n chunksize = max(len(data) // (args.process_count * 2), 500)\n else:\n chunksize = args.multiprocessing_chunksize\n\n with Pool(process_count) as p:\n tokenized_data = list(tqdm(p.imap(tokenize_multi, data, chunksize=chunksize), total=len(data)))\n return tokenized_data\n\n if not interact and dataset_path == PERSONACHAT_URL:\n if not evaluate:\n dataset = dataset[\"train\"]\n else:\n dataset = dataset[\"valid\"]\n\n dataset = tokenize(dataset)\n torch.save(dataset, dataset_cache)\n return dataset\n\n\nclass AttrDict(dict):\n def __init__(self, *args, **kwargs):\n super(AttrDict, self).__init__(*args, **kwargs)\n self.__dict__ = self\n"
] | [
[
"torch.save",
"torch.load"
]
] |
laurentletg/pyradiomics | [
"b30a7fe086417999481bc6792dced4bf3dc3de32"
] | [
"radiomics/imageoperations.py"
] | [
"from __future__ import print_function\n\nimport logging\n\nimport numpy\nimport pywt\nimport SimpleITK as sitk\nimport six\nfrom six.moves import range\n\nlogger = logging.getLogger(__name__)\n\n\ndef getMask(mask, **kwargs):\n \"\"\"\n Function to get the correct mask. Includes enforcing a correct pixel data type (UInt32).\n\n Also supports extracting the mask for a segmentation (stored as SimpleITK Vector image) if necessary.\n In this case, the mask at index ``label_channel`` is extracted. The resulting 3D volume is then treated as it were a\n scalar input volume (i.e. with the region of interest defined by voxels with value matching ``label``).\n\n Finally, checks if the mask volume contains an ROI identified by ``label``. Raises a value error if the label is not\n present (including a list of valid labels found).\n\n :param mask: SimpleITK Image object representing the mask. Can be a vector image to allow for overlapping masks.\n :param kwargs: keyword arguments. If argument ``label_channel`` is present, this is used to select the channel.\n Otherwise label_channel ``0`` is assumed.\n :return: SimpleITK.Image with pixel type UInt32 representing the mask volume\n \"\"\"\n global logger\n label = kwargs.get('label', 1)\n label_channel = kwargs.get('label_channel', 0)\n if 'vector' in mask.GetPixelIDTypeAsString().lower():\n logger.debug('Mask appears to be a segmentation object (=stored as vector image).')\n n_components = mask.GetNumberOfComponentsPerPixel()\n assert label_channel < n_components, \\\n \"Mask %i requested, but segmentation object only contains %i objects\" % (label_channel, n_components)\n\n logger.info('Extracting mask at index %i', label_channel)\n selector = sitk.VectorIndexSelectionCastImageFilter()\n selector.SetIndex(label_channel)\n mask = selector.Execute(mask)\n\n logger.debug('Force casting mask to UInt32 to ensure correct datatype.')\n mask = sitk.Cast(mask, sitk.sitkUInt32)\n\n labels = numpy.unique(sitk.GetArrayFromImage(mask))\n if len(labels) == 1:\n raise ValueError('No labels found in this mask (i.e. nothing is segmented)!')\n if label not in labels:\n raise ValueError('Label (%g) not present in mask. Choose from %s' % (label, labels[labels != 0]))\n\n return mask\n\n\ndef getBinEdges(parameterValues, **kwargs):\n r\"\"\"\n Calculate and return the histogram using parameterValues (1D array of all segmented voxels in the image).\n\n **Fixed bin width:**\n\n Returns the bin edges, a list of the edges of the calculated bins, length is N(bins) + 1. Bins are defined such, that\n the bin edges are equally spaced from zero, and that the leftmost edge :math:`\\leq \\min(X_{gl})`. These bin edges\n represent the half-open ranges of each bin :math:`[\\text{lower_edge}, \\text{upper_edge})` and result in gray value\n discretization as follows:\n\n .. math::\n X_{b, i} = \\lfloor \\frac{X_{gl, i}}{W} \\rfloor - \\lfloor \\frac {\\min(X_{gl})}{W} \\rfloor + 1\n\n Here, :math:`X_{gl, i}` and :math:`X_{b, i}` are gray level intensities before and after discretization, respectively.\n :math:`{W}` is the bin width value (specfied in ``binWidth`` parameter). The first part of the formula ensures that\n the bins are equally spaced from 0, whereas the second part ensures that the minimum gray level intensity inside the\n ROI after binning is always 1.\n\n In the case where the maximum gray level intensity is equally dividable by the binWidth, i.e.\n :math:`\\max(X_{gl}) \\mod W = 0`, this will result in that maximum gray level being assigned to bin\n :math:`[\\max(X_{gl}), \\max(X_{gl}) + W)`, which is consistent with numpy.digitize, but different from the behaviour\n of numpy.histogram, where the final bin has a closed range, including the maximum gray level, i.e.\n :math:`[\\max(X_{gl}) - W, \\max(X_{gl})]`.\n\n .. note::\n This method is slightly different from the fixed bin size discretization method described by IBSI. The two most\n notable differences are 1) that PyRadiomics uses a floor division (and adds 1), as opposed to a ceiling division and\n 2) that in PyRadiomics, bins are always equally spaced from 0, as opposed to equally spaced from the minimum\n gray level intensity.\n\n *Example: for a ROI with values ranging from 54 to 166, and a bin width of 25, the bin edges will be [50, 75, 100,\n 125, 150, 175].*\n\n This value can be directly passed to ``numpy.histogram`` to generate a histogram or ``numpy.digitize`` to discretize\n the ROI gray values. See also :py:func:`binImage()`.\n\n **Fixed bin Count:**\n\n .. math::\n X_{b, i} = \\left\\{ {\\begin{array}{lcl}\n \\lfloor N_b\\frac{(X_{gl, i} - \\min(X_{gl})}{\\max(X_{gl}) - \\min(X_{gl})} \\rfloor + 1 &\n \\mbox{for} & X_{gl, i} < \\max(X_{gl}) \\\\\n N_b & \\mbox{for} & X_{gl, i} = \\max(X_{gl}) \\end{array}} \\right.\n\n Here, :math:`N_b` is the number of bins to use, as defined in ``binCount``.\n\n References\n\n - Leijenaar RTH, Nalbantov G, Carvalho S, et al. The effect of SUV discretization in quantitative FDG-PET Radiomics:\n the need for standardized methodology in tumor texture analysis. Sci Rep. 2015;5(August):11075.\n \"\"\"\n global logger\n binWidth = kwargs.get('binWidth', 25)\n binCount = kwargs.get('binCount')\n\n if binCount is not None:\n binEdges = numpy.histogram(parameterValues, binCount)[1]\n binEdges[-1] += 1 # Ensures that the maximum value is included in the topmost bin when using numpy.digitize\n else:\n minimum = min(parameterValues)\n maximum = max(parameterValues)\n\n # Start binning form the first value lesser than or equal to the minimum value and evenly dividable by binwidth\n lowBound = minimum - (minimum % binWidth)\n # Add + 2* binwidth to ensure the maximum value is included in the range generated by numpy.arange, and that values\n # equal to highbound are binned into a separate bin by numpy.histogram (This ensures ALL bins are half open, as\n # numpy.histogram treats the last bin as a closed interval. Moreover, this ensures consistency with numpy.digitize,\n # which will assign len(bins) + 1 to values equal to rightmost bin edge, treating all bins as half-open)\n highBound = maximum + 2 * binWidth\n\n binEdges = numpy.arange(lowBound, highBound, binWidth)\n\n # if min(parameterValues) % binWidth = 0 and min(parameterValues) = max(parameterValues), binEdges will only contain\n # 1 value. If this is the case (flat region) ensure that numpy.histogram creates 1 bin (requires 2 edges). For\n # numpy.histogram, a binCount (1) would also suffice, however, this is not accepted by numpy.digitize, which also uses\n # binEdges calculated by this function.\n if len(binEdges) == 1: # Flat region, ensure that there is 1 bin\n binEdges = [binEdges[0] - .5, binEdges[0] + .5] # Simulates binEdges returned by numpy.histogram if bins = 1\n\n logger.debug('Calculated %d bins for bin width %g with edges: %s)', len(binEdges) - 1, binWidth, binEdges)\n\n return binEdges # numpy.histogram(parameterValues, bins=binedges)\n\n\ndef binImage(parameterMatrix, parameterMatrixCoordinates=None, **kwargs):\n r\"\"\"\n Discretizes the parameterMatrix (matrix representation of the gray levels in the ROI) using the binEdges calculated\n using :py:func:`getBinEdges`. Only voxels defined by parameterMatrixCoordinates (defining the segmentation) are used\n for calculation of histogram and subsequently discretized. Voxels outside segmentation are left unchanged.\n \"\"\"\n global logger\n logger.debug('Discretizing gray levels inside ROI')\n\n discretizedParameterMatrix = numpy.zeros(parameterMatrix.shape, dtype='int')\n if parameterMatrixCoordinates is None:\n binEdges = getBinEdges(parameterMatrix.flatten(), **kwargs)\n discretizedParameterMatrix = numpy.digitize(parameterMatrix, binEdges)\n else:\n binEdges = getBinEdges(parameterMatrix[parameterMatrixCoordinates], **kwargs)\n discretizedParameterMatrix[parameterMatrixCoordinates] = numpy.digitize(parameterMatrix[parameterMatrixCoordinates], binEdges)\n\n return discretizedParameterMatrix, binEdges\n\n\ndef checkMask(imageNode, maskNode, **kwargs):\n \"\"\"\n Checks whether the Region of Interest (ROI) defined in the mask size and dimensions match constraints, specified in\n settings. The following checks are performed.\n\n 1. Check whether the mask corresponds to the image (i.e. has a similar size, spacing, direction and origin). **N.B.\n This check is performed by SimpleITK, if it fails, an error is logged, with additional error information from\n SimpleITK logged with level DEBUG (i.e. logging-level has to be set to debug to store this information in the log\n file).** The tolerance can be increased using the ``geometryTolerance`` parameter. Alternatively, if the\n ``correctMask`` parameter is ``True``, PyRadiomics will check if the mask contains a valid ROI (inside image\n physical area) and if so, resample the mask to image geometry. See :ref:`radiomics-settings-label` for more info.\n\n 2. Check if the label is present in the mask\n 3. Count the number of dimensions in which the size of the ROI > 1 (i.e. does the ROI represent a single voxel (0), a\n line (1), a surface (2) or a volume (3)) and compare this to the minimum number of dimension required (specified in\n ``minimumROIDimensions``).\n 4. Optional. Check if there are at least N voxels in the ROI. N is defined in ``minimumROISize``, this test is skipped\n if ``minimumROISize = None``.\n\n This function returns a tuple of two items. The first item is the bounding box of the mask. The second item is the\n mask that has been corrected by resampling to the input image geometry (if that resampling was successful).\n\n If a check fails, a ValueError is raised. No features will be extracted for this mask.\n If the mask passes all tests, this function returns the bounding box, which is used in the :py:func:`cropToTumorMask`\n function.\n\n The bounding box is calculated during (1.) and used for the subsequent checks. The bounding box is\n calculated by SimpleITK.LabelStatisticsImageFilter() and returned as a tuple of indices: (L_x, U_x, L_y, U_y, L_z,\n U_z), where 'L' and 'U' are lower and upper bound, respectively, and 'x', 'y' and 'z' the three image dimensions.\n\n By reusing the bounding box calculated here, calls to SimpleITK.LabelStatisticsImageFilter() are reduced, improving\n performance.\n\n Uses the following settings:\n\n - minimumROIDimensions [1]: Integer, range 1-3, specifies the minimum dimensions (1D, 2D or 3D, respectively).\n Single-voxel segmentations are always excluded.\n - minimumROISize [None]: Integer, > 0, specifies the minimum number of voxels required. Test is skipped if\n this parameter is set to None.\n\n .. note::\n\n If the first check fails there are generally 2 possible causes:\n\n 1. The image and mask are matched, but there is a slight difference in origin, direction or spacing. The exact\n cause, difference and used tolerance are stored with level DEBUG in a log (if enabled). For more information on\n setting up logging, see \":ref:`setting up logging <radiomics-logging-label>`\" and the helloRadiomics examples\n (located in the ``pyradiomics/examples`` folder). This problem can be fixed by changing the global tolerance\n (``geometryTolerance`` parameter) or enabling mask correction (``correctMask`` parameter).\n 2. The image and mask do not match, but the ROI contained within the mask does represent a physical volume\n contained within the image. If this is the case, resampling is needed to ensure matching geometry between image\n and mask before features can be extracted. This can be achieved by enabling mask correction using the\n ``correctMask`` parameter.\n \"\"\"\n global logger\n\n correctedMask = None\n\n label = kwargs.get('label', 1)\n minDims = kwargs.get('minimumROIDimensions', 2)\n minSize = kwargs.get('minimumROISize', None)\n\n logger.debug('Checking mask with label %d', label)\n logger.debug('Calculating bounding box')\n # Determine bounds\n lsif = sitk.LabelStatisticsImageFilter()\n try:\n lsif.Execute(imageNode, maskNode)\n\n # If lsif fails, and mask is corrected, it includes a check whether the label is present. Therefore, perform\n # this test here only if lsif does not fail on the first attempt.\n if label not in lsif.GetLabels():\n raise ValueError('Label (%g) not present in mask' % label)\n except RuntimeError as e:\n # If correctMask = True, try to resample the mask to the image geometry, otherwise return None (\"fail\")\n if not kwargs.get('correctMask', False):\n if \"Both images for LabelStatisticsImageFilter don't match type or dimension!\" in e.args[0]:\n logger.debug('Additional information on error.', exc_info=True)\n raise ValueError('Image/Mask datatype or size mismatch. Potential fix: enable correctMask, see '\n 'Documentation:Usage:Customizing the Extraction:Settings:correctMask for more information')\n elif \"Inputs do not occupy the same physical space!\" in e.args[0]:\n logger.debug('Additional information on error.', exc_info=True)\n raise ValueError('Image/Mask geometry mismatch. Potential fix: increase tolerance using geometryTolerance, '\n 'see Documentation:Usage:Customizing the Extraction:Settings:geometryTolerance for more '\n 'information')\n else:\n raise e # unhandled error\n\n logger.warning('Image/Mask geometry mismatch, attempting to correct Mask')\n\n correctedMask = _correctMask(imageNode, maskNode, **kwargs) # Raises Value error if ROI outside image physical space\n\n # Resampling successful, try to calculate boundingbox\n try:\n lsif.Execute(imageNode, correctedMask)\n except RuntimeError:\n logger.debug('Bounding box calculation with resampled mask failed', exc_info=True)\n raise ValueError('Calculation of bounding box failed, for more information run with DEBUG logging and check log')\n\n # LBound and UBound of the bounding box, as (L_X, U_X, L_Y, U_Y, L_Z, U_Z)\n boundingBox = numpy.array(lsif.GetBoundingBox(label))\n\n logger.debug('Checking minimum number of dimensions requirements (%d)', minDims)\n ndims = numpy.sum((boundingBox[1::2] - boundingBox[0::2] + 1) > 1) # UBound - LBound + 1 = Size\n if ndims == 0:\n raise ValueError('mask only contains 1 segmented voxel! Cannot extract features for a single voxel.')\n elif ndims < minDims:\n raise ValueError('mask has too few dimensions (number of dimensions %d, minimum required %d)' % (ndims, minDims))\n\n if minSize is not None:\n logger.debug('Checking minimum size requirements (minimum size: %d)', minSize)\n roiSize = lsif.GetCount(label)\n if roiSize <= minSize:\n raise ValueError('Size of the ROI is too small (minimum size: %g, ROI size: %g' % (minSize, roiSize))\n\n return boundingBox, correctedMask\n\n\ndef _correctMask(imageNode, maskNode, **kwargs):\n \"\"\"\n If the mask geometry does not match the image geometry, this function can be used to resample the mask to the image\n physical space.\n\n First, the mask is checked for a valid ROI (i.e. maskNode contains an ROI with the given label value, which does not\n include areas outside of the physical image bounds).\n\n If the ROI is valid, the maskNode is resampled using the imageNode as a reference image and a nearest neighbor\n interpolation.\n\n If the ROI is valid, the resampled mask is returned, otherwise ``None`` is returned.\n \"\"\"\n global logger\n logger.debug('Resampling mask to image geometry')\n\n _checkROI(imageNode, maskNode, **kwargs) # Raises a value error if ROI is invalid\n\n rif = sitk.ResampleImageFilter()\n rif.SetReferenceImage(imageNode)\n rif.SetInterpolator(sitk.sitkNearestNeighbor)\n\n logger.debug('Resampling...')\n\n return rif.Execute(maskNode)\n\n\ndef _checkROI(imageNode, maskNode, **kwargs):\n \"\"\"\n Check whether maskNode contains a valid ROI defined by label:\n\n 1. Check whether the label value is present in the maskNode.\n 2. Check whether the ROI defined by the label does not include an area outside the physical area of the image.\n\n For the second check, a tolerance of 1e-3 is allowed.\n\n If the ROI is valid, the bounding box (lower bounds, followd by size in all dimensions (X, Y, Z ordered)) is\n returned. Otherwise, a ValueError is raised.\n \"\"\"\n global logger\n label = kwargs.get('label', 1)\n\n logger.debug('Checking ROI validity')\n\n # Determine bounds of cropped volume in terms of original Index coordinate space\n lssif = sitk.LabelShapeStatisticsImageFilter()\n lssif.Execute(maskNode)\n\n logger.debug('Checking if label %d is persent in the mask', label)\n if label not in lssif.GetLabels():\n raise ValueError('Label (%d) not present in mask', label)\n\n # LBound and size of the bounding box, as (L_X, L_Y, [L_Z], S_X, S_Y, [S_Z])\n bb = numpy.array(lssif.GetBoundingBox(label))\n Nd = maskNode.GetDimension()\n\n # Determine if the ROI is within the physical space of the image\n\n logger.debug('Comparing physical space of bounding box to physical space of image')\n # Step 1: Get the origin and UBound corners of the bounding box in physical space\n # The additional 0.5 represents the difference between the voxel center and the voxel corner\n # Upper bound index of ROI = bb[:Nd] + bb[Nd:] - 1 (LBound + Size - 1), .5 is added to get corner\n ROIBounds = (maskNode.TransformContinuousIndexToPhysicalPoint(bb[:Nd] - .5), # Origin\n maskNode.TransformContinuousIndexToPhysicalPoint(bb[:Nd] + bb[Nd:] - 0.5)) # UBound\n # Step 2: Translate the ROI physical bounds to the image coordinate space\n ROIBounds = (imageNode.TransformPhysicalPointToContinuousIndex(ROIBounds[0]), # Origin\n imageNode.TransformPhysicalPointToContinuousIndex(ROIBounds[1]))\n\n logger.debug('ROI bounds (image coordinate space): %s', ROIBounds)\n\n # Check if any of the ROI bounds are outside the image indices (i.e. -0.5 < ROI < Im.Size -0.5)\n # The additional 0.5 is to allow for different spacings (defines the edges, not the centers of the edge-voxels\n tolerance = 1e-3 # Define a tolerance to correct for machine precision errors\n if numpy.any(numpy.min(ROIBounds, axis=0) < (- .5 - tolerance)) or \\\n numpy.any(numpy.max(ROIBounds, axis=0) > (numpy.array(imageNode.GetSize()) - .5 + tolerance)):\n raise ValueError('Bounding box of ROI is larger than image space:\\n\\t'\n 'ROI bounds (x, y, z image coordinate space) %s\\n\\tImage Size %s' %\n (ROIBounds, imageNode.GetSize()))\n\n logger.debug('ROI valid, calculating resampling grid')\n\n return bb\n\n\ndef cropToTumorMask(imageNode, maskNode, boundingBox, **kwargs):\n \"\"\"\n Create a sitkImage of the segmented region of the image based on the input label.\n\n Create a sitkImage of the labelled region of the image, cropped to have a\n cuboid shape equal to the ijk boundaries of the label.\n\n :param boundingBox: The bounding box used to crop the image. This is the bounding box as returned by\n :py:func:`checkMask`.\n :param label: [1], value of the label, onto which the image and mask must be cropped.\n :return: Cropped image and mask (SimpleITK image instances).\n\n \"\"\"\n global logger\n padDistance = kwargs.get('padDistance', 0)\n\n size = numpy.array(maskNode.GetSize())\n\n ijkMinBounds = boundingBox[0::2] - padDistance\n ijkMaxBounds = size - boundingBox[1::2] - padDistance - 1\n\n # Ensure cropped area is not outside original image bounds\n ijkMinBounds = numpy.maximum(ijkMinBounds, 0)\n ijkMaxBounds = numpy.maximum(ijkMaxBounds, 0)\n\n # Crop Image\n logger.debug('Cropping to size %s', (boundingBox[1::2] - boundingBox[0::2]) + 1)\n cif = sitk.CropImageFilter()\n try:\n cif.SetLowerBoundaryCropSize(ijkMinBounds)\n cif.SetUpperBoundaryCropSize(ijkMaxBounds)\n except TypeError:\n # newer versions of SITK/python want a tuple or list\n cif.SetLowerBoundaryCropSize(ijkMinBounds.tolist())\n cif.SetUpperBoundaryCropSize(ijkMaxBounds.tolist())\n croppedImageNode = cif.Execute(imageNode)\n croppedMaskNode = cif.Execute(maskNode)\n\n return croppedImageNode, croppedMaskNode\n\n\ndef resampleImage(imageNode, maskNode, **kwargs):\n \"\"\"\n Resamples image and mask to the specified pixel spacing (The default interpolator is Bspline).\n\n Resampling can be enabled using the settings 'interpolator' and 'resampledPixelSpacing' in the parameter file or as\n part of the settings passed to the feature extractor. See also\n :ref:`feature extractor <radiomics-featureextractor-label>`.\n\n 'imageNode' and 'maskNode' are SimpleITK Objects, and 'resampledPixelSpacing' is the output pixel spacing (sequence of\n 3 elements).\n\n If only in-plane resampling is required, set the output pixel spacing for the out-of-plane dimension (usually the last\n dimension) to 0. Spacings with a value of 0 are replaced by the spacing as it is in the original mask.\n\n Only part of the image and labelmap are resampled. The resampling grid is aligned to the input origin, but only voxels\n covering the area of the image ROI (defined by the bounding box) and the padDistance are resampled. This results in a\n resampled and partially cropped image and mask. Additional padding is required as some filters also sample voxels\n outside of segmentation boundaries. For feature calculation, image and mask are cropped to the bounding box without\n any additional padding, as the feature classes do not need the gray level values outside the segmentation.\n\n The resampling grid is calculated using only the input mask. Even when image and mask have different directions, both\n the cropped image and mask will have the same direction (equal to direction of the mask). Spacing and size are\n determined by settings and bounding box of the ROI.\n\n .. note::\n Before resampling the bounds of the non-padded ROI are compared to the bounds. If the ROI bounding box includes\n areas outside of the physical space of the image, an error is logged and (None, None) is returned. No features will\n be extracted. This enables the input image and mask to have different geometry, so long as the ROI defines an area\n within the image.\n\n .. note::\n The additional padding is adjusted, so that only the physical space within the mask is resampled. This is done to\n prevent resampling outside of the image. Please note that this assumes the image and mask to image the same physical\n space. If this is not the case, it is possible that voxels outside the image are included in the resampling grid,\n these will be assigned a value of 0. It is therefore recommended, but not enforced, to use an input mask which has\n the same or a smaller physical space than the image.\n \"\"\"\n global logger\n resampledPixelSpacing = kwargs['resampledPixelSpacing']\n interpolator = kwargs.get('interpolator', sitk.sitkBSpline)\n padDistance = kwargs.get('padDistance', 5)\n label = kwargs.get('label', 1)\n\n logger.debug('Resampling image and mask')\n\n if imageNode is None or maskNode is None:\n raise ValueError('Requires both image and mask to resample')\n\n maskSpacing = numpy.array(maskNode.GetSpacing())\n imageSpacing = numpy.array(imageNode.GetSpacing())\n\n Nd_resampled = len(resampledPixelSpacing)\n Nd_mask = len(maskSpacing)\n assert Nd_resampled == Nd_mask, \\\n 'Wrong dimensionality (%i-D) of resampledPixelSpacing!, %i-D required' % (Nd_resampled, Nd_mask)\n\n # If spacing for a direction is set to 0, use the original spacing (enables \"only in-slice\" resampling)\n logger.debug('Where resampled spacing is set to 0, set it to the original spacing (mask)')\n resampledPixelSpacing = numpy.array(resampledPixelSpacing)\n resampledPixelSpacing = numpy.where(resampledPixelSpacing == 0, maskSpacing, resampledPixelSpacing)\n\n # Check if the maskNode contains a valid ROI. If ROI is valid, the bounding box needed to calculate the resampling\n # grid is returned.\n bb = _checkROI(imageNode, maskNode, **kwargs)\n\n # Do not resample in those directions where labelmap spans only one slice.\n maskSize = numpy.array(maskNode.GetSize())\n resampledPixelSpacing = numpy.where(bb[Nd_mask:] != 1, resampledPixelSpacing, maskSpacing)\n\n # If current spacing is equal to resampledPixelSpacing, no interpolation is needed\n # Tolerance = 1e-5 + 1e-8*abs(resampledSpacing)\n logger.debug('Comparing resampled spacing to original spacing (image')\n if numpy.allclose(imageSpacing, resampledPixelSpacing):\n logger.info('New spacing equal to original image spacing, just resampling the mask')\n\n # Ensure that image and mask geometry match\n rif = sitk.ResampleImageFilter()\n rif.SetReferenceImage(imageNode)\n rif.SetInterpolator(sitk.sitkNearestNeighbor)\n maskNode = rif.Execute(maskNode)\n\n # re-calculate the bounding box of the mask\n lssif = sitk.LabelShapeStatisticsImageFilter()\n lssif.Execute(maskNode)\n bb = numpy.array(lssif.GetBoundingBox(label))\n\n low_up_bb = numpy.empty(Nd_mask * 2, dtype=int)\n low_up_bb[::2] = bb[:3]\n low_up_bb[1::2] = bb[:3] + bb[3:] - 1\n return cropToTumorMask(imageNode, maskNode, low_up_bb, **kwargs)\n\n spacingRatio = maskSpacing / resampledPixelSpacing\n\n # Determine bounds of cropped volume in terms of new Index coordinate space,\n # round down for lowerbound and up for upperbound to ensure entire segmentation is captured (prevent data loss)\n # Pad with an extra .5 to prevent data loss in case of upsampling. For Ubound this is (-1 + 0.5 = -0.5)\n bbNewLBound = numpy.floor((bb[:Nd_mask] - 0.5) * spacingRatio - padDistance)\n bbNewUBound = numpy.ceil((bb[:Nd_mask] + bb[Nd_mask:] - 0.5) * spacingRatio + padDistance)\n\n # Ensure resampling is not performed outside bounds of original image\n maxUbound = numpy.ceil(maskSize * spacingRatio) - 1\n bbNewLBound = numpy.where(bbNewLBound < 0, 0, bbNewLBound)\n bbNewUBound = numpy.where(bbNewUBound > maxUbound, maxUbound, bbNewUBound)\n\n # Calculate the new size. Cast to int to prevent error in sitk.\n newSize = numpy.array(bbNewUBound - bbNewLBound + 1, dtype='int').tolist()\n\n # Determine continuous index of bbNewLBound in terms of the original Index coordinate space\n bbOriginalLBound = bbNewLBound / spacingRatio\n\n # Origin is located in center of first voxel, e.g. 1/2 of the spacing\n # from Corner, which corresponds to 0 in the original Index coordinate space.\n # The new spacing will be in 0 the new Index coordinate space. Here we use continuous\n # index to calculate where the new 0 of the new Index coordinate space (of the original volume\n # in terms of the original spacing, and add the minimum bounds of the cropped area to\n # get the new Index coordinate space of the cropped volume in terms of the original Index coordinate space.\n # Then use the ITK functionality to bring the continuous index into the physical space (mm)\n newOriginIndex = numpy.array(.5 * (resampledPixelSpacing - maskSpacing) / maskSpacing)\n newCroppedOriginIndex = newOriginIndex + bbOriginalLBound\n newOrigin = maskNode.TransformContinuousIndexToPhysicalPoint(newCroppedOriginIndex)\n\n imagePixelType = imageNode.GetPixelID()\n maskPixelType = maskNode.GetPixelID()\n\n direction = numpy.array(maskNode.GetDirection())\n\n logger.info('Applying resampling from spacing %s and size %s to spacing %s and size %s',\n maskSpacing, maskSize, resampledPixelSpacing, newSize)\n\n try:\n if isinstance(interpolator, six.string_types):\n interpolator = getattr(sitk, interpolator)\n except Exception:\n logger.warning('interpolator \"%s\" not recognized, using sitkBSpline', interpolator)\n interpolator = sitk.sitkBSpline\n\n rif = sitk.ResampleImageFilter()\n\n rif.SetOutputSpacing(resampledPixelSpacing)\n rif.SetOutputDirection(direction)\n rif.SetSize(newSize)\n rif.SetOutputOrigin(newOrigin)\n\n logger.debug('Resampling image')\n rif.SetOutputPixelType(imagePixelType)\n rif.SetInterpolator(interpolator)\n resampledImageNode = rif.Execute(imageNode)\n\n logger.debug('Resampling mask')\n rif.SetOutputPixelType(maskPixelType)\n rif.SetInterpolator(sitk.sitkNearestNeighbor)\n resampledMaskNode = rif.Execute(maskNode)\n\n return resampledImageNode, resampledMaskNode\n\n\ndef normalizeImage(image, **kwargs):\n r\"\"\"\n Normalizes the image by centering it at the mean with standard deviation. Normalization is based on all gray values in\n the image, not just those inside the segementation.\n\n :math:`f(x) = \\frac{s(x - \\mu_x)}{\\sigma_x}`\n\n Where:\n\n - :math:`x` and :math:`f(x)` are the original and normalized intensity, respectively.\n - :math:`\\mu_x` and :math:`\\sigma_x` are the mean and standard deviation of the image instensity values.\n - :math:`s` is an optional scaling defined by ``scale``. By default, it is set to 1.\n\n Optionally, outliers can be removed, in which case values for which :math:`x > \\mu_x + n\\sigma_x` or\n :math:`x < \\mu_x - n\\sigma_x` are set to :math:`\\mu_x + n\\sigma_x` and :math:`\\mu_x - n\\sigma_x`, respectively.\n Here, :math:`n>0` and defined by ``outliers``. This, in turn, is controlled by the ``removeOutliers`` parameter.\n Removal of outliers is done after the values of the image are normalized, but before ``scale`` is applied.\n \"\"\"\n global logger\n scale = kwargs.get('normalizeScale', 1)\n outliers = kwargs.get('removeOutliers')\n\n logger.debug('Normalizing image with scale %d', scale)\n image = sitk.Normalize(image)\n\n if outliers is not None:\n logger.debug('Removing outliers > %g standard deviations', outliers)\n imageArr = sitk.GetArrayFromImage(image)\n\n imageArr[imageArr > outliers] = outliers\n imageArr[imageArr < -outliers] = -outliers\n\n newImage = sitk.GetImageFromArray(imageArr)\n newImage.CopyInformation(image)\n image = newImage\n\n image *= scale\n\n return image\n\n\ndef resegmentMask(imageNode, maskNode, **kwargs):\n r\"\"\"\n Resegment the Mask based on the range specified by the threshold(s) in ``resegmentRange``. Either 1 or 2 thresholds\n can be defined. In case of 1 threshold, all values equal to or higher than that threshold are included. If there are\n 2 thresholds, all voxels with a value inside the closed-range defined by these thresholds is included\n (i.e. a voxels is included if :math:`T_{lower} \\leq X_gl \\leq T_{upper}`).\n The resegmented mask is therefore always equal or smaller in size than the original mask.\n In the case where either resegmentRange or resegmentMode contains illigal values, a ValueError is raised.\n\n There are 3 modes for defining the threshold:\n\n 1. absolute (default): The values in resegmentRange define as absolute values (i.e. corresponding to the gray values\n in the image\n 2. relative: The values in resegmentRange define the threshold as relative to the maximum value found in the ROI.\n (e.g. 0.5 indicates a threshold at 50% of maximum gray value)\n 3. sigma: The threshold is defined as the number of sigma from the mean. (e.g. resegmentRange [-3, 3] will include\n all voxels that have a value that differs 3 or less standard deviations from the mean).\n\n \"\"\"\n global logger\n resegmentRange = kwargs['resegmentRange']\n resegmentMode = kwargs.get('resegmentMode', 'absolute')\n label = kwargs.get('label', 1)\n\n if resegmentRange is None:\n raise ValueError('resegmentRange is None.')\n if len(resegmentRange) == 0 or len(resegmentRange) > 2:\n raise ValueError('Length %i is not allowed for resegmentRange' % len(resegmentRange))\n\n logger.debug('Resegmenting mask (range %s, mode %s)', resegmentRange, resegmentMode)\n\n im_arr = sitk.GetArrayFromImage(imageNode)\n ma_arr = (sitk.GetArrayFromImage(maskNode) == label) # boolean array\n\n oldSize = numpy.sum(ma_arr)\n\n if resegmentMode == 'absolute':\n logger.debug('Resegmenting in absolute mode')\n thresholds = sorted(resegmentRange)\n elif resegmentMode == 'relative':\n max_gl = numpy.max(im_arr[ma_arr])\n logger.debug('Resegmenting in relative mode, max %g', max_gl)\n thresholds = [max_gl * th for th in sorted(resegmentRange)]\n elif resegmentMode == 'sigma':\n mean_gl = numpy.mean(im_arr[ma_arr])\n sd_gl = numpy.std(im_arr[ma_arr])\n logger.debug('Resegmenting in sigma mode, mean %g, std %g', mean_gl, sd_gl)\n thresholds = [mean_gl + sd_gl * th for th in sorted(resegmentRange)]\n else:\n raise ValueError('Resegment mode %s not recognized.' % resegmentMode)\n\n # Apply lower threshold\n logger.debug('Applying lower threshold (%g)', thresholds[0])\n ma_arr[ma_arr] = im_arr[ma_arr] >= thresholds[0]\n\n # If 2 thresholds are defined, also apply an upper threshold\n if len(thresholds) == 2:\n logger.debug('Applying upper threshold (%g)', thresholds[1])\n ma_arr[ma_arr] = im_arr[ma_arr] <= thresholds[1]\n\n roiSize = numpy.sum(ma_arr)\n\n if roiSize <= 1:\n raise ValueError(\"Resegmentation excluded too many voxels with label %i (retained %i voxel(s))! \"\n \"Cannot extract features\" % (label, roiSize))\n\n # Transform the boolean array back to an image with the correct voxels set to the label value\n newMask_arr = numpy.zeros(ma_arr.shape, dtype='int')\n newMask_arr[ma_arr] = label\n\n newMask = sitk.GetImageFromArray(newMask_arr)\n newMask.CopyInformation(maskNode)\n logger.debug('Resegmentation complete, new size: %d voxels (excluded %d voxels)', roiSize, oldSize - roiSize)\n\n return newMask\n\n\ndef getOriginalImage(inputImage, inputMask, **kwargs):\n \"\"\"\n This function does not apply any filter, but returns the original image. This function is needed to\n dynamically expose the original image as a valid image type.\n\n :return: Yields original image, 'original' and ``kwargs``\n \"\"\"\n global logger\n logger.debug('Yielding original image')\n yield inputImage, 'original', kwargs\n\n\ndef getLoGImage(inputImage, inputMask, **kwargs):\n r\"\"\"\n Applies a Laplacian of Gaussian filter to the input image and yields a derived image for each sigma value specified.\n\n A Laplacian of Gaussian image is obtained by convolving the image with the second derivative (Laplacian) of a Gaussian\n kernel.\n\n The Gaussian kernel is used to smooth the image and is defined as\n\n .. math::\n\n G(x, y, z, \\sigma) = \\frac{1}{(\\sigma \\sqrt{2 \\pi})^3}e^{-\\frac{x^2 + y^2 + z^2}{2\\sigma^2}}\n\n The Gaussian kernel is convolved by the laplacian kernel :math:`\\nabla^2G(x, y, z)`, which is sensitive to areas with\n rapidly changing intensities, enhancing edges. The width of the filter in the Gaussian kernel is determined by\n :math:`\\sigma` and can be used to emphasize more fine (low :math:`\\sigma` values) or coarse (high :math:`\\sigma`\n values) textures.\n\n .. warning::\n\n The LoG filter implemented in PyRadiomics is a 3D LoG filter, and therefore requires 3D input. Features using a\n single slice (2D) segmentation can still be extracted, but the input image *must* be a 3D image, with a minimum size\n in all dimensions :math:`\\geq \\sigma`. If input image is too small, a warning is logged and :math:`\\sigma` value is\n skipped. Moreover, the image size *must* be at least 4 voxels in each dimensions, if this constraint is not met, no\n LoG derived images can be generated.\n\n Following settings are possible:\n\n - sigma: List of floats or integers, must be greater than 0. Filter width (mm) to use for the Gaussian kernel\n (determines coarseness).\n\n .. warning::\n Setting for sigma must be provided. If omitted, no LoG image features are calculated and the function\n will return an empty dictionary.\n\n Returned filter name reflects LoG settings:\n log-sigma-<sigmaValue>-3D.\n\n References:\n\n - `SimpleITK Doxygen documentation\n <https://itk.org/SimpleITKDoxygen/html/classitk_1_1simple_1_1LaplacianRecursiveGaussianImageFilter.html>`_\n - `ITK Doxygen documentation <https://itk.org/Doxygen/html/classitk_1_1LaplacianRecursiveGaussianImageFilter.html>`_\n - `<https://en.wikipedia.org/wiki/Blob_detection#The_Laplacian_of_Gaussian>`_\n\n :return: Yields log filtered image for each specified sigma, corresponding image type name and ``kwargs`` (customized\n settings).\n \"\"\"\n global logger\n\n logger.debug('Generating LoG images')\n\n # Check if size of image is > 4 in all 3D directions (otherwise, LoG filter will fail)\n size = numpy.array(inputImage.GetSize())\n spacing = numpy.array(inputImage.GetSpacing())\n\n if numpy.min(size) < 4:\n logger.warning('Image too small to apply LoG filter, size: %s', size)\n return\n\n sigmaValues = kwargs.get('sigma', [])\n\n for sigma in sigmaValues:\n logger.info('Computing LoG with sigma %g', sigma)\n\n if sigma > 0.0:\n if numpy.all(size >= numpy.ceil(sigma / spacing) + 1):\n lrgif = sitk.LaplacianRecursiveGaussianImageFilter()\n lrgif.SetNormalizeAcrossScale(True)\n lrgif.SetSigma(sigma)\n inputImageName = 'log-sigma-%s-mm-3D' % (str(sigma).replace('.', '-'))\n logger.debug('Yielding %s image', inputImageName)\n yield lrgif.Execute(inputImage), inputImageName, kwargs\n else:\n logger.warning('applyLoG: sigma(%g)/spacing(%s) + 1 must be greater than the size(%s) of the inputImage',\n sigma,\n spacing,\n size)\n else:\n logger.warning('applyLoG: sigma must be greater than 0.0: %g', sigma)\n\n\ndef getWaveletImage(inputImage, inputMask, **kwargs):\n \"\"\"\n Applies wavelet filter to the input image and yields the decompositions and the approximation.\n\n Following settings are possible:\n\n - start_level [0]: integer, 0 based level of wavelet which should be used as first set of decompositions\n from which a signature is calculated\n - level [1]: integer, number of levels of wavelet decompositions from which a signature is calculated.\n - wavelet [\"coif1\"]: string, type of wavelet decomposition. Enumerated value, validated against possible values\n present in the ``pyWavelet.wavelist()``. Current possible values (pywavelet version 0.4.0) (where an\n aditional number is needed, range of values is indicated in []):\n\n - haar\n - dmey\n - sym[2-20]\n - db[1-20]\n - coif[1-5]\n - bior[1.1, 1.3, 1.5, 2.2, 2.4, 2.6, 2.8, 3.1, 3.3, 3.5, 3.7, 3.9, 4.4, 5.5, 6.8]\n - rbio[1.1, 1.3, 1.5, 2.2, 2.4, 2.6, 2.8, 3.1, 3.3, 3.5, 3.7, 3.9, 4.4, 5.5, 6.8]\n\n Returned filter name reflects wavelet type:\n wavelet[level]-<decompositionName>\n\n N.B. only levels greater than the first level are entered into the name.\n\n :return: Yields each wavelet decomposition and final approximation, corresponding imaget type name and ``kwargs``\n (customized settings).\n \"\"\"\n global logger\n\n logger.debug('Generating Wavelet images')\n\n Nd = inputImage.GetDimension()\n axes = list(range(Nd - 1, -1, -1))\n if kwargs.get('force2D', False):\n axes.remove(kwargs.get('force2Ddimension', 0))\n\n approx, ret = _swt3(inputImage, tuple(axes), **kwargs)\n\n for idx, wl in enumerate(ret, start=1):\n for decompositionName, decompositionImage in wl.items():\n logger.info('Computing Wavelet %s', decompositionName)\n\n if idx == 1:\n inputImageName = 'wavelet-%s' % (decompositionName)\n else:\n inputImageName = 'wavelet%s-%s' % (idx, decompositionName)\n logger.debug('Yielding %s image', inputImageName)\n yield decompositionImage, inputImageName, kwargs\n\n if len(ret) == 1:\n inputImageName = 'wavelet-%s' % ('L' * len(axes))\n else:\n inputImageName = 'wavelet%s-%s' % (len(ret), ('L' * len(axes)))\n logger.debug('Yielding approximation (%s) image', inputImageName)\n yield approx, inputImageName, kwargs\n\n\ndef _swt3(inputImage, axes, **kwargs): # Stationary Wavelet Transform 3D\n wavelet = kwargs.get('wavelet', 'coif1')\n level = kwargs.get('level', 1)\n start_level = kwargs.get('start_level', 0)\n\n matrix = sitk.GetArrayFromImage(inputImage) # This function gets a numpy array from the SimpleITK Image \"inputImage\"\n matrix = numpy.asarray(matrix) # The function np.asarray converts \"matrix\" (which could be also a tuple) into an array.\n\n original_shape = matrix.shape\n # original_shape becomes a tuple (?,?,?) containing the number of rows, columns, and slices of the image\n # this is of course dependent on the number of dimensions, but the same principle holds\n padding = tuple([(0, 1 if dim % 2 != 0 else 0) for dim in original_shape])\n # padding is necessary because of pywt.swtn (see function Notes)\n data = matrix.copy() # creates a modifiable copy of \"matrix\" and we call it \"data\"\n data = numpy.pad(data, padding, 'wrap') # padding the tuple \"padding\" previously computed\n\n if not isinstance(wavelet, pywt.Wavelet):\n wavelet = pywt.Wavelet(wavelet)\n\n for i in range(0, start_level): # if start_level = 0 (default) this for loop never gets executed\n # compute all decompositions and saves them in \"dec\" dict\n dec = pywt.swtn(data, wavelet, level=1, start_level=0, axes=axes)[0]\n # copies in \"data\" just the \"aaa\" decomposition (i.e. approximation; No of consecutive 'a's = len(axes))\n data = dec['a' * len(axes)].copy()\n\n ret = [] # initialize empty list\n for i in range(start_level, start_level + level):\n # compute the n-dimensional stationary wavelet transform\n dec = pywt.swtn(data, wavelet, level=1, start_level=0, axes=axes)[0]\n # Copy the approximation into data (approximation in output / input for next levels)\n data = dec['a' * len(axes)].copy()\n\n dec_im = {} # initialize empty dict\n for decName, decImage in six.iteritems(dec):\n # Returning the approximiation is done only for the last loop,\n # and is handled separately below (by building it from `data`)\n # There for, skip it here\n if decName == 'a' * len(axes):\n continue\n decTemp = decImage.copy()\n decTemp = decTemp[tuple(slice(None, -1 if dim % 2 != 0 else None) for dim in original_shape)]\n sitkImage = sitk.GetImageFromArray(decTemp)\n sitkImage.CopyInformation(inputImage)\n dec_im[str(decName).replace('a', 'L').replace('d', 'H')] = sitkImage\n # modifies 'a' with 'L' (Low-pass filter) and 'd' with 'H' (High-pass filter)\n\n ret.append(dec_im) # appending all the filtered sitk images (stored in \"dec_im\") to the \"ret\" list\n\n data = data[tuple(slice(None, -1 if dim % 2 != 0 else None) for dim in original_shape)]\n approximation = sitk.GetImageFromArray(data)\n approximation.CopyInformation(inputImage)\n\n return approximation, ret # returns the approximation and the detail (ret) coefficients of the stationary wavelet decomposition\n\n\ndef getSquareImage(inputImage, inputMask, **kwargs):\n r\"\"\"\n Computes the square of the image intensities.\n\n Resulting values are rescaled on the range of the initial original image and negative intensities are made\n negative in resultant filtered image.\n\n :math:`f(x) = (cx)^2,\\text{ where } c=\\displaystyle\\frac{1}{\\sqrt{\\max(|x|)}}`\n\n Where :math:`x` and :math:`f(x)` are the original and filtered intensity, respectively.\n\n :return: Yields square filtered image, 'square' and ``kwargs`` (customized settings).\n \"\"\"\n global logger\n\n im = sitk.GetArrayFromImage(inputImage)\n im = im.astype('float64')\n coeff = 1 / numpy.sqrt(numpy.max(numpy.abs(im)))\n im = (coeff * im) ** 2\n im = sitk.GetImageFromArray(im)\n im.CopyInformation(inputImage)\n\n logger.debug('Yielding square image')\n yield im, 'square', kwargs\n\n\ndef getSquareRootImage(inputImage, inputMask, **kwargs):\n r\"\"\"\n Computes the square root of the absolute value of image intensities.\n\n Resulting values are rescaled on the range of the initial original image and negative intensities are made\n negative in resultant filtered image.\n\n :math:`f(x) = \\left\\{ {\\begin{array}{lcl}\n \\sqrt{cx} & \\mbox{for} & x \\ge 0 \\\\\n -\\sqrt{-cx} & \\mbox{for} & x < 0\\end{array}} \\right.,\\text{ where } c=\\max(|x|)`\n\n Where :math:`x` and :math:`f(x)` are the original and filtered intensity, respectively.\n\n :return: Yields square root filtered image, 'squareroot' and ``kwargs`` (customized settings).\n \"\"\"\n global logger\n\n im = sitk.GetArrayFromImage(inputImage)\n im = im.astype('float64')\n coeff = numpy.max(numpy.abs(im))\n im[im > 0] = numpy.sqrt(im[im > 0] * coeff)\n im[im < 0] = - numpy.sqrt(-im[im < 0] * coeff)\n im = sitk.GetImageFromArray(im)\n im.CopyInformation(inputImage)\n\n logger.debug('Yielding squareroot image')\n yield im, 'squareroot', kwargs\n\n\ndef getLogarithmImage(inputImage, inputMask, **kwargs):\n r\"\"\"\n Computes the logarithm of the absolute value of the original image + 1.\n\n Resulting values are rescaled on the range of the initial original image and negative intensities are made\n negative in resultant filtered image.\n\n :math:`f(x) = \\left\\{ {\\begin{array}{lcl}\n c\\log{(x + 1)} & \\mbox{for} & x \\ge 0 \\\\\n -c\\log{(-x + 1)} & \\mbox{for} & x < 0\\end{array}} \\right. \\text{, where } c=\\frac{\\max(|x|)}{\\log(\\max(|x|) + 1)}`\n\n Where :math:`x` and :math:`f(x)` are the original and filtered intensity, respectively.\n\n :return: Yields logarithm filtered image, 'logarithm' and ``kwargs`` (customized settings)\n \"\"\"\n global logger\n\n im = sitk.GetArrayFromImage(inputImage)\n im = im.astype('float64')\n im_max = numpy.max(numpy.abs(im))\n im[im > 0] = numpy.log(im[im > 0] + 1)\n im[im < 0] = - numpy.log(- (im[im < 0] - 1))\n im = im * (im_max / numpy.max(numpy.abs(im)))\n im = sitk.GetImageFromArray(im)\n im.CopyInformation(inputImage)\n\n logger.debug('Yielding logarithm image')\n yield im, 'logarithm', kwargs\n\n\ndef getExponentialImage(inputImage, inputMask, **kwargs):\n r\"\"\"\n Computes the exponential of the original image.\n\n Resulting values are rescaled on the range of the initial original image.\n\n :math:`f(x) = e^{cx},\\text{ where } c=\\displaystyle\\frac{\\log(\\max(|x|))}{\\max(|x|)}`\n\n Where :math:`x` and :math:`f(x)` are the original and filtered intensity, respectively.\n\n :return: Yields exponential filtered image, 'exponential' and ``kwargs`` (customized settings)\n \"\"\"\n global logger\n\n im = sitk.GetArrayFromImage(inputImage)\n im = im.astype('float64')\n im_max = numpy.max(numpy.abs(im))\n coeff = numpy.log(im_max) / im_max\n im = numpy.exp(coeff * im)\n im = sitk.GetImageFromArray(im)\n im.CopyInformation(inputImage)\n\n logger.debug('Yielding exponential image')\n yield im, 'exponential', kwargs\n\n\ndef getGradientImage(inputImage, inputMask, **kwargs):\n r\"\"\"\n Compute and return the Gradient Magnitude in the image.\n By default, takes into account the image spacing, this can be switched off by specifying\n ``gradientUseSpacing = False``.\n\n References:\n\n - `SimpleITK documentation\n <https://itk.org/SimpleITKDoxygen/html/classitk_1_1simple_1_1GradientMagnitudeImageFilter.html>`_\n - `<https://en.wikipedia.org/wiki/Image_gradient>`_\n \"\"\"\n gmif = sitk.GradientMagnitudeImageFilter()\n gmif.SetUseImageSpacing(kwargs.get('gradientUseSpacing', True))\n im = gmif.Execute(inputImage)\n yield im, 'gradient', kwargs\n\n\ndef getLBP2DImage(inputImage, inputMask, **kwargs):\n \"\"\"\n Compute and return the Local Binary Pattern (LBP) in 2D. If ``force2D`` is set to false (= feature extraction in 3D) a\n warning is logged, as this filter processes the image in a by-slice operation. The plane in which the LBP is\n applied can be controlled by the ``force2Ddimension`` parameter (see also :py:func:`generateAngles`).\n\n Following settings are possible (in addition to ``force2Ddimension``):\n\n - ``lbp2DRadius`` [1]: Float, specifies the radius in which the neighbours should be sampled\n - ``lbp2DSamples`` [9]: Integer, specifies the number of samples to use\n - ``lbp2DMethod`` ['uniform']: String, specifies the method for computing the LBP to use.\n\n For more information see `scikit documentation\n <http://scikit-image.org/docs/dev/api/skimage.feature.html#skimage.feature.local_binary_pattern>`_\n\n :return: Yields LBP filtered image, 'lbp-2D' and ``kwargs`` (customized settings)\n\n .. note::\n LBP can often return only a very small number of different gray levels. A customized bin width is often needed.\n .. warning::\n Requires package ``scikit-image`` to function. If not available, this filter logs a warning and does not yield an image.\n\n References:\n\n - T. Ojala, M. Pietikainen, and D. Harwood (1994), \"Performance evaluation of texture measures with classification\n based on Kullback discrimination of distributions\", Proceedings of the 12th IAPR International Conference on Pattern\n Recognition (ICPR 1994), vol. 1, pp. 582 - 585.\n - T. Ojala, M. Pietikainen, and D. Harwood (1996), \"A Comparative Study of Texture Measures with Classification Based\n on Feature Distributions\", Pattern Recognition, vol. 29, pp. 51-59.\n \"\"\"\n global logger\n try:\n from skimage.feature import local_binary_pattern\n except ImportError:\n logger.warning('Could not load required package \"skimage\", cannot implement filter LBP 2D')\n return\n\n lbp_radius = kwargs.get('lbp2DRadius', 1)\n lbp_samples = kwargs.get('lbp2DSamples', 8)\n lbp_method = kwargs.get('lbp2DMethod', 'uniform')\n\n im_arr = sitk.GetArrayFromImage(inputImage)\n\n Nd = inputImage.GetDimension()\n if Nd == 3:\n # Warn the user if features are extracted in 3D, as this function calculates LBP in 2D\n if not kwargs.get('force2D', False):\n logger.warning('Calculating Local Binary Pattern in 2D, but extracting features in 3D. Use with caution!')\n lbp_axis = kwargs.get('force2Ddimension', 0)\n\n im_arr = im_arr.swapaxes(0, lbp_axis)\n for idx in range(im_arr.shape[0]):\n im_arr[idx, ...] = local_binary_pattern(im_arr[idx, ...], P=lbp_samples, R=lbp_radius, method=lbp_method)\n im_arr = im_arr.swapaxes(0, lbp_axis)\n elif Nd == 2:\n im_arr = local_binary_pattern(im_arr, P=lbp_samples, R=lbp_radius, method=lbp_method)\n else:\n logger.warning('LBP 2D is only available for 2D or 3D with forced 2D extraction')\n return\n\n im = sitk.GetImageFromArray(im_arr)\n im.CopyInformation(inputImage)\n\n yield im, 'lbp-2D', kwargs\n\n\ndef getLBP3DImage(inputImage, inputMask, **kwargs):\n \"\"\"\n Compute and return the Local Binary Pattern (LBP) in 3D using spherical harmonics.\n If ``force2D`` is set to true (= feature extraction in 2D) a warning is logged.\n\n LBP is only calculated for voxels segmented in the mask\n\n Following settings are possible:\n\n - ``lbp3DLevels`` [2]: integer, specifies the the number of levels in spherical harmonics to use.\n - ``lbp3DIcosphereRadius`` [1]: Float, specifies the radius in which the neighbours should be sampled\n - ``lbp3DIcosphereSubdivision`` [1]: Integer, specifies the number of subdivisions to apply in the icosphere\n\n :return: Yields LBP filtered image for each level, 'lbp-3D-m<level>' and ``kwargs`` (customized settings).\n Additionally yields the kurtosis image, 'lbp-3D-k' and ``kwargs``.\n\n .. note::\n LBP can often return only a very small number of different gray levels. A customized bin width is often needed.\n .. warning::\n Requires package ``scipy`` and ``trimesh`` to function. If not available, this filter logs a warning and does not\n yield an image.\n\n References:\n\n - Banerjee, J, Moelker, A, Niessen, W.J, & van Walsum, T.W. (2013), \"3D LBP-based rotationally invariant region\n description.\" In: Park JI., Kim J. (eds) Computer Vision - ACCV 2012 Workshops. ACCV 2012. Lecture Notes in Computer\n Science, vol 7728. Springer, Berlin, Heidelberg. doi:10.1007/978-3-642-37410-4_3\n \"\"\"\n global logger\n Nd = inputImage.GetDimension()\n if Nd != 3:\n logger.warning('LBP 3D only available for 3 dimensional images, found %i dimensions', Nd)\n return\n\n try:\n from scipy.stats import kurtosis\n from scipy.ndimage.interpolation import map_coordinates\n from scipy.special import sph_harm\n from trimesh.creation import icosphere\n except ImportError:\n logger.warning('Could not load required package \"scipy\" or \"trimesh\", cannot implement filter LBP 3D')\n return\n\n # Warn the user if features are extracted in 2D, as this function calculates LBP in 3D\n if kwargs.get('force2D', False):\n logger.warning('Calculating Local Binary Pattern in 3D, but extracting features in 2D. Use with caution!')\n\n label = kwargs.get('label', 1)\n\n lbp_levels = kwargs.get('lbp3DLevels', 2)\n lbp_icosphereRadius = kwargs.get('lbp3DIcosphereRadius', 1)\n lbp_icosphereSubdivision = kwargs.get('lbp3DIcosphereSubdivision', 1)\n\n im_arr = sitk.GetArrayFromImage(inputImage)\n ma_arr = sitk.GetArrayFromImage(inputMask)\n\n # Variables used in the shape comments:\n # Np Number of voxels\n # Nv Number of vertices\n\n # Vertices icosahedron for spherical sampling\n coords_icosahedron = numpy.array(icosphere(lbp_icosphereSubdivision, lbp_icosphereRadius).vertices) # shape(Nv, 3)\n\n # Corresponding polar coordinates\n theta = numpy.arccos(numpy.true_divide(coords_icosahedron[:, 2], lbp_icosphereRadius))\n phi = numpy.arctan2(coords_icosahedron[:, 1], coords_icosahedron[:, 0])\n\n # Corresponding spherical harmonics coefficients Y_{m, n, theta, phi}\n Y = sph_harm(0, 0, theta, phi) # shape(Nv,)\n n_ix = numpy.array(0)\n\n for n in range(1, lbp_levels):\n for m in range(-n, n + 1):\n n_ix = numpy.append(n_ix, n)\n Y = numpy.column_stack((Y, sph_harm(m, n, theta, phi)))\n # shape (Nv, x) where x is the number of iterations in the above loops + 1\n\n # Get labelled coordinates\n ROI_coords = numpy.where(ma_arr == label) # shape(3, Np)\n\n # Interpolate f (samples on the spheres across the entire volume)\n coords = numpy.array(ROI_coords).T[None, :, :] + coords_icosahedron[:, None, :] # shape(Nv, Np, 3)\n f = map_coordinates(im_arr, coords.T, order=3) # Shape(Np, Nv) Note that 'Np' and 'Nv' are swapped due to .T\n\n # Compute spherical Kurtosis\n k = kurtosis(f, axis=1) # shape(Np,)\n\n # Apply sign function\n f_centroids = im_arr[ROI_coords] # Shape(Np,)\n f = numpy.greater_equal(f, f_centroids[:, None]).astype(int) # Shape(Np, Nv)\n\n # Compute c_{m,n} coefficients\n c = numpy.multiply(f[:, :, None], Y[None, :, :]) # Shape(Np, Nv, x)\n c = c.sum(axis=1) # Shape(Np, x)\n\n # Integrate over m\n f = numpy.multiply(c[:, None, n_ix == 0], Y[None, :, n_ix == 0]) # Shape (Np, Nv, 1)\n for n in range(1, lbp_levels):\n f = numpy.concatenate((f,\n numpy.sum(numpy.multiply(c[:, None, n_ix == n], Y[None, :, n_ix == n]),\n axis=2, keepdims=True)\n ),\n axis=2)\n # Shape f (Np, Nv, levels)\n\n # Compute L2-Norm\n f = numpy.sqrt(numpy.sum(f ** 2, axis=1)) # shape(Np, levels)\n\n # Keep only Real Part\n f = numpy.real(f) # shape(Np, levels)\n k = numpy.real(k) # shape(Np,)\n\n # Yield the derived images for each level\n result = numpy.ndarray(im_arr.shape)\n for l_idx in range(lbp_levels):\n result[ROI_coords] = f[:, l_idx]\n\n # Create a SimpleITK image\n im = sitk.GetImageFromArray(result)\n im.CopyInformation(inputImage)\n\n yield im, 'lbp-3D-m%d' % (l_idx + 1), kwargs\n\n # Yield Kurtosis\n result[ROI_coords] = k\n\n # Create a SimpleITK image\n im = sitk.GetImageFromArray(result)\n im.CopyInformation(inputImage)\n\n yield im, 'lbp-3D-k', kwargs\n"
] | [
[
"numpy.sum",
"numpy.multiply",
"numpy.histogram",
"numpy.asarray",
"numpy.greater_equal",
"numpy.log",
"numpy.allclose",
"numpy.append",
"numpy.abs",
"numpy.ndarray",
"numpy.where",
"scipy.ndimage.interpolation.map_coordinates",
"numpy.mean",
"numpy.ceil",
"numpy.zeros",
"scipy.stats.kurtosis",
"numpy.arange",
"scipy.special.sph_harm",
"numpy.max",
"numpy.min",
"numpy.maximum",
"numpy.std",
"numpy.pad",
"numpy.array",
"numpy.arctan2",
"numpy.empty",
"numpy.true_divide",
"numpy.floor",
"numpy.exp",
"numpy.sqrt",
"numpy.real",
"numpy.digitize"
]
] |
ccj5351/hmr_rgbd | [
"d1dcf81d72c11e1f502f2c494cd86425f384d9cc",
"d1dcf81d72c11e1f502f2c494cd86425f384d9cc"
] | [
"debug/test_tf_funcs.py",
"pytorch_src/ResnetV2.py"
] | [
"# !/usr/bin/env python3\n# -*-coding:utf-8-*-\n# @file: test_tf_funcs.py\n# @brief:\n# @author: Changjiang Cai, [email protected], [email protected]\n# @version: 0.0.1\n# @creation date: 13-08-2019\n# @last modified: Tue 13 Aug 2019 05:38:05 PM EDT\n\nimport tensorflow as tf\nimport numpy as np\n\nif __name__ == \"__main__\":\n \n\n \n \"\"\" test tf.gather_nd \"\"\" \n # data is [[[ 0 1]\n # [ 2 3]\n # [ 4 5]]\n #\n # [[ 6 7]\n # [ 8 9]\n # [10 11]]]\n data = np.reshape(np.arange(12), [2, 3, 2])\n x = tf.constant(data)\n\n idx_1 = [[[0, 0, 0], [0, 1, 1]], [[1, 0, 1], [1, 1, 0]]] # 2 x 2 x 3\n result1 = tf.gather_nd(x, idx_1)\n \n idx_2 = [[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 0]] # 4 x 3\n result2 = tf.gather_nd(x, idx_2)\n \n # Construct a 'Session' to execute the graph.\n sess = tf.Session()\n # Execute the graph and store the value that `e` represents in `result`.\n x, res1, res2 = sess.run([x, result1, result2])\n\n print ('x = {}'.format(x))\n print ('res1 = {}'.format(res1))\n print ('res2 = {}'.format(res2))\n",
"# !/usr/bin/env python3\n# -*-coding:utf-8-*-\n# @file:\n# @brief:\n# @author: Changjiang Cai, [email protected], [email protected]\n# @version: 0.0.1\n# @creation date: 23-10-2019\n# @last modified: Wed 30 Oct 2019 03:17:36 PM EDT\n\"\"\"\n file: ResnetV2.py\n author: Changjiang Cai\n mark: adopted from:\n 1) pytorch source code, and \n 2) and https://github.com/MandyMo/pytorch_HMR.git\n 3) and https://github.com/lucasb-eyer/lbtoolbox/blob/master/lbtoolbox/pytorch.py#L61;\n\"\"\"\n\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch\nfrom torch.nn.parameter import Parameter\nimport torch.optim as optim\nimport numpy as np\nimport math\nimport torchvision\nimport sys\n#from dollections import OrderedDict\n\n\"\"\"Contains definitions for the preactivation form of Residual Networks.\n\nResidual networks (ResNets) were originally proposed in:\n[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun\n Deep Residual Learning for Image Recognition. arXiv:1512.03385\n\nThe full preactivation 'v2' ResNet variant implemented in this module was\nintroduced by:\n[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun\n Identity Mappings in Deep Residual Networks. arXiv: 1603.05027\n\nThe key difference of the full preactivation 'v2' variant compared to the\n'v1' variant in [1] is the use of batch normalization before every weight layer.\n\n\"\"\"\n\n########################################\n# Kaiming's blocks\n########################################\ndef conv3x3(cin, cout, stride=1, groups=1, bias=False):\n return nn.Conv2d(cin, cout, kernel_size=3, stride=stride, padding=1, bias=bias, \n groups=groups)\n\n\ndef conv1x1(cin, cout, stride=1,bias=False):\n return nn.Conv2d(cin, cout, kernel_size=1, stride=stride, padding=0, bias=bias)\n\n# bottleneck_v2\n# x-->BN --> ReLU-->(conv1, BN, ReLU)-->(conv2, BN, ReLU) --> conv3\n# | |\n# | |\n# | |\n# |--------------------------------------------> Addition --> x_new\nclass Bottleneck_V2(nn.Module):\n expansion = 4\n def __init__(self, cin, cout, stride):\n super(Bottleneck_V2, self).__init__()\n cmid = cout// self.expansion\n \n self.relu = nn.ReLU(inplace=True)\n \"\"\" Pre Act \"\"\"\n self.bn0 = nn.BatchNorm2d(cin)\n \n \"\"\" (conv1, BN, ReLU)\"\"\"\n self.conv1 = conv1x1(cin, cmid, bias=False) #conv1\n self.bn1 = nn.BatchNorm2d(cmid) #conv1/BatchNorm\n \n \"\"\" (conv2, BN, ReLU)\"\"\"\n self.conv2 = conv3x3(cmid, cmid, stride, bias=False) #conv2\n self.bn2 = nn.BatchNorm2d(cmid) #conv2/BatchNorm\n \"\"\" (conv3 )\"\"\"\n self.conv3 = conv1x1(cmid, cout, bias=True) # conv3\n\n self.stride = stride\n self.maxpool2d= nn.MaxPool2d(kernel_size=1, stride = stride)\n self.shortcut = None\n if cin != cout:\n # conv, 1 x 1\n self.shortcut = conv1x1(cin, cout, stride, bias = True)\n\n def forward(self, x):\n \"\"\" Pre Act \"\"\"\n preact = self.relu(self.bn0(x))\n if self.shortcut is not None:\n shortcut = self.shortcut(preact) # e.g., stride = 2\n else:\n shortcut = self.maxpool2d(x)\n \n \"\"\" (conv1, BN, ReLU)\"\"\"\n residual = self.relu(self.bn1(self.conv1(preact)))\n \"\"\" (conv2, BN, ReLU)\"\"\"\n residual = self.relu(self.bn2(self.conv2(residual)))\n \"\"\" (conv3 )\"\"\"\n residual = self.conv3(residual)\n output = shortcut + residual\n return output\n\n\nclass ResNet_V2(nn.Module):\n def __init__(self, block, layers, num_classes=None, global_pool = True, \n isFetchDictForDebug = False):\n self.isFetchDictForDebug = isFetchDictForDebug\n self.inplanes = 64\n self.expansion = 4\n super(ResNet_V2, self).__init__()\n self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=True)\n # We do not include batch normalization or activation functions in\n # conv1 because the first ResNet unit will perform these. Cf.\n # Appendix of [2].\n #self.bn1 = nn.BatchNorm2d(64)\n\n #self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)\n #Updated to implement 'same' padding in tensorflow; do manually padding to bottom and right, \n # then apply the follwoing maxpool with padding = 0 as its argument;\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)\n # padding size: starting from the last dimension and moving forward;\n self.maxpool_pad = (0,1,0,1)# i.e, (padding_left, padding_right, padding_top, padding_bottom)\n\n self.layer1 = self._make_layer(block, 64, layers[0], stride=2)\n self.layer2 = self._make_layer(block, 128, layers[1], stride=2)\n self.layer3 = self._make_layer(block, 256, layers[2], stride=2)\n self.layer4 = self._make_layer(block, 512, layers[3], stride=1)\n \n # This is needed because the pre-activation variant does not have batch\n # normalization or activation functions in the residual unit output. See\n # Appendix of [2].\n self.postnorm = nn.BatchNorm2d(512*self.expansion)\n self.relu = nn.ReLU(inplace=True)\n #self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) # output is of size 1 x 1 here;\n self.global_pool = global_pool\n #Note: in HMR project, we set `num_classes=None`;\n if num_classes is not None:\n self.fc = nn.Linear(512 * block.expansion, num_classes)\n else:\n self.fc = None\n \n #leave it here FYI:\n #for m in self.modules():\n # if isinstance(m, nn.Conv2d):\n # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n # m.weight.data.normal_(0, math.sqrt(2. / n))\n # elif isinstance(m, nn.BatchNorm2d):\n # m.weight.data.fill_(1)\n # m.bias.data.zero_()\n \n # the new version is shown below:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):\n nn.init.constant_(m.weight, 1)\n nn.init.constant_(m.bias, 0)\n\n #def __init__(self, cin, cout, stride=1):\n\n def _make_layer(self, block, planes, numBlocks, stride):\n expansion = block.expansion\n layers = []\n for i in range(0, numBlocks):\n cur_inplanes = planes * expansion if i > 0 else self.inplanes\n tmp_stride = 1 if i < (numBlocks - 1) else stride\n layers.append(block(cur_inplanes, planes*expansion, tmp_stride))\n #update self.inplanes = output planes, for next incoming Residual block, with new palnes #;\n self.inplanes = planes * expansion\n return nn.Sequential(*layers)\n\n def forward(self, x):\n \"\"\" fetch dict \"\"\"\n fetch_dict = {}\n \n x = self.conv1(x)\n fetch_dict['x_conv1'] = x\n\n #Updated to implement 'same' padding in tensorflow; do manually padding to bottom and right, \n # then apply the follwoing maxpool with padding = 0 as its argument;\n x = F.pad(x, pad = self.maxpool_pad, mode = 'constant', value = 0)\n x = self.maxpool(x)\n fetch_dict['x_maxpool'] = x\n\n x = self.layer1(x)\n fetch_dict['x_layer1'] = x\n x = self.layer2(x)\n fetch_dict['x_layer2'] = x\n x = self.layer3(x)\n fetch_dict['x_layer3'] = x\n x = self.layer4(x)\n fetch_dict['x_layer4'] = x\n x = self.postnorm(x)\n #Updated on 2019/10/30: missing the relu added!!!\n x = self.relu(x)\n fetch_dict['x_postnorm'] = x\n if self.global_pool:\n x = torch.mean(x, dim=[2,3], keepdim = True)\n fetch_dict['x_global_pool'] = x\n\n if self.fc is not None:\n x = self.fc(torch.flatten(x,1))\n if self.isFetchDictForDebug:\n return x, fetch_dict\n else:\n return x\n\n\ndef resnet_v2_50(num_classes=None, global_pool = True, isFetchDictForDebug = False):\n model = ResNet_V2(Bottleneck_V2, [3,4,6,3],num_classes, global_pool, isFetchDictForDebug)\n return model\n\ndef get_tf2pt_key_map_dict():\n map_dict = {\n '' : '',\n # for root block: conv1 --> pool1\n # that is: input x --> (conv1 --> pool1 )--> (residual-block1,2,3,4) --> postnorm --> global avg-pool --> output\n 'conv1/weights' : 'conv1.weight',\n 'conv1/biases' : 'conv1.bias',\n # for post norm:\n 'postnorm/beta': 'postnorm.bias',\n 'postnorm/gamma': 'postnorm.weight',\n 'postnorm/moving_mean': 'postnorm.running_mean',\n 'postnorm/moving_variance': 'postnorm.running_var',\n }\n\n \"\"\" block 1, has 3 unites \"\"\"\n \"\"\" block 2, has 4 unites \"\"\"\n \"\"\" block 3, has 6 unites \"\"\"\n \"\"\" block 4, has 3 unites \"\"\"\n # processing tf_key_1\n blks = [(1,3), (2,4), (3,6), (4,3)]\n for t in blks:\n b_idx = t[0]\n for u_idx in range(t[1]):\n key = 'block{}/unit_{}'.format(b_idx, u_idx + 1)\n vaule = 'layer{}.{}'.format(b_idx, u_idx )\n map_dict[key] = vaule\n \n # processing tf_key_2\n #Example: (tf_key, pt_key)\n \"\"\" In each bottleneck block: we have the following: \"\"\"\n bottleneck_tf_pt_tuples = [\n # Note: 'resnet_v2_50/block1/unit_1/bottleneck_v2/preact/beta/Adam':\n # 'Adam' is related to Adam Optimization, so here we do not use it!!!\n # Pre-Act: bn0\"\"\"\n # BN: out = gamma * X_norm + beta, so beta is bias, gamma is weight;\n ['preact/gamma','bn0.weight'],\n ['preact/beta', 'bn0.bias'],\n ['preact/moving_mean', 'bn0.running_mean'],\n ['preact/moving_variance', 'bn0.running_var'],\n #conv1 + bn1 + relu1\n ['conv1/weights', 'conv1.weight'],\n ['conv1/BatchNorm/gamma', 'bn1.weight'],\n ['conv1/BatchNorm/beta', 'bn1.bias'],\n ['conv1/BatchNorm/moving_mean', 'bn1.running_mean'],\n ['conv1/BatchNorm/moving_variance', 'bn1.running_var'],\n #conv2 + bn2 + relu2\n ['conv2/weights', 'conv2.weight'],\n ['conv2/BatchNorm/gamma', 'bn2.weight'],\n ['conv2/BatchNorm/beta', 'bn2.bias'],\n ['conv2/BatchNorm/moving_mean', 'bn2.running_mean'],\n ['conv2/BatchNorm/moving_variance', 'bn2.running_var'],\n #conv3\n ['conv3/weights', 'conv3.weight'],\n ['conv3/biases', 'conv3.bias'],\n\n #shortcut\n ['shortcut/weights', 'shortcut.weight'],\n ['shortcut/biases', 'shortcut.bias'],\n ]\n for cur_tuple in bottleneck_tf_pt_tuples:\n map_dict[cur_tuple[0]] = cur_tuple[1]\n #print (map_dict)\n return map_dict\n\ndef map_tf_dictKeys_2PyTorch_dictKeys( map_dict,\n tf_key = 'resnet_v2_50/block1/unit_1/bottleneck_v2/conv1/BatchNorm/beta'):\n # E.g.:\n # tf_key = 'resnet_v2_50/block1/unit_1/bottleneck_v2/conv1/BatchNorm/beta'\n # or tf_key = 'resnet_v2_50/conv1/biases'\n # 1) skip the first part : 'resnet_v2_50'\n tf_key = tf_key[len('resnet_v2_50')+1:]\n # 2) find 'bottleneck_v2' if exists, and pick the part before and after 'bottleneck_v2'\n pos = tf_key.find('bottleneck_v2')\n \n if pos > 0: # if found 'bottleneck_v2'\n tf_key_1, tf_key_2 = tf_key[0:pos-1], tf_key[pos+1+len('bottleneck_v2'):]\n else: # no found 'bottleneck_v2'\n tf_key_1, tf_key_2 = '', tf_key\n \n # processing tf_key_1\n #print (tf_key_1)\n pt_key_1 = map_dict[tf_key_1]\n #print (pt_key_1)\n #print (tf_key_2)\n pt_key_2 = map_dict[tf_key_2]\n #print (pt_key_2)\n if pt_key_1 == '':\n pt_key = pt_key_2\n else:\n pt_key = pt_key_1 + '.' + pt_key_2\n #print (\"[***] {} --> {}\".format(tf_key, pt_key))\n return pt_key\n \n\n\n#>see https://stackoverflow.com/questions/51628607/pytorch-passing-numpy-array-for-weight-initialization\ndef set_resnet_parameter_data(layer, parameter_name, new_torch_data):\n param = getattr(layer, parameter_name)\n param.data = new_torch_data\n\ndef pass_np_model_state_to_resnet(src_np_model_state_dict, dst_resnet_model):\n map_dict = get_tf2pt_key_map_dict()\n dst_state_dict = dst_resnet_model.state_dict()\n n_valid = 0\n n_adam = 0\n tf_var_names = list(src_np_model_state_dict['resnet_v2_50_names'])\n N = len(tf_var_names)\n\n for tf_key in sorted(src_np_model_state_dict.keys()):\n # Note: 'resnet_v2_50/block1/unit_1/bottleneck_v2/preact/beta/Adam':\n # 'Adam' is related to Adam Optimization, so here we do not use it!!!\n param = src_np_model_state_dict[tf_key]\n if 'Adam' in tf_key:\n #print('Adam! {} is only for Adam Optimization, not uesed here!!'.format(tf_key))\n n_adam += 1\n tf_var_names.remove(tf_key)\n continue\n elif 'resnet_v2_50_names' == tf_key:\n continue\n pt_key = map_tf_dictKeys_2PyTorch_dictKeys(map_dict, tf_key)\n if pt_key not in dst_state_dict:\n print('unexpected ', pt_key, ' !')\n continue\n if not isinstance(param, np.ndarray):\n raise ValueError('Expected a np.ndarray')\n else:\n # !!! Note: added by CCJ on 2019/10/24;\n # tensorflow conv2d weight in size of [kernel_size[0], kernel_size[1], in_channels, out_channels], \n # e.g., weight in size [7,7,3,64] means applying 7x7-kernel-size convolution to input image with 3 channel \n # and output channel is 64;\n # While, PyTorch will have its weight in shape [out_channels, in_channels/groups, kernel_size[0], kernel_size[1]], \n # here we assume gropus = 1; \n if param.ndim == 4:\n param = np.transpose(param, [3,2,0,1])\n param = torch.from_numpy(param).contiguous()\n try:\n dst_state_dict[pt_key].copy_(param)\n n_valid += 1\n tf_var_names.remove(tf_key)\n except:\n print(pt_key, ' is inconsistent!')\n print ('src np.ndarray in shape {}, dst tensor in shape {}'.format(param.shape, \n dst_state_dict[pt_key].shape))\n n_valid -= 1\n tf_var_names.append(tf_key)\n continue\n \n \n \n print('%d out of %d variables processed! Wherein:'%(n_valid + n_adam, N))\n print(' [***] Copyed state dict for %d variables and finished!' %n_valid)\n print(' [***] Skip %d adam variables, which are related to Adam optimaization state' %(n_adam))\n print(' [***] {} variables are left unprocessed!'.format(len(tf_var_names)))\n if n_valid + n_adam == N:\n print (\" [***] Resnet_V2_50 loading Numpy weights Succeed!!!\")\n else:\n print (\" [***] Resnet_V2_50 loading Numpy weights Failed !!!\")\n #print('[***] Including: ', tf_var_names)\n\n\ndef load_Res50ModelFromNpyFile(npy_file = '/home/ccj/hmr-rgbd/results/saved_weights/hmr_pre_trained_resnet_v2_50.npy'):\n dst_resnet_model = resnet_v2_50()\n assert (npy_file is not None)\n # this npy file is generated by Python2, due to Tensorflow is installed in Python2;\n # load this npy file (generated by Python2) to Python3, due to PyTorch is installed in Python3;\n src_np_model_state_dict = np.load(npy_file, allow_pickle= True, encoding = 'latin1').item()\n #tmp_name = 'resnet_v2_50/block4/unit_3/bottleneck_v2/conv2/weights'\n # check the variable dimensionality\n # print should be : [3, 3, 512, 512];\n #print(src_np_model_state_dict[tmp_name].shape)\n \n pass_np_model_state_to_resnet(src_np_model_state_dict, dst_resnet_model)\n return dst_resnet_model\n\n\nif __name__ == '__main__':\n \n if 0:\n print ('resnet_v2_50 state_dict():')\n n = 0\n for k,v in resnet_v2_50().state_dict().items():\n print (k, v.shape)\n n += 1\n print (n)\n \n if 0: \n \"\"\" load dictionary \"\"\" \n npy_file = '/home/ccj/hmr-rgbd/results/saved_weights/hmr_pre_trained_resnet_v2_50.npy'\n resnet_dict2 = np.load(npy_file, allow_pickle= True, encoding = 'latin1').item()\n print ('loaded var_names : ', resnet_dict2['resnet_v2_50_names'])\n tmp_name = 'resnet_v2_50/block4/unit_3/bottleneck_v2/conv2/weights'\n # check the variable dimensionality\n # print should be : [3, 3, 512, 512];\n print (resnet_dict2[tmp_name].shape)\n \n \"\"\" load numpy dictionary to Pytorch model and save the model\"\"\" \n if 1:\n # this npy file is generated by Python2, due to Tensorflow is installed in Python2;\n npy_file = '/home/ccj/hmr-rgbd/results/saved_weights/hmr_pre_trained_resnet_v2_50.npy'\n # load this npy file (generated by Python2) to Python3, due to PyTorch is installed in Python3;\n dst_resnet_model = load_Res50ModelFromNpyFile(npy_file)\n dst_state_dict = dst_resnet_model.state_dict()\n\n model_path = '/home/ccj/hmr-rgbd/results/saved_weights/hmr_pre_trained_resnet_v2_50.pt'\n torch.save(dst_state_dict, model_path)\n print ('saved %s' % model_path)\n #n = 0\n #for k,v in dst_state_dict.items():\n # print (k, v.shape)\n # n += 1\n #print (n)\n if 1:\n # get a new model\n resnet_v2_50 = resnet_v2_50()\n model_path = '/home/ccj/hmr-rgbd/results/saved_weights/hmr_pre_trained_resnet_v2_50.pt'\n # load the weights\n resnet_v2_50.load_state_dict(torch.load(model_path))\n print ('Loading %s' % model_path)\n"
] | [
[
"numpy.arange",
"tensorflow.constant",
"tensorflow.Session",
"tensorflow.gather_nd"
],
[
"torch.nn.MaxPool2d",
"torch.nn.BatchNorm2d",
"numpy.load",
"torch.nn.Linear",
"torch.load",
"torch.nn.init.kaiming_normal_",
"numpy.transpose",
"torch.nn.init.constant_",
"torch.flatten",
"torch.nn.functional.pad",
"torch.save",
"torch.from_numpy",
"torch.nn.Conv2d",
"torch.nn.Sequential",
"torch.nn.ReLU",
"torch.mean"
]
] |
agarwalrounak/optuna | [
"9331374a2460da067a6922e4ea09dd4706f3d950"
] | [
"tests/storages_tests/rdb_tests/test_with_server.py"
] | [
"from multiprocessing import Pool\nimport os\nfrom typing import Sequence\nfrom typing import Tuple\n\nimport numpy as np\nimport pytest\n\nimport optuna\n\n\n_STUDY_NAME = \"_test_multiprocess\"\n\n\ndef f(x: float, y: float) -> float:\n return (x - 3) ** 2 + y\n\n\ndef objective(trial: optuna.Trial) -> float:\n x = trial.suggest_float(\"x\", -10, 10)\n y = trial.suggest_float(\"y\", -10, 10)\n trial.report(x, 0)\n trial.report(y, 1)\n trial.set_user_attr(\"x\", x)\n trial.set_system_attr(\"y\", y)\n return f(x, y)\n\n\ndef run_optimize(args: Tuple[str, str]) -> None:\n study_name = args[0]\n storage_url = args[1]\n # Create a study\n study = optuna.load_study(study_name=study_name, storage=storage_url)\n # Run optimization\n study.optimize(objective, n_trials=20)\n\n\[email protected]\ndef storage_url() -> str:\n if \"TEST_DB_URL\" not in os.environ:\n pytest.skip(\"This test requires TEST_DB_URL.\")\n storage_url = os.environ[\"TEST_DB_URL\"]\n try:\n optuna.study.delete_study(_STUDY_NAME, storage_url)\n except KeyError:\n pass\n return storage_url\n\n\ndef _check_trials(trials: Sequence[optuna.trial.FrozenTrial]) -> None:\n # Check trial states.\n assert all(trial.state == optuna.trial.TrialState.COMPLETE for trial in trials)\n\n # Check trial values and params.\n assert all(\"x\" in trial.params for trial in trials)\n assert all(\"y\" in trial.params for trial in trials)\n assert all(\n np.isclose(\n np.asarray([trial.value for trial in trials]),\n [f(trial.params[\"x\"], trial.params[\"y\"]) for trial in trials],\n atol=1e-4,\n ).tolist()\n )\n\n # Check intermediate values.\n assert all(len(trial.intermediate_values) == 2 for trial in trials)\n assert all(trial.params[\"x\"] == trial.intermediate_values[0] for trial in trials)\n assert all(trial.params[\"y\"] == trial.intermediate_values[1] for trial in trials)\n\n # Check attrs.\n assert all(\n np.isclose(\n [trial.user_attrs[\"x\"] for trial in trials],\n [trial.params[\"x\"] for trial in trials],\n atol=1e-4,\n ).tolist()\n )\n assert all(\n np.isclose(\n [trial.system_attrs[\"y\"] for trial in trials],\n [trial.params[\"y\"] for trial in trials],\n atol=1e-4,\n ).tolist()\n )\n\n\ndef test_loaded_trials(storage_url: str) -> None:\n # Please create the tables by placing this function before the multi-process tests.\n\n N_TRIALS = 20\n study = optuna.create_study(study_name=_STUDY_NAME, storage=storage_url)\n # Run optimization\n study.optimize(objective, n_trials=N_TRIALS)\n\n trials = study.trials\n assert len(trials) == N_TRIALS\n\n _check_trials(trials)\n\n # Create a new study to confirm the study can load trial properly.\n loaded_study = optuna.load_study(study_name=_STUDY_NAME, storage=storage_url)\n _check_trials(loaded_study.trials)\n\n\ndef test_multiprocess(storage_url: str) -> None:\n n_workers = 8\n study_name = _STUDY_NAME\n optuna.create_study(storage=storage_url, study_name=study_name)\n with Pool(n_workers) as pool:\n pool.map(run_optimize, [(study_name, storage_url)] * n_workers)\n\n study = optuna.load_study(study_name=study_name, storage=storage_url)\n\n trials = study.trials\n assert len(trials) == n_workers * 20\n\n _check_trials(trials)\n"
] | [
[
"numpy.isclose",
"numpy.asarray"
]
] |
chunzhang-hub/PaddleHub | [
"9a3b23295947e22149cc85c17cb4cf23c03f9e06"
] | [
"modules/text/language_model/lda_webpage/vose_alias.py"
] | [
"import os\n\nimport numpy as np\nfrom paddlehub.common.logger import logger\n\nfrom lda_webpage.util import rand, rand_k\n\n\nclass VoseAlias(object):\n \"\"\"Vose's Alias Method.\n \"\"\"\n\n def __init__(self):\n self.__alias = None\n self.__prob = None # np.array\n\n def initialize(self, distribution):\n \"\"\"Initialize the alias table according to the input distribution\n Arg:\n distribution: Numpy array.\n \"\"\"\n size = distribution.shape[0]\n self.__alias = np.zeros(size, dtype=np.int64)\n self.__prob = np.zeros(size)\n sum_ = np.sum(distribution)\n p = distribution / sum_ * size # Scale up probability.\n large, small = [], []\n for i, p_ in enumerate(p):\n if p_ < 1.0:\n small.append(i)\n else:\n large.append(i)\n\n while large and small:\n l = small[0]\n g = large[0]\n small.pop(0)\n large.pop(0)\n self.__prob[l] = p[l]\n self.__alias[l] = g\n p[g] = p[g] + p[l] - 1 # A more numerically stable option.\n if p[g] < 1.0:\n small.append(g)\n else:\n large.append(g)\n\n while large:\n g = large[0]\n large.pop(0)\n self.__prob[g] = 1.0\n\n while small:\n l = small[0]\n small.pop(0)\n self.__prob[l] = 1.0\n\n def generate(self):\n \"\"\"Generate samples from given distribution.\n \"\"\"\n dart1 = rand_k(self.size())\n dart2 = int(rand())\n return dart1 if dart2 > self.__prob[dart1] else self.__alias[dart1]\n\n def size(self):\n return self.__prob.shape[0]\n"
] | [
[
"numpy.sum",
"numpy.zeros"
]
] |
franktoffel/dapper | [
"373a27273ea109f349e5edcdcef0cfe0b83b925e"
] | [
"mods/Lorenz95/core.py"
] | [
"# \"Lorenz-95\" (or 96) model. For a deeper introduction, see\n# \"DAPPER/tutorials/T4 - Dynamical systems, chaos, Lorenz.ipynb\"\n#\n# Note: implementation is ndim-agnostic.\n\nimport numpy as np\nfrom tools.math import rk4, integrate_TLM, is1d\n\nForce = 8.0\n\n# Note: the model is unstable (blows up) if there are large peaks\n# (as may be occasioned by the analysis update, especially with partial obs). \n# Example: integrate 4 steps with dt=0.05 from x0 = [0,-30,0,30].\n# This is effectively a CFL condition... Can be addressed by:\n# - lowering dt\n# - using an implicit time stepping scheme instead of rk4\n# - stupidly crop amplitudes, as is done here:\nprevent_blow_up = False\n\nTplot = 10\n\nx0 = lambda M: 2.3*np.ones(M)\n\ndef dxdt(x):\n a = x.ndim-1\n s = lambda x,n: np.roll(x,-n,axis=a)\n return (s(x,1)-s(x,-2))*s(x,-1) - x + Force\n\ndef step(x0, t, dt):\n\n if prevent_blow_up:\n clip = abs(x0)>30\n x0[clip] *= 0.1\n\n return rk4(lambda t,x: dxdt(x), x0, np.nan, dt)\n\n################################################\n# OPTIONAL (not necessary for EnKF or PartFilt):\n################################################\ndef TLM(x):\n \"\"\"Tangent linear model\"\"\"\n assert is1d(x)\n Nx = len(x)\n TLM = np.zeros((Nx,Nx))\n md = lambda i: np.mod(i,Nx)\n for i in range(Nx):\n TLM[i,i] = -1.0\n TLM[i, i-2 ] = -x[i-1]\n TLM[i,md(i+1)] = +x[i-1]\n TLM[i, i-1 ] = x[md(i+1)]-x[i-2]\n return TLM\n\ndef dfdx(x,t,dt):\n \"\"\"Integral of TLM. Jacobian of step.\"\"\"\n # method='analytic' is a substantial upgrade for Lor95 \n return integrate_TLM(TLM(x),dt,method='analytic')\n\n\n################################################\n# Add some non-default liveplotters\n################################################\nimport tools.liveplotting as LP\ndef LPs(jj=None): return [\n (11, 1, LP.spatial1d(jj) ),\n (12, 1, LP.correlations ),\n (15, 0, LP.spectral_errors),\n (13, 0, LP.phase3d(jj) ),\n (11, 0, LP.sliding_marginals(jj)) ,\n ]\n\n\n"
] | [
[
"numpy.ones",
"numpy.roll",
"numpy.zeros",
"numpy.mod"
]
] |
pyl1b/decay | [
"7200516455fc03351ad658af66b5cc39b2b2d50a"
] | [
"decay/decays/sample/half_sudden.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nContains the definition of the SuddenDecay class.\n\"\"\"\nfrom __future__ import unicode_literals\nfrom __future__ import print_function\n\nimport logging\nimport numpy as np\n\nfrom . import SampleBasedDecay\n\nlogger = logging.getLogger('decay.half_sudden')\n\n\nclass HalfSuddenDecay(SampleBasedDecay):\n \"\"\"\n Class that decays the value following the sigmoid curve.\n\n Sigmoid is:\n k\n Y = --------------------- + 1\n a + bx\n 1 + e\n\n This curve used a=10, b=-10, k=-2\n This intersects the Y axis at\n +1 and the X axis at -1 and +1. We're interested only in the\n positive x.\n \"\"\"\n def __init__(self, *args, **kwargs):\n \"\"\" Constructor. \"\"\"\n super(HalfSuddenDecay, self).__init__(\n decay_name='.decay.half_sudden.', *args, **kwargs)\n\n def __str__(self):\n \"\"\" Represent this object as a human-readable string. \"\"\"\n return 'SuddenDecay()'\n\n def __repr__(self):\n \"\"\" Represent this object as a python constructor. \"\"\"\n return 'SuddenDecay()'\n\n decay_x = np.array([\n 0.0,\n 0.05263157894736842,\n 0.10526315789473684,\n 0.15789473684210525,\n 0.21052631578947367,\n 0.2631578947368421,\n 0.3157894736842105,\n 0.3684210526315789,\n 0.42105263157894735,\n 0.47368421052631576,\n 0.5263157894736842,\n 0.5789473684210527,\n 0.631578947368421,\n 0.6842105263157894,\n 0.7368421052631579,\n 0.7894736842105263,\n 0.8421052631578947,\n 0.894736842105263,\n 0.9473684210526315,\n 1.0,\n ])\n\n decay_y = np.array([\n 1.0,\n 0.9998463162863197,\n 0.9997398757902081,\n 0.9995597314205974,\n 0.999254877774581,\n 0.9987390684889199,\n 0.9978665723466811,\n 0.9963914462121438,\n 0.9938994809709213,\n 0.9896955173948945,\n 0.9826197888368629,\n 0.9707568136416107,\n 0.9509968204584932,\n 0.9184373437414545,\n 0.8657330022308358,\n 0.7828273568190789,\n 0.6581107760257361,\n 0.4825598285864794,\n 0.2572468384313463,\n 0.0,\n ])\n"
] | [
[
"numpy.array"
]
] |
glauberrleite/system-identifier | [
"982e04b7df84211d5797d259e9cb431d83b00529"
] | [
"test.py"
] | [
"from Util import Util\nimport numpy\nimport matplotlib.pyplot as pyplot\n\ninputArray = numpy.ones(100)\ntheta = [ 2.705, -2.448, 0.7408, 0.0523, -0.0855, 0.035 ]\norderOutput = 3\norderInput = 3\nsampleRate = 0.1\n\n\ny = Util.computeOutput(inputArray, theta, orderOutput, orderInput)\nt = numpy.arange(0, len(y)*sampleRate, sampleRate)\n\npyplot.plot(t, y, 'r')\npyplot.plot(t, inputArray, 'b--')\npyplot.show()\n"
] | [
[
"numpy.ones",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.show"
]
] |
Imperial-lord/IITG | [
"df4233905d2954511d5b16666f0d44cc38b9df90"
] | [
"Semester 6/MA 374 (Financial Engg. Lab)/Lab 1/180123062_ABSatyaprakash_q1 1.py"
] | [
"# Q.1 Run your program for M = 1, 5, 10, 20, 50, 100, 200, 400 \n# to get the initial option prices and tabulate them\n\n# Pandas : pip install pandas \n# Matplotlib: pip install matplotlib \n# Numpy: pip install numpy \n# Ipython: pip install ipython\n\n\nimport math\nimport pandas as pd\nfrom IPython.display import display\n\n# Function to get Option Price for a given M\ndef getOptionPrice(M, u, d, p):\n callList = [0]*(M+1)\n putList = [0]*(M+1)\n \n for i in range(M+1):\n callList[i] = max(S0*(u**i)*(d**(M-i)) - K, 0)\n putList[i] = max(0, K - S0*(u**i)*(d**(M-i)))\n \n for i in range(M):\n for j in range(M-i):\n callList[j] = ((1-p)*callList[j] + p*callList[j+1])*math.exp(-r*T/M)\n putList[j] = ((1-p)*putList[j] + p*putList[j+1])*math.exp(-r*T/M)\n return callList[0], putList[0]\n\n# Given data\nS0=100\nK=105\nT=5\nr=0.05\nsig=0.3\nMList=[1, 5, 10, 20, 50, 100, 200, 400]\n\n# Lists to store the option prices\ncallPrices = []\nputPrices = []\n\n\nfor M in MList:\n dt = T/M\n u = math.exp(sig*math.sqrt(dt)+(r-sig*sig/2)*dt)\n d = math.exp(-sig*math.sqrt(dt)+(r-sig*sig/2)*dt)\n p = (math.exp(r*dt)-d)/(u-d)\n \n # Check if No Arbitrage Principle has got violated\n if p < 0 or p > 1:\n print(\"No Arbitrage Principle has been Violated\")\n CallPrices.append('-')\n PutPrices.append('-')\n continue\n \n call, put = getOptionPrice(M, u, d, p)\n callPrices.append(call)\n putPrices.append(put)\n\n# Display the data using Pandas Dataframe\ndf = pd.DataFrame({'Step Size':MList,'Call Option Price': callPrices, 'Put Option Price': putPrices},)\ndisplay(df)\n"
] | [
[
"pandas.DataFrame"
]
] |
Pathology-Consistent-Stain-Transfer/Unpaired-Stain-Transfer-using-Pathology-Consistent-Constrained-Generative-Adversarial-Networks | [
"b57c56b314e65a0f31d9e44f57174108599c8b14"
] | [
"Stain_seperation/stain_Norm_Vahadane.py"
] | [
"\"\"\"\nStain normalization inspired by method of:\n\nA. Vahadane et al., ‘Structure-Preserving Color Normalization and Sparse Stain Separation for Histological Images’, IEEE Transactions on Medical Imaging, vol. 35, no. 8, pp. 1962–1971, Aug. 2016.\n\nUses the spams package:\n\nhttp://spams-devel.gforge.inria.fr/index.html\n\nUse with python via e.g https://anaconda.org/conda-forge/python-spams\n\"\"\"\n# windows: pip install spams-bin\n# linux:pip install python-spams\nimport spams\nimport numpy as np\nimport Stain_seperation.stain_utils as ut\n\n\ndef get_stain_matrix(I, threshold=0.8, lamda=0.1):\n \"\"\"\n Get 2x3 stain matrix. First row H and second row E\n :param I:\n :param threshold:\n :param lamda:\n :return:\n \"\"\"\n mask = ut.notwhite_mask(I, thresh=threshold).reshape((-1,))\n OD = ut.RGB_to_OD(I).reshape((-1, 3))\n OD = OD[mask]\n dictionary = spams.trainDL(OD.T, K=2, lambda1=lamda, mode=2, modeD=0, posAlpha=True, posD=True, verbose=False).T\n if dictionary[0, 0] < dictionary[1, 0]:\n dictionary = dictionary[[1, 0], :]\n dictionary = ut.normalize_rows(dictionary)\n return dictionary\n\n\nclass normalizer(object):\n \"\"\"\n A stain normalization object\n \"\"\"\n\n def __init__(self):\n\n self.stain_matrix_target = np.array([[0.62600721, 0.62330743, 0.46861798],\n [0.3203682, 0.5473311, 0.77317067]])\n # Ki67 Normalization initial matirx obtained from \"Sample_target\"\n # [[0.58594418, 0.68469766, 0.43342651]\n # [0.3203682, 0.5473311, 0.77317067]]\n\n # [[0.62600721,0.62330743,0.46861798],\n # [0.35395456,0.58236586,0.73182387]]\n\n # [[0.58583788, 0.66078505, 0.46920901],\n # [0.3536072, 0.56354522, 0.74657801]]\n\n # HE Normalization initial matirx obtained from \"Sample_target\"\n # self.stain_matrix_target = np.array([[0.60559458, 0.69559906, 0.38651928],\n # [0.1100605, 0.94701408, 0.30174662]])\n # [[0.59958405,0.70248408,0.38342546]\n # [0.06893222,0.95236792,0.2970584]]\n\n # [[0.60559458 0.69559906 0.38651928]\n # [0.1100605 0.94701408 0.30174662]]\n\n # [[0.60715608 0.72015621 0.3357626]\n # [0.21154943 0.9271104 0.30937542]]\n\n def fit(self, target_list):\n if target_list.__len__() > 1:\n Ws = []\n for f_id in range(target_list.__len__()):\n target = ut.read_image(target_list[f_id])\n target = ut.standardize_brightness(target)\n stain_matrix_target = get_stain_matrix(target)\n Ws.append(stain_matrix_target)\n Ws = np.asarray(Ws)\n Median_W = np.median(Ws, axis=0)\n self.stain_matrix_target = ut.normalize_rows(Median_W)\n print('WSI target stain matrix: ', self.stain_matrix_target)\n else:\n target = ut.read_image(target_list[0])\n target = ut.standardize_brightness(target)\n self.stain_matrix_target = get_stain_matrix(target)\n print('Single target image stain matrix: ', self.stain_matrix_target)\n\n def stains_Vec_RGB(self, stain_matrix_target):\n return ut.OD_to_RGB(stain_matrix_target)\n\n def transform(self, I):\n I = ut.standardize_brightness(I)\n stain_matrix_source = get_stain_matrix(I)\n source_concentrations = ut.get_concentrations(I, stain_matrix_source)\n return (255 * np.exp(-1 * np.dot(source_concentrations, self.stain_matrix_target).reshape(I.shape))).astype(\n np.uint8)\n\n def hematoxylin_eosin(self, I):\n I = ut.standardize_brightness(I)\n h, w, _ = I.shape\n stain_matrix_source = get_stain_matrix(I)\n source_concentrations = ut.get_concentrations(I, stain_matrix_source)\n\n H = source_concentrations[:, 0].reshape(h, w)\n H = np.exp(-1 * H)\n\n E = source_concentrations[:, 1].reshape(h, w)\n E = np.exp(-1 * E)\n\n # H = np.reshape(source_concentrations[:, 0], newshape=(h*w, 1))\n # H = (255 * np.exp(-1 * np.dot(H, np.reshape(stain_matrix_source[0],\n # newshape=(1, 3))).reshape(I.shape))).astype(np.uint8)\n # E = np.reshape(source_concentrations[:, 1], newshape=(h*w, 1))\n # E = (255 * np.exp(-1 * np.dot(E, np.reshape(stain_matrix_source[1],\n # newshape=(1, 3))).reshape(I.shape))).astype(np.uint8)\n return H, E\n"
] | [
[
"numpy.asarray",
"numpy.exp",
"numpy.median",
"numpy.array",
"numpy.dot"
]
] |
Meghanath-Data/ml-on-gcp | [
"bfd96dce610e26236c4448ba0d4eb430ca2817ff"
] | [
"example_zoo/tensorflow/models/mnist/official/mnist/mnist.py"
] | [
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Convolutional Neural Network Estimator for MNIST, built with tf.layers.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom absl import app as absl_app\nfrom absl import flags\nflags.DEFINE_string(name=\"job-dir\", default=\"/tmp\", help=\"AI Platform Training passes this to the training script.\")\nimport tensorflow as tf # pylint: disable=g-bad-import-order\n\nfrom official.mnist import dataset\nfrom official.utils.flags import core as flags_core\nfrom official.utils.logs import hooks_helper\nfrom official.utils.misc import distribution_utils\nfrom official.utils.misc import model_helpers\n\n\nLEARNING_RATE = 1e-4\n\n\ndef create_model(data_format):\n \"\"\"Model to recognize digits in the MNIST dataset.\n\n Network structure is equivalent to:\n https://github.com/tensorflow/tensorflow/blob/r1.5/tensorflow/examples/tutorials/mnist/mnist_deep.py\n and\n https://github.com/tensorflow/models/blob/master/tutorials/image/mnist/convolutional.py\n\n But uses the tf.keras API.\n\n Args:\n data_format: Either 'channels_first' or 'channels_last'. 'channels_first' is\n typically faster on GPUs while 'channels_last' is typically faster on\n CPUs. See\n https://www.tensorflow.org/performance/performance_guide#data_formats\n\n Returns:\n A tf.keras.Model.\n \"\"\"\n if data_format == 'channels_first':\n input_shape = [1, 28, 28]\n else:\n assert data_format == 'channels_last'\n input_shape = [28, 28, 1]\n\n l = tf.keras.layers\n max_pool = l.MaxPooling2D(\n (2, 2), (2, 2), padding='same', data_format=data_format)\n # The model consists of a sequential chain of layers, so tf.keras.Sequential\n # (a subclass of tf.keras.Model) makes for a compact description.\n return tf.keras.Sequential(\n [\n l.Reshape(\n target_shape=input_shape,\n input_shape=(28 * 28,)),\n l.Conv2D(\n 32,\n 5,\n padding='same',\n data_format=data_format,\n activation=tf.nn.relu),\n max_pool,\n l.Conv2D(\n 64,\n 5,\n padding='same',\n data_format=data_format,\n activation=tf.nn.relu),\n max_pool,\n l.Flatten(),\n l.Dense(1024, activation=tf.nn.relu),\n l.Dropout(0.4),\n l.Dense(10)\n ])\n\n\ndef define_mnist_flags():\n flags_core.define_base()\n flags_core.define_performance(num_parallel_calls=False)\n flags_core.define_image()\n flags.adopt_module_key_flags(flags_core)\n flags_core.set_defaults(data_dir='/tmp/mnist_data',\n model_dir='/tmp/mnist_model',\n batch_size=100,\n train_epochs=40)\n\n\ndef model_fn(features, labels, mode, params):\n \"\"\"The model_fn argument for creating an Estimator.\"\"\"\n model = create_model(params['data_format'])\n image = features\n if isinstance(image, dict):\n image = features['image']\n\n if mode == tf.estimator.ModeKeys.PREDICT:\n logits = model(image, training=False)\n predictions = {\n 'classes': tf.argmax(logits, axis=1),\n 'probabilities': tf.nn.softmax(logits),\n }\n return tf.estimator.EstimatorSpec(\n mode=tf.estimator.ModeKeys.PREDICT,\n predictions=predictions,\n export_outputs={\n 'classify': tf.estimator.export.PredictOutput(predictions)\n })\n if mode == tf.estimator.ModeKeys.TRAIN:\n optimizer = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE)\n\n logits = model(image, training=True)\n loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)\n accuracy = tf.metrics.accuracy(\n labels=labels, predictions=tf.argmax(logits, axis=1))\n\n # Name tensors to be logged with LoggingTensorHook.\n tf.identity(LEARNING_RATE, 'learning_rate')\n tf.identity(loss, 'cross_entropy')\n tf.identity(accuracy[1], name='train_accuracy')\n\n # Save accuracy scalar to Tensorboard output.\n tf.summary.scalar('train_accuracy', accuracy[1])\n\n return tf.estimator.EstimatorSpec(\n mode=tf.estimator.ModeKeys.TRAIN,\n loss=loss,\n train_op=optimizer.minimize(loss, tf.train.get_or_create_global_step()))\n if mode == tf.estimator.ModeKeys.EVAL:\n logits = model(image, training=False)\n loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)\n return tf.estimator.EstimatorSpec(\n mode=tf.estimator.ModeKeys.EVAL,\n loss=loss,\n eval_metric_ops={\n 'accuracy':\n tf.metrics.accuracy(\n labels=labels, predictions=tf.argmax(logits, axis=1)),\n })\n\n\ndef run_mnist(flags_obj):\n \"\"\"Run MNIST training and eval loop.\n\n Args:\n flags_obj: An object containing parsed flag values.\n \"\"\"\n model_helpers.apply_clean(flags_obj)\n model_function = model_fn\n\n session_config = tf.ConfigProto(\n inter_op_parallelism_threads=flags_obj.inter_op_parallelism_threads,\n intra_op_parallelism_threads=flags_obj.intra_op_parallelism_threads,\n allow_soft_placement=True)\n\n distribution_strategy = distribution_utils.get_distribution_strategy(\n flags_core.get_num_gpus(flags_obj), flags_obj.all_reduce_alg)\n\n run_config = tf.estimator.RunConfig(\n train_distribute=distribution_strategy, session_config=session_config)\n\n data_format = flags_obj.data_format\n if data_format is None:\n data_format = ('channels_first'\n if tf.test.is_built_with_cuda() else 'channels_last')\n mnist_classifier = tf.estimator.Estimator(\n model_fn=model_function,\n model_dir=flags_obj.model_dir,\n config=run_config,\n params={\n 'data_format': data_format,\n })\n\n # Set up training and evaluation input functions.\n def train_input_fn():\n \"\"\"Prepare data for training.\"\"\"\n\n # When choosing shuffle buffer sizes, larger sizes result in better\n # randomness, while smaller sizes use less memory. MNIST is a small\n # enough dataset that we can easily shuffle the full epoch.\n ds = dataset.train(flags_obj.data_dir)\n ds = ds.cache().shuffle(buffer_size=50000).batch(flags_obj.batch_size)\n\n # Iterate through the dataset a set number (`epochs_between_evals`) of times\n # during each training session.\n ds = ds.repeat(flags_obj.epochs_between_evals)\n return ds\n\n def eval_input_fn():\n return dataset.test(flags_obj.data_dir).batch(\n flags_obj.batch_size).make_one_shot_iterator().get_next()\n\n # Set up hook that outputs training logs every 100 steps.\n train_hooks = hooks_helper.get_train_hooks(\n flags_obj.hooks, model_dir=flags_obj.model_dir,\n batch_size=flags_obj.batch_size)\n\n # Train and evaluate model.\n for _ in range(flags_obj.train_epochs // flags_obj.epochs_between_evals):\n mnist_classifier.train(input_fn=train_input_fn, hooks=train_hooks)\n eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)\n print('\\nEvaluation results:\\n\\t%s\\n' % eval_results)\n\n if model_helpers.past_stop_threshold(flags_obj.stop_threshold,\n eval_results['accuracy']):\n break\n\n # Export the model\n if flags_obj.export_dir is not None:\n image = tf.placeholder(tf.float32, [None, 28, 28])\n input_fn = tf.estimator.export.build_raw_serving_input_receiver_fn({\n 'image': image,\n })\n mnist_classifier.export_savedmodel(flags_obj.export_dir, input_fn,\n strip_default_attrs=True)\n\n\ndef main(_):\n run_mnist(flags.FLAGS)\n\n\nif __name__ == '__main__':\n tf.logging.set_verbosity(tf.logging.INFO)\n define_mnist_flags()\n absl_app.run(main)\n"
] | [
[
"tensorflow.estimator.Estimator",
"tensorflow.summary.scalar",
"tensorflow.placeholder",
"tensorflow.logging.set_verbosity",
"tensorflow.train.AdamOptimizer",
"tensorflow.estimator.export.build_raw_serving_input_receiver_fn",
"tensorflow.test.is_built_with_cuda",
"tensorflow.estimator.RunConfig",
"tensorflow.losses.sparse_softmax_cross_entropy",
"tensorflow.estimator.export.PredictOutput",
"tensorflow.argmax",
"tensorflow.train.get_or_create_global_step",
"tensorflow.identity",
"tensorflow.nn.softmax",
"tensorflow.ConfigProto"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.