repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list | possible_versions
list |
|---|---|---|---|---|---|
huttzza/maskrcnn-benchmark | [
"d15971e4b602bb71e5494ce8973293fedf202e58"
] | [
"maskrcnn_benchmark/modeling/da_heads/da_heads.py"
] | [
"# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\nfrom __future__ import print_function\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom maskrcnn_benchmark.layers import GradientScalarLayer\n\nfrom .loss import make_da_heads_loss_evaluator\n\nclass DAImgHead(nn.Module):\n \"\"\"\n Adds a simple Image-level Domain Classifier head\n \"\"\"\n\n def __init__(self, in_channels):\n \"\"\"\n Arguments:\n in_channels (int): number of channels of the input feature\n USE_FPN (boolean): whether FPN feature extractor is used\n \"\"\"\n super(DAImgHead, self).__init__()\n \n self.conv1_da = nn.Conv2d(in_channels, 512, kernel_size=1, stride=1)\n self.conv2_da = nn.Conv2d(512, 1, kernel_size=1, stride=1)\n\n for l in [self.conv1_da, self.conv2_da]:\n torch.nn.init.normal_(l.weight, std=0.001)\n torch.nn.init.constant_(l.bias, 0)\n\n def forward(self, x):\n img_features = []\n for feature in x:\n t = F.relu(self.conv1_da(feature))\n img_features.append(self.conv2_da(t))\n return img_features\n\n\nclass DAInsHead(nn.Module):\n \"\"\"\n Adds a simple Instance-level Domain Classifier head\n \"\"\"\n\n def __init__(self, in_channels):\n \"\"\"\n Arguments:\n in_channels (int): number of channels of the input feature\n \"\"\"\n super(DAInsHead, self).__init__()\n self.fc1_da = nn.Linear(in_channels, 1024)\n self.fc2_da = nn.Linear(1024, 1024)\n self.fc3_da = nn.Linear(1024, 1)\n for l in [self.fc1_da, self.fc2_da]:\n nn.init.normal_(l.weight, std=0.01)\n nn.init.constant_(l.bias, 0)\n nn.init.normal_(self.fc3_da.weight, std=0.05)\n nn.init.constant_(self.fc3_da.bias, 0)\n\n def forward(self, x):\n x = F.relu(self.fc1_da(x))\n x = F.dropout(x, p=0.5, training=self.training)\n\n x = F.relu(self.fc2_da(x))\n x = F.dropout(x, p=0.5, training=self.training)\n\n x = self.fc3_da(x)\n return x\n\n\nclass DomainAdaptationModule(torch.nn.Module):\n \"\"\"\n Module for Domain Adaptation Component. Takes feature maps from the backbone and instance\n feature vectors, domain labels and proposals. Works for both FPN and non-FPN.\n \"\"\"\n\n def __init__(self, cfg):\n super(DomainAdaptationModule, self).__init__()\n\n self.cfg = cfg.clone()\n\n stage_index = 4\n stage2_relative_factor = 2 ** (stage_index - 1)\n res2_out_channels = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS\n num_ins_inputs = cfg.MODEL.ROI_BOX_HEAD.MLP_HEAD_DIM if cfg.MODEL.BACKBONE.CONV_BODY.startswith('V') else res2_out_channels * stage2_relative_factor\n \n self.resnet_backbone = cfg.MODEL.BACKBONE.CONV_BODY.startswith('R')\n self.avgpool = nn.AvgPool2d(kernel_size=7, stride=7)\n \n self.img_weight = cfg.MODEL.DA_HEADS.DA_IMG_LOSS_WEIGHT\n self.ins_weight = cfg.MODEL.DA_HEADS.DA_INS_LOSS_WEIGHT\n self.cst_weight = cfg.MODEL.DA_HEADS.DA_CST_LOSS_WEIGHT\n\n self.grl_img = GradientScalarLayer(-1.0*self.cfg.MODEL.DA_HEADS.DA_IMG_GRL_WEIGHT)\n self.grl_ins = GradientScalarLayer(-1.0*self.cfg.MODEL.DA_HEADS.DA_INS_GRL_WEIGHT)\n self.grl_img_consist = GradientScalarLayer(1.0*self.cfg.MODEL.DA_HEADS.DA_IMG_GRL_WEIGHT)\n self.grl_ins_consist = GradientScalarLayer(1.0*self.cfg.MODEL.DA_HEADS.DA_INS_GRL_WEIGHT)\n \n in_channels = cfg.MODEL.BACKBONE.OUT_CHANNELS\n\n self.imghead = DAImgHead(in_channels)\n self.inshead = DAInsHead(num_ins_inputs)\n self.loss_evaluator = make_da_heads_loss_evaluator(cfg)\n\n def forward(self, img_features, da_ins_feature, da_ins_labels, targets=None):\n \"\"\"\n Arguments:\n img_features (list[Tensor]): features computed from the images that are\n used for computing the predictions.\n da_ins_feature (Tensor): instance-level feature vectors\n da_ins_labels (Tensor): domain labels for instance-level feature vectors\n targets (list[BoxList): ground-truth boxes present in the image (optional)\n\n Returns:\n losses (dict[Tensor]): the losses for the model during training. During\n testing, it is an empty dict.\n \"\"\"\n if self.resnet_backbone:\n da_ins_feature = self.avgpool(da_ins_feature)\n da_ins_feature = da_ins_feature.view(da_ins_feature.size(0), -1)\n\n img_grl_fea = [self.grl_img(fea) for fea in img_features]\n ins_grl_fea = self.grl_ins(da_ins_feature)\n img_grl_consist_fea = [self.grl_img_consist(fea) for fea in img_features]\n ins_grl_consist_fea = self.grl_ins_consist(da_ins_feature)\n\n da_img_features = self.imghead(img_grl_fea)\n da_ins_features = self.inshead(ins_grl_fea)\n da_img_consist_features = self.imghead(img_grl_consist_fea)\n da_ins_consist_features = self.inshead(ins_grl_consist_fea)\n da_img_consist_features = [fea.sigmoid() for fea in da_img_consist_features]\n da_ins_consist_features = da_ins_consist_features.sigmoid()\n if self.training:\n da_img_loss, da_ins_loss, da_consistency_loss = self.loss_evaluator(\n da_img_features, da_ins_features, da_img_consist_features, da_ins_consist_features, da_ins_labels, targets\n )\n losses = {}\n if self.img_weight > 0:\n losses[\"loss_da_image\"] = self.img_weight * da_img_loss\n if self.ins_weight > 0:\n losses[\"loss_da_instance\"] = self.ins_weight * da_ins_loss\n if self.cst_weight > 0:\n losses[\"loss_da_consistency\"] = self.cst_weight * da_consistency_loss\n return losses\n return {}\n\ndef build_da_heads(cfg):\n if cfg.MODEL.DOMAIN_ADAPTATION_ON:\n return DomainAdaptationModule(cfg)\n return []\n"
] | [
[
"torch.nn.functional.dropout",
"torch.nn.init.constant_",
"torch.nn.Conv2d",
"torch.nn.Linear",
"torch.nn.AvgPool2d",
"torch.nn.init.normal_"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
DevinCrowley/ardent | [
"5e731947e58b8670463521abe6a52d4962d4221f"
] | [
"ardent/visualization.py"
] | [
"import numpy as np\nimport matplotlib.pyplot as plt\nimport nibabel as nib\nimport nilearn.plotting as niplot\n\ndef _scale_data(data, limit_mode=None, stdevs=4, quantile=0.01, limits=None):\n \"\"\"Returns a copy of data scaled such that the bulk of the values are mapped to the range [0, 1].\n \n Upper and lower limits are chosen based on limit_mode and other arguments.\n These limits are the anchors by which <data> is scaled such that after scaling,\n they lie on either end of the range [0, 1].\n\n supported limit_mode values:\n - 'valid mode' | related_kwarg [default kwarg value] --> description\n - 'stdev' | stdevs [4] --> limits are the mean +/- <stdevs> standard deviations\n - 'quantile' | quantile [0.05] --> limits are the <quantile> and 1 - <quantile> quantiles\n\n If <limits> is provided as a 2-element iterable, it will override limit_mode \n and be used directly as the anchoring limits:\n <limits> = (lower, upper).\"\"\"\n\n # Verify type of data.\n if not isinstance(data, np.ndarray):\n raise TypeError(f\"data must be of type np.ndarray.\\ntype(data): {type(data)}.\")\n\n # Determine scaling limits.\n\n if limits is not None:\n # TODO: make <limits> validation robust.\n if not isinstance(limits, (tuple, list, np.ndarray)):\n raise TypeError(f\"If provided, limits must be one of the following types: tuple, list, np.ndarray.\\n\"\n f\"type(limits): {type(limits)}.\")\n else:\n # <limits> is a tuple, list, or np.ndarray.\n try:\n if len(limits) != 2:\n raise ValueError(f\"If provided, limits must have length 2.\\n\"\n f\"len(limits): {len(limits)}.\")\n except TypeError:\n raise ValueError(f\"limits was provided as a 0-dimensional np.ndarray. It must have length 2.\\n\"\n f\"limits: {limits}.\")\n # <limits> is a 2-element tuple, list, or np.ndarray.\n lower_lim, upper_lim = limits\n else:\n # limits is None. Use limit_mode to determine upper and lower limits.\n # List supported limit_mode values.\n supported_limit_modes = [None, 'stdev', 'quantile']\n # Handle default None value, with no meaningful limits.\n if limit_mode is None:\n lower_lim = np.min(data)\n upper_lim = np.max(data)\n # Check limit_mode type.\n elif not isinstance(limit_mode, str):\n raise TypeError(f\"If provided, limit_mode must be a string.\\ntype(limit_mode): {type(limit_mode)}.\")\n # limit_mode is a string.\n # Calculate limits appropriately.\n elif limit_mode == 'stdev':\n # Verify stdevs.\n if not isinstance(stdevs, (int, float)):\n raise TypeError(f\"For limit_mode='stdev', <stdevs> must be of type int or float.\\n\"\n f\"type(stdevs): {type(stdevs)}.\")\n if stdevs < 0:\n raise ValueError(f\"For limit_mode='stdev', <stdevs> must be non-negative.\\n\"\n f\"stdevs: {stdevs}.\")\n # Choose limits equal to the mean +/- <stdevs> standard deviations.\n stdev = np.std(data)\n mean = np.mean(data)\n lower_lim = mean - stdevs*stdev\n upper_lim = mean + stdevs*stdev\n elif limit_mode == 'quantile':\n # Verify quantile.\n if not isinstance(quantile, (int, float)):\n raise TypeError(f\"For limit_mode='quantile', <quantile> must be of type int or float.\\n\"\n f\"type(quantile): {type(quantile)}.\")\n if quantile < 0 or quantile > 1:\n raise ValueError(f\"For limit_mode='quantile', <quantile> must be in the interval [0, 1].\\n\"\n f\"quantile: {quantile}.\")\n # Choose limits based on quantile.\n lower_lim = np.quantile(data, min(quantile, 1 - quantile))\n upper_lim = np.quantile(data, max(quantile, 1 - quantile))\n else:\n raise ValueError(f\"Unrecognized value for limit_mode. Supported values include {supported_limit_modes}.\\n\"\n f\"limit_mode: {limit_mode}.\")\n # lower_lim and upper_lim are set appropriately.\n\n # TODO: make harmonious with quantiles approach so that it centers at the median.\n # Scale data such that the bulk lies approximately on [0, 1].\n scaled_data = (data - lower_lim) / (upper_lim - lower_lim)\n \n # Return scaled copy of data.\n return scaled_data\n\n\ndef _validate_inputs(data, title, n_cuts, xcuts, ycuts, zcuts, figsize):\n \"\"\"Returns a dictionary of the form {'inputName' : inputValue}.\n It has an entry for each argument that has been validated.\"\"\"\n\n inputDict = {'data':data, 'figsize':figsize}\n\n # Validate data.\n\n supported_data_types = [np.ndarray]\n # Convert data to np.ndarray for supported types.\n # if isinstance(data, ):\n # # Convert to np.ndarray.\n # data = np.array(data)\n\n # If data is none of the supported types, attempt to cast it as a np.ndarray.\n if not isinstance(data, np.ndarray):\n try:\n data = np.array(data)\n except TypeError:\n # If a TypeError was raised on casting data to a np.ndarray, raise informative TypeError.\n raise TypeError(f\"data is not one of the supported types {supported_data_types} and cannot be cast as a np.ndarray.\\n\"\n f\"type(data): {type(data)}.\")\n\n if data.ndim < 3: # <3\n raise ValueError(f\"data must have at least 3 dimensions.\\ndata.ndim: {data.ndim}.\")\n # data is valid.\n inputDict.update(data=data)\n\n # Validate figsize.\n\n # TODO: dynamicize figsize.\n if figsize is None:\n # Compute figsize.\n raise NotImplementedError(\"This functionality has not yet been implemented. Please provide another figsize.\")\n else:\n try:\n if len(figsize) != 2:\n raise ValueError(f\"figsize must be an iterable with length 2.\\n\"\n f\"len(figsize): {len(figsize)}.\")\n except TypeError:\n raise TypeError(f\"figsize must be an iterable.\\ntype(figsize): {type(figsize)}.\")\n # figsize is valid.\n inputDict.update(figsize=figsize)\n\n return inputDict\n\n\n# TODO: update work with interesting_cuts and new Image class\ndef _Image_to_Nifti2Image(image, affine=None):\n \n nifti2header = nib.Nifti2Header()\n nifti2header['dim'][1:1 + len(image.nxyz)] = image.nxyz\n nifti2header['pixdim'][1:1 + len(image.dxyz)] = image.dxyz\n \n nifti2image = nib.Nifti2Image(image.data, affine=affine, header=nifti2header)\n \n return nifti2image\n\n\ndef _get_cuts(data, xcuts, ycuts, zcuts, n_cuts=5, interesting_cuts=False):\n \"\"\"Returns xcuts, ycuts, & zcuts. If any of these are provided, they are used. \n If any are not provided, they are computed. \n \n The default is to compute unprovided cuts as evenly spaced slices across that dimension.\n However, if interesting_cuts is True, then any dimension's cuts that are not specified \n are computed using niplot.find_cut_slices.\"\"\"\n\n if interesting_cuts is True:\n # TODO: update Image_to_Nifti2Image to allow for multiple input types, and find a way to give it image metadata.\n raise NotImplementedError(\"This functionality has not been fully implemented yet.\")\n xcuts = xcuts or niplot.find_cut_slices(Image_to_Nifti2Image(atlas_Image, affine=np.eye(4)), direction='x', n_cuts=n_cuts).astype(int)\n ycuts = ycuts or niplot.find_cut_slices(Image_to_Nifti2Image(atlas_Image, affine=np.eye(4)), direction='y', n_cuts=n_cuts).astype(int)\n zcuts = zcuts or niplot.find_cut_slices(Image_to_Nifti2Image(atlas_Image, affine=np.eye(4)), direction='z', n_cuts=n_cuts).astype(int)\n else:\n xcuts = xcuts or np.linspace(0, data.shape[0], n_cuts + 2)[1:-1]\n ycuts = ycuts or np.linspace(0, data.shape[1], n_cuts + 2)[1:-1]\n zcuts = zcuts or np.linspace(0, data.shape[2], n_cuts + 2)[1:-1]\n \n return xcuts, ycuts, zcuts\n\n# TODO: verify plotting works with xyzcuts provided with inconsistent lengths.\n# TODO: allow n_cuts to be a triple.\ndef heatslices(data, \n title=None, figsize=(10, 5), cmap='gray',\n n_cuts=5, xcuts=[], ycuts=[], zcuts=[],\n limit_mode=None, stdevs=4, quantile=0.01, limits=None, vmin=0, vmax=1):\n \"\"\"\n Produce a figure with 3 rows of images, each corresponding to a different orthogonal view of data.\n Each row can have arbitrarily many parallel views.\n The data is scaled such that its bulk lies on the interval [0, 1], with the extrema optionally left unaccounted for in determining the scaling.\n Those values outside the limits saturate at 0 or 1 in the figure.\n \n Args:\n data (np.ndarray): A 3 or 4 dimensional array containing volumetric intensity data (if 3D) or RGB data (if 4D) to be viewed.\n title (str, optional): The figure title. Defaults to None.\n figsize (tuple, optional): The width and height of the figure in inches. Defaults to (10, 5).\n cmap (str, optional): The name of the chosen color map. Defaults to 'gray'.\n n_cuts (int, optional): The number of parallel views to show on each row without a specified list of cuts. Defaults to 5.\n xcuts (list, optional): A list of indices at which to display a view in the first row. Defaults to [n_cuts evenly spaced indices. Half the spacing between indices pads each end].\n ycuts (list, optional): A list of indices at which to display a view in the second row. Defaults to [n_cuts evenly spaced indices. Half the spacing between indices pads each end].\n zcuts (list, optional): A list of indices at which to display a view in the third row. Defaults to [n_cuts evenly spaced indices. Half the spacing between indices pads each end.].\n limit_mode (str, NoneType, optional): A string indicating what mode to use for clipping the extrema of data for determining the scaling to the interval [vmin, vmax]. \n \n Accepted values:\n - None\n - 'stdev'\n - 'quantile'\n Defaults to None.\n stdevs (float, optional): Used if limit_mode == 'stdev': The number of standard deviations from the mean that will be scaled to the interval [vmin, vmax]. Defaults to 4.\n quantile (float, optional): Used if limit_mode == 'quantile': The proportion of data that will not be considered for scaling to the interval [vmin, vmax]. Defaults to 0.01.\n limits (sequence, optional): The lower and upper limits bookmarking which values in data will be considered when scaling to the interval [vmin, vmax]. Overrides limit_mode. Defaults to None.\n vmin (float, optional): The smallest value displayed in the figure. Smaller values will saturate to vmin. Defaults to 0.\n vmax (float, optional): The largest value displayed in the figure. Larger values will saturate to vmax. Defaults to 1.\n \"\"\"\n # Figure-tuning arguments.\n # What will be displayed.\n # data-scaling arguments.\n \n \n # TODO: validate all inputs.\n # Validate inputs\n inputs = {'data':data, 'title':title, 'n_cuts':n_cuts, 'xcuts':xcuts, 'ycuts':ycuts, 'zcuts':zcuts, 'figsize':figsize}\n validated_inputs = _validate_inputs(**inputs)\n locals().update(validated_inputs)\n\n # Scale bulk of data to [0, 1].\n data = _scale_data(data, limit_mode=limit_mode, stdevs=stdevs, quantile=quantile, limits=limits) # Side-effect: breaks alias.\n \n # Get cuts.\n xcuts, ycuts, zcuts = _get_cuts(data, xcuts, ycuts, zcuts, n_cuts)\n \n # maxcuts is the number of cuts in the dimension with the largest number of cuts.\n maxcuts = max(list(map(lambda cuts: len(cuts), [xcuts, ycuts, zcuts])))\n \n # TODO: check out imshow param extent for anisotropy\n # TODO: properly scale subplots / axs such that scale is consistent across all images.\n fig, axs = plt.subplots(3, maxcuts, sharex='row', sharey='row', figsize=figsize)\n plt.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9, wspace=0.1, hspace=0.2)\n for ax in axs.ravel():\n pass\n plt.setp(axs, aspect='equal', xticks=[], yticks=[])\n for row, cuts in enumerate([xcuts, ycuts, zcuts]):\n for col, cut in enumerate(cuts):\n axs[row, col].grid(False)\n img = axs[row, col].imshow(data.take(cut, row), vmin=vmin, vmax=vmax, cmap=cmap)\n cax = plt.axes([0.925, 0.1, 0.025, 0.77])\n plt.colorbar(img, cax=cax)\n fig.suptitle(title, fontsize=20)"
] | [
[
"numpy.linspace",
"numpy.min",
"numpy.eye",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.axes",
"matplotlib.pyplot.colorbar",
"numpy.max",
"numpy.std",
"matplotlib.pyplot.setp",
"numpy.mean",
"matplotlib.pyplot.subplots_adjust",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ivandrej/checkmatte | [
"48992e9eb777b609eab32e58d918f1fb41ca51f1",
"48992e9eb777b609eab32e58d918f1fb41ca51f1"
] | [
"evaluation/varying_misalignment.py",
"evaluation/evaluation_metrics.py"
] | [
"import argparse\nimport os\n\nimport pandas as pd\n\nimport evaluate_experiment\nimport perform_experiment\nfrom composite import read_metadata\n\n\ndef read_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('--experiment-metadata', type=str, required=True)\n parser.add_argument('--experiment-dir', type=str, required=True)\n parser.add_argument('--input-dir', type=str, required=True)\n parser.add_argument('--load-model', type=str, required=True)\n parser.add_argument('--model-type', type=str, choices=['addition', 'concat', 'f3', 'f4'], default='addition')\n parser.add_argument('--resize', type=int, default=None, nargs=2)\n parser.add_argument('--num-frames', type=int, default=100)\n parser.add_argument('--num-workers', type=int, default=8)\n parser.add_argument('--random-bgr', action=\"store_true\")\n return parser.parse_args()\n\nif __name__ == \"__main__\":\n args = read_args()\n input_dir = args.input_dir\n\n clips = read_metadata(args.experiment_metadata)\n # if args.random_bgr:\n # clips = replace_bgr_with_random_bgr(clips)\n temporal_offsets = [10, 30, 50, 80]\n rotations = [(0, 0), (5, 10), (25, 30)]\n\n for temporal_offset in temporal_offsets:\n for rotation in rotations:\n out_dir = os.path.join(args.experiment_dir, f\"offset{temporal_offset}_rotation{[rotation[0],rotation[1]]}\")\n print(f\"Saving results in {out_dir}\")\n print(\"Performing inference...\")\n perform_experiment.inference(out_dir, args.model_type, args.load_model,\n input_dir, clips, args.resize, output_type='png_sequence',\n bgr_offset=temporal_offset, bgr_rotation=rotation)\n\n print(\"Performing evaluation...\")\n evaluate_experiment.Evaluator(out_dir, args.experiment_metadata, args.num_workers, args.resize,\n metrics=['pha_mad', 'pha_bgr_mad', 'pha_fgr_mad'])\n\n summary = {'misalignment': [], 'pha_mad': [], 'pha_bgr_mad': [], 'pha_fgr_mad': []}\n for misalignment_type in os.listdir(args.experiment_dir):\n df = pd.read_csv(os.path.join(args.experiment_dir, misalignment_type, 'metrics.csv')).set_index(\"clipname\")\n summary['misalignment'].append(misalignment_type)\n # print(df)\n summary['pha_mad'].append(df.loc['mean', 'pha_mad'])\n summary['pha_bgr_mad'].append(df.loc['mean', 'pha_bgr_mad'])\n summary['pha_fgr_mad'].append(df.loc['mean', 'pha_fgr_mad'])\n\n pd.DataFrame.from_dict(summary).to_csv(os.path.join(args.experiment_dir, 'summary.csv'))",
"import warnings\n\nimport torch\nimport kornia\nimport numpy as np\n\n\nclass MetricMAD:\n def __call__(self, pred, true):\n return (pred - true).abs_().mean() * 1e3\n\nclass MetricBgrMAD:\n def __call__(self, pred, true):\n bgr_mask = true == 0\n return (pred[bgr_mask] - true[bgr_mask]).abs_().mean() * 1e3\n\nclass MetricFgrMAD:\n def __call__(self, pred, true):\n fgr_mask = true > 0\n return (pred[fgr_mask] - true[fgr_mask]).abs_().mean() * 1e3\n\n\nclass MetricMSE:\n def __call__(self, pred, true):\n return ((pred - true) ** 2).mean() * 1e3\n\n\nclass MetricGRAD:\n def __init__(self, sigma=1.4):\n self.filter_x, self.filter_y = self.gauss_filter(sigma)\n self.filter_x = torch.from_numpy(self.filter_x).unsqueeze(0).cuda()\n self.filter_y = torch.from_numpy(self.filter_y).unsqueeze(0).cuda()\n\n def __call__(self, pred, true):\n true_grad = self.gauss_gradient(true)\n pred_grad = self.gauss_gradient(pred)\n return ((true_grad - pred_grad) ** 2).sum() / 1000\n\n def gauss_gradient(self, img):\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n warnings.warn(\"deprecated\", DeprecationWarning)\n img_filtered_x = kornia.filters.filter2D(img[None, None, :, :], self.filter_x, border_type='replicate')[0, 0]\n img_filtered_y = kornia.filters.filter2D(img[None, None, :, :], self.filter_y, border_type='replicate')[0, 0]\n return (img_filtered_x ** 2 + img_filtered_y ** 2).sqrt()\n\n @staticmethod\n def gauss_filter(sigma, epsilon=1e-2):\n half_size = np.ceil(sigma * np.sqrt(-2 * np.log(np.sqrt(2 * np.pi) * sigma * epsilon)))\n size = np.int(2 * half_size + 1)\n\n # create filter in x axis\n filter_x = np.zeros((size, size))\n for i in range(size):\n for j in range(size):\n filter_x[i, j] = MetricGRAD.gaussian(i - half_size, sigma) * MetricGRAD.dgaussian(\n j - half_size, sigma)\n\n # normalize filter\n norm = np.sqrt((filter_x ** 2).sum())\n filter_x = filter_x / norm\n filter_y = np.transpose(filter_x)\n\n return filter_x, filter_y\n\n @staticmethod\n def gaussian(x, sigma):\n return np.exp(-x ** 2 / (2 * sigma ** 2)) / (sigma * np.sqrt(2 * np.pi))\n\n @staticmethod\n def dgaussian(x, sigma):\n return -x * MetricGRAD.gaussian(x, sigma) / sigma ** 2\n\n\nclass MetricDTSSD:\n def __call__(self, pred_t, pred_tm1, true_t, true_tm1):\n dtSSD = ((pred_t - pred_tm1) - (true_t - true_tm1)) ** 2\n dtSSD = dtSSD.sum() / true_t.numel()\n dtSSD = dtSSD.sqrt()\n return dtSSD * 1e2\n"
] | [
[
"pandas.DataFrame.from_dict"
],
[
"numpy.sqrt",
"torch.from_numpy",
"numpy.int",
"numpy.transpose",
"numpy.exp",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
brightcoder01/sqlflow | [
"1b5b75a62908c6fa17fbfd1309a502c8c613fe3d",
"1b5b75a62908c6fa17fbfd1309a502c8c613fe3d"
] | [
"python/sqlflow_submitter/xgboost/dataset.py",
"python/sqlflow_submitter/tensorflow/estimator_example.py"
] | [
"# Copyright 2020 The SQLFlow Authors. All rights reserved.\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 json\nimport os\nimport shutil\nimport sys\nfrom pathlib import Path\n\nimport numpy as np\nimport six\nimport xgboost as xgb\nfrom scipy.sparse import vstack\nfrom sklearn.datasets import load_svmlight_file, load_svmlight_files\nfrom sqlflow_submitter import db\n\n\ndef xgb_dataset(datasource,\n fn,\n dataset_sql,\n feature_specs,\n feature_column_names,\n label_spec,\n is_pai=False,\n pai_table=\"\",\n pai_single_file=False,\n cache=False,\n batch_size=None,\n epoch=1,\n rank=0,\n nworkers=1,\n transform_fn=None,\n feature_column_code=\"\",\n raw_data_dir=None):\n if raw_data_dir:\n # raw_data_dir is needed when predicting. Because we\n # should write the raw data from the source db into\n # the dest db, instead of the transformed data after\n # `transform_fn(features)` . If raw_data_dir is not\n # None, the raw data from the source db would be written\n # into another file.\n if os.path.exists(raw_data_dir):\n shutil.rmtree(raw_data_dir, ignore_errors=True)\n\n os.mkdir(raw_data_dir)\n\n if is_pai:\n for dmatrix in pai_dataset(\n fn,\n feature_specs,\n feature_column_names,\n label_spec,\n \"odps://{}/tables/{}\".format(*pai_table.split(\".\")),\n pai_single_file,\n cache,\n rank,\n nworkers,\n batch_size=batch_size,\n feature_column_code=feature_column_code,\n raw_data_dir=raw_data_dir):\n yield dmatrix\n return\n\n conn = db.connect_with_data_source(datasource)\n gen = db.db_generator(conn.driver, conn, dataset_sql, feature_column_names,\n label_spec, feature_specs)()\n\n selected_cols = db.selected_cols(conn.driver, conn, dataset_sql)\n for _ in six.moves.range(epoch):\n step = 0\n # the filename per batch is [filename]_[step]\n step_file_name = \"%s_%d\" % (fn, step)\n written_rows = dump_dmatrix(step_file_name,\n gen,\n feature_column_names,\n feature_specs,\n label_spec,\n selected_cols,\n transform_fn=transform_fn,\n raw_data_dir=raw_data_dir)\n\n while written_rows > 0:\n yield load_dmatrix('{0}#{0}.cache'.format(step_file_name)\n if cache else step_file_name)\n os.remove(step_file_name)\n\n step += 1\n step_file_name = \"%s_%d\" % (fn, step)\n written_rows = dump_dmatrix(step_file_name,\n gen,\n feature_column_names,\n feature_specs,\n label_spec,\n selected_cols,\n transform_fn=transform_fn,\n raw_data_dir=raw_data_dir)\n\n\ndef dump_dmatrix(filename,\n generator,\n feature_column_names,\n feature_specs,\n has_label,\n selected_cols,\n batch_size=None,\n transform_fn=None,\n raw_data_dir=None):\n # TODO(yancey1989): generate group and weight text file if necessary\n row_id = 0\n\n if raw_data_dir:\n index = filename.rindex('/') + 1 if '/' in filename else 0\n raw_data_fid = open(os.path.join(raw_data_dir, filename[index:]), 'a')\n else:\n raw_data_fid = None\n\n with open(filename, 'a') as f:\n for row, label in generator:\n features = db.read_features_from_row(row, selected_cols,\n feature_column_names,\n feature_specs)\n\n if raw_data_fid is not None:\n row_data = [\"{}:{}\".format(i, r) for i, r in enumerate(row)]\n raw_data_fid.write(\"\\t\".join(row_data) + \"\\n\")\n\n if transform_fn:\n features = transform_fn(features)\n\n row_data = []\n offset = 0\n for i, v in enumerate(features):\n if len(v) == 1: # dense feature\n value = v[0]\n if isinstance(value, np.ndarray):\n value = value.reshape((-1, ))\n row_data.extend([\n \"{}:{}\".format(i + offset, item)\n for i, item in enumerate(value)\n ])\n offset += value.size\n else:\n row_data.append(\"{}:{}\".format(offset, value))\n offset += 1\n else: # sparse feature\n indices = v[0]\n value = v[1].reshape((-1))\n dense_size = np.prod(v[2])\n row_data.extend([\n \"{}:{}\".format(i + offset, item)\n for i, item in six.moves.zip(indices, value)\n ])\n offset += dense_size\n\n if has_label:\n row_data = [str(label)] + row_data\n\n f.write(\"\\t\".join(row_data) + \"\\n\")\n row_id += 1\n # batch_size == None meas use all data in generator\n if batch_size == None:\n continue\n if row_id >= batch_size:\n break\n # return rows written\n if raw_data_fid is not None:\n raw_data_fid.close()\n\n return row_id\n\n\ndef load_dmatrix(filename):\n '''\n NOTE(sneaxiy): XGBoost distributed training using rabit would\n split CSV/LIBSVM file into N pieces automatically, where N is\n the worker number. However, in our implementation, we dump\n different data file into each worker, and each worker should\n not split the dumped file again when training. Otherwise,\n some data would be lost. To prevent the automatic data sharding\n by XGBoost itself, we load the LIBSVM file using\n 'sklearn.datasets.load_svmlight_file' to be a CSR sparse matrix\n first, and then convert it to 'xgboost.DMatrix'.\n\n See https://github.com/sql-machine-learning/sqlflow/issues/2326\n in detailed.\n '''\n if xgb.rabit.get_world_size() > 1:\n # XGBoost DMatrix supports to load data from file path like\n # \"train.txt#train.txt.cache\". The actual data path is\n # \"train.txt\", while \"train.txt.cache\" is used as the\n # external memory cache. But \"train.txt#train.txt.cache\"\n # is not a valid file path, and it is not supported by\n # load_svmlight_file(s). So we remove the suffix \"#...\"\n # here before loading the data using load_svmlight_file(s).\n if '#' in filename:\n filename = filename[0:filename.index('#')]\n\n if os.path.isdir(filename):\n files = [os.path.join(filename, f) for f in os.listdir(filename)]\n assert len(files) > 0, \"No data file found in {}\".format(filename)\n\n ret = load_svmlight_files(files, zero_based=True)\n X = vstack(ret[0::2])\n y = np.concatenate(ret[1::2], axis=0)\n return xgb.DMatrix(X, y)\n else:\n ret = load_svmlight_file(filename, zero_based=True)\n return xgb.DMatrix(ret[0], ret[1])\n else:\n return xgb.DMatrix(filename)\n\n\ndef get_pai_table_slice_count(table, nworkers, batch_size):\n if batch_size is None or batch_size <= 0:\n batch_size = 4096 # default batch_size\n\n row_cnt = db.get_pai_table_row_num(table)\n\n assert row_cnt >= nworkers, \"Data number {} should not less than worker number {}\".format(\n row_cnt, nworkers)\n\n slice_num_per_worker = max(int(row_cnt / (nworkers * batch_size)), 1)\n slice_count = slice_num_per_worker * nworkers\n\n print('row_cnt = {}, slice_count = {}, nworkers = {}'.format(\n row_cnt, slice_count, nworkers))\n\n return slice_count\n\n\ndef pai_dataset(filename,\n feature_specs,\n feature_column_names,\n label_spec,\n pai_table,\n single_file,\n cache,\n rank=0,\n nworkers=1,\n batch_size=None,\n feature_column_code=\"\",\n raw_data_dir=None):\n from subprocess import Popen, PIPE\n from multiprocessing.dummy import Pool # ThreadPool\n import queue\n\n dname = filename\n if single_file:\n dname = filename + '.dir'\n\n if os.path.exists(dname):\n shutil.rmtree(dname, ignore_errors=True)\n\n os.mkdir(dname)\n\n slice_count = get_pai_table_slice_count(pai_table, nworkers, batch_size)\n\n thread_num = min(int(slice_count / nworkers), 128)\n\n pool = Pool(thread_num)\n complete_queue = queue.Queue()\n\n def thread_worker(slice_id):\n p = Popen(\"{} -m {}\".format(sys.executable, __name__),\n shell=True,\n stdin=PIPE)\n p.communicate(\n json.dumps([\n dname, feature_specs, feature_column_names, label_spec,\n pai_table, slice_id, slice_count, feature_column_code,\n raw_data_dir\n ]))\n\n assert p.returncode == 0, \"The subprocess raises error when reading data\"\n complete_queue.put(slice_id)\n\n slice_id = rank\n slice_total = 0\n while slice_id < slice_count:\n pool.apply_async(thread_worker, (slice_id, ))\n slice_id += nworkers\n slice_total += 1\n\n if batch_size is None:\n pool.close()\n pool.join()\n yield load_dmatrix('{0}#{0}.cache'.format(dname) if cache else dname)\n return\n\n for _ in six.moves.range(slice_total):\n slice_id = complete_queue.get(block=True)\n if not single_file:\n downloaded_file = \"./{}/{}.txt\".format(dname, slice_id)\n # ignore empty files or the xgb.DMatrix will throw error.\n if Path(downloaded_file).stat().st_size > 0:\n yield load_dmatrix('{0}#{0}.cache'.format(downloaded_file)\n if cache else downloaded_file)\n os.unlink(downloaded_file)\n\n if single_file:\n\n def merge_files(dir_name, file_name):\n cmd = \"cat %s/*.txt > %s\" % (dir_name, file_name)\n p = Popen(cmd, shell=True, stdin=PIPE, stderr=PIPE)\n out, err = p.communicate()\n if err:\n raise Exception(\"merge data files failed: %s\" % err)\n\n merge_files(dname, filename)\n if raw_data_dir:\n merge_files(raw_data_dir, '{}.raw'.format(filename))\n\n yield load_dmatrix(\n '{0}#{0}.cache'.format(filename) if cache else filename)\n\n pool.close()\n pool.join()\n\n\ndef pai_download_table_data_worker(dname, feature_specs, feature_column_names,\n label_spec, pai_table, slice_id,\n slice_count, feature_column_code,\n raw_data_dir):\n import sqlflow_submitter.xgboost as xgboost_extended\n feature_column_transformers = eval('[{}]'.format(feature_column_code))\n transform_fn = xgboost_extended.feature_column.ComposedColumnTransformer(\n feature_column_names, *feature_column_transformers)\n\n label_column_name = label_spec['feature_name'] if label_spec else None\n gen = db.pai_maxcompute_db_generator(pai_table,\n feature_column_names,\n label_column_name,\n feature_specs,\n slice_id=slice_id,\n slice_count=slice_count)()\n selected_cols = db.pai_selected_cols(pai_table)\n filename = \"{}/{}.txt\".format(dname, slice_id)\n dump_dmatrix(filename,\n gen,\n feature_column_names,\n feature_specs,\n label_spec,\n selected_cols,\n transform_fn=transform_fn,\n raw_data_dir=raw_data_dir)\n\n\nif __name__ == \"__main__\":\n pai_download_table_data_worker(*json.load(sys.stdin))\n",
"# Copyright 2020 The SQLFlow Authors. All rights reserved.\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# NOTE: this file is used by train_predict_test.py, do **NOT** delete!\nimport shutil\n\nimport sqlflow_submitter\nimport tensorflow as tf\nfrom sqlflow_submitter.db_test import testing_mysql_db_url\nfrom sqlflow_submitter.tensorflow.predict import pred\nfrom sqlflow_submitter.tensorflow.train import train\n\ndatasource = testing_mysql_db_url()\nselect = \"SELECT * FROM iris.train;\"\nvalidate_select = \"SELECT * FROM iris.test;\"\nselect_binary = \"SELECT * FROM iris.train WHERE class!=2;\"\nvalidate_select_binary = \"SELECT * FROM iris.test WHERE class!=2;\"\nfeature_column_names = [\n \"sepal_length\", \"sepal_width\", \"petal_length\", \"petal_width\"\n]\nfeature_column_names_map = {\n \"feature_columns\":\n [\"sepal_length\", \"sepal_width\", \"petal_length\", \"petal_width\"]\n}\n\nfeature_columns = {\n \"feature_columns\": [\n tf.feature_column.numeric_column(\"sepal_length\", shape=[1]),\n tf.feature_column.numeric_column(\"sepal_width\", shape=[1]),\n tf.feature_column.numeric_column(\"petal_length\", shape=[1]),\n tf.feature_column.numeric_column(\"petal_width\", shape=[1])\n ]\n}\n\nfeature_metas = {\n \"sepal_length\": {\n \"feature_name\": \"sepal_length\",\n \"dtype\": \"float32\",\n \"delimiter\": \"\",\n \"shape\": [1],\n \"is_sparse\": \"false\" == \"true\"\n },\n \"sepal_width\": {\n \"feature_name\": \"sepal_width\",\n \"dtype\": \"float32\",\n \"delimiter\": \"\",\n \"shape\": [1],\n \"is_sparse\": \"false\" == \"true\"\n },\n \"petal_length\": {\n \"feature_name\": \"petal_length\",\n \"dtype\": \"float32\",\n \"delimiter\": \"\",\n \"shape\": [1],\n \"is_sparse\": \"false\" == \"true\"\n },\n \"petal_width\": {\n \"feature_name\": \"petal_width\",\n \"dtype\": \"float32\",\n \"delimiter\": \"\",\n \"shape\": [1],\n \"is_sparse\": \"false\" == \"true\"\n }\n}\nlabel_meta = {\n \"feature_name\": \"class\",\n \"dtype\": \"int64\",\n \"delimiter\": \"\",\n \"shape\": [],\n \"is_sparse\": \"false\" == \"true\"\n}\n\nif __name__ == \"__main__\":\n # tf.python.training.basic_session_run_hooks.LoggingTensorHook = sqlflow_submitter.tensorflow.train.PrintTensorsHook\n train(datasource=datasource,\n estimator_string=\"tf.estimator.DNNClassifier\",\n select=select,\n validation_select=validate_select,\n feature_columns=feature_columns,\n feature_column_names=feature_column_names,\n feature_metas=feature_metas,\n label_meta=label_meta,\n model_params={\n \"n_classes\": 3,\n \"hidden_units\": [10, 20]\n },\n save=\"mymodel\",\n batch_size=1,\n epoch=3,\n verbose=0)\n train(datasource=datasource,\n estimator_string=\"tf.estimator.DNNClassifier\",\n select=select_binary,\n validation_select=validate_select_binary,\n feature_columns=feature_columns,\n feature_column_names=feature_column_names,\n feature_metas=feature_metas,\n label_meta=label_meta,\n model_params={\n \"n_classes\": 2,\n \"hidden_units\": [10, 20]\n },\n save=\"mymodel_binary\",\n batch_size=1,\n epoch=3,\n verbose=1)\n pred(datasource=datasource,\n estimator_string=\"tf.estimator.DNNClassifier\",\n select=select,\n result_table=\"iris.predict\",\n feature_columns=feature_columns,\n feature_column_names=feature_column_names,\n feature_column_names_map=feature_column_names_map,\n result_col_name=label_meta[\"feature_name\"],\n feature_metas=feature_metas,\n model_params={\n \"n_classes\": 3,\n \"hidden_units\": [10, 20]\n },\n save=\"mymodel\",\n batch_size=1)\n shutil.rmtree(\"mymodel\")\n shutil.rmtree(\"mymodel_binary\")\n"
] | [
[
"sklearn.datasets.load_svmlight_files",
"numpy.concatenate",
"numpy.prod",
"scipy.sparse.vstack",
"sklearn.datasets.load_svmlight_file"
],
[
"tensorflow.feature_column.numeric_column"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16",
"1.8"
],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
PatrickChoDev/CSA-3D | [
"34aa87194d653a93f16834d485738255f55112f0",
"34aa87194d653a93f16834d485738255f55112f0",
"34aa87194d653a93f16834d485738255f55112f0"
] | [
"det3d/ops/roipool3d/setup.py",
"det3d/solver/learning_schedules_fastai.py",
"det3d/datasets/utils/create_gt_database.py"
] | [
"from setuptools import setup\n\nfrom torch.utils.cpp_extension import BuildExtension, CUDAExtension\n\nsetup(\n name=\"roipool3d\",\n ext_modules=[\n CUDAExtension(\n \"roipool3d_cuda\",\n [\"src/roipool3d.cpp\", \"src/roipool3d_kernel.cu\",],\n extra_compile_args={\"cxx\": [\"-g\"], \"nvcc\": [\"-O2\"]},\n )\n ],\n cmdclass={\"build_ext\": BuildExtension},\n)\n",
"import math\nfrom functools import partial\n\nimport numpy as np\n\n\nclass LRSchedulerStep(object):\n def __init__(self, fai_optimizer, total_step, lr_phases, mom_phases):\n self.optimizer = fai_optimizer\n self.total_step = total_step\n self.lr_phases = []\n\n for i, (start, lambda_func) in enumerate(lr_phases):\n if len(self.lr_phases) != 0:\n assert self.lr_phases[-1][0] < int(start * total_step)\n if isinstance(lambda_func, str):\n lambda_func = eval(lambda_func)\n if i < len(lr_phases) - 1:\n self.lr_phases.append(\n (\n int(start * total_step),\n int(lr_phases[i + 1][0] * total_step),\n lambda_func,\n )\n )\n else:\n self.lr_phases.append(\n (int(start * total_step), total_step, lambda_func)\n )\n assert self.lr_phases[0][0] == 0\n self.mom_phases = []\n for i, (start, lambda_func) in enumerate(mom_phases):\n if len(self.mom_phases) != 0:\n assert self.mom_phases[-1][0] < start\n if isinstance(lambda_func, str):\n lambda_func = eval(lambda_func)\n if i < len(mom_phases) - 1:\n self.mom_phases.append(\n (\n int(start * total_step),\n int(mom_phases[i + 1][0] * total_step),\n lambda_func,\n )\n )\n else:\n self.mom_phases.append(\n (int(start * total_step), total_step, lambda_func)\n )\n # assert self.mom_phases[0][0] == 0\n if len(mom_phases) > 0:\n assert self.mom_phases[0][0] == 0\n\n def step(self, step):\n lrs, moms = [], []\n\n for start, end, func in self.lr_phases:\n if step >= start:\n # self.optimizer.lr = func((step - start) / (end - start))\n lrs.append(func((step - start) / (end - start)))\n if len(lrs) > 0:\n self.optimizer.lr = lrs[-1]\n for start, end, func in self.mom_phases:\n if step >= start:\n moms.append(func((step - start) / (end - start)))\n self.optimizer.mom = func((step - start) / (end - start))\n if len(moms) > 0:\n self.optimizer.mom = moms[-1]\n\n\ndef annealing_cos(start, end, pct):\n # print(pct, start, end)\n \"Cosine anneal from `start` to `end` as pct goes from 0.0 to 1.0.\"\n cos_out = np.cos(np.pi * pct) + 1\n return end + (start - end) / 2 * cos_out\n\n\nclass OneCycle(LRSchedulerStep):\n def __init__(self, fai_optimizer, total_step, lr_max, moms, div_factor, pct_start):\n self.lr_max = lr_max\n self.moms = moms\n self.div_factor = div_factor\n self.pct_start = pct_start\n a1 = int(total_step * self.pct_start)\n a2 = total_step - a1\n low_lr = self.lr_max / self.div_factor\n lr_phases = (\n (0, partial(annealing_cos, low_lr, self.lr_max)),\n (self.pct_start, partial(annealing_cos, self.lr_max, low_lr / 1e4)),\n )\n mom_phases = (\n (0, partial(annealing_cos, *self.moms)),\n (self.pct_start, partial(annealing_cos, *self.moms[::-1])),\n )\n fai_optimizer.lr, fai_optimizer.mom = low_lr, self.moms[0]\n super().__init__(fai_optimizer, total_step, lr_phases, mom_phases)\n\n\nclass ExponentialDecay(LRSchedulerStep):\n def __init__(\n self,\n fai_optimizer,\n total_step,\n initial_learning_rate,\n decay_length,\n decay_factor,\n staircase=True,\n ):\n \"\"\"\n Args:\n decay_length: must in (0, 1)\n \"\"\"\n assert decay_length > 0\n assert decay_length < 1\n self._decay_steps_unified = decay_length\n self._decay_factor = decay_factor\n self._staircase = staircase\n step = 0\n stage = 1\n lr_phases = []\n if staircase:\n while step <= total_step:\n func = lambda p, _d=initial_learning_rate * stage: _d\n lr_phases.append((step / total_step, func))\n stage *= decay_factor\n step += int(decay_length * total_step)\n else:\n func = lambda p: pow(decay_factor, (p / decay_length))\n lr_phases.append((0, func))\n super().__init__(fai_optimizer, total_step, lr_phases, [])\n\n\nclass ManualStepping(LRSchedulerStep):\n def __init__(self, fai_optimizer, total_step, boundaries, rates):\n assert all([b > 0 and b < 1 for b in boundaries])\n assert len(boundaries) + 1 == len(rates)\n boundaries.insert(0, 0.0)\n lr_phases = []\n for start, rate in zip(boundaries, rates):\n func = lambda p, _d=rate: _d\n lr_phases.append((start, func))\n super().__init__(fai_optimizer, total_step, lr_phases, [])\n\n\nclass FakeOptim:\n def __init__(self):\n self.lr = 0\n self.mom = 0\n\n\nif __name__ == \"__main__\":\n import matplotlib.pyplot as plt\n\n opt = FakeOptim() # 3e-3, wd=0.4, div_factor=10\n # schd = OneCycle(opt, 100, 3e-3, (0.95, 0.85), 10.0, 0.1)\n schd = ExponentialDecay(opt, 100, 3e-4, 0.1, 0.8, staircase=True)\n schd = ManualStepping(opt, 100, [0.8, 0.9], [0.001, 0.0001, 0.00005])\n\n lrs = []\n moms = []\n for i in range(100):\n schd.step(i)\n lrs.append(opt.lr)\n moms.append(opt.mom)\n plt.plot(lrs)\n # plt.plot(moms)\n # plt.show()\n # plt.plot(moms)\n plt.show()\n",
"import pickle\nfrom pathlib import Path\n\nimport numpy as np\n\nfrom det3d.core import box_np_ops\nfrom det3d.datasets.dataset_factory import get_dataset\n\nfrom tqdm import tqdm\n\ndataset_name_map = {\n \"KITTI\": \"KittiDataset\",\n \"NUSC\": \"NuScenesDataset\",\n \"LYFT\": \"LyftDataset\",\n}\n\n\ndef create_groundtruth_database(\n dataset_class_name,\n data_path,\n info_path=None,\n used_classes=None,\n db_path=None,\n dbinfo_path=None,\n relative_path=True,\n add_rgb=False,\n lidar_only=False,\n bev_only=False,\n coors_range=None,\n **kwargs,\n):\n pipeline = [\n {\n \"type\": \"LoadPointCloudFromFile\",\n \"dataset\": dataset_name_map[dataset_class_name],\n },\n {\"type\": \"LoadPointCloudAnnotations\", \"with_bbox\": True},\n ]\n\n if \"nsweeps\" in kwargs:\n dataset = get_dataset(dataset_class_name)(\n info_path=info_path,\n root_path=data_path,\n pipeline=pipeline,\n test_mode=True,\n nsweeps=kwargs[\"nsweeps\"],\n )\n nsweeps = dataset.nsweeps\n else:\n dataset = get_dataset(dataset_class_name)(\n info_path=info_path, root_path=data_path, test_mode=True, pipeline=pipeline\n )\n nsweeps = 1\n\n root_path = Path(data_path)\n\n if dataset_class_name == \"NUSC\":\n if db_path is None:\n db_path = root_path / f\"gt_database_{nsweeps}sweeps_withvelo\"\n if dbinfo_path is None:\n dbinfo_path = root_path / f\"dbinfos_train_{nsweeps}sweeps_withvelo.pkl\"\n else:\n if db_path is None:\n db_path = root_path / \"gt_database\"\n if dbinfo_path is None:\n dbinfo_path = root_path / \"dbinfos_train.pkl\"\n if dataset_class_name == \"NUSC\" or dataset_class_name == \"LYFT\":\n point_features = 5\n elif dataset_class_name == \"KITTI\":\n point_features = 4\n\n db_path.mkdir(parents=True, exist_ok=True)\n\n all_db_infos = {}\n group_counter = 0\n\n # def prepare_single_data(index):\n for index in tqdm(range(len(dataset))):\n image_idx = index\n # modified to nuscenes\n sensor_data = dataset.get_sensor_data(index)\n # for nsweep, sensor_data in enumerate(sensor_datas):\n if \"image_idx\" in sensor_data[\"metadata\"]:\n image_idx = sensor_data[\"metadata\"][\"image_idx\"]\n\n if dataset_class_name == \"NUSC\":\n points = sensor_data[\"lidar\"][\"combined\"]\n elif dataset_class_name == \"KITTI\":\n points = sensor_data[\"lidar\"][\"points\"]\n elif dataset_class_name == \"LYFT\":\n points = sensor_data[\"lidar\"][\"points\"]\n\n annos = sensor_data[\"lidar\"][\"annotations\"]\n gt_boxes = annos[\"boxes\"]\n names = annos[\"names\"]\n group_dict = {}\n group_ids = np.full([gt_boxes.shape[0]], -1, dtype=np.int64)\n if \"group_ids\" in annos:\n group_ids = annos[\"group_ids\"]\n else:\n group_ids = np.arange(gt_boxes.shape[0], dtype=np.int64)\n difficulty = np.zeros(gt_boxes.shape[0], dtype=np.int32)\n if \"difficulty\" in annos:\n difficulty = annos[\"difficulty\"]\n\n num_obj = gt_boxes.shape[0]\n point_indices = box_np_ops.points_in_rbbox(points, gt_boxes)\n for i in range(num_obj):\n filename = f\"{image_idx}_{names[i]}_{i}.bin\"\n filepath = db_path / filename\n gt_points = points[point_indices[:, i]]\n gt_points[:, :3] -= gt_boxes[i, :3]\n with open(filepath, \"w\") as f:\n gt_points[:, :point_features].tofile(f)\n\n if (used_classes is None) or names[i] in used_classes:\n if relative_path:\n db_dump_path = str(db_path.stem + \"/\" + filename)\n else:\n db_dump_path = str(filepath)\n\n db_info = {\n \"name\": names[i],\n \"path\": db_dump_path,\n \"image_idx\": image_idx,\n \"gt_idx\": i,\n \"box3d_lidar\": gt_boxes[i],\n \"num_points_in_gt\": gt_points.shape[0],\n \"difficulty\": difficulty[i],\n # \"group_id\": -1,\n # \"bbox\": bboxes[i],\n }\n local_group_id = group_ids[i]\n # if local_group_id >= 0:\n if local_group_id not in group_dict:\n group_dict[local_group_id] = group_counter\n group_counter += 1\n db_info[\"group_id\"] = group_dict[local_group_id]\n if \"score\" in annos:\n db_info[\"score\"] = annos[\"score\"][i]\n if names[i] in all_db_infos:\n all_db_infos[names[i]].append(db_info)\n else:\n all_db_infos[names[i]] = [db_info]\n # print(f\"Finish {index}th sample\")\n\n print(\"dataset length: \", len(dataset))\n for k, v in all_db_infos.items():\n print(f\"load {len(v)} {k} database infos\")\n\n with open(dbinfo_path, \"wb\") as f:\n pickle.dump(all_db_infos, f)\n"
] | [
[
"torch.utils.cpp_extension.CUDAExtension"
],
[
"matplotlib.pyplot.plot",
"matplotlib.pyplot.show",
"numpy.cos"
],
[
"numpy.arange",
"numpy.zeros",
"numpy.full"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
PierreExeter/rl_reach | [
"4f9c46c8503a84edaa48f9dfd58054548552253a",
"4f9c46c8503a84edaa48f9dfd58054548552253a"
] | [
"code/tests/manual/7_test_jaco_env_with_log_plot.py",
"code/scripts/plot_experiment.py"
] | [
"\"\"\" Test env with random actions \"\"\"\n\nimport time\nimport gym\nimport gym_envs\nimport subprocess\nfrom collections import OrderedDict\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n\nenv = gym.make('ReachingJaco-v7')\nplot_filename = \"plot_ReachingJaco-v7_rand.png\"\n\nenv.render()\nenv.reset()\n\nlog_df = pd.DataFrame()\nlog_dict = OrderedDict()\nEPISODE_RETURN = 0\n\nfor t in range(100):\n action = env.action_space.sample()\n # action = [0, 0, -2, 0, 0, 0]\n obs, reward, done, info = env.step(action)\n EPISODE_RETURN += reward\n\n print(\"action: \", action)\n print(\"obs: \", obs)\n print(\"reward: \", reward)\n print(\"done: \", done)\n print(\"info: \", info)\n print(\"timestep: \", t)\n\n\n log_dict['episode'] = 1\n log_dict['timestep'] = t\n log_dict['action1'] = info['action'][0]\n log_dict['action2'] = info['action'][1]\n log_dict['action3'] = info['action'][2]\n log_dict['action4'] = info['action'][3]\n log_dict['action5'] = info['action'][4]\n log_dict['action6'] = info['action'][5]\n log_dict['action1_min'] = info['action_min'][0]\n log_dict['action2_min'] = info['action_min'][1]\n log_dict['action3_min'] = info['action_min'][2]\n log_dict['action4_min'] = info['action_min'][3]\n log_dict['action5_min'] = info['action_min'][4]\n log_dict['action6_min'] = info['action_min'][5]\n log_dict['action1_max'] = info['action_max'][0]\n log_dict['action2_max'] = info['action_max'][1]\n log_dict['action3_max'] = info['action_max'][2]\n log_dict['action4_max'] = info['action_max'][3]\n log_dict['action5_max'] = info['action_max'][4]\n log_dict['action6_max'] = info['action_max'][5]\n log_dict['pyb_action1'] = info['pybullet_action'][0]\n log_dict['pyb_action2'] = info['pybullet_action'][1]\n log_dict['pyb_action3'] = info['pybullet_action'][2]\n log_dict['pyb_action4'] = info['pybullet_action'][3]\n log_dict['pyb_action5'] = info['pybullet_action'][4]\n log_dict['pyb_action6'] = info['pybullet_action'][5]\n log_dict['pyb_action1_min'] = info['pybullet_action_min'][0]\n log_dict['pyb_action2_min'] = info['pybullet_action_min'][1]\n log_dict['pyb_action3_min'] = info['pybullet_action_min'][2]\n log_dict['pyb_action4_min'] = info['pybullet_action_min'][3]\n log_dict['pyb_action5_min'] = info['pybullet_action_min'][4]\n log_dict['pyb_action6_min'] = info['pybullet_action_min'][5]\n log_dict['pyb_action1_max'] = info['pybullet_action_max'][0]\n log_dict['pyb_action2_max'] = info['pybullet_action_max'][1]\n log_dict['pyb_action3_max'] = info['pybullet_action_max'][2]\n log_dict['pyb_action4_max'] = info['pybullet_action_max'][3]\n log_dict['pyb_action5_max'] = info['pybullet_action_max'][4]\n log_dict['pyb_action6_max'] = info['pybullet_action_max'][5]\n log_dict['joint1_pos'] = info['joint_pos'][0]\n log_dict['joint2_pos'] = info['joint_pos'][1]\n log_dict['joint3_pos'] = info['joint_pos'][2]\n log_dict['joint4_pos'] = info['joint_pos'][3]\n log_dict['joint5_pos'] = info['joint_pos'][4]\n log_dict['joint6_pos'] = info['joint_pos'][5]\n log_dict['desired_joint1_pos'] = info['desired_joint_pos'][0]\n log_dict['desired_joint2_pos'] = info['desired_joint_pos'][1]\n log_dict['desired_joint3_pos'] = info['desired_joint_pos'][2]\n log_dict['desired_joint4_pos'] = info['desired_joint_pos'][3]\n log_dict['desired_joint5_pos'] = info['desired_joint_pos'][4]\n log_dict['desired_joint6_pos'] = info['desired_joint_pos'][5]\n log_dict['joint1_vel'] = info['joint_vel'][0]\n log_dict['joint2_vel'] = info['joint_vel'][1]\n log_dict['joint3_vel'] = info['joint_vel'][2]\n log_dict['joint4_vel'] = info['joint_vel'][3]\n log_dict['joint5_vel'] = info['joint_vel'][4]\n log_dict['joint6_vel'] = info['joint_vel'][5]\n log_dict['joint1_tor'] = info['joint_tor'][0]\n log_dict['joint2_tor'] = info['joint_tor'][1]\n log_dict['joint3_tor'] = info['joint_tor'][2]\n log_dict['joint4_tor'] = info['joint_tor'][3]\n log_dict['joint5_tor'] = info['joint_tor'][4]\n log_dict['joint6_tor'] = info['joint_tor'][5]\n log_dict['joint1_min'] = info['joint_min'][0]\n log_dict['joint2_min'] = info['joint_min'][1]\n log_dict['joint3_min'] = info['joint_min'][2]\n log_dict['joint4_min'] = info['joint_min'][3]\n log_dict['joint5_min'] = info['joint_min'][4]\n log_dict['joint6_min'] = info['joint_min'][5]\n log_dict['joint1_max'] = info['joint_max'][0]\n log_dict['joint2_max'] = info['joint_max'][1]\n log_dict['joint3_max'] = info['joint_max'][2]\n log_dict['joint4_max'] = info['joint_max'][3]\n log_dict['joint5_max'] = info['joint_max'][4]\n log_dict['joint6_max'] = info['joint_max'][5]\n log_dict['reward'] = reward\n log_dict['return'] = EPISODE_RETURN\n log_dict['distance'] = info['distance']\n log_dict['orientation'] = info['orientation']\n log_dict['goal_x'] = info['goal_pos'][0]\n log_dict['goal_y'] = info['goal_pos'][1]\n log_dict['goal_z'] = info['goal_pos'][2]\n log_dict['tip_x'] = info['endeffector_pos'][0]\n log_dict['tip_y'] = info['endeffector_pos'][1]\n log_dict['tip_z'] = info['endeffector_pos'][2]\n log_dict['goal_yaw'] = info['goal_orient'][0]\n log_dict['goal_pitch'] = info['goal_orient'][1]\n log_dict['goal_roll'] = info['goal_orient'][2]\n log_dict['tip_yaw'] = info['endeffector_orient'][0]\n log_dict['tip_pitch'] = info['endeffector_orient'][1]\n log_dict['tip_roll'] = info['endeffector_orient'][2]\n log_dict['done'] = done\n log_dict['term1'] = info['term1']\n log_dict['term2'] = info['term2']\n log_dict['vel_dist'] = info['vel_dist']\n log_dict['vel_pos'] = info['vel_pos']\n log_dict['collision'] = info['collision']\n\n # log_dict['obs'] = obs\n # log_dict['obs_space_low'] = env.observation_space.low\n # log_dict['obs_space_high'] = env.observation_space.high\n\n log_df = log_df.append(log_dict, ignore_index=True)\n\n\n\n# sort columns\nlog_df = log_df[log_dict.keys()]\n\n# add estimated tip velocity and acceleration\n# (according to the Pybullet documentation, 1 timestep = 240 Hz)\nlog_df['acc_dist'] = log_df['vel_dist'].diff() * 240\nlog_df['acc_pos'] = log_df['vel_pos'].diff() * 240\n# initial acceleration is 0\nlog_df['acc_dist'].loc[0] = (log_df['vel_dist'].loc[0] - 0 ) * 240\nlog_df['acc_pos'].loc[0] = (log_df['vel_pos'].loc[0] - 0 ) * 240\n\n# Write to file\nlog_df.to_csv(\"res_episode.csv\", index=False) # slow\n\n# # read data\n# log_df = pd.read_csv(FILE_PATH)\n\n# plot\nfig, axs = plt.subplots(5, 6, figsize=(25, 10), dpi=300, sharex=True)\n\nlog_df.plot(x='timestep', y='joint1_pos', ax=axs[0, 0], style=\"gx\")\nlog_df.plot(x='timestep', y='desired_joint1_pos', ax=axs[0, 0], style=\"b+\")\nlog_df.plot(x='timestep', y='joint1_min', ax=axs[0, 0], style=\"r--\")\nlog_df.plot(x='timestep', y='joint1_max', ax=axs[0, 0], style=\"r--\")\n\nlog_df.plot(x='timestep', y='joint2_pos', ax=axs[0, 1], style=\"gx\")\nlog_df.plot(x='timestep', y='desired_joint2_pos', ax=axs[0, 1], style=\"b+\")\nlog_df.plot(x='timestep', y='joint2_min', ax=axs[0, 1], style=\"r--\")\nlog_df.plot(x='timestep', y='joint2_max', ax=axs[0, 1], style=\"r--\")\n\nlog_df.plot(x='timestep', y='joint3_pos', ax=axs[0, 2], style=\"gx\")\nlog_df.plot(x='timestep', y='desired_joint3_pos', ax=axs[0, 2], style=\"b+\")\nlog_df.plot(x='timestep', y='joint3_min', ax=axs[0, 2], style=\"r--\")\nlog_df.plot(x='timestep', y='joint3_max', ax=axs[0, 2], style=\"r--\")\n\nlog_df.plot(x='timestep', y='joint4_pos', ax=axs[0, 3], style=\"gx\")\nlog_df.plot(x='timestep', y='desired_joint4_pos', ax=axs[0, 3], style=\"b+\")\nlog_df.plot(x='timestep', y='joint4_min', ax=axs[0, 3], style=\"r--\")\nlog_df.plot(x='timestep', y='joint4_max', ax=axs[0, 3], style=\"r--\")\n\nlog_df.plot(x='timestep', y='joint5_pos', ax=axs[0, 4], style=\"gx\")\nlog_df.plot(x='timestep', y='desired_joint5_pos', ax=axs[0, 4], style=\"b+\")\nlog_df.plot(x='timestep', y='joint5_min', ax=axs[0, 4], style=\"r--\")\nlog_df.plot(x='timestep', y='joint5_max', ax=axs[0, 4], style=\"r--\")\n\nlog_df.plot(x='timestep', y='joint6_pos', ax=axs[0, 5], style=\"gx\")\nlog_df.plot(x='timestep', y='desired_joint6_pos', ax=axs[0, 5], style=\"b+\")\nlog_df.plot(x='timestep', y='joint6_min', ax=axs[0, 5], style=\"r--\")\nlog_df.plot(x='timestep', y='joint6_max', ax=axs[0, 5], style=\"r--\")\n\n##################################################################\n\nlog_df.plot(x='timestep', y='joint1_vel', ax=axs[1, 0], color=\"b\")\nax_joint1 = axs[1, 0].twinx()\nlog_df.plot(x='timestep', y='joint1_tor', ax=ax_joint1, color=\"g\")\n\nlog_df.plot(x='timestep', y='joint2_vel', ax=axs[1, 1], color=\"b\")\nax_joint2 = axs[1, 1].twinx()\nlog_df.plot(x='timestep', y='joint2_tor', ax=ax_joint2, color=\"g\")\n\nlog_df.plot(x='timestep', y='joint3_vel', ax=axs[1, 2], color=\"b\")\nax_joint3 = axs[1, 2].twinx()\nlog_df.plot(x='timestep', y='joint3_tor', ax=ax_joint3, color=\"g\")\n\nlog_df.plot(x='timestep', y='joint4_vel', ax=axs[1, 3], color=\"b\")\nax_joint4 = axs[1, 3].twinx()\nlog_df.plot(x='timestep', y='joint4_tor', ax=ax_joint4, color=\"g\")\n\nlog_df.plot(x='timestep', y='joint5_vel', ax=axs[1, 4], color=\"b\")\nax_joint5 = axs[1, 4].twinx()\nlog_df.plot(x='timestep', y='joint5_tor', ax=ax_joint5, color=\"g\")\n\nlog_df.plot(x='timestep', y='joint6_vel', ax=axs[1, 5], color=\"b\")\nax_joint6 = axs[1, 5].twinx()\nlog_df.plot(x='timestep', y='joint6_tor', ax=ax_joint6, color=\"g\")\n\n##################################################################\n\nlog_df.plot(x='timestep', y='action1', ax=axs[2, 0])\nlog_df.plot(x='timestep', y='action1_min', ax=axs[2, 0], style=\"r--\")\nlog_df.plot(x='timestep', y='action1_max', ax=axs[2, 0], style=\"r--\")\n\nlog_df.plot(x='timestep', y='action2', ax=axs[2, 1])\nlog_df.plot(x='timestep', y='action2_min', ax=axs[2, 1], style=\"r--\")\nlog_df.plot(x='timestep', y='action2_max', ax=axs[2, 1], style=\"r--\")\n\nlog_df.plot(x='timestep', y='action3', ax=axs[2, 2])\nlog_df.plot(x='timestep', y='action3_min', ax=axs[2, 2], style=\"r--\")\nlog_df.plot(x='timestep', y='action3_max', ax=axs[2, 2], style=\"r--\")\n\nlog_df.plot(x='timestep', y='action4', ax=axs[2, 3])\nlog_df.plot(x='timestep', y='action4_min', ax=axs[2, 3], style=\"r--\")\nlog_df.plot(x='timestep', y='action4_max', ax=axs[2, 3], style=\"r--\")\n\nlog_df.plot(x='timestep', y='action5', ax=axs[2, 4])\nlog_df.plot(x='timestep', y='action5_min', ax=axs[2, 4], style=\"r--\")\nlog_df.plot(x='timestep', y='action5_max', ax=axs[2, 4], style=\"r--\")\n\nlog_df.plot(x='timestep', y='action6', ax=axs[2, 5])\nlog_df.plot(x='timestep', y='action6_min', ax=axs[2, 5], style=\"r--\")\nlog_df.plot(x='timestep', y='action6_max', ax=axs[2, 5], style=\"r--\")\n\n##################################################################\n\nlog_df.plot(x='timestep', y='pyb_action1', ax=axs[3, 0])\nlog_df.plot(x='timestep', y='pyb_action1_min', ax=axs[3, 0], style=\"r--\")\nlog_df.plot(x='timestep', y='pyb_action1_max', ax=axs[3, 0], style=\"r--\")\n\nlog_df.plot(x='timestep', y='pyb_action2', ax=axs[3, 1])\nlog_df.plot(x='timestep', y='pyb_action2_min', ax=axs[3, 1], style=\"r--\")\nlog_df.plot(x='timestep', y='pyb_action2_max', ax=axs[3, 1], style=\"r--\")\n\nlog_df.plot(x='timestep', y='pyb_action3', ax=axs[3, 2])\nlog_df.plot(x='timestep', y='pyb_action3_min', ax=axs[3, 2], style=\"r--\")\nlog_df.plot(x='timestep', y='pyb_action3_max', ax=axs[3, 2], style=\"r--\")\n\nlog_df.plot(x='timestep', y='pyb_action4', ax=axs[3, 3])\nlog_df.plot(x='timestep', y='pyb_action4_min', ax=axs[3, 3], style=\"r--\")\nlog_df.plot(x='timestep', y='pyb_action4_max', ax=axs[3, 3], style=\"r--\")\n\nlog_df.plot(x='timestep', y='pyb_action5', ax=axs[3, 4])\nlog_df.plot(x='timestep', y='pyb_action5_min', ax=axs[3, 4], style=\"r--\")\nlog_df.plot(x='timestep', y='pyb_action5_max', ax=axs[3, 4], style=\"r--\")\n\nlog_df.plot(x='timestep', y='pyb_action6', ax=axs[3, 5])\nlog_df.plot(x='timestep', y='pyb_action6_min', ax=axs[3, 5], style=\"r--\")\nlog_df.plot(x='timestep', y='pyb_action6_max', ax=axs[3, 5], style=\"r--\")\n\n##################################################################\n\nlog_df.plot(x='timestep', y='reward', ax=axs[4, 0], color=\"b\", marker=\"x\")\nlog_df.plot(x='timestep', y='term1', ax=axs[4, 0], color=\"r\")\nlog_df.plot(x='timestep', y='term2', ax=axs[4, 0], color=\"g\")\n\nlog_df.plot(x='timestep', y='return', ax=axs[4, 1], color=\"m\", marker=\"x\")\n\nlog_df.plot(x='timestep', y='distance', ax=axs[4, 2], color=\"b\")\nax_1 = axs[4, 2].twinx()\nlog_df.plot(x='timestep', y='orientation', ax=ax_1, color=\"r\")\n\nlog_df.plot(x='timestep', y='vel_dist', ax=axs[4, 3], color=\"g\")\nlog_df.plot(x='timestep', y='vel_pos', ax=axs[4, 3], color=\"g\", marker=\"+\")\nax_2 = axs[4, 3].twinx()\nlog_df.plot(x='timestep', y='acc_dist', ax=ax_2, color=\"r\")\nlog_df.plot(x='timestep', y='acc_pos', ax=ax_2, color=\"r\", marker=\"+\")\n\nlog_df.plot(x='timestep', y='goal_x', ax=axs[4, 4], style='r')\nlog_df.plot(x='timestep', y='goal_y', ax=axs[4, 4], style='b')\nlog_df.plot(x='timestep', y='goal_z', ax=axs[4, 4], style='g')\nlog_df.plot(x='timestep', y='tip_x', ax=axs[4, 4], style='xr')\nlog_df.plot(x='timestep', y='tip_y', ax=axs[4, 4], style='xb')\nlog_df.plot(x='timestep', y='tip_z', ax=axs[4, 4], style='xg')\n\nlog_df.plot(x='timestep', y='goal_yaw', ax=axs[4, 5], style='r')\nlog_df.plot(x='timestep', y='goal_pitch', ax=axs[4, 5], style='b')\nlog_df.plot(x='timestep', y='goal_roll', ax=axs[4, 5], style='g')\nlog_df.plot(x='timestep', y='tip_yaw', ax=axs[4, 5], style='xr')\nlog_df.plot(x='timestep', y='tip_pitch', ax=axs[4, 5], style='xb')\nlog_df.plot(x='timestep', y='tip_roll', ax=axs[4, 5], style='xg')\n\n##################################################################\n\naxs[0, 0].set_ylabel(\"joint1 pos (rad)\")\naxs[0, 1].set_ylabel(\"joint2 pos (rad)\")\naxs[0, 2].set_ylabel(\"joint3 pos (rad)\")\naxs[0, 3].set_ylabel(\"joint4 pos (rad)\")\naxs[0, 4].set_ylabel(\"joint5 pos (rad)\")\naxs[0, 5].set_ylabel(\"joint6 pos (rad)\")\n\n##################################################################\n\naxs[1, 0].set_ylabel(\"Velocity (rad/s)\", color=\"b\")\nax_joint1.set_ylabel(\"Torque (Nm)\", color=\"g\")\naxs[1, 0].tick_params(axis='y', labelcolor=\"b\")\nax_joint1.tick_params(axis='y', labelcolor=\"g\")\nax_joint1.legend(loc=\"upper right\")\naxs[1, 0].legend(loc=\"upper left\")\n\naxs[1, 1].set_ylabel(\"Velocity (rad/s)\", color=\"b\")\nax_joint1.set_ylabel(\"Torque (Nm)\", color=\"g\")\naxs[1, 1].tick_params(axis='y', labelcolor=\"b\")\nax_joint1.tick_params(axis='y', labelcolor=\"g\")\nax_joint1.legend(loc=\"upper right\")\naxs[1, 1].legend(loc=\"upper left\")\n\naxs[1, 2].set_ylabel(\"Velocity (rad/s)\", color=\"b\")\nax_joint1.set_ylabel(\"Torque (Nm)\", color=\"g\")\naxs[1, 2].tick_params(axis='y', labelcolor=\"b\")\nax_joint1.tick_params(axis='y', labelcolor=\"g\")\nax_joint1.legend(loc=\"upper right\")\naxs[1, 2].legend(loc=\"upper left\")\n\naxs[1, 3].set_ylabel(\"Velocity (rad/s)\", color=\"b\")\nax_joint1.set_ylabel(\"Torque (Nm)\", color=\"g\")\naxs[1, 3].tick_params(axis='y', labelcolor=\"b\")\nax_joint1.tick_params(axis='y', labelcolor=\"g\")\nax_joint1.legend(loc=\"upper right\")\naxs[1, 3].legend(loc=\"upper left\")\n\naxs[1, 4].set_ylabel(\"Velocity (rad/s)\", color=\"b\")\nax_joint1.set_ylabel(\"Torque (Nm)\", color=\"g\")\naxs[1, 4].tick_params(axis='y', labelcolor=\"b\")\nax_joint1.tick_params(axis='y', labelcolor=\"g\")\nax_joint1.legend(loc=\"upper right\")\naxs[1, 4].legend(loc=\"upper left\")\n\naxs[1, 5].set_ylabel(\"Velocity (rad/s)\", color=\"b\")\nax_joint1.set_ylabel(\"Torque (Nm)\", color=\"g\")\naxs[1, 5].tick_params(axis='y', labelcolor=\"b\")\nax_joint1.tick_params(axis='y', labelcolor=\"g\")\nax_joint1.legend(loc=\"upper right\")\naxs[1, 5].legend(loc=\"upper left\")\n\n##################################################################\n\naxs[2, 0].set_ylabel(\"Action 1\")\naxs[2, 1].set_ylabel(\"Action 2\")\naxs[2, 2].set_ylabel(\"Action 3\")\naxs[2, 3].set_ylabel(\"Action 4\")\naxs[2, 4].set_ylabel(\"Action 5\")\naxs[2, 5].set_ylabel(\"Action 6\")\n\n##################################################################\n\naxs[3, 0].set_ylabel(\"Pybullet action1\")\naxs[3, 1].set_ylabel(\"Pybullet action2\")\naxs[3, 2].set_ylabel(\"Pybullet action3\")\naxs[3, 3].set_ylabel(\"Pybullet action4\")\naxs[3, 4].set_ylabel(\"Pybullet action5\")\naxs[3, 5].set_ylabel(\"Pybullet action6\")\n\n##################################################################\n\naxs[4, 0].set_ylabel(\"Reward\")\n\naxs[4, 1].set_ylabel(\"Return\")\n\naxs[4, 2].set_ylabel(\"Distance (m)\", color=\"b\")\nax_1.set_ylabel(\"Orientation\", color=\"r\")\naxs[4, 2].tick_params(axis='y', labelcolor=\"b\")\nax_1.tick_params(axis='y', labelcolor=\"r\")\nax_1.legend(loc=\"upper right\")\naxs[4, 2].legend(loc=\"upper left\")\n\naxs[4, 3].set_ylabel(\"Velocity (m/s)\", color=\"g\")\nax_2.set_ylabel(\"Acceleration (m/s^2)\", color=\"r\")\naxs[4, 3].tick_params(axis='y', labelcolor=\"g\")\nax_2.tick_params(axis='y', labelcolor=\"r\")\nax_2.legend(loc=\"upper right\")\naxs[4, 3].legend(loc=\"upper left\")\n\naxs[4, 4].set_ylabel(\"Coordinates (m)\")\naxs[4, 4].legend(loc=\"upper right\")\n\naxs[4, 5].set_ylabel(\"Orientation (rad)\")\naxs[4, 5].legend(loc=\"upper right\")\n\n# ax3.legend(bbox_to_anchor=(1, 1.05))\n# ax4.legend(bbox_to_anchor=(1.2, 1.05))\n\n##################################################################\n\nplt.tight_layout()\n# plt.show()\nplt.savefig(plot_filename, bbox_inches='tight')\n",
"\"\"\"\nLog all metrics and environment variables in benchmark/benchmark_results.csv\nPlot learning curves of all the seed runs in the experiment\n\"\"\"\n\nimport sys\nimport argparse\nimport os\nfrom pathlib import Path\nimport pandas as pd\nimport yaml\nimport matplotlib.pyplot as plt\nfrom stable_baselines3.common.results_plotter import load_results\n\n\nif __name__ == '__main__':\n\n parser = argparse.ArgumentParser()\n parser.add_argument('-f', '--log-folder', help='Log folder', type=str)\n parser.add_argument('-e', '--env', help='env name', type=str)\n parser.add_argument('-a', '--algo', help='RL Algorithm', type=str)\n parser.add_argument('-ns', '--nb-seeds', help='number of seeds', type=int)\n parser.add_argument(\n '-n',\n '--n-eval-steps',\n help=\"Number of evaluation timesteps\",\n type=int)\n parser.add_argument(\n '-d',\n '--deterministic-flag',\n help='0: Stochastic evaluation, 1: deterministic evaluation',\n type=int)\n parser.add_argument('--exp-id', help='Experiment ID', type=int)\n args = parser.parse_args()\n\n log_dir = args.log_folder + \"/\" + args.algo + \"/\"\n # print(log_dir)\n\n ###############\n # 1. SAVE ENVS VARIABLES, TRAINING HYPERPARAMETERS AND EVALUATION METRICS TO BENCHMARK FILE\n ###############\n\n # 1.1. Create dict of useful environment variables\n\n try:\n df_envs = pd.read_csv(\"gym_envs/gym_envs/envs_list.csv\")\n # print(df_envs)\n df_env = df_envs[df_envs[\"env_id\"] == args.env]\n env_dict = df_env.to_dict('records')[0]\n # print(env_dict)\n except BaseException:\n print((\"The environment specified is missing! \"\n \"Please update gym_envs/gym_envs/envs_list.csv. Exiting...\"))\n sys.exit(0)\n\n env_dict['exp_id'] = args.exp_id\n env_dict['algo'] = args.algo\n env_dict['nb_seeds'] = args.nb_seeds\n env_dict['nb_eval_timesteps'] = args.n_eval_steps\n env_dict['deterministic'] = args.deterministic_flag\n\n # 1.2. Create hyperparams dict\n\n # Load hyperparameters from config.yml\n config_path = list(Path(log_dir).rglob('config.yml'))[0]\n\n with open(config_path, 'r') as f:\n hyperparams_ordered = yaml.load(f, Loader=yaml.UnsafeLoader)\n hyperparams_dict = dict(hyperparams_ordered)\n\n # Load extra training arguments from args.yml\n args_path = list(Path(log_dir).rglob('args.yml'))[0]\n\n with open(args_path, 'r') as f:\n args_ordered = yaml.load(f, Loader=yaml.UnsafeLoader)\n args_dict = dict(args_ordered)\n\n # append useful entries to hyperparams_dict\n hyperparams_dict['nb_eval_ep_during_training'] = args_dict['eval_episodes']\n hyperparams_dict['eval_freq_during_training'] = args_dict['eval_freq']\n hyperparams_dict['vec_env'] = args_dict['vec_env']\n # overwrite n_timesteps from hyperparams.yml\n hyperparams_dict['n_timesteps'] = args_dict['n_timesteps']\n hyperparams_dict['num_threads'] = args_dict['num_threads']\n\n # print(hyperparams_dict)\n\n # 1.3. create metric dict\n\n res_file_list = []\n\n for path in Path(log_dir).rglob('stats.csv'):\n # print(path)\n res_file_list.append(path)\n\n res_file_list = sorted(res_file_list)\n # print(res_file_list)\n\n li = []\n COUNT = 0\n\n for filename in res_file_list:\n df = pd.read_csv(filename, index_col=None, header=0)\n df['seed'] = COUNT\n df['log_dir'] = filename\n li.append(df)\n COUNT += 1\n\n # print(li)\n\n df = pd.concat(li, axis=0, ignore_index=True)\n # print(df)\n\n metrics_dict = {\n 'mean_train_time(s)': df['Train walltime (s)'].mean(),\n 'std_train_time(s)': df['Train walltime (s)'].std(),\n 'min_train_time(s)': df['Train walltime (s)'].min(),\n 'simulated_time(s)': hyperparams_dict['n_timesteps'] / 240,\n 'mean_return': df['Eval mean reward'].mean(),\n 'std_return': df['Eval mean reward'].std(),\n 'max_return': df['Eval mean reward'].max(),\n 'mean_SR_pos_50': df['SR pos 50mm'].mean(),\n 'std_SR_pos_50': df['SR pos 50mm'].std(),\n 'max_SR_pos_50': df['SR pos 50mm'].max(),\n 'mean_RT_pos_50': df['RT pos 50mm'].mean(),\n 'std_RT_pos_50': df['RT pos 50mm'].std(),\n 'max_RT_pos_50': df['RT pos 50mm'].max(),\n 'mean_SR_pos_20': df['SR pos 20mm'].mean(),\n 'std_SR_pos_20': df['SR pos 20mm'].std(),\n 'max_SR_pos_20': df['SR pos 20mm'].max(),\n 'mean_RT_pos_20': df['RT pos 20mm'].mean(),\n 'std_RT_pos_20': df['RT pos 20mm'].std(),\n 'max_RT_pos_20': df['RT pos 20mm'].max(),\n 'mean_SR_pos_10': df['SR pos 10mm'].mean(),\n 'std_SR_pos_10': df['SR pos 10mm'].std(),\n 'max_SR_pos_10': df['SR pos 10mm'].max(),\n 'mean_RT_pos_10': df['RT pos 10mm'].mean(),\n 'std_RT_pos_10': df['RT pos 10mm'].std(),\n 'max_RT_pos_10': df['RT pos 10mm'].max(),\n 'mean_SR_pos_5': df['SR pos 5mm'].mean(),\n 'std_SR_pos_5': df['SR pos 5mm'].std(),\n 'max_SR_pos_5': df['SR pos 5mm'].max(),\n 'mean_RT_pos_5': df['RT pos 5mm'].mean(),\n 'std_RT_pos_5': df['RT pos 5mm'].std(),\n 'max_RT_pos_5': df['RT pos 5mm'].max(),\n 'mean_SR_pos_2': df['SR pos 2mm'].mean(),\n 'std_SR_pos_2': df['SR pos 2mm'].std(),\n 'max_SR_pos_2': df['SR pos 2mm'].max(),\n 'mean_RT_pos_2': df['RT pos 2mm'].mean(),\n 'std_RT_pos_2': df['RT pos 2mm'].std(),\n 'max_RT_pos_2': df['RT pos 2mm'].max(),\n 'mean_SR_pos_1': df['SR pos 1mm'].mean(),\n 'std_SR_pos_1': df['SR pos 1mm'].std(),\n 'max_SR_pos_1': df['SR pos 1mm'].max(),\n 'mean_RT_pos_1': df['RT pos 1mm'].mean(),\n 'std_RT_pos_1': df['RT pos 1mm'].std(),\n 'max_RT_pos_1': df['RT pos 1mm'].max(),\n 'mean_SR_pos_05': df['SR pos 0.5mm'].mean(),\n 'std_SR_pos_05': df['SR pos 0.5mm'].std(),\n 'max_SR_pos_05': df['SR pos 0.5mm'].max(),\n 'mean_RT_pos_05': df['RT pos 0.5mm'].mean(),\n 'std_RT_pos_05': df['RT pos 0.5mm'].std(),\n 'max_RT_pos_05': df['RT pos 0.5mm'].max(),\n 'mean_SR_orient_50': df['SR orient 50mm'].mean(),\n 'std_SR_orient_50': df['SR orient 50mm'].std(),\n 'max_SR_orient_50': df['SR orient 50mm'].max(),\n 'mean_RT_orient_50': df['RT orient 50mm'].mean(),\n 'std_RT_orient_50': df['RT orient 50mm'].std(),\n 'max_RT_orient_50': df['RT orient 50mm'].max(),\n 'mean_SR_orient_20': df['SR orient 20mm'].mean(),\n 'std_SR_orient_20': df['SR orient 20mm'].std(),\n 'max_SR_orient_20': df['SR orient 20mm'].max(),\n 'mean_RT_orient_20': df['RT orient 20mm'].mean(),\n 'std_RT_orient_20': df['RT orient 20mm'].std(),\n 'max_RT_orient_20': df['RT orient 20mm'].max(),\n 'mean_SR_orient_10': df['SR orient 10mm'].mean(),\n 'std_SR_orient_10': df['SR orient 10mm'].std(),\n 'max_SR_orient_10': df['SR orient 10mm'].max(),\n 'mean_RT_orient_10': df['RT orient 10mm'].mean(),\n 'std_RT_orient_10': df['RT orient 10mm'].std(),\n 'max_RT_orient_10': df['RT orient 10mm'].max(),\n 'mean_SR_orient_5': df['SR orient 5mm'].mean(),\n 'std_SR_orient_5': df['SR orient 5mm'].std(),\n 'max_SR_orient_5': df['SR orient 5mm'].max(),\n 'mean_RT_orient_5': df['RT orient 5mm'].mean(),\n 'std_RT_orient_5': df['RT orient 5mm'].std(),\n 'max_RT_orient_5': df['RT orient 5mm'].max(),\n 'mean_SR_orient_2': df['SR orient 2mm'].mean(),\n 'std_SR_orient_2': df['SR orient 2mm'].std(),\n 'max_SR_orient_2': df['SR orient 2mm'].max(),\n 'mean_RT_orient_2': df['RT orient 2mm'].mean(),\n 'std_RT_orient_2': df['RT orient 2mm'].std(),\n 'max_RT_orient_2': df['RT orient 2mm'].max(),\n 'mean_SR_orient_1': df['SR orient 1mm'].mean(),\n 'std_SR_orient_1': df['SR orient 1mm'].std(),\n 'max_SR_orient_1': df['SR orient 1mm'].max(),\n 'mean_RT_orient_1': df['RT orient 1mm'].mean(),\n 'std_RT_orient_1': df['RT orient 1mm'].std(),\n 'max_RT_orient_1': df['RT orient 1mm'].max(),\n 'mean_SR_orient_05': df['SR orient 0.5mm'].mean(),\n 'std_SR_orient_05': df['SR orient 0.5mm'].std(),\n 'max_SR_orient_05': df['SR orient 0.5mm'].max(),\n 'mean_RT_orient_05': df['RT orient 0.5mm'].mean(),\n 'std_RT_orient_05': df['RT orient 0.5mm'].std(),\n 'max_RT_orient_05': df['RT orient 0.5mm'].max()\n }\n\n df_metrics = pd.DataFrame(metrics_dict, index=[0])\n df_metrics.to_csv(log_dir + \"results_exp.csv\", index=False)\n\n # concatenate all 3 dictionaries\n benchmark_dict = {**env_dict, **hyperparams_dict, **metrics_dict}\n\n # transform into a dataframe\n df_bench = pd.DataFrame(benchmark_dict, index=[0])\n\n BENCH_PATH = \"benchmark/benchmark_results.csv\"\n if os.path.isfile(BENCH_PATH):\n\n backedup_df = pd.read_csv(BENCH_PATH)\n # If experiment hasn't been evaluated yet\n if args.exp_id in backedup_df['exp_id'].values:\n ANSWER = None\n while ANSWER not in (\"Y\", \"n\"):\n ANSWER = input((\"This experiment has already been evaluated and \"\n \"added to the benchmark file. Do you still want to continue ? [Y/n] \"))\n if ANSWER == \"Y\":\n break\n if ANSWER == \"n\":\n print(\"Aborting...\")\n sys.exit()\n else:\n print(\"Please enter Y or n.\")\n\n # add to existing results and save\n appended_df = backedup_df.append(df_bench, ignore_index=True)\n appended_df.to_csv(BENCH_PATH, index=False)\n else:\n # if benchmark file doesn't exist, save df_bench\n df_bench.to_csv(BENCH_PATH, index=False)\n\n ###############\n # 2. PLOT LEARNING CURVES\n ###############\n\n ##### 2.1. create all_reward dataframe\n\n res_file_list = []\n\n for path in Path(log_dir).rglob(args.env + '_*'):\n res_file_list.append(path)\n\n res_file_list = sorted(res_file_list)\n # print(res_file_list)\n\n df_list = []\n col_list = []\n COUNT = 1\n\n for filename in res_file_list:\n # print(filename)\n FILENAME = str(filename) # convert from Posixpath to string\n\n W = load_results(FILENAME)\n # print(W['r'])\n\n df_list.append(W['r'])\n col_list.append(\"seed \" + str(COUNT))\n COUNT += 1\n\n all_rewards = pd.concat(df_list, axis=1)\n all_rewards.columns = col_list\n\n all_rewards_copy = all_rewards.copy()\n all_rewards[\"mean_reward\"] = all_rewards_copy.mean(axis=1)\n all_rewards[\"std_reward\"] = all_rewards_copy.std(axis=1)\n all_rewards[\"upper\"] = all_rewards[\"mean_reward\"] + \\\n all_rewards[\"std_reward\"]\n all_rewards[\"lower\"] = all_rewards[\"mean_reward\"] - \\\n all_rewards[\"std_reward\"]\n all_rewards['timesteps'] = W['l'].cumsum()\n all_rewards.to_csv(log_dir + \"all_rewards.csv\", index=False)\n\n # apply rolling window (except on timesteps)\n all_rewards_smoothed = all_rewards.copy()\n\n for col in all_rewards_smoothed.columns[:-1]:\n # print(col)\n all_rewards_smoothed[col] = all_rewards_smoothed[col].rolling(window=50).mean()\n\n all_rewards_smoothed.dropna(inplace=True) # remove NaN due to rolling average\n all_rewards_smoothed.to_csv(log_dir + \"all_rewards_smooth.csv\", index=False)\n # print(all_rewards_smoothed)\n\n # remove underscore in column name (issue with tex)\n all_rewards.rename(lambda s: s.replace('_', ' '), axis='columns', inplace=True)\n all_rewards_smoothed.rename(lambda s: s.replace('_', ' '), axis='columns', inplace=True)\n\n ###### 2.2. Plot\n\n fs = 15\n plt.rc('text', usetex=True)\n plt.rc('font', family='serif')\n plt.rc('xtick', labelsize=fs)\n plt.rc('ytick', labelsize=fs)\n\n ##### 2.2.1. plot reward vs timesteps\n fig, ax = plt.subplots(figsize=(10, 7))\n\n for seed_col in col_list:\n # print(seed_col)\n all_rewards.plot(x='timesteps', y=seed_col, ax=ax)\n\n all_rewards.plot(x='timesteps', y='mean reward', ax=ax, color='k')\n ax.ticklabel_format(axis='x', style='sci', scilimits=(0, 5))\n\n plt.xlabel(r'Time steps', fontsize=fs)\n plt.ylabel(r'Average return', fontsize=fs)\n plt.legend(loc=\"lower right\", fontsize=fs)\n\n plt.savefig(log_dir + \"reward_vs_timesteps.png\", bbox_inches='tight', dpi=100)\n # plt.show()\n\n ########## 2.2.2. plot reward vs timesteps (smoothed)\n fig, ax = plt.subplots(figsize=(10, 7))\n\n for seed_col in col_list:\n # print(seed_col)\n all_rewards_smoothed.plot(x='timesteps', y=seed_col, ax=ax)\n\n all_rewards_smoothed.plot(x='timesteps', y='mean reward', ax=ax, color='k')\n ax.ticklabel_format(axis='x', style='sci', scilimits=(0, 5))\n\n plt.xlabel(r'Time steps', fontsize=fs)\n plt.ylabel(r'Average return', fontsize=fs)\n plt.legend(loc=\"lower right\", fontsize=fs)\n\n plt.savefig(log_dir + \"reward_vs_timesteps_smoothed.png\", bbox_inches='tight', dpi=100)\n # plt.show()\n\n # ####### 2.2.3. plot reward vs timesteps (fill between)\n fig, ax = plt.subplots(figsize=(10, 7))\n\n ax.plot(all_rewards['timesteps'], all_rewards['mean reward'], color='k', label='Mean return', linewidth=0.5)\n ax.fill_between(all_rewards['timesteps'], all_rewards['lower'], all_rewards['upper'], color='r', alpha=0.35, label='Confidence interval')\n # plt.axhline(y=0, color='r', linestyle='--', label=\"min reward\")\n ax.ticklabel_format(axis='x', style='sci', scilimits=(0, 5))\n\n plt.xlabel(r'Time steps', fontsize=fs)\n plt.ylabel(r'Average return', fontsize=fs)\n plt.legend(loc=\"lower right\", fontsize=fs)\n\n plt.savefig(log_dir + \"reward_vs_timesteps_fill.png\", bbox_inches='tight', dpi=100)\n # plt.show()\n\n # ####### 2.2.4. plot reward vs timesteps (fill between) + smoothed\n fig, ax = plt.subplots(figsize=(10, 7))\n\n ax.plot(all_rewards_smoothed['timesteps'], all_rewards_smoothed['mean reward'], color='k', label='Mean return')\n ax.fill_between(all_rewards_smoothed['timesteps'], all_rewards_smoothed['lower'], all_rewards_smoothed['upper'], color='r', alpha=0.35, label='Confidence interval')\n # plt.axhline(y=0, color='r', linestyle='--', label=\"min reward\")\n ax.ticklabel_format(axis='x', style='sci', scilimits=(0, 5))\n\n plt.xlabel(r'Time steps', fontsize=fs)\n plt.ylabel(r'Average return', fontsize=fs)\n plt.legend(loc=\"lower right\", fontsize=fs)\n\n plt.savefig(log_dir + \"reward_vs_timesteps_fill_smoothed.png\", bbox_inches='tight', dpi=100)\n # plt.show()\n\n"
] | [
[
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.subplots",
"pandas.DataFrame",
"matplotlib.pyplot.savefig"
],
[
"matplotlib.pyplot.legend",
"pandas.concat",
"pandas.read_csv",
"matplotlib.pyplot.rc",
"matplotlib.pyplot.subplots",
"pandas.DataFrame",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.ylabel"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
sebastianbernasek/dataincubator | [
"de29e86c917f107650d03d3331109cb992a6881c"
] | [
"modules/dynamics.py"
] | [
"from scipy.signal import savgol_filter\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\ndef normalize_by_baseline(timeseries, baseline_length=4):\n baseline = timeseries.iloc[:baseline_length].mean(axis=0)\n normalized_timeseries = np.log2(timeseries / baseline)\n normalized_timeseries = normalized_timeseries.iloc[baseline_length:, :]\n return normalized_timeseries\n\ndef detrend(timeseries):\n trend = timeseries.mean(axis=1)\n return timeseries.subtract(trend, axis=0)\n\ndef ptp(timeseries):\n return timeseries.max(axis=0) - timeseries.min(axis=0)\n\ndef differentiate(timeseries, window_size=3, polyorder=1):\n return timeseries.diff(axis=0, periods=1).apply(savgol_filter, axis=0, args=(window_size, polyorder))\n\ndef plot_timeseries(timeseries, label=None, examples=None):\n fig, ax = plt.subplots()\n timeseries.plot(ax=ax, legend=False, color='k', lw=0.2)\n\n # set ylabel\n if label is not None:\n ax.set_ylabel(label)\n\n # highlight examples\n if examples is not None:\n if type(examples) == int:\n timeseries.loc[:, examples].plot(ax=ax, lw=3, color='r')\n elif type(examples) in (list, tuple):\n for example in examples:\n timeseries.loc[:, example].plot(ax=ax, lw=3, color='r')\n\n return ax\n"
] | [
[
"numpy.log2",
"matplotlib.pyplot.subplots"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
GabrielJie/PyMFEM | [
"fa654447ac6819c5aa0341397b91a299f4ce5492"
] | [
"mfem/common/chypre.py"
] | [
"'''\n CHypre (Complex Hypre)\n\n CHypreVec : ParVector\n CHypreMat : ParCSR\n\n container object to support complex using\n real value hypre\n\n it should work with pure real or pure imaginary\n case too.\n\n it follows the mathod naming convetion used\n in scipy.sparse. However, since it inherits the list\n object, __setitem__ can not be used for accessing\n array elements. Use set_element, instead.\n'''\nimport numpy as np\nfrom numbers import Number\nfrom scipy.sparse import csr_matrix, coo_matrix, lil_matrix\nfrom mfem.common.parcsr_extra import *\n\n# DO NOT IMPORT MPI in Global, sicne some routins will be used\n# in serial mode too.\ntry:\n import mfem.par\n MFEM_PAR = True\nexcept BaseException:\n MFEM_PAR = False\n\n\nclass CHypreVec(list):\n def __init__(self, r=None, i=None, horizontal=False):\n list.__init__(self, [None] * 2)\n self._horizontal = horizontal\n\n if isinstance(r, np.ndarray):\n self[0] = ToHypreParVec(r)\n else:\n self[0] = r\n if isinstance(i, np.ndarray):\n self[1] = ToHypreParVec(i)\n else:\n self[1] = i\n\n def __repr__(self):\n if self[0] is not None:\n part = self[0].GetPartitioningArray()\n elif self[1] is not None:\n part = self[1].GetPartitioningArray()\n else:\n return \"CHypreVec (empty)\"\n return \"CHypreVec\" + str(self.shape) + \\\n \"[\" + str(part[1] - part[0]) + \"]\"\n\n @property\n def imag(self):\n return self[1]\n\n @imag.setter\n def imag(self, value):\n self[1] = value\n\n @property\n def real(self):\n return self[0]\n\n @real.setter\n def real(self, value):\n self[0] = value\n\n @property\n def shape(self):\n if self[0] is not None:\n size = self[0].GlobalSize()\n elif self[1] is not None:\n size = self[1].GlobalSize()\n else:\n size = 0.0\n\n if self._horizontal:\n return 1, size\n else:\n return size, 1\n\n def isComplex(self):\n return not (self[1] is None)\n\n def GetPartitioningArray(self):\n if self[0] is not None:\n part = self[0].GetPartitioningArray()\n #part[2] = self[0].GlobalSize()\n elif self[1] is not None:\n prat = self[1].GetPartitioningArray()\n #part[2] = self[1].GlobalSize()\n else:\n raise ValueError(\"CHypreVec is empty\")\n return part\n\n def __imul__(self, other):\n if isinstance(other, CHypreVec):\n assert False, \"CHypreVec *= vector is not supported. Use dot\"\n elif np.iscomplexobj(other):\n #other = complex(other)\n i = other.imag\n r = other.real\n\n if self[0] is not None and self[1] is not None:\n rr = self[0].GetDataArray() * r - self[1].GetDataArray() * i\n ii = self[0].GetDataArray() * i + self[1].GetDataArray() * r\n self[0] = ToHypreParVec(rr)\n self[1] = ToHypreParVec(ii)\n\n elif self[0] is not None:\n if np.any(i != 0.):\n self[1] = ToHypreParVec(i * self[0].GetDataArray())\n if np.any(r != 0.):\n tmp = self[0].GetDataArray()\n tmp *= r\n else:\n self[0] = None\n\n elif self[1] is not None:\n if np.any(i != 0.):\n self[0] = ToHypreParVec(-i * self[1].GetDataArray())\n if np.any(r != 0.):\n tmp = self[1].GetDataArray()\n tmp *= r\n else:\n self[1] = None\n\n else:\n passself[0] = None\n else:\n other = float(other)\n if self[0] is not None:\n self[0] *= other\n if self[1] is not None:\n self[1] *= other\n return self\n\n def __mul__(self, other):\n if isinstance(other, CHypreVec):\n assert False, \"CHypreVec *= vector is not supported. Use dot\"\n elif np.iscomplexobj(other):\n other = complex(other)\n i = other.imag\n r = other.real\n else:\n r = float(other)\n i = 0.0\n rdata = self[0].GetDataArray() if self[0] is not None else 0\n idata = self[1].GetDataArray() if self[1] is not None else 0\n\n rr = rdata * r - idata * i\n ii = rdata * i + idata * r\n\n # note: for the real part we keep it even if it is zero\n # so that it conservs vector size information\n rr = ToHypreParVec(rr)\n ii = ToHypreParVec(ii) if np.count_nonzero(ii) != 0 else None\n\n return CHypreVec(rr, ii, horizontal=self._horizontal)\n\n def __add__(self, other):\n assert self._horizontal == other._horizontal, \"can not add vertical and hirozontal vector\"\n\n if self[0] is not None and other[0] is not None:\n data = self[0].GetDataArray() + other[0].GetDataArray()\n r = ToHypreParVec(data)\n elif self[0] is not None:\n data = self[0].GetDataArray()\n r = ToHypreParVec(data)\n elif other[0] is not None:\n data = other[0].GetDataArray()\n r = ToHypreParVec(data)\n else:\n r = None\n if self[1] is not None and other[1] is not None:\n data = self[1].GetDataArray() + other[1].GetDataArray()\n i = ToHypreParVec(data)\n elif self[1] is not None:\n data = self[1].GetDataArray()\n i = ToHypreParVec(data)\n elif other[1] is not None:\n data = other[1].GetDataArray()\n i = ToHypreParVec(data)\n else:\n i = None\n return CHypreVec(r, i, horizontal=self._horizontal)\n\n def __sub__(self, other):\n assert self._horizontal == other._horizontal, \"can not add vertical and hirozontal vector\"\n if self[0] is not None and other[0] is not None:\n data = self[0].GetDataArray() - other[0].GetDataArray()\n r = ToHypreParVec(data)\n elif self[0] is not None:\n data = self[0].GetDataArray()\n r = ToHypreParVec(data)\n elif other[0] is not None:\n data = -other[0].GetDataArray()\n r = ToHypreParVec(data)\n else:\n r = None\n if self[1] is not None and other[1] is not None:\n data = self[1].GetDataArray() - other[1].GetDataArray()\n i = ToHypreParVec(data)\n elif self[1] is not None:\n data = self[1].GetDataArray()\n i = ToHypreParVec(data)\n elif other[1] is not None:\n data = -other[1].GetDataArray()\n i = ToHypreParVec(data)\n else:\n i = None\n return CHypreVec(r, i, horizontal=self._horizontal)\n\n def dot(self, other):\n if isinstance(other, CHypreVec):\n return InnerProductComplex(self, other)\n elif (isinstance(other, CHypreMat) and\n self._horizontal):\n ret = other.transpose().dot(self)\n ret._horizontal = True\n return ret\n else:\n raise ValueError(\n \"CHypreVec::dot supports Vec*Vec (InnerProduct) and (Mat^t*Vec)^t \")\n\n def get_elements(self, idx):\n part = self.GetPartitioningArray()\n idx = idx - part[0]\n idx = idx[idx < part[1]-part[0]]\n idx = idx[idx >= 0]\n\n if len(idx) == 0:\n return np.array([])\n\n ret = 0.0\n if self[0] is not None:\n ret = ret + self[0].GetDataArray()[idx]\n if self[1] is not None:\n ret = ret + 1j*self[1].GetDataArray()[idx]\n return ret\n\n def set_elements(self, idx, value):\n part = self.GetPartitioningArray()\n idx = idx - part[0]\n idx = idx[idx < part[1]-part[0]]\n idx = idx[idx >= 0]\n\n rvalue = value.real if np.iscomplexobj(value) else value\n\n if len(idx) == 0:\n return\n\n if self[0] is not None:\n self[0].GetDataArray()[idx] = rvalue\n\n if np.iscomplexobj(value):\n if self[1] is None:\n i = self[0].GetDataArray()*0.0\n self[1] = ToHypreParVec(i)\n self[1].GetDataArray()[idx] = value.imag\n\n def set_element(self, i, v):\n part = self.GetPartitioningArray()\n if part[0] <= i and i < part[1]:\n v = complex(v)\n if self[0] is not None:\n self[0][int(i - part[0])] = v.real\n if self[1] is not None:\n self[1][int(i - part[0])] = v.imag\n\n def get_element(self, i):\n part = self.GetPartitioningArray()\n if part[0] <= i and i < part[1]:\n if self[0] is not None:\n r = self[0][int(i - part[0])]\n else:\n r = 0\n if self[1] is not None:\n return r + 1j * self[1][int(i - part[0])]\n else:\n return r\n\n def copy_element(self, tdof, vec):\n for i in tdof:\n v = vec.get_element(i)\n self.set_element(i, v)\n\n '''\n def gather(self):\n from mpi4py import MPI\n myid = MPI.COMM_WORLD.rank\n vecr = 0.0; veci = 0.0\n if self[0] is not None:\n vecr = gather_vector(self[0].GetDataArray(), MPI.DOUBLE)\n if self[1] is not None:\n veci = gather_vector(self[1].GetDataArray(), MPI.DOUBLE)\n\n if myid == 0:\n if self[0] is None:\n return vecr\n else:\n return vecr + 1j*veci\n '''\n\n def get_squaremat_from_right(self):\n '''\n squre matrix which can be multipled from the right of self.\n '''\n if not self._horizontal:\n raise ValueError(\"Vector orientation is not right\")\n\n part = self.GetPartitioningArray()\n width = self[1].GlobalSize()\n return SquareCHypreMat(width, part, real=(self[1] is None))\n\n def transpose(self):\n self._horizontal = not self._horizontal\n return self\n\n def _do_reset(self, v, idx):\n # ownership is transferrd to a new vector.\n ownership = v.GetOwnership()\n data = v.GetDataArray()\n part = v.GetPartitioningArray()\n for i in idx:\n if i >= part[1]:\n continue\n if i < part[0]:\n continue\n data[i - part[0]] = 0\n\n ret = ToHypreParVec(data)\n ret.SetOwnership(ownership)\n v.SetOwnership(0)\n return ret\n\n def resetCol(self, idx):\n if self._horizontal:\n if self[0] is not None:\n self[0] = self._do_reset(self[0], idx)\n if self[1] is not None:\n self[1] = self._do_reset(self[1], idx)\n else:\n if 0 in idx:\n self *= 0.0\n\n def resetRow(self, idx):\n if self._horizontal:\n if 0 in idx:\n self *= 0.0\n else:\n if self[0] is not None:\n self[0] = self._do_reset(self[0], idx)\n if self[1] is not None:\n self[1] = self._do_reset(self[1], idx)\n\n def _do_select(self, v, lidx):\n # ownership is transferrd to a new vector.\n ownership = v.GetOwnership()\n data = v.GetDataArray()\n data2 = data[lidx]\n ret = ToHypreParVec(data2)\n ret.SetOwnership(ownership)\n v.SetOwnership(0)\n return ret\n\n def selectRows(self, idx):\n '''\n idx is global index\n '''\n if self._horizontal:\n if not 0 in idx:\n raise ValueError(\"VectorSize becomes zero\")\n return self\n\n part = self.GetPartitioningArray()\n idx = idx[idx >= part[0]]\n idx = idx[idx < part[1]]\n lidx = idx - part[0]\n\n r = None\n i = None\n if not self._horizontal:\n if self[0] is not None:\n r = self._do_select(self[0], lidx)\n if self[1] is not None:\n i = self._do_select(self[1], lidx)\n return CHypreVec(r, i, horizontal=self._horizontal)\n\n def selectCols(self, idx):\n '''\n idx is global index\n '''\n if not self._horizontal:\n if not 0 in idx:\n raise ValueError(\"VectorSize becomes zero\")\n return self\n\n part = self.GetPartitioningArray()\n idx = idx[idx >= part[0]]\n idx = idx[idx < part[1]]\n lidx = idx - part[0]\n\n r = None\n i = None\n if self._horizontal:\n if self[0] is not None:\n r = self._do_select(self[0], lidx)\n if self[1] is not None:\n i = self._do_select(self[1], lidx)\n return CHypreVec(r, i, horizontal=self._horizontal)\n\n def GlobalVector(self):\n '''\n Here it is reimplmente using MPI allgather.\n This is because GlobalVactor does not work when the vector\n is too small so that some node does not have data.\n '''\n def gather_allvector(data):\n from mfem.common.mpi_dtype import get_mpi_datatype\n from mpi4py import MPI\n\n mpi_data_type = get_mpi_datatype(data)\n myid = MPI.COMM_WORLD.rank\n rcounts = data.shape[0]\n rcounts = np.array(MPI.COMM_WORLD.allgather(rcounts))\n\n for x in data.shape[1:]:\n rcounts = rcounts * x\n cm = np.hstack((0, np.cumsum(rcounts)))\n disps = list(cm[:-1])\n length = cm[-1]\n recvbuf = np.empty([length], dtype=data.dtype)\n recvdata = [recvbuf, rcounts, disps, mpi_data_type]\n senddata = [data.flatten(), data.flatten().shape[0]]\n MPI.COMM_WORLD.Allgatherv(senddata, recvdata)\n return recvbuf.reshape(-1, *data.shape[1:])\n\n if self[0] is not None:\n v1 = gather_allvector(self[0].GetDataArray().copy())\n else:\n v1 = 0.0\n if self[1] is not None:\n v2 = gather_allvector(self[1].GetDataArray().copy())\n v1 = v1 + 1j * v2\n return v1\n\n def toarray(self):\n '''\n numpy array of local vector\n '''\n if self[0] is not None:\n v = self[0].GetDataArray()\n else:\n v = 0.0\n if self[1] is not None:\n v = v + 1j * self[1].GetDataArray()\n return v\n\n def isAllZero(self):\n return any(self.GlobalVector())\n\n def get_global_coo(self):\n data = self[0].GetDataArray()\n if self[1] is not None:\n data = data + 1j * self[1].GetDataArray()\n gcoo = coo_matrix(self.shape, dtype=data.dtype)\n gcoo.data = data\n part = self.GetPartitioningArray()\n if self._horizontal:\n gcoo.row = np.zeros(len(data))\n gcoo.col = np.arange(len(data)) + part[0]\n else:\n gcoo.col = np.zeros(len(data))\n gcoo.row = np.arange(len(data)) + part[0]\n return gcoo\n\n def true_nnz(self):\n '''\n more expensive version which reports nnz after\n eliminating all zero entries\n I can not use @property, since ScipyCoo can't\n have @property (class inherited from ndarray)\n '''\n data = self[0].GetDataArray()\n if self[1] is not None:\n data = data + 1j * self[1].GetDataArray()\n local_nnz = np.sum(data == 0.)\n\n from mpi4py import MPI\n comm = MPI.COMM_WORLD\n nnz = comm.allgather(local_nnz)\n return nnz\n\n @property\n def isHypre(self):\n return True\n\n\nclass CHypreMat(list):\n def __init__(self, r=None, i=None, col_starts=None):\n list.__init__(self, [None] * 2)\n if isinstance(r, csr_matrix):\n self[0] = ToHypreParCSR(r, col_starts=col_starts)\n elif isinstance(r, mfem.par.HypreParMatrix):\n self[0] = r\n elif r is None:\n self[0] = r\n else:\n assert False, \"unknonw matrix element\"\n if isinstance(i, csr_matrix):\n self[1] = ToHypreParCSR(i, col_starts=col_starts)\n elif isinstance(i, mfem.par.HypreParMatrix):\n self[1] = i\n elif i is None:\n self[1] = i\n else:\n assert False, \"unknonw matrix element\"\n\n def GetOwns(self):\n flags = [None] * 6\n if self[0] is not None:\n flags[0] = self[0].OwnsDiag()\n flags[1] = self[0].OwnsOffd()\n flags[2] = self[0].OwnsColMap()\n if self[1] is not None:\n flags[3] = self[1].OwnsDiag()\n flags[4] = self[1].OwnsOffd()\n flags[5] = self[1].OwnsColMap()\n return flags\n\n def __repr__(self):\n return \"CHypreMat\" + str(self.shape) + \"[\" + str(self.lshape) + \"]\"\n\n def isComplex(self):\n return not (self[1] is None)\n\n def __mul__(self, other): # A * B or A * v\n if isinstance(other, CHypreMat):\n return CHypreMat(*ParMultComplex(self, other))\n elif isinstance(other, CHypreVec):\n v = CHypreVec(*ParMultVecComplex(self, other))\n v._horizontal = other._horizontal\n return v\n elif isinstance(other, Number):\n if np.iscomplexobj(other):\n other = complex(other)\n r = other.real\n i = other.imag\n else:\n r = other\n i = 0\n if self[0] is not None and self[1] is not None:\n R = mfem.par.Add(r, self[0], -i, self[1])\n I = mfem.par.Add(i, self[0], r, self[1])\n elif self[0] is not None:\n #R = mfem.par.Add(r, self[0], 0.0, self[0])\n R = mfem.par.Add(r, self[0], 0.0, self[0])\n if i != 0.0:\n I = mfem.par.Add(i, self[0], 0.0, self[0])\n else:\n I = None\n elif self[1] is not None:\n if r != 0.0:\n I = mfem.par.Add(r, self[1], 0.0, self[1])\n else:\n I = None\n R = mfem.par.Add(-i, self[1], 0.0, self[1])\n else:\n assert False, \"this mode is not supported\"\n R = None\n I = None\n if R is not None:\n R.CopyRowStarts()\n R.CopyColStarts()\n if I is not None:\n I.CopyRowStarts()\n I.CopyColStarts()\n return CHypreMat(R, I)\n raise ValueError(\"argument should be CHypreMat/Vec\")\n\n def __rmul__(self, other):\n if not isinstance(other, CHypreMat):\n raise ValueError(\n \"argument should be CHypreMat\")\n return CHypreMat(*ParMultComplex(other, self))\n\n def __add__(self, other): # A + B\n if not isinstance(other, CHypreMat):\n raise ValueError(\n \"argument should be CHypreMat\")\n if self[0] is not None and other[0] is not None:\n r = ParAdd(self[0], other[0])\n elif self[0] is not None:\n r = ToHypreParCSR(ToScipyCoo(self[0]).tocsr())\n elif other[0] is not None:\n r = ToHypreParCSR(ToScipyCoo(other[0]).tocsr())\n else:\n r = None\n if self[1] is not None and other[1] is not None:\n i = ParAdd(self[1], other[1])\n# i = mfem.par.add_hypre(1.0, self[1], 1.0, other[1])\n elif self[1] is not None:\n i = ToHypreParCSR(ToScipyCoo(self[1]).tocsr())\n elif other[1] is not None:\n i = ToHypreParCSR(ToScipyCoo(other[1]).tocsr())\n else:\n i = None\n\n if r is not None:\n r.CopyRowStarts()\n r.CopyColStarts()\n if i is not None:\n i.CopyRowStarts()\n i.CopyColStarts()\n\n return CHypreMat(r, i)\n\n def __sub__(self, other): # A - B\n if not isinstance(other, CHypreMat):\n raise ValueError(\n \"argument should be CHypreMat\")\n if self[0] is not None and other[0] is not None:\n other[0] *= -1\n r = ParAdd(self[0], other[0])\n other[0] *= -1\n elif self[0] is not None:\n r = ToHypreParCSR(ToScipyCoo(self[0]).tocsr())\n elif other[0] is not None:\n r = mfem.par.Add(-1, othe[0], 0.0, other[0])\n else:\n r = None\n if self[1] is not None and other[1] is not None:\n other[1] *= -1\n i = ParAdd(self[1], other[1])\n other[1] *= -1\n elif self[1] is not None:\n i = ToHypreParCSR(ToScipyCoo(self[1]).tocsr())\n elif other[1] is not None:\n i = mfem.par.Add(-1, othe[1], 0.0, other[1])\n else:\n i = None\n\n if r is not None:\n r.CopyRowStarts()\n r.CopyColStarts()\n if i is not None:\n i.CopyRowStarts()\n i.CopyColStarts()\n\n return CHypreMat(r, i)\n\n def __neg__(self): # -B\n r = None\n i = None\n if self[0] is not None:\n r = mfem.par.Add(-1, self[0], 0.0, self[0])\n r.CopyRowStarts()\n r.CopyColStarts()\n if self[1] is not None:\n i = mfem.par.Add(-1, self[1], 0.0, self[0])\n i.CopyRowStarts()\n i.CopyColStarts()\n\n return CHypreMat(r, i)\n\n @property\n def imag(self):\n return self[1]\n\n @imag.setter\n def imag(self, value):\n self[1] = value\n\n @property\n def real(self):\n return self[0]\n\n @real.setter\n def real(self, value):\n self[0] = value\n\n def GetColPartArray(self):\n if self[0] is not None:\n return self[0].GetColPartArray()\n else:\n return self[1].GetColPartArray()\n\n def GetRowPartArray(self):\n if self[0] is not None:\n return self[0].GetRowPartArray()\n else:\n return self[1].GetRowPartArray()\n\n def __imul__(self, other):\n if self[0] is not None:\n self[0] *= other\n if self[1] is not None:\n self[1] *= other\n return self\n\n def dot(self, other):\n return self.__mul__(other)\n\n def transpose(self):\n '''\n transpose of matrix\n this method returns a new matrix\n '''\n R = self[0].Transpose() if self[0] is not None else None\n I = self[1].Transpose() if self[1] is not None else None\n return CHypreMat(R, I)\n # return CHypreMat(self[0].Transpose(), self[1].Transpose())\n\n def conj(self, inplace=True):\n '''\n complex conjugate\n if copy is on, imaginary part becomes different object\n '''\n if self[1] is None:\n return self\n\n if not inplace:\n self[1] = ToHypreParCSR(-ToScipyCoo(self[1]).tocsr())\n else:\n self[1] *= -1.0\n return self\n\n def rap(self, B):\n '''\n B^* A B\n '''\n ret = B.conj().transpose() * self\n ret = ret * (B.conj())\n # this should put B back to original\n return ret\n\n def setDiag(self, idx, value=1.0):\n if self[0] is not None:\n self[0] = ResetHypreDiag(self[0], idx, value=np.real(value))\n if self[1] is not None:\n self[1] = ResetHypreDiag(self[1], idx, value=np.imag(value))\n\n def getDiag(self, idx):\n if self[0] is not None:\n diagvalue = ReadHypreDiag(self[0], idx)\n else:\n diagvalue = complex(0.0)\n\n if self[1] is not None:\n diagvalue = diagvalue + 1j*ReadHypreDiag(self[1], idx)\n else:\n diagvalue = diagvalue + 0j\n return diagvalue\n\n def resetCol(self, idx, inplace=True):\n if self[0] is not None:\n r = ResetHypreCol(self[0], idx)\n else:\n r = None\n if self[1] is not None:\n i = ResetHypreCol(self[1], idx)\n else:\n i = None\n if inplace:\n self[0] = r\n self[1] = i\n return self\n else:\n return CHypreMat(r, i)\n\n def resetRow(self, idx, inplace=True):\n if self[0] is not None:\n r = ResetHypreRow(self[0], idx)\n else:\n r = None\n if self[1] is not None:\n i = ResetHypreRow(self[1], idx)\n else:\n i = None\n if inplace:\n self[0] = r\n self[1] = i\n return self\n else:\n return CHypreMat(r, i)\n\n def selectRows(self, idx):\n '''\n idx is global index\n '''\n rpart = self[0].GetRowPartArray()\n #rpart[2] = self[0].GetGlobalNumRows()\n cpart = self[0].GetColPartArray()\n #cpart[2] = self[0].GetGlobalNumCols()\n\n idx = idx[idx >= rpart[0]]\n idx = idx[idx < rpart[1]]\n idx = idx - rpart[0]\n\n csr = ToScipyCoo(self[0]).tocsr()\n\n csr = csr[idx, :]\n r = ToHypreParCSR(csr, col_starts=cpart)\n if self[1] is not None:\n csr = ToScipyCoo(self[1]).tocsr()\n csr = csr[idx, :]\n i = ToHypreParCSR(csr, col_starts=cpart)\n else:\n i = None\n return CHypreMat(r, i)\n\n def selectCols(self, idx):\n '''\n idx is global index\n '''\n cpart = self[0].GetColPartArray()\n #cpart[2] = self[0].GetGlobalNumCols()\n rpart = self[0].GetRowPartArray()\n #rpart[2] = self[0].GetGlobalNumRows()\n\n idx = idx[idx >= cpart[0]]\n idx = idx[idx < cpart[1]]\n idx = idx - cpart[0]\n\n mat = self.transpose()\n csr = ToScipyCoo(mat[0]).tocsr()\n csr = csr[idx, :]\n r = ToHypreParCSR(csr, col_starts=rpart)\n if self[1] is not None:\n csr = ToScipyCoo(mat[1]).tocsr()\n csr = csr[idx, :]\n i = ToHypreParCSR(csr, col_starts=rpart)\n else:\n i = None\n mat = CHypreMat(r, i).transpose()\n '''\n if (cpart == rpart).all():\n csr = ToScipyCoo(mat[0]).tocsr()\n mat[0] = ToHypreParCSR(csr, col_starts =rpart)\n if mat[1] is not None:\n csr = ToScipyCoo(mat[1]).tocsr()\n mat[1] = ToHypreParCSR(csr, col_starts =rpart)\n '''\n return mat\n\n @property\n def nnz(self):\n if self[0] is not None and self[1] is not None:\n return self[0].NNZ(), self[1].NNZ()\n if self[0] is not None:\n return self[0].NNZ()\n if self[1] is not None:\n return self[1].NNZ()\n\n def true_nnz(self):\n '''\n more expensive version which reports nnz after\n eliminating all zero entries\n '''\n #coo = self.get_local_coo()\n if self[0] is not None:\n nnz0, tnnz0 = self[0].get_local_true_nnz()\n else:\n nnz0 = 0\n tnnz0 = 0\n if self[1] is not None:\n nnz1, tnnz1 = self[1].get_local_true_nnz()\n else:\n nnz1 = 0\n tnnz1 = 0\n # print nnz0, tnnz0, nnz1, tnnz1\n return tnnz0, tnnz1\n\n def m(self):\n '''\n return global row number: two number should be the same\n '''\n ans = []\n if self[0] is not None:\n ans.append(self[0].M())\n if self[1] is not None:\n ans.append(self[1].M())\n\n if len(ans) == 2 and ans[0] != ans[1]:\n raise ValueError(\n \"data format error, real and imag should have same size\")\n return ans[0]\n\n def n(self):\n '''\n return global col number: two number should be the same\n '''\n ans = []\n if self[0] is not None:\n ans.append(self[0].N())\n if self[1] is not None:\n ans.append(self[1].N())\n if len(ans) == 2 and ans[0] != ans[1]:\n raise ValueError(\n \"data format error, real and imag should have same size\")\n return ans[0]\n\n @property\n def shape(self):\n if self[0] is not None:\n return (self[0].GetGlobalNumRows(), self[0].GetGlobalNumCols())\n elif self[1] is not None:\n return (self[1].GetGlobalNumRows(), self[1].GetGlobalNumCols())\n else:\n return (0, 0)\n\n @property\n def lshape(self):\n if self[0] is not None:\n return (self[0].GetNumRows(), self[0].GetNumCols())\n elif self[1] is not None:\n return (self[1].GetNumRows(), self[1].GetNumCols())\n else:\n return (0, 0)\n\n def get_local_coo(self):\n if self.isComplex():\n return (ToScipyCoo(self[0]) + 1j * ToScipyCoo(self[1])).tocoo()\n else:\n return ToScipyCoo(self[0])\n\n def get_global_coo(self):\n lcoo = self.get_local_coo()\n gcoo = coo_matrix(self.shape)\n gcoo.data = lcoo.data\n\n gcoo.row = lcoo.row + self.GetRowPartArray()[0]\n gcoo.col = lcoo.col\n return gcoo\n\n def get_squaremat_from_right(self):\n '''\n squre matrix which can be multipled from the right of self.\n '''\n size = self.shape[1]\n if self[0] is not None:\n part = self[0].GetColPartArray()\n width = self[0].GetGlobalNumCols()\n elif self[1] is not None:\n part = self[1].GetColPartArray()\n width = self[1].GetGlobalNumCols()\n else:\n raise ValueError(\"CHypreMat is empty\")\n return SquareCHypreMat(width, part, real=(self[1] is None))\n\n def elimination_matrix(self, idx):\n # # local version\n # ret = lil_matrix((len(nonzeros), self.shape[0]))\n # for k, z in enumerate(nonzeros):\n # ret[k, z] = 1.\n # return ret.tocoo()\n cpart = self.GetColPartArray()\n rpart = self.GetRowPartArray()\n\n idx = idx[idx >= rpart[0]]\n idx = idx[idx < rpart[1]]\n idx = idx - rpart[0]\n\n shape = (len(idx), self.shape[1])\n # print shape, idx + rpart[0]\n elil = lil_matrix(shape)\n for i, j in enumerate(idx):\n elil[i, j + rpart[0]] = 1\n\n r = ToHypreParCSR(elil.tocsr(), col_starts=cpart)\n return CHypreMat(r, None)\n\n def eliminate_RowsCols(self, B, tdof, inplace=False, diagpolicy=0):\n # note: tdof is a valued viewed in each node. MyTDoF offset is\n # subtracted\n tdof1 = mfem.par.intArray(tdof)\n if not inplace:\n #print(\"inplace flag off copying ParCSR\")\n if self[0] is not None:\n r = ToHypreParCSR(ToScipyCoo(self[0]).tocsr())\n\n else:\n r = None\n if self[1] is not None:\n i = ToHypreParCSR(ToScipyCoo(self[1]).tocsr())\n\n else:\n i = None\n target = CHypreMat(r, i)\n else:\n target = self\n\n row0 = self.GetRowPartArray()[0]\n gtdof = list(np.array(tdof, dtype=int) + row0)\n\n if diagpolicy == 0:\n diagAe = target.getDiag(gtdof) - 1\n diagA = 1.0\n else:\n diagAe = 0.0\n diagA = target.getDiag(gtdof)\n\n if target[0] is not None:\n Aer = target[0].EliminateRowsCols(tdof1)\n Aer.CopyRowStarts()\n Aer.CopyColStarts()\n #row0 = Aer.GetRowPartArray()[0]\n else:\n Aer = None\n\n if target[1] is not None:\n Aei = target[1].EliminateRowsCols(tdof1)\n Aei.CopyRowStarts()\n Aei.CopyColStarts()\n #row0 = Aei.GetRowPartArray()[0]\n else:\n Aei = None\n\n Ae = CHypreMat(Aer, Aei)\n\n target.setDiag(gtdof, value=diagA)\n Ae.setDiag(gtdof, value=diagAe)\n\n # if diagpolicy == 0:\n # part = B.GetPartitioningArray()\n # xxx = np.ones(part[1] - part[0], dtype=complex)\n # xxx[tdof] = diagA\n # B *= xxx\n # if diagpolicy == 1:\n # print(tdof)\n # print(diagA.shape)\n # diagA = diagA[tdof]\n\n B.set_elements(gtdof, diagA)\n\n return Ae, target, B\n\n @property\n def isHypre(self):\n return True\n\n\ndef SquareCHypreMat(width, part, real=False):\n from scipy.sparse import csr_matrix\n lr = part[1] - part[0]\n m1 = csr_matrix((lr, width))\n if real:\n m2 = None\n else:\n m2 = csr_matrix((lr, width))\n return CHypreMat(m1, m2)\n\n\ndef Array2CHypreVec(array, part=None, horizontal=False):\n '''\n convert array in rank =0 to\n distributed Hypre 1D Matrix (size = m x 1)\n '''\n from mpi4py import MPI\n isComplex = MPI.COMM_WORLD.bcast(np.iscomplexobj(array), root=0)\n if isComplex:\n if array is None:\n rarray = None\n iarray = None\n else:\n rarray = array.real\n iarray = array.imag\n return CHypreVec(Array2HypreVec(rarray, part),\n Array2HypreVec(iarray, part), horizontal=horizontal)\n else:\n if array is None:\n rarray = None\n else:\n rarray = array\n return CHypreVec(Array2HypreVec(rarray, part),\n None, horizontal=horizontal)\n\n\ndef CHypreVec2Array(array):\n from mpi4py import MPI\n myid = MPI.COMM_WORLD.rank\n\n if array[0] is not None:\n r = HypreVec2Array(array[0])\n else:\n if myid == 0:\n r = 0.0\n else:\n r = None\n if array[1] is None:\n return r\n else:\n i = HypreVec2Array(array[1])\n if i is None:\n return r\n else:\n if myid == 0:\n return r + 1j * i\n else:\n return None\n\n\ndef CHypreMat2Coo(mat):\n print(\"CHYPREMat2Coo: deprecated, Use class method !!!!\")\n if mat.isComplex():\n return ToScipyCoo(mat.real) + 1j * ToScipyCoo(mat.imag)\n else:\n return ToScipyCoo(mat.real)\n\n\ndef LF2PyVec(rlf, ilf=None, horizontal=False):\n if MFEM_PAR:\n '''\n From ParLF to CHypreVec\n '''\n rv = rlf.ParallelAssemble()\n rv.thisown = True\n if ilf is not None:\n iv = ilf.ParallelAssemble()\n iv.thisown = True\n else:\n iv = None\n return CHypreVec(rv, iv, horizontal=horizontal)\n else:\n b1 = rlf.GetDataArray().copy() # ; rlf.thisown = False\n if ilf is not None:\n b2 = ilf.GetDataArray() # ; ilf.thisown = False\n b1 = b1 + 1j * b2\n if horizontal:\n return b1.reshape((1, -1))\n else:\n return b1.reshape((-1, 1))\n\n\nLinearForm2PyVector = LF2PyVec\n\n\ndef MfemVec2PyVec(rlf, ilf=None, horizontal=False):\n b1 = rlf.GetDataArray().copy() # ; rlf.thisown = False\n if ilf is not None:\n b2 = ilf.GetDataArray() # ; ilf.thisown = False\n else:\n b2 = None\n\n if MFEM_PAR:\n b1 = ToHypreParVec(b1)\n if b2 is not None:\n b2 = ToHypreParVec(b2)\n return CHypreVec(b1, b2, horizontal=horizontal)\n else:\n if b2 is not None:\n b1 = b1 + 1j * b2\n if horizontal:\n return b1.reshape((1, -1))\n else:\n return b1.reshape((-1, 1))\n\n\ndef Array2PyVec(array, part=None, horizontal=False):\n '''\n convert array in rank = 0 to\n distributed Hypre 1D Matrix (size = m x 1)\n '''\n\n if MFEM_PAR:\n return Array2CHypreVec(array, part=part, horizontal=horizontal)\n else:\n if horizontal:\n return array.reshape((1, -1))\n else:\n return array.reshape((-1, 1))\n\n\ndef BF2PyMat(rbf, ibf=None, finalize=False):\n '''\n Convert pair of BilinearForms to CHypreMat or\n ScipySparsematrix\n '''\n if finalize:\n rbf.Finalize()\n if ibf is not None:\n ibf.Finalize()\n\n if MFEM_PAR:\n M1 = rbf.ParallelAssemble()\n M1.thisown = True\n if ibf is not None:\n M2 = ibf.ParallelAssemble()\n M2.thisown = True\n else:\n M2 = None\n return CHypreMat(M1, M2)\n else:\n from mfem.common.sparse_utils import sparsemat_to_scipycsr\n M1 = rbf.SpMat()\n if ibf is None:\n return sparsemat_to_scipycsr(M1, dtype=float)\n if ibf is not None:\n M2 = ibf.SpMat()\n m1 = sparsemat_to_scipycsr(M1, dtype=float).tolil()\n m2 = sparsemat_to_scipycsr(M2, dtype=complex).tolil()\n m = m1 + 1j * m2\n m = m.tocsr()\n return m\n\n\nBilinearForm2PyMatix = BF2PyMat\n\n\ndef MfemMat2PyMat(M1, M2=None):\n '''\n Convert pair of SpMat/HypreParCSR to CHypreMat or\n ScipySparsematrix. This is simpler version of BF2PyMat, only\n difference is it skippes convertion from BF to Matrix.\n '''\n from mfem.common.sparse_utils import sparsemat_to_scipycsr\n if MFEM_PAR:\n return CHypreMat(M1, M2)\n else:\n if M2 is None:\n return sparsemat_to_scipycsr(M1, dtype=float)\n else:\n m1 = sparsemat_to_scipycsr(M1, dtype=float).tolil()\n m2 = sparsemat_to_scipycsr(M2, dtype=complex).tolil()\n m = m1 + 1j * m2\n m = m.tocsr()\n return m\n\n\ndef EmptySquarePyMat(m, col_starts=None):\n from scipy.sparse import csr_matrix\n if MFEM_PAR:\n if col_starts is None:\n col_starts = get_assumed_patitioning(m)\n rows = col_starts[1] - col_starts[0]\n m1 = csr_matrix((rows, m))\n return CHypreMat(m1, None, )\n else:\n from scipy.sparse import csr_matrix\n return csr_matrix((m, m))\n\n\ndef IdentityPyMat(m, col_starts=None, diag=1.0):\n from scipy.sparse import coo_matrix, lil_matrix\n if MFEM_PAR:\n if col_starts is None:\n col_starts = get_assumed_patitioning(m)\n rows = col_starts[1] - col_starts[0]\n\n if np.iscomplexobj(diag):\n real = diag.real\n imag = diag.imag\n else:\n real = float(np.real(diag))\n imag = 0.0\n # if real != 0.0:\n m1 = lil_matrix((rows, m))\n for i in range(rows):\n m1[i, i + col_starts[0]] = real\n m1 = m1.tocsr()\n\n if imag != 0.0:\n m2 = lil_matrix((rows, m))\n for i in range(rows):\n m2[i, i + col_starts[0]] = imag\n m2 = m2.tocsr()\n else:\n m2 = None\n return CHypreMat(m1, m2, )\n else:\n m1 = coo_matrix((m, m))\n m1.setdiag(np.zeros(m) + diag)\n return m1.tocsr()\n\n\ndef HStackPyVec(vecs, col_starts=None):\n '''\n horizontally stack vertical vectors to generate\n PyMat\n '''\n from scipy.sparse import csr_matrix\n if MFEM_PAR:\n from mpi4py import MPI\n comm = MPI.COMM_WORLD\n rows = vecs[0].GetPartitioningArray()\n if col_starts is None:\n col_starts = get_assumed_patitioning(len(vecs))\n\n isComplex = any([v.isComplex() for v in vecs])\n mat = np.hstack([np.atleast_2d(v.toarray()).transpose() for v in vecs])\n if isComplex:\n m1 = csr_matrix(mat.real)\n m2 = csr_matrix(mat.imag)\n else:\n m1 = csr_matrix(mat)\n m2 = None\n ret = CHypreMat(m1, m2, col_starts=col_starts)\n return ret\n else:\n return csr_matrix(np.hstack(vecs))\n\n\ndef PyVec2PyMat(vec, col_starts=None):\n from scipy.sparse import csr_matrix\n if MFEM_PAR:\n '''\n vec must be vertical\n '''\n assert not vec._horizontal, \"PyVec must be vertical\"\n\n from mpi4py import MPI\n comm = MPI.COMM_WORLD\n rows = vec.GetPartitioningArray()\n if col_starts is None:\n col_starts = get_assumed_patitioning(1)\n\n isComplex = vec.isComplex()\n mat = np.atleast_2d(vec.toarray()).transpose()\n\n if isComplex:\n m1 = csr_matrix(mat.real)\n m2 = csr_matrix(mat.imag)\n else:\n m1 = csr_matrix(mat)\n m2 = None\n # print m1.shape\n ret = CHypreMat(m1, m2, col_starts=col_starts)\n # print \"returning\", ret,\n return ret\n else:\n return csr_matrix(vec)\n"
] | [
[
"numpy.hstack",
"scipy.sparse.coo_matrix",
"numpy.imag",
"numpy.cumsum",
"scipy.sparse.csr_matrix",
"numpy.real",
"numpy.any",
"numpy.count_nonzero",
"numpy.iscomplexobj",
"numpy.array",
"numpy.zeros",
"numpy.sum",
"numpy.empty",
"scipy.sparse.lil_matrix"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16",
"1.8"
],
"tensorflow": []
}
] |
prabhatnagarajan/chainer | [
"3029bbaa587c15b3539b55ee1fd357a4149e5aed"
] | [
"chainer/functions/connection/convolution_2d.py"
] | [
"import numpy\n\nimport chainer\nfrom chainer import backend\nfrom chainer.backends import cuda\nfrom chainer.backends import intel64\nfrom chainer import configuration\nfrom chainer import function_node\nimport chainer.functions\nfrom chainer.utils import argument\nfrom chainer.utils import conv\nfrom chainer.utils import type_check\nimport chainerx\n\nif cuda.cudnn_enabled:\n _cudnn_version = cuda.cuda.cudnn.getVersion() # type: ignore\n\n\ndef _pair(x):\n if hasattr(x, '__getitem__'):\n return x\n return x, x\n\n\n# Used by deconvolution_2d.py.\n# TODO(beam2d): Unify matmul implementations\ndef _matmul(a, b):\n xp = backend.get_array_module(a)\n if not hasattr(xp, 'matmul'):\n # NumPy 1.9 does not support matmul. We use einsum instead.\n return xp.einsum('ijl,ilk->ijk', a, b)\n return xp.matmul(a, b)\n\n\nclass Convolution2DFunction(function_node.FunctionNode):\n\n _use_ideep = False\n\n def __init__(self, stride=1, pad=0, cover_all=False, **kwargs):\n dilate, groups = argument.parse_kwargs(\n kwargs, ('dilate', 1), ('groups', 1),\n deterministic='deterministic argument is not supported anymore. '\n 'Use chainer.using_config(\\'cudnn_deterministic\\', value) context '\n 'where value is either `True` or `False`.',\n requires_x_grad='requires_x_grad argument is not supported '\n 'anymore. Just remove the argument. Note that whether to compute '\n 'the gradient w.r.t. x is automatically decided during '\n 'backpropagation.')\n\n self.sy, self.sx = _pair(stride)\n self.ph, self.pw = _pair(pad)\n self.cover_all = cover_all\n self.dy, self.dx = _pair(dilate)\n self.groups = groups\n\n if self.dx < 1 or self.dy < 1:\n raise ValueError('Dilate should be positive, but {} is '\n 'supplied.'.format(dilate))\n\n def check_type_forward(self, in_types):\n n_in = in_types.size()\n type_check.expect(2 <= n_in, n_in <= 3)\n\n x_type = in_types[0]\n w_type = in_types[1]\n type_check.expect(\n x_type.dtype.kind == 'f',\n w_type.dtype.kind == 'f',\n x_type.ndim == 4,\n w_type.ndim == 4,\n x_type.shape[1] == w_type.shape[1] * self.groups,\n )\n\n if type_check.eval(n_in) == 3:\n b_type = in_types[2]\n type_check.expect(\n b_type.dtype == x_type.dtype,\n b_type.ndim == 1,\n b_type.shape[0] == w_type.shape[0],\n )\n\n def _get_out_size(self, inputs):\n x, W = inputs[:2]\n _, _, kh, kw = W.shape\n _, _, h, w = x.shape\n out_h = conv.get_conv_outsize(\n h, kh, self.sy, self.ph, cover_all=self.cover_all, d=self.dy)\n if out_h <= 0:\n raise RuntimeError('Height in the output should be positive.')\n out_w = conv.get_conv_outsize(\n w, kw, self.sx, self.pw, cover_all=self.cover_all, d=self.dx)\n if out_w <= 0:\n raise RuntimeError('Width in the output should be positive.')\n return out_h, out_w\n\n def forward_chainerx(self, inputs):\n # TODO(hvy): Support mixed precision.\n if any([arr.dtype != inputs[0].dtype for arr in inputs[1:]]):\n return chainer.Fallback\n # TODO(hvy): Support dilate > 1.\n if self.dy > 1 or self.dx > 1:\n return chainer.Fallback\n # TODO(hvy): Support groups > 1.\n if self.groups > 1:\n return chainer.Fallback\n if inputs[0].device.backend.name == 'cuda' and self.cover_all:\n return chainer.Fallback\n\n return chainerx.conv(\n *inputs, stride=(self.sy, self.sx), pad=(self.ph, self.pw),\n cover_all=self.cover_all),\n\n def forward_cpu(self, inputs):\n self.retain_inputs((0, 1)) # retain only x and W\n if len(inputs) == 2:\n (x, W), b = inputs, None\n else:\n x, W, b = inputs\n\n if (intel64.should_use_ideep('>=auto')\n and intel64.inputs_all_ready(inputs)):\n self._use_ideep = True\n\n if self.groups > 1:\n return self._forward_grouped_convolution(x, W, b)\n else:\n return self._forward_cpu_core(x, W, b)\n\n def _forward_cpu_core(self, x, W, b):\n if self._use_ideep:\n return self._forward_ideep(x, W, b)\n\n kh, kw = W.shape[2:]\n col = conv.im2col_cpu(\n x, kh, kw, self.sy, self.sx, self.ph, self.pw,\n cover_all=self.cover_all, dy=self.dy, dx=self.dx)\n y = numpy.tensordot(\n col, W, ((1, 2, 3), (1, 2, 3))).astype(x.dtype, copy=False)\n if b is not None:\n y += b\n y = numpy.rollaxis(y, 3, 1)\n return y,\n\n def _forward_ideep(self, x, W, b):\n out_c, input_c, kh, kw = W.shape\n n, c, h, w = x.shape\n\n out_h, out_w = self._get_out_size((x, W))\n pd = (self.sy * (out_h - 1)\n + (kh + (kh - 1) * (self.dy - 1)) - h - self.ph)\n pr = (self.sx * (out_w - 1)\n + (kw + (kw - 1) * (self.dx - 1)) - w - self.pw)\n param = intel64.ideep.convolution2DParam(\n (n, out_c, out_h, out_w),\n self.dy, self.dx,\n self.sy, self.sx,\n self.ph, self.pw,\n pd, pr)\n y = intel64.ideep.convolution2D.Forward(\n intel64.ideep.array(x),\n intel64.ideep.array(W),\n intel64.ideep.array(b) if b is not None else None,\n param)\n return y,\n\n def forward_gpu(self, inputs):\n self.retain_inputs((0, 1)) # retain only x and W\n if len(inputs) == 2:\n (x, W), b = inputs, None\n else:\n x, W, b = inputs\n\n out_c, _, kh, kw = W.shape\n n, _, h, w = x.shape\n\n out_h, out_w = self._get_out_size(inputs)\n y = cuda.cupy.empty((n, out_c, out_h, out_w), dtype=x.dtype)\n\n use_cudnn = (\n chainer.should_use_cudnn('>=auto')\n and not self.cover_all\n and x.dtype == W.dtype\n and ((self.dy == 1 and self.dx == 1) or _cudnn_version >= 6000)\n and (self.groups <= 1 or _cudnn_version >= 7000)\n )\n\n if use_cudnn:\n # cuDNN implementation\n return self._forward_cudnn(x, W, b, y)\n\n elif self.groups > 1:\n return self._forward_grouped_convolution(x, W, b)\n\n else:\n return self._forward_gpu_core(x, W, b)\n\n def _forward_gpu_core(self, x, W, b):\n kh, kw = W.shape[2:]\n # Implementation using im2col\n col = conv.im2col_gpu(\n x, kh, kw, self.sy, self.sx, self.ph, self.pw,\n cover_all=self.cover_all, dy=self.dy, dx=self.dx)\n y = cuda.cupy.tensordot(\n col, W, ((1, 2, 3), (1, 2, 3))).astype(x.dtype, copy=False)\n # TODO(beam2d): Support unshared bias\n if b is not None:\n y += b\n y = cuda.cupy.rollaxis(y, 3, 1)\n return y,\n\n def _forward_grouped_convolution(self, x, W, b):\n # G: group count\n # N: batch size\n # kH, kW: kernel height, kernel width\n # iC, iH, iW: input channels, input height, input width\n # oC, oH, oW: output channels, output height, output width\n G = self.groups\n N, iC, iH, iW = x.shape\n oC, _, kH, kW = W.shape # _ == iCg\n iCg = iC // G\n oCg = oC // G\n\n # (N, iC, kW, kW, oH, oW)\n x = conv.im2col(x, kH, kW, self.sy, self.sx, self.ph, self.pw,\n cover_all=self.cover_all, dy=self.dy, dx=self.dx)\n oH, oW = x.shape[-2:]\n\n x = x.transpose(1, 2, 3, 0, 4, 5) # (iC, kH, kW, N, oH, oW)\n x = x.reshape(G, iCg * kH * kW, N * oH * oW)\n\n W = W.reshape(G, oCg, iCg * kH * kW)\n\n # (G, oCg, N*oH*oW) = (G, oCg, iCg*kH*kW) @ (G, iCg*kH*kW, N*oH*oW)\n y = _matmul(W, x).astype(x.dtype, copy=False)\n y = y.reshape(oC, N, oH, oW)\n y = y.transpose(1, 0, 2, 3) # (N, oC, oH, oW)\n if b is not None:\n y += b.reshape(1, b.size, 1, 1)\n\n return y,\n\n def _forward_cudnn(self, x, W, b, y):\n pad = (self.ph, self.pw)\n stride = (self.sy, self.sx)\n dilation = (self.dy, self.dx)\n auto_tune = configuration.config.autotune\n tensor_core = configuration.config.use_cudnn_tensor_core\n cuda.cudnn.convolution_forward(\n x, W, b, y, pad, stride, dilation, self.groups,\n auto_tune=auto_tune, tensor_core=tensor_core)\n return y,\n\n def backward(self, indexes, grad_outputs):\n x, W = self.get_retained_inputs()\n gy, = grad_outputs\n\n ret = []\n if 0 in indexes:\n xh, xw = x.shape[2:]\n gx = chainer.functions.deconvolution_2d(\n gy, W, stride=(self.sy, self.sx), pad=(self.ph, self.pw),\n outsize=(xh, xw), dilate=(self.dy, self.dx),\n groups=self.groups)\n ret.append(gx)\n if 1 in indexes:\n gW, = Convolution2DGradW(self).apply((x, gy))\n ret.append(gW)\n if 2 in indexes:\n gb = chainer.functions.sum(gy, axis=(0, 2, 3))\n ret.append(gb)\n\n return ret\n\n\nclass Convolution2DGradW(function_node.FunctionNode):\n\n def __init__(self, conv2d):\n W_node = conv2d.inputs[1]\n self.kh, self.kw = W_node.shape[2:]\n self.sy = conv2d.sy\n self.sx = conv2d.sx\n self.ph = conv2d.ph\n self.pw = conv2d.pw\n self.dy = conv2d.dy\n self.dx = conv2d.dx\n self.cover_all = conv2d.cover_all\n self.W_dtype = W_node.dtype\n self.groups = conv2d.groups\n self._use_ideep = conv2d._use_ideep\n\n def forward_cpu(self, inputs):\n self.retain_inputs((0, 1))\n x, gy = inputs\n\n if self.groups > 1:\n return self._forward_grouped_convolution(x, gy)\n else:\n return self._forward_cpu_core(x, gy)\n\n def _forward_cpu_core(self, x, gy):\n if self._use_ideep:\n return self._forward_ideep(x, gy)\n\n # NumPy raises an error when the array is not contiguous.\n # See: https://github.com/chainer/chainer/issues/2744\n # TODO(niboshi): Remove this code when NumPy is fixed.\n if (not (gy.flags.c_contiguous or gy.flags.f_contiguous) and\n 1 in gy.shape):\n gy = numpy.ascontiguousarray(gy)\n\n col = conv.im2col_cpu(\n x, self.kh, self.kw, self.sy, self.sx, self.ph, self.pw,\n cover_all=self.cover_all, dy=self.dy, dx=self.dx)\n gW = numpy.tensordot(gy, col, ((0, 2, 3), (0, 4, 5))\n ).astype(self.W_dtype, copy=False)\n return gW,\n\n def _forward_ideep(self, x, gy):\n n, input_c, h, w = x.shape\n n, out_c, out_h, out_w = gy.shape\n pd = (self.sy * (out_h - 1)\n + (self.kh + (self.kh - 1) * (self.dy - 1))\n - h - self.ph)\n pr = (self.sx * (out_w - 1)\n + (self.kw + (self.kw - 1) * (self.dx - 1))\n - w - self.pw)\n\n param = intel64.ideep.convolution2DParam(\n (out_c, input_c, self.kh, self.kw),\n self.dy, self.dx,\n self.sy, self.sx,\n self.ph, self.pw,\n pd, pr)\n gW = intel64.ideep.convolution2D.BackwardWeights(\n intel64.ideep.array(x),\n intel64.ideep.array(gy),\n param)\n return gW,\n\n def forward_gpu(self, inputs):\n self.retain_inputs((0, 1))\n x, gy = inputs\n\n use_cudnn = (\n chainer.should_use_cudnn('>=auto')\n and not self.cover_all\n and x.dtype == self.W_dtype\n and ((self.dy == 1 and self.dx == 1)\n or (_cudnn_version >= 6000\n and not configuration.config.cudnn_deterministic))\n and (self.groups <= 1 or _cudnn_version >= 7000)\n )\n\n if use_cudnn:\n # cuDNN implementation\n return self._forward_cudnn(x, gy)\n\n elif self.groups > 1:\n return self._forward_grouped_convolution(x, gy)\n\n else:\n return self._forward_gpu_core(x, gy)\n\n def _forward_gpu_core(self, x, gy):\n col = conv.im2col_gpu(\n x, self.kh, self.kw, self.sy, self.sx, self.ph, self.pw,\n cover_all=self.cover_all, dy=self.dy, dx=self.dx)\n gW = cuda.cupy.tensordot(gy, col, ((0, 2, 3), (0, 4, 5))\n ).astype(self.W_dtype, copy=False)\n return gW,\n\n def _forward_grouped_convolution(self, x, gy):\n # G: group count\n # N: batch size\n # kH, kW: kernel height, kernel width\n # iC, iH, iW: input channels, input height, input width\n # oC, oH, oW: output channels, output height, output width\n G = self.groups\n N, iC, iH, iW = x.shape\n _, oC, oH, oW = gy.shape # _ == N\n kH = self.kh\n kW = self.kw\n iCg = iC // G\n oCg = oC // G\n\n # (N, iC, kH, kW, oH, oW)\n x = conv.im2col(x, kH, kW, self.sy, self.sx, self.ph, self.pw,\n cover_all=self.cover_all, dy=self.dy, dx=self.dx)\n\n x = x.transpose(1, 2, 3, 0, 4, 5) # (iC, kH, kW, N, oH, oW)\n x = x.reshape(G, iCg * kH * kW, N * oH * oW)\n x = x.transpose(0, 2, 1) # (G, N*oH*oW, iCg*kH*kW)\n\n gy = gy.transpose(1, 0, 2, 3) # (oC, N, oH, oW)\n gy = gy.reshape(G, oCg, N * oH * oW)\n\n # (G, oCg, iCg*kH*kW) = (G, oCg, N*oH*oW) @ (G, N*oH*oW, iCg*kH*kW)\n gW = _matmul(gy, x).astype(self.W_dtype, copy=False)\n gW = gW.reshape(oC, iCg, kH, kW)\n\n return gW,\n\n def _forward_cudnn(self, x, gy):\n _, out_c, out_h, out_w = gy.shape\n n, c, h, w = x.shape\n\n iC = c\n iCg = int(iC / self.groups)\n gW = cuda.cupy.empty((out_c, iCg, self.kh, self.kw),\n dtype=self.W_dtype)\n pad = (self.ph, self.pw)\n stride = (self.sy, self.sx)\n dilation = (self.dy, self.dx)\n deterministic = configuration.config.cudnn_deterministic\n auto_tune = configuration.config.autotune\n tensor_core = configuration.config.use_cudnn_tensor_core\n cuda.cudnn.convolution_backward_filter(\n x, gy, gW, pad, stride, dilation, self.groups,\n deterministic=deterministic, auto_tune=auto_tune,\n tensor_core=tensor_core)\n\n return gW,\n\n def backward(self, indexes, grad_outputs):\n x, gy = self.get_retained_inputs()\n ggW, = grad_outputs\n\n ret = []\n if 0 in indexes:\n xh, xw = x.shape[2:]\n gx = chainer.functions.deconvolution_2d(\n gy, ggW, stride=(self.sy, self.sx), pad=(self.ph, self.pw),\n outsize=(xh, xw), dilate=(self.dy, self.dx),\n groups=self.groups)\n ret.append(gx)\n if 1 in indexes:\n ggy = convolution_2d(\n x, ggW, stride=(self.sy, self.sx), pad=(self.ph, self.pw),\n cover_all=self.cover_all, dilate=(self.dy, self.dx),\n groups=self.groups)\n ret.append(ggy)\n\n return ret\n\n\ndef convolution_2d(x, W, b=None, stride=1, pad=0, cover_all=False, **kwargs):\n \"\"\"convolution_2d(x, W, b=None, stride=1, pad=0, cover_all=False, *, \\\ndilate=1, groups=1)\n\n Two-dimensional convolution function.\n\n This is an implementation of two-dimensional convolution in ConvNets.\n It takes three variables: the input image ``x``, the filter weight ``W``,\n and the bias vector ``b``.\n\n Notation: here is a notation for dimensionalities.\n\n - :math:`n` is the batch size.\n - :math:`c_I` and :math:`c_O` are the number of the input and output\n channels, respectively.\n - :math:`h_I` and :math:`w_I` are the height and width of the input image,\n respectively.\n - :math:`h_K` and :math:`w_K` are the height and width of the filters,\n respectively.\n - :math:`h_P` and :math:`w_P` are the height and width of the spatial\n padding size, respectively.\n\n Then the ``Convolution2D`` function computes correlations between filters\n and patches of size :math:`(h_K, w_K)` in ``x``.\n Note that correlation here is equivalent to the inner product between\n expanded vectors.\n Patches are extracted at positions shifted by multiples of ``stride`` from\n the first position ``(-h_P, -w_P)`` for each spatial axis.\n The right-most (or bottom-most) patches do not run over the padded spatial\n size.\n\n Let :math:`(s_Y, s_X)` be the stride of filter application. Then, the\n output size :math:`(h_O, w_O)` is determined by the following equations:\n\n .. math::\n\n h_O &= (h_I + 2h_P - h_K) / s_Y + 1,\\\\\\\\\n w_O &= (w_I + 2w_P - w_K) / s_X + 1.\n\n If ``cover_all`` option is ``True``, the filter will cover the all\n spatial locations. So, if the last stride of filter does not cover the\n end of spatial locations, an additional stride will be applied to the end\n part of spatial locations. In this case, the output size :math:`(h_O, w_O)`\n is determined by the following equations:\n\n .. math::\n\n h_O &= (h_I + 2h_P - h_K + s_Y - 1) / s_Y + 1,\\\\\\\\\n w_O &= (w_I + 2w_P - w_K + s_X - 1) / s_X + 1.\n\n If the bias vector is given, then it is added to all spatial locations of\n the output of convolution.\n\n The output of this function can be non-deterministic when it uses cuDNN.\n If ``chainer.configuration.config.cudnn_deterministic`` is ``True`` and\n cuDNN version is >= v3, it forces cuDNN to use a deterministic algorithm.\n\n Convolution links can use a feature of cuDNN called autotuning, which\n selects the most efficient CNN algorithm for images of fixed-size,\n can provide a significant performance boost for fixed neural nets.\n To enable, set `chainer.using_config('autotune', True)`\n\n When the dilation factor is greater than one, cuDNN is not used unless\n the version is 6.0 or higher.\n\n Args:\n x (:class:`~chainer.Variable` or :ref:`ndarray`):\n Input variable of shape :math:`(n, c_I, h_I, w_I)`.\n W (:class:`~chainer.Variable` or :ref:`ndarray`):\n Weight variable of shape :math:`(c_O, c_I, h_K, w_K)`.\n b (None or :class:`~chainer.Variable` or :ref:`ndarray`):\n Bias variable of length :math:`c_O` (optional).\n stride (:class:`int` or pair of :class:`int` s):\n Stride of filter applications. ``stride=s`` and ``stride=(s, s)``\n are equivalent.\n pad (:class:`int` or pair of :class:`int` s):\n Spatial padding width for input arrays.\n ``pad=p`` and ``pad=(p, p)`` are equivalent.\n cover_all (:class:`bool`):\n If ``True``, all spatial locations are convoluted into some output\n pixels.\n dilate (:class:`int` or pair of :class:`int` s):\n Dilation factor of filter applications.\n ``dilate=d`` and ``dilate=(d, d)`` are equivalent.\n groups (:class:`int`): Number of groups of channels. If the number\n is greater than 1, input tensor :math:`W` is divided into some\n blocks by this value. For each tensor blocks, convolution\n operation will be executed independently. Input channel size\n :math:`c_I` and output channel size :math:`c_O` must be exactly\n divisible by this value.\n\n Returns:\n ~chainer.Variable:\n Output variable of shape :math:`(n, c_O, h_O, w_O)`.\n\n .. seealso:: :class:`~chainer.links.Convolution2D`\n\n .. admonition:: Example\n\n >>> n = 10\n >>> c_i, c_o = 3, 1\n >>> h_i, w_i = 30, 40\n >>> h_k, w_k = 10, 10\n >>> h_p, w_p = 5, 5\n >>> x = np.random.uniform(0, 1, (n, c_i, h_i, w_i)).astype(np.float32)\n >>> x.shape\n (10, 3, 30, 40)\n >>> W = np.random.uniform(0, 1, (c_o, c_i, h_k, w_k)).\\\nastype(np.float32)\n >>> W.shape\n (1, 3, 10, 10)\n >>> b = np.random.uniform(0, 1, (c_o,)).astype(np.float32)\n >>> b.shape\n (1,)\n >>> s_y, s_x = 5, 7\n >>> y = F.convolution_2d(x, W, b, stride=(s_y, s_x), pad=(h_p, w_p))\n >>> y.shape\n (10, 1, 7, 6)\n >>> h_o = int((h_i + 2 * h_p - h_k) / s_y + 1)\n >>> w_o = int((w_i + 2 * w_p - w_k) / s_x + 1)\n >>> y.shape == (n, c_o, h_o, w_o)\n True\n >>> y = F.convolution_2d(x, W, b, stride=(s_y, s_x), pad=(h_p, w_p), \\\ncover_all=True)\n >>> y.shape == (n, c_o, h_o, w_o + 1)\n True\n\n \"\"\"\n dilate, groups = argument.parse_kwargs(\n kwargs, ('dilate', 1), ('groups', 1),\n deterministic='deterministic argument is not supported anymore. '\n 'Use chainer.using_config(\\'cudnn_deterministic\\', value) '\n 'context where value is either `True` or `False`.')\n\n fnode = Convolution2DFunction(stride, pad, cover_all, dilate=dilate,\n groups=groups)\n if b is None:\n args = x, W\n else:\n args = x, W, b\n y, = fnode.apply(args)\n return y\n"
] | [
[
"numpy.rollaxis",
"numpy.tensordot",
"numpy.ascontiguousarray"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
muyiguangda/tensorflow-keras-yolov3 | [
"04a873529e9941a576e7058e47f8991d188ba15b"
] | [
"train.py"
] | [
"\"\"\"\n@authors: Hulking\nApril 2019\n\"\"\"\n\nimport numpy as np\nimport keras.backend as K\nfrom keras.layers import Input, Lambda\nfrom keras.models import Model\nfrom keras.optimizers import Adam\nfrom keras.callbacks import TensorBoard, ModelCheckpoint, ReduceLROnPlateau, EarlyStopping\n\nfrom yolo3.model import preprocess_true_boxes, yolo_body, tiny_yolo_body, yolo_loss\nfrom yolo3.utils import get_random_data\n\n\"\"\"\n训练流程\n\"\"\"\ndef _main():\n annotation_path = 'train.txt'\n log_dir = 'logs/000/'\n classes_path = 'model_data/voc_classes.txt'\n anchors_path = 'model_data/yolo_anchors.txt'\n class_names = get_classes(classes_path)\n num_classes = len(class_names)\n anchors = get_anchors(anchors_path)\n\n input_shape = (416,416) # multiple of 32, hw\n\n is_tiny_version = len(anchors)==6 # default setting\n if is_tiny_version:\n model = create_tiny_model(input_shape, anchors, num_classes,\n freeze_body=2, weights_path='model_data/tiny_yolo_weights.h5')\n else:\n model = create_model(input_shape, anchors, num_classes,\n freeze_body=2, weights_path='model_data/yolo_weights.h5') # make sure you know what you freeze\n\n logging = TensorBoard(log_dir=log_dir)\n checkpoint = ModelCheckpoint(log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5',\n monitor='val_loss', save_weights_only=True, save_best_only=True, period=3)\n reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1)\n early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1)\n\n val_split = 0.1\n with open(annotation_path) as f:\n lines = f.readlines()\n np.random.seed(10101)\n np.random.shuffle(lines)\n np.random.seed(None)\n num_val = int(len(lines)*val_split)\n num_train = len(lines) - num_val\n\n # Train with frozen layers first, to get a stable loss.\n # Adjust num epochs to your dataset. This step is enough to obtain a not bad model.\n if True:\n model.compile(optimizer=Adam(lr=1e-3), loss={\n # use custom yolo_loss Lambda layer.\n 'yolo_loss': lambda y_true, y_pred: y_pred})\n\n batch_size = 32\n print('Train on {} samples, val on {} samples, with batch size {}.'.format(num_train, num_val, batch_size))\n model.fit_generator(data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes),\n steps_per_epoch=max(1, num_train//batch_size),\n validation_data=data_generator_wrapper(lines[num_train:], batch_size, input_shape, anchors, num_classes),\n validation_steps=max(1, num_val//batch_size),\n epochs=50,\n initial_epoch=0,\n callbacks=[logging, checkpoint])\n model.save_weights(log_dir + 'trained_weights_stage_1.h5')\n\n # Unfreeze and continue training, to fine-tune.\n # Train longer if the result is not good.\n if True:\n for i in range(len(model.layers)):\n model.layers[i].trainable = True\n model.compile(optimizer=Adam(lr=1e-4), loss={'yolo_loss': lambda y_true, y_pred: y_pred}) # recompile to apply the change\n print('Unfreeze all of the layers.')\n\n batch_size = 32 # note that more GPU memory is required after unfreezing the body\n print('Train on {} samples, val on {} samples, with batch size {}.'.format(num_train, num_val, batch_size))\n model.fit_generator(data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes),\n steps_per_epoch=max(1, num_train//batch_size),\n validation_data=data_generator_wrapper(lines[num_train:], batch_size, input_shape, anchors, num_classes),\n validation_steps=max(1, num_val//batch_size),\n epochs=100,\n initial_epoch=50,\n callbacks=[logging, checkpoint, reduce_lr, early_stopping])\n model.save_weights(log_dir + 'trained_weights_final.h5')\n\n # Further training if needed.\n\n\"\"\"\n获取类别\n\"\"\"\ndef get_classes(classes_path):\n '''loads the classes'''\n with open(classes_path) as f:\n class_names = f.readlines()\n class_names = [c.strip() for c in class_names]\n return class_names\n\"\"\"\n获取锚点\n\"\"\"\ndef get_anchors(anchors_path):\n '''loads the anchors from a file'''\n with open(anchors_path) as f:\n anchors = f.readline()\n anchors = [float(x) for x in anchors.split(',')]\n return np.array(anchors).reshape(-1, 2)\n\n\"\"\"\n创建模型\n\"\"\"\ndef create_model(input_shape, anchors, num_classes, load_pretrained=True, freeze_body=2,\n weights_path='model_data/yolo_weights.h5'):\n '''create the training model'''\n K.clear_session() # get a new session\n image_input = Input(shape=(None, None, 3))\n h, w = input_shape\n num_anchors = len(anchors)\n\n y_true = [Input(shape=(h//{0:32, 1:16, 2:8}[l], w//{0:32, 1:16, 2:8}[l], \\\n num_anchors//3, num_classes+5)) for l in range(3)]\n\n model_body = yolo_body(image_input, num_anchors//3, num_classes)\n print('Create YOLOv3 model with {} anchors and {} classes.'.format(num_anchors, num_classes))\n\n if load_pretrained:\n model_body.load_weights(weights_path, by_name=True, skip_mismatch=True)\n print('Load weights {}.'.format(weights_path))\n if freeze_body in [1, 2]:\n # Freeze darknet53 body or freeze all but 3 output layers.\n num = (185, len(model_body.layers)-3)[freeze_body-1]\n for i in range(num): model_body.layers[i].trainable = False\n print('Freeze the first {} layers of total {} layers.'.format(num, len(model_body.layers)))\n\n model_loss = Lambda(yolo_loss, output_shape=(1,), name='yolo_loss',\n arguments={'anchors': anchors, 'num_classes': num_classes, 'ignore_thresh': 0.5})(\n [*model_body.output, *y_true])\n model = Model([model_body.input, *y_true], model_loss)\n\n return model\n\"\"\"\n创建阉割版模型\n\"\"\"\ndef create_tiny_model(input_shape, anchors, num_classes, load_pretrained=True, freeze_body=2,\n weights_path='model_data/tiny_yolo_weights.h5'):\n '''create the training model, for Tiny YOLOv3'''\n K.clear_session() # get a new session\n image_input = Input(shape=(None, None, 3))\n h, w = input_shape\n num_anchors = len(anchors)\n\n y_true = [Input(shape=(h//{0:32, 1:16}[l], w//{0:32, 1:16}[l], \\\n num_anchors//2, num_classes+5)) for l in range(2)]\n\n model_body = tiny_yolo_body(image_input, num_anchors//2, num_classes)\n print('Create Tiny YOLOv3 model with {} anchors and {} classes.'.format(num_anchors, num_classes))\n\n if load_pretrained:\n model_body.load_weights(weights_path, by_name=True, skip_mismatch=True)\n print('Load weights {}.'.format(weights_path))\n if freeze_body in [1, 2]:\n # Freeze the darknet body or freeze all but 2 output layers.\n num = (20, len(model_body.layers)-2)[freeze_body-1]\n for i in range(num): model_body.layers[i].trainable = False\n print('Freeze the first {} layers of total {} layers.'.format(num, len(model_body.layers)))\n\n model_loss = Lambda(yolo_loss, output_shape=(1,), name='yolo_loss',\n arguments={'anchors': anchors, 'num_classes': num_classes, 'ignore_thresh': 0.7})(\n [*model_body.output, *y_true])\n model = Model([model_body.input, *y_true], model_loss)\n\n return model\n\"\"\"\n真值数据生成\n\"\"\"\ndef data_generator(annotation_lines, batch_size, input_shape, anchors, num_classes):\n '''data generator for fit_generator'''\n n = len(annotation_lines)\n i = 0\n while True:\n image_data = []\n box_data = []\n for b in range(batch_size):\n if i==0:\n np.random.shuffle(annotation_lines)\n image, box = get_random_data(annotation_lines[i], input_shape, random=True)\n image_data.append(image)\n box_data.append(box)\n i = (i+1) % n\n image_data = np.array(image_data)\n box_data = np.array(box_data)\n y_true = preprocess_true_boxes(box_data, input_shape, anchors, num_classes)\n yield [image_data, *y_true], np.zeros(batch_size)\n\ndef data_generator_wrapper(annotation_lines, batch_size, input_shape, anchors, num_classes):\n n = len(annotation_lines)\n if n==0 or batch_size<=0: return None\n return data_generator(annotation_lines, batch_size, input_shape, anchors, num_classes)\n\nif __name__ == '__main__':\n _main()\n"
] | [
[
"numpy.random.shuffle",
"numpy.array",
"numpy.zeros",
"numpy.random.seed"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
rflperry/mvlearn | [
"8db0f63a0a811d7458aa0bd6b187f9f551241927"
] | [
"mvlearn/semi_supervised/ctclassifier.py"
] | [
"# License: MIT\n#\n# Implements multi-view co-training classification for 2-view data.\n\nimport numpy as np\nfrom sklearn.naive_bayes import GaussianNB\n\nfrom .base import BaseCoTrainEstimator\nfrom ..utils.utils import check_Xs, check_Xs_y_nan_allowed\n\n\nclass CTClassifier(BaseCoTrainEstimator):\n r\"\"\"\n This class implements the co-training classifier for supervised and\n semi-supervised learning with the framework as described in [#1CTC]_.\n The best use case is when the 2 views of input data are sufficiently\n distinct and independent as detailed in [#1CTC]_. However, this can\n also be successful when a single matrix of input data is given as\n both views and two estimators are chosen which are quite different.\n [#2CTC]_. See the examples below.\n\n In the semi-supervised case, performance can vary greatly, so using\n a separate validation set or cross validation procedure is\n recommended to ensure the classifier has fit well.\n\n Parameters\n ----------\n estimator1 : classifier object, (default=sklearn GaussianNB)\n The classifier object which will be trained on view 1 of the data.\n This classifier should support the predict_proba() function so that\n classification probabilities can be computed and co-training can be\n performed effectively.\n\n estimator2 : classifier object, (default=sklearn GaussianNB)\n The classifier object which will be trained on view 2 of the data.\n Does not need to be of the same type as ``estimator1``, but should\n support predict_proba().\n\n p : int, optional (default=None)\n The number of positive classifications from the unlabeled_pool\n training set which will be given a positive \"label\". If None, the\n default is the floor of the ratio of positive to negative examples\n in the labeled training data (at least 1). If only one of ``p`` or\n ``n`` is not None, the other will be set to be the same. When the\n labels are 0 or 1, positive is defined as 1, and in general, positive\n is the larger label.\n\n n : int, optional (default=None)\n The number of negative classifications from the unlabeled_pool\n training set which will be given a negative \"label\". If None, the\n default is the floor of the ratio of positive to negative examples\n in the labeled training data (at least 1). If only one of ``p`` or\n ``n`` is not None, the other will be set to be the same. When the\n labels are 0 or 1, negative is defined as 0, and in general, negative\n is the smaller label.\n\n unlabeled_pool_size : int, optional (default=75)\n The number of unlabeled_pool samples which will be kept in a\n separate pool for classification and selection by the updated\n classifier at each training iteration.\n\n num_iter : int, optional (default=50)\n The maximum number of training iterations to run.\n\n random_state : int (default=None)\n The starting random seed for fit() and class operations, passed to\n numpy.random.seed().\n\n Attributes\n ----------\n estimator1_ : classifier object\n The classifier used on view 1.\n\n estimator2_ : classifier object\n The classifier used on view 2.\n\n class_name_: string\n The name of the class.\n\n p_ : int, optional (default=None)\n The number of positive classifications from the unlabeled_pool\n training set which will be given a positive \"label\" each round.\n\n n_ : int, optional (default=None)\n The number of negative classifications from the unlabeled_pool\n training set which will be given a negative \"label\" each round.\n\n classes_ : array-like of shape (n_classes,)\n Unique class labels.\n\n Examples\n --------\n >>> # Supervised learning of single-view data with 2 distinct estimators\n >>> from mvlearn.semi_supervised import CTClassifier\n >>> from mvlearn.datasets import load_UCImultifeature\n >>> import numpy as np\n >>> from sklearn.ensemble import RandomForestClassifier\n >>> from sklearn.naive_bayes import GaussianNB\n >>> from sklearn.model_selection import train_test_split\n >>> data, labels = load_UCImultifeature(select_labeled=[0,1])\n >>> X1 = data[0] # Only using the first view\n >>> X1_train, X1_test, l_train, l_test = train_test_split(X1, labels)\n\n >>> # Supervised learning with a single view of data and 2 estimator types\n >>> estimator1 = GaussianNB()\n >>> estimator2 = RandomForestClassifier()\n >>> ctc = CTClassifier(estimator1, estimator2, random_state=1)\n >>> # Use the same matrix for each view\n >>> ctc = ctc.fit([X1_train, X1_train], l_train)\n >>> preds = ctc.predict([X1_test, X1_test])\n >>> print(\"Accuracy: \", sum(preds==l_test) / len(preds))\n Accuracy: 0.97\n\n Notes\n -----\n Multi-view co-training is most helpful for tasks in semi-supervised\n learning where each view offers unique information not seen in the\n other. As is shown in the example notebooks for using this algorithm,\n multi-view co-training can provide good classification results even\n when number of unlabeled samples far exceeds the number of labeled\n samples. This classifier uses 2 classifiers which work individually\n on each view but which share information and thus result in improved\n performance over looking at the views completely separately or even\n when concatenating the views to get more features in a single-view\n setting. The classifier can be initialized with or without the\n classifiers desired for each view being specified, but if the\n classifier for a certain view is specified, then it must support a\n predict_proba() method in order to give a sense of the most likely labels\n for different examples. This is because the algorithm must be able to\n determine which of the training samples it is most confident about during\n training epochs. The algorithm, as first proposed by Blum and Mitchell,\n is described in detail below.\n\n *Algorithm*\n\n Given:\n\n * a set *L* of labeled training samples (with 2 views)\n * a set *U* of unlabeled samples (with 2 views)\n\n Create a pool *U'* of examples by choosing *u* examples at random\n from *U*\n\n Loop for *k* iterations\n\n * Use *L* to train a classifier *h1* (``estimator1``) that considers\n only the view 1 portion of the data (i.e. Xs[0])\n * Use *L* to train a classifier *h2* (``estimator2``) that considers\n only the view 2 portion of the data (i.e. Xs[1])\n * Allow *h1* to label *p* (``self.p_``) positive and *n* (``self.n_``)\n negative samples from view 1 of *U'*\n * Allow *h2* to label *p* positive and *n* negative samples\n from view 2 of *U'*\n * Add these self-labeled samples to *L*\n * Randomly take 2*p* + 2*n* samples from *U* to replenish *U'*\n\n References\n ----------\n .. [#1CTC] Blum, A., and Mitchell, T. \"Combining labeled and unlabeled\n data with co-training.\" In Proceedings of the Eleventh Annual\n Conference on Computational Learning Theory, pages 92–100, 1998.\n\n .. [#2CTC] Goldman, Sally, and Yan Zhou. \"Enhancing supervised\n learning with unlabeled data.\" In Proceedings of the Eleventh\n Annual Conference on Computational Learning Theory, 2000.\n\n \"\"\"\n\n def __init__(self,\n estimator1=None,\n estimator2=None,\n p=None,\n n=None,\n unlabeled_pool_size=75,\n num_iter=50,\n random_state=None\n ):\n\n # initialize a BaseCTEstimator object\n super().__init__(estimator1, estimator2, random_state)\n\n # if not given, set classifiers as gaussian naive bayes estimators\n if self.estimator1_ is None:\n self.estimator1_ = GaussianNB()\n if self.estimator2_ is None:\n self.estimator2_ = GaussianNB()\n\n # If only 1 of p or n is not None, set them equal\n if (p is not None and n is None):\n n = p\n self.p_, self.n_ = p, n\n elif (p is None and n is not None):\n p = n\n self.p_, self.n_ = p, n\n else:\n self.p_, self.n_ = p, n\n\n self.n_views = 2 # only 2 view learning supported currently\n self.class_name_ = \"CTClassifier\"\n self.unlabeled_pool_size = unlabeled_pool_size\n self.num_iter = num_iter\n\n self._check_params()\n\n def _check_params(self):\n r\"\"\"\n Checks that cotraining parameters are valid. Throws AttributeError\n if estimators are invalid. Throws ValueError if any other parameters\n are not valid. The checks performed are:\n - estimator1 and estimator2 have predict_proba methods\n - p and n are both positive\n - unlabeled_pool_size is positive\n - num_iter is positive\n \"\"\"\n\n # verify that estimator1 and estimator2 have predict_proba\n if (not hasattr(self.estimator1_, 'predict_proba') or\n not hasattr(self.estimator2_, 'predict_proba')):\n raise AttributeError(\"Co-training classifier must be initialized \"\n \"with classifiers supporting \"\n \"predict_proba().\")\n\n if (self.p_ is not None and self.p_ <= 0) or (self.n_ is not None and\n self.n_ <= 0):\n raise ValueError(\"Both p and n must be positive.\")\n\n if self.unlabeled_pool_size <= 0:\n raise ValueError(\"unlabeled_pool_size must be positive.\")\n\n if self.num_iter <= 0:\n raise ValueError(\"num_iter must be positive.\")\n\n def fit(self, Xs, y):\n r\"\"\"\n Fit the classifier object to the data in Xs, y.\n\n Parameters\n ----------\n Xs : list of array-likes or numpy.ndarray\n - Xs length: n_views\n - Xs[i] shape: (n_samples, n_features_i)\n A list of the different views of data to train on.\n\n y : array, shape (n_samples,)\n The labels of the training data. Unlabeled examples should\n have label np.nan.\n\n Returns\n -------\n self : returns an instance of self\n \"\"\"\n\n # verify Xs and y\n Xs, y = check_Xs_y_nan_allowed(Xs,\n y,\n multiview=True,\n enforce_views=self.n_views,\n max_classes=2, min_classes=1)\n\n y = np.array(y)\n if self.random_state is not None:\n np.random.seed(self.random_state)\n\n self.classes_ = list(set(y[~np.isnan(y)]))\n self.n_classes = len(self.classes_)\n\n # extract the multiple views given\n X1 = Xs[0]\n X2 = Xs[1]\n\n # if don't have 2 classes of labeled data, then just fit and return,\n # since can't do any iterations of cotraining\n if self.n_classes > 1:\n\n # if both p & n are none, set as ratio of one class to the other\n if (self.p_ is None and self.n_ is None):\n num_class_n = sum(1 for y_n in y if y_n == self.classes_[0])\n num_class_p = sum(1 for y_p in y if y_p == self.classes_[1])\n p_over_n_ratio = num_class_p // num_class_n\n if p_over_n_ratio > 1:\n self.p_, self.n_ = p_over_n_ratio, 1\n else:\n self.n_, self.p_ = num_class_n // num_class_p, 1\n\n # the full set of unlabeled samples\n U = [i for i, y_i in enumerate(y) if np.isnan(y_i)]\n\n # shuffle unlabeled_pool data for easy random access\n np.random.shuffle(U)\n\n # the small pool of unlabled samples to draw from in training\n unlabeled_pool = U[-min(len(U), self.unlabeled_pool_size):]\n\n # the labeled samples\n L = [i for i, y_i in enumerate(y) if ~np.isnan(y_i)]\n\n # remove the pool from overall unlabeled data\n U = U[:-len(unlabeled_pool)]\n\n # number of rounds of co-training\n it = 0\n\n # machine epsilon\n eps = np.finfo(float).eps\n\n while it < self.num_iter and U:\n it += 1\n\n # fit each model to its respective view\n self.estimator1_.fit(X1[L], y[L])\n self.estimator2_.fit(X2[L], y[L])\n\n # predict log probability for greater spread in confidence\n\n y1_prob = np.log(self.estimator1_.\n predict_proba(X1[unlabeled_pool]) + eps)\n y2_prob = np.log(self.estimator2_.\n predict_proba(X2[unlabeled_pool]) + eps)\n\n n, p = [], []\n\n # take the most confident labeled examples from the\n # unlabeled pool in each category and put them in L\n for i in (y1_prob[:, 0].argsort())[-self.n_:]:\n if y1_prob[i, 0] > np.log(0.5):\n n.append(i)\n for i in (y1_prob[:, 1].argsort())[-self.p_:]:\n if y1_prob[i, 1] > np.log(0.5):\n p.append(i)\n for i in (y2_prob[:, 0].argsort())[-self.n_:]:\n if y2_prob[i, 0] > np.log(0.5):\n n.append(i)\n for i in (y2_prob[:, 1].argsort())[-self.p_:]:\n if y2_prob[i, 1] > np.log(0.5):\n p.append(i)\n\n # create new labels for new additions to the labeled group\n y[[unlabeled_pool[x] for x in n]] = self.classes_[0]\n y[[unlabeled_pool[x] for x in p]] = self.classes_[1]\n L.extend([unlabeled_pool[x] for x in p])\n L.extend([unlabeled_pool[x] for x in n])\n\n # remove newly labeled samples from unlabeled_pool\n unlabeled_pool = [elem for elem in unlabeled_pool\n if not (elem in p or elem in n)]\n\n # add new elements to unlabeled_pool\n add_counter = 0\n num_to_add = len(p) + len(n)\n while add_counter != num_to_add and U:\n add_counter += 1\n unlabeled_pool.append(U.pop())\n\n # if only had 1 class in the labeled examples\n else:\n # the labeled sample indices\n L = [i for i, y_i in enumerate(y) if ~np.isnan(y_i)]\n\n # fit the overall model on fully \"labeled\" data\n self.estimator1_.fit(X1[L], y[L])\n self.estimator2_.fit(X2[L], y[L])\n\n return self\n\n def predict(self, Xs):\n r\"\"\"\n Predict the classes of the examples in the two input views.\n\n Parameters\n ----------\n Xs : list of array-likes or numpy.ndarray\n - Xs length: n_views\n - Xs[i] shape: (n_samples, n_features_i)\n A list of the different views of data to predict.\n\n Returns\n -------\n y_pred : array-like (n_samples,)\n The predicted class of each input example. If the two classifiers\n don't agree, pick the one with the highest predicted probability\n from predict_proba().\n \"\"\"\n\n Xs = check_Xs(Xs,\n multiview=True,\n enforce_views=self.n_views)\n\n X1 = Xs[0]\n X2 = Xs[1]\n\n # predict each view independently\n y1 = self.estimator1_.predict(X1)\n y2 = self.estimator2_.predict(X2)\n\n # initialize\n y_pred = np.zeros(X1.shape[0],)\n\n # predict samples based on trained classifiers\n for i, (y1_i, y2_i) in enumerate(zip(y1, y2)):\n # if classifiers agree, use their prediction\n if y1_i == y2_i:\n y_pred[i] = y1_i\n # if classifiers don't agree, take the more confident\n else:\n y1_probs = self.estimator1_.predict_proba([X1[i]])[0]\n y2_probs = self.estimator2_.predict_proba([X2[i]])[0]\n sum_y_probs = [prob1 + prob2 for (prob1, prob2) in\n zip(y1_probs, y2_probs)]\n max_sum_prob = max(sum_y_probs)\n y_pred[i] = self.classes_[sum_y_probs.index(max_sum_prob)]\n\n return y_pred\n\n def predict_proba(self, Xs):\n r\"\"\"\n Predict the probability of each example belonging to a each class.\n\n Parameters\n ----------\n Xs : list of array-likes or numpy.ndarray\n - Xs length: n_views\n - Xs[i] shape: (n_samples, n_features_i)\n A list of the different views of data to predict.\n\n Returns\n -------\n y_proba : array-like (n_samples, n_classes)\n The probability of each sample being in each class.\n \"\"\"\n\n Xs = check_Xs(Xs,\n multiview=True,\n enforce_views=self.n_views)\n\n X1 = Xs[0]\n X2 = Xs[1]\n\n # predict each probability independently\n y1_proba = self.estimator1_.predict_proba(X1)\n y2_proba = self.estimator2_.predict_proba(X2)\n # return the average probability for the sample\n return (y1_proba + y2_proba) * .5\n"
] | [
[
"numpy.log",
"sklearn.naive_bayes.GaussianNB",
"numpy.random.seed",
"numpy.isnan",
"numpy.random.shuffle",
"numpy.finfo",
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Obarads/torch_point_cloud | [
"86e19cc5c1196f22f609f2d98504b913272cbba8"
] | [
"examples/function_and_class/knn.py"
] | [
"import numpy as np\n\nimport torch\nfrom torch.utils.data import DataLoader\n\n# local package\nfrom libs import tpcpath\nfrom libs.dataset import SimpleSceneDataset\nfrom libs.three_nn import three_nn # PointRCNN\n\n# torch-points-kernels\nimport torch_points_kernels as tpk\n\n# torchpcp pacakage\nfrom torchpcp.modules.functional.other import index2points\nfrom torchpcp.modules.functional.sampling import furthest_point_sampling\nfrom torchpcp.modules.functional import nns\nfrom torchpcp.utils.monitor import timecheck\nfrom torchpcp.utils import pytorch_tools\n\n# pytorch_tools.set_seed(0)\ndevice = pytorch_tools.select_device(\"cuda\")\n\ndef speed_test(method, loader):\n for i, data in enumerate(loader): pass # for speed processing\n \n # print name\n if method == 0:\n t_name = \"original c++ impl. time\"\n elif method == 1:\n t_name = \"original py impl. time\"\n elif method == 2:\n t_name = \"other c++ impl. time\"\n elif method == 3:\n t_name = \"tpk impl. time\"\n else:\n raise NotImplementedError()\n\n # timer start\n t = timecheck()\n for _ in range(100):\n for i, data in enumerate(loader):\n point_clouds, sem_labels, ins_labels = data\n point_clouds = torch.transpose(point_clouds[:, :, :3].to(device), 1, 2)\n center_idxs = furthest_point_sampling(point_clouds, 1024)\n center_pc = index2points(point_clouds, center_idxs)\n if method == 0:\n pred, _ = nns.k_nearest_neighbors(center_pc, point_clouds, k=3)\n elif method == 1:\n pred, _ = nns.py_k_nearest_neighbors(center_pc, point_clouds, k=3, memory_saving=False)\n elif method == 2:\n pred = three_nn(center_pc.transpose(1,2).contiguous(), point_clouds.transpose(1,2).contiguous())\n elif method == 3:\n pred, _ = tpk.knn(point_clouds.transpose(1,2).contiguous(), center_pc.transpose(1,2).contiguous(), 3)\n else:\n raise NotImplementedError()\n # timer end\n timecheck(t, t_name)\n\n gt, _ = nns.py_k_nearest_neighbors(center_pc, point_clouds, k=3, memory_saving=False)\n\n print(False in (pred == gt))\n\nnp.set_printoptions(threshold=np.inf)\ntorch.set_printoptions(threshold=np.inf)\n\n# get dataset\ndataset = SimpleSceneDataset()\npoints, sem_label, ins_label = dataset[0]\npc = torch.tensor([points[:, :3]], device=\"cuda\").transpose(1,2)\n\n# compare knn\nk = 20\nidx, dist = nns.k_nearest_neighbors(pc, pc, k)\nidx2, dist2 = nns.py_k_nearest_neighbors(pc, pc, k)\ncheck_idx = idx == idx2\nif True:\n for ib in range(len(check_idx)):\n b_idxs = check_idx[ib]\n for i_n in range(len(b_idxs)):\n n_idxs = b_idxs[i_n]\n if False in n_idxs:\n for i_p in range(len(n_idxs)):\n k_idxs = n_idxs[i_p]\n if False == k_idxs:\n print(\"pyknn ib {}, in {}, ip {} dist {} idx {}\".format(ib, i_n, i_p, dist[ib, i_n, i_p], idx[ib, i_n, i_p]))\n # print(\"pybq and dist2 {}\".format(dist[ib, i_n, i_p]))\n print(\"dist {} idx {}\".format(dist2[ib, i_n, i_p], idx2[ib, i_n, i_p]))\n # else:\n # print(\"pyknn ib {}, in {}, ip {} dist {} idx {}\".format(ib, i_n, i_p, dist[ib, i_n, i_p], idx[ib, i_n, i_p]))\nprint(\"CHECK1:\", False in (check_idx))\n\n# ↑ result (a part)\n\"\"\"\npyknn ib 0, in 3397, ip 5 dist 0.0005849996232427657 idx 2927\ndist 0.0005850791931152344 idx 542\npyknn ib 0, in 3398, ip 10 dist 0.009334004484117031 idx 3892\ndist 0.00933384895324707 idx 1082\npyknn ib 0, in 3398, ip 11 dist 0.009334005415439606 idx 1082\ndist 0.00933384895324707 idx 3892\npyknn ib 0, in 3402, ip 6 dist 0.01157099287956953 idx 1313\ndist 0.011570453643798828 idx 2092\npyknn ib 0, in 3402, ip 7 dist 0.01157099287956953 idx 2092\ndist 0.011570453643798828 idx 1313\npyknn ib 0, in 3402, ip 9 dist 0.013051005080342293 idx 2169\ndist 0.013050079345703125 idx 2962\npyknn ib 0, in 3402, ip 10 dist 0.013051005080342293 idx 2962\ndist 0.013050079345703125 idx 2169\npyknn ib 0, in 3402, ip 14 dist 0.019140997901558876 idx 128\ndist 0.019140243530273438 idx 1118\npyknn ib 0, in 3402, ip 15 dist 0.019140997901558876 idx 1118\ndist 0.019140243530273438 idx 128\npyknn ib 0, in 3403, ip 2 dist 0.0013459994224831462 idx 3251\ndist 0.001345992088317871 idx 3264\npyknn ib 0, in 3403, ip 3 dist 0.0013459994224831462 idx 3264\ndist 0.001345992088317871 idx 3251\npyknn ib 0, in 3404, ip 13 dist 0.005812999792397022 idx 2701\ndist 0.0058135986328125 idx 3754\npyknn ib 0, in 3404, ip 14 dist 0.005812999792397022 idx 3754\ndist 0.0058135986328125 idx 2701\npyknn ib 0, in 3407, ip 4 dist 0.002997000701725483 idx 1947\ndist 0.0029970109462738037 idx 3656\npyknn ib 0, in 3407, ip 5 dist 0.002997000701725483 idx 3656\ndist 0.0029970109462738037 idx 1947\npyknn ib 0, in 3409, ip 0 dist 0.0 idx 1269\ndist -2.384185791015625e-07 idx 3409\npyknn ib 0, in 3409, ip 1 dist 0.0 idx 3409\ndist -2.384185791015625e-07 idx 1269\npyknn ib 0, in 3409, ip 17 dist 0.008043000474572182 idx 1042\ndist 0.00804293155670166 idx 1482\npyknn ib 0, in 3409, ip 18 dist 0.008043000474572182 idx 1482\ndist 0.00804293155670166 idx 1042\npyknn ib 0, in 3410, ip 11 dist 0.005334001034498215 idx 1024\ndist 0.00533401221036911 idx 2834\npyknn ib 0, in 3410, ip 12 dist 0.005334001034498215 idx 2834\ndist 0.00533401221036911 idx 1024\npyknn ib 0, in 3413, ip 0 dist 0.0 idx 152\ndist 0.0 idx 3413\npyknn ib 0, in 3413, ip 1 dist 0.0 idx 3413\ndist 0.0 idx 152\npyknn ib 0, in 3413, ip 14 dist 0.010057998821139336 idx 2104\ndist 0.010058045387268066 idx 2583\npyknn ib 0, in 3413, ip 15 dist 0.010057998821139336 idx 2583\ndist 0.010058045387268066 idx 2104\npyknn ib 0, in 3414, ip 9 dist 0.00410101655870676 idx 2055\ndist 0.004100799560546875 idx 2936\npyknn ib 0, in 3414, ip 10 dist 0.00410101655870676 idx 2936\ndist 0.004100799560546875 idx 2055\npyknn ib 0, in 3415, ip 1 dist 0.00021200145420152694 idx 1176\ndist 0.0002117156982421875 idx 3866\npyknn ib 0, in 3415, ip 2 dist 0.00021200145420152694 idx 3866\ndist 0.0002117156982421875 idx 1176\npyknn ib 0, in 3415, ip 11 dist 0.007836993783712387 idx 3519\ndist 0.007837295532226562 idx 4066\npyknn ib 0, in 3415, ip 12 dist 0.007836993783712387 idx 4066\ndist 0.007837295532226562 idx 3519\npyknn ib 0, in 3416, ip 4 dist 0.001897998503409326 idx 3325\ndist 0.001898050308227539 idx 3729\npyknn ib 0, in 3416, ip 5 dist 0.001897998503409326 idx 3729\ndist 0.001898050308227539 idx 3325\npyknn ib 0, in 3421, ip 7 dist 0.004901004955172539 idx 1018\ndist 0.00490117073059082 idx 3982\npyknn ib 0, in 3421, ip 8 dist 0.004901004955172539 idx 3982\ndist 0.00490117073059082 idx 1018\npyknn ib 0, in 3429, ip 3 dist 0.00023299954773392528 idx 1024\ndist 0.00023300200700759888 idx 2834\npyknn ib 0, in 3429, ip 4 dist 0.00023299954773392528 idx 2834\ndist 0.00023300200700759888 idx 1024\npyknn ib 0, in 3430, ip 13 dist 0.00894500408321619 idx 810\ndist 0.008943557739257812 idx 3766\npyknn ib 0, in 3430, ip 14 dist 0.00894500408321619 idx 3766\ndist 0.008943557739257812 idx 810\npyknn ib 0, in 3440, ip 4 dist 0.003592999652028084 idx 2143\ndist 0.0035930201411247253 idx 4072\npyknn ib 0, in 3440, ip 5 dist 0.003592999652028084 idx 4072\ndist 0.0035930201411247253 idx 2143\npyknn ib 0, in 3440, ip 11 dist 0.006083999294787645 idx 2987\ndist 0.006083987653255463 idx 868\npyknn ib 0, in 3440, ip 12 dist 0.006084000691771507 idx 868\ndist 0.00608399510383606 idx 2987\npyknn ib 0, in 3440, ip 18 dist 0.010029001161456108 idx 0\ndist 0.010029010474681854 idx 1032\npyknn ib 0, in 3440, ip 19 dist 0.010029001161456108 idx 1032\ndist 0.010029010474681854 idx 0\npyknn ib 0, in 3441, ip 16 dist 0.007686000782996416 idx 0\ndist 0.007686004042625427 idx 1032\npyknn ib 0, in 3441, ip 17 dist 0.007686000782996416 idx 1032\ndist 0.007686004042625427 idx 1850\npyknn ib 0, in 3441, ip 18 dist 0.007686000782996416 idx 1850\ndist 0.007686004042625427 idx 0\npyknn ib 0, in 3442, ip 11 dist 0.004209999926388264 idx 1947\ndist 0.004209995269775391 idx 3656\npyknn ib 0, in 3442, ip 12 dist 0.004209999926388264 idx 3656\ndist 0.004209995269775391 idx 1947\npyknn ib 0, in 3445, ip 10 dist 0.004147999454289675 idx 488\ndist 0.004148006439208984 idx 2434\npyknn ib 0, in 3445, ip 11 dist 0.004147999454289675 idx 2434\ndist 0.004148006439208984 idx 488\npyknn ib 0, in 3456, ip 7 dist 0.0031460002064704895 idx 1024\ndist 0.0031460076570510864 idx 2834\npyknn ib 0, in 3456, ip 8 dist 0.0031460002064704895 idx 2834\ndist 0.0031460076570510864 idx 1024\npyknn ib 0, in 3456, ip 9 dist 0.004821000155061483 idx 363\ndist 0.004821024835109711 idx 694\npyknn ib 0, in 3456, ip 10 dist 0.004821000155061483 idx 694\ndist 0.004821024835109711 idx 363\npyknn ib 0, in 3456, ip 11 dist 0.004900998901575804 idx 2953\ndist 0.004901014268398285 idx 3429\npyknn ib 0, in 3456, ip 12 dist 0.004900998901575804 idx 3429\ndist 0.004901014268398285 idx 2953\npyknn ib 0, in 3461, ip 13 dist 0.013138998299837112 idx 1212\ndist 0.013138949871063232 idx 3522\npyknn ib 0, in 3461, ip 14 dist 0.013138998299837112 idx 3522\ndist 0.013138949871063232 idx 1212\npyknn ib 0, in 3462, ip 0 dist 0.0 idx 3462\ndist 0.0 idx 3465\npyknn ib 0, in 3462, ip 1 dist 0.0 idx 3465\ndist 0.0 idx 3462\npyknn ib 0, in 3465, ip 0 dist 0.0 idx 3462\ndist 0.0 idx 3465\npyknn ib 0, in 3465, ip 1 dist 0.0 idx 3465\ndist 0.0 idx 3462\npyknn ib 0, in 3470, ip 9 dist 0.0076049999333918095 idx 281\ndist 0.007604971528053284 idx 2437\npyknn ib 0, in 3470, ip 10 dist 0.0076049999333918095 idx 2437\ndist 0.007604971528053284 idx 281\npyknn ib 0, in 3472, ip 18 dist 0.014760998077690601 idx 158\ndist 0.014760971069335938 idx 1404\npyknn ib 0, in 3472, ip 19 dist 0.014760998077690601 idx 1404\ndist 0.014760971069335938 idx 158\npyknn ib 0, in 3474, ip 12 dist 0.010493999347090721 idx 666\ndist 0.010493874549865723 idx 2543\npyknn ib 0, in 3474, ip 13 dist 0.010493999347090721 idx 2543\ndist 0.010493874549865723 idx 666\npyknn ib 0, in 3474, ip 15 dist 0.011125998571515083 idx 1590\ndist 0.011126160621643066 idx 2927\npyknn ib 0, in 3474, ip 16 dist 0.011125998571515083 idx 2927\ndist 0.011126160621643066 idx 1590\npyknn ib 0, in 3480, ip 4 dist 0.012818001210689545 idx 1951\ndist 0.012817949056625366 idx 2710\npyknn ib 0, in 3480, ip 5 dist 0.012818001210689545 idx 2710\ndist 0.012817949056625366 idx 1951\npyknn ib 0, in 3481, ip 2 dist 0.000298000784823671 idx 128\ndist 0.0002970695495605469 idx 1118\npyknn ib 0, in 3481, ip 3 dist 0.000298000784823671 idx 1118\ndist 0.0002970695495605469 idx 128\npyknn ib 0, in 3481, ip 9 dist 0.004514000378549099 idx 1313\ndist 0.004513740539550781 idx 2092\npyknn ib 0, in 3481, ip 10 dist 0.004514000378549099 idx 2092\ndist 0.004513740539550781 idx 1313\npyknn ib 0, in 3488, ip 6 dist 0.005204994697123766 idx 1304\ndist 0.005205094814300537 idx 2654\npyknn ib 0, in 3488, ip 7 dist 0.005204994697123766 idx 2654\ndist 0.005205094814300537 idx 1304\npyknn ib 0, in 3488, ip 11 dist 0.00811500009149313 idx 2397\ndist 0.008115053176879883 idx 4050\npyknn ib 0, in 3488, ip 12 dist 0.00811500009149313 idx 4050\ndist 0.008115053176879883 idx 2397\npyknn ib 0, in 3491, ip 18 dist 0.008860995061695576 idx 1304\ndist 0.008860945701599121 idx 2654\npyknn ib 0, in 3491, ip 19 dist 0.008860995061695576 idx 2654\ndist 0.008860945701599121 idx 1304\npyknn ib 0, in 3495, ip 0 dist 0.0 idx 1425\ndist 0.0 idx 3495\npyknn ib 0, in 3495, ip 1 dist 0.0 idx 3495\ndist 0.0 idx 1425\npyknn ib 0, in 3500, ip 18 dist 0.013730003498494625 idx 1487\ndist 0.01372992992401123 idx 3004\npyknn ib 0, in 3500, ip 19 dist 0.013730003498494625 idx 3004\ndist 0.01372992992401123 idx 1487\npyknn ib 0, in 3501, ip 2 dist 0.0018849981715902686 idx 1225\ndist 0.0018854141235351562 idx 1637\npyknn ib 0, in 3501, ip 3 dist 0.0018849981715902686 idx 1637\ndist 0.0018854141235351562 idx 1225\npyknn ib 0, in 3504, ip 3 dist 0.0021460067946463823 idx 869\ndist 0.0021452903747558594 idx 2454\npyknn ib 0, in 3504, ip 4 dist 0.0021460067946463823 idx 2454\ndist 0.0021452903747558594 idx 869\npyknn ib 0, in 3507, ip 10 dist 0.006412987597286701 idx 1487\ndist 0.0064127445220947266 idx 3004\npyknn ib 0, in 3507, ip 11 dist 0.006412987597286701 idx 3004\ndist 0.0064127445220947266 idx 1487\npyknn ib 0, in 3508, ip 1 dist 0.001189997885376215 idx 1052\ndist 0.0011899471282958984 idx 2093\npyknn ib 0, in 3508, ip 2 dist 0.001189997885376215 idx 2093\ndist 0.0011899471282958984 idx 1052\npyknn ib 0, in 3509, ip 1 dist 0.0012090002419427037 idx 1304\ndist 0.001208961009979248 idx 2654\npyknn ib 0, in 3509, ip 2 dist 0.0012090002419427037 idx 2654\ndist 0.001208961009979248 idx 1304\npyknn ib 0, in 3511, ip 8 dist 0.002437000395730138 idx 2701\ndist 0.002437591552734375 idx 3754\npyknn ib 0, in 3511, ip 9 dist 0.002437000395730138 idx 3754\ndist 0.002437591552734375 idx 2701\npyknn ib 0, in 3512, ip 10 dist 0.006725003011524677 idx 937\ndist 0.006725311279296875 idx 2228\npyknn ib 0, in 3512, ip 11 dist 0.006725003011524677 idx 2228\ndist 0.006725311279296875 idx 937\npyknn ib 0, in 3512, ip 18 dist 0.014550035819411278 idx 1400\ndist 0.014549732208251953 idx 3069\npyknn ib 0, in 3512, ip 19 dist 0.014550035819411278 idx 3069\ndist 0.014549732208251953 idx 1400\npyknn ib 0, in 3519, ip 0 dist 0.0 idx 3519\ndist 0.0 idx 4066\npyknn ib 0, in 3519, ip 1 dist 0.0 idx 4066\ndist 0.0 idx 3519\npyknn ib 0, in 3519, ip 2 dist 0.0004419961478561163 idx 829\ndist 0.00044155120849609375 idx 3173\npyknn ib 0, in 3519, ip 3 dist 0.0004419961478561163 idx 3173\ndist 0.00044155120849609375 idx 829\npyknn ib 0, in 3520, ip 1 dist 0.00022599961084779352 idx 818\ndist 0.00022605061531066895 idx 3318\npyknn ib 0, in 3520, ip 2 dist 0.00022599961084779352 idx 3318\ndist 0.00022605061531066895 idx 818\npyknn ib 0, in 3524, ip 10 dist 0.006727982312440872 idx 810\ndist 0.006728172302246094 idx 3766\npyknn ib 0, in 3524, ip 11 dist 0.006727982312440872 idx 3766\ndist 0.006728172302246094 idx 810\npyknn ib 0, in 3525, ip 4 dist 0.001409997814334929 idx 1649\ndist 0.0014100074768066406 idx 3471\npyknn ib 0, in 3525, ip 5 dist 0.001409997814334929 idx 3471\ndist 0.0014100074768066406 idx 1649\npyknn ib 0, in 3526, ip 6 dist 0.00230899965390563 idx 1123\ndist 0.0023088455200195312 idx 2937\npyknn ib 0, in 3526, ip 7 dist 0.00230899965390563 idx 2937\ndist 0.0023088455200195312 idx 1123\npyknn ib 0, in 3527, ip 10 dist 0.009864001534879208 idx 1212\ndist 0.009863987565040588 idx 3522\npyknn ib 0, in 3527, ip 11 dist 0.009864001534879208 idx 3522\ndist 0.009863987565040588 idx 1212\npyknn ib 0, in 3528, ip 3 dist 0.0019439997849985957 idx 1947\ndist 0.0019440054893493652 idx 3656\npyknn ib 0, in 3528, ip 4 dist 0.0019439997849985957 idx 3656\ndist 0.0019440054893493652 idx 1947\npyknn ib 0, in 3530, ip 11 dist 0.004930997267365456 idx 1871\ndist 0.0049304962158203125 idx 3541\npyknn ib 0, in 3530, ip 12 dist 0.004930997267365456 idx 3541\ndist 0.0049304962158203125 idx 1871\npyknn ib 0, in 3535, ip 2 dist 0.00040199910290539265 idx 2176\ndist 0.00040340423583984375 idx 2815\npyknn ib 0, in 3535, ip 3 dist 0.00040199910290539265 idx 2815\ndist 0.00040340423583984375 idx 2176\npyknn ib 0, in 3541, ip 0 dist 0.0 idx 1871\ndist -1.9073486328125e-06 idx 3541\npyknn ib 0, in 3541, ip 1 dist 0.0 idx 3541\ndist -1.9073486328125e-06 idx 1871\npyknn ib 0, in 3546, ip 11 dist 0.005651996936649084 idx 2316\ndist 0.005651950836181641 idx 2761\npyknn ib 0, in 3546, ip 12 dist 0.005651996936649084 idx 2761\ndist 0.005651950836181641 idx 2316\npyknn ib 0, in 3553, ip 16 dist 0.003945999778807163 idx 2502\ndist 0.003945887088775635 idx 3168\npyknn ib 0, in 3553, ip 17 dist 0.003945999778807163 idx 3168\ndist 0.003945887088775635 idx 2502\npyknn ib 0, in 3560, ip 11 dist 0.00826500728726387 idx 2745\ndist 0.008264780044555664 idx 3933\npyknn ib 0, in 3560, ip 12 dist 0.00826500728726387 idx 3933\ndist 0.008264780044555664 idx 2745\npyknn ib 0, in 3567, ip 7 dist 0.004524988122284412 idx 1297\ndist 0.00452423095703125 idx 2984\npyknn ib 0, in 3567, ip 8 dist 0.004524995107203722 idx 2984\ndist 0.00452423095703125 idx 1297\npyknn ib 0, in 3575, ip 2 dist 0.0017249988159164786 idx 2854\ndist 0.0017247200012207031 idx 3996\npyknn ib 0, in 3575, ip 3 dist 0.0017249988159164786 idx 3996\ndist 0.0017247200012207031 idx 2854\npyknn ib 0, in 3579, ip 1 dist 0.00023399594647344202 idx 810\ndist 0.000232696533203125 idx 3766\npyknn ib 0, in 3579, ip 2 dist 0.00023399594647344202 idx 3766\ndist 0.000232696533203125 idx 810\npyknn ib 0, in 3579, ip 10 dist 0.008099023252725601 idx 1093\ndist 0.008098602294921875 idx 2320\npyknn ib 0, in 3579, ip 11 dist 0.008099023252725601 idx 2320\ndist 0.008098602294921875 idx 1093\npyknn ib 0, in 3581, ip 9 dist 0.006384999491274357 idx 2176\ndist 0.00638580322265625 idx 2815\npyknn ib 0, in 3581, ip 10 dist 0.006384999491274357 idx 2815\ndist 0.00638580322265625 idx 2176\npyknn ib 0, in 3582, ip 11 dist 0.006272999569773674 idx 1952\ndist 0.00627291202545166 idx 2823\npyknn ib 0, in 3582, ip 12 dist 0.006272999569773674 idx 2823\ndist 0.00627291202545166 idx 1952\npyknn ib 0, in 3583, ip 1 dist 0.0015939960721880198 idx 1313\ndist 0.0015935897827148438 idx 2092\npyknn ib 0, in 3583, ip 2 dist 0.0015939960721880198 idx 2092\ndist 0.0015935897827148438 idx 1313\npyknn ib 0, in 3594, ip 12 dist 0.006574000231921673 idx 849\ndist 0.006572723388671875 idx 1128\npyknn ib 0, in 3594, ip 13 dist 0.006574000231921673 idx 1128\ndist 0.006572723388671875 idx 849\npyknn ib 0, in 3598, ip 18 dist 0.008245003409683704 idx 193\ndist 0.008244991302490234 idx 231\npyknn ib 0, in 3598, ip 19 dist 0.008245003409683704 idx 231\ndist 0.008244991302490234 idx 193\npyknn ib 0, in 3600, ip 11 dist 0.0064890035428106785 idx 1059\ndist 0.006489008665084839 idx 3232\npyknn ib 0, in 3600, ip 12 dist 0.0064890035428106785 idx 3232\ndist 0.006489008665084839 idx 1059\npyknn ib 0, in 3610, ip 14 dist 0.007984996773302555 idx 1925\ndist 0.00798499584197998 idx 2416\npyknn ib 0, in 3610, ip 15 dist 0.007984996773302555 idx 2416\ndist 0.00798499584197998 idx 1925\npyknn ib 0, in 3612, ip 5 dist 0.0035329984966665506 idx 2316\ndist 0.003532886505126953 idx 2761\npyknn ib 0, in 3612, ip 6 dist 0.0035329984966665506 idx 2761\ndist 0.003532886505126953 idx 2316\npyknn ib 0, in 3621, ip 10 dist 0.006896963343024254 idx 937\ndist 0.006896495819091797 idx 2228\npyknn ib 0, in 3621, ip 11 dist 0.006896963343024254 idx 2228\ndist 0.006896495819091797 idx 937\npyknn ib 0, in 3627, ip 11 dist 0.008366001769900322 idx 767\ndist 0.008365988731384277 idx 1375\npyknn ib 0, in 3627, ip 13 dist 0.008366001769900322 idx 1375\ndist 0.008365988731384277 idx 767\npyknn ib 0, in 3629, ip 12 dist 0.0073130009695887566 idx 403\ndist 0.007312774658203125 idx 2045\npyknn ib 0, in 3629, ip 13 dist 0.0073130009695887566 idx 2045\ndist 0.007312774658203125 idx 403\npyknn ib 0, in 3631, ip 0 dist 0.0 idx 3631\ndist 0.0 idx 4089\npyknn ib 0, in 3631, ip 1 dist 0.0 idx 4089\ndist 0.0 idx 3631\npyknn ib 0, in 3634, ip 18 dist 0.009790007025003433 idx 2397\ndist 0.00978994369506836 idx 4050\npyknn ib 0, in 3634, ip 19 dist 0.009790007025003433 idx 4050\ndist 0.00978994369506836 idx 2397\npyknn ib 0, in 3635, ip 0 dist 0.0 idx 1906\ndist 9.5367431640625e-07 idx 3635\npyknn ib 0, in 3635, ip 1 dist 0.0 idx 3635\ndist 9.5367431640625e-07 idx 1906\npyknn ib 0, in 3635, ip 7 dist 0.006624998524785042 idx 2790\ndist 0.006625652313232422 idx 3722\npyknn ib 0, in 3635, ip 8 dist 0.006624998524785042 idx 3722\ndist 0.006625652313232422 idx 2790\npyknn ib 0, in 3637, ip 18 dist 0.010817998088896275 idx 1123\ndist 0.010816574096679688 idx 2937\npyknn ib 0, in 3637, ip 19 dist 0.010817998088896275 idx 2937\ndist 0.010816574096679688 idx 1123\npyknn ib 0, in 3638, ip 0 dist 0.0 idx 2780\ndist -4.76837158203125e-07 idx 3638\npyknn ib 0, in 3638, ip 1 dist 0.0 idx 3638\ndist -4.76837158203125e-07 idx 2780\npyknn ib 0, in 3642, ip 4 dist 0.0014510012697428465 idx 363\ndist 0.0014509856700897217 idx 694\npyknn ib 0, in 3642, ip 5 dist 0.0014510012697428465 idx 694\ndist 0.0014509856700897217 idx 363\npyknn ib 0, in 3645, ip 8 dist 0.0035089822486042976 idx 615\ndist 0.0035085678100585938 idx 2297\npyknn ib 0, in 3645, ip 9 dist 0.0035089822486042976 idx 2297\ndist 0.0035085678100585938 idx 615\npyknn ib 0, in 3653, ip 8 dist 0.005330007988959551 idx 236\ndist 0.0053310394287109375 idx 1959\npyknn ib 0, in 3653, ip 9 dist 0.005330007988959551 idx 1959\ndist 0.0053310394287109375 idx 236\npyknn ib 0, in 3653, ip 12 dist 0.007883005775511265 idx 483\ndist 0.007884025573730469 idx 2764\npyknn ib 0, in 3653, ip 13 dist 0.007883005775511265 idx 2764\ndist 0.007884025573730469 idx 483\npyknn ib 0, in 3655, ip 10 dist 0.005937003064900637 idx 962\ndist 0.005936622619628906 idx 3213\npyknn ib 0, in 3655, ip 11 dist 0.005937003064900637 idx 3213\ndist 0.005936622619628906 idx 962\npyknn ib 0, in 3656, ip 0 dist 0.0 idx 1947\ndist 5.960464477539063e-08 idx 3656\npyknn ib 0, in 3656, ip 1 dist 0.0 idx 3656\ndist 5.960464477539063e-08 idx 1947\npyknn ib 0, in 3668, ip 4 dist 0.002050999319180846 idx 829\ndist 0.0020503997802734375 idx 3173\npyknn ib 0, in 3668, ip 5 dist 0.002050999319180846 idx 3173\ndist 0.0020503997802734375 idx 829\npyknn ib 0, in 3668, ip 9 dist 0.0033809910528361797 idx 3519\ndist 0.0033788681030273438 idx 4066\npyknn ib 0, in 3668, ip 10 dist 0.0033809910528361797 idx 4066\ndist 0.0033788681030273438 idx 3519\npyknn ib 0, in 3673, ip 11 dist 0.005558010656386614 idx 1052\ndist 0.0055577754974365234 idx 2093\npyknn ib 0, in 3673, ip 12 dist 0.005558010656386614 idx 2093\ndist 0.0055577754974365234 idx 1052\npyknn ib 0, in 3674, ip 2 dist 0.0007700005662627518 idx 344\ndist 0.0007699877023696899 idx 1751\npyknn ib 0, in 3674, ip 3 dist 0.0007700005662627518 idx 1751\ndist 0.0007699877023696899 idx 344\npyknn ib 0, in 3675, ip 10 dist 0.006197004113346338 idx 3140\ndist 0.006197214126586914 idx 2736\npyknn ib 0, in 3675, ip 11 dist 0.006197008304297924 idx 2736\ndist 0.006197214126586914 idx 3140\npyknn ib 0, in 3682, ip 2 dist 0.000953999871853739 idx 1031\ndist 0.0009539127349853516 idx 1100\npyknn ib 0, in 3682, ip 3 dist 0.000953999871853739 idx 1100\ndist 0.0009539127349853516 idx 2711\npyknn ib 0, in 3682, ip 4 dist 0.000953999871853739 idx 2711\ndist 0.0009539127349853516 idx 1031\npyknn ib 0, in 3682, ip 5 dist 0.002277006395161152 idx 744\ndist 0.002276897430419922 idx 3909\npyknn ib 0, in 3682, ip 6 dist 0.002277006395161152 idx 3909\ndist 0.002276897430419922 idx 744\npyknn ib 0, in 3685, ip 6 dist 0.0022769994102418423 idx 1032\ndist 0.002277001738548279 idx 1850\npyknn ib 0, in 3685, ip 7 dist 0.0022769994102418423 idx 1850\ndist 0.002277001738548279 idx 1032\npyknn ib 0, in 3686, ip 18 dist 0.012762016616761684 idx 962\ndist 0.012761116027832031 idx 3213\npyknn ib 0, in 3686, ip 19 dist 0.012762016616761684 idx 3213\ndist 0.012761116027832031 idx 962\npyknn ib 0, in 3699, ip 9 dist 0.006161997560411692 idx 158\ndist 0.006161689758300781 idx 1404\npyknn ib 0, in 3699, ip 10 dist 0.006161997560411692 idx 1404\ndist 0.006161689758300781 idx 158\npyknn ib 0, in 3703, ip 0 dist 0.0 idx 963\ndist 0.0 idx 3703\npyknn ib 0, in 3703, ip 1 dist 0.0 idx 3703\ndist 0.0 idx 963\npyknn ib 0, in 3705, ip 7 dist 0.005197002552449703 idx 869\ndist 0.005197048187255859 idx 2454\npyknn ib 0, in 3705, ip 8 dist 0.005197002552449703 idx 2454\ndist 0.005197048187255859 idx 869\npyknn ib 0, in 3706, ip 1 dist 0.0005649998784065247 idx 497\ndist 0.0005649328231811523 idx 2785\npyknn ib 0, in 3706, ip 2 dist 0.0005649998784065247 idx 2785\ndist 0.0005649328231811523 idx 497\npyknn ib 0, in 3707, ip 0 dist 0.0 idx 719\ndist -4.76837158203125e-07 idx 3707\npyknn ib 0, in 3707, ip 1 dist 0.0 idx 3707\ndist -4.76837158203125e-07 idx 719\npyknn ib 0, in 3714, ip 5 dist 0.0016370017547160387 idx 2328\ndist 0.0016369819641113281 idx 3774\npyknn ib 0, in 3714, ip 6 dist 0.0016370017547160387 idx 3774\ndist 0.0016369819641113281 idx 2328\npyknn ib 0, in 3715, ip 3 dist 0.000400999968405813 idx 636\ndist 0.0004010051488876343 idx 3362\npyknn ib 0, in 3715, ip 4 dist 0.000400999968405813 idx 3362\ndist 0.0004010051488876343 idx 636\npyknn ib 0, in 3717, ip 10 dist 0.0069059995003044605 idx 767\ndist 0.0069060176610946655 idx 1375\npyknn ib 0, in 3717, ip 12 dist 0.0069059995003044605 idx 1375\ndist 0.0069060176610946655 idx 767\npyknn ib 0, in 3720, ip 5 dist 0.0029769993852823973 idx 1024\ndist 0.0029769912362098694 idx 2834\npyknn ib 0, in 3720, ip 6 dist 0.0029769993852823973 idx 2834\ndist 0.0029769912362098694 idx 1024\npyknn ib 0, in 3720, ip 8 dist 0.0040999967604875565 idx 2953\ndist 0.004099994897842407 idx 3429\npyknn ib 0, in 3720, ip 9 dist 0.0040999967604875565 idx 3429\ndist 0.004099994897842407 idx 2953\npyknn ib 0, in 3721, ip 1 dist 0.0002810000441968441 idx 1647\ndist 0.0002810955047607422 idx 2457\npyknn ib 0, in 3721, ip 2 dist 0.0002810000441968441 idx 2457\ndist 0.0002810955047607422 idx 1647\npyknn ib 0, in 3721, ip 12 dist 0.006165006663650274 idx 282\ndist 0.0061647891998291016 idx 2323\npyknn ib 0, in 3721, ip 13 dist 0.006165006663650274 idx 2323\ndist 0.0061647891998291016 idx 282\npyknn ib 0, in 3722, ip 0 dist 0.0 idx 2790\ndist 0.0 idx 3722\npyknn ib 0, in 3722, ip 1 dist 0.0 idx 3722\ndist 0.0 idx 2790\npyknn ib 0, in 3722, ip 14 dist 0.006624998524785042 idx 1906\ndist 0.006625652313232422 idx 3635\npyknn ib 0, in 3722, ip 15 dist 0.006624998524785042 idx 3635\ndist 0.006625652313232422 idx 1906\npyknn ib 0, in 3723, ip 11 dist 0.006090002600103617 idx 497\ndist 0.006090044975280762 idx 2785\npyknn ib 0, in 3723, ip 12 dist 0.006090002600103617 idx 2785\ndist 0.006090044975280762 idx 497\npyknn ib 0, in 3725, ip 9 dist 0.004778000060468912 idx 683\ndist 0.004777997732162476 idx 3377\npyknn ib 0, in 3725, ip 10 dist 0.004778000060468912 idx 2705\ndist 0.004777997732162476 idx 683\npyknn ib 0, in 3725, ip 11 dist 0.004778000060468912 idx 3377\ndist 0.004777997732162476 idx 2705\npyknn ib 0, in 3728, ip 5 dist 0.003074999898672104 idx 722\ndist 0.0030749994330108166 idx 3776\npyknn ib 0, in 3728, ip 6 dist 0.003074999898672104 idx 3776\ndist 0.0030749994330108166 idx 722\npyknn ib 0, in 3731, ip 16 dist 0.01155802421271801 idx 2854\ndist 0.011558055877685547 idx 3996\npyknn ib 0, in 3731, ip 17 dist 0.01155802421271801 idx 3996\ndist 0.011558055877685547 idx 2854\npyknn ib 0, in 3734, ip 2 dist 0.0009229975985363126 idx 1649\ndist 0.0009236335754394531 idx 3471\npyknn ib 0, in 3734, ip 3 dist 0.0009229975985363126 idx 3471\ndist 0.0009236335754394531 idx 1649\npyknn ib 0, in 3737, ip 0 dist 0.0 idx 3261\ndist 0.0 idx 3737\npyknn ib 0, in 3737, ip 1 dist 0.0 idx 3737\ndist 0.0 idx 3261\npyknn ib 0, in 3738, ip 3 dist 0.0022369935177266598 idx 959\ndist 0.0022363662719726562 idx 2733\npyknn ib 0, in 3738, ip 4 dist 0.0022370037622749805 idx 2733\ndist 0.0022363662719726562 idx 959\npyknn ib 0, in 3740, ip 1 dist 0.0019520005444064736 idx 1647\ndist 0.0019516944885253906 idx 2457\npyknn ib 0, in 3740, ip 2 dist 0.0019520005444064736 idx 2457\ndist 0.0019516944885253906 idx 1647\npyknn ib 0, in 3740, ip 4 dist 0.0031559993512928486 idx 282\ndist 0.0031557083129882812 idx 2323\npyknn ib 0, in 3740, ip 5 dist 0.0031559993512928486 idx 2323\ndist 0.0031557083129882812 idx 282\npyknn ib 0, in 3742, ip 11 dist 0.007034010253846645 idx 937\ndist 0.007033348083496094 idx 2228\npyknn ib 0, in 3742, ip 12 dist 0.007034010253846645 idx 2228\ndist 0.007033348083496094 idx 937\npyknn ib 0, in 3746, ip 4 dist 0.0036910013295710087 idx 1342\ndist 0.003690958023071289 idx 2235\npyknn ib 0, in 3746, ip 5 dist 0.0036910013295710087 idx 2235\ndist 0.003690958023071289 idx 1342\npyknn ib 0, in 3746, ip 6 dist 0.003737997729331255 idx 847\ndist 0.003737926483154297 idx 2932\npyknn ib 0, in 3746, ip 7 dist 0.003737997729331255 idx 2932\ndist 0.003737926483154297 idx 847\npyknn ib 0, in 3749, ip 11 dist 0.004900988657027483 idx 2055\ndist 0.004900932312011719 idx 2936\npyknn ib 0, in 3749, ip 12 dist 0.004900988657027483 idx 2936\ndist 0.004900932312011719 idx 2055\npyknn ib 0, in 3752, ip 6 dist 0.0036260022316128016 idx 1248\ndist 0.0036258697509765625 idx 3939\npyknn ib 0, in 3752, ip 7 dist 0.0036260022316128016 idx 3939\ndist 0.0036258697509765625 idx 1248\npyknn ib 0, in 3753, ip 10 dist 0.005917004309594631 idx 1881\ndist 0.0059168338775634766 idx 2188\npyknn ib 0, in 3753, ip 11 dist 0.005917004309594631 idx 2188\ndist 0.0059168338775634766 idx 1881\npyknn ib 0, in 3754, ip 0 dist 0.0 idx 2701\ndist 0.0 idx 3754\npyknn ib 0, in 3754, ip 1 dist 0.0 idx 3754\ndist 0.0 idx 2701\npyknn ib 0, in 3758, ip 18 dist 0.01014699973165989 idx 127\ndist 0.010146856307983398 idx 2848\npyknn ib 0, in 3758, ip 19 dist 0.01014699973165989 idx 2848\ndist 0.010146856307983398 idx 127\npyknn ib 0, in 3765, ip 3 dist 0.001645983662456274 idx 2854\ndist 0.0016455650329589844 idx 3996\npyknn ib 0, in 3765, ip 4 dist 0.001645983662456274 idx 3996\ndist 0.0016455650329589844 idx 2854\npyknn ib 0, in 3766, ip 0 dist 0.0 idx 810\ndist -1.9073486328125e-06 idx 3766\npyknn ib 0, in 3766, ip 1 dist 0.0 idx 3766\ndist -1.9073486328125e-06 idx 810\npyknn ib 0, in 3767, ip 5 dist 0.004002002067863941 idx 3251\ndist 0.0040018558502197266 idx 3264\npyknn ib 0, in 3767, ip 6 dist 0.004002002067863941 idx 3264\ndist 0.0040018558502197266 idx 3251\npyknn ib 0, in 3768, ip 9 dist 0.005507001653313637 idx 1167\ndist 0.005507469177246094 idx 2174\npyknn ib 0, in 3768, ip 10 dist 0.005507001653313637 idx 2174\ndist 0.005507469177246094 idx 1167\npyknn ib 0, in 3774, ip 0 dist 0.0 idx 2328\ndist 0.0 idx 3774\npyknn ib 0, in 3774, ip 1 dist 0.0 idx 3774\ndist 0.0 idx 2328\npyknn ib 0, in 3776, ip 0 dist 0.0 idx 722\ndist 0.0 idx 3776\npyknn ib 0, in 3776, ip 1 dist 0.0 idx 3776\ndist 0.0 idx 722\npyknn ib 0, in 3777, ip 0 dist 0.0 idx 1062\ndist 5.960464477539063e-08 idx 3777\npyknn ib 0, in 3777, ip 2 dist 0.0 idx 3777\ndist 5.960464477539063e-08 idx 1062\npyknn ib 0, in 3778, ip 14 dist 0.006602999288588762 idx 722\ndist 0.006602998822927475 idx 3776\npyknn ib 0, in 3778, ip 15 dist 0.006602999288588762 idx 3776\ndist 0.006602998822927475 idx 722\npyknn ib 0, in 3785, ip 17 dist 0.010439997538924217 idx 363\ndist 0.01043999195098877 idx 694\npyknn ib 0, in 3785, ip 18 dist 0.010439997538924217 idx 694\ndist 0.01043999195098877 idx 363\npyknn ib 0, in 3791, ip 16 dist 0.010437000542879105 idx 722\ndist 0.01043699961155653 idx 3776\npyknn ib 0, in 3791, ip 17 dist 0.010437000542879105 idx 3776\ndist 0.01043699961155653 idx 722\npyknn ib 0, in 3792, ip 3 dist 0.001552001223899424 idx 1871\ndist 0.0015506744384765625 idx 3541\npyknn ib 0, in 3792, ip 4 dist 0.001552001223899424 idx 3541\ndist 0.0015506744384765625 idx 1871\npyknn ib 0, in 3792, ip 18 dist 0.013074001297354698 idx 1167\ndist 0.013072013854980469 idx 2174\npyknn ib 0, in 3792, ip 19 dist 0.013074001297354698 idx 2174\ndist 0.013072013854980469 idx 1167\npyknn ib 0, in 3796, ip 18 dist 0.011904004961252213 idx 963\ndist 0.011904239654541016 idx 3703\npyknn ib 0, in 3796, ip 19 dist 0.011904004961252213 idx 3703\ndist 0.011904239654541016 idx 963\npyknn ib 0, in 3797, ip 1 dist 0.00010100007784785703 idx 3325\ndist 0.00010102987289428711 idx 3729\npyknn ib 0, in 3797, ip 2 dist 0.00010100007784785703 idx 3729\ndist 0.00010102987289428711 idx 3325\npyknn ib 0, in 3799, ip 3 dist 0.00041699971188791096 idx 2266\ndist 0.0004177093505859375 idx 3388\npyknn ib 0, in 3799, ip 4 dist 0.00041699971188791096 idx 3388\ndist 0.0004177093505859375 idx 2266\npyknn ib 0, in 3802, ip 14 dist 0.011641998775303364 idx 3383\ndist 0.011641979217529297 idx 3439\npyknn ib 0, in 3802, ip 15 dist 0.011641998775303364 idx 3439\ndist 0.011641979217529297 idx 3383\npyknn ib 0, in 3805, ip 7 dist 0.0040910011157393456 idx 792\ndist 0.004091024398803711 idx 974\npyknn ib 0, in 3805, ip 8 dist 0.0040910011157393456 idx 974\ndist 0.004091024398803711 idx 792\npyknn ib 0, in 3807, ip 14 dist 0.008724001236259937 idx 744\ndist 0.008723974227905273 idx 3909\npyknn ib 0, in 3807, ip 15 dist 0.008724001236259937 idx 3909\ndist 0.008723974227905273 idx 744\npyknn ib 0, in 3818, ip 2 dist 0.000551996985450387 idx 2458\ndist 0.0005519390106201172 idx 2645\npyknn ib 0, in 3818, ip 3 dist 0.000551996985450387 idx 2645\ndist 0.0005519390106201172 idx 2458\npyknn ib 0, in 3821, ip 14 dist 0.004901000298559666 idx 2701\ndist 0.004901885986328125 idx 3754\npyknn ib 0, in 3821, ip 15 dist 0.004901000298559666 idx 3754\ndist 0.004901885986328125 idx 2701\npyknn ib 0, in 3826, ip 12 dist 0.010700996033847332 idx 1031\ndist 0.01070094108581543 idx 1100\npyknn ib 0, in 3826, ip 13 dist 0.010700996033847332 idx 1100\ndist 0.01070094108581543 idx 1031\npyknn ib 0, in 3826, ip 16 dist 0.012152014300227165 idx 744\ndist 0.01215219497680664 idx 3909\npyknn ib 0, in 3826, ip 17 dist 0.012152014300227165 idx 3909\ndist 0.01215219497680664 idx 744\npyknn ib 0, in 3833, ip 9 dist 0.003604000201448798 idx 281\ndist 0.003603994846343994 idx 2437\npyknn ib 0, in 3833, ip 10 dist 0.003604000201448798 idx 2437\ndist 0.003603994846343994 idx 281\npyknn ib 0, in 3835, ip 7 dist 0.004132998175919056 idx 1093\ndist 0.004132270812988281 idx 2320\npyknn ib 0, in 3835, ip 8 dist 0.004132998175919056 idx 2320\ndist 0.004132270812988281 idx 1093\npyknn ib 0, in 3835, ip 18 dist 0.010659990832209587 idx 810\ndist 0.010659217834472656 idx 3766\npyknn ib 0, in 3835, ip 19 dist 0.010659990832209587 idx 3766\ndist 0.010659217834472656 idx 810\npyknn ib 0, in 3842, ip 8 dist 0.005413996987044811 idx 2767\ndist 0.005414038896560669 idx 3503\npyknn ib 0, in 3842, ip 9 dist 0.005413996987044811 idx 3503\ndist 0.005414038896560669 idx 2767\npyknn ib 0, in 3843, ip 12 dist 0.005192999728024006 idx 847\ndist 0.005192995071411133 idx 2932\npyknn ib 0, in 3843, ip 13 dist 0.005192999728024006 idx 2932\ndist 0.005192995071411133 idx 847\npyknn ib 0, in 3851, ip 7 dist 0.0037380007561296225 idx 1333\ndist 0.003738000988960266 idx 1388\npyknn ib 0, in 3851, ip 8 dist 0.0037380007561296225 idx 1388\ndist 0.003738000988960266 idx 1333\npyknn ib 0, in 3853, ip 2 dist 0.0003970006946474314 idx 818\ndist 0.00039702653884887695 idx 3318\npyknn ib 0, in 3853, ip 3 dist 0.0003970006946474314 idx 3318\ndist 0.00039702653884887695 idx 818\npyknn ib 0, in 3853, ip 18 dist 0.025717997923493385 idx 3462\ndist 0.025718003511428833 idx 3465\npyknn ib 0, in 3853, ip 19 dist 0.025717997923493385 idx 3465\ndist 0.025718003511428833 idx 3462\npyknn ib 0, in 3858, ip 3 dist 0.004686000291258097 idx 636\ndist 0.004686005413532257 idx 3362\npyknn ib 0, in 3858, ip 4 dist 0.004686000291258097 idx 3362\ndist 0.004686005413532257 idx 636\npyknn ib 0, in 3859, ip 8 dist 0.0045179990120232105 idx 2502\ndist 0.004517912864685059 idx 3168\npyknn ib 0, in 3859, ip 9 dist 0.0045179990120232105 idx 3168\ndist 0.004517912864685059 idx 2502\npyknn ib 0, in 3859, ip 17 dist 0.0062250057235360146 idx 2316\ndist 0.006224989891052246 idx 2761\npyknn ib 0, in 3859, ip 18 dist 0.0062250057235360146 idx 2761\ndist 0.006224989891052246 idx 2316\npyknn ib 0, in 3860, ip 1 dist 0.001565000507980585 idx 768\ndist 0.00156499445438385 idx 2765\npyknn ib 0, in 3860, ip 2 dist 0.001565000507980585 idx 2765\ndist 0.00156499445438385 idx 768\npyknn ib 0, in 3864, ip 8 dist 0.0025200005620718002 idx 1219\ndist 0.0025200843811035156 idx 3352\npyknn ib 0, in 3864, ip 9 dist 0.0025200005620718002 idx 3352\ndist 0.0025200843811035156 idx 1219\npyknn ib 0, in 3866, ip 9 dist 0.008149027824401855 idx 3519\ndist 0.008148193359375 idx 4066\npyknn ib 0, in 3866, ip 10 dist 0.008149027824401855 idx 4066\ndist 0.008148193359375 idx 3519\npyknn ib 0, in 3866, ip 18 dist 0.011526023969054222 idx 2377\ndist 0.011525154113769531 idx 3132\npyknn ib 0, in 3866, ip 19 dist 0.011526023969054222 idx 3132\ndist 0.011525154113769531 idx 2377\npyknn ib 0, in 3867, ip 9 dist 0.004133999813348055 idx 857\ndist 0.004133939743041992 idx 2424\npyknn ib 0, in 3867, ip 10 dist 0.004133999813348055 idx 2424\ndist 0.004133939743041992 idx 857\npyknn ib 0, in 3868, ip 18 dist 0.012170001864433289 idx 1333\ndist 0.012169986963272095 idx 1388\npyknn ib 0, in 3868, ip 19 dist 0.012170001864433289 idx 1388\ndist 0.012169986963272095 idx 1333\npyknn ib 0, in 3869, ip 3 dist 0.002033001510426402 idx 938\ndist 0.0020329952239990234 idx 1350\npyknn ib 0, in 3869, ip 4 dist 0.002033001510426402 idx 1350\ndist 0.0020329952239990234 idx 938\npyknn ib 0, in 3872, ip 4 dist 0.0024029994383454323 idx 683\ndist 0.0024029985070228577 idx 2705\npyknn ib 0, in 3872, ip 5 dist 0.0024029994383454323 idx 2705\ndist 0.0024029985070228577 idx 3377\npyknn ib 0, in 3872, ip 6 dist 0.0024029994383454323 idx 3377\ndist 0.0024029985070228577 idx 683\npyknn ib 0, in 3873, ip 4 dist 0.0017179968999698758 idx 1304\ndist 0.001717984676361084 idx 2654\npyknn ib 0, in 3873, ip 5 dist 0.0017179968999698758 idx 2654\ndist 0.001717984676361084 idx 1304\npyknn ib 0, in 3874, ip 10 dist 0.007155999541282654 idx 366\ndist 0.0071561336517333984 idx 3555\npyknn ib 0, in 3874, ip 11 dist 0.007155999541282654 idx 3555\ndist 0.0071561336517333984 idx 366\npyknn ib 0, in 3883, ip 2 dist 0.0005449995514936745 idx 158\ndist 0.0005464553833007812 idx 1404\npyknn ib 0, in 3883, ip 3 dist 0.0005449995514936745 idx 1404\ndist 0.0005464553833007812 idx 158\npyknn ib 0, in 3884, ip 7 dist 0.0038480001967400312 idx 1018\ndist 0.003847837448120117 idx 3982\npyknn ib 0, in 3884, ip 8 dist 0.0038480001967400312 idx 3982\ndist 0.003847837448120117 idx 1018\npyknn ib 0, in 3887, ip 10 dist 0.006790000945329666 idx 3107\ndist 0.006789207458496094 idx 1966\npyknn ib 0, in 3887, ip 11 dist 0.006790002807974815 idx 1966\ndist 0.006789207458496094 idx 3107\npyknn ib 0, in 3890, ip 0 dist 0.0 idx 1426\ndist 0.0 idx 3890\npyknn ib 0, in 3890, ip 1 dist 0.0 idx 3890\ndist 0.0 idx 1426\npyknn ib 0, in 3890, ip 6 dist 0.0032750004902482033 idx 2328\ndist 0.0032750368118286133 idx 3774\npyknn ib 0, in 3890, ip 7 dist 0.0032750004902482033 idx 3774\ndist 0.0032750368118286133 idx 2328\npyknn ib 0, in 3894, ip 4 dist 0.002228998579084873 idx 1254\ndist 0.0022287368774414062 idx 2552\npyknn ib 0, in 3894, ip 5 dist 0.002228998579084873 idx 2552\ndist 0.0022287368774414062 idx 1254\npyknn ib 0, in 3899, ip 11 dist 0.006374003365635872 idx 497\ndist 0.006373763084411621 idx 2785\npyknn ib 0, in 3899, ip 12 dist 0.006374003365635872 idx 2785\ndist 0.006373763084411621 idx 497\npyknn ib 0, in 3902, ip 2 dist 0.000996999442577362 idx 1333\ndist 0.0009969770908355713 idx 1388\npyknn ib 0, in 3902, ip 3 dist 0.000996999442577362 idx 1388\ndist 0.0009969770908355713 idx 1333\npyknn ib 0, in 3906, ip 11 dist 0.008240998722612858 idx 768\ndist 0.00824098289012909 idx 2765\npyknn ib 0, in 3906, ip 12 dist 0.008240998722612858 idx 2765\ndist 0.00824098289012909 idx 768\npyknn ib 0, in 3909, ip 0 dist 0.0 idx 744\ndist 0.0 idx 3909\npyknn ib 0, in 3909, ip 1 dist 0.0 idx 3909\ndist 0.0 idx 744\npyknn ib 0, in 3909, ip 3 dist 0.0003130019176751375 idx 1031\ndist 0.00031256675720214844 idx 2711\npyknn ib 0, in 3909, ip 4 dist 0.0003130019176751375 idx 1100\ndist 0.00031256675720214844 idx 1031\npyknn ib 0, in 3909, ip 5 dist 0.0003130019176751375 idx 2711\ndist 0.00031256675720214844 idx 1100\npyknn ib 0, in 3911, ip 3 dist 0.0003949997771997005 idx 2143\ndist 0.00039499253034591675 idx 4072\npyknn ib 0, in 3911, ip 4 dist 0.0003949997771997005 idx 4072\ndist 0.00039499253034591675 idx 2143\npyknn ib 0, in 3912, ip 18 dist 0.007466008421033621 idx 476\ndist 0.007465362548828125 idx 784\npyknn ib 0, in 3912, ip 19 dist 0.007466008421033621 idx 784\ndist 0.007465362548828125 idx 476\npyknn ib 0, in 3916, ip 12 dist 0.00708600040525198 idx 488\ndist 0.007086008787155151 idx 2434\npyknn ib 0, in 3916, ip 13 dist 0.00708600040525198 idx 2434\ndist 0.007086008787155151 idx 488\npyknn ib 0, in 3918, ip 13 dist 0.009893002919852734 idx 3325\ndist 0.009893059730529785 idx 3729\npyknn ib 0, in 3918, ip 14 dist 0.009893002919852734 idx 3729\ndist 0.009893059730529785 idx 3325\npyknn ib 0, in 3918, ip 18 dist 0.012113000266253948 idx 1426\ndist 0.012112975120544434 idx 3890\npyknn ib 0, in 3918, ip 19 dist 0.012113000266253948 idx 3890\ndist 0.012112975120544434 idx 1426\npyknn ib 0, in 3921, ip 3 dist 0.003403998911380768 idx 281\ndist 0.003403991460800171 idx 2437\npyknn ib 0, in 3921, ip 4 dist 0.003403998911380768 idx 2437\ndist 0.003403991460800171 idx 281\npyknn ib 0, in 3931, ip 5 dist 0.0017810005228966475 idx 2701\ndist 0.001781463623046875 idx 3754\npyknn ib 0, in 3931, ip 6 dist 0.0017810005228966475 idx 3754\ndist 0.001781463623046875 idx 2701\npyknn ib 0, in 3933, ip 0 dist 0.0 idx 2745\ndist -4.76837158203125e-07 idx 3933\npyknn ib 0, in 3933, ip 1 dist 0.0 idx 3933\ndist -4.76837158203125e-07 idx 2745\npyknn ib 0, in 3936, ip 13 dist 0.013471986167132854 idx 1031\ndist 0.013471603393554688 idx 1100\npyknn ib 0, in 3936, ip 14 dist 0.013471986167132854 idx 1100\ndist 0.013471603393554688 idx 2711\npyknn ib 0, in 3936, ip 15 dist 0.013471986167132854 idx 2711\ndist 0.013471603393554688 idx 1031\npyknn ib 0, in 3936, ip 16 dist 0.013521000742912292 idx 744\ndist 0.013520956039428711 idx 3909\npyknn ib 0, in 3936, ip 17 dist 0.013521000742912292 idx 3909\ndist 0.013520956039428711 idx 744\npyknn ib 0, in 3938, ip 4 dist 0.004649000242352486 idx 1555\ndist 0.004649162292480469 idx 2866\npyknn ib 0, in 3938, ip 5 dist 0.004649000242352486 idx 2866\ndist 0.004649162292480469 idx 1555\npyknn ib 0, in 3939, ip 0 dist 0.0 idx 1248\ndist 0.0 idx 3939\npyknn ib 0, in 3939, ip 1 dist 0.0 idx 3939\ndist 0.0 idx 1248\npyknn ib 0, in 3940, ip 2 dist 0.002899995306506753 idx 1231\ndist 0.002899169921875 idx 533\npyknn ib 0, in 3940, ip 3 dist 0.002900000661611557 idx 533\ndist 0.002899646759033203 idx 1231\npyknn ib 0, in 3940, ip 14 dist 0.00899400096386671 idx 1021\ndist 0.008993148803710938 idx 1857\npyknn ib 0, in 3940, ip 15 dist 0.00899400096386671 idx 1857\ndist 0.008993148803710938 idx 1021\npyknn ib 0, in 3942, ip 1 dist 0.0005389998550526798 idx 2767\ndist 0.0005390048027038574 idx 3503\npyknn ib 0, in 3942, ip 2 dist 0.0005389998550526798 idx 3503\ndist 0.0005390048027038574 idx 2767\npyknn ib 0, in 3943, ip 5 dist 0.002406000392511487 idx 1426\ndist 0.002406001091003418 idx 3890\npyknn ib 0, in 3943, ip 6 dist 0.002406000392511487 idx 3890\ndist 0.002406001091003418 idx 1426\npyknn ib 0, in 3943, ip 9 dist 0.004201000090688467 idx 2328\ndist 0.004200935363769531 idx 3774\npyknn ib 0, in 3943, ip 10 dist 0.004201000090688467 idx 3774\ndist 0.004200935363769531 idx 2328\npyknn ib 0, in 3950, ip 8 dist 0.003989000804722309 idx 1718\ndist 0.003989040851593018 idx 2775\npyknn ib 0, in 3950, ip 9 dist 0.003989000804722309 idx 2775\ndist 0.003989040851593018 idx 1718\npyknn ib 0, in 3951, ip 8 dist 0.004125999752432108 idx 2266\ndist 0.004126548767089844 idx 3388\npyknn ib 0, in 3951, ip 9 dist 0.004125999752432108 idx 3388\ndist 0.004126548767089844 idx 2266\npyknn ib 0, in 3952, ip 5 dist 0.003297999268397689 idx 744\ndist 0.0032978057861328125 idx 3909\npyknn ib 0, in 3952, ip 6 dist 0.003297999268397689 idx 3909\ndist 0.0032978057861328125 idx 744\npyknn ib 0, in 3952, ip 9 dist 0.005625006277114153 idx 1031\ndist 0.005624532699584961 idx 2711\npyknn ib 0, in 3952, ip 11 dist 0.005625006277114153 idx 2711\ndist 0.005624532699584961 idx 1031\npyknn ib 0, in 3953, ip 9 dist 0.009367999620735645 idx 542\ndist 0.009368062019348145 idx 1590\npyknn ib 0, in 3953, ip 10 dist 0.009367999620735645 idx 1590\ndist 0.009368062019348145 idx 542\npyknn ib 0, in 3953, ip 16 dist 0.014188993722200394 idx 798\ndist 0.014188885688781738 idx 3397\npyknn ib 0, in 3953, ip 17 dist 0.014188996516168118 idx 3397\ndist 0.014189004898071289 idx 798\npyknn ib 0, in 3955, ip 6 dist 0.0023769985418766737 idx 3325\ndist 0.002377033233642578 idx 3729\npyknn ib 0, in 3955, ip 7 dist 0.0023769985418766737 idx 3729\ndist 0.002377033233642578 idx 3325\npyknn ib 0, in 3959, ip 6 dist 0.0041410005651414394 idx 2780\ndist 0.004140615463256836 idx 3638\npyknn ib 0, in 3959, ip 7 dist 0.0041410005651414394 idx 3638\ndist 0.004140615463256836 idx 2780\npyknn ib 0, in 3962, ip 4 dist 0.001824999344535172 idx 768\ndist 0.0018250048160552979 idx 2765\npyknn ib 0, in 3962, ip 5 dist 0.001824999344535172 idx 2765\ndist 0.0018250048160552979 idx 768\npyknn ib 0, in 3962, ip 11 dist 0.0032780019100755453 idx 281\ndist 0.003278002142906189 idx 2437\npyknn ib 0, in 3962, ip 12 dist 0.0032780019100755453 idx 2437\ndist 0.003278002142906189 idx 281\npyknn ib 0, in 3971, ip 12 dist 0.007450995501130819 idx 1157\ndist 0.007451057434082031 idx 2023\npyknn ib 0, in 3971, ip 13 dist 0.007450995501130819 idx 2023\ndist 0.007451057434082031 idx 1157\npyknn ib 0, in 3976, ip 1 dist 0.0003900023002643138 idx 963\ndist 0.00039005279541015625 idx 3703\npyknn ib 0, in 3976, ip 2 dist 0.0003900023002643138 idx 3703\ndist 0.00039005279541015625 idx 963\npyknn ib 0, in 3977, ip 5 dist 0.003753000171855092 idx 767\ndist 0.0037530213594436646 idx 1375\npyknn ib 0, in 3977, ip 6 dist 0.003753000171855092 idx 954\ndist 0.0037530213594436646 idx 767\npyknn ib 0, in 3977, ip 7 dist 0.003753000171855092 idx 1375\ndist 0.0037530213594436646 idx 954\npyknn ib 0, in 3982, ip 0 dist 0.0 idx 1018\ndist 0.0 idx 3982\npyknn ib 0, in 3982, ip 1 dist 0.0 idx 3982\ndist 0.0 idx 1018\npyknn ib 0, in 3987, ip 3 dist 0.0009689986472949386 idx 282\ndist 0.0009691715240478516 idx 2323\npyknn ib 0, in 3987, ip 4 dist 0.0009689986472949386 idx 2323\ndist 0.0009691715240478516 idx 282\npyknn ib 0, in 3988, ip 8 dist 0.004057002253830433 idx 2745\ndist 0.004056692123413086 idx 3933\npyknn ib 0, in 3988, ip 9 dist 0.004057002253830433 idx 3933\ndist 0.004056692123413086 idx 2745\npyknn ib 0, in 3989, ip 7 dist 0.007250993978232145 idx 1031\ndist 0.007250308990478516 idx 1100\npyknn ib 0, in 3989, ip 8 dist 0.007250993978232145 idx 1100\ndist 0.007250308990478516 idx 1031\npyknn ib 0, in 3989, ip 14 dist 0.010538001544773579 idx 744\ndist 0.010537862777709961 idx 3909\npyknn ib 0, in 3989, ip 15 dist 0.010538001544773579 idx 3909\ndist 0.010537862777709961 idx 744\npyknn ib 0, in 3996, ip 0 dist 0.0 idx 2854\ndist 0.0 idx 3996\npyknn ib 0, in 3996, ip 1 dist 0.0 idx 3996\ndist 0.0 idx 2854\npyknn ib 0, in 3999, ip 12 dist 0.010126007720828056 idx 1018\ndist 0.010125875473022461 idx 3982\npyknn ib 0, in 3999, ip 13 dist 0.010126007720828056 idx 3982\ndist 0.010125875473022461 idx 1018\npyknn ib 0, in 4005, ip 11 dist 0.004081999883055687 idx 193\ndist 0.004082083702087402 idx 231\npyknn ib 0, in 4005, ip 12 dist 0.004081999883055687 idx 231\ndist 0.004082083702087402 idx 193\npyknn ib 0, in 4007, ip 7 dist 0.0034770015627145767 idx 1800\ndist 0.003475189208984375 idx 2901\npyknn ib 0, in 4007, ip 8 dist 0.0034770015627145767 idx 2901\ndist 0.003475189208984375 idx 1800\npyknn ib 0, in 4011, ip 4 dist 0.0019210001919418573 idx 281\ndist 0.0019209980964660645 idx 2437\npyknn ib 0, in 4011, ip 5 dist 0.0019210001919418573 idx 2437\ndist 0.0019209980964660645 idx 281\npyknn ib 0, in 4011, ip 8 dist 0.0032220007851719856 idx 768\ndist 0.0032220035791397095 idx 2765\npyknn ib 0, in 4011, ip 9 dist 0.0032220007851719856 idx 2765\ndist 0.0032220035791397095 idx 768\npyknn ib 0, in 4015, ip 6 dist 0.0012199964839965105 idx 1925\ndist 0.0012197494506835938 idx 2416\npyknn ib 0, in 4015, ip 7 dist 0.0012199964839965105 idx 2416\ndist 0.0012197494506835938 idx 1925\npyknn ib 0, in 4017, ip 9 dist 0.0036890103947371244 idx 366\ndist 0.003688812255859375 idx 3555\npyknn ib 0, in 4017, ip 10 dist 0.0036890103947371244 idx 3555\ndist 0.003688812255859375 idx 366\npyknn ib 0, in 4019, ip 8 dist 0.003205000888556242 idx 1225\ndist 0.0032033920288085938 idx 1637\npyknn ib 0, in 4019, ip 9 dist 0.003205000888556242 idx 1637\ndist 0.0032033920288085938 idx 1225\npyknn ib 0, in 4026, ip 7 dist 0.002222006907686591 idx 595\ndist 0.0022215843200683594 idx 2077\npyknn ib 0, in 4026, ip 8 dist 0.002222006907686591 idx 2077\ndist 0.0022215843200683594 idx 595\npyknn ib 0, in 4032, ip 12 dist 0.007041999604552984 idx 792\ndist 0.0070416927337646484 idx 974\npyknn ib 0, in 4032, ip 13 dist 0.007041999604552984 idx 974\ndist 0.0070416927337646484 idx 792\npyknn ib 0, in 4038, ip 2 dist 0.0010400002356618643 idx 636\ndist 0.0010400041937828064 idx 3362\npyknn ib 0, in 4038, ip 3 dist 0.0010400002356618643 idx 3362\ndist 0.0010400041937828064 idx 636\npyknn ib 0, in 4047, ip 5 dist 0.0014030011370778084 idx 719\ndist 0.0014026165008544922 idx 3707\npyknn ib 0, in 4047, ip 6 dist 0.0014030011370778084 idx 3707\ndist 0.0014026165008544922 idx 719\npyknn ib 0, in 4050, ip 0 dist 0.0 idx 2397\ndist 0.0 idx 4050\npyknn ib 0, in 4050, ip 1 dist 0.0 idx 4050\ndist 0.0 idx 2397\npyknn ib 0, in 4058, ip 6 dist 0.0026439952198415995 idx 1225\ndist 0.0026445388793945312 idx 1637\npyknn ib 0, in 4058, ip 7 dist 0.0026439952198415995 idx 1637\ndist 0.0026445388793945312 idx 1225\npyknn ib 0, in 4058, ip 8 dist 0.0026499878149479628 idx 29\ndist 0.0026502609252929688 idx 1466\npyknn ib 0, in 4058, ip 9 dist 0.0026499878149479628 idx 1466\ndist 0.0026502609252929688 idx 29\npyknn ib 0, in 4058, ip 19 dist 0.009620998986065388 idx 1176\ndist 0.00962066650390625 idx 2555\npyknn ib 0, in 4061, ip 10 dist 0.006673999130725861 idx 3462\ndist 0.006673991680145264 idx 3465\npyknn ib 0, in 4061, ip 11 dist 0.006673999130725861 idx 3465\ndist 0.006673991680145264 idx 3462\npyknn ib 0, in 4062, ip 3 dist 0.001948998891748488 idx 315\ndist 0.0019488334655761719 idx 3219\npyknn ib 0, in 4062, ip 4 dist 0.001948998891748488 idx 3219\ndist 0.0019488334655761719 idx 315\npyknn ib 0, in 4063, ip 1 dist 6.1000100686214864e-05 idx 1951\ndist 6.097555160522461e-05 idx 2710\npyknn ib 0, in 4063, ip 2 dist 6.1000100686214864e-05 idx 2710\ndist 6.097555160522461e-05 idx 1951\npyknn ib 0, in 4063, ip 9 dist 0.006617994979023933 idx 1161\ndist 0.006617993116378784 idx 2641\npyknn ib 0, in 4063, ip 10 dist 0.006617994979023933 idx 2641\ndist 0.006617993116378784 idx 1161\npyknn ib 0, in 4065, ip 5 dist 0.0018000002019107342 idx 2790\ndist 0.001800537109375 idx 3722\npyknn ib 0, in 4065, ip 6 dist 0.0018000002019107342 idx 3722\ndist 0.001800537109375 idx 2790\npyknn ib 0, in 4065, ip 8 dist 0.0027250039856880903 idx 1906\ndist 0.0027251243591308594 idx 3635\npyknn ib 0, in 4065, ip 9 dist 0.0027250039856880903 idx 3635\ndist 0.0027251243591308594 idx 1906\npyknn ib 0, in 4066, ip 0 dist 0.0 idx 3519\ndist 0.0 idx 4066\npyknn ib 0, in 4066, ip 1 dist 0.0 idx 4066\ndist 0.0 idx 3519\npyknn ib 0, in 4066, ip 2 dist 0.0004419961478561163 idx 829\ndist 0.00044155120849609375 idx 3173\npyknn ib 0, in 4066, ip 3 dist 0.0004419961478561163 idx 3173\ndist 0.00044155120849609375 idx 829\npyknn ib 0, in 4070, ip 9 dist 0.004648996517062187 idx 1248\ndist 0.004649162292480469 idx 3939\npyknn ib 0, in 4070, ip 10 dist 0.004648996517062187 idx 3939\ndist 0.004649162292480469 idx 1248\npyknn ib 0, in 4072, ip 0 dist 0.0 idx 2143\ndist 0.0 idx 4072\npyknn ib 0, in 4072, ip 1 dist 0.0 idx 4072\ndist 0.0 idx 2143\npyknn ib 0, in 4074, ip 1 dist 0.0005799981881864369 idx 1259\ndist 0.0005799531936645508 idx 310\npyknn ib 0, in 4074, ip 2 dist 0.0005799999344162643 idx 310\ndist 0.0005799531936645508 idx 1259\npyknn ib 0, in 4083, ip 3 dist 0.0021730000153183937 idx 965\ndist 0.0021734237670898438 idx 1552\npyknn ib 0, in 4083, ip 4 dist 0.0021730000153183937 idx 1552\ndist 0.0021734237670898438 idx 965\npyknn ib 0, in 4087, ip 2 dist 0.00047799956519156694 idx 991\ndist 0.000476837158203125 idx 2895\npyknn ib 0, in 4087, ip 3 dist 0.00047799956519156694 idx 2895\ndist 0.000476837158203125 idx 991\npyknn ib 0, in 4088, ip 15 dist 0.012462000362575054 idx 965\ndist 0.012462615966796875 idx 1552\npyknn ib 0, in 4088, ip 16 dist 0.012462000362575054 idx 1552\ndist 0.012462615966796875 idx 965\npyknn ib 0, in 4089, ip 0 dist 0.0 idx 3631\ndist 0.0 idx 4089\npyknn ib 0, in 4089, ip 1 dist 0.0 idx 4089\ndist 0.0 idx 3631\nCHECK1: True\n\"\"\"\n\n# print(idx)\n\n# speed test\n# loader = DataLoader(\n# dataset,\n# batch_size=2,\n# num_workers=8,\n# pin_memory=True,\n# shuffle=False\n# )\n# speed_test(0, loader)\n# speed_test(1, loader)\n# speed_test(2, loader)\n# speed_test(3, loader)\n"
] | [
[
"torch.set_printoptions",
"numpy.set_printoptions",
"torch.tensor"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mjlbach/iGibson-baselines | [
"c97d310b99f848ba2469eacdc6a84888f990bcd3"
] | [
"ray/eric_model_bak.py"
] | [
"\"\"\"\nExample showing how to wrap the iGibson class using ray for rllib.\nMultiple environments are only supported on Linux. If issues arise, please ensure torch/numpy\nare installed *without* MKL support.\n\nThis example requires ray to be installed with rllib support, and pytorch to be installed:\n `pip install torch \"ray[rllib]\"`\n\nNote: rllib only supports a single observation modality:\n\"\"\"\nimport argparse\n\nfrom igibson.envs.igibson_env import iGibsonEnv\n\nimport os\n\nfrom ray import tune\nfrom ray.rllib.models import ModelCatalog\nfrom ray.rllib.models.torch.torch_modelv2 import TorchModelV2\nfrom ray.rllib.models.torch.fcnet import FullyConnectedNetwork as TorchFC\nfrom ray.tune.registry import register_env\n\nimport ray\nimport torch\nimport torch.nn as nn\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport igibson\n\n\n# Eric's structure\n# MultiInputActorCriticPolicy(\n# (features_extractor): CombinedExtractor(\n# (extractors): ModuleDict(\n# (depth): NatureCNN(\n# (cnn): Sequential(\n# (0): Conv2d(1, 32, kernel_size=(8, 8), stride=(4, 4))\n# (1): ReLU()\n# (2): Conv2d(32, 64, kernel_size=(4, 4), stride=(2, 2))\n# (3): ReLU()\n# (4): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))\n# (5): ReLU()\n# (6): Flatten()\n# )\n# (linear): Sequential(\n# (0): Linear(in_features=11264, out_features=256, bias=True)\n# (1): ReLU()\n# )\n# )\n# (rgb): NatureCNN(\n# (cnn): Sequential(\n# (0): Conv2d(3, 32, kernel_size=(8, 8), stride=(4, 4))\n# (1): ReLU()\n# (2): Conv2d(32, 64, kernel_size=(4, 4), stride=(2, 2))\n# (3): ReLU()\n# (4): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))\n# (5): ReLU()\n# (6): Flatten()\n# )\n# (linear): Sequential(\n# (0): Linear(in_features=11264, out_features=256, bias=True)\n# (1): ReLU()\n# )\n# )\n# (scan): Flatten()\n# (task_obs): Flatten()\n# )\n# )\n# (mlp_extractor): MlpExtractor(\n# (shared_net): Sequential()\n# (policy_net): Sequential(\n# (0): Linear(in_features=744, out_features=64, bias=True)\n# (1): Tanh()\n# (2): Linear(in_features=64, out_features=64, bias=True)\n# (3): Tanh()\n# )\n# (value_net): Sequential(\n# (0): Linear(in_features=744, out_features=64, bias=True)\n# (1): Tanh()\n# (2): Linear(in_features=64, out_features=64, bias=True)\n# (3): Tanh()\n# )\n# )\n# (action_net): Linear(in_features=64, out_features=2, bias=True)\n# (value_net): Linear(in_features=64, out_features=1, bias=True)\n# )\n# ray.init(local_mode=True)\nray.init()\n\n\nclass FC(nn.Module):\n\n def __init__(self, in_shape=232, out_shape=2):\n super(FC, self).__init__()\n self.fc1 = nn.Linear(in_shape, 64, bias=True)\n self.fc2 = nn.Linear(64, out_shape, bias=True)\n\n def forward(self, x):\n x = torch.tanh(self.fc1(x))\n x = torch.tanh(self.fc2(x))\n return x\n\nclass iGibsonPPOModel(TorchModelV2, nn.Module):\n \"\"\"Example of a PyTorch custom model that just delegates to a fc-net.\"\"\"\n\n def __init__(self, obs_space, action_space, num_outputs, model_config,\n name):\n TorchModelV2.__init__(self, obs_space, action_space, num_outputs,\n model_config, name)\n nn.Module.__init__(self)\n\n self.value_head = FC(in_shape=232, out_shape=1)\n self.action_head = FC(in_shape=232, out_shape=2)\n\n def forward(self, input_dict, state, seq_lens):\n obs = input_dict['obs']\n obs[\"task_obs\"] = obs[\"task_obs\"].float().flatten(start_dim=1)\n obs[\"scan\"] = obs[\"scan\"].float().flatten(start_dim=1)\n\n policy_input = torch.cat([\n obs[\"task_obs\"],\n obs[\"scan\"],\n ],\n dim=1\n )\n\n self._value_out = torch.flatten(self.value_head(policy_input))\n action_out = self.action_head(policy_input)\n\n return action_out, []\n\n def value_function(self):\n return self._value_out\n\n\n\nclass iGibsonRayEnv(iGibsonEnv):\n def __init__(self, env_config):\n super().__init__(\n config_file=env_config['config_file'],\n mode=env_config['mode'],\n action_timestep=env_config['action_timestep'],\n physics_timestep=env_config['physics_timestep'],\n )\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--config',\n '-c',\n default=os.path.join(igibson.root_path, \"examples\", \"configs\", \"turtlebot_point_nav.yaml\"),\n help='which config file to use [default: use yaml files in examples/configs]')\n parser.add_argument(\n '--ray_mode',\n default=\"train\",\n help='Whether to run ray in train or test mode')\n parser.add_argument(\n '--local_dir',\n default=None,\n help='Directory where to save model logs and default checkpoints')\n parser.add_argument(\n '--resume',\n type=str,\n default=None,\n choices=[None, \"PROMPT\"],\n help='Whether to resume the experiment. Note this does *not* restore the checkpoint, just re-uses the same config/log.')\n parser.add_argument(\n '--restore_checkpoint',\n default=None,\n help='Checkpoint to force restore')\n parser.add_argument('--exp_name',\n default='my_igibson_run',\n help='which mode for simulation (default: headless)')\n parser.add_argument('--mode',\n '-m',\n choices=['headless', 'gui', 'iggui'],\n default='headless',\n help='which mode for simulation (default: headless)')\n \n args = parser.parse_args()\n\n ModelCatalog.register_custom_model(\"iGibsonPPOModel\", iGibsonPPOModel)\n register_env(\"iGibsonEnv\", lambda c: iGibsonRayEnv(c))\n # See here for stable-baselines3 defaults\n #https://github.com/DLR-RM/stable-baselines3/blob/2fa06ae8d24662a40a7c247dd96625bebf182dce/stable_baselines3/ppo/ppo.py#L69-L91\n # Things currently missing/not confirmed to be equal\n # num_epochs\n # clip_range\n # clip_range_vf\n # not sure GAE/lambda matches\n # not sure if observation filtering matches\n config = {\n \"env\" : \"iGibsonEnv\",\n \"env_config\" : {\n \"config_file\": args.config,\n \"mode\": args.mode,\n # matches eric\n \"action_timestep\": 1.0 / 10.0,\n # matches eric\n \"physics_timestep\": 1.0 / 120.0\n },\n #ray specific\n \"num_gpus\": 1,\n # ray specific\n \"num_cpus_for_driver\": 5,\n # \"remote_worker_envs\": True,\n # number of workers == number of environments, confirmed match\n \"num_workers\": 8,\n # ray specific\n \"num_envs_per_worker\": 1,\n # ray specific\n \"num_cpus_per_worker\": 5,\n # normalization, none for now\n # \"observation_filter\": \"MeanStdFilter\",\n \"horizon\": 3000,\n # equivalent to buffer size (num_envs * n_steps)\n \"train_batch_size\": 16384,\n # equivalent to learning rate, confirmed match\n \"lr\": 3e-4,\n # equivalent to n_steps, confirmed match\n \"rollout_fragment_length\": 2048,\n # equivalent to batch_size, confirmed match\n \"sgd_minibatch_size\": 64,\n # equivalent to num_epochs... maybe??\n \"num_sgd_iter\": 10,\n # kl_target (none in stable-basdelines3)\n #https://github.com/ray-project/ray/blob/06f6f4e0ecb4aa549af274aebc5e6028b9d866e3/rllib/agents/ppo/ppo_torch_policy.py#L185\n # kl_coeff (None in stable-baselinse3\n #https://github.com/ray-project/ray/blob/06f6f4e0ecb4aa549af274aebc5e6028b9d866e3/rllib/agents/ppo/ppo_torch_policy.py#L183\n #https://github.com/DLR-RM/stable-baselines3/blob/2fa06ae8d24662a40a7c247dd96625bebf182dce/stable_baselines3/ppo/ppo.py#L76\n \"gamma\": 0.99,\n \"use_gae\": True,\n # Equivalent to GAE lambda?\n \"lambda\": 0.95,\n # MISSING CLIP_RANGE\n # MISSING CLIP_RANGE_VF\n #https://github.com/ray-project/ray/blob/06f6f4e0ecb4aa549af274aebc5e6028b9d866e3/rllib/agents/ppo/ppo_torch_policy.py#L245\n \"entropy_coeff\": 0.0,\n \"vf_loss_coeff\": 0.5,\n # MISSING MAX_GRAD_NORM\n # Everything else from this point on set to false or none in constructor\n \"model\": {\n \"custom_model\": \"iGibsonPPOModel\",\n },\n \"framework\": \"torch\"\n }\n stop={\"training_iteration\": 100000}\n if args.resume is not None:\n assert args.restore_checkpoint is not None, \"Error: When resuming must provide explicit path to checkpoint\"\n\n results = tune.run(\"PPO\",\n config=config,\n verbose=2,\n restore=args.restore_checkpoint,\n name=args.exp_name,\n local_dir=args.local_dir,\n checkpoint_freq=100, \n resume=args.resume\n)\n"
] | [
[
"torch.nn.Linear",
"torch.nn.Module.__init__",
"torch.cat"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
danielemingolla/sentiment_analysis_performances_comparison | [
"03c73257582f5a92285f8438c7390b0c806c31b1"
] | [
"src/models/train_LSTM.py"
] | [
"from keras.layers import Dense, Dropout, Embedding, LSTM, GlobalMaxPooling1D, SpatialDropout1D, Flatten\nfrom keras.models import Sequential\nfrom keras.utils import to_categorical\nfrom keras import layers\nfrom keras.preprocessing.sequence import pad_sequences\nfrom keras.preprocessing.text import Tokenizer\nimport pandas as pd\nfrom sklearn.metrics import classification_report\nfrom sklearn.model_selection import train_test_split\nimport os\nfrom keras.wrappers.scikit_learn import KerasClassifier\nfrom sklearn.model_selection import RandomizedSearchCV\nimport numpy as np\nfrom datetime import datetime\nfrom matplotlib import pyplot as plt\nfrom sklearn.externals import joblib\nimport sys\nplt.style.use('ggplot')\n\n\ndef plot_history(history):\n accuracy = history.history['accuracy']\n val_acc = history.history['val_accuracy']\n loss = history.history['loss']\n val_loss = history.history['val_loss']\n x = range(1, len(loss) + 1)\n\n plt.figure(figsize=(12, 5))\n plt.subplot(1, 2, 1)\n plt.plot(x, accuracy, 'b', label='Training accuracy')\n plt.plot(x, val_acc, 'g', label='Validation accuracy')\n plt.title('Training and validation accuracy')\n plt.legend()\n plt.subplot(1, 2, 2)\n plt.plot(x, loss, 'b', label='Training loss')\n plt.plot(x, val_loss, 'g', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n plt.show()\n\n\ndef create_model(vocab_size, embedding_dim, maxlen, lstm_units):\n model_lstm = Sequential()\n model_lstm.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=maxlen))\n model_lstm.add(SpatialDropout1D(0.2))\n model_lstm.add(LSTM(lstm_units, dropout=0.1, recurrent_dropout=0.1))\n model_lstm.add(layers.Dense(3, activation='softmax'))\n model_lstm.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n return model_lstm\n\n\ndata_today = datetime.now().strftime(\"_%d_%m_%Y__%H_%M\")\ncurrent_directory = os.getcwd()\n\nlstm_name = \"LSTM_{}.h5\".format(data_today)\noutput_path = os.path.join(current_directory, '\\\\'.join(['models', lstm_name]))\nlog_file_name = os.path.join(current_directory, '\\\\'.join(['log', 'lstm_log.txt']))\ntokenizer_path = os.path.join(current_directory, '\\\\'.join(['transformer', \"lstm_tokenizer{}.pkl\".format(data_today)]))\n\n\ndf_clean = \"df_last.csv\"\ndataset = pd.read_csv(os.path.join(current_directory, '\\\\'.join(['df_pulito', df_clean])))\n\n# OVERPROVISIONING\nover_prov = dataset[(dataset.CLASSE == 2) | (dataset.CLASSE == 3)]\ndataset = pd.concat([dataset, over_prov])\n\nsentences = dataset['FRASE']\ny = dataset['CLASSE'].map({1: 0, 2: 1, 3: 2})\n\nS_train, S_test, y_train, y_test = train_test_split(sentences, y, test_size=0.25, random_state=42)\n\ntokenizer = Tokenizer(num_words=1600)\ntokenizer.fit_on_texts(S_train)\njoblib.dump(tokenizer, tokenizer_path)\nX_train = tokenizer.texts_to_sequences(S_train)\nX_test = tokenizer.texts_to_sequences(S_test)\n\nvocab_size = len(tokenizer.word_index) + 1\n\n\n# Main settings\nepochs = 10\nmaxlen = 30\nbatch_size = 128\nembedding_dim = 40\n\n# Pad sequences with zeros\nX_train = pad_sequences(X_train, padding='post', maxlen=maxlen)\nX_test = pad_sequences(X_test, padding='post', maxlen=maxlen)\n\nparam_grid = dict(\n vocab_size=[vocab_size],\n embedding_dim=[embedding_dim],\n maxlen=[maxlen],\n lstm_units=[50, 70, 80, 100]\n)\n\nmodel = KerasClassifier(build_fn=create_model,\n epochs=epochs, batch_size=batch_size,\n verbose=1)\n\ngrid = RandomizedSearchCV(estimator=model, param_distributions=param_grid,\n cv=5, verbose=1, n_iter=4, random_state=42)\n\ngrid_result = grid.fit(X_train, y_train)\n\n# get best parameters\nparams = grid_result.best_params_\n\ntest_model = create_model(vocab_size=params['vocab_size'],\n embedding_dim=params['embedding_dim'],\n maxlen=params['maxlen'],\n lstm_units=params['lstm_units'])\n\ny_train = to_categorical(y_train)\n\nhistory = test_model.fit(X_train, y_train,\n validation_split=0.1,\n epochs=epochs,\n batch_size=batch_size)\n\n# save model\ntest_model.save(output_path)\n\nplot_history(history)\n\ny_pred = test_model.predict_classes(X_test, batch_size=batch_size)\n\nprint(classification_report(y_test, y_pred))\n\n\n# save model's paramaters\nfile_object = open(log_file_name, 'a')\ntext_to_write = ('\\n{}\\n\\n{}\\n\\n{}\\n{}'.format(lstm_name, grid_result.best_params_, classification_report(y_test, y_pred), '*'*10))\nfile_object.write(text_to_write)\nfile_object.close()\n"
] | [
[
"sklearn.externals.joblib.dump",
"pandas.concat",
"matplotlib.pyplot.legend",
"sklearn.model_selection.RandomizedSearchCV",
"matplotlib.pyplot.title",
"sklearn.model_selection.train_test_split",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.show",
"sklearn.metrics.classification_report",
"matplotlib.pyplot.style.use",
"matplotlib.pyplot.figure"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
babayigit-arge/fire-smoke-detect-yolov4 | [
"c195d2d4d5b7c4fcf53142ac22b3fc2b96ace8d8",
"c195d2d4d5b7c4fcf53142ac22b3fc2b96ace8d8",
"c195d2d4d5b7c4fcf53142ac22b3fc2b96ace8d8"
] | [
"yolov4/scripts/process_fire_temp.py",
"yolov5/utils/google_utils.py",
"yolov4/yolov4_to_onnx/yolov4_to_onnx.py"
] | [
"'''\n 处理火灾检测数据集 VOC2020\n'''\nimport os\nimport numpy as np\n\n# xml_root = r'/home/ailab/dataset/Security_check/VOC2020/Annotations/'\n# xmls = os.listdir(xml_root)\n# f =open(r'/home/ailab/dataset/Security_check/VOC2020/ImageSets/Main/train.txt', 'w')\n# for xml in xmls:\n# f.write(xml.split('.')[0]+'\\n')\n# f.close()\n\n\n\n# 处理安检图像\n# root = r'/home/ailab/dataset/hlw_fire_data/VOC2020/JPEGImages/'\n# f = open(r'/home/ailab/dataset/hlw_fire_data/VOC2020/2020_train.txt', 'w')\n# names = os.listdir(root)\n# for name in names:\n# print(name)\n# f.write(os.path.join(root, name)+'\\n')\n# f.close()\n\n''' 区分train test '''\nnames = os.listdir(r'/home/ailab/dataset/hlw_fire_data/VOC2020/JPEGImages')\nnames = [name for name in names if name.endswith('.jpg')]\nnum = len(names)\n# 打乱\nnp.random.shuffle(names)\n\ntrain_txt = open('', 'w')\ntest_txt = open('', 'w')\n\nfor i in range(num):\n # train\n if i < (num*4 // 5):\n train_txt.write(names[i].split('.')[0]+'\\n')\n else:\n test_txt.write(names[i].split('.')[0]+'\\n')\ntrain_txt.close()\ntest_txt.close()\n\n",
"# This file contains google utils: https://cloud.google.com/storage/docs/reference/libraries\n# pip install --upgrade google-cloud-storage\n# from google.cloud import storage\n\nimport os\nimport platform\nimport time\nfrom pathlib import Path\nimport torch\n\n\ndef attempt_download(weights):\n # Attempt to download pretrained weights if not found locally\n weights = weights.strip().replace(\"'\", '')\n file = Path(weights).name\n\n msg = weights + ' missing, try downloading from https://github.com/ultralytics/yolov5/releases/'\n models = ['yolov5s.pt', 'yolov5m.pt', 'yolov5l.pt', 'yolov5x.pt'] # available models\n\n if file in models and not os.path.isfile(weights):\n # Google Drive\n # d = {'yolov5s.pt': '1R5T6rIyy3lLwgFXNms8whc-387H0tMQO',\n # 'yolov5m.pt': '1vobuEExpWQVpXExsJ2w-Mbf3HJjWkQJr',\n # 'yolov5l.pt': '1hrlqD1Wdei7UT4OgT785BEk1JwnSvNEV',\n # 'yolov5x.pt': '1mM8aZJlWTxOg7BZJvNUMrTnA2AbeCVzS'}\n # r = gdrive_download(id=d[file], name=weights) if file in d else 1\n # if r == 0 and os.path.exists(weights) and os.path.getsize(weights) > 1E6: # check\n # return\n\n try: # GitHub\n url = 'https://github.com/ultralytics/yolov5/releases/download/v2.0/' + file\n print('Downloading %s to %s...' % (url, weights))\n if platform.system() == 'Darwin': # avoid MacOS python requests certificate error\n r = os.system('curl -L %s -o %s' % (url, weights))\n else:\n torch.hub.download_url_to_file(url, weights)\n assert os.path.exists(weights) and os.path.getsize(weights) > 1E6 # check\n except Exception as e: # GCP\n print('Download error: %s' % e)\n url = 'https://storage.googleapis.com/ultralytics/yolov5/ckpt/' + file\n print('Downloading %s to %s...' % (url, weights))\n r = os.system('curl -L %s -o %s' % (url, weights)) # torch.hub.download_url_to_file(url, weights)\n finally:\n if not (os.path.exists(weights) and os.path.getsize(weights) > 1E6): # check\n os.remove(weights) if os.path.exists(weights) else None # remove partial downloads\n print('ERROR: Download failure: %s' % msg)\n print('')\n return\n\n\ndef gdrive_download(id='1n_oKgR81BJtqk75b00eAjdv03qVCQn2f', name='coco128.zip'):\n # Downloads a file from Google Drive. from utils.google_utils import *; gdrive_download()\n t = time.time()\n\n print('Downloading https://drive.google.com/uc?export=download&id=%s as %s... ' % (id, name), end='')\n os.remove(name) if os.path.exists(name) else None # remove existing\n os.remove('cookie') if os.path.exists('cookie') else None\n\n # Attempt file download\n out = \"NUL\" if platform.system() == \"Windows\" else \"/dev/null\"\n os.system('curl -c ./cookie -s -L \"drive.google.com/uc?export=download&id=%s\" > %s ' % (id, out))\n if os.path.exists('cookie'): # large file\n s = 'curl -Lb ./cookie \"drive.google.com/uc?export=download&confirm=%s&id=%s\" -o %s' % (get_token(), id, name)\n else: # small file\n s = 'curl -s -L -o %s \"drive.google.com/uc?export=download&id=%s\"' % (name, id)\n r = os.system(s) # execute, capture return\n os.remove('cookie') if os.path.exists('cookie') else None\n\n # Error check\n if r != 0:\n os.remove(name) if os.path.exists(name) else None # remove partial\n print('Download error ') # raise Exception('Download error')\n return r\n\n # Unzip if archive\n if name.endswith('.zip'):\n print('unzipping... ', end='')\n os.system('unzip -q %s' % name) # unzip\n os.remove(name) # remove zip to free space\n\n print('Done (%.1fs)' % (time.time() - t))\n return r\n\n\ndef get_token(cookie=\"./cookie\"):\n with open(cookie) as f:\n for line in f:\n if \"download\" in line:\n return line.split()[-1]\n return \"\"\n\n# def upload_blob(bucket_name, source_file_name, destination_blob_name):\n# # Uploads a file to a bucket\n# # https://cloud.google.com/storage/docs/uploading-objects#storage-upload-object-python\n#\n# storage_client = storage.Client()\n# bucket = storage_client.get_bucket(bucket_name)\n# blob = bucket.blob(destination_blob_name)\n#\n# blob.upload_from_filename(source_file_name)\n#\n# print('File {} uploaded to {}.'.format(\n# source_file_name,\n# destination_blob_name))\n#\n#\n# def download_blob(bucket_name, source_blob_name, destination_file_name):\n# # Uploads a blob from a bucket\n# storage_client = storage.Client()\n# bucket = storage_client.get_bucket(bucket_name)\n# blob = bucket.blob(source_blob_name)\n#\n# blob.download_to_filename(destination_file_name)\n#\n# print('Blob {} downloaded to {}.'.format(\n# source_blob_name,\n# destination_file_name))\n",
"from __future__ import print_function\nfrom collections import OrderedDict\nimport onnx\nfrom onnx import helper\nfrom onnx import TensorProto\nimport numpy as np\nimport argparse\n\n'''\n此py文件转onnx，将3个输出transpose->reshape->concat后直接输出1个结果，并未将sigmoid结合进来！\n\n'''\n\nclass DarkNetParser(object):\n \"\"\"Definition of a parser for DarkNet-based YOLOv3-608 (only tested for this topology).\"\"\"\n\n def __init__(self, supported_layers):\n \"\"\"Initializes a DarkNetParser object.\n\n Keyword argument:\n supported_layers -- a string list of supported layers in DarkNet naming convention,\n parameters are only added to the class dictionary if a parsed layer is included.\n \"\"\"\n\n # A list of YOLOv3 layers containing dictionaries with all layer\n # parameters:\n self.layer_configs = OrderedDict()\n self.supported_layers = supported_layers\n self.layer_counter = 0\n\n def parse_cfg_file(self, cfg_file_path):\n \"\"\"Takes the yolov3.cfg file and parses it layer by layer,\n appending each layer's parameters as a dictionary to layer_configs.\n\n Keyword argument:\n cfg_file_path -- path to the yolov3.cfg file as string\n \"\"\"\n with open(cfg_file_path, 'r', encoding='utf-8') as cfg_file:\n remainder = cfg_file.read()\n while remainder is not None:\n layer_dict, layer_name, remainder = self._next_layer(remainder)\n if layer_dict is not None:\n self.layer_configs[layer_name] = layer_dict\n return self.layer_configs\n\n def _next_layer(self, remainder):\n \"\"\"Takes in a string and segments it by looking for DarkNet delimiters.\n Returns the layer parameters and the remaining string after the last delimiter.\n Example for the first Conv layer in yolo.cfg ...\n\n [convolutional]\n batch_normalize=1\n filters=32\n size=3\n stride=1\n pad=1\n activation=leaky\n\n ... becomes the following layer_dict return value:\n {'activation': 'leaky', 'stride': 1, 'pad': 1, 'filters': 32,\n 'batch_normalize': 1, 'type': 'convolutional', 'size': 3}.\n\n '001_convolutional' is returned as layer_name, and all lines that follow in yolo.cfg\n are returned as the next remainder.\n\n Keyword argument:\n remainder -- a string with all raw text after the previously parsed layer\n \"\"\"\n remainder = remainder.split('[', 1)\n if len(remainder) == 2:\n remainder = remainder[1]\n else:\n return None, None, None\n remainder = remainder.split(']', 1)\n if len(remainder) == 2:\n layer_type, remainder = remainder\n else:\n return None, None, None\n if remainder.replace(' ', '')[0] == '#':\n remainder = remainder.split('\\n', 1)[1]\n\n layer_param_block, remainder = remainder.split('\\n\\n', 1)\n layer_param_lines = layer_param_block.split('\\n')[1:]\n layer_name = str(self.layer_counter).zfill(3) + '_' + layer_type\n layer_dict = dict(type=layer_type)\n if layer_type in self.supported_layers:\n for param_line in layer_param_lines:\n if param_line[0] == '#':\n continue\n param_type, param_value = self._parse_params(param_line)\n layer_dict[param_type] = param_value\n else:\n for param_line in layer_param_lines:\n if 'class' in param_line:\n param_type, param_value = self._parse_params(param_line)\n layer_dict[param_type] = param_value\n if 'num' in param_line:\n param_type, param_value = self._parse_params(param_line)\n layer_dict[param_type] = param_value\n self.layer_counter += 1\n return layer_dict, layer_name, remainder\n\n def _parse_params(self, param_line):\n \"\"\"Identifies the parameters contained in one of the cfg file and returns\n them in the required format for each parameter type, e.g. as a list, an int or a float.\n\n Keyword argument:\n param_line -- one parsed line within a layer block\n \"\"\"\n param_line = param_line.replace(' ', '')\n param_type, param_value_raw = param_line.split('=')\n param_value = None\n if param_type == 'layers':\n layer_indexes = list()\n for index in param_value_raw.split(','):\n layer_indexes.append(int(index))\n param_value = layer_indexes\n elif isinstance(param_value_raw, str) and not param_value_raw.isalpha():\n condition_param_value_positive = param_value_raw.isdigit()\n condition_param_value_negative = param_value_raw[0] == '-' and \\\n param_value_raw[1:].isdigit()\n if condition_param_value_positive or condition_param_value_negative:\n param_value = int(param_value_raw)\n else:\n param_value = float(param_value_raw)\n else:\n param_value = str(param_value_raw)\n return param_type, param_value\n\nclass MajorNodeSpecs(object):\n \"\"\"Helper class used to store the names of ONNX output names,\n corresponding to the output of a DarkNet layer and its output channels.\n Some DarkNet layers are not created and there is no corresponding ONNX node,\n but we still need to track them in order to set up skip connections.\n \"\"\"\n\n def __init__(self, name, channels):\n \"\"\" Initialize a MajorNodeSpecs object.\n\n Keyword arguments:\n name -- name of the ONNX node\n channels -- number of output channels of this node\n \"\"\"\n self.name = name\n self.channels = channels\n self.created_onnx_node = False\n if name is not None and isinstance(channels, int) and channels > 0:\n self.created_onnx_node = True\n\nclass ConvParams(object):\n \"\"\"Helper class to store the hyper parameters of a Conv layer,\n including its prefix name in the ONNX graph and the expected dimensions\n of weights for convolution, bias, and batch normalization.\n\n Additionally acts as a wrapper for generating safe names for all\n weights, checking on feasible combinations.\n \"\"\"\n\n def __init__(self, node_name, batch_normalize, conv_weight_dims):\n \"\"\"Constructor based on the base node name (e.g. 101_convolutional), the batch\n normalization setting, and the convolutional weights shape.\n\n Keyword arguments:\n node_name -- base name of this YOLO convolutional layer\n batch_normalize -- bool value if batch normalization is used\n conv_weight_dims -- the dimensions of this layer's convolutional weights\n \"\"\"\n self.node_name = node_name\n self.batch_normalize = batch_normalize\n assert len(conv_weight_dims) == 4\n self.conv_weight_dims = conv_weight_dims\n\n def generate_param_name(self, param_category, suffix):\n \"\"\"Generates a name based on two string inputs,\n and checks if the combination is valid.\"\"\"\n assert suffix\n assert param_category in ['bn', 'conv']\n assert(suffix in ['scale', 'mean', 'var', 'weights', 'bias'])\n if param_category == 'bn':\n assert self.batch_normalize\n assert suffix in ['scale', 'bias', 'mean', 'var']\n elif param_category == 'conv':\n assert suffix in ['weights', 'bias']\n if suffix == 'bias':\n assert not self.batch_normalize\n param_name = self.node_name + '_' + param_category + '_' + suffix\n return param_name\n\n# yolov4增加的\nclass ResizeParams(object):\n # Helper class to store the scale parameter for an Resize node.\n\n def __init__(self, node_name, value):\n \"\"\"Constructor based on the base node name (e.g. 86_Resize),\n and the value of the scale input tensor.\n\n Keyword arguments:\n node_name -- base name of this YOLO Resize layer\n value -- the value of the scale input to the Resize layer as numpy array\n \"\"\"\n self.node_name = node_name\n self.value = value\n\n def generate_param_name(self):\n \"\"\"Generates the scale parameter name for the Resize node.\"\"\"\n param_name = self.node_name + '_' + \"scale\"\n return param_name\n\n# yolov4增加的\nclass ROIParams(object):\n # Helper class to store the scale parameter for an Resize node.\n\n def __init__(self, node_name, value):\n \"\"\"Constructor based on the base node name (e.g. 86_Resize),\n and the value of the scale input tensor.\n\n Keyword arguments:\n node_name -- base name of this YOLO Resize layer\n value -- the value of the scale input to the Resize layer as numpy array\n \"\"\"\n self.node_name = node_name\n self.value = value\n\n def generate_param_name(self):\n \"\"\"Generates the scale parameter name for the Resize node.\"\"\"\n param_name = self.node_name + '_' + \"roi\"\n return param_name\n\nclass ReshapeParams(object):\n # Helper class to store the scale parameter for an Resize node.\n\n def __init__(self, node_name, value):\n \"\"\"Constructor based on the base node name (e.g. 86_Resize),\n and the value of the scale input tensor.\n\n Keyword arguments:\n node_name -- base name of this YOLO Resize layer\n value -- the value of the scale input to the Resize layer as numpy array\n \"\"\"\n self.node_name = node_name\n self.value = value\n\n def generate_param_name(self):\n \"\"\"Generates the scale parameter name for the Resize node.\"\"\"\n param_name = self.node_name + '_' + \"shape\"\n return param_name\n\nclass WeightLoader(object):\n \"\"\"Helper class used for loading the serialized weights of a binary file stream\n and returning the initializers and the input tensors required for populating\n the ONNX graph with weights.\n \"\"\"\n\n def __init__(self, weights_file_path):\n \"\"\"Initialized with a path to the YOLOv3 .weights file.\n\n Keyword argument:\n weights_file_path -- path to the weights file.\n \"\"\"\n self.weights_file = self._open_weights_file(weights_file_path)\n\n def load_resize_scales(self, resize_params):\n \"\"\"\n Returns the initializers with the value of the scale input\n tensor given by resize_params.\n\n Keyword argument:\n resize_params -- a ResizeParams object\n \"\"\"\n initializer = list()\n inputs = list()\n name = resize_params.generate_param_name()\n shape = resize_params.value.shape\n data = resize_params.value\n scale_init = helper.make_tensor(\n name, TensorProto.FLOAT, shape, data)\n scale_input = helper.make_tensor_value_info(\n name, TensorProto.FLOAT, shape)\n initializer.append(scale_init)\n inputs.append(scale_input)\n return initializer, inputs\n\n def load_reshape_scales(self, reshape_params):\n \"\"\"\n Returns the initializers with the value of the reshape_params.\n\n Keyword argument:\n reshape_params -- a ReshapeParams object\n \"\"\"\n initializer = list()\n inputs = list()\n name = reshape_params.generate_param_name()\n shape = reshape_params.value.shape\n data = reshape_params.value\n scale_init = helper.make_tensor(\n name, TensorProto.INT64, shape, data)\n scale_input = helper.make_tensor_value_info(\n name, TensorProto.INT64, shape)\n initializer.append(scale_init)\n inputs.append(scale_input)\n return initializer, inputs\n\n def load_conv_weights(self, conv_params):\n \"\"\"Returns the initializers with weights from the weights file and\n the input tensors of a convolutional layer for all corresponding ONNX nodes.\n\n Keyword argument:\n conv_params -- a ConvParams object\n \"\"\"\n initializer = list()\n inputs = list()\n if conv_params.batch_normalize:\n bias_init, bias_input = self._create_param_tensors(\n conv_params, 'bn', 'bias')\n bn_scale_init, bn_scale_input = self._create_param_tensors(\n conv_params, 'bn', 'scale')\n bn_mean_init, bn_mean_input = self._create_param_tensors(\n conv_params, 'bn', 'mean')\n bn_var_init, bn_var_input = self._create_param_tensors(\n conv_params, 'bn', 'var')\n initializer.extend(\n [bn_scale_init, bias_init, bn_mean_init, bn_var_init])\n inputs.extend([bn_scale_input, bias_input,\n bn_mean_input, bn_var_input])\n else:\n bias_init, bias_input = self._create_param_tensors(\n conv_params, 'conv', 'bias')\n initializer.append(bias_init)\n inputs.append(bias_input)\n conv_init, conv_input = self._create_param_tensors(\n conv_params, 'conv', 'weights')\n initializer.append(conv_init)\n inputs.append(conv_input)\n return initializer, inputs\n\n def _open_weights_file(self, weights_file_path):\n \"\"\"Opens a YOLOv3 DarkNet file stream and skips the header.\n\n Keyword argument:\n weights_file_path -- path to the weights file.\n \"\"\"\n weights_file = open(weights_file_path, 'rb')\n length_header = 5\n np.ndarray(\n shape=(length_header, ), dtype='int32', buffer=weights_file.read(\n length_header * 4))\n return weights_file\n\n def _create_param_tensors(self, conv_params, param_category, suffix):\n \"\"\"Creates the initializers with weights from the weights file together with\n the input tensors.\n\n Keyword arguments:\n conv_params -- a ConvParams object\n param_category -- the category of parameters to be created ('bn' or 'conv')\n suffix -- a string determining the sub-type of above param_category (e.g.,\n 'weights' or 'bias')\n \"\"\"\n param_name, param_data, param_data_shape = self._load_one_param_type(\n conv_params, param_category, suffix)\n\n initializer_tensor = helper.make_tensor(\n param_name, TensorProto.FLOAT, param_data_shape, param_data)\n input_tensor = helper.make_tensor_value_info(\n param_name, TensorProto.FLOAT, param_data_shape)\n return initializer_tensor, input_tensor\n\n def _load_one_param_type(self, conv_params, param_category, suffix):\n \"\"\"Deserializes the weights from a file stream in the DarkNet order.\n\n Keyword arguments:\n conv_params -- a ConvParams object\n param_category -- the category of parameters to be created ('bn' or 'conv')\n suffix -- a string determining the sub-type of above param_category (e.g.,\n 'weights' or 'bias')\n \"\"\"\n param_name = conv_params.generate_param_name(param_category, suffix)\n channels_out, channels_in, filter_h, filter_w = conv_params.conv_weight_dims\n if param_category == 'bn':\n param_shape = [channels_out]\n elif param_category == 'conv':\n if suffix == 'weights':\n param_shape = [channels_out, channels_in, filter_h, filter_w]\n elif suffix == 'bias':\n param_shape = [channels_out]\n param_size = np.product(np.array(param_shape))\n param_data = np.ndarray(\n shape=param_shape,\n dtype='float32',\n buffer=self.weights_file.read(param_size * 4))\n param_data = param_data.flatten().astype(float)\n return param_name, param_data, param_shape\n\nclass GraphBuilderONNX(object):\n \"\"\"Class for creating an ONNX graph from a previously generated list of layer dictionaries.\"\"\"\n\n def __init__(self, output_tensors):\n \"\"\"Initialize with all DarkNet default parameters used creating YOLOv3,\n and specify the output tensors as an OrderedDict for their output dimensions\n with their names as keys.\n\n Keyword argument:\n output_tensors -- the output tensors as an OrderedDict containing the keys'\n output dimensions\n \"\"\"\n self.output_tensors = output_tensors\n self._nodes = list()\n self.graph_def = None\n self.input_tensor = None\n self.epsilon_bn = 1e-5\n self.momentum_bn = 0.99\n self.alpha_lrelu = 0.1\n self.param_dict = OrderedDict()\n self.major_node_specs = list()\n self.batch_size = 1\n self.classes = 80\n self.num = 9\n\n def build_onnx_graph(\n self,\n layer_configs,\n weights_file_path,\n verbose=True):\n \"\"\"Iterate over all layer configs (parsed from the DarkNet representation\n of YOLOv3-608), create an ONNX graph, populate it with weights from the weights\n file and return the graph definition.\n\n Keyword arguments:\n layer_configs -- an OrderedDict object with all parsed layers' configurations\n weights_file_path -- location of the weights file\n verbose -- toggles if the graph is printed after creation (default: True)\n \"\"\"\n for layer_name in layer_configs.keys():\n layer_dict = layer_configs[layer_name]\n major_node_specs = self._make_onnx_node(layer_name, layer_dict)\n if major_node_specs.name is not None:\n self.major_node_specs.append(major_node_specs)\n\n # 参考yolov3输出 3个输出，此时将3个输出节点 通过transpose concat结合在一起！\n transposes = list()\n total_grids = 0\n for tensor_name in self.output_tensors.keys():\n grids = 1\n for i in self.output_tensors[tensor_name]:\n grids *= i\n total_grids += grids / (self.classes + 5)\n output_dims = [self.batch_size, ] + self.output_tensors[tensor_name]\n layer_name, layer_dict = tensor_name, {'output_dims': output_dims}\n transpose_name = self._make_transpose_node(layer_name, layer_dict)\n transposes.append(transpose_name)\n\n output_name = 'ouputs'\n route_node = helper.make_node(\n 'Concat',\n axis=1,\n inputs=transposes,\n outputs=[output_name],\n name=output_name,\n )\n self._nodes.append(route_node)\n # yolov3有3个输出，因此构建3个make_tensor_value_info, 但是yolov4这里修改了，通过1个node将输出变成1个！\n output_dims = (self.batch_size, int(total_grids), self.classes + 5)\n outputs = [helper.make_tensor_value_info(output_name, TensorProto.FLOAT, output_dims)]\n\n #\n inputs = [self.input_tensor]\n weight_loader = WeightLoader(weights_file_path)\n initializer = list()\n # If a layer has parameters, add them to the initializer and input lists.\n for layer_name in self.param_dict.keys():\n _, layer_type = layer_name.split('_', 1)\n params = self.param_dict[layer_name]\n if layer_type == 'convolutional':\n initializer_layer, inputs_layer = weight_loader.load_conv_weights(\n params)\n initializer.extend(initializer_layer)\n inputs.extend(inputs_layer)\n elif layer_type == 'upsample':\n initializer_layer, inputs_layer = weight_loader.load_resize_scales(\n params)\n initializer.extend(initializer_layer)\n inputs.extend(inputs_layer)\n elif 'reshape' in layer_type: # reshape在层名中\n initializer_layer, inputs_layer = weight_loader.load_reshape_scales(params)\n initializer.extend(initializer_layer)\n inputs.extend(inputs_layer)\n del weight_loader\n self.graph_def = helper.make_graph(\n nodes=self._nodes,\n name='YOLOv4-608',\n inputs=inputs, # helper.make_tensor_value_info, inputs类似tf的placeholder占位符; 构建node时 无make_tensor_value_info，仅仅是名字，对于需要的参数\n outputs=outputs,\n initializer=initializer # make_tensor 实际初始化的data, 将权重等参数 初始化 固定；\n )\n if verbose:\n print(helper.printable_graph(self.graph_def))\n model_def = helper.make_model(self.graph_def,\n producer_name='NVIDIA TensorRT sample')\n return model_def\n\n def _make_onnx_node(self, layer_name, layer_dict):\n \"\"\"Take in a layer parameter dictionary, choose the correct function for\n creating an ONNX node and store the information important to graph creation\n as a MajorNodeSpec object.\n\n Keyword arguments:\n layer_name -- the layer's name (also the corresponding key in layer_configs)\n layer_dict -- a layer parameter dictionary (one element of layer_configs)\n \"\"\"\n layer_type = layer_dict['type']\n if self.input_tensor is None:\n if layer_type == 'net':\n major_node_output_name, major_node_output_channels = self._make_input_tensor(\n layer_name, layer_dict)\n major_node_specs = MajorNodeSpecs(major_node_output_name,\n major_node_output_channels)\n else:\n raise ValueError('The first node has to be of type \"net\".')\n else:\n node_creators = dict()\n node_creators['convolutional'] = self._make_conv_node\n node_creators['shortcut'] = self._make_shortcut_node\n node_creators['route'] = self._make_route_node\n node_creators['upsample'] = self._make_resize_node\n node_creators['maxpool'] = self._make_maxpool_node\n\n if layer_type in node_creators.keys():\n major_node_output_name, major_node_output_channels = \\\n node_creators[layer_type](layer_name, layer_dict)\n major_node_specs = MajorNodeSpecs(major_node_output_name,\n major_node_output_channels)\n else:\n print(\n 'Layer of type %s not supported, skipping ONNX node generation.' %\n layer_type)\n if layer_type == 'yolo':\n self.classes = layer_dict['classes']\n self.num = layer_dict['num']\n major_node_specs = MajorNodeSpecs(layer_name,\n None)\n return major_node_specs\n\n\n def _make_input_tensor(self, layer_name, layer_dict):\n \"\"\"Create an ONNX input tensor from a 'net' layer and store the batch size.\n\n Keyword arguments:\n layer_name -- the layer's name (also the corresponding key in layer_configs)\n layer_dict -- a layer parameter dictionary (one element of layer_configs)\n \"\"\"\n batch_size = layer_dict['batch']\n channels = layer_dict['channels']\n height = layer_dict['height']\n width = layer_dict['width']\n self.batch_size = batch_size\n input_tensor = helper.make_tensor_value_info(\n str(layer_name), TensorProto.FLOAT, [\n batch_size, channels, height, width])\n self.input_tensor = input_tensor\n return layer_name, channels\n\n def _get_previous_node_specs(self, target_index=-1):\n \"\"\"Get a previously generated ONNX node (skip those that were not generated).\n Target index can be passed for jumping to a specific index.\n\n Keyword arguments:\n target_index -- optional for jumping to a specific index (default: -1 for jumping\n to previous element)\n \"\"\"\n previous_node = None\n for node in self.major_node_specs[target_index::-1]:\n if node.created_onnx_node:\n previous_node = node\n break\n assert previous_node is not None\n return previous_node\n\n def _make_conv_node(self, layer_name, layer_dict):\n \"\"\"Create an ONNX Conv node with optional batch normalization and\n activation nodes.\n\n Keyword arguments:\n layer_name -- the layer's name (also the corresponding key in layer_configs)\n layer_dict -- a layer parameter dictionary (one element of layer_configs)\n \"\"\"\n previous_node_specs = self._get_previous_node_specs()\n inputs = [previous_node_specs.name]\n previous_channels = previous_node_specs.channels\n kernel_size = layer_dict['size']\n stride = layer_dict['stride']\n filters = layer_dict['filters']\n batch_normalize = False\n if 'batch_normalize' in layer_dict.keys(\n ) and layer_dict['batch_normalize'] == 1:\n batch_normalize = True\n\n groups = 1\n if 'groups' in layer_dict.keys():\n groups = layer_dict['groups']\n\n previous_channels = previous_channels // groups\n\n kernel_shape = [kernel_size, kernel_size]\n weights_shape = [filters, previous_channels] + kernel_shape\n conv_params = ConvParams(layer_name, batch_normalize, weights_shape)\n\n strides = [stride, stride]\n dilations = [1, 1]\n weights_name = conv_params.generate_param_name('conv', 'weights')\n inputs.append(weights_name)\n if not batch_normalize:\n bias_name = conv_params.generate_param_name('conv', 'bias')\n inputs.append(bias_name)\n\n conv_node = helper.make_node(\n 'Conv',\n inputs=inputs,\n outputs=[layer_name],\n kernel_shape=kernel_shape,\n strides=strides,\n group=groups,\n auto_pad='SAME_LOWER',\n dilations=dilations,\n name=layer_name\n )\n self._nodes.append(conv_node)\n inputs = [layer_name]\n layer_name_output = layer_name\n\n if batch_normalize:\n layer_name_bn = layer_name + '_bn'\n bn_param_suffixes = ['scale', 'bias', 'mean', 'var']\n for suffix in bn_param_suffixes:\n bn_param_name = conv_params.generate_param_name('bn', suffix)\n inputs.append(bn_param_name)\n batchnorm_node = helper.make_node(\n 'BatchNormalization',\n inputs=inputs,\n outputs=[layer_name_bn],\n epsilon=self.epsilon_bn,\n momentum=self.momentum_bn,\n name=layer_name_bn\n )\n self._nodes.append(batchnorm_node)\n inputs = [layer_name_bn]\n layer_name_output = layer_name_bn\n\n if layer_dict['activation'] == 'leaky':\n layer_name_lrelu = layer_name + '_lrelu'\n\n lrelu_node = helper.make_node(\n 'LeakyRelu',\n inputs=inputs,\n outputs=[layer_name_lrelu],\n name=layer_name_lrelu,\n alpha=self.alpha_lrelu\n )\n self._nodes.append(lrelu_node)\n inputs = [layer_name_lrelu]\n layer_name_output = layer_name_lrelu\n elif layer_dict['activation'] == 'relu':\n layer_name_relu = layer_name + '_relu'\n\n relu_node = helper.make_node(\n 'Relu',\n inputs=inputs,\n outputs=[layer_name_relu],\n name=layer_name_relu\n )\n self._nodes.append(relu_node)\n inputs = [layer_name_relu]\n layer_name_output = layer_name_relu\n elif layer_dict['activation'] == 'mish':\n layer_name_softplus = layer_name + '_softplus'\n\n softplus_node = helper.make_node(\n 'Softplus',\n inputs=inputs,\n outputs=[layer_name_softplus],\n name=layer_name_softplus\n )\n self._nodes.append(softplus_node)\n\n inputs_t = [layer_name_softplus]\n layer_name_tanh = layer_name + '_tanh'\n tanh_node = helper.make_node(\n 'Tanh',\n inputs=inputs_t,\n outputs=[layer_name_tanh],\n name=layer_name_tanh\n )\n self._nodes.append(tanh_node)\n\n inputs.append(layer_name_tanh)\n layer_name_mish = layer_name + '_mish'\n mul_node = helper.make_node(\n 'Mul',\n inputs=inputs,\n outputs=[layer_name_mish],\n name=layer_name_mish\n )\n self._nodes.append(mul_node)\n inputs = [layer_name_mish]\n layer_name_output = layer_name_mish\n\n elif layer_dict['activation'] == 'linear':\n pass\n else:\n print('Activation not supported.')\n\n self.param_dict[layer_name] = conv_params\n return layer_name_output, filters\n\n def _make_shortcut_node(self, layer_name, layer_dict):\n \"\"\"Create an ONNX Add node with the shortcut properties from\n the DarkNet-based graph.\n\n Keyword arguments:\n layer_name -- the layer's name (also the corresponding key in layer_configs)\n layer_dict -- a layer parameter dictionary (one element of layer_configs)\n \"\"\"\n shortcut_index = layer_dict['from']\n activation = layer_dict['activation']\n assert activation == 'linear'\n\n first_node_specs = self._get_previous_node_specs()\n second_node_specs = self._get_previous_node_specs(\n target_index=shortcut_index)\n assert first_node_specs.channels == second_node_specs.channels\n channels = first_node_specs.channels\n inputs = [first_node_specs.name, second_node_specs.name]\n shortcut_node = helper.make_node(\n 'Add',\n inputs=inputs,\n outputs=[layer_name],\n name=layer_name,\n )\n self._nodes.append(shortcut_node)\n return layer_name, channels\n\n def _make_route_node(self, layer_name, layer_dict):\n \"\"\"If the 'layers' parameter from the DarkNet configuration is only one index, continue\n node creation at the indicated (negative) index. Otherwise, create an ONNX Concat node\n with the route properties from the DarkNet-based graph.\n\n Keyword arguments:\n layer_name -- the layer's name (also the corresponding key in layer_configs)\n layer_dict -- a layer parameter dictionary (one element of layer_configs)\n \"\"\"\n route_node_indexes = layer_dict['layers']\n if len(route_node_indexes) == 1:\n split_index = route_node_indexes[0]\n prev_node_specs = self._get_previous_node_specs(target_index=-1)\n input_node_specs = self._get_previous_node_specs(target_index=split_index if split_index < 0 else split_index + 1)\n # 这里与yolov3有着很大的区别，因为yolov4涉及很多concat层，而yolov3只在yolo层涉及\n if split_index == -4 and 'maxpool' not in prev_node_specs.name:\n # Increment by one because we skipped the YOLO layer:\n split_index += 1\n self.major_node_specs = self.major_node_specs[:split_index]\n layer_name = None\n channels = None\n else: # -2 or maxpool in\n inputs = [input_node_specs.name]\n route_node = helper.make_node(\n 'Concat',\n axis=1,\n inputs=inputs,\n outputs=[layer_name],\n name=layer_name,\n )\n channels = input_node_specs.channels\n self._nodes.append(route_node)\n else:\n inputs = list()\n channels = 0\n for index in route_node_indexes:\n if index > 0:\n # Increment by one because we count the input as a node (DarkNet\n # does not)\n index += 1\n route_node_specs = self._get_previous_node_specs(target_index=index)\n inputs.append(route_node_specs.name)\n channels += route_node_specs.channels\n assert inputs\n assert channels > 0\n\n route_node = helper.make_node(\n 'Concat',\n axis=1,\n inputs=inputs,\n outputs=[layer_name],\n name=layer_name,\n )\n self._nodes.append(route_node)\n return layer_name, channels\n\n def _make_resize_node(self, layer_name, layer_dict):\n \"\"\"Create an ONNX Resize node with the properties from\n the DarkNet-based graph.\n\n Keyword arguments:\n layer_name -- the layer's name (also the corresponding key in layer_configs)\n layer_dict -- a layer parameter dictionary (one element of layer_configs)\n \"\"\"\n resize_scale_factors = float(layer_dict['stride'])\n # Create the scale factor array with node parameters\n scales = np.array([1.0, 1.0, resize_scale_factors, resize_scale_factors]).astype(np.float32)\n previous_node_specs = self._get_previous_node_specs()\n inputs = [previous_node_specs.name]\n\n channels = previous_node_specs.channels\n assert channels > 0\n resize_params = ResizeParams(layer_name, scales)\n scales_name = resize_params.generate_param_name()\n inputs.append(scales_name)\n\n resize_node = helper.make_node(\n 'Resize',\n mode='nearest',\n inputs=inputs,\n outputs=[layer_name],\n name=layer_name,\n )\n self._nodes.append(resize_node)\n self.param_dict[layer_name] = resize_params\n return layer_name, channels\n\n def _make_maxpool_node(self, layer_name, layer_dict):\n stride = layer_dict['stride']\n kernel_size = layer_dict['size']\n previous_node_specs = self._get_previous_node_specs()\n inputs = [previous_node_specs.name]\n channels = previous_node_specs.channels\n kernel_shape = [kernel_size, kernel_size]\n strides = [stride, stride]\n assert channels > 0\n maxpool_node = helper.make_node(\n 'MaxPool',\n inputs=inputs,\n outputs=[layer_name],\n kernel_shape=kernel_shape,\n strides=strides,\n auto_pad='SAME_UPPER',\n name=layer_name,\n )\n self._nodes.append(maxpool_node)\n return layer_name, channels\n\n def _make_transpose_node(self, layer_name, layer_dict):\n inputs = [layer_name]\n reshape_name = layer_name + '_reshape_1'\n shape = np.array([layer_dict['output_dims'][0], self.num // 3, self.classes + 5,\n layer_dict['output_dims'][-2], layer_dict['output_dims'][-1]]).astype(np.int64)\n reshape_params = ReshapeParams(layer_name, shape)\n self.param_dict[reshape_name] = reshape_params\n param_name = reshape_params.generate_param_name()\n inputs.append(param_name)\n reshape_node = onnx.helper.make_node(\n 'Reshape',\n inputs=inputs,\n outputs=[reshape_name]\n )\n self._nodes.append(reshape_node)\n transpose_name = layer_name + '_transpose'\n permutations = (0, 1, 3, 4, 2)\n transpose_node = onnx.helper.make_node(\n 'Transpose',\n inputs=[reshape_name],\n outputs=[transpose_name],\n perm=permutations\n )\n self._nodes.append(transpose_node)\n inputs = [transpose_name]\n output_name = layer_name + '_reshape_2'\n shape = np.array([layer_dict['output_dims'][0], -1, self.classes + 5]).astype(np.int64)\n reshape_params = ReshapeParams(transpose_name, shape)\n self.param_dict[output_name] = reshape_params\n param_name = reshape_params.generate_param_name()\n inputs.append(param_name)\n reshape_node = onnx.helper.make_node(\n 'Reshape',\n inputs=inputs,\n outputs=[output_name]\n )\n self._nodes.append(reshape_node)\n return output_name\n\ndef main(cfg_file='yolov3.cfg', weights_file='yolov3.weights', output_file='yolov3.onnx', neck='FPN'):\n cfg_file_path = cfg_file\n\n supported_layers = ['net', 'convolutional', 'shortcut',\n 'route', 'upsample', 'maxpool']\n\n parser = DarkNetParser(supported_layers)\n layer_configs = parser.parse_cfg_file(cfg_file_path)\n del parser\n\n width = layer_configs['000_net']['width']\n height = layer_configs['000_net']['height']\n\n conv_layers = []\n for layer_key in layer_configs.keys():\n if 'conv' in layer_key:\n conv_layer = layer_key\n if 'yolo' in layer_key:\n yolo_layer = layer_key\n conv_layers.append(conv_layer)\n\n classes = layer_configs[yolo_layer]['classes']\n\n if neck == 'FPN':\n stride = [32, 16, 8]\n elif neck == 'PAN':\n stride = [8, 16, 32]\n else:\n print('Neck must be FPN or PAN!')\n return\n\n output_tensor_dims = OrderedDict()\n output_tensor_dims[conv_layers[0]] = [(classes + 5) * 3, width // stride[0], height // stride[0]]\n output_tensor_dims[conv_layers[1]] = [(classes + 5) * 3, width // stride[1], height // stride[1]]\n output_tensor_dims[conv_layers[2]] = [(classes + 5) * 3, width // stride[2], height // stride[2]]\n\n # Create a GraphBuilderONNX object with the known output tensor dimensions:\n builder = GraphBuilderONNX(output_tensor_dims)\n\n weights_file_path = weights_file\n\n # Now generate an ONNX graph with weights from the previously parsed layer configurations\n # and the weights file:\n yolov3_model_def = builder.build_onnx_graph(\n layer_configs=layer_configs,\n weights_file_path=weights_file_path,\n verbose=True)\n # Once we have the model definition, we do not need the builder anymore:\n del builder\n\n # Perform a sanity check on the ONNX model definition:\n onnx.checker.check_model(yolov3_model_def)\n\n # Serialize the generated ONNX graph to this file:\n output_file_path = output_file\n onnx.save(yolov3_model_def, output_file_path)\n print('Save ONNX File {} success!'.format(output_file_path))\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description='Transform YOLO weights to ONNX.')\n parser.add_argument('--cfg_file', type=str, default='yolov4.cfg', help='yolo cfg file')\n parser.add_argument('--weights_file', type=str, default='yolov4.weights', help='yolo weights file')\n parser.add_argument('--output_file', type=str, default='yolov4.onnx', help='yolo onnx file')\n parser.add_argument('--neck', type=str, default='PAN', help='use which kind neck')\n args = parser.parse_args()\n '''\n 在转换yolov4模型前\n 需要将cfg文件里的倒数第一和倒数第三route层的-37改成116，-16改成126，修改后的正值\n 可以参考darknet运行时的输出进行设置。yolov3模型不需要修改，batch也对应修改。\n '''\n main(cfg_file=args.cfg_file, weights_file=args.weights_file, output_file=args.output_file, neck=args.neck)"
] | [
[
"numpy.random.shuffle"
],
[
"torch.hub.download_url_to_file"
],
[
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
JaydenL33/ReLearningPython | [
"60d54172eefb29f285ca8976350010829d312a16"
] | [
"DataScience/Ryan_SVMPython.py"
] | [
"#############################################################################\n# Author: Jayden Lee ([email protected])\n# Date: 6/10/19\n# Purpose: To use a SVM for our regression problem. \n# Source: \n# In Source Documentation\n#############################################################################\n\n#############################################################################\n\nfrom sklearn import svm\nimport numpy as np\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import metrics\nimport pickle\nimport time\n#############################################################################\n# Input: input\n# This function DOES\n# Output: input\n#############################################################################\n\ndef SVMRegression(filename):\n\n\t#Read in File\n\tdata = pd.read_csv(\"Inputs/\"+ filename + '.csv', sep=',', low_memory=False)\n\t# Drop the first 2 columns from X\n\tX = data.drop([\"QuoteConversion_Flag\", \"Quote_ID\"], axis=1)\n\t# Y Contains the Quote Conversion Column\n\ty = data['QuoteConversion_Flag']\n\n\t#print(X)\n\t\n\t# Pass in the features->X, Pass in the Target->Y, Takes 30% of the data for testing and the other 70% is for training, Randomly selects data\"\n\tX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=109)\n\t#print(X_train)\n\t#print(y_train)\n\t# Allocates the start time\n\tstart_time = time.time()\n\n\tsvclassifier = svm.SVC(kernel='linear', degree=4, gamma='auto', max_iter = 100000, tol=0.001)\n\n\tprint(\"Fitting the data.\")\n\tprint(\"##################################################\")\n\tsvclassifier.fit(X_train, y_train) \n\tprint(\"--- %s seconds to complete ---\" % (time.time() - start_time))\n\tprint(\"Fitment Complete. Moving onto the Prediciton.\")\n\tprint(\"##################################################\")\n\n\ty_pred = svclassifier.predict(X_test)\n\tstart_time = time.time()\n\tprint(\"--- %s seconds to complete ---\" % (time.time() - start_time))\n\t#y_pred.to_csv(y_pred,\"Prediction\" sep=',', low_memory=False)\n\n\tprint(\"##################################################\")\n\tprint(\"Accuracy:\",metrics.accuracy_score(y_test, y_pred))\n\tprint(\"Precision:\",metrics.precision_score(y_test, y_pred))\n\tprint(\"Recall:\",metrics.recall_score(y_test, y_pred))\n\tprint(\"F Score:\",metrics.f1_score(y_test, y_pred))\n\n\n\tdmp = pickle.dump(svclassifier, open(\"Outputs/\" + filename + '.sav','wb'))\n\tnp.savetxt(\"Outputs/\" + filename + \".csv\", y_pred, delimiter=\",\")\n\n#############################################################################\n# \t\t\t\t\t\t\t\tMain Code. \n#############################################################################\n\nfilename = \"Ryan2\"\n\nSVMRegression(filename)"
] | [
[
"pandas.read_csv",
"sklearn.metrics.precision_score",
"sklearn.model_selection.train_test_split",
"sklearn.svm.SVC",
"numpy.savetxt",
"sklearn.metrics.f1_score",
"sklearn.metrics.recall_score",
"sklearn.metrics.accuracy_score"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
TomasBombadil/tf-face-recognition | [
"f167d31a2f4e1b60462cb2331dde027d2fcac47a"
] | [
"src/tensorface/embedding.py"
] | [
"import os\n\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.python.platform import gfile\n\nfrom tensorface.const import PRETREINED_MODEL_DIR\n\nMODEL_FILE_NAME = '20180402-114759/20180402-114759.pb'\n\n# to get Flask not complain\nglobal tf\n_tf = tf\nglobal sess\nsess = None\n\ndef load_model(pb_file, input_map=None):\n global _tf\n global sess\n #if sess is None:\n if True:\n sess = _tf.Session()\n print('Model filename: %s' % pb_file)\n with gfile.FastGFile(pb_file, 'rb') as f:\n graph_def = _tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _tf.import_graph_def(graph_def, input_map=input_map, name='')\n pass\n\n#load_model(os.path.join(PRETREINED_MODEL_DIR, MODEL_FILE_NAME))\n\n# inception net requires this\ndef prewhiten(x):\n mean = np.mean(x)\n std = np.std(x)\n std_adj = np.maximum(std, 1.0 / np.sqrt(x.size))\n y = np.multiply(np.subtract(x, mean), 1 / std_adj)\n return y\n\n\ndef embedding(face_np):\n load_model(os.path.join(PRETREINED_MODEL_DIR, MODEL_FILE_NAME))\n #global sess\n images_placeholder = tf.get_default_graph().get_tensor_by_name(\"input:0\")\n embeddings = tf.get_default_graph().get_tensor_by_name(\"embeddings:0\")\n phase_train_placeholder = tf.get_default_graph().get_tensor_by_name(\"phase_train:0\")\n x = prewhiten(face_np)\n feed_dict = {images_placeholder: [x], phase_train_placeholder: False}\n result = sess.run(embeddings, feed_dict=feed_dict)[0]\n return result\n\n\ndef input_shape():\n return _tf.get_default_graph().get_tensor_by_name(\"input:0\").get_shape()\n\n\ndef embedding_size():\n return _tf.get_default_graph().get_tensor_by_name(\"embeddings:0\").get_shape()[1]\n"
] | [
[
"tensorflow.get_default_graph",
"numpy.sqrt",
"numpy.subtract",
"numpy.std",
"numpy.mean",
"tensorflow.python.platform.gfile.FastGFile"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
}
] |
afranck64/ultimatum | [
"313b840e6f0942c1c937aa8b3f2d26e5059c7a7f",
"313b840e6f0942c1c937aa8b3f2d26e5059c7a7f",
"313b840e6f0942c1c937aa8b3f2d26e5059c7a7f"
] | [
"snippets/generate_game_resp_summary copy.py",
"snippets/generate_game_prop_summary.py",
"snippets/hypotheses/test_h36.py"
] | [
"import os\nimport sys\nimport argparse\nimport pandas as pd\nfrom scipy import stats\n\nsys.path.append(os.path.abspath(\"..\"))\n\nfrom survey._app import CODE_DIR, app\nfrom core.models.metrics import gain_mean, rejection_ratio, gain\nfrom utils import get_con_and_dfs, get_all_con_and_dfs\nimport metrics\n\nSTATS_FUNCTIONS = {}\n\n\n\n\n\n# overwritten by a command line flag. If true, percentage will be generated instead of frequency\nUSE_PERCENTAGE = None\n\nUSE_LABELS = None\n\nSELECTION = None\n\nAI_FEEDBACK_ACCURACY_SCALAS = {\n \"ai_much_worse\": \"AI much worse than PROPOSER\",\n \"ai_worse\": \"AI worse\",\n \"ai_sligthly_worse\": \"AI slighly worse\",\n \"ai_equal_to_proposer\": \"AI equal to PROPOSER\",\n \"ai_slighly_better\": \"AI slighly better\",\n \"ai_better\": \"AI better\",\n \"ai_much_better\": \"AI much better than the PROPOSER\",\n}\n\nAI_FEEDBACK_SCALAS = {\n 1: \"strongly_disagree\",\n 2: \"disagree\",\n 3: \"slightly_disagree\",\n 4: \"neutral\",\n 5: \"slightly_agree\",\n 6: \"agree\",\n 7: \"strongly_agree\"\n}\n\ndef get_parser():\n parser = argparse.ArgumentParser(description='Generate statistics for a given treatment')\n parser.add_argument('--use-percentage', help='Generate percentages instead of frequencies', action='store_true')\n parser.add_argument('--use-latex', help='Print results as latex table', action='store_true')\n parser.add_argument('--use-labels', help='Print results using description labels', action='store_true')\n parser.add_argument('--output-dir', help='Output directory where csv files were exported')\n parser.add_argument('--selection', help='Whether to restrict the stats to responder or proposers', choices=['prop', 'resp'])\n parser.add_argument('treatments', help='Comma separated treatments')\n return parser\n\n\nALL_CONS, ALL_DFS = get_all_con_and_dfs()\n\n\ndef mark_for_stats(label=None):\n def _mark_for_stats(function, label=label):\n if label is None:\n label = function.__name__[4:]\n STATS_FUNCTIONS[label] = function\n return function\n return _mark_for_stats\n\n\n\ndef get_count_participants(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n sql = f\"\"\"\n select * from result__{treatment}_survey\n where worker_id not in (\n select worker_id from main__txx where worker_code == 'dropped'\n )\n \"\"\"\n if SELECTION == \"resp\":\n sql = f\"\"\"\n select worker_id from result__{treatment}_resp\n \"\"\"\n elif SELECTION == \"prop\":\n sql = f\"\"\"\n select worker_id from result__{treatment}_prop\n \"\"\"\n else:\n sql = f\"\"\"\n select * from (\n select worker_id from result__{treatment}_resp\n union\n select worker_id from result__{treatment}_prop\n )\n \"\"\"\n df = pd.read_sql(sql, con)\n return df.shape[0]\n\n@mark_for_stats()\ndef get_count(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n sql = f\"\"\"\n select * from result__{treatment}_survey\n where worker_id in (\n select worker_id from main__txx where worker_code != 'dropped'\n )\n \"\"\"\n if SELECTION == \"resp\":\n sql += f\"\"\"and\n worker_id in (\n select worker_id from result__{treatment}_resp\n )\n \"\"\"\n elif SELECTION == \"prop\":\n sql += f\"\"\"and\n worker_id in (\n select worker_id from result__{treatment}_prop\n )\n \"\"\"\n df = pd.read_sql(sql, con)\n count_stats = df.shape[0]\n count_all = get_count_participants(treatment, con, dfs, use_percentage, use_labels)\n\n return {\"count\": f\"{count_stats} ({count_all}*)\"}\n\nRESPONDERS = {\n \"t00\": \"t00\",\n \"t10a\": \"t10a\",\n \"t10b\": \"t10a\",\n \"t11a\": \"t11a\",\n \"t11b\": \"t11a\",\n \"t11c\": \"t11a\",\n \"t20\": \"t20a\",\n \"t20a\": \"t20a\",\n}\n\n\nPROPOSERS = {\n \"t00\": \"t00\",\n \"t10a\": \"t10a\",\n \"t11a\": \"t11a\",\n \"t12a\": \"t10a\",\n \"t13a\": \"t10a\",\n \"t20a\": \"t10a\",\n}\n\ndef get_prop_resp(treatment):\n if SELECTION == \"prop\":\n df_prop = ALL_DFS[f\"result__{treatment}_prop\"].copy()\n if treatment in {\"t20\", \"t20a\"}:\n df_prop[\"offer\"] = df_prop[\"ai_offer\"]\n df_prop[\"offer_dss\"] = df_prop[\"ai_offer\"]\n df_prop[\"offer_final\"] = df_prop[\"ai_offer\"]\n df_resp = ALL_DFS[f\"result__{RESPONDERS[treatment]}_resp\"].copy()\n elif SELECTION == \"resp\":\n df_resp = ALL_DFS[f\"result__{treatment}_resp\"].copy()\n df_prop = ALL_DFS[f\"result__{PROPOSERS[treatment]}_prop\"].copy()\n if \"offer_dss\" not in df_prop.columns:\n df_prop[\"offer_dss\"] = df_prop[\"offer\"]\n df_prop[\"offer_final\"] = df_prop[\"offer\"]\n if \"min_offer_dss\" not in df_resp.columns:\n df_resp[\"min_offer_dss\"] = df_resp[\"min_offer\"]\n df_resp[\"min_offer_final\"] = df_resp[\"min_offer\"]\n size = min(df_prop.shape[0], df_resp.shape[0])\n df_prop = df_prop.head(size)\n df_resp = df_resp.head(size)\n return df_prop, df_resp\n\ndef _get_prop_vs_prop_dss_score(treatment, con, dfs=None, use_percentage=None, use_labels=None, metric=None, as_percentage=None):\n df_prop, df_resp = get_prop_resp(treatment)\n if as_percentage:\n res = {\n \"Proposer\": f'{round(100 * metric(df_resp[\"min_offer\"], df_prop[\"offer\"]), 2)} %',\n \"Proposer + DSS\": f'{round(100 * metric(df_resp[\"min_offer\"], df_prop[\"offer_dss\"]), 2)} %',\n \"Auto DSS\": f'{round(100 * metric(df_resp[\"min_offer\"], df_prop[\"ai_offer\"]), 2)} %',\n }\n else:\n res = {\n \"Proposer\": f'{round(metric(df_resp[\"min_offer\"], df_prop[\"offer\"]), 2)}',\n \"Proposer + DSS\": f'{round(metric(df_resp[\"min_offer\"], df_prop[\"offer_dss\"]), 2)}',\n \"Auto DSS\": f'{round(metric(df_resp[\"min_offer\"], df_prop[\"ai_offer\"]), 2)}', \n }\n\n return res\n\n# @mark_for_stats()\ndef get_rejection_ratio(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n return _get_prop_vs_prop_dss_score(treatment, con, dfs, use_percentage, use_labels, metric=rejection_ratio, as_percentage=True)\n\n\n@mark_for_stats()\ndef get_rel_responder_min_offer(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if SELECTION != \"resp\":\n return\n df_prop, df_resp = get_prop_resp(treatment)\n df_prop[df_resp.columns] = df_resp\n\n _, df_resp_t00 = get_prop_resp(\"t00\")\n resp_stat = stats.ttest_rel(df_resp[\"min_offer\"], df_resp[\"min_offer_final\"])\n\n print(\"REF to t00\", stats.ttest_ind(get_prop_resp(\"t00\")[0][\"min_offer\"], df_resp[\"min_offer_final\"]))\n resp_stat_t00 = stats.ttest_ind(df_resp[\"min_offer_final\"], df_resp_t00[\"min_offer\"])\n\n resp_wc_stat = stats.wilcoxon(df_resp[\"min_offer\"], df_resp[\"min_offer_final\"])\n res = {\n \"n\": df_resp[\"min_offer\"].shape[0],\n \"mean (initial)\": metrics.get_mean(df_resp[\"min_offer\"]),\n \"mean\": metrics.get_mean(df_resp[\"min_offer_final\"]),\n \"median\": df_resp[\"min_offer_final\"].median(),\n \"mode\": df_resp[\"min_offer_final\"].mode()[0],\n \"standard deviation\": metrics.get_std(df_resp[\"min_offer\"]),\n \"standard deviation\": metrics.get_std(df_resp[\"min_offer_final\"]),\n\n # \"rejection_ratio\": rejection_ratio(df_prop)\n \"stat\": resp_stat[0],\n \"p-value\": resp_stat[1],\n \"stat-t00\": resp_stat_t00[0],\n \"p-value-t00\": resp_stat_t00[1],\n \"stat-wc\": resp_wc_stat[0],\n \"p-value-wc\": resp_wc_stat[1]\n }\n return {k: (f\"{v:.3f}\" if pd.notnull(v) and v!= int(v) else v) for k,v in res.items()}\n\n@mark_for_stats()\ndef get_rel_responder_gain2(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if SELECTION != \"resp\":\n return\n df_prop, df_resp = get_prop_resp(treatment)\n df_prop[df_resp.columns] = df_resp\n resp_gain = metrics.get_mean(metrics.gain_responder(df_prop[\"min_offer\"], df_prop[\"offer\"]))\n resp_gain_dss = metrics.get_mean(metrics.gain_responder(df_prop[\"min_offer_dss\"], df_prop[\"offer_final\"]))\n resp_gain_2 = metrics.get_mean(metrics.get_rel_gain_responder(df_prop[\"min_offer\"], df_prop[\"min_offer_dss\"], df_prop[\"offer\"]))\n resp_gain_dss_2 = metrics.get_mean(metrics.get_rel_gain_responder(df_prop[\"min_offer\"], df_prop[\"min_offer_dss\"], df_prop[\"offer_final\"]))\n return {\n \"resp_gain: \": resp_gain,\n \"resp_gain_dss: \": resp_gain_dss,\n \"rel_gain: vs proposer\": resp_gain_2,\n \"rel_gain: vs proposer + DSS\": resp_gain_dss_2,\n # \"rejection_ratio\": rejection_ratio(df_prop)\n }\n\n\n# @mark_for_stats()\n# def get_ttest_rel(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# df_prop = ALL_DFS[f\"result__{treatment}_prop\"]\n# offers = df_prop[\"offer\"]\n# offers_dss = df_prop[\"offer_dss\"]\n# return stats.ttest_rel(offers, offers_dss, axis=0)\n\n# # @mark_for_stats()\n# def get_ks_2samp(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# df_prop = ALL_DFS[f\"result__{treatment}_prop\"]\n# offers = df_prop[\"offer\"]\n# offers_dss = df_prop[\"offer_dss\"]\n# s, p = stats.ks_2samp(offers, offers_dss)\n# return {\"stat\": s, \"p\": p}\n\n\n# @mark_for_stats()\n# def get_wilcoxon(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# df_prop = ALL_DFS[f\"result__{treatment}_prop\"]\n# offers = df_prop[\"offer\"]\n# offers_dss = df_prop[\"offer_dss\"]\n# s, p = stats.wilcoxon(offers, offers_dss)\n# return {\"stat\": s, \"p\": p}\n\n@mark_for_stats()\ndef get_wilcoxon_proposer_gain(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if SELECTION != \"prop\":\n return\n df_prop, df_resp = get_prop_resp(treatment)\n x = gain(df_prop[\"offer\"], df_resp[\"min_offer\"])\n y = gain(df_prop[\"offer_dss\"], df_resp[\"min_offer\"])\n s, p = stats.wilcoxon(x, y)\n return {\"stat\": f\"{round(s, 3)}\", \"p\": f\"{round(p, 3)}\"}\n\n\n\n\n# @mark_for_stats()\n# def get_spearman(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# df_prop = ALL_DFS[f\"result__{treatment}_prop\"]\n# offers = df_prop[\"offer\"]\n# offers_dss = df_prop[\"offer_dss\"]\n# s, p = stats.spearmanr(offers, offers_dss)\n# return {\"stat\": s, \"p\": p}\n\n\n\ndef generate_stats(treatment, con, dfs):\n stats = {label:function(treatment, con, dfs) for label, function in STATS_FUNCTIONS.items()}\n return stats\n\n\ndef main():\n global USE_PERCENTAGE, USE_LABELS, SELECTION\n parser = get_parser()\n args = parser.parse_args()\n\n treatments = args.treatments.split(\",\")\n\n USE_PERCENTAGE = args.use_percentage\n\n USE_LABELS = args.use_labels\n\n SELECTION = args.selection\n\n results = dict()\n lst_stats = []\n for treatment in treatments:\n if \".\" in treatment:\n treatment, SELECTION = treatment.split(\".\")\n else:\n SELECTION = args.selection\n #con, dfs = get_con_and_dfs(treatment)\n con = ALL_CONS[treatment]\n dfs = ALL_DFS\n stats = generate_stats(treatment, con, dfs)\n for k, v in stats.items():\n lst = results.get(k, [])\n lst.append(v)\n results[k] = lst\n\n print(\"\\n\\n\")\n for k, items in results.items():\n columns = None\n if items and isinstance(items[0], (tuple, list, set, dict)):\n columns = list(items[0])\n df = pd.DataFrame(items, index=treatments, columns=columns)\n print(k)\n if args.use_latex:\n print(df.T.to_latex())\n else:\n print(df.T)\n print(\"DONE\")\n\n\nif __name__ == \"__main__\":\n main()",
"import os\nimport sys\nimport argparse\nimport numbers\n\nimport numpy as np\nimport pandas as pd\nfrom scipy import stats\nimport statsmodels.stats.api as sms\n\nsys.path.append(os.path.abspath(\"..\"))\n\nfrom survey._app import CODE_DIR, app\nfrom core.models.metrics import gain_mean, rejection_ratio, gain\nfrom utils import get_con_and_dfs, get_all_con_and_dfs\nimport metrics\n\nSTATS_FUNCTIONS = {}\n\n\n\n\n\n# overwritten by a command line flag. If true, percentage will be generated instead of frequency\nUSE_PERCENTAGE = None\n\nUSE_LABELS = None\n\nSELECTION = None\n\nAI_FEEDBACK_ACCURACY_SCALAS = {\n \"ai_much_worse\": \"AI much worse than PROPOSER\",\n \"ai_worse\": \"AI worse\",\n \"ai_sligthly_worse\": \"AI slighly worse\",\n \"ai_equal_to_proposer\": \"AI equal to PROPOSER\",\n \"ai_slighly_better\": \"AI slighly better\",\n \"ai_better\": \"AI better\",\n \"ai_much_better\": \"AI much better than the PROPOSER\",\n}\n\nAI_FEEDBACK_SCALAS = {\n 1: \"strongly_disagree\",\n 2: \"disagree\",\n 3: \"slightly_disagree\",\n 4: \"neutral\",\n 5: \"slightly_agree\",\n 6: \"agree\",\n 7: \"strongly_agree\"\n}\n\ndef get_parser():\n parser = argparse.ArgumentParser(description='Generate statistics for a given treatment')\n parser.add_argument('--use-percentage', help='Generate percentages instead of frequencies', action='store_true')\n parser.add_argument('--use-latex', help='Print results as latex table', action='store_true')\n parser.add_argument('--use-labels', help='Print results using description labels', action='store_true')\n parser.add_argument('--output-dir', help='Output directory where csv files were exported')\n parser.add_argument('--transpose', help='Transpose the output', action='store_true')\n parser.add_argument('--selection', help='Whether to restrict the stats to responder or proposers', choices=['prop', 'resp'])\n parser.add_argument('treatments', help='Comma separated treatments')\n return parser\n\n\nALL_CONS, ALL_DFS = get_all_con_and_dfs()\n\n\ndef mark_for_stats(label=None):\n def _mark_for_stats(function, label=label):\n if label is None:\n label = function.__name__[4:]\n STATS_FUNCTIONS[label] = function\n return function\n return _mark_for_stats\n\n\n\ndef get_count_participants(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n sql = f\"\"\"\n select * from result__{treatment}_survey\n where worker_id not in (\n select worker_id from main__txx where worker_code == 'dropped'\n )\n \"\"\"\n if SELECTION == \"resp\":\n sql = f\"\"\"\n select worker_id from result__{treatment}_resp\n \"\"\"\n elif SELECTION == \"prop\":\n sql = f\"\"\"\n select worker_id from result__{treatment}_prop\n \"\"\"\n else:\n sql = f\"\"\"\n select * from (\n select worker_id from result__{treatment}_resp\n union\n select worker_id from result__{treatment}_prop\n )\n \"\"\"\n df = pd.read_sql(sql, con)\n return df.shape[0]\n\n@mark_for_stats()\ndef get_count(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n sql = f\"\"\"\n select * from result__{treatment}_survey\n where worker_id in (\n select worker_id from main__txx where worker_code != 'dropped'\n )\n \"\"\"\n if SELECTION == \"resp\":\n sql += f\"\"\"and\n worker_id in (\n select worker_id from result__{treatment}_resp\n )\n \"\"\"\n elif SELECTION == \"prop\":\n sql += f\"\"\"and\n worker_id in (\n select worker_id from result__{treatment}_prop\n )\n \"\"\"\n df = pd.read_sql(sql, con)\n count_stats = df.shape[0]\n count_all = get_count_participants(treatment, con, dfs, use_percentage, use_labels)\n\n return {\"count\": f\"{count_stats} ({count_all}*)\"}\n\nRESPONDERS = {\n \"t00\": \"t00\",\n \"t10a\": \"t10a\",\n \"t10b\": \"t10a\",\n \"t11a\": \"t11a\",\n \"t11b\": \"t11a\",\n \"t11c\": \"t11a\",\n \"t20\": \"t20a\",\n \"t20a\": \"t20a\",\n}\n\n\nPROPOSERS = {\n \"t00\": \"t00\",\n \"t10a\": \"t10a\",\n \"t11a\": \"t11a\",\n \"t12a\": \"t10a\",\n \"t13a\": \"t10a\",\n \"t20a\": \"t10a\",\n}\n\ndef get_prop_resp(treatment):\n if SELECTION == \"prop\":\n df_prop = ALL_DFS[f\"result__{treatment}_prop\"].copy()\n if treatment in {\"t20\", \"t20a\"}:\n df_prop[\"offer\"] = df_prop[\"ai_offer\"]\n df_prop[\"offer_dss\"] = df_prop[\"ai_offer\"]\n df_prop[\"offer_final\"] = df_prop[\"ai_offer\"]\n df_resp = ALL_DFS[f\"result__{RESPONDERS[treatment]}_resp\"].copy()\n elif SELECTION == \"resp\":\n df_resp = ALL_DFS[f\"result__{treatment}_resp\"].copy()\n df_prop = ALL_DFS[f\"result__{PROPOSERS[treatment]}_prop\"].copy()\n if \"offer_dss\" not in df_prop.columns:\n df_prop[\"offer_dss\"] = df_prop[\"offer\"]\n df_prop[\"offer_final\"] = df_prop[\"offer\"]\n if \"min_offer_dss\" not in df_resp.columns:\n df_resp[\"min_offer_dss\"] = df_resp[\"min_offer\"]\n df_resp[\"min_offer_final\"] = df_resp[\"min_offer\"]\n size = min(df_prop.shape[0], df_resp.shape[0])\n df_prop = df_prop.head(size)\n df_resp = df_resp.head(size)\n return df_prop, df_resp\n\ndef _get_prop_vs_prop_dss_score(treatment, con, dfs=None, use_percentage=None, use_labels=None, metric=None, as_percentage=None, metric_is_ratio=None, alternative=None):\n df_prop, df_resp = get_prop_resp(treatment)\n\n prop_values = metric(df_resp[\"min_offer\"], df_prop[\"offer\"])\n prop_value = metrics.get_mean(prop_values)\n\n prop_dss_values = metric(df_resp[\"min_offer\"], df_prop[\"offer_dss\"])\n prop_dss_value = metrics.get_mean(prop_dss_values)\n\n auto_dss_values = metric(df_resp[\"min_offer\"], df_prop[\"ai_offer\"])\n auto_dss_value = metrics.get_mean(auto_dss_values)\n\n if metric_is_ratio:\n n = prop_dss_values.shape[0]\n #z_ratio = sms.proportions_ztest(usage_ratio * n, n, pnull, alternative='larger')\n s, p = 0, 0\n else:\n assert prop_dss_values.shape[0] == prop_dss_values.shape[0]\n s, p = stats.wilcoxon(prop_values, prop_dss_values, alternative=alternative or 'greater')\n #return {\"stat\": f\"{round(s, 3)}\", \"p\": f\"{round(p, 3)}\"}\n\n if as_percentage:\n res = {\n \"Proposer\": f'{100 * prop_value:.2f} %',\n \"Proposer + DSS\": f'{100 * prop_dss_value:.2f} %',\n \"Auto DSS\": f'{100 * auto_dss_value:.2f} %',\n \"prop:dss - prop\": f'{100 * (prop_dss_value - prop_value):.2f} %',\n }\n else:\n res = {\n \"Proposer\": f'{prop_value:.2f}',\n \"Proposer + DSS\": f'{prop_dss_value:.2f}',\n \"Auto DSS\": f'{auto_dss_value:.2f}',\n \"prop:dss - prop\": f'{(prop_dss_value - prop_value):.2f} %',\n }\n\n #res[\"stat\"] = f\"{s, 3)}\", \"p\": f\"{round(p, 3)}\"\n res[\"$H_0$: equal, H_a: greater\"] = f\"{s:.3f} ({p:.3f})\"\n print(\"RES: \", res)\n return res\n\ndef rejection_ratio_helper(min_offer, offer):\n res = (offer < min_offer)\n res = res.astype(np.float)\n return res\n\n@mark_for_stats()\ndef get_rejection_ratio(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n # rejection_ratio_lambda = lambda min_offer, offer: (offer >= min_offer) * 1\n return _get_prop_vs_prop_dss_score(treatment, con, dfs, use_percentage, use_labels, metric=rejection_ratio_helper, as_percentage=True)\n\n\n@mark_for_stats()\ndef get_prop_summary(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if SELECTION != \"prop\":\n return\n df_prop, df_resp = get_prop_resp(treatment)\n df_prop[df_prop.columns] = df_prop\n\n df_prop_t00, _ = get_prop_resp(\"t00\")\n resp_stat = stats.ttest_rel(df_prop[\"offer\"], df_prop[\"offer_final\"])\n\n print(\"REF to t00\", stats.ttest_ind(get_prop_resp(\"t00\")[0][\"offer\"], df_prop[\"offer_final\"]))\n resp_stat_t00 = stats.ttest_ind(df_prop[\"offer_final\"], df_prop_t00[\"offer\"])\n\n resp_wc_stat = stats.wilcoxon(df_prop[\"offer\"], df_prop[\"offer_final\"])\n\n #cm = sms.CompareMeans(sms.DescrStatsW(df_prop[\"offer\"]), sms.DescrStatsW(df_prop[\"offer_final\"]))\n cm = sms.CompareMeans.from_data(df_prop[\"offer\"], df_prop[\"offer_final\"])\n\n\n print(treatment, \"CHECK: \", cm.tconfint_diff(usevar=\"unequal\"))\n res = {\n \"n\": df_prop[\"offer\"].shape[0],\n \"mean (initial)\": metrics.get_mean(df_prop[\"offer\"]),\n \"mean\": metrics.get_mean(df_prop[\"offer_final\"]),\n \"median\": df_prop[\"offer_final\"].median(),\n \"mode\": df_prop[\"offer_final\"].mode()[0],\n \"standard deviation\": metrics.get_std(df_prop[\"offer\"]),\n \"standard deviation\": metrics.get_std(df_prop[\"offer_final\"]),\n\n # \"rejection_ratio\": rejection_ratio(df_prop)\n \"stat\": resp_stat[0],\n \"p-value\": resp_stat[1],\n \"stat-t00\": resp_stat_t00[0],\n \"p-value-t00\": resp_stat_t00[1],\n \"stat-wc\": resp_wc_stat[0],\n \"p-value-wc\": resp_wc_stat[1],\n }\n return {k: (f\"{v:.3f}\" if pd.notnull(v) and v!= int(v) else v) for k,v in res.items()}\n\n\n@mark_for_stats()\ndef get_prop_system_usage(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if SELECTION != \"prop\":\n return\n df_prop, df_resp = get_prop_resp(treatment)\n df_prop[df_prop.columns] = df_prop\n \n n = df_prop.shape[0]\n\n usage_ratio = metrics.get_mean(metrics.get_dss_usage(df_prop))\n unique_calls = metrics.get_mean(metrics.get_dss_average_unique_calls(df_prop))\n\n pnull = 0\n phat = usage_ratio\n \n z_ratio = sms.proportions_ztest(usage_ratio * n, n, pnull, alternative='larger')\n # z_calls = sms.proportions_ztest()\n res = {\n \"usage_ratio\": f\"{100*usage_ratio:.2f} %\",\n \"mean unique-calls\": unique_calls,\n \"z-score-usage_ratio\": f\"{z_ratio[0]:.3f} ({z_ratio[1]:.3f})\",\n #\"z-score- mean unique-calls\": 0\n }\n\n return {k: (f\"{v:.3f}\" if isinstance(v, numbers.Number) and v!= int(v) else v) for k,v in res.items()}\n# @mark_for_stats()\n# def get_rel_responder_gain2(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# if SELECTION != \"resp\":\n# return\n# df_prop, df_resp = get_prop_resp(treatment)\n# df_prop[df_resp.columns] = df_resp\n# resp_gain = metrics.get_mean(metrics.gain_responder(df_prop[\"min_offer\"], df_prop[\"offer\"]))\n# resp_gain_dss = metrics.get_mean(metrics.gain_responder(df_prop[\"min_offer_dss\"], df_prop[\"offer_final\"]))\n# resp_gain_2 = metrics.get_mean(metrics.get_rel_gain_responder(df_prop[\"min_offer\"], df_prop[\"min_offer_dss\"], df_prop[\"offer\"]))\n# resp_gain_dss_2 = metrics.get_mean(metrics.get_rel_gain_responder(df_prop[\"min_offer\"], df_prop[\"min_offer_dss\"], df_prop[\"offer_final\"]))\n# return {\n# \"resp_gain: \": resp_gain,\n# \"resp_gain_dss: \": resp_gain_dss,\n# \"rel_gain: vs proposer\": resp_gain_2,\n# \"rel_gain: vs proposer + DSS\": resp_gain_dss_2,\n# # \"rejection_ratio\": rejection_ratio(df_prop)\n# }\n\n\n#@mark_for_stats()\n# def get_ttest_proposer_gain(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# if SELECTION != \"prop\":\n# return\n# df_prop, df_resp = get_prop_resp(treatment)\n# x = gain(df_prop[\"offer\"], df_resp[\"min_offer\"])\n# y = gain(df_prop[\"offer_dss\"], df_resp[\"min_offer\"])\n# s, p = stats.ttest_rel(x, y, axis=0)\n# return {\"stat\": f\"{round(s, 3)}\", \"p\": f\"{round(p, 3)}\"}\n\n# # @mark_for_stats()\n# def get_ks_2samp(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# df_prop = ALL_DFS[f\"result__{treatment}_prop\"]\n# offers = df_prop[\"offer\"]\n# offers_dss = df_prop[\"offer_dss\"]\n# s, p = stats.ks_2samp(offers, offers_dss)\n# return {\"stat\": s, \"p\": p}\n\n\n# @mark_for_stats()\n# def get_wilcoxon(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# df_prop = ALL_DFS[f\"result__{treatment}_prop\"]\n# offers = df_prop[\"offer\"]\n# offers_dss = df_prop[\"offer_dss\"]\n# s, p = stats.wilcoxon(offers, offers_dss)\n# return {\"stat\": s, \"p\": p}\n\n# @mark_for_stats()\n# def get_wilcoxon_proposer_gain(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# if SELECTION != \"prop\":\n# return\n# df_prop, df_resp = get_prop_resp(treatment)\n# x = gain(df_prop[\"offer\"], df_resp[\"min_offer\"])\n# y = gain(df_prop[\"offer_dss\"], df_resp[\"min_offer\"])\n# s, p = stats.wilcoxon(x, y)\n# return {\"stat\": f\"{round(s, 3)}\", \"p\": f\"{round(p, 3)}\"}\n\n\n@mark_for_stats()\ndef get_wilcoxon_proposer_gain(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if SELECTION != \"prop\":\n return\n df_prop, df_resp = get_prop_resp(treatment)\n x = gain(df_prop[\"offer\"], df_resp[\"min_offer\"])\n y = gain(df_prop[\"offer_dss\"], df_resp[\"min_offer\"])\n s, p = stats.wilcoxon(x, y, alternative='greater')\n # return {\"stat\": f\"{round(s, 3)}\", \"p\": f\"{round(p, 3)}\"}\n return {\"$H_0$: equal, H_a: greater\": f\"{s:.3f} ({p:.3f})\"}\n\n\n\n@mark_for_stats()\ndef get_mean_proposer_gain(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if SELECTION != \"prop\":\n return\n return _get_prop_vs_prop_dss_score(treatment, con, dfs, use_percentage, use_labels, metric=gain, as_percentage=False, alternative=\"less\" )\n\n\ndef generate_stats(treatment, con, dfs):\n stats = {label:function(treatment, con, dfs) for label, function in STATS_FUNCTIONS.items()}\n return stats\n\n\ndef main():\n global USE_PERCENTAGE, USE_LABELS, SELECTION\n parser = get_parser()\n args = parser.parse_args()\n\n treatments = args.treatments.split(\",\")\n\n USE_PERCENTAGE = args.use_percentage\n\n USE_LABELS = args.use_labels\n\n SELECTION = args.selection\n\n results = dict()\n lst_stats = []\n for treatment in treatments:\n if \".\" in treatment:\n treatment, SELECTION = treatment.split(\".\")\n else:\n SELECTION = args.selection\n #con, dfs = get_con_and_dfs(treatment)\n con = ALL_CONS[treatment]\n dfs = ALL_DFS\n stats = generate_stats(treatment, con, dfs)\n for k, v in stats.items():\n lst = results.get(k, [])\n lst.append(v)\n results[k] = lst\n\n print(\"\\n\\n\")\n for k, items in results.items():\n columns = None\n if items and isinstance(items[0], (tuple, list, set, dict)):\n columns = list(items[0])\n df = pd.DataFrame(items, index=treatments, columns=columns)\n\n if (args.transpose):\n df = df.T\n print(k)\n if args.use_latex:\n print(df.T.to_latex())\n else:\n print(df.T)\n print(\"DONE\")\n\n\nif __name__ == \"__main__\":\n main()",
"import sys\nimport os\nimport argparse\nimport pandas as pd\nimport numpy as np\n\nsys.path.extend([os.path.join(os.path.split(__file__)[0], parent) for parent in [\"..\", \"../..\"]])\n\nfrom utils import get_con_and_dfs\n\nSTATS_FUNCTIONS = {}\n\n\n\n\n# overwritten by a command line flag. If true, percentage will be generated instead of frequency\nUSE_PERCENTAGE = None\n\nUSE_LABELS = None\n\nSELECTION = None\n\nAI_FEEDBACK_ACCURACY_SCALAS = {\n \"ai_much_worse\": \"AI much worse than PROPOSER\",\n \"ai_worse\": \"AI worse\",\n \"ai_sligthly_worse\": \"AI slighly worse\",\n \"ai_equal_to_proposer\": \"AI equal to PROPOSER\",\n \"ai_slighly_better\": \"AI slighly better\",\n \"ai_better\": \"AI better\",\n \"ai_much_better\": \"AI much better than the PROPOSER\",\n}\n\nAI_FEEDBACK_SCALAS = {\n 1: \"strongly_disagree\",\n 2: \"disagree\",\n 3: \"slightly_disagree\",\n 4: \"neutral\",\n 5: \"slightly_agree\",\n 6: \"agree\",\n 7: \"strongly_agree\"\n}\n\ndef get_parser():\n parser = argparse.ArgumentParser(description='Generate statistics for a given treatment')\n parser.add_argument('--use-percentage', help='Generate percentages instead of frequencies', action='store_true')\n parser.add_argument('--use-latex', help='Print results as latex table', action='store_true')\n parser.add_argument('--use-labels', help='Print results using description labels', action='store_true')\n parser.add_argument('--output-dir', help='Output directory where csv files were exported')\n parser.add_argument('--selection', help='Whether to restrict the stats to responder or proposers', choices=['prop', 'resp'])\n parser.add_argument('treatments', help='Comma separated treatments')\n return parser\n\n\n\n\ndef mark_for_stats(label=None):\n def _mark_for_stats(function, label=label):\n if label is None:\n label = function.__name__[4:]\n STATS_FUNCTIONS[label] = function\n return function\n return _mark_for_stats\n\n\ndef _get_feedback_accuracy_stat(name, labels, treatment, con, dfs=None, use_percentage=None, use_labels=None, transformer=None):\n if SELECTION is None:\n sql = f\"\"\"\n select * from (\n select {name}, worker_id from result__{treatment}_resp\n union\n select {name}, worker_id from result__{treatment}_prop\n \n )\n \"\"\"\n else:\n sql = f\"\"\"\n select * from (\n select {name}, worker_id from result__{treatment}_{SELECTION}\n )\n \"\"\"\n if use_percentage is None:\n use_percentage = USE_PERCENTAGE\n if use_labels is None:\n use_labels = USE_LABELS\n try:\n df = pd.read_sql(sql, con)\n except Exception as err:\n df = pd.DataFrame(columns=[name])\n data = df[name].values\n result = {}\n for item in data:\n result[item] = result.get(item, 0) + 1\n\n result = {k:(result[k] if k in result else 0) for k in labels}\n\n if transformer is not None:\n result = transformer(result, data)\n if use_percentage:\n new_result = {}\n for k, v in result.items():\n if isinstance(v, (int, float)):\n new_result[k] = f\"{round(result[k])} ({round(100 * result[k]/(len(data) or 1), 2)})\"\n else:\n new_result[k] = v\n # result = {k: f\"{round(result[k])} ({round(100 * result[k]/(len(data) or 1), 2)})\" for k in result}\n result = new_result\n\n if use_labels:\n label_result = {}\n for k, l in labels.items():\n label_result[l] = result.get(k)\n result = label_result\n \n if (data==None).sum()==data.shape[0]:\n for k in result:\n result[k] = \"n/a\"\n return result\n\n\n\nAI_FEEDBACK_ACCURACY_SCALAS_REV = {\n \"ai_much_worse\": 1,\n \"ai_worse\": 2,\n \"ai_sligthly_worse\": 3,\n \"ai_equal_to_proposer\": 4,\n \"ai_slighly_better\": 5,\n \"ai_better\": 6,\n \"ai_much_better\": 7,\n}\n\n\n# def transformer_alt(tmp, data):\n# res = {}\n# values = []\n# coefs = []\n# for k, v in tmp.items():\n# if k in (1, 2, 3):\n# res[\"disagree\"] = res.get(\"disagree\", 0) + v\n# elif k in (4, ):\n# res[\"neutral\"] = res.get(\"neutral\", 0) + v\n# elif k in (5, 6, 7):\n# res[\"agree\"] = res.get(\"agree\", 0) + v\n# else:\n# res[k] = res.get(k, 0) + v\n# values.append(v*k)\n# coefs.append(k)\n# res[\"mean\"] = f\"{round((np.mean(data)), 2)}\"\n# res[\"std\"] = f\"{round((np.std(data)), 2)}\"\n# #res[\"cronbach alpha\"] = cronbach_alpha(data)\n# return res\n\n\n\n\ndef transformer_alt(tmp, data):\n res = {}\n values = []\n coefs = []\n for k, v in tmp.items():\n if k in (1, 2, 3):\n res[\"disagree\"] = res.get(\"disagree\", 0) + v\n elif k in (4, ):\n res[\"neutral\"] = res.get(\"neutral\", 0) + v\n elif k in (5, 6, 7):\n res[\"agree\"] = res.get(\"agree\", 0) + v\n else:\n res[k] = res.get(k, 0) + v\n values.append(v*k)\n coefs.append(k)\n res[\"mean\"] = f\"{round((np.mean(data)), 2)}\"\n res[\"std\"] = f\"{round((np.std(data)), 2)}\"\n #res[\"cronbach alpha\"] = cronbach_alpha(data)\n return res\n\n@mark_for_stats()\ndef get_feedback_understanding(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if not use_labels:\n return _get_feedback_accuracy_stat(\"feedback_understanding\", AI_FEEDBACK_SCALAS, treatment, con, dfs, use_percentage, use_labels, transformer_alt)\n else:\n return _get_feedback_accuracy_stat(\"feedback_understanding\", AI_FEEDBACK_SCALAS, treatment, con, dfs, use_percentage, use_labels)\n\n\n\n\n@mark_for_stats()\ndef get_feedback_explainability(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n if not use_labels:\n return _get_feedback_accuracy_stat(\"feedback_explanation\", AI_FEEDBACK_SCALAS, treatment, con, dfs, use_percentage, use_labels, transformer_alt)\n else:\n return _get_feedback_accuracy_stat(\"feedback_explanation\", AI_FEEDBACK_SCALAS, treatment, con, dfs, use_percentage, use_labels)\n\n\n\n\n\n# @mark_for_stats()\n# def get_feedback_alternative(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# if not use_labels:\n# return _get_feedback_accuracy_stat(\"feedback_alternative\", AI_FEEDBACK_SCALAS, treatment, con, dfs, use_percentage, use_labels, transformer=transformer_alt)\n# else:\n# return _get_feedback_accuracy_stat(\"feedback_alternative\", AI_FEEDBACK_SCALAS, treatment, con, dfs, use_percentage, use_labels)\n\n\n# @mark_for_stats()\n# def get_feedback_fairness(treatment, con, dfs=None, use_percentage=None, use_labels=None):\n# if not use_labels:\n# return _get_feedback_accuracy_stat(\"feedback_fairness\", AI_FEEDBACK_SCALAS, treatment, con, dfs, use_percentage, use_labels, transformer=transformer_alt)\n# else:\n# return _get_feedback_accuracy_stat(\"feedback_fairness\", AI_FEEDBACK_SCALAS, treatment, con, dfs, use_percentage, use_labels)\n\n\n\ndef generate_stats(treatment, con, dfs):\n stats = {label:function(treatment, con, dfs) for label, function in STATS_FUNCTIONS.items()}\n return stats\n\ndef main():\n global USE_PERCENTAGE, USE_LABELS, SELECTION\n parser = get_parser()\n args = parser.parse_args()\n\n treatments = args.treatments.split(\",\")\n\n USE_PERCENTAGE = args.use_percentage\n\n USE_LABELS = args.use_labels\n\n SELECTION = args.selection\n\n results = dict()\n lst_stats = []\n for treatment in treatments:\n if \".\" in treatment:\n treatment, SELECTION = treatment.split(\".\")\n else:\n SELECTION = args.selection\n con, dfs = get_con_and_dfs(treatment)\n demographics = generate_stats(treatment, con, dfs)\n for k, v in demographics.items():\n lst = results.get(k, [])\n lst.append(v)\n results[k] = lst\n\n # if args.use_latex:\n # print(pd.DataFrame(lst_stats, index=treatments).T.to_latex())\n # else:\n # print(pd.DataFrame(lst_stats, index=treatments).T)\n print(\"\\n\\n\")\n print(len(results))\n for k, items in results.items():\n columns = None\n if items and isinstance(items[0], (tuple, list, set, dict)):\n columns = list(items[0])\n df = pd.DataFrame(items, index=treatments, columns=columns)\n print(k)\n if args.use_latex:\n print(df.to_latex())\n else:\n print(df)\n\n\n\nif __name__ == \"__main__\":\n main()"
] | [
[
"pandas.notnull",
"pandas.read_sql",
"pandas.DataFrame"
],
[
"pandas.notnull",
"pandas.read_sql",
"pandas.DataFrame"
],
[
"numpy.std",
"numpy.mean",
"pandas.read_sql",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
yangarbiter/python-features | [
"ab0b9035454bd467800daba7f27a152c06eecb13"
] | [
"pipeline/removeOutliers.py"
] | [
"from shutil import copyfile\nimport os, csv, sys, numpy\n\nDATA_FOLDER = sys.argv[1]\nOUT_FOLDER = sys.argv[2]\n\nfracs = {}\nfor fileName in os.listdir(DATA_FOLDER):\n with open(os.path.join(DATA_FOLDER,fileName), 'r') as inFile:\n csvFile = csv.DictReader(inFile)\n noChange = 0\n didChange = 0\n for row in csvFile:\n if row['L-NoChange'] == '1.0' and row['L-DidChange'] == '0.0':\n noChange += 1\n elif row['L-NoChange'] == '0.0' and row['L-DidChange'] == '1.0':\n didChange += 1\n else:\n raise hell #this should never happen\n fracs[fileName] = didChange / (didChange + noChange)\n\nos.makedirs(OUT_FOLDER, exist_ok=True)\n\nfracslist = list(fracs.values())\nmean = numpy.mean(fracslist)\nstd = numpy.std(fracslist)\nfor fileName in os.listdir(DATA_FOLDER):\n if fracs[fileName] <= mean+std:\n fullPath = os.path.join(DATA_FOLDER,fileName)\n copyfile(fullPath, os.path.join(OUT_FOLDER,fileName))"
] | [
[
"numpy.std",
"numpy.mean"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
kanavsetia/qiskit-chemistry | [
"d03abb9c4c37dfc343bf224bb947b4f2439e2269"
] | [
"test/test_mp2info.py"
] | [
"# -*- coding: utf-8 -*-\n\n# Copyright 2018 IBM.\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\nimport unittest\n\nimport numpy as np\n\nfrom qiskit.chemistry import QiskitChemistryError, MP2Info\nfrom qiskit.chemistry.drivers import PySCFDriver, UnitsType\nfrom test.common import QiskitChemistryTestCase\n\n\nclass TestMP2Info(QiskitChemistryTestCase):\n \"\"\"Test Mp2 Info class - uses PYSCF drive to get molecule.\"\"\"\n\n def setUp(self):\n try:\n driver = PySCFDriver(atom='Li .0 .0 .0; H .0 .0 1.6',\n unit=UnitsType.ANGSTROM,\n charge=0,\n spin=0,\n basis='sto3g')\n except QiskitChemistryError:\n self.skipTest('PYSCF driver does not appear to be installed')\n self.qmolecule = driver.run()\n self.mp2info = MP2Info(self.qmolecule)\n\n def test_mp2_delta(self):\n self.assertAlmostEqual(-0.012903900586859602, self.mp2info.mp2_delta, places=6)\n\n def test_mp2_energy(self):\n self.assertAlmostEqual(-7.874768670395503, self.mp2info.mp2_energy, places=6)\n\n def test_mp2_terms(self):\n terms = self.mp2info.mp2_terms()\n self.assertEqual(76, len(terms.keys()))\n\n def test_mp2_terms_frozen_core(self):\n terms = self.mp2info.mp2_terms(True)\n self.assertEqual(16, len(terms.keys()))\n\n def test_mp2_terms_frozen_core_orbital_reduction(self):\n terms = self.mp2info.mp2_terms(True, [-3, -2])\n self.assertEqual(4, len(terms.keys()))\n\n def test_mp2_get_term_info(self):\n excitations = [[0, 1, 5, 9], [0, 4, 5, 9]]\n coeffs, e_deltas = self.mp2info.mp2_get_term_info(excitations, True)\n np.testing.assert_array_almost_equal([0.028919010908783453, -0.07438748755263687],\n coeffs, decimal=6)\n np.testing.assert_array_almost_equal([-0.0010006159224579285, -0.009218577508137853],\n e_deltas, decimal=6)\n\n\nif __name__ == '__main__':\n unittest.main()\n"
] | [
[
"numpy.testing.assert_array_almost_equal"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
romanhaa/pandas | [
"3f67dc33088a088fe5a69ea2e3f3153565d53b3f"
] | [
"pandas/io/excel/_base.py"
] | [
"from __future__ import annotations\n\nimport abc\nimport datetime\nfrom io import BytesIO\nimport os\nfrom textwrap import fill\nfrom typing import (\n Any,\n Mapping,\n cast,\n)\nimport warnings\nimport zipfile\n\nfrom pandas._config import config\n\nfrom pandas._libs.parsers import STR_NA_VALUES\nfrom pandas._typing import (\n Buffer,\n DtypeArg,\n FilePathOrBuffer,\n StorageOptions,\n)\nfrom pandas.compat._optional import (\n get_version,\n import_optional_dependency,\n)\nfrom pandas.errors import EmptyDataError\nfrom pandas.util._decorators import (\n Appender,\n deprecate_nonkeyword_arguments,\n doc,\n)\nfrom pandas.util._exceptions import find_stack_level\n\nfrom pandas.core.dtypes.common import (\n is_bool,\n is_float,\n is_integer,\n is_list_like,\n)\n\nfrom pandas.core.frame import DataFrame\nfrom pandas.core.shared_docs import _shared_docs\nfrom pandas.util.version import Version\n\nfrom pandas.io.common import (\n IOHandles,\n get_handle,\n stringify_path,\n validate_header_arg,\n)\nfrom pandas.io.excel._util import (\n fill_mi_header,\n get_default_engine,\n get_writer,\n maybe_convert_usecols,\n pop_header_name,\n)\nfrom pandas.io.parsers import TextParser\n\n_read_excel_doc = (\n \"\"\"\nRead an Excel file into a pandas DataFrame.\n\nSupports `xls`, `xlsx`, `xlsm`, `xlsb`, `odf`, `ods` and `odt` file extensions\nread from a local filesystem or URL. Supports an option to read\na single sheet or a list of sheets.\n\nParameters\n----------\nio : str, bytes, ExcelFile, xlrd.Book, path object, or file-like object\n Any valid string path is acceptable. The string could be a URL. Valid\n URL schemes include http, ftp, s3, and file. For file URLs, a host is\n expected. A local file could be: ``file://localhost/path/to/table.xlsx``.\n\n If you want to pass in a path object, pandas accepts any ``os.PathLike``.\n\n By file-like object, we refer to objects with a ``read()`` method,\n such as a file handle (e.g. via builtin ``open`` function)\n or ``StringIO``.\nsheet_name : str, int, list, or None, default 0\n Strings are used for sheet names. Integers are used in zero-indexed\n sheet positions. Lists of strings/integers are used to request\n multiple sheets. Specify None to get all sheets.\n\n Available cases:\n\n * Defaults to ``0``: 1st sheet as a `DataFrame`\n * ``1``: 2nd sheet as a `DataFrame`\n * ``\"Sheet1\"``: Load sheet with name \"Sheet1\"\n * ``[0, 1, \"Sheet5\"]``: Load first, second and sheet named \"Sheet5\"\n as a dict of `DataFrame`\n * None: All sheets.\n\nheader : int, list of int, default 0\n Row (0-indexed) to use for the column labels of the parsed\n DataFrame. If a list of integers is passed those row positions will\n be combined into a ``MultiIndex``. Use None if there is no header.\nnames : array-like, default None\n List of column names to use. If file contains no header row,\n then you should explicitly pass header=None.\nindex_col : int, list of int, default None\n Column (0-indexed) to use as the row labels of the DataFrame.\n Pass None if there is no such column. If a list is passed,\n those columns will be combined into a ``MultiIndex``. If a\n subset of data is selected with ``usecols``, index_col\n is based on the subset.\nusecols : int, str, list-like, or callable default None\n * If None, then parse all columns.\n * If str, then indicates comma separated list of Excel column letters\n and column ranges (e.g. \"A:E\" or \"A,C,E:F\"). Ranges are inclusive of\n both sides.\n * If list of int, then indicates list of column numbers to be parsed.\n * If list of string, then indicates list of column names to be parsed.\n\n .. versionadded:: 0.24.0\n\n * If callable, then evaluate each column name against it and parse the\n column if the callable returns ``True``.\n\n Returns a subset of the columns according to behavior above.\n\n .. versionadded:: 0.24.0\n\nsqueeze : bool, default False\n If the parsed data only contains one column then return a Series.\ndtype : Type name or dict of column -> type, default None\n Data type for data or columns. E.g. {'a': np.float64, 'b': np.int32}\n Use `object` to preserve data as stored in Excel and not interpret dtype.\n If converters are specified, they will be applied INSTEAD\n of dtype conversion.\nengine : str, default None\n If io is not a buffer or path, this must be set to identify io.\n Supported engines: \"xlrd\", \"openpyxl\", \"odf\", \"pyxlsb\".\n Engine compatibility :\n\n - \"xlrd\" supports old-style Excel files (.xls).\n - \"openpyxl\" supports newer Excel file formats.\n - \"odf\" supports OpenDocument file formats (.odf, .ods, .odt).\n - \"pyxlsb\" supports Binary Excel files.\n\n .. versionchanged:: 1.2.0\n The engine `xlrd <https://xlrd.readthedocs.io/en/latest/>`_\n now only supports old-style ``.xls`` files.\n When ``engine=None``, the following logic will be\n used to determine the engine:\n\n - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),\n then `odf <https://pypi.org/project/odfpy/>`_ will be used.\n - Otherwise if ``path_or_buffer`` is an xls format,\n ``xlrd`` will be used.\n - Otherwise if ``path_or_buffer`` is in xlsb format,\n ``pyxlsb`` will be used.\n\n .. versionadded:: 1.3.0\n - Otherwise ``openpyxl`` will be used.\n\n .. versionchanged:: 1.3.0\n\nconverters : dict, default None\n Dict of functions for converting values in certain columns. Keys can\n either be integers or column labels, values are functions that take one\n input argument, the Excel cell content, and return the transformed\n content.\ntrue_values : list, default None\n Values to consider as True.\nfalse_values : list, default None\n Values to consider as False.\nskiprows : list-like, int, or callable, optional\n Line numbers to skip (0-indexed) or number of lines to skip (int) at the\n start of the file. If callable, the callable function will be evaluated\n against the row indices, returning True if the row should be skipped and\n False otherwise. An example of a valid callable argument would be ``lambda\n x: x in [0, 2]``.\nnrows : int, default None\n Number of rows to parse.\nna_values : scalar, str, list-like, or dict, default None\n Additional strings to recognize as NA/NaN. If dict passed, specific\n per-column NA values. By default the following values are interpreted\n as NaN: '\"\"\"\n + fill(\"', '\".join(sorted(STR_NA_VALUES)), 70, subsequent_indent=\" \")\n + \"\"\"'.\nkeep_default_na : bool, default True\n Whether or not to include the default NaN values when parsing the data.\n Depending on whether `na_values` is passed in, the behavior is as follows:\n\n * If `keep_default_na` is True, and `na_values` are specified, `na_values`\n is appended to the default NaN values used for parsing.\n * If `keep_default_na` is True, and `na_values` are not specified, only\n the default NaN values are used for parsing.\n * If `keep_default_na` is False, and `na_values` are specified, only\n the NaN values specified `na_values` are used for parsing.\n * If `keep_default_na` is False, and `na_values` are not specified, no\n strings will be parsed as NaN.\n\n Note that if `na_filter` is passed in as False, the `keep_default_na` and\n `na_values` parameters will be ignored.\nna_filter : bool, default True\n Detect missing value markers (empty strings and the value of na_values). In\n data without any NAs, passing na_filter=False can improve the performance\n of reading a large file.\nverbose : bool, default False\n Indicate number of NA values placed in non-numeric columns.\nparse_dates : bool, list-like, or dict, default False\n The behavior is as follows:\n\n * bool. If True -> try parsing the index.\n * list of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3\n each as a separate date column.\n * list of lists. e.g. If [[1, 3]] -> combine columns 1 and 3 and parse as\n a single date column.\n * dict, e.g. {'foo' : [1, 3]} -> parse columns 1, 3 as date and call\n result 'foo'\n\n If a column or index contains an unparsable date, the entire column or\n index will be returned unaltered as an object data type. If you don`t want to\n parse some cells as date just change their type in Excel to \"Text\".\n For non-standard datetime parsing, use ``pd.to_datetime`` after ``pd.read_excel``.\n\n Note: A fast-path exists for iso8601-formatted dates.\ndate_parser : function, optional\n Function to use for converting a sequence of string columns to an array of\n datetime instances. The default uses ``dateutil.parser.parser`` to do the\n conversion. Pandas will try to call `date_parser` in three different ways,\n advancing to the next if an exception occurs: 1) Pass one or more arrays\n (as defined by `parse_dates`) as arguments; 2) concatenate (row-wise) the\n string values from the columns defined by `parse_dates` into a single array\n and pass that; and 3) call `date_parser` once for each row using one or\n more strings (corresponding to the columns defined by `parse_dates`) as\n arguments.\nthousands : str, default None\n Thousands separator for parsing string columns to numeric. Note that\n this parameter is only necessary for columns stored as TEXT in Excel,\n any numeric columns will automatically be parsed, regardless of display\n format.\ncomment : str, default None\n Comments out remainder of line. Pass a character or characters to this\n argument to indicate comments in the input file. Any data between the\n comment string and the end of the current line is ignored.\nskipfooter : int, default 0\n Rows at the end to skip (0-indexed).\nconvert_float : bool, default True\n Convert integral floats to int (i.e., 1.0 --> 1). If False, all numeric\n data will be read in as floats: Excel stores all numbers as floats\n internally.\n\n .. deprecated:: 1.3.0\n convert_float will be removed in a future version\n\nmangle_dupe_cols : bool, default True\n Duplicate columns will be specified as 'X', 'X.1', ...'X.N', rather than\n 'X'...'X'. Passing in False will cause data to be overwritten if there\n are duplicate names in the columns.\nstorage_options : dict, optional\n Extra options that make sense for a particular storage connection, e.g.\n host, port, username, password, etc., if using a URL that will\n be parsed by ``fsspec``, e.g., starting \"s3://\", \"gcs://\". An error\n will be raised if providing this argument with a local path or\n a file-like buffer. See the fsspec and backend storage implementation\n docs for the set of allowed keys and values.\n\n .. versionadded:: 1.2.0\n\nReturns\n-------\nDataFrame or dict of DataFrames\n DataFrame from the passed in Excel file. See notes in sheet_name\n argument for more information on when a dict of DataFrames is returned.\n\nSee Also\n--------\nDataFrame.to_excel : Write DataFrame to an Excel file.\nDataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.\nread_csv : Read a comma-separated values (csv) file into DataFrame.\nread_fwf : Read a table of fixed-width formatted lines into DataFrame.\n\nExamples\n--------\nThe file can be read using the file name as string or an open file object:\n\n>>> pd.read_excel('tmp.xlsx', index_col=0) # doctest: +SKIP\n Name Value\n0 string1 1\n1 string2 2\n2 #Comment 3\n\n>>> pd.read_excel(open('tmp.xlsx', 'rb'),\n... sheet_name='Sheet3') # doctest: +SKIP\n Unnamed: 0 Name Value\n0 0 string1 1\n1 1 string2 2\n2 2 #Comment 3\n\nIndex and header can be specified via the `index_col` and `header` arguments\n\n>>> pd.read_excel('tmp.xlsx', index_col=None, header=None) # doctest: +SKIP\n 0 1 2\n0 NaN Name Value\n1 0.0 string1 1\n2 1.0 string2 2\n3 2.0 #Comment 3\n\nColumn types are inferred but can be explicitly specified\n\n>>> pd.read_excel('tmp.xlsx', index_col=0,\n... dtype={'Name': str, 'Value': float}) # doctest: +SKIP\n Name Value\n0 string1 1.0\n1 string2 2.0\n2 #Comment 3.0\n\nTrue, False, and NA values, and thousands separators have defaults,\nbut can be explicitly specified, too. Supply the values you would like\nas strings or lists of strings!\n\n>>> pd.read_excel('tmp.xlsx', index_col=0,\n... na_values=['string1', 'string2']) # doctest: +SKIP\n Name Value\n0 NaN 1\n1 NaN 2\n2 #Comment 3\n\nComment lines in the excel input file can be skipped using the `comment` kwarg\n\n>>> pd.read_excel('tmp.xlsx', index_col=0, comment='#') # doctest: +SKIP\n Name Value\n0 string1 1.0\n1 string2 2.0\n2 None NaN\n\"\"\"\n)\n\n\n@deprecate_nonkeyword_arguments(allowed_args=[\"io\", \"sheet_name\"], version=\"2.0\")\n@Appender(_read_excel_doc)\ndef read_excel(\n io,\n sheet_name=0,\n header=0,\n names=None,\n index_col=None,\n usecols=None,\n squeeze=False,\n dtype: DtypeArg | None = None,\n engine=None,\n converters=None,\n true_values=None,\n false_values=None,\n skiprows=None,\n nrows=None,\n na_values=None,\n keep_default_na=True,\n na_filter=True,\n verbose=False,\n parse_dates=False,\n date_parser=None,\n thousands=None,\n comment=None,\n skipfooter=0,\n convert_float=None,\n mangle_dupe_cols=True,\n storage_options: StorageOptions = None,\n):\n\n should_close = False\n if not isinstance(io, ExcelFile):\n should_close = True\n io = ExcelFile(io, storage_options=storage_options, engine=engine)\n elif engine and engine != io.engine:\n raise ValueError(\n \"Engine should not be specified when passing \"\n \"an ExcelFile - ExcelFile already has the engine set\"\n )\n\n try:\n data = io.parse(\n sheet_name=sheet_name,\n header=header,\n names=names,\n index_col=index_col,\n usecols=usecols,\n squeeze=squeeze,\n dtype=dtype,\n converters=converters,\n true_values=true_values,\n false_values=false_values,\n skiprows=skiprows,\n nrows=nrows,\n na_values=na_values,\n keep_default_na=keep_default_na,\n na_filter=na_filter,\n verbose=verbose,\n parse_dates=parse_dates,\n date_parser=date_parser,\n thousands=thousands,\n comment=comment,\n skipfooter=skipfooter,\n convert_float=convert_float,\n mangle_dupe_cols=mangle_dupe_cols,\n )\n finally:\n # make sure to close opened file handles\n if should_close:\n io.close()\n return data\n\n\nclass BaseExcelReader(metaclass=abc.ABCMeta):\n def __init__(self, filepath_or_buffer, storage_options: StorageOptions = None):\n self.handles = IOHandles(\n handle=filepath_or_buffer, compression={\"method\": None}\n )\n if not isinstance(filepath_or_buffer, (ExcelFile, self._workbook_class)):\n self.handles = get_handle(\n filepath_or_buffer, \"rb\", storage_options=storage_options, is_text=False\n )\n\n if isinstance(self.handles.handle, self._workbook_class):\n self.book = self.handles.handle\n elif hasattr(self.handles.handle, \"read\"):\n # N.B. xlrd.Book has a read attribute too\n self.handles.handle.seek(0)\n try:\n self.book = self.load_workbook(self.handles.handle)\n except Exception:\n self.close()\n raise\n elif isinstance(self.handles.handle, bytes):\n self.book = self.load_workbook(BytesIO(self.handles.handle))\n else:\n raise ValueError(\n \"Must explicitly set engine if not passing in buffer or path for io.\"\n )\n\n @property\n @abc.abstractmethod\n def _workbook_class(self):\n pass\n\n @abc.abstractmethod\n def load_workbook(self, filepath_or_buffer):\n pass\n\n def close(self):\n if hasattr(self, \"book\") and hasattr(self.book, \"close\"):\n # pyxlsb: opens a TemporaryFile\n # openpyxl: https://stackoverflow.com/questions/31416842/\n # openpyxl-does-not-close-excel-workbook-in-read-only-mode\n self.book.close()\n self.handles.close()\n\n @property\n @abc.abstractmethod\n def sheet_names(self):\n pass\n\n @abc.abstractmethod\n def get_sheet_by_name(self, name):\n pass\n\n @abc.abstractmethod\n def get_sheet_by_index(self, index):\n pass\n\n @abc.abstractmethod\n def get_sheet_data(self, sheet, convert_float):\n pass\n\n def raise_if_bad_sheet_by_index(self, index: int) -> None:\n n_sheets = len(self.sheet_names)\n if index >= n_sheets:\n raise ValueError(\n f\"Worksheet index {index} is invalid, {n_sheets} worksheets found\"\n )\n\n def raise_if_bad_sheet_by_name(self, name: str) -> None:\n if name not in self.sheet_names:\n raise ValueError(f\"Worksheet named '{name}' not found\")\n\n def parse(\n self,\n sheet_name=0,\n header=0,\n names=None,\n index_col=None,\n usecols=None,\n squeeze=False,\n dtype: DtypeArg | None = None,\n true_values=None,\n false_values=None,\n skiprows=None,\n nrows=None,\n na_values=None,\n verbose=False,\n parse_dates=False,\n date_parser=None,\n thousands=None,\n comment=None,\n skipfooter=0,\n convert_float=None,\n mangle_dupe_cols=True,\n **kwds,\n ):\n\n if convert_float is None:\n convert_float = True\n else:\n stacklevel = find_stack_level()\n warnings.warn(\n \"convert_float is deprecated and will be removed in a future version\",\n FutureWarning,\n stacklevel=stacklevel,\n )\n\n validate_header_arg(header)\n\n ret_dict = False\n\n # Keep sheetname to maintain backwards compatibility.\n if isinstance(sheet_name, list):\n sheets = sheet_name\n ret_dict = True\n elif sheet_name is None:\n sheets = self.sheet_names\n ret_dict = True\n else:\n sheets = [sheet_name]\n\n # handle same-type duplicates.\n sheets = list(dict.fromkeys(sheets).keys())\n\n output = {}\n\n for asheetname in sheets:\n if verbose:\n print(f\"Reading sheet {asheetname}\")\n\n if isinstance(asheetname, str):\n sheet = self.get_sheet_by_name(asheetname)\n else: # assume an integer if not a string\n sheet = self.get_sheet_by_index(asheetname)\n\n data = self.get_sheet_data(sheet, convert_float)\n if hasattr(sheet, \"close\"):\n # pyxlsb opens two TemporaryFiles\n sheet.close()\n usecols = maybe_convert_usecols(usecols)\n\n if not data:\n output[asheetname] = DataFrame()\n continue\n\n if is_list_like(header) and len(header) == 1:\n header = header[0]\n\n # forward fill and pull out names for MultiIndex column\n header_names = None\n if header is not None and is_list_like(header):\n header_names = []\n control_row = [True] * len(data[0])\n\n for row in header:\n if is_integer(skiprows):\n row += skiprows\n\n data[row], control_row = fill_mi_header(data[row], control_row)\n\n if index_col is not None:\n header_name, _ = pop_header_name(data[row], index_col)\n header_names.append(header_name)\n\n # If there is a MultiIndex header and an index then there is also\n # a row containing just the index name(s)\n has_index_names = (\n is_list_like(header) and len(header) > 1 and index_col is not None\n )\n\n if is_list_like(index_col):\n # Forward fill values for MultiIndex index.\n if header is None:\n offset = 0\n elif not is_list_like(header):\n offset = 1 + header\n else:\n offset = 1 + max(header)\n\n # GH34673: if MultiIndex names present and not defined in the header,\n # offset needs to be incremented so that forward filling starts\n # from the first MI value instead of the name\n if has_index_names:\n offset += 1\n\n # Check if we have an empty dataset\n # before trying to collect data.\n if offset < len(data):\n for col in index_col:\n last = data[offset][col]\n\n for row in range(offset + 1, len(data)):\n if data[row][col] == \"\" or data[row][col] is None:\n data[row][col] = last\n else:\n last = data[row][col]\n\n # GH 12292 : error when read one empty column from excel file\n try:\n parser = TextParser(\n data,\n names=names,\n header=header,\n index_col=index_col,\n has_index_names=has_index_names,\n squeeze=squeeze,\n dtype=dtype,\n true_values=true_values,\n false_values=false_values,\n skiprows=skiprows,\n nrows=nrows,\n na_values=na_values,\n skip_blank_lines=False, # GH 39808\n parse_dates=parse_dates,\n date_parser=date_parser,\n thousands=thousands,\n comment=comment,\n skipfooter=skipfooter,\n usecols=usecols,\n mangle_dupe_cols=mangle_dupe_cols,\n **kwds,\n )\n\n output[asheetname] = parser.read(nrows=nrows)\n\n if not squeeze or isinstance(output[asheetname], DataFrame):\n if header_names:\n output[asheetname].columns = output[\n asheetname\n ].columns.set_names(header_names)\n\n except EmptyDataError:\n # No Data, return an empty DataFrame\n output[asheetname] = DataFrame()\n\n if ret_dict:\n return output\n else:\n return output[asheetname]\n\n\nclass ExcelWriter(metaclass=abc.ABCMeta):\n \"\"\"\n Class for writing DataFrame objects into excel sheets.\n\n Default is to use xlwt for xls, openpyxl for xlsx, odf for ods.\n See DataFrame.to_excel for typical usage.\n\n The writer should be used as a context manager. Otherwise, call `close()` to save\n and close any opened file handles.\n\n Parameters\n ----------\n path : str or typing.BinaryIO\n Path to xls or xlsx or ods file.\n engine : str (optional)\n Engine to use for writing. If None, defaults to\n ``io.excel.<extension>.writer``. NOTE: can only be passed as a keyword\n argument.\n\n .. deprecated:: 1.2.0\n\n As the `xlwt <https://pypi.org/project/xlwt/>`__ package is no longer\n maintained, the ``xlwt`` engine will be removed in a future\n version of pandas.\n\n date_format : str, default None\n Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').\n datetime_format : str, default None\n Format string for datetime objects written into Excel files.\n (e.g. 'YYYY-MM-DD HH:MM:SS').\n mode : {'w', 'a'}, default 'w'\n File mode to use (write or append). Append does not work with fsspec URLs.\n\n .. versionadded:: 0.24.0\n storage_options : dict, optional\n Extra options that make sense for a particular storage connection, e.g.\n host, port, username, password, etc., if using a URL that will\n be parsed by ``fsspec``, e.g., starting \"s3://\", \"gcs://\".\n\n .. versionadded:: 1.2.0\n if_sheet_exists : {'error', 'new', 'replace'}, default 'error'\n How to behave when trying to write to a sheet that already\n exists (append mode only).\n\n * error: raise a ValueError.\n * new: Create a new sheet, with a name determined by the engine.\n * replace: Delete the contents of the sheet before writing to it.\n\n .. versionadded:: 1.3.0\n engine_kwargs : dict, optional\n Keyword arguments to be passed into the engine.\n\n .. versionadded:: 1.3.0\n **kwargs : dict, optional\n Keyword arguments to be passed into the engine.\n\n .. deprecated:: 1.3.0\n\n Use engine_kwargs instead.\n\n Attributes\n ----------\n None\n\n Methods\n -------\n None\n\n Notes\n -----\n None of the methods and properties are considered public.\n\n For compatibility with CSV writers, ExcelWriter serializes lists\n and dicts to strings before writing.\n\n Examples\n --------\n Default usage:\n\n >>> df = pd.DataFrame([[\"ABC\", \"XYZ\"]], columns=[\"Foo\", \"Bar\"])\n >>> with ExcelWriter(\"path_to_file.xlsx\") as writer:\n ... df.to_excel(writer)\n\n To write to separate sheets in a single file:\n\n >>> df1 = pd.DataFrame([[\"AAA\", \"BBB\"]], columns=[\"Spam\", \"Egg\"])\n >>> df2 = pd.DataFrame([[\"ABC\", \"XYZ\"]], columns=[\"Foo\", \"Bar\"])\n >>> with ExcelWriter(\"path_to_file.xlsx\") as writer:\n ... df1.to_excel(writer, sheet_name=\"Sheet1\")\n ... df2.to_excel(writer, sheet_name=\"Sheet2\")\n\n You can set the date format or datetime format:\n\n >>> from datetime import date, datetime\n >>> df = pd.DataFrame(\n ... [\n ... [date(2014, 1, 31), date(1999, 9, 24)],\n ... [datetime(1998, 5, 26, 23, 33, 4), datetime(2014, 2, 28, 13, 5, 13)],\n ... ],\n ... index=[\"Date\", \"Datetime\"],\n ... columns=[\"X\", \"Y\"],\n ... )\n >>> with ExcelWriter(\n ... \"path_to_file.xlsx\",\n ... date_format=\"YYYY-MM-DD\",\n ... datetime_format=\"YYYY-MM-DD HH:MM:SS\"\n ... ) as writer:\n ... df.to_excel(writer)\n\n You can also append to an existing Excel file:\n\n >>> with ExcelWriter(\"path_to_file.xlsx\", mode=\"a\", engine=\"openpyxl\") as writer:\n ... df.to_excel(writer, sheet_name=\"Sheet3\")\n\n You can store Excel file in RAM:\n\n >>> import io\n >>> df = pd.DataFrame([[\"ABC\", \"XYZ\"]], columns=[\"Foo\", \"Bar\"])\n >>> buffer = io.BytesIO()\n >>> with pd.ExcelWriter(buffer) as writer:\n ... df.to_excel(writer)\n\n You can pack Excel file into zip archive:\n\n >>> import zipfile\n >>> df = pd.DataFrame([[\"ABC\", \"XYZ\"]], columns=[\"Foo\", \"Bar\"])\n >>> with zipfile.ZipFile(\"path_to_file.zip\", \"w\") as zf:\n ... with zf.open(\"filename.xlsx\", \"w\") as buffer:\n ... with pd.ExcelWriter(buffer) as writer:\n ... df.to_excel(writer)\n \"\"\"\n\n # Defining an ExcelWriter implementation (see abstract methods for more...)\n\n # - Mandatory\n # - ``write_cells(self, cells, sheet_name=None, startrow=0, startcol=0)``\n # --> called to write additional DataFrames to disk\n # - ``supported_extensions`` (tuple of supported extensions), used to\n # check that engine supports the given extension.\n # - ``engine`` - string that gives the engine name. Necessary to\n # instantiate class directly and bypass ``ExcelWriterMeta`` engine\n # lookup.\n # - ``save(self)`` --> called to save file to disk\n # - Mostly mandatory (i.e. should at least exist)\n # - book, cur_sheet, path\n\n # - Optional:\n # - ``__init__(self, path, engine=None, **kwargs)`` --> always called\n # with path as first argument.\n\n # You also need to register the class with ``register_writer()``.\n # Technically, ExcelWriter implementations don't need to subclass\n # ExcelWriter.\n def __new__(\n cls,\n path: FilePathOrBuffer | ExcelWriter,\n engine=None,\n date_format=None,\n datetime_format=None,\n mode: str = \"w\",\n storage_options: StorageOptions = None,\n if_sheet_exists: str | None = None,\n engine_kwargs: dict | None = None,\n **kwargs,\n ):\n if kwargs:\n if engine_kwargs is not None:\n raise ValueError(\"Cannot use both engine_kwargs and **kwargs\")\n warnings.warn(\n \"Use of **kwargs is deprecated, use engine_kwargs instead.\",\n FutureWarning,\n stacklevel=2,\n )\n\n # only switch class if generic(ExcelWriter)\n\n if cls is ExcelWriter:\n if engine is None or (isinstance(engine, str) and engine == \"auto\"):\n if isinstance(path, str):\n ext = os.path.splitext(path)[-1][1:]\n else:\n ext = \"xlsx\"\n\n try:\n engine = config.get_option(f\"io.excel.{ext}.writer\", silent=True)\n if engine == \"auto\":\n engine = get_default_engine(ext, mode=\"writer\")\n except KeyError as err:\n raise ValueError(f\"No engine for filetype: '{ext}'\") from err\n\n if engine == \"xlwt\":\n xls_config_engine = config.get_option(\n \"io.excel.xls.writer\", silent=True\n )\n # Don't warn a 2nd time if user has changed the default engine for xls\n if xls_config_engine != \"xlwt\":\n warnings.warn(\n \"As the xlwt package is no longer maintained, the xlwt \"\n \"engine will be removed in a future version of pandas. \"\n \"This is the only engine in pandas that supports writing \"\n \"in the xls format. Install openpyxl and write to an xlsx \"\n \"file instead. You can set the option io.excel.xls.writer \"\n \"to 'xlwt' to silence this warning. While this option is \"\n \"deprecated and will also raise a warning, it can \"\n \"be globally set and the warning suppressed.\",\n FutureWarning,\n stacklevel=4,\n )\n\n cls = get_writer(engine)\n\n return object.__new__(cls)\n\n # declare external properties you can count on\n path = None\n\n @property\n @abc.abstractmethod\n def supported_extensions(self):\n \"\"\"Extensions that writer engine supports.\"\"\"\n pass\n\n @property\n @abc.abstractmethod\n def engine(self):\n \"\"\"Name of engine.\"\"\"\n pass\n\n @abc.abstractmethod\n def write_cells(\n self, cells, sheet_name=None, startrow=0, startcol=0, freeze_panes=None\n ):\n \"\"\"\n Write given formatted cells into Excel an excel sheet\n\n Parameters\n ----------\n cells : generator\n cell of formatted data to save to Excel sheet\n sheet_name : str, default None\n Name of Excel sheet, if None, then use self.cur_sheet\n startrow : upper left cell row to dump data frame\n startcol : upper left cell column to dump data frame\n freeze_panes: int tuple of length 2\n contains the bottom-most row and right-most column to freeze\n \"\"\"\n pass\n\n @abc.abstractmethod\n def save(self):\n \"\"\"\n Save workbook to disk.\n \"\"\"\n pass\n\n def __init__(\n self,\n path: FilePathOrBuffer | ExcelWriter,\n engine=None,\n date_format=None,\n datetime_format=None,\n mode: str = \"w\",\n storage_options: StorageOptions = None,\n if_sheet_exists: str | None = None,\n engine_kwargs: dict | None = None,\n **kwargs,\n ):\n # validate that this engine can handle the extension\n if isinstance(path, str):\n ext = os.path.splitext(path)[-1]\n self.check_extension(ext)\n\n # use mode to open the file\n if \"b\" not in mode:\n mode += \"b\"\n # use \"a\" for the user to append data to excel but internally use \"r+\" to let\n # the excel backend first read the existing file and then write any data to it\n mode = mode.replace(\"a\", \"r+\")\n\n # cast ExcelWriter to avoid adding 'if self.handles is not None'\n self.handles = IOHandles(cast(Buffer, path), compression={\"copression\": None})\n if not isinstance(path, ExcelWriter):\n self.handles = get_handle(\n path, mode, storage_options=storage_options, is_text=False\n )\n self.sheets: dict[str, Any] = {}\n self.cur_sheet = None\n\n if date_format is None:\n self.date_format = \"YYYY-MM-DD\"\n else:\n self.date_format = date_format\n if datetime_format is None:\n self.datetime_format = \"YYYY-MM-DD HH:MM:SS\"\n else:\n self.datetime_format = datetime_format\n\n self.mode = mode\n\n if if_sheet_exists not in [None, \"error\", \"new\", \"replace\"]:\n raise ValueError(\n f\"'{if_sheet_exists}' is not valid for if_sheet_exists. \"\n \"Valid options are 'error', 'new' and 'replace'.\"\n )\n if if_sheet_exists and \"r+\" not in mode:\n raise ValueError(\"if_sheet_exists is only valid in append mode (mode='a')\")\n if if_sheet_exists is None:\n if_sheet_exists = \"error\"\n self.if_sheet_exists = if_sheet_exists\n\n def __fspath__(self):\n return getattr(self.handles.handle, \"name\", \"\")\n\n def _get_sheet_name(self, sheet_name):\n if sheet_name is None:\n sheet_name = self.cur_sheet\n if sheet_name is None: # pragma: no cover\n raise ValueError(\"Must pass explicit sheet_name or set cur_sheet property\")\n return sheet_name\n\n def _value_with_fmt(self, val):\n \"\"\"\n Convert numpy types to Python types for the Excel writers.\n\n Parameters\n ----------\n val : object\n Value to be written into cells\n\n Returns\n -------\n Tuple with the first element being the converted value and the second\n being an optional format\n \"\"\"\n fmt = None\n\n if is_integer(val):\n val = int(val)\n elif is_float(val):\n val = float(val)\n elif is_bool(val):\n val = bool(val)\n elif isinstance(val, datetime.datetime):\n fmt = self.datetime_format\n elif isinstance(val, datetime.date):\n fmt = self.date_format\n elif isinstance(val, datetime.timedelta):\n val = val.total_seconds() / 86400\n fmt = \"0\"\n else:\n val = str(val)\n\n return val, fmt\n\n @classmethod\n def check_extension(cls, ext: str):\n \"\"\"\n checks that path's extension against the Writer's supported\n extensions. If it isn't supported, raises UnsupportedFiletypeError.\n \"\"\"\n if ext.startswith(\".\"):\n ext = ext[1:]\n # error: \"Callable[[ExcelWriter], Any]\" has no attribute \"__iter__\" (not\n # iterable)\n if not any(\n ext in extension\n for extension in cls.supported_extensions # type: ignore[attr-defined]\n ):\n raise ValueError(f\"Invalid extension for engine '{cls.engine}': '{ext}'\")\n else:\n return True\n\n # Allow use as a contextmanager\n def __enter__(self):\n return self\n\n def __exit__(self, exc_type, exc_value, traceback):\n self.close()\n\n def close(self):\n \"\"\"synonym for save, to make it more file-like\"\"\"\n content = self.save()\n self.handles.close()\n return content\n\n\nXLS_SIGNATURES = (\n b\"\\x09\\x00\\x04\\x00\\x07\\x00\\x10\\x00\", # BIFF2\n b\"\\x09\\x02\\x06\\x00\\x00\\x00\\x10\\x00\", # BIFF3\n b\"\\x09\\x04\\x06\\x00\\x00\\x00\\x10\\x00\", # BIFF4\n b\"\\xD0\\xCF\\x11\\xE0\\xA1\\xB1\\x1A\\xE1\", # Compound File Binary\n)\nZIP_SIGNATURE = b\"PK\\x03\\x04\"\nPEEK_SIZE = max(map(len, XLS_SIGNATURES + (ZIP_SIGNATURE,)))\n\n\n@doc(storage_options=_shared_docs[\"storage_options\"])\ndef inspect_excel_format(\n content_or_path: FilePathOrBuffer,\n storage_options: StorageOptions = None,\n) -> str | None:\n \"\"\"\n Inspect the path or content of an excel file and get its format.\n\n Adopted from xlrd: https://github.com/python-excel/xlrd.\n\n Parameters\n ----------\n content_or_path : str or file-like object\n Path to file or content of file to inspect. May be a URL.\n {storage_options}\n\n Returns\n -------\n str or None\n Format of file if it can be determined.\n\n Raises\n ------\n ValueError\n If resulting stream is empty.\n BadZipFile\n If resulting stream does not have an XLS signature and is not a valid zipfile.\n \"\"\"\n if isinstance(content_or_path, bytes):\n content_or_path = BytesIO(content_or_path)\n\n with get_handle(\n content_or_path, \"rb\", storage_options=storage_options, is_text=False\n ) as handle:\n stream = handle.handle\n stream.seek(0)\n buf = stream.read(PEEK_SIZE)\n if buf is None:\n raise ValueError(\"stream is empty\")\n else:\n assert isinstance(buf, bytes)\n peek = buf\n stream.seek(0)\n\n if any(peek.startswith(sig) for sig in XLS_SIGNATURES):\n return \"xls\"\n elif not peek.startswith(ZIP_SIGNATURE):\n return None\n\n # ZipFile typing is overly-strict\n # https://github.com/python/typeshed/issues/4212\n zf = zipfile.ZipFile(stream) # type: ignore[arg-type]\n\n # Workaround for some third party files that use forward slashes and\n # lower case names.\n component_names = [name.replace(\"\\\\\", \"/\").lower() for name in zf.namelist()]\n\n if \"xl/workbook.xml\" in component_names:\n return \"xlsx\"\n if \"xl/workbook.bin\" in component_names:\n return \"xlsb\"\n if \"content.xml\" in component_names:\n return \"ods\"\n return \"zip\"\n\n\nclass ExcelFile:\n \"\"\"\n Class for parsing tabular excel sheets into DataFrame objects.\n\n See read_excel for more documentation.\n\n Parameters\n ----------\n path_or_buffer : str, path object (pathlib.Path or py._path.local.LocalPath),\n a file-like object, xlrd workbook or openpyxl workbook.\n If a string or path object, expected to be a path to a\n .xls, .xlsx, .xlsb, .xlsm, .odf, .ods, or .odt file.\n engine : str, default None\n If io is not a buffer or path, this must be set to identify io.\n Supported engines: ``xlrd``, ``openpyxl``, ``odf``, ``pyxlsb``\n Engine compatibility :\n\n - ``xlrd`` supports old-style Excel files (.xls).\n - ``openpyxl`` supports newer Excel file formats.\n - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).\n - ``pyxlsb`` supports Binary Excel files.\n\n .. versionchanged:: 1.2.0\n\n The engine `xlrd <https://xlrd.readthedocs.io/en/latest/>`_\n now only supports old-style ``.xls`` files.\n When ``engine=None``, the following logic will be\n used to determine the engine:\n\n - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),\n then `odf <https://pypi.org/project/odfpy/>`_ will be used.\n - Otherwise if ``path_or_buffer`` is an xls format,\n ``xlrd`` will be used.\n - Otherwise if ``path_or_buffer`` is in xlsb format,\n `pyxlsb <https://pypi.org/project/pyxlsb/>`_ will be used.\n\n .. versionadded:: 1.3.0\n - Otherwise if `openpyxl <https://pypi.org/project/openpyxl/>`_ is installed,\n then ``openpyxl`` will be used.\n - Otherwise if ``xlrd >= 2.0`` is installed, a ``ValueError`` will be raised.\n - Otherwise ``xlrd`` will be used and a ``FutureWarning`` will be raised.\n This case will raise a ``ValueError`` in a future version of pandas.\n\n .. warning::\n\n Please do not report issues when using ``xlrd`` to read ``.xlsx`` files.\n This is not supported, switch to using ``openpyxl`` instead.\n \"\"\"\n\n from pandas.io.excel._odfreader import ODFReader\n from pandas.io.excel._openpyxl import OpenpyxlReader\n from pandas.io.excel._pyxlsb import PyxlsbReader\n from pandas.io.excel._xlrd import XlrdReader\n\n _engines: Mapping[str, Any] = {\n \"xlrd\": XlrdReader,\n \"openpyxl\": OpenpyxlReader,\n \"odf\": ODFReader,\n \"pyxlsb\": PyxlsbReader,\n }\n\n def __init__(\n self, path_or_buffer, engine=None, storage_options: StorageOptions = None\n ):\n if engine is not None and engine not in self._engines:\n raise ValueError(f\"Unknown engine: {engine}\")\n\n # Could be a str, ExcelFile, Book, etc.\n self.io = path_or_buffer\n # Always a string\n self._io = stringify_path(path_or_buffer)\n\n # Determine xlrd version if installed\n if import_optional_dependency(\"xlrd\", errors=\"ignore\") is None:\n xlrd_version = None\n else:\n import xlrd\n\n xlrd_version = Version(get_version(xlrd))\n\n ext = None\n if engine is None:\n # Only determine ext if it is needed\n if xlrd_version is not None and isinstance(path_or_buffer, xlrd.Book):\n ext = \"xls\"\n else:\n ext = inspect_excel_format(\n content_or_path=path_or_buffer, storage_options=storage_options\n )\n if ext is None:\n raise ValueError(\n \"Excel file format cannot be determined, you must specify \"\n \"an engine manually.\"\n )\n\n engine = config.get_option(f\"io.excel.{ext}.reader\", silent=True)\n if engine == \"auto\":\n engine = get_default_engine(ext, mode=\"reader\")\n\n if engine == \"xlrd\" and xlrd_version is not None:\n if ext is None:\n # Need ext to determine ext in order to raise/warn\n if isinstance(path_or_buffer, xlrd.Book):\n ext = \"xls\"\n else:\n ext = inspect_excel_format(\n path_or_buffer, storage_options=storage_options\n )\n\n # Pass through if ext is None, otherwise check if ext valid for xlrd\n if ext and ext != \"xls\" and xlrd_version >= Version(\"2\"):\n raise ValueError(\n f\"Your version of xlrd is {xlrd_version}. In xlrd >= 2.0, \"\n f\"only the xls format is supported. Install openpyxl instead.\"\n )\n elif ext and ext != \"xls\":\n stacklevel = find_stack_level()\n warnings.warn(\n f\"Your version of xlrd is {xlrd_version}. In xlrd >= 2.0, \"\n f\"only the xls format is supported. Install \"\n f\"openpyxl instead.\",\n FutureWarning,\n stacklevel=stacklevel,\n )\n\n self.engine = engine\n self.storage_options = storage_options\n\n self._reader = self._engines[engine](self._io, storage_options=storage_options)\n\n def __fspath__(self):\n return self._io\n\n def parse(\n self,\n sheet_name=0,\n header=0,\n names=None,\n index_col=None,\n usecols=None,\n squeeze=False,\n converters=None,\n true_values=None,\n false_values=None,\n skiprows=None,\n nrows=None,\n na_values=None,\n parse_dates=False,\n date_parser=None,\n thousands=None,\n comment=None,\n skipfooter=0,\n convert_float=None,\n mangle_dupe_cols=True,\n **kwds,\n ):\n \"\"\"\n Parse specified sheet(s) into a DataFrame.\n\n Equivalent to read_excel(ExcelFile, ...) See the read_excel\n docstring for more info on accepted parameters.\n\n Returns\n -------\n DataFrame or dict of DataFrames\n DataFrame from the passed in Excel file.\n \"\"\"\n return self._reader.parse(\n sheet_name=sheet_name,\n header=header,\n names=names,\n index_col=index_col,\n usecols=usecols,\n squeeze=squeeze,\n converters=converters,\n true_values=true_values,\n false_values=false_values,\n skiprows=skiprows,\n nrows=nrows,\n na_values=na_values,\n parse_dates=parse_dates,\n date_parser=date_parser,\n thousands=thousands,\n comment=comment,\n skipfooter=skipfooter,\n convert_float=convert_float,\n mangle_dupe_cols=mangle_dupe_cols,\n **kwds,\n )\n\n @property\n def book(self):\n return self._reader.book\n\n @property\n def sheet_names(self):\n return self._reader.sheet_names\n\n def close(self):\n \"\"\"close io if necessary\"\"\"\n self._reader.close()\n\n def __enter__(self):\n return self\n\n def __exit__(self, exc_type, exc_value, traceback):\n self.close()\n\n def __del__(self):\n # Ensure we don't leak file descriptors, but put in try/except in case\n # attributes are already deleted\n try:\n self.close()\n except AttributeError:\n pass\n"
] | [
[
"pandas.io.common.IOHandles",
"pandas.io.excel._util.fill_mi_header",
"pandas.io.excel._util.maybe_convert_usecols",
"pandas.io.parsers.TextParser",
"pandas.util._decorators.deprecate_nonkeyword_arguments",
"pandas.core.frame.DataFrame",
"pandas.io.common.get_handle",
"pandas.compat._optional.import_optional_dependency",
"pandas.util.version.Version",
"pandas.core.dtypes.common.is_float",
"pandas.core.dtypes.common.is_list_like",
"pandas.util._decorators.Appender",
"pandas.io.common.stringify_path",
"pandas.compat._optional.get_version",
"pandas.core.dtypes.common.is_bool",
"pandas._config.config.get_option",
"pandas.util._exceptions.find_stack_level",
"pandas.io.excel._util.pop_header_name",
"pandas.io.common.validate_header_arg",
"pandas.core.dtypes.common.is_integer",
"pandas.io.excel._util.get_default_engine",
"pandas.io.excel._util.get_writer",
"pandas.util._decorators.doc"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
aj-tap/traffic-bot-counter | [
"2ef3ddcf3b3caca87d728e8b4ed6b8e7e6ffa161"
] | [
"gui/pages/result.py"
] | [
"\"\"\"\nThis page is similar to Menu class, but here we\nwill render the results and summon the graph.\n\nself = where the widgets will be rendered.\n\napp = to access app-bot and change bot properties and methods\nfor threshold, confidence, paths, intersection line.\n\nmain_container = where the menu will be rendered.\nA frame object needs a Tk object or another frame\nto render into in this case we will render into\nthe main_container.\n\nnext_page = result page.\n\"\"\"\n\nfrom tkinter.ttk import Label, Button\nfrom tkinter import Frame, Tk\n\nfrom matplotlib.figure import Figure\nfrom matplotlib.backends.backend_tkagg import (FigureCanvasTkAgg, NavigationToolbar2Tk)\n\n\nclass Result(Frame):\n def __init__(self, app, main_container, previous_page):\n super().__init__(main_container)\n\n Button(self, text=\"Plot\", command=lambda: plot()).pack()\n\n Button(self, text=\"Back\",\n command=lambda: app.show_frame(previous_page)).pack()\n\n Label(self, text=\"By: Aldwin Tapican and Marjolo Mabuti\").pack()\n\n self.grid(row=0, column=0, sticky='nsew')\n\n # TEMPORARY\n def plot():\n window = Tk()\n window.title('Result')\n window.wm_iconbitmap('../assets/traffic.ico')\n window.geometry(\"500x500\")\n # the figure that will contain the plot\n fig = Figure(figsize=(5, 5),\n dpi=100)\n # list of squares\n y = [i ** 2 for i in range(101)]\n # adding the subplot\n plot1 = fig.add_subplot(111)\n # plotting the graph\n plot1.plot(y)\n # creating the Tkinter canvas\n # containing the Matplotlib figure\n canvas = FigureCanvasTkAgg(fig,\n master=window)\n canvas.draw()\n # placing the canvas on the Tkinter window\n canvas.get_tk_widget().pack()\n # creating the Matplotlib toolbar\n toolbar = NavigationToolbar2Tk(canvas,\n window)\n toolbar.update()\n # placing the toolbar on the Tkinter window\n canvas.get_tk_widget().pack()\n"
] | [
[
"matplotlib.backends.backend_tkagg.NavigationToolbar2Tk",
"matplotlib.backends.backend_tkagg.FigureCanvasTkAgg",
"matplotlib.figure.Figure"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
dangom/rapidtide | [
"ab92bbb612623f8499a16e1e85cea643766f3af8"
] | [
"rapidtide/tests/test_findmaxlag.py"
] | [
"#!/usr/bin/env python\n\n\nimport os.path as op\n\nimport numpy as np\nimport pylab as plt\nfrom scipy import arange\n\nimport rapidtide.io as tide_io\nimport rapidtide.fit as tide_fit\nfrom rapidtide.tests.utils import get_test_data_path\n\n\ndef test_findmaxlag(display=False, debug=False):\n textfilename = op.join(get_test_data_path(), \"lt_rt.txt\")\n display = False\n debug = False\n\n # set default variable values\n searchfrac = 0.75\n limitfit = False\n\n indata = tide_io.readvecs(textfilename)\n xvecs = indata[0, :]\n yvecs = indata[1, :]\n testmaxval = 0.8\n testmaxlag = 8.0\n testmaxsigma = 5.0\n yvecs = tide_fit.gauss_eval(xvecs, np.array([testmaxval, testmaxlag, testmaxsigma]))\n lagmin = -20\n lagmax = 20\n widthlimit = 1000.0\n absmaxsigma = 1000.0\n\n (\n maxindex,\n maxlag,\n maxval,\n maxsigma,\n maskval,\n failreason,\n peakstart,\n peakend,\n ) = tide_fit.findmaxlag_gauss(\n xvecs,\n yvecs,\n lagmin,\n lagmax,\n widthlimit,\n tweaklims=False,\n refine=True,\n debug=debug,\n searchfrac=searchfrac,\n zerooutbadfit=False,\n )\n\n (\n maxindexr,\n maxlagr,\n maxvalr,\n maxsigmar,\n maskvalr,\n failreasonr,\n peakstartr,\n peakendr,\n ) = tide_fit.findmaxlag_gauss_rev(\n xvecs,\n yvecs,\n lagmin,\n lagmax,\n widthlimit,\n absmaxsigma=absmaxsigma,\n tweaklims=False,\n refine=True,\n debug=debug,\n searchfrac=searchfrac,\n zerooutbadfit=False,\n )\n\n print(\n \"final results:\",\n maxindex,\n maxlag,\n maxval,\n maxsigma,\n maskval,\n failreason,\n peakstart,\n peakend,\n )\n print(\n \"final results:\",\n maxindexr,\n maxlagr,\n maxvalr,\n maxsigmar,\n maskvalr,\n failreasonr,\n peakstartr,\n peakendr,\n )\n oversampfactor = 10\n gauss_xvecs = arange(\n xvecs[0], xvecs[-1], (xvecs[1] - xvecs[0]) / oversampfactor, dtype=\"float\"\n )\n gauss_yvecs = tide_fit.gauss_eval(gauss_xvecs, (maxval, maxlag, maxsigma))\n gauss_yvecsr = tide_fit.gauss_eval(gauss_xvecs, (maxvalr, maxlagr, maxsigmar))\n if display:\n fig = plt.figure()\n ax = fig.add_subplot(1, 1, 1)\n ax.plot(xvecs, yvecs, \"r\")\n ax.plot(\n gauss_xvecs[(peakstart * oversampfactor) : (peakend * oversampfactor + 1)],\n 0.1\n + gauss_yvecs[\n (peakstart * oversampfactor) : (peakend * oversampfactor + 1)\n ],\n \"g.\",\n )\n ax.plot(\n gauss_xvecs[\n (peakstartr * oversampfactor) : (peakendr * oversampfactor + 1)\n ],\n 0.2\n + gauss_yvecsr[\n (peakstartr * oversampfactor) : (peakendr * oversampfactor + 1)\n ],\n \"b.\",\n )\n # ax.set_xlim((lagmin, lagmax))\n plt.show()\n\n\ndef main():\n test_findmaxlag(display=True, debug=True)\n\n\nif __name__ == \"__main__\":\n main()\n"
] | [
[
"numpy.array",
"scipy.arange"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
bregirl3/Post-Your-Work-On-Github-Project | [
"daf6e3e76aca42dab0ced59f36b0592cc1dd19a8"
] | [
"bikeshare.py"
] | [
"import time\nimport pandas as pd\nimport numpy as np\n\nCITY_DATA = { 'chicago': 'chicago.csv',\n 'new york city': 'new_york_city.csv',\n 'washington': 'washington.csv' }\n\ndef get_filters():\n \"\"\"\n Asks user to specify a city, month, and day to analyze.\n Returns:\n (str) city - name of the city to analyze\n (str) month - name of the month to filter by, or \"all\" to apply no month filter\n (str) day - name of the day of week to filter by, or \"all\" to apply no day filter\n \"\"\"\n print('Hello! Let\\'s explore some US bikeshare data!')\n # get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\n while True:\n city = input(\"Which city would you like to explore ?\")\n city = city.lower()\n if city in ['chicago', 'new york city', 'washington']:\n break\n else:\n print(\"invalid input. Please enter a valid input\")\n # get user input for month (all, january, february, ... , june)\n while True: \n month = input(\"Do you want details specific to a particular month? If yes, type month name from within first six months else type 'all'\")\n month = month.lower()\n if month in ['january', 'february', 'march', 'april', 'may', 'june', 'all']:\n break\n else:\n print(\"invalid input. Please enter a valid input\")\n # get user input for day of week (all, monday, tuesday, ... sunday)\n while True:\n day = input(\"Do you want details specific to a particular day? If yes, type day name else type 'all'\")\n day = day.lower()\n if day in ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday', 'all']:\n break\n else:\n print(\"invalid input. Please enter a valid input\")\n print('-'*40)\n return city, month, day\n\n\ndef load_data(city, month, day):\n \"\"\"\n Loads data for the specified city and filters by month and day if applicable.\n Args:\n (str) city - name of the city to analyze\n (str) month - name of the month to filter by, or \"all\" to apply no month filter\n (str) day - name of the day of week to filter by, or \"all\" to apply no day filter\n Returns:\n df - Pandas DataFrame containing city data filtered by month and day\n \"\"\"\n # load data file into a dataframe\n df = pd.read_csv(CITY_DATA[city])\n \n # convert the Start Time column to datetime\n df['Start Time'] = pd.to_datetime(df['Start Time'])\n\n # extract month and day of week from Start Time to create new columns\n df['month'] = df['Start Time'].dt.month\n df['day_of_week'] = df['Start Time'].dt.weekday_name\n\n\n # filter by month if applicable\n if month != 'all':\n # use the index of the months list to get the corresponding int\n months = ['january', 'february', 'march', 'april', 'may', 'june']\n month = months.index(month) + 1\n \n # filter by month to create the new dataframe\n df = df[df['month'] == month]\n\n # filter by day of week if applicable\n if day != 'all':\n # filter by day of week to create the new dataframe\n \n df = df[df['day_of_week'] == day.title()]\n\n return df\n\n\ndef time_stats(df):\n \"\"\"Displays statistics on the most frequent times of travel.\"\"\"\n\n print('\\nCalculating The Most Frequent Times of Travel...\\n')\n start_time = time.time()\n\n # display the most common month\n print(\"The most common month is \", df['month'].mode()[0], \"\\n\")\n\n # display the most common day of week\n print(\"The most common day of week is \", df['day_of_week'].mode()[0], \"\\n\")\n\n # display the most common start hour\n df['hour'] = df['Start Time'].dt.hour\n print(\"The most common start hour is \", df['hour'].mode()[0])\n\n print(\"\\nThis took %s seconds.\" % (time.time() - start_time))\n print('-'*40)\n\n\ndef station_stats(df):\n \"\"\"Displays statistics on the most popular stations and trip.\"\"\"\n\n print('\\nCalculating The Most Popular Stations and Trip...\\n')\n start_time = time.time()\n\n # display most commonly used start station\n print(\"The most commonly used start station is \", df['Start Station'].mode()[0], \"\\n\")\n\n # display most commonly used end station\n print(\"The most commonly used end station is \", df['End Station'].mode()[0], \"\\n\")\n\n # display most frequent combination of start station and end station trip\n df['combination'] = df['Start Station'] + \" \" + df['End Station']\n print(\"The most frequent combination of start station and end station trip is: \", df['combination'].mode()[0])\n\n print(\"\\nThis took %s seconds.\" % (time.time() - start_time))\n print('-'*40)\n\n\ndef trip_duration_stats(df):\n \"\"\"Displays statistics on the total and average trip duration.\"\"\"\n\n print('\\nCalculating Trip Duration...\\n')\n start_time = time.time()\n\n # display total travel time\n print(\"The total travel time is\", df['Trip Duration'].sum(), \"\\n\")\n\n # display mean travel time\n print(\"The total mean time is\", df['Trip Duration'].mean())\n\n print(\"\\nThis took %s seconds.\" % (time.time() - start_time))\n print('-'*40)\n\n\ndef user_stats(df, city):\n \"\"\"Displays statistics on bikeshare users.\"\"\"\n\n print('\\nCalculating User Stats...\\n')\n start_time = time.time()\n\n # Display counts of user types\n user_types = df.groupby(['User Type'])['User Type'].count()\n print(user_types, \"\\n\")\n if city != 'washington':\n # Display counts of gender\n gen = df.groupby(['Gender'])['Gender'].count()\n print(gen)\n # Display earliest, most recent, and most common year of birth\n mryob = sorted(df.groupby(['Birth Year'])['Birth Year'], reverse=True)[0][0]\n eyob = sorted(df.groupby(['Birth Year'])['Birth Year'])[0][0]\n mcyob = df['Birth Year'].mode()[0]\n print(\"The earliest year of birth is \", eyob, \"\\n\")\n print(\"The most recent year of birth is \", mryob, \"\\n\")\n print(\"The most common year of birth is \", mcyob, \"\\n\")\n\n print(\"\\nThis took %s seconds.\" % (time.time() - start_time))\n print('-'*40)\n x = 1\n while True:\n raw = input('\\nWould you like to see some raw data? Enter yes or no.\\n')\n if raw.lower() == 'yes':\n print(df[x:x+5])\n x = x+5\n else:\n break\n\ndef main():\n while True:\n city, month, day = get_filters()\n df = load_data(city, month, day)\n\n time_stats(df)\n station_stats(df)\n trip_duration_stats(df)\n user_stats(df, city)\n\n restart = input('\\nWould you like to restart? Enter yes or no.\\n')\n if restart.lower() != 'yes':\n break\n\n\nif __name__ == \"__main__\":\n\tmain()\n"
] | [
[
"pandas.read_csv",
"pandas.to_datetime"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
Tiamat-Tech/ddsp | [
"cd57829b9caa8643d37994caf6e1ee0a7fc11ad8",
"cd57829b9caa8643d37994caf6e1ee0a7fc11ad8"
] | [
"ddsp/training/data_preparation/ddsp_prepare_tfrecord.py",
"ddsp/training/ddsp_run.py"
] | [
"# Copyright 2021 The DDSP Authors.\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# Lint as: python3\nr\"\"\"Create a TFRecord dataset from audio files.\n\nUsage:\n====================\nddsp_prepare_tfrecord \\\n--input_audio_filepatterns=/path/to/wavs/*wav,/path/to/mp3s/*mp3 \\\n--output_tfrecord_path=/path/to/output.tfrecord \\\n--num_shards=10 \\\n--alsologtostderr\n\n\"\"\"\n\nfrom absl import app\nfrom absl import flags\nfrom ddsp.training.data_preparation.prepare_tfrecord_lib import prepare_tfrecord\nimport tensorflow.compat.v2 as tf\n\nFLAGS = flags.FLAGS\n\nflags.DEFINE_list('input_audio_filepatterns', [],\n 'List of filepatterns to glob for input audio files.')\nflags.DEFINE_string(\n 'output_tfrecord_path', None,\n 'The prefix path to the output TFRecord. Shard numbers will be added to '\n 'actual path(s).')\nflags.DEFINE_integer(\n 'num_shards', None,\n 'The number of shards to use for the TFRecord. If None, this number will '\n 'be determined automatically.')\nflags.DEFINE_integer('sample_rate', 16000,\n 'The sample rate to use for the audio.')\nflags.DEFINE_integer(\n 'frame_rate', 250,\n 'The frame rate to use for f0 and loudness features. If set to 0, '\n 'these features will not be computed.')\nflags.DEFINE_float(\n 'example_secs', 4,\n 'The length of each example in seconds. Input audio will be split to this '\n 'length using a sliding window. If 0, each full piece of audio will be '\n 'used as an example.')\nflags.DEFINE_float(\n 'sliding_window_hop_secs', 1,\n 'The hop size in seconds to use when splitting audio into constant-length '\n 'examples.')\nflags.DEFINE_float(\n 'eval_split_fraction', 0.0,\n 'Fraction of the dataset to reserve for eval split. If set to 0, no eval '\n 'split is created.'\n)\nflags.DEFINE_float(\n 'coarse_chunk_secs', 20.0,\n 'Chunk size in seconds used to split the input audio files.')\nflags.DEFINE_list(\n 'pipeline_options', '--runner=DirectRunner',\n 'A comma-separated list of command line arguments to be used as options '\n 'for the Beam Pipeline.')\n\n\ndef run():\n input_audio_paths = []\n for filepattern in FLAGS.input_audio_filepatterns:\n input_audio_paths.extend(tf.io.gfile.glob(filepattern))\n\n prepare_tfrecord(\n input_audio_paths,\n FLAGS.output_tfrecord_path,\n num_shards=FLAGS.num_shards,\n sample_rate=FLAGS.sample_rate,\n frame_rate=FLAGS.frame_rate,\n window_secs=FLAGS.example_secs,\n hop_secs=FLAGS.sliding_window_hop_secs,\n eval_split_fraction=FLAGS.eval_split_fraction,\n coarse_chunk_secs=FLAGS.coarse_chunk_secs,\n pipeline_options=FLAGS.pipeline_options)\n\n\ndef main(unused_argv):\n \"\"\"From command line.\"\"\"\n run()\n\n\ndef console_entry_point():\n \"\"\"From pip installed script.\"\"\"\n app.run(main)\n\n\nif __name__ == '__main__':\n console_entry_point()\n",
"# Copyright 2021 The DDSP Authors.\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# Lint as: python3\nr\"\"\"Train, evaluate, or sample (from) a ddsp model.\n\nUsage:\n================================================================================\nFor training, you need to specify --gin_file for both the model and the dataset.\nYou can optionally specify additional params with --gin_param.\nThe pip install installs a `ddsp_run` script that can be called directly.\n================================================================================\nddsp_run \\\n--mode=train \\\n--alsologtostderr \\\n--save_dir=/tmp/$USER-ddsp-0 \\\n--gin_file=models/ae.gin \\\n--gin_file=datasets/nsynth.gin \\\n--gin_param=batch_size=16\n\n\n================================================================================\nFor evaluation and sampling, only the dataset file is required.\n================================================================================\nddsp_run \\\n--mode=eval \\\n--alsologtostderr \\\n--save_dir=/tmp/$USER-ddsp-0 \\\n--gin_file=datasets/nsynth.gin\n\nddsp_run \\\n--mode=sample \\\n--alsologtostderr \\\n--save_dir=/tmp/$USER-ddsp-0 \\\n--gin_file=datasets/nsynth.gin\n\n\n================================================================================\nThe directory `gin/papers/` stores configs that give the specific models and\ndatasets used for a paper's experiments, so only require one gin file to train.\n================================================================================\nddsp_run \\\n--mode=train \\\n--alsologtostderr \\\n--save_dir=/tmp/$USER-ddsp-0 \\\n--gin_file=papers/iclr2020/nsynth_ae.gin\n\n\n\"\"\"\n\nimport os\nimport time\n\nfrom absl import app\nfrom absl import flags\nfrom absl import logging\nfrom ddsp.training import cloud\nfrom ddsp.training import eval_util\nfrom ddsp.training import models\nfrom ddsp.training import train_util\nfrom ddsp.training import trainers\nimport gin\nimport pkg_resources\nimport tensorflow.compat.v2 as tf\n\ngfile = tf.io.gfile\nFLAGS = flags.FLAGS\n\n# Program flags.\nflags.DEFINE_enum('mode', 'train', ['train', 'eval', 'sample'],\n 'Whether to train, evaluate, or sample from the model.')\nflags.DEFINE_string('save_dir', '/tmp/ddsp',\n 'Path where checkpoints and summary events will be saved '\n 'during training and evaluation.')\nflags.DEFINE_string('restore_dir', '',\n 'Path from which checkpoints will be restored before '\n 'training. Can be different than the save_dir.')\nflags.DEFINE_string('tpu', '', 'Address of the TPU. No TPU if left blank.')\nflags.DEFINE_string('cluster_config', '',\n 'Worker-specific JSON string for multiworker setup. '\n 'For more information see train_util.get_strategy().')\nflags.DEFINE_boolean('allow_memory_growth', False,\n 'Whether to grow the GPU memory usage as is needed by the '\n 'process. Prevents crashes on GPUs with smaller memory.')\nflags.DEFINE_boolean('hypertune', False,\n 'Enable metric reporting for hyperparameter tuning, such '\n 'as on Google Cloud AI-Platform.')\nflags.DEFINE_float('early_stop_loss_value', None,\n 'Stops training early when the `total_loss` reaches below '\n 'this value during training.')\n\n# Gin config flags.\nflags.DEFINE_multi_string('gin_search_path', [],\n 'Additional gin file search paths.')\nflags.DEFINE_multi_string('gin_file', [],\n 'List of paths to the config files. If file '\n 'in gstorage bucket specify whole gstorage path: '\n 'gs://bucket-name/dir/in/bucket/file.gin.')\nflags.DEFINE_multi_string('gin_param', [],\n 'Newline separated list of Gin parameter bindings.')\n\n# Evaluation/sampling specific flags.\nflags.DEFINE_boolean('run_once', False, 'Whether evaluation will run once.')\nflags.DEFINE_integer('initial_delay_secs', None,\n 'Time to wait before evaluation starts')\n\nGIN_PATH = pkg_resources.resource_filename(__name__, 'gin')\n\n\ndef delay_start():\n \"\"\"Optionally delay the start of the run.\"\"\"\n delay_time = FLAGS.initial_delay_secs\n if delay_time:\n logging.info('Waiting for %i second(s)', delay_time)\n time.sleep(delay_time)\n\n\ndef parse_gin(restore_dir):\n \"\"\"Parse gin config from --gin_file, --gin_param, and the model directory.\"\"\"\n # Enable parsing gin files on Google Cloud.\n gin.config.register_file_reader(tf.io.gfile.GFile, tf.io.gfile.exists)\n # Add user folders to the gin search path.\n for gin_search_path in [GIN_PATH] + FLAGS.gin_search_path:\n gin.add_config_file_search_path(gin_search_path)\n\n # Parse gin configs, later calls override earlier ones.\n with gin.unlock_config():\n # Optimization defaults.\n use_tpu = bool(FLAGS.tpu)\n opt_default = 'base.gin' if not use_tpu else 'base_tpu.gin'\n gin.parse_config_file(os.path.join('optimization', opt_default))\n eval_default = 'eval/basic.gin'\n gin.parse_config_file(eval_default)\n\n # Load operative_config if it exists (model has already trained).\n try:\n operative_config = train_util.get_latest_operative_config(restore_dir)\n logging.info('Using operative config: %s', operative_config)\n operative_config = cloud.make_file_paths_local(operative_config, GIN_PATH)\n gin.parse_config_file(operative_config, skip_unknown=True)\n except FileNotFoundError:\n logging.info('Operative config not found in %s', restore_dir)\n\n # User gin config and user hyperparameters from flags.\n gin_file = cloud.make_file_paths_local(FLAGS.gin_file, GIN_PATH)\n gin.parse_config_files_and_bindings(\n gin_file, FLAGS.gin_param, skip_unknown=True)\n\n\ndef allow_memory_growth():\n \"\"\"Sets the GPUs to grow the memory usage as is needed by the process.\"\"\"\n gpus = tf.config.experimental.list_physical_devices('GPU')\n if gpus:\n try:\n # Currently, memory growth needs to be the same across GPUs.\n for gpu in gpus:\n tf.config.experimental.set_memory_growth(gpu, True)\n except RuntimeError as e:\n # Memory growth must be set before GPUs have been initialized.\n print(e)\n\n\ndef main(unused_argv):\n \"\"\"Parse gin config and run ddsp training, evaluation, or sampling.\"\"\"\n restore_dir = os.path.expanduser(FLAGS.restore_dir)\n save_dir = os.path.expanduser(FLAGS.save_dir)\n # If no separate restore directory is given, use the save directory.\n restore_dir = save_dir if not restore_dir else restore_dir\n logging.info('Restore Dir: %s', restore_dir)\n logging.info('Save Dir: %s', save_dir)\n\n gfile.makedirs(restore_dir) # Only makes dirs if they don't exist.\n parse_gin(restore_dir)\n logging.info('Operative Gin Config:\\n%s', gin.config.config_str())\n train_util.gin_register_keras_layers()\n\n if FLAGS.allow_memory_growth:\n allow_memory_growth()\n\n # Training.\n if FLAGS.mode == 'train':\n strategy = train_util.get_strategy(tpu=FLAGS.tpu,\n cluster_config=FLAGS.cluster_config)\n with strategy.scope():\n model = models.get_model()\n trainer = trainers.get_trainer_class()(model, strategy)\n\n train_util.train(data_provider=gin.REQUIRED,\n trainer=trainer,\n save_dir=save_dir,\n restore_dir=restore_dir,\n early_stop_loss_value=FLAGS.early_stop_loss_value,\n report_loss_to_hypertune=FLAGS.hypertune)\n\n # Evaluation.\n elif FLAGS.mode == 'eval':\n model = models.get_model()\n delay_start()\n eval_util.evaluate(data_provider=gin.REQUIRED,\n model=model,\n save_dir=save_dir,\n restore_dir=restore_dir,\n run_once=FLAGS.run_once)\n\n # Sampling.\n elif FLAGS.mode == 'sample':\n model = models.get_model()\n delay_start()\n eval_util.sample(data_provider=gin.REQUIRED,\n model=model,\n save_dir=save_dir,\n restore_dir=restore_dir,\n run_once=FLAGS.run_once)\n\n\ndef console_entry_point():\n \"\"\"From pip installed script.\"\"\"\n app.run(main)\n\n\nif __name__ == '__main__':\n console_entry_point()\n"
] | [
[
"tensorflow.compat.v2.io.gfile.glob"
],
[
"tensorflow.compat.v2.config.experimental.list_physical_devices",
"tensorflow.compat.v2.config.experimental.set_memory_growth"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
akihironitta/pyro | [
"0ab6e474330942ff4ec2a87a6cc0c671943fc5cd"
] | [
"examples/scanvi/data.py"
] | [
"# Copyright Contributors to the Pyro project.\n# Copyright (c) 2020, YosefLab.\n# SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause\n\n\"\"\"\nThe data preprocessing code in this script is adapted from:\nhttps://github.com/YosefLab/scvi-tutorials/blob/50dd3269abfe0c375ec47114f2c20725a016736f/seed_labeling.ipynb\n\"\"\"\n\nimport math\nimport numpy as np\nfrom scipy import sparse\n\nimport torch\nimport torch.nn as nn\n\n\nclass BatchDataLoader(object):\n \"\"\"\n This custom DataLoader serves mini-batches that are either fully-observed (i.e. labeled)\n or partially-observed (i.e. unlabeled) but never mixed.\n \"\"\"\n def __init__(self, data_x, data_y, batch_size, num_classes=4, missing_label=-1):\n super().__init__()\n self.data_x = data_x\n self.data_y = data_y\n self.batch_size = batch_size\n self.num_classes = num_classes\n\n self.unlabeled = torch.where(data_y == missing_label)[0]\n self.num_unlabeled = self.unlabeled.size(0)\n self.num_unlabeled_batches = math.ceil(self.num_unlabeled / self.batch_size)\n\n self.labeled = torch.where(data_y != missing_label)[0]\n self.num_labeled = self.labeled.size(0)\n self.num_labeled_batches = math.ceil(self.num_labeled / self.batch_size)\n\n assert self.data_x.size(0) == self.data_y.size(0)\n assert len(self) > 0\n\n @property\n def size(self):\n return self.data_x.size(0)\n\n def __len__(self):\n return self.num_unlabeled_batches + self.num_labeled_batches\n\n def _sample_batch_indices(self):\n batch_order = torch.randperm(len(self)).tolist()\n unlabeled_idx = self.unlabeled[torch.randperm(self.num_unlabeled)]\n labeled_idx = self.labeled[torch.randperm(self.num_labeled)]\n\n slices = []\n\n for i in range(self.num_unlabeled_batches):\n _slice = unlabeled_idx[i * self.batch_size: (i + 1) * self.batch_size]\n slices.append((_slice, False))\n\n for i in range(self.num_labeled_batches):\n _slice = labeled_idx[i * self.batch_size: (i + 1) * self.batch_size]\n slices.append((_slice, True))\n\n return slices, batch_order\n\n def __iter__(self):\n slices, batch_order = self._sample_batch_indices()\n\n for i in range(len(batch_order)):\n _slice = slices[batch_order[i]]\n if _slice[1]:\n # labeled\n yield self.data_x[_slice[0]], \\\n nn.functional.one_hot(self.data_y[_slice[0]], num_classes=self.num_classes)\n else:\n # unlabeled\n yield self.data_x[_slice[0]], None\n\n\ndef _get_score(normalized_adata, gene_set):\n \"\"\"\n Returns the score per cell given a dictionary of + and - genes\n \"\"\"\n score = np.zeros(normalized_adata.n_obs)\n for gene in gene_set['positive']:\n expression = np.array(normalized_adata[:, gene].X)\n score += expression.flatten()\n for gene in gene_set['negative']:\n expression = np.array(normalized_adata[:, gene].X)\n score -= expression.flatten()\n return score\n\n\ndef _get_cell_mask(normalized_adata, gene_set):\n \"\"\"\n Calculates the score per cell for a list of genes, then returns a mask for\n the cells with the highest 50 scores.\n \"\"\"\n score = _get_score(normalized_adata, gene_set)\n cell_idx = score.argsort()[-50:]\n mask = np.zeros(normalized_adata.n_obs)\n mask[cell_idx] = 1\n return mask.astype(bool)\n\n\ndef get_data(dataset=\"pbmc\", batch_size=100, cuda=False):\n \"\"\"\n Does the necessary preprocessing and returns a BatchDataLoader for the PBMC dataset.\n \"\"\"\n assert dataset in ['pbmc', 'mock']\n\n # create mock dataset for CI\n if dataset == 'mock':\n num_genes = 17\n num_data = 200\n X = torch.distributions.Poisson(rate=10.0).sample(sample_shape=(num_data, num_genes))\n Y = torch.zeros(num_data, dtype=torch.long)\n Y[50:100] = 1\n Y[100:] = -1\n\n if cuda:\n X, Y = X.cuda(), Y.cuda()\n\n return BatchDataLoader(X, Y, batch_size), num_genes, 2.0, 1.0, None\n\n import scvi\n import scanpy as sc\n adata = scvi.data.purified_pbmc_dataset(subset_datasets=[\"regulatory_t\", \"naive_t\",\n \"memory_t\", \"naive_cytotoxic\"])\n\n gene_subset = [\"CD4\", \"FOXP3\", \"TNFRSF18\", \"IL2RA\", \"CTLA4\", \"CD44\", \"TCF7\",\n \"CD8B\", \"CCR7\", \"CD69\", \"PTPRC\", \"S100A4\"]\n\n normalized = adata.copy()\n sc.pp.normalize_total(normalized, target_sum=1e4)\n sc.pp.log1p(normalized)\n\n normalized = normalized[:, gene_subset].copy()\n sc.pp.scale(normalized)\n\n # hand curated list of genes for identifying ground truth\n cd4_reg_geneset = {\"positive\": [\"TNFRSF18\", \"CTLA4\", \"FOXP3\", \"IL2RA\"], \"negative\": [\"S100A4\", \"PTPRC\", \"CD8B\"]}\n cd8_naive_geneset = {\"positive\": [\"CD8B\", \"CCR7\"], \"negative\": [\"CD4\"]}\n cd4_naive_geneset = {\"positive\": [\"CCR7\", \"CD4\"], \"negative\": [\"S100A4\", \"PTPRC\", \"FOXP3\", \"IL2RA\", \"CD69\"]}\n cd4_mem_geneset = {\"positive\": [\"S100A4\"], \"negative\": [\"IL2RA\", \"FOXP3\", \"TNFRSF18\", \"CCR7\"]}\n\n cd4_reg_mask = _get_cell_mask(normalized, cd4_reg_geneset)\n cd8_naive_mask = _get_cell_mask(normalized, cd8_naive_geneset)\n cd4_naive_mask = _get_cell_mask(normalized, cd4_naive_geneset)\n cd4_mem_mask = _get_cell_mask(normalized, cd4_mem_geneset)\n\n # these will be our seed labels\n seed_labels = -np.ones(cd4_mem_mask.shape[0])\n seed_labels[cd8_naive_mask] = 0 # \"CD8 Naive T cell\"\n seed_labels[cd4_naive_mask] = 1 # \"CD4 Naive T cell\"\n seed_labels[cd4_mem_mask] = 2 # \"CD4 Memory T cell\"\n seed_labels[cd4_reg_mask] = 3 # \"CD4 Regulatory T cell\"\n\n # this metadata will be used for plotting\n seed_colors = ['lightgray'] * seed_labels.shape[0]\n seed_sizes = [0.05] * seed_labels.shape[0]\n for i in range(len(seed_colors)):\n if seed_labels[i] == 0:\n seed_colors[i] = 'lightcoral'\n elif seed_labels[i] == 1:\n seed_colors[i] = 'limegreen'\n elif seed_labels[i] == 2:\n seed_colors[i] = 'deepskyblue'\n elif seed_labels[i] == 3:\n seed_colors[i] = 'mediumorchid'\n if seed_labels[i] != -1:\n seed_sizes[i] = 25\n\n adata.obs['seed_labels'] = seed_labels\n adata.obs['seed_colors'] = seed_colors\n adata.obs['seed_marker_sizes'] = seed_sizes\n\n # filter out non-variable genes\n adata_filter = adata.copy()\n sc.pp.normalize_per_cell(adata_filter, counts_per_cell_after=1e4)\n sc.pp.log1p(adata_filter)\n sc.pp.highly_variable_genes(adata_filter, min_mean=0.0125, max_mean=3.0, min_disp=0.5)\n highly_variable_genes = adata_filter.var[\"highly_variable\"]\n\n Y = torch.from_numpy(seed_labels).long()\n X = torch.from_numpy(sparse.csr_matrix.todense(adata.X)).float()\n\n # the prior mean and scale for the log count latent variable `l`\n # is set using the empirical mean and variance of the observed log counts\n log_counts = X.sum(-1).log()\n l_mean, l_scale = log_counts.mean().item(), log_counts.std().item()\n\n if cuda:\n X, Y = X.cuda(), Y.cuda()\n\n # subsample and remove ~50% of the unlabeled cells\n labeled = torch.where(Y != -1)[0]\n unlabeled = torch.where(Y == -1)[0]\n unlabeled = unlabeled[torch.randperm(unlabeled.size(0))[:19800]]\n idx = torch.cat([labeled, unlabeled])\n\n num_genes = X.size(-1)\n\n adata = adata[idx.data.cpu().numpy(), highly_variable_genes]\n adata.raw = adata\n\n return BatchDataLoader(X[idx], Y[idx], batch_size), num_genes, l_mean, l_scale, adata\n"
] | [
[
"scipy.sparse.csr_matrix.todense",
"torch.zeros",
"torch.cat",
"torch.randperm",
"torch.nn.functional.one_hot",
"torch.from_numpy",
"numpy.ones",
"torch.where",
"torch.distributions.Poisson",
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16",
"1.8"
],
"tensorflow": []
}
] |
pyiron/pysqa | [
"f300c8676305690d3033d633e6baa190ee6a01ba"
] | [
"pysqa/wrapper/gent.py"
] | [
"# coding: utf-8\n# Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department\n# Distributed under the terms of \"New BSD License\", see the LICENSE file.\n\nimport pandas\nfrom pysqa.wrapper.slurm import SlurmCommands\n\n\n__author__ = \"Jan Janssen\"\n__copyright__ = (\n \"Copyright 2019, Max-Planck-Institut für Eisenforschung GmbH - \"\n \"Computational Materials Design (CM) Department\"\n)\n__version__ = \"1.0\"\n__maintainer__ = \"Jan Janssen\"\n__email__ = \"[email protected]\"\n__status__ = \"development\"\n__date__ = \"Feb 9, 2019\"\n\n\nclass GentCommands(SlurmCommands):\n @staticmethod\n def get_job_id_from_output(queue_submit_output):\n return int(queue_submit_output.splitlines()[-1].rstrip().lstrip().split(\";\")[0])\n\n @staticmethod\n def get_queue_from_output(queue_submit_output):\n return str(queue_submit_output.splitlines()[-1].rstrip().lstrip().split(\";\")[1])\n\n @staticmethod\n def convert_queue_status(queue_status_output):\n qstat = queue_status_output.splitlines()\n queue = qstat[0].split(\":\")[1].strip()\n if len(qstat) <= 1: # first row contains cluster name, check if there are jobs\n return None\n\n line_split_lst = [line.split(\"|\") for line in qstat[1:]]\n job_id_lst, user_lst, status_lst, job_name_lst, queue_lst = zip(\n *[\n (int(jobid), user, status.lower(), jobname, queue)\n for jobid, user, status, jobname in line_split_lst\n ]\n )\n return pandas.DataFrame(\n {\n \"cluster\": queue_lst,\n \"jobid\": job_id_lst,\n \"user\": user_lst,\n \"jobname\": job_name_lst,\n \"status\": status_lst,\n }\n )\n"
] | [
[
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
aatifjiwani/nums | [
"40e225a4dd34a8df87702c271dc673711f2264a3"
] | [
"nums/core/array/application.py"
] | [
"# coding=utf-8\n# Copyright (C) 2020 NumS Development Team.\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\nfrom typing import List, Tuple, Dict, Union\n\nimport numpy as np\n\nfrom nums.core.array import utils as array_utils\nfrom nums.core.array.blockarray import BlockArray, Block\nfrom nums.core.array.random import NumsRandomState\nfrom nums.core.compute.compute_manager import ComputeManager\nfrom nums.core.grid.grid import ArrayGrid\nfrom nums.core.grid.grid import DeviceID\nfrom nums.core.storage.storage import StoredArray, StoredArrayS3\nfrom nums.core.systems.filesystem import FileSystem\n\n# pylint: disable = too-many-lines\n\n\nclass ArrayApplication(object):\n def __init__(self, cm: ComputeManager, fs: FileSystem):\n self.cm: ComputeManager = cm\n self._fs: FileSystem = fs\n self._array_grids: Dict[str, ArrayGrid] = {}\n self.random = self.random_state()\n\n self.one_half = self.scalar(0.5)\n self.two = self.scalar(2.0)\n self.one = self.scalar(1.0)\n self.zero = self.scalar(0.0)\n\n def compute_block_shape(\n self,\n shape: tuple,\n dtype: Union[type, np.dtype],\n cluster_shape=None,\n num_cores=None,\n ):\n return self.cm.compute_block_shape(shape, dtype, cluster_shape, num_cores)\n\n def get_block_shape(self, shape, dtype):\n return self.cm.get_block_shape(shape, dtype)\n\n def _get_array_grid(self, filename: str, stored_array_cls) -> ArrayGrid:\n if filename not in self._array_grids:\n store_inst: StoredArray = stored_array_cls(filename)\n self._array_grids[filename] = store_inst.get_grid()\n return self._array_grids[filename]\n\n ######################################\n # Filesystem API\n ######################################\n\n def write_fs(self, ba: BlockArray, filename: str):\n res = self._write(ba, filename, self._fs.write_block_fs)\n self._fs.write_meta_fs(ba, filename)\n return res\n\n def read_fs(self, filename: str):\n meta = self._fs.read_meta_fs(filename)\n addresses = meta[\"addresses\"]\n grid_meta = meta[\"grid_meta\"]\n grid = ArrayGrid.from_meta(grid_meta)\n ba: BlockArray = BlockArray(grid, self.cm)\n for grid_entry in addresses:\n device_id: DeviceID = DeviceID.from_str(addresses[grid_entry])\n ba.blocks[grid_entry].oid = self._fs.read_block_fs(\n filename, grid_entry, grid_meta, syskwargs={\"device_id\": device_id}\n )\n return ba\n\n def delete_fs(self, filename: str):\n meta = self._fs.read_meta_fs(filename)\n addresses = meta[\"addresses\"]\n grid_meta = meta[\"grid_meta\"]\n grid = ArrayGrid.from_meta(grid_meta)\n result_grid = ArrayGrid(\n grid.grid_shape,\n tuple(np.ones_like(grid.shape, dtype=np.int)),\n dtype=dict.__name__,\n )\n rarr = BlockArray(result_grid, self.cm)\n for grid_entry in addresses:\n device_id: DeviceID = DeviceID.from_str(addresses[grid_entry])\n rarr.blocks[grid_entry].oid = self._fs.delete_block_fs(\n filename, grid_entry, grid_meta, syskwargs={\"device_id\": device_id}\n )\n self._fs.delete_meta_fs(filename)\n return rarr\n\n def write_s3(self, ba: BlockArray, filename: str):\n grid_entry = tuple(np.zeros_like(ba.shape, dtype=np.int))\n result = self._fs.write_meta_s3(\n filename,\n grid_meta=ba.grid.to_meta(),\n syskwargs={\"grid_entry\": grid_entry, \"grid_shape\": ba.grid.grid_shape},\n )\n assert \"ETag\" in self.cm.get(result).item(), \"Metadata write failed.\"\n return self._write(ba, filename, self._fs.write_block_s3)\n\n def _write(self, ba: BlockArray, filename, remote_func):\n grid = ba.grid\n result_grid = ArrayGrid(\n grid.grid_shape,\n tuple(np.ones_like(grid.shape, dtype=np.int)),\n dtype=dict.__name__,\n )\n rarr = BlockArray(result_grid, self.cm)\n for grid_entry in grid.get_entry_iterator():\n rarr.blocks[grid_entry].oid = remote_func(\n ba.blocks[grid_entry].oid,\n filename,\n grid_entry,\n grid.to_meta(),\n syskwargs={\"grid_entry\": grid_entry, \"grid_shape\": grid.grid_shape},\n )\n return rarr\n\n def read_s3(self, filename: str):\n store_cls, remote_func = StoredArrayS3, self._fs.read_block_s3\n grid = self._get_array_grid(filename, store_cls)\n grid_meta = grid.to_meta()\n grid_entry_iterator = grid.get_entry_iterator()\n rarr = BlockArray(grid, self.cm)\n for grid_entry in grid_entry_iterator:\n rarr.blocks[grid_entry].oid = remote_func(\n filename,\n grid_entry,\n grid_meta,\n syskwargs={\"grid_entry\": grid_entry, \"grid_shape\": grid.grid_shape},\n )\n return rarr\n\n def delete_s3(self, filename: str):\n grid = self._get_array_grid(filename, StoredArrayS3)\n grid_entry = tuple(np.zeros_like(grid.shape, dtype=np.int))\n result = self._fs.delete_meta_s3(\n filename,\n syskwargs={\"grid_entry\": grid_entry, \"grid_shape\": grid.grid_shape},\n )\n deleted_key = self.cm.get(result).item()[\"Deleted\"][0][\"Key\"]\n assert deleted_key == StoredArrayS3(filename, grid).get_meta_key()\n results: BlockArray = self._delete(\n filename, StoredArrayS3, self._fs.delete_block_s3\n )\n return results\n\n def _delete(self, filename, store_cls, remote_func):\n grid = self._get_array_grid(filename, store_cls)\n result_grid = ArrayGrid(\n grid.grid_shape,\n tuple(np.ones_like(grid.shape, dtype=np.int)),\n dtype=dict.__name__,\n )\n rarr = BlockArray(result_grid, self.cm)\n for grid_entry in grid.get_entry_iterator():\n rarr.blocks[grid_entry].oid = remote_func(\n filename,\n grid_entry,\n grid.to_meta(),\n syskwargs={\"grid_entry\": grid_entry, \"grid_shape\": grid.grid_shape},\n )\n return rarr\n\n def read_csv(\n self, filename, dtype=float, delimiter=\",\", has_header=False, num_workers=None\n ):\n if num_workers is None:\n num_workers = self.cm.num_cores_total()\n arrays: list = self._fs.read_csv(\n filename, dtype, delimiter, has_header, num_workers\n )\n shape = np.zeros(len(arrays[0].shape), dtype=int)\n for array in arrays:\n shape += np.array(array.shape, dtype=int)\n shape = tuple(shape)\n block_shape = self.cm.get_block_shape(shape, dtype)\n result = self.concatenate(arrays, axis=0, axis_block_size=block_shape[0])\n # Release references immediately, in case we need to do another reshape.\n del arrays\n if result.block_shape[1] != block_shape[1]:\n result = result.reshape(block_shape=block_shape)\n return result\n\n def loadtxt(\n self,\n fname,\n dtype=float,\n comments=\"# \",\n delimiter=\" \",\n converters=None,\n skiprows=0,\n usecols=None,\n unpack=False,\n ndmin=0,\n encoding=\"bytes\",\n max_rows=None,\n num_workers=None,\n ) -> BlockArray:\n if num_workers is None:\n num_workers = self.cm.num_cores_total()\n return self._fs.loadtxt(\n fname,\n dtype=dtype,\n comments=comments,\n delimiter=delimiter,\n converters=converters,\n skiprows=skiprows,\n usecols=usecols,\n unpack=unpack,\n ndmin=ndmin,\n encoding=encoding,\n max_rows=max_rows,\n num_workers=num_workers,\n )\n\n ######################################\n # Array Operations API\n ######################################\n\n def scalar(self, value):\n return BlockArray.from_scalar(value, self.cm)\n\n def array(self, array: Union[np.ndarray, List[float]], block_shape: tuple = None):\n if not isinstance(array, np.ndarray):\n if array_utils.is_array_like(array):\n array = np.array(array)\n else:\n raise ValueError(\n \"Unable to instantiate array from type %s\" % type(array)\n )\n assert len(array.shape) == len(block_shape)\n return BlockArray.from_np(\n array, block_shape=block_shape, copy=False, cm=self.cm\n )\n\n def zeros(self, shape: tuple, block_shape: tuple, dtype: np.dtype = None):\n return self._new_array(\"zeros\", shape, block_shape, dtype)\n\n def ones(self, shape: tuple, block_shape: tuple, dtype: np.dtype = None):\n return self._new_array(\"ones\", shape, block_shape, dtype)\n\n def empty(self, shape: tuple, block_shape: tuple, dtype: np.dtype = None):\n return self._new_array(\"empty\", shape, block_shape, dtype)\n\n def _new_array(\n self, op_name: str, shape: tuple, block_shape: tuple, dtype: np.dtype = None\n ):\n assert len(shape) == len(block_shape)\n if dtype is None:\n dtype = np.float64\n grid = ArrayGrid(shape, block_shape, dtype.__name__)\n grid_meta = grid.to_meta()\n rarr = BlockArray(grid, self.cm)\n for grid_entry in grid.get_entry_iterator():\n rarr.blocks[grid_entry].oid = self.cm.new_block(\n op_name,\n grid_entry,\n grid_meta,\n syskwargs={\"grid_entry\": grid_entry, \"grid_shape\": grid.grid_shape},\n )\n return rarr\n\n def concatenate(self, arrays: List, axis: int, axis_block_size: int = None):\n num_arrs = len(arrays)\n assert num_arrs > 1\n first_arr: BlockArray = arrays[0]\n num_axes = len(first_arr.shape)\n # Check assumptions and define result shapes and block shapes.\n for i in range(num_arrs):\n curr_ba: BlockArray = arrays[i]\n assert num_axes == len(curr_ba.shape), \"Unequal num axes.\"\n assert curr_ba.dtype == first_arr.dtype, \"Incompatible dtypes \" \"%s, %s\" % (\n curr_ba.dtype,\n first_arr.dtype,\n )\n for curr_axis in range(num_axes):\n first_block_size = first_arr.block_shape[curr_axis]\n block_size = curr_ba.block_shape[curr_axis]\n if first_block_size == block_size:\n continue\n elif axis == curr_axis:\n assert axis_block_size is not None, (\n \"block axis size is required \" \"when block shapes are neq.\"\n )\n else:\n raise ValueError(\n \"Other axis shapes and block shapes must be equal.\"\n )\n\n # Compute result shapes.\n result_shape = []\n result_block_shape = []\n for curr_axis in range(num_axes):\n if curr_axis == axis:\n if axis_block_size is None:\n # They are all equal.\n axis_block_size = first_arr.block_shape[curr_axis]\n result_block_size = axis_block_size\n result_size = 0\n for i in range(num_arrs):\n curr_ba: BlockArray = arrays[i]\n size = curr_ba.shape[curr_axis]\n result_size += size\n else:\n result_size = first_arr.shape[curr_axis]\n result_block_size = first_arr.block_shape[curr_axis]\n result_shape.append(result_size)\n result_block_shape.append(result_block_size)\n result_shape, result_block_shape = tuple(result_shape), tuple(\n result_block_shape\n )\n result_ba = self.empty(result_shape, result_block_shape, first_arr.dtype)\n\n # Write result blocks.\n # TODO (hme): This can be optimized by updating blocks directly.\n pos = 0\n for arr in arrays:\n delta = arr.shape[axis]\n axis_slice = slice(pos, pos + delta)\n result_selector = tuple(\n [slice(None, None) for _ in range(axis)] + [axis_slice, ...]\n )\n result_ba[result_selector] = arr\n pos += delta\n return result_ba\n\n def eye(self, shape: tuple, block_shape: tuple, dtype: np.dtype = None):\n assert len(shape) == len(block_shape) == 2\n if dtype is None:\n dtype = np.float64\n grid = ArrayGrid(shape, block_shape, dtype.__name__)\n grid_meta = grid.to_meta()\n rarr = BlockArray(grid, self.cm)\n for grid_entry in grid.get_entry_iterator():\n syskwargs = {\"grid_entry\": grid_entry, \"grid_shape\": grid.grid_shape}\n if np.all(np.diff(grid_entry) == 0):\n # This is a diagonal block.\n rarr.blocks[grid_entry].oid = self.cm.new_block(\n \"eye\", grid_entry, grid_meta, syskwargs=syskwargs\n )\n else:\n rarr.blocks[grid_entry].oid = self.cm.new_block(\n \"zeros\", grid_entry, grid_meta, syskwargs=syskwargs\n )\n return rarr\n\n def diag(self, X: BlockArray) -> BlockArray:\n def find_diag_output_blocks(X: BlockArray, total_elements: int):\n # The i,j entry corresponding to a block in X_blocks.\n block_i, block_j = 0, 0\n\n # The i,j entry within the current block.\n element_i, element_j = 0, 0\n\n # Keep track of the no of elements found so far.\n count = 0\n\n # Start at block 0,0.\n block = X.blocks[(0, 0)]\n\n # Each element contains block indices, diag offset,\n # and the total elements required from the block.\n diag_meta = []\n\n while count < total_elements:\n if element_i > block.shape[0] - 1:\n block_i = block_i + 1\n element_i = 0\n if element_j > block.shape[1] - 1:\n block_j = block_j + 1\n element_j = 0\n\n block = X.blocks[(block_i, block_j)]\n block_rows, block_cols = block.shape[0], block.shape[1]\n offset = -element_i if element_i > element_j else element_j\n total_elements_block = (\n min(block_rows - 1 - element_i, block_cols - 1 - element_j) + 1\n )\n diag_meta.append(((block_i, block_j), offset, total_elements_block))\n count, element_i = (\n count + total_elements_block,\n element_i + total_elements_block,\n )\n element_j = element_j + total_elements_block\n return diag_meta\n\n if len(X.shape) == 1:\n shape = X.shape[0], X.shape[0]\n block_shape = X.block_shape[0], X.block_shape[0]\n grid = ArrayGrid(shape, block_shape, X.dtype.__name__)\n grid_meta = grid.to_meta()\n rarr = BlockArray(grid, self.cm)\n for grid_entry in grid.get_entry_iterator():\n syskwargs = {\"grid_entry\": grid_entry, \"grid_shape\": grid.grid_shape}\n if np.all(np.diff(grid_entry) == 0):\n # This is a diagonal block.\n rarr.blocks[grid_entry].oid = self.cm.diag(\n X.blocks[grid_entry[0]].oid, 0, syskwargs=syskwargs\n )\n else:\n rarr.blocks[grid_entry].oid = self.cm.new_block(\n \"zeros\", grid_entry, grid_meta, syskwargs=syskwargs\n )\n elif len(X.shape) == 2:\n out_shape = (min(X.shape),)\n out_block_shape = (min(X.block_shape),)\n # Obtain the block indices which contain the diagonal of the matrix.\n\n diag_meta = find_diag_output_blocks(X, out_shape[0])\n output_block_arrays = []\n out_grid_shape = (len(diag_meta),)\n count = 0\n # Obtain the diagonals.\n for block_indices, offset, total_elements in diag_meta:\n syskwargs = {\"grid_entry\": (count,), \"grid_shape\": out_grid_shape}\n result_block_shape = (total_elements,)\n block_grid = ArrayGrid(\n result_block_shape,\n result_block_shape,\n X.blocks[block_indices].dtype.__name__,\n )\n block_array = BlockArray(block_grid, self.cm)\n block_array.blocks[0].oid = self.cm.diag(\n X.blocks[block_indices].oid, offset, syskwargs=syskwargs\n )\n output_block_arrays.append(block_array)\n count += 1\n if len(output_block_arrays) > 1:\n # If there are multiple blocks, concatenate them.\n return self.concatenate(\n output_block_arrays, axis=0, axis_block_size=out_block_shape[0]\n )\n return output_block_arrays[0]\n else:\n raise ValueError(\"X must have 1 or 2 axes.\")\n return rarr\n\n def arange(self, start_in, shape, block_shape, step=1, dtype=None) -> BlockArray:\n assert step == 1\n if dtype is None:\n dtype = np.__getattribute__(\n str(np.result_type(start_in, shape[0] + start_in))\n )\n\n # Generate ranges per block.\n grid = ArrayGrid(shape, block_shape, dtype.__name__)\n rarr = BlockArray(grid, self.cm)\n for _, grid_entry in enumerate(grid.get_entry_iterator()):\n syskwargs = {\"grid_entry\": grid_entry, \"grid_shape\": grid.grid_shape}\n start = start_in + block_shape[0] * grid_entry[0]\n entry_shape = grid.get_block_shape(grid_entry)\n stop = start + entry_shape[0]\n rarr.blocks[grid_entry].oid = self.cm.arange(\n start, stop, step, dtype, syskwargs=syskwargs\n )\n return rarr\n\n def linspace(self, start, stop, shape, block_shape, endpoint, retstep, dtype, axis):\n assert axis == 0\n assert endpoint is True\n assert retstep is False\n\n step_size = (stop - start) / (shape[0] - 1)\n result = self.arange(0, shape, block_shape)\n result = start + result * step_size\n\n if dtype is not None and dtype != result.dtype:\n result = result.astype(dtype)\n return result\n\n def log(self, X: BlockArray):\n return X.ufunc(\"log\")\n\n def exp(self, X: BlockArray):\n return X.ufunc(\"exp\")\n\n def abs(self, X: BlockArray):\n return X.ufunc(\"abs\")\n\n def min(self, X: BlockArray, axis=None, keepdims=False):\n return self.reduce(\"min\", X, axis, keepdims)\n\n def max(self, X: BlockArray, axis=None, keepdims=False):\n return self.reduce(\"max\", X, axis, keepdims)\n\n def argmin(self, X: BlockArray, axis=None):\n pass\n\n def sum(self, X: BlockArray, axis=None, keepdims=False, dtype=None):\n return self.reduce(\"sum\", X, axis, keepdims, dtype)\n\n def reduce(\n self, op_name: str, X: BlockArray, axis=None, keepdims=False, dtype=None\n ):\n res = X.reduce_axis(op_name, axis, keepdims=keepdims)\n if dtype is not None:\n res = res.astype(dtype)\n return res\n\n def mean(self, X: BlockArray, axis=None, keepdims=False, dtype=None):\n if X.dtype not in (float, np.float32, np.float64):\n X = X.astype(np.float64)\n num_summed = np.product(X.shape) if axis is None else X.shape[axis]\n res = self.sum(X, axis=axis, keepdims=keepdims) / num_summed\n if dtype is not None:\n res = res.astype(dtype)\n return res\n\n def var(self, X: BlockArray, axis=None, ddof=0, keepdims=False, dtype=None):\n mean = self.mean(X, axis=axis, keepdims=True)\n ss = self.sum((X - mean) ** self.two, axis=axis, keepdims=keepdims)\n num_summed = (np.product(X.shape) if axis is None else X.shape[axis]) - ddof\n res = ss / num_summed\n if dtype is not None:\n res = res.astype(dtype)\n return res\n\n def std(self, X: BlockArray, axis=None, ddof=0, keepdims=False, dtype=None):\n res = self.sqrt(self.var(X, axis, ddof, keepdims))\n if dtype is not None:\n res = res.astype(dtype)\n return res\n\n def argop(self, op_name: str, arr: BlockArray, axis=None):\n if len(arr.shape) > 1:\n raise NotImplementedError(\n \"%s currently supports one-dimensional arrays.\" % op_name\n )\n if axis is None:\n axis = 0\n assert axis == 0\n grid = ArrayGrid(shape=(), block_shape=(), dtype=np.int64.__name__)\n result = BlockArray(grid, self.cm)\n reduction_result = None, None\n for grid_entry in arr.grid.get_entry_iterator():\n block_slice: slice = arr.grid.get_slice(grid_entry)[0]\n block: Block = arr.blocks[grid_entry]\n syskwargs = {\n \"grid_entry\": grid_entry,\n \"grid_shape\": arr.grid.grid_shape,\n \"options\": {\"num_returns\": 2},\n }\n reduction_result = self.cm.arg_op(\n op_name, block.oid, block_slice, *reduction_result, syskwargs=syskwargs\n )\n argoptima, _ = reduction_result\n result.blocks[()].oid = argoptima\n return result\n\n def sqrt(self, X):\n if X.dtype not in (float, np.float32, np.float64):\n X = X.astype(np.float64)\n return X.ufunc(\"sqrt\")\n\n def norm(self, X):\n return self.sqrt(X.T @ X)\n\n def xlogy(self, x: BlockArray, y: BlockArray) -> BlockArray:\n if x.dtype not in (float, np.float32, np.float64):\n x = x.astype(np.float64)\n if x.dtype not in (float, np.float32, np.float64):\n y = y.astype(np.float64)\n return self.map_bop(\"xlogy\", x, y)\n\n def where(self, condition: BlockArray, x: BlockArray = None, y: BlockArray = None):\n result_oids = []\n shape_oids = []\n num_axes = max(1, len(condition.shape))\n # Stronger constraint than necessary, but no reason for anything stronger.\n if x is not None or y is not None:\n assert x is not None and y is not None\n assert condition.shape == x.shape == y.shape\n assert condition.block_shape == x.block_shape == y.block_shape\n assert x.dtype == y.dtype\n result = BlockArray(x.grid.copy(), self.cm)\n for grid_entry in condition.grid.get_entry_iterator():\n cond_oid = condition.blocks[grid_entry].oid\n x_oid = x.blocks[grid_entry].oid\n y_oid = y.blocks[grid_entry].oid\n r_oid = self.cm.where(\n cond_oid,\n x_oid,\n y_oid,\n None,\n syskwargs={\n \"grid_entry\": grid_entry,\n \"grid_shape\": condition.grid.grid_shape,\n \"options\": {\"num_returns\": 1},\n },\n )\n result.blocks[grid_entry].oid = r_oid\n return result\n else:\n for grid_entry in condition.grid.get_entry_iterator():\n block: Block = condition.blocks[grid_entry]\n block_slice_tuples = condition.grid.get_slice_tuples(grid_entry)\n roids = self.cm.where(\n block.oid,\n None,\n None,\n block_slice_tuples,\n syskwargs={\n \"grid_entry\": grid_entry,\n \"grid_shape\": condition.grid.grid_shape,\n \"options\": {\"num_returns\": num_axes + 1},\n },\n )\n block_oids, shape_oid = roids[:-1], roids[-1]\n shape_oids.append(shape_oid)\n result_oids.append(block_oids)\n shapes = self.cm.get(shape_oids)\n result_shape = (np.sum(shapes),)\n if result_shape == (0,):\n return (self.array(np.array([], dtype=np.int64), block_shape=(0,)),)\n # Remove empty shapes.\n result_shape_pair = []\n for i, shape in enumerate(shapes):\n if np.sum(shape) > 0:\n result_shape_pair.append((result_oids[i], shape))\n result_block_shape = self.cm.compute_block_shape(result_shape, np.int64)\n result_arrays = []\n for axis in range(num_axes):\n block_arrays = []\n for i in range(len(result_oids)):\n if shapes[i] == (0,):\n continue\n block_arrays.append(\n BlockArray.from_oid(\n result_oids[i][axis], shapes[i], np.int64, self.cm\n )\n )\n if len(block_arrays) == 1:\n axis_result = block_arrays[0]\n else:\n axis_result = self.concatenate(\n block_arrays, 0, result_block_shape[0]\n )\n result_arrays.append(axis_result)\n return tuple(result_arrays)\n\n def quickselect(self, arr_oids: List[object], kth: int):\n \"\"\"Find the `kth` largest element in a 1D BlockArray in O(n) time.\n Used as a subprocedure in `median` and `top_k`.\n\n Args:\n arr_oids: Flattened list of oids for array objects.\n kth: Index of the element (in ascending order) to select.\n\n Returns:\n Value of the `kth` largest element.\n \"\"\"\n num_arrs = len(arr_oids)\n\n # Compute weighted median of medians (wmm).\n m_oids, s_oids = [], []\n for i, arr_oid in enumerate(arr_oids):\n syskwargs = {\n \"grid_entry\": (i,),\n \"grid_shape\": (num_arrs,),\n \"options\": {\"num_returns\": 1},\n }\n m_oids.append(self.cm.select_median(arr_oid, syskwargs=syskwargs))\n s_oids.append(self.cm.size(arr_oid, syskwargs=syskwargs))\n ms_oids = m_oids + s_oids\n device_0 = self.cm.devices()[0]\n wmm_oid = self.cm.system.call(\"weighted_median\", ms_oids, {}, device_0, {})\n total_size = sum(self.cm.get(s) for s in s_oids)\n if kth < 0:\n kth += total_size\n if kth < 0 or total_size <= kth:\n raise IndexError(\"'kth' must be a valid index for 'arr'.\")\n\n # Compute \"greater than\" partition using wmm as pivot, recurse if kth is in range.\n gr_size_oids, gr_oids = [], []\n for i, arr_oid in enumerate(arr_oids):\n gr_size_oid, gr_oid = self.cm.pivot_partition(\n arr_oid,\n wmm_oid,\n \"gt\",\n syskwargs={\n \"grid_entry\": (i,),\n \"grid_shape\": (num_arrs,),\n \"options\": {\"num_returns\": 2},\n },\n )\n gr_size_oids.append(gr_size_oid)\n gr_oids.append(gr_oid)\n gr_size = sum(self.cm.get(s) for s in gr_size_oids)\n if kth < gr_size:\n del arr_oids\n return self.quickselect(gr_oids, kth)\n\n # Compute \"less than\" partition using wmm as pivot, recurse if kth is in range.\n ls_size_oids, ls_oids = [], []\n for i, arr_oid in enumerate(arr_oids):\n ls_size_oid, ls_oid = self.cm.pivot_partition(\n arr_oid,\n wmm_oid,\n \"lt\",\n syskwargs={\n \"grid_entry\": (i,),\n \"grid_shape\": (num_arrs,),\n \"options\": {\"num_returns\": 2},\n },\n )\n ls_size_oids.append(ls_size_oid)\n ls_oids.append(ls_oid)\n ls_size = sum(self.cm.get(s) for s in ls_size_oids)\n if kth >= total_size - ls_size:\n del arr_oids\n return self.quickselect(ls_oids, kth - (total_size - ls_size))\n\n # The kth value is wmm.\n return wmm_oid\n\n def median(self, arr: BlockArray) -> BlockArray:\n \"\"\"Compute the median of a BlockArray.\n\n Args:\n a: A BlockArray.\n\n Returns:\n The median value.\n \"\"\"\n if arr.ndim != 1:\n raise NotImplementedError(\"Only 1D 'arr' is currently supported.\")\n\n a_oids = arr.flattened_oids()\n if arr.size % 2 == 1:\n m_oid = self.quickselect(a_oids, arr.size // 2)\n return BlockArray.from_oid(m_oid, (1,), arr.dtype, self.cm)\n else:\n m0_oid = self.quickselect(a_oids, arr.size // 2 - 1)\n m0 = BlockArray.from_oid(m0_oid, (1,), arr.dtype, self.cm)\n m1_oid = self.quickselect(a_oids, arr.size // 2)\n m1 = BlockArray.from_oid(m1_oid, (1,), arr.dtype, self.cm)\n return (m0 + m1) / 2\n\n def top_k(\n self, arr: BlockArray, k: int, largest=True\n ) -> Tuple[BlockArray, BlockArray]:\n \"\"\"Find the `k` largest or smallest elements of a BlockArray.\n\n If there are multiple kth elements that are equal in value, then no guarantees are made as\n to which ones are included in the top k.\n\n Args:\n arr: A BlockArray.\n k: Number of top elements to return.\n largest: Whether to return largest or smallest elements.\n\n Returns:\n A tuple containing two BlockArrays, (`values`, `indices`).\n values: Values of the top k elements, unsorted.\n indices: Indices of the top k elements, ordered by their corresponding values.\n \"\"\"\n if arr.ndim != 1:\n raise NotImplementedError(\"Only 1D 'arr' is currently supported.\")\n if k <= 0 or arr.size < k:\n raise IndexError(\"'k' must be at least 1 and at most the size of 'arr'.\")\n arr_oids = arr.flattened_oids()\n if largest:\n k_oid = self.quickselect(arr_oids, k - 1)\n k_val = BlockArray.from_oid(k_oid, (1,), arr.dtype, self.cm)\n ie_indices = self.where(arr > k_val[0])[0]\n else:\n k_oid = self.quickselect(arr_oids, -k)\n k_val = BlockArray.from_oid(k_oid, (1,), arr.dtype, self.cm)\n ie_indices = self.where(arr < k_val[0])[0]\n eq_indices = self.where(arr == k_val[0])[0]\n eq_indices_pad = eq_indices[: k - ie_indices.size]\n axis_block_size = self.compute_block_shape((k,), int)[0]\n indices = self.concatenate([ie_indices, eq_indices_pad], 0, axis_block_size)\n return arr[indices], indices\n\n def map_uop(\n self,\n op_name: str,\n arr: BlockArray,\n out: BlockArray = None,\n where=True,\n args=None,\n kwargs=None,\n ) -> BlockArray:\n \"\"\"A map, for unary operators, that applies to every entry of an array.\n\n Args:\n op_name: An element-wise unary operator.\n arr: A BlockArray.\n out: A BlockArray to which the result is written.\n where: An indicator specifying the indices to which op is applied.\n args: Args provided to op.\n kwargs: Keyword args provided to op.\n\n Returns:\n A BlockArray.\n \"\"\"\n if where is not True:\n raise NotImplementedError(\"'where' argument is not yet supported.\")\n args = () if args is None else args\n kwargs = {} if kwargs is None else kwargs\n shape = arr.shape\n block_shape = arr.block_shape\n dtype = array_utils.get_uop_output_type(op_name, arr.dtype)\n assert len(shape) == len(block_shape)\n if out is None:\n grid = ArrayGrid(shape, block_shape, dtype.__name__)\n rarr = BlockArray(grid, self.cm)\n else:\n rarr = out\n grid = rarr.grid\n assert rarr.shape == arr.shape and rarr.block_shape == arr.block_shape\n for grid_entry in grid.get_entry_iterator():\n # TODO(hme): Faster to create ndarray first,\n # and instantiate block array on return\n # to avoid instantiating blocks on BlockArray initialization.\n rarr.blocks[grid_entry] = arr.blocks[grid_entry].uop_map(\n op_name, args=args, kwargs=kwargs\n )\n return rarr\n\n def matmul(self, arr_1: BlockArray, arr_2: BlockArray) -> BlockArray:\n return arr_1 @ arr_2\n\n def tensordot(\n self, arr_1: BlockArray, arr_2: BlockArray, axes: int = 2\n ) -> BlockArray:\n return arr_1.tensordot(arr_2, axes)\n\n def map_bop(\n self,\n op_name: str,\n arr_1: BlockArray,\n arr_2: BlockArray,\n out: BlockArray = None,\n where=True,\n args=None,\n kwargs=None,\n ) -> BlockArray:\n # TODO (hme): Move this into BlockArray, and invoke on operator implementations.\n \"\"\"A map for binary operators that applies element-wise to every entry of the input arrays.\n\n Args:\n op_name: An element-wise binary operator.\n arr_1: A BlockArray.\n arr_2: A BlockArray.\n out: A BlockArray to which the result is written.\n where: An indicator specifying the indices to which op is applied.\n args: Args provided to op.\n kwargs: Keyword args provided to op.\n\n Returns:\n A BlockArray.\n \"\"\"\n if where is not True:\n raise NotImplementedError(\"'where' argument is not yet supported.\")\n if args is not None:\n raise NotImplementedError(\"'args' is not yet supported.\")\n if not (kwargs is None or len(kwargs) == 0):\n raise NotImplementedError(\"'kwargs' is not yet supported.\")\n\n if not array_utils.broadcastable(\n arr_1.shape, arr_2.shape, arr_1.block_shape, arr_2.block_shape\n ):\n raise ValueError(\"Operands cannot be broadcasted.\")\n\n try:\n ufunc = np.__getattribute__(op_name)\n if (\n op_name.endswith(\"max\")\n or op_name == \"maximum\"\n or op_name.endswith(\"min\")\n or op_name == \"minimum\"\n or op_name.startswith(\"logical\")\n ):\n rarr = self._broadcast_bop(op_name, arr_1, arr_2)\n else:\n result_blocks: np.ndarray = ufunc(arr_1.blocks, arr_2.blocks)\n rarr = BlockArray.from_blocks(\n result_blocks, result_shape=None, cm=self.cm\n )\n except Exception as _:\n rarr = self._broadcast_bop(op_name, arr_1, arr_2)\n if out is not None:\n assert out.grid.grid_shape == rarr.grid.grid_shape\n assert out.shape == rarr.shape\n assert out.block_shape == rarr.block_shape\n out.blocks[:] = rarr.blocks[:]\n rarr = out\n return rarr\n\n def _broadcast_bop(self, op_name, arr_1, arr_2) -> BlockArray:\n \"\"\"We want to avoid invoking this op whenever possible; NumPy's imp is faster.\n\n Args:\n op_name: Name of binary operation.\n arr_1: A BlockArray.\n arr_2: A BlockArray.\n\n Returns:\n A BlockArray.\n \"\"\"\n if arr_1.shape != arr_2.shape:\n output_grid_shape = array_utils.broadcast_shape(\n arr_1.grid.grid_shape, arr_2.grid.grid_shape\n )\n arr_1 = arr_1.broadcast_to(output_grid_shape)\n arr_2 = arr_2.broadcast_to(output_grid_shape)\n dtype = array_utils.get_bop_output_type(op_name, arr_1.dtype, arr_2.dtype)\n grid = ArrayGrid(arr_1.shape, arr_1.block_shape, dtype.__name__)\n rarr = BlockArray(grid, self.cm)\n for grid_entry in rarr.grid.get_entry_iterator():\n block_1: Block = arr_1.blocks[grid_entry]\n block_2: Block = arr_2.blocks[grid_entry]\n rarr.blocks[grid_entry] = block_1.bop(op_name, block_2, {})\n return rarr\n\n def get(self, *arrs):\n if len(arrs) == 1:\n if isinstance(arrs[0], BlockArray):\n return arrs[0].get()\n else:\n return arrs[0]\n else:\n r = []\n for item in arrs:\n if isinstance(item, BlockArray):\n r.append(item.get())\n else:\n r.append(item)\n return r\n\n def array_compare(self, func_name, a: BlockArray, b: BlockArray, *args):\n assert a.shape == b.shape and a.block_shape == b.block_shape\n bool_list = []\n grid_shape = a.grid.grid_shape\n for grid_entry in a.grid.get_entry_iterator():\n a_block, b_block = a.blocks[grid_entry].oid, b.blocks[grid_entry].oid\n bool_list.append(\n self.cm.array_compare(\n func_name,\n a_block,\n b_block,\n args,\n syskwargs={\"grid_entry\": grid_entry, \"grid_shape\": grid_shape},\n )\n )\n oid = self.cm.logical_and(\n *bool_list, syskwargs={\"grid_entry\": (0, 0), \"grid_shape\": (1, 1)}\n )\n return BlockArray.from_oid(oid, (), np.bool, self.cm)\n\n def array_equal(self, a: BlockArray, b: BlockArray):\n return self.array_compare(\"array_equal\", a, b)\n\n def array_equiv(self, a: BlockArray, b: BlockArray):\n return self.array_compare(\"array_equiv\", a, b)\n\n def allclose(self, a: BlockArray, b: BlockArray, rtol=1.0e-5, atol=1.0e-8):\n return self.array_compare(\"allclose\", a, b, rtol, atol)\n\n def vec_from_oids(self, oids, shape, block_shape, dtype):\n arr = BlockArray(\n ArrayGrid(shape=shape, block_shape=shape, dtype=dtype.__name__), self.cm\n )\n # Make sure resulting grid shape is a vector (1 dimensional).\n assert np.sum(arr.grid.grid_shape) == (\n max(arr.grid.grid_shape) + len(arr.grid.grid_shape) - 1\n )\n for i, grid_entry in enumerate(arr.grid.get_entry_iterator()):\n arr.blocks[grid_entry].oid = oids[i]\n if block_shape != shape:\n return arr.reshape(block_shape=block_shape)\n return arr\n\n def random_state(self, seed=None):\n return NumsRandomState(self.cm, seed)\n\n def isnan(self, X: BlockArray):\n return self.map_uop(\"isnan\", X)\n\n def nanmean(self, a: BlockArray, axis=None, keepdims=False, dtype=None):\n if not array_utils.is_float(a):\n a = a.astype(np.float64)\n\n num_summed = self.sum(\n ~a.ufunc(\"isnan\"), axis=axis, dtype=a.dtype, keepdims=keepdims\n )\n\n if num_summed.ndim == 0 and num_summed == 0:\n return self.scalar(np.nan)\n\n if num_summed.ndim > 0:\n num_summed = self.where(\n num_summed == 0,\n self.empty(num_summed.shape, num_summed.block_shape) * np.nan,\n num_summed,\n )\n\n res = (\n self.reduce(\"nansum\", a, axis=axis, dtype=dtype, keepdims=keepdims)\n / num_summed\n )\n\n if dtype is not None:\n res = res.astype(dtype)\n return res\n\n def nanvar(self, a: BlockArray, axis=None, ddof=0, keepdims=False, dtype=None):\n mean = self.nanmean(a, axis=axis, keepdims=True)\n ss = self.reduce(\n \"nansum\", (a - mean) ** self.two, axis=axis, dtype=dtype, keepdims=keepdims\n )\n num_summed = (\n self.sum(~a.ufunc(\"isnan\"), axis=axis, dtype=a.dtype, keepdims=keepdims)\n - ddof\n )\n res = ss / num_summed\n if dtype is not None:\n res = res.astype(dtype)\n return res\n\n def nanstd(self, a: BlockArray, axis=None, ddof=0, keepdims=False, dtype=None):\n res = self.sqrt(self.nanvar(a, axis, ddof, keepdims))\n if dtype is not None:\n res = res.astype(dtype)\n return res\n\n def atleast_1d(self, *arys):\n res = []\n for ary in arys:\n ary = BlockArray.to_block_array(ary, self.cm)\n if ary.ndim == 0:\n result = ary.reshape(1)\n else:\n result = ary\n res.append(result)\n if len(res) == 1:\n return res[0]\n else:\n return res\n\n def atleast_2d(self, *arys):\n res = []\n for ary in arys:\n ary = BlockArray.to_block_array(ary, self.cm)\n if ary.ndim == 0:\n result = ary.reshape(1, 1)\n\n # TODO (MWE): Implement this using newaxis when supported\n # This is because ary.base needs to stay consistent,\n # which reshape will not accomplish\n elif ary.ndim == 1:\n result = ary.reshape(1, ary.shape[0])\n else:\n result = ary\n res.append(result)\n if len(res) == 1:\n return res[0]\n else:\n return res\n\n def atleast_3d(self, *arys):\n res = []\n for ary in arys:\n ary = BlockArray.to_block_array(ary, self.cm)\n if ary.ndim == 0:\n result = ary.reshape(1, 1, 1)\n\n # TODO (MWE): Implement this using newaxis when supported\n # This is because ary.base needs to stay consistent,\n # which reshape will not accomplish\n elif ary.ndim == 1:\n result = ary.reshape(1, ary.shape[0], 1)\n elif ary.ndim == 2:\n result = ary.reshape(ary.shape[0], ary.shape[1], 1)\n else:\n result = ary\n res.append(result)\n if len(res) == 1:\n return res[0]\n else:\n return res\n\n def _check_or_covert_stack_array(self, arrs):\n if not isinstance(arrs, list):\n arrs = [arrs]\n return arrs\n\n def hstack(self, tup, axis_block_size=None):\n arrs = self._check_or_covert_stack_array(self.atleast_1d(*tup))\n # As a special case, dimension 0 of 1-dimensional arrays is \"horizontal\"\n if arrs and arrs[0].ndim == 1:\n return self.concatenate(arrs, 0, axis_block_size=axis_block_size)\n else:\n return self.concatenate(arrs, 1, axis_block_size=axis_block_size)\n\n def vstack(self, tup, axis_block_size=None):\n arrs = self._check_or_covert_stack_array(self.atleast_2d(*tup))\n return self.concatenate(arrs, 0, axis_block_size=axis_block_size)\n\n def dstack(self, tup, axis_block_size=None):\n arrs = self._check_or_covert_stack_array(self.atleast_3d(*tup))\n return self.concatenate(arrs, 2, axis_block_size=axis_block_size)\n\n def row_stack(self, tup, axis_block_size=None):\n return self.vstack(tup, axis_block_size=axis_block_size)\n\n def column_stack(self, tup, axis_block_size=None):\n # Based on numpy source.\n arrays = []\n for obj in tup:\n arr = BlockArray.to_block_array(obj, self.cm)\n if arr.ndim < 2:\n arrays.append(self.atleast_2d(arr).T)\n else:\n arrays.append(self.atleast_2d(arr))\n return self.concatenate(arrays, 1, axis_block_size=axis_block_size)\n"
] | [
[
"numpy.__getattribute__",
"numpy.product",
"numpy.ones_like",
"numpy.result_type",
"numpy.zeros_like",
"numpy.diff",
"numpy.array",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
kritikush/hub | [
"22b2f6f2539df760f77824f1f4c92a41007313de",
"22b2f6f2539df760f77824f1f4c92a41007313de"
] | [
"tfhub_dev/tools/validator.py",
"examples/mnist_export_v2/export.py"
] | [
"# Copyright 2020 The TensorFlow Hub 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\"\"\"Markdown documentation validator for published models.\n\n1) To validate selected files, run from the project root path:\n$ python tfhub_dev/tools/validator.py vtab/models/wae-ukl/1.md [other_files]\n\nThis will download and smoke test the model specified on asset-path metadata.\n\n2) To validate all documentation files, run from the project root path:\n$ python tfhub_dev/tools/validator.py\n\nThis does not download and smoke test the model.\n\n3) To validate files from outside the project root path, use the --root_dir\nflag:\n$ python tfhub_dev/tools/validator.py --root_dir=path_to_project_root\n\"\"\"\n\nimport abc\nimport argparse\nimport os\nimport re\nimport sys\nfrom absl import app\nfrom absl import logging\n\nimport tensorflow as tf\nimport tensorflow_hub as hub\n\n# pylint: disable=g-direct-tensorflow-import\nfrom tensorflow.python.saved_model import loader_impl\n# pylint: enable=g-direct-tensorflow-import\n\nFLAGS = None\n\n# Regex pattern for the first line of the documentation of Saved Models.\n# Example: \"Module google/universal-sentence-encoder/1\"\nMODEL_HANDLE_PATTERN = (\n r\"# Module (?P<publisher>[\\w-]+)/(?P<name>([\\w\\.-]+(/[\\w\\.-]+)*))/(?P<vers>\\d+)\") # pylint: disable=line-too-long\n# Regex pattern for the first line of the documentation of placeholder MD files.\n# Example: \"Placeholder google/universal-sentence-encoder/1\"\nPLACEHOLDER_HANDLE_PATTERN = (\n r\"# Placeholder \"\n r\"(?P<publisher>[\\w-]+)/(?P<name>([\\w\\.-]+(/[\\w\\.-]+)*))/(?P<vers>\\d+)\") # pylint: disable=line-too-long\n# Regex pattern for the first line of the documentation of TF Lite models.\n# Example: \"# Lite google/spice/1\"\nLITE_HANDLE_PATTERN = (\n r\"# Lite (?P<publisher>[\\w-]+)/(?P<name>([\\w\\.-]+(/[\\w\\.-]+)*))/(?P<vers>\\d+)\") # pylint: disable=line-too-long\n# Regex pattern for the first line of the documentation of TFJS models.\n# Example: \"# Tfjs google/spice/1/default/1\"\nTFJS_HANDLE_PATTERN = (\n r\"# Tfjs (?P<publisher>[\\w-]+)/(?P<name>([\\w\\.-]+(/[\\w\\.-]+)*))/(?P<vers>\\d+)\") # pylint: disable=line-too-long\n# Regex pattern for the first line of the documentation of Coral models.\n# Example: \"# Coral tensorflow/mobilenet_v2_1.0_224_quantized/1/default/1\"\nCORAL_HANDLE_PATTERN = (\n r\"# Coral (?P<publisher>[\\w-]+)/(?P<name>([\\w\\.-]+(/[\\w\\.-]+)*))/(?P<vers>\\d+)\") # pylint: disable=line-too-long\n# Regex pattern for the first line of the documentation of publishers.\n# Example: \"Publisher google\"\nPUBLISHER_HANDLE_PATTERN = r\"# Publisher (?P<publisher>[\\w-]+)\"\n# Regex pattern for the first line of the documentation of collections.\n# Example: \"Collection google/universal-sentence-encoders/1\"\nCOLLECTION_HANDLE_PATTERN = (\n r\"# Collection (?P<publisher>[\\w-]+)/(?P<name>(\\w|-|/|&|;|\\.)+)/(\\d+)\")\n# Regex pattern for the line of the documentation describing model metadata.\n# Example: \"<!-- finetunable: true -->\"\n# Note: Both key and value consumes free space characters, but later on these\n# are stripped.\nMETADATA_LINE_PATTERN = r\"^<!--(?P<key>(\\w|\\s|-)+):(?P<value>.+)-->$\"\n\n# Map a handle pattern to the corresponding model type name.\nHANDLE_PATTERN_TO_MODEL_TYPE = {\n MODEL_HANDLE_PATTERN: \"Module\",\n PLACEHOLDER_HANDLE_PATTERN: \"Placeholder\",\n LITE_HANDLE_PATTERN: \"Lite\",\n TFJS_HANDLE_PATTERN: \"Tfjs\",\n CORAL_HANDLE_PATTERN: \"Coral\"\n}\n\n\nclass Filesystem(object):\n \"\"\"Convenient (and mockable) file system access.\"\"\"\n\n def get_contents(self, filename):\n \"\"\"Returns file contents as a string.\"\"\"\n with tf.io.gfile.GFile(filename, \"r\") as f:\n return f.read()\n\n def file_exists(self, filename):\n \"\"\"Returns whether file exists.\"\"\"\n return tf.io.gfile.exists(filename)\n\n def recursive_list_dir(self, root_dir):\n \"\"\"Yields all files of a root directory tree.\"\"\"\n for dirname, _, filenames in tf.io.gfile.walk(root_dir):\n for filename in filenames:\n yield os.path.join(dirname, filename)\n\n\nclass MarkdownDocumentationError(Exception):\n \"\"\"Problem with markdown syntax parsing.\"\"\"\n\n\ndef smoke_test_model(model_path):\n try:\n resolved_model = hub.resolve(model_path)\n loader_impl.parse_saved_model(resolved_model)\n except Exception as e: # pylint: disable=broad-except\n return False, e\n return True, None\n\n\nclass ParsingPolicy(object):\n \"\"\"The base class for type specific parsing policy.\"\"\"\n __metaclass__ = abc.ABCMeta\n\n def __init__(self, publisher, model_name, model_version):\n self._publisher = publisher\n self._model_name = model_name\n self._model_version = model_version\n\n @property\n @abc.abstractmethod\n def type_name(self):\n \"\"\"Return readable name of the parsed type.\"\"\"\n\n @property\n def handle(self):\n return \"%s/%s/%s\" % (self._publisher, self._model_name, self._model_version)\n\n @property\n def publisher(self):\n return self._publisher\n\n def get_expected_location(self, root_dir):\n \"\"\"Returns the expected path of a documentation file.\"\"\"\n del root_dir\n return\n\n def get_top_level_dir(self, root_dir):\n \"\"\"Returns the top level publisher directory.\"\"\"\n return os.path.join(root_dir, self._publisher)\n\n def get_required_metadata(self):\n \"\"\"Return a list of required metadata for this type.\"\"\"\n return list()\n\n def get_single_valued_metadata(self):\n \"\"\"Return a list of metadata attaining only one value for this type.\"\"\"\n return list()\n\n def asset_tester(self):\n \"\"\"Return a function that smoke tests an asset.\n\n This function takes asset path on input and returns a tuple\n (passed, reason), where passed==True iff the asset passes a smoke test and\n reason is None for passed==True, or reason for failing if passed==False.\n\n Returns:\n A function that smoke tests an asset.\n \"\"\"\n return lambda _: True, None\n\n\nclass ModelParsingPolicy(ParsingPolicy):\n \"\"\"ParsingPolicy for model documentation.\"\"\"\n\n def __init__(self, publisher, model_name, model_version, model_type):\n super(ModelParsingPolicy, self).__init__(publisher, model_name,\n model_version)\n self._model_type = model_type\n if self._model_type == \"Module\":\n self._metadata_properties = [\n \"asset-path\", \"module-type\", \"fine-tunable\", \"format\"\n ]\n elif self._model_type == \"Placeholder\":\n self._metadata_properties = [\"module-type\"]\n elif self._model_type in (\"Lite\", \"Tfjs\", \"Coral\"):\n self._metadata_properties = [\"asset-path\", \"parent-model\"]\n else:\n self.raise_error(\"Unexpected model type: %s\", self._model_type)\n\n def type_name(self):\n return self._model_type\n\n def get_required_metadata(self):\n return self._metadata_properties\n\n def get_single_valued_metadata(self):\n return self._metadata_properties\n\n def asset_tester(self):\n return smoke_test_model\n\n\nclass PublisherParsingPolicy(ParsingPolicy):\n \"\"\"ParsingPolicy for publisher documentation.\"\"\"\n\n def type_name(self):\n return \"Publisher\"\n\n @property\n def handle(self):\n return self._publisher\n\n def get_expected_location(self, root_dir):\n return os.path.join(root_dir, self._publisher, self._publisher + \".md\")\n\n\nclass CollectionParsingPolicy(ParsingPolicy):\n \"\"\"ParsingPolicy for collection documentation.\"\"\"\n\n def type_name(self):\n return \"Collection\"\n\n def get_required_metadata(self):\n return [\"module-type\"]\n\n\nclass DocumentationParser(object):\n \"\"\"Class used for parsing model documentation strings.\"\"\"\n\n def __init__(self, documentation_dir, filesystem):\n self._documentation_dir = documentation_dir\n self._filesystem = filesystem\n self._parsed_metadata = dict()\n self._parsed_description = \"\"\n\n @property\n def parsed_description(self):\n return self._parsed_description\n\n @property\n def parsed_metadata(self):\n return self._parsed_metadata\n\n def raise_error(self, message):\n message_with_file = \"Error at file %s: %s\" % (self._file_path, message)\n raise MarkdownDocumentationError(message_with_file)\n\n def consume_first_line(self):\n \"\"\"Consume first line describing the model type and handle.\"\"\"\n first_line = self._lines[0].replace(\"‌\", \"\")\n patterns_and_policies = [\n (MODEL_HANDLE_PATTERN, ModelParsingPolicy),\n (PLACEHOLDER_HANDLE_PATTERN, ModelParsingPolicy),\n (LITE_HANDLE_PATTERN, ModelParsingPolicy),\n (TFJS_HANDLE_PATTERN, ModelParsingPolicy),\n (CORAL_HANDLE_PATTERN, ModelParsingPolicy),\n (PUBLISHER_HANDLE_PATTERN, PublisherParsingPolicy),\n (COLLECTION_HANDLE_PATTERN, CollectionParsingPolicy),\n ]\n for pattern, policy in patterns_and_policies:\n match = re.match(pattern, first_line)\n if not match:\n continue\n groups = match.groupdict()\n if policy == ModelParsingPolicy:\n self._parsing_policy = policy(\n groups.get(\"publisher\"), groups.get(\"name\"), groups.get(\"vers\"),\n HANDLE_PATTERN_TO_MODEL_TYPE[pattern])\n else:\n self._parsing_policy = policy(\n groups.get(\"publisher\"), groups.get(\"name\"), groups.get(\"vers\"))\n return\n self.raise_error(\n \"First line of the documentation file must match one of the following \"\n \"formats depending on the MD type:\\n\"\n \"TF Model: %s\\n\"\n \"TFJS: %s\\n\"\n \"Lite: %s\\n\"\n \"Coral: %s\\n\"\n \"Publisher: %s\\n\"\n \"Collection: %s\\n\"\n \"Placeholder: %s\\n\"\n \"For example \\\"# Module google/text-embedding-model/1\\\". Instead the \"\n \"first line is \\\"%s\\\".\" %\n (MODEL_HANDLE_PATTERN, TFJS_HANDLE_PATTERN, LITE_HANDLE_PATTERN,\n CORAL_HANDLE_PATTERN, PUBLISHER_HANDLE_PATTERN,\n COLLECTION_HANDLE_PATTERN, PLACEHOLDER_HANDLE_PATTERN, first_line))\n\n def assert_publisher_page_exists(self):\n \"\"\"Assert that publisher page exists for the publisher of this model.\"\"\"\n # Use a publisher policy to get the expected documentation page path.\n publisher_policy = PublisherParsingPolicy(self._parsing_policy.publisher,\n self._parsing_policy.publisher,\n None)\n expected_publisher_doc_location = publisher_policy.get_expected_location(\n self._documentation_dir)\n if not self._filesystem.file_exists(expected_publisher_doc_location):\n self.raise_error(\n \"Publisher documentation does not exist. It should be added to %s.\" %\n expected_publisher_doc_location)\n\n def assert_correct_location(self):\n \"\"\"Assert that documentation file is submitted to a correct location.\"\"\"\n expected_file_path = self._parsing_policy.get_expected_location(\n self._documentation_dir)\n # Exact location must be enforced for some types (publishers).\n if expected_file_path and self._file_path != expected_file_path:\n self.raise_error(\n \"Documentation file is not on a correct path. Documentation for a \"\n \"%s with handle \\\"%s\\\" should be submitted to \\\"%s\\\" \" %\n (self._parsing_policy.type_name, self._parsing_policy.handle,\n expected_file_path))\n\n publisher_dir = self._parsing_policy.get_top_level_dir(\n self._documentation_dir)\n if not self._file_path.startswith(publisher_dir + \"/\"):\n self.raise_error(\n \"Documentation file is not on a correct path. Documentation for a \"\n \"%s with handle \\\"%s\\\" should be placed in the publisher \"\n \"directory: \\\"%s\\\"\" % (self._parsing_policy.type_name,\n self._parsing_policy.handle, publisher_dir))\n\n if not self._file_path.endswith(\".md\"):\n self.raise_error(\"Documentation file does not end with \\\".md\\\": %s\" %\n self._file_path)\n\n def consume_description(self):\n \"\"\"Consume second line with a short model description.\"\"\"\n first_description_line = self._lines[1]\n if not first_description_line:\n self.raise_error(\n \"Second line of the documentation file has to contain a short \"\n \"description. For example \\\"Word2vec text embedding model.\\\".\")\n self._parsed_description = self._lines[1]\n self._current_index = 2\n while self._lines[self._current_index] and not self._lines[\n self._current_index].startswith(\"<!--\"):\n self._parsed_description += \" \" + self._lines[self._current_index]\n self._current_index += 1\n\n def consume_metadata(self):\n \"\"\"Consume all metadata.\"\"\"\n while self._current_index < len(\n self._lines) and (not self._lines[self._current_index].startswith(\"#\")):\n if not self._lines[self._current_index]:\n # Empty line is ok.\n self._current_index += 1\n continue\n match = re.match(METADATA_LINE_PATTERN, self._lines[self._current_index])\n if match:\n # Add found metadata.\n groups = match.groupdict()\n key = groups.get(\"key\").strip()\n value = groups.get(\"value\").strip()\n if key not in self._parsed_metadata:\n self._parsed_metadata[key] = set()\n self._parsed_metadata[key].add(value)\n self._current_index += 1\n continue\n if self._lines[self._current_index].startswith(\"[![Icon URL]]\"):\n # Icon for publishers.\n self._current_index += 1\n continue\n if self._lines[self._current_index].startswith(\n \"[![Open Colab notebook]]\"):\n # Colab.\n self._current_index += 1\n continue\n # Not an empty line and not expected metadata.\n self.raise_error(\n \"Unexpected line found: \\\"%s\\\". Please refer to [README.md]\"\n \"(https://github.com/tensorflow/hub/blob/master/tensorflow_hub\"\n \"/tfhub_dev/README.md) for information about markdown format.\" %\n self._lines[self._current_index])\n\n def assert_correct_metadata(self):\n \"\"\"Assert that all required metadata is present.\"\"\"\n required_metadata = set(self._parsing_policy.get_required_metadata())\n provided_metadata = set(self._parsed_metadata.keys())\n if not provided_metadata.issuperset(required_metadata):\n self.raise_error(\n \"The MD file is missing the following required metadata properties: \"\n \"%s. Please refer to README.md for information about markdown \"\n \"format.\" % sorted(required_metadata.difference(provided_metadata)))\n\n duplicate_metadata = list()\n for key, values in self._parsed_metadata.items():\n if key in self._parsing_policy.get_single_valued_metadata(\n ) and len(values) > 1:\n duplicate_metadata.append(key)\n if duplicate_metadata:\n self.raise_error(\n \"There are duplicate metadata values. Please refer to \"\n \"README.md for information about markdown format. In particular the \"\n \"duplicated metadata are: %s\" % sorted(duplicate_metadata))\n\n if \"module-type\" in self._parsed_metadata:\n allowed_prefixes = [\"image-\", \"text-\", \"audio-\", \"video-\"]\n for value in self._parsed_metadata[\"module-type\"]:\n if all([not value.startswith(prefix) for prefix in allowed_prefixes]):\n self.raise_error(\n \"The \\\"module-type\\\" metadata has to start with any of \\\"image-\\\"\"\n \", \\\"text\\\", \\\"audio-\\\", \\\"video-\\\", but is: \\\"%s\\\"\" % value)\n\n def assert_allowed_license(self):\n \"\"\"Validate provided license.\"\"\"\n if \"license\" in self._parsed_metadata:\n license_id = list(self._parsed_metadata[\"license\"])[0]\n allowed_license_ids = [\n \"Apache-2.0\", \"BSD-3-Clause\", \"BSD-2-Clause\", \"GPL-2.0\", \"GPL-3.0\",\n \"LGPL-2.0\", \"LGPL-2.1\", \"LGPL-3.0\", \"MIT\", \"MPL-2.0\", \"CDDL-1.0\",\n \"EPL-2.0\", \"custom\"\n ]\n if license_id not in allowed_license_ids:\n self.raise_error(\n \"The license %s provided in metadata is not allowed. Please \"\n \"specify a license id from list of allowed ids: [%s]. Example: \"\n \"<!-- license: Apache-2.0 -->\" % (license_id, allowed_license_ids))\n\n def smoke_test_asset(self):\n \"\"\"Smoke test asset provided on asset-path metadata.\"\"\"\n if \"asset-path\" not in self._parsed_metadata:\n return\n if self._parsing_policy.type_name() != \"Module\":\n return\n asset_path = list(self._parsed_metadata[\"asset-path\"])[0]\n asset_tester = self._parsing_policy.asset_tester()\n passed, reason = asset_tester(asset_path)\n if not passed:\n self.raise_error(\n \"The model on path %s failed to parse. Please make sure that the \"\n \"asset-path metadata points to a valid TF2 SavedModel or a TF1 Hub \"\n \"module, compressed as described in section \\\"Model\\\" of \"\n \"README.md. Underlying reason for failure: %s.\" %\n (asset_path, reason))\n\n def validate(self, file_path, do_smoke_test):\n \"\"\"Validate one documentation markdown file.\"\"\"\n self._raw_content = self._filesystem.get_contents(file_path)\n self._lines = self._raw_content.split(\"\\n\")\n self._file_path = file_path\n self.consume_first_line()\n self.assert_correct_location()\n self.consume_description()\n self.consume_metadata()\n self.assert_correct_metadata()\n self.assert_allowed_license()\n self.assert_publisher_page_exists()\n if do_smoke_test:\n self.smoke_test_asset()\n\n\ndef validate_documentation_files(documentation_dir,\n files_to_validate=None,\n filesystem=Filesystem()):\n \"\"\"Validate documentation files in a directory.\"\"\"\n file_paths = list(filesystem.recursive_list_dir(documentation_dir))\n do_smoke_test = bool(files_to_validate)\n validated = 0\n for file_path in file_paths:\n if files_to_validate and file_path[len(documentation_dir) +\n 1:] not in files_to_validate:\n continue\n logging.info(\"Validating %s.\", file_path)\n documentation_parser = DocumentationParser(documentation_dir, filesystem)\n documentation_parser.validate(file_path, do_smoke_test)\n validated += 1\n logging.info(\"Found %d matching files - all validated successfully.\",\n validated)\n if not do_smoke_test:\n logging.info(\n \"No models were smoke tested. To download and smoke test a specific \"\n \"model, specify files directly in the command line, for example: \"\n \"\\\"python tfhub_dev/tools/validator.py vtab/models/wae-ukl/1.md\\\"\")\n return validated\n\n\ndef main(_):\n root_dir = FLAGS.root_dir or os.getcwd()\n documentation_dir = os.path.join(root_dir, \"tfhub_dev\", \"assets\")\n logging.info(\"Using %s for documentation directory.\", documentation_dir)\n\n files_to_validate = None\n if FLAGS.file:\n files_to_validate = FLAGS.file\n logging.info(\"Going to validate files %s in documentation directory %s.\",\n files_to_validate, documentation_dir)\n else:\n logging.info(\"Going to validate all files in documentation directory %s.\",\n documentation_dir)\n\n validate_documentation_files(\n documentation_dir=documentation_dir, files_to_validate=files_to_validate)\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"file\",\n type=str,\n default=None,\n help=(\"Path to files to validate. Path is relative to `--root_dir`. \"\n \"The model will be smoke tested only for files specified by this \"\n \"flag.\"),\n nargs=\"*\")\n parser.add_argument(\n \"--root_dir\",\n type=str,\n default=None,\n help=(\"Root directory that contains documentation files under \"\n \"./tfhub_dev/assets. Defaults to current directory.\"))\n FLAGS, unparsed = parser.parse_known_args()\n app.run(main=main, argv=[sys.argv[0]] + unparsed)\n",
"# Copyright 2019 The TensorFlow Hub 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# ==============================================================================\nr\"\"\"Example for exporting a MNIST classifier in SavedModel v2.0 format.\n\nThe module has as a single signature, accepting a batch of images with shape\n[None, 28, 28, 1] and returning a prediction vector.\nIn this example, we are loading the MNIST Dataset from TFDS and training a\nsimple digit classifier.\n\nFor a more realistic exporting example, see:\ntensorflow/examples/saved_model/integration_tests/export_mnist_cnn.py.\n\"\"\"\n\nimport argparse\nimport logging\nimport sys\n\nimport tensorflow.compat.v2 as tf\nimport tensorflow_datasets as tfds\n\nFLAGS = None\n\n\nclass MNIST(tf.keras.models.Model):\n \"\"\"Model representing a MNIST classifier.\"\"\"\n\n def __init__(self, output_activation=\"softmax\"):\n super(MNIST, self).__init__()\n self.layer_1 = tf.keras.layers.Dense(64)\n self.layer_2 = tf.keras.layers.Dense(10, activation=output_activation)\n\n def call(self, inputs):\n casted = tf.keras.layers.Lambda(lambda x: tf.cast(x, tf.float32))(inputs)\n flatten = tf.keras.layers.Flatten()(casted)\n\n def normalize_fn(x):\n return x / tf.reduce_max(tf.gather(x, 0))\n\n normalize = tf.keras.layers.Lambda(normalize_fn)(flatten)\n x = self.layer_1(normalize)\n output = self.layer_2(x)\n return output\n\n\ndef train_step(model, loss_fn, optimizer_fn, metric, image, label):\n \"\"\"Perform one training step for the model.\n\n Args:\n model: Keras model to train.\n loss_fn: Loss function to use.\n optimizer_fn: Optimizer function to use.\n metric: keras.metric to use.\n image: Tensor of training images of shape [batch_size, 28, 28, 1].\n label: Tensor of class labels of shape [batch_size].\n \"\"\"\n with tf.GradientTape() as tape:\n preds = model(image)\n label_onehot = tf.one_hot(label, 10)\n loss_ = loss_fn(label_onehot, preds)\n grads = tape.gradient(loss_, model.trainable_variables)\n optimizer_fn.apply_gradients(zip(grads, model.trainable_variables))\n metric(loss_)\n\n\ndef train_and_export(export_path,\n buffer_size=1000,\n batch_size=32,\n learning_rate=1e-3,\n epoch=10,\n dataset=None):\n \"\"\"Trains and export the model as SavedModel 2.0.\n\n Args:\n export_path: (str) Path to export the trained model.\n buffer_size: (int) Size of buffer to use while shuffling.\n batch_size: (int) Size of each training batch.\n learning_rate: (float) Learning rate to use for the optimizer.\n epoch: (int) Number of Epochs to train for.\n dataset: (tf.data.Dataset) Dataset object. Defaults to a MNIST dataset.\n \"\"\"\n model = MNIST()\n if not dataset:\n dataset = tfds.load(\n \"mnist\", split=\"train\", batch_size=batch_size,\n shuffle_files=True).shuffle(\n buffer_size, reshuffle_each_iteration=True)\n\n optimizer_fn = tf.keras.optimizers.Adam(learning_rate=learning_rate)\n loss_fn = tf.keras.losses.CategoricalCrossentropy(from_logits=True)\n metric = tf.keras.metrics.Mean()\n model.compile(optimizer_fn, loss=loss_fn)\n\n # Training loop.\n for epoch in range(epoch):\n for step, data in enumerate(dataset):\n train_step(model, loss_fn, optimizer_fn, metric, data[\"image\"],\n data[\"label\"])\n print(\"\\rEpoch: #{}\\tStep: #{}\\tLoss: {}\\n\".format(\n epoch, step,\n metric.result().numpy()))\n\n # We have to call either predict or fit to make it possible to export with\n # tf.saved_model.save.\n model.predict(next(iter(dataset))[\"image\"])\n # Export the model as SavedModel 2.0.\n tf.saved_model.save(model, export_path)\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--export_path\",\n type=str,\n default=None,\n help=\"Path to export the module\")\n parser.add_argument(\n \"--buffer_size\",\n type=int,\n default=1000,\n help=\"Buffer Size to use while shuffling the dataset\")\n parser.add_argument(\n \"--batch_size\", type=int, default=32, help=\"Size of each batch\")\n parser.add_argument(\n \"--learning_rate\", type=float, default=1e-3, help=\"learning rate\")\n parser.add_argument(\n \"--epoch\", type=int, default=10, help=\"Number of iterations\")\n FLAGS, unparsed = parser.parse_known_args()\n\n if not FLAGS.export_path:\n logging.error(\"Must set flag --export_path.\")\n sys.exit(1)\n\n train_and_export(**vars(FLAGS))\n"
] | [
[
"tensorflow.io.gfile.exists",
"tensorflow.python.saved_model.loader_impl.parse_saved_model",
"tensorflow.io.gfile.GFile",
"tensorflow.io.gfile.walk"
],
[
"tensorflow.compat.v2.keras.layers.Flatten",
"tensorflow.compat.v2.keras.metrics.Mean",
"tensorflow.compat.v2.GradientTape",
"tensorflow.compat.v2.keras.layers.Dense",
"tensorflow.compat.v2.cast",
"tensorflow.compat.v2.keras.losses.CategoricalCrossentropy",
"tensorflow.compat.v2.keras.optimizers.Adam",
"tensorflow.compat.v2.one_hot",
"tensorflow.compat.v2.keras.layers.Lambda",
"tensorflow.compat.v2.gather",
"tensorflow.compat.v2.saved_model.save"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
JosephZheng1998/CNN-Emotion-Detection | [
"f56e99103be7a90a52b8ee51c8ae30cdd0051d5c"
] | [
"autoencoder/Training.py"
] | [
"import os\nimport numpy as np\nfrom PIL import Image\n\nimport torch\nimport torchvision\nfrom torchvision import transforms\nimport torchvision.models as models\nfrom torchvision.datasets import ImageFolder\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.nn.functional as F\nfrom torch.utils.data import Dataset, DataLoader, random_split\nfrom sklearn.metrics import roc_auc_score\nfrom IPython.display import Image\nfrom IPython.core.display import Image, display\nfrom torchvision.utils import save_image\nimport time\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport random\n\ndef preprocessing():\n batch_size = 64\n train_transform = transforms.Compose([\n transforms.RandomRotation(45),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n val_transform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n\n train_dataset = ImageFolder(root='train/', transform=train_transform)\n train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=16, pin_memory=True)\n\n dev_dataset = ImageFolder(root='val_test/val/', transform=val_transform)\n dev_loader = DataLoader(dev_dataset, batch_size=batch_size, shuffle=False, num_workers=16, pin_memory=True)\n\n test_dataset = ImageFolder(root='val_test/test/', transform=val_transform)\n test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=16, pin_memory=True)\n\n print('train dataset: {} images {} classes'.format(len(train_dataset), len(train_dataset.classes)))\n print('dev dataset: {} images {} classes'.format(len(dev_dataset), len(dev_dataset.classes)))\n print('test dataset: {} images {} classes'.format(len(test_dataset), len(test_dataset.classes)))\n\n return train_loader, dev_loader, test_loader\n\n# train the multitasking model\ndef train(model, train_loader, val_loader, recon_criterion, class_criterion, optimizer, scheduler, epochs, device):\n t_start = time.time()\n train_recon_losses = []\n train_class_losses = []\n train_accs = []\n val_class_losses = []\n val_recon_losses = []\n val_accs = []\n for epoch in range(epochs):\n model.train()\n running_recon_loss = 0\n running_class_loss = 0\n total = 0\n correct = 0\n for idx, (images, labels) in enumerate(train_loader):\n images, labels = images.to(device), labels.to(device)\n optimizer.zero_grad()\n features, idx_list = model.encoder.forward(images)\n output = model.classifier.forward(features)\n recon_images = model.decoder.forward(features, idx_list)\n class_loss = class_criterion(output, labels)\n recon_loss = recon_criterion(recon_images, images)\n total_loss = class_loss + 10*recon_loss\n total_loss.backward()\n #class_loss.backward()\n optimizer.step()\n preds = torch.argmax(output, dim=1)\n correct += (preds == labels).sum().item()\n running_recon_loss += float(recon_loss.item() * images.shape[0])\n running_class_loss += float(class_loss.item() * images.shape[0])\n total += images.shape[0]\n #recon_loss = 0\n del images\n del labels\n del recon_images\n del features\n del idx_list\n del output\n del recon_loss\n del class_loss\n del preds\n del total_loss\n torch.cuda.empty_cache()\n val_class_loss, val_recon_loss, val_acc = validate(model, val_loader, recon_criterion, class_criterion, device)\n val_total_loss = val_recon_loss + val_class_loss\n train_recon_loss = running_recon_loss/total\n train_class_loss = running_class_loss/total\n train_total_loss = train_recon_loss + train_class_loss\n train_acc = correct/total\n train_recon_losses.append(train_recon_loss)\n train_class_losses.append(train_class_loss)\n train_accs.append(train_acc)\n val_class_losses.append(val_class_loss)\n val_recon_losses.append(val_recon_loss)\n val_accs.append(val_acc)\n scheduler.step(val_class_loss)\n to_print = \"Epoch: {}/{}, Training Time:{:.2f}, Trained Samples: {}/{}, Train Total Loss: {:.5f}, Train Recon Loss: {:.5f}, Train Class Loss: {:.5f} Train Accuracy: {:.5f}, Val Total Loss: {:.5f}, Val Recon Loss: {:.5f}, Val Class Loss: {:.5f}, Val Accuracy: {:.5f}\".format(\n epoch+1, epochs, time.time()-t_start, total, len(train_loader.dataset), train_total_loss, train_recon_loss, train_class_loss, train_acc,\n val_total_loss, val_recon_loss, val_class_loss, val_acc)\n print(to_print)\n if (epoch+1) % 10 == 0:\n saved_model = {\n 'train_epochs': epoch + 1,\n 'model': model.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'recon_criterion': recon_criterion.state_dict(),\n 'class_criterion': class_criterion.state_dict(),\n 'scheduler': scheduler.state_dict(),\n 'train_class_losses': train_class_losses,\n 'train_recon_losses': train_recon_losses,\n 'train_accuracy': train_accs,\n 'valid_class_losses': val_class_losses,\n 'valid_accuracy': val_accs,\n 'val_recon_losses': val_recon_losses,\n }\n torch.save(saved_model, 'gdrive/MyDrive/complete_model{}'.format(epoch+1))\n return train_recon_losses, train_class_losses, train_accs, val_class_losses, val_recon_losses, val_accs\n\n# validate the multitasking model\ndef validate(model, val_loader, recon_criterion, class_criterion, device):\n model.eval()\n correct = 0\n total = 0\n running_recon_loss = 0\n running_class_loss = 0\n\n with torch.no_grad():\n for idx, (images, labels) in enumerate(val_loader):\n images, labels = images.to(device), labels.to(device)\n features, idx_list = model.encoder.forward(images)\n output = model.classifier.forward(features)\n recon_images = model.decoder.forward(features, idx_list)\n class_loss = class_criterion(output, labels)\n recon_loss = recon_criterion(recon_images, images)\n running_recon_loss += float(recon_loss.item() * labels.shape[0])\n running_class_loss += float(class_loss * labels.shape[0])\n total += labels.shape[0]\n preds = torch.argmax(output, dim=1)\n correct += (preds == labels).sum().item()\n \"\"\"\n print(correct)\n print(preds)\n print(labels)\n \"\"\"\n del images\n del labels\n del recon_images\n del features\n del idx_list\n del output\n del recon_loss\n del class_loss\n del preds\n torch.cuda.empty_cache()\n return running_class_loss/total, running_recon_loss/total, correct/total\n\n\n# only train the autoencoder part of the model\ndef pretrain(model, train_loader, val_loader, criterion, optimizer, scheduler, epochs, device):\n t_start = time.time()\n train_recon_losses = []\n val_recon_losses = []\n for epoch in range(epochs):\n model.train()\n running_recon_loss = 0\n total = 0\n for idx, (images, labels) in enumerate(train_loader):\n images, labels = images.to(device), labels.to(device)\n optimizer.zero_grad()\n features, idx_list = model.encoder.forward(images)\n recon_images = model.decoder.forward(features, idx_list)\n recon_loss = criterion(recon_images, images)\n recon_loss.backward()\n optimizer.step()\n running_recon_loss += float(recon_loss.item() * images.shape[0])\n total += images.shape[0]\n del images\n del labels\n del recon_images\n del features\n del idx_list\n del recon_loss\n torch.cuda.empty_cache()\n val_recon_loss = pre_validate(model, val_loader, criterion, device)\n train_recon_loss = running_recon_loss/total\n train_recon_losses.append(train_recon_loss)\n val_recon_losses.append(val_recon_loss)\n scheduler.step(val_recon_loss)\n to_print = \"Epoch: {}/{}, Training Time:{:.2f}, Trained Samples: {}/{}, Train Recon Loss: {:.5f}, Val Recon Loss: {:.5f}\".format(\n epoch+1, epochs, time.time()-t_start, total, len(train_loader.dataset), train_recon_loss,\n val_recon_loss)\n print(to_print)\n if epoch % 10 == 0:\n saved_model = {\n 'train_epochs': epoch + 1,\n 'model': model.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'recon_criterion': criterion.state_dict(),\n 'scheduler': scheduler.state_dict(),\n }\n torch.save(saved_model, 'gdrive/MyDrive/pre_model{}'.format(epoch))\n return train_recon_losses, val_recon_losses\n\n# only validate the autoencoder part of the model\ndef pre_validate(model, val_loader, recon_criterion, device):\n model.eval()\n total = 0\n running_recon_loss = 0\n with torch.no_grad():\n for idx, (images, labels) in enumerate(val_loader):\n images, labels = images.to(device), labels.to(device)\n features, idx_list = model.encoder.forward(images)\n recon_images = model.decoder.forward(features, idx_list)\n recon_loss = recon_criterion(recon_images, images)\n running_recon_loss += float(recon_loss.item() * labels.shape[0])\n total += images.shape[0]\n del images\n del labels\n del recon_images\n del features\n del idx_list\n del recon_loss\n torch.cuda.empty_cache()\n return running_recon_loss/total\n\n# only train the model's classifier\ndef train_class(model, train_loader, val_loader, criterion, optimizer, scheduler, epochs, device):\n t_start = time.time()\n train_class_losses = []\n train_accs = []\n val_class_losses = []\n val_accs = []\n for epoch in range(epochs):\n model.train()\n running_class_loss = 0\n total = 0\n correct = 0\n for idx, (images, labels) in enumerate(train_loader):\n images, labels = images.to(device), labels.to(device)\n optimizer.zero_grad()\n features, idx_list = model.encoder.forward(images)\n features = features.detach()\n output = model.classifier.forward(features)\n class_loss = criterion(output, labels)\n class_loss.backward()\n optimizer.step()\n preds = torch.argmax(output, dim=1)\n correct += (preds == labels).sum().item()\n running_class_loss += float(class_loss.item() * images.shape[0])\n total += images.shape[0]\n del images\n del labels\n del features\n del idx_list\n del output\n del class_loss\n del preds\n torch.cuda.empty_cache()\n val_class_loss, val_acc = validate_class(model, val_loader, criterion, device)\n train_class_loss = running_class_loss/total\n train_acc = correct/total\n train_class_losses.append(train_class_loss)\n train_accs.append(train_acc)\n val_class_losses.append(val_class_loss)\n val_accs.append(val_acc)\n scheduler.step(val_class_loss)\n to_print = \"Epoch: {}/{}, Training Time:{:.2f}, Trained Samples: {}/{}, Train Class Loss: {:.5f} Train Accuracy: {:.5f}, Val Class Loss: {:.5f}, Val Accuracy: {:.5f}\".format(\n epoch+1, epochs, time.time()-t_start, total, len(train_loader.dataset), train_class_loss, train_acc,\n val_class_loss, val_acc)\n print(to_print)\n if (epoch+1) % 10 == 0:\n saved_model = {\n 'train_epochs': epoch + 1,\n 'model': model.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'criterion': criterion.state_dict(),\n 'scheduler': scheduler.state_dict(),\n 'train_class_losses': train_class_losses,\n 'train_accuracy': train_accs,\n 'valid_class_losses': val_class_losses,\n 'valid_accuracy': val_accs,\n }\n torch.save(saved_model, 'gdrive/MyDrive/complete_model{}'.format(epoch+1))\n return train_class_losses, train_accs, val_class_losses, val_accs\n\n# only validate the model's classifier\ndef validate_class(model, val_loader, criterion, device):\n model.eval()\n correct = 0\n total = 0\n running_class_loss = 0\n\n with torch.no_grad():\n for idx, (images, labels) in enumerate(val_loader):\n images, labels = images.to(device), labels.to(device)\n features, idx_list = model.encoder.forward(images)\n features = features.detach()\n output = model.classifier.forward(features)\n class_loss = class_criterion(output, labels)\n running_class_loss += float(class_loss * labels.shape[0])\n total += labels.shape[0]\n preds = torch.argmax(output, dim=1)\n correct += (preds == labels).sum().item()\n \"\"\"\n print(correct)\n print(preds)\n print(labels)\n \"\"\"\n del images\n del labels\n del features\n del idx_list\n del output\n del class_loss\n del preds\n torch.cuda.empty_cache()\n return running_class_loss/total, correct/total\n\n\"\"\"# Training and Validating Function\"\"\"\n\n# train the multitasking model\ndef train(model, train_loader, val_loader, recon_criterion, class_criterion, optimizer, scheduler, epochs, device):\n t_start = time.time()\n train_recon_losses = []\n train_class_losses = []\n train_accs = []\n val_class_losses = []\n val_recon_losses = []\n val_accs = []\n for epoch in range(epochs):\n model.train()\n running_recon_loss = 0\n running_class_loss = 0\n total = 0\n correct = 0\n for idx, (images, labels) in enumerate(train_loader):\n images, labels = images.to(device), labels.to(device)\n optimizer.zero_grad()\n features, idx_list = model.encoder.forward(images)\n output = model.classifier.forward(features)\n recon_images = model.decoder.forward(features, idx_list)\n class_loss = class_criterion(output, labels)\n recon_loss = recon_criterion(recon_images, images)\n total_loss = class_loss + 10*recon_loss\n total_loss.backward()\n #class_loss.backward()\n optimizer.step()\n preds = torch.argmax(output, dim=1)\n correct += (preds == labels).sum().item()\n running_recon_loss += float(recon_loss.item() * images.shape[0])\n running_class_loss += float(class_loss.item() * images.shape[0])\n total += images.shape[0]\n #recon_loss = 0\n del images\n del labels\n del recon_images\n del features\n del idx_list\n del output\n del recon_loss\n del class_loss\n del preds\n del total_loss\n torch.cuda.empty_cache()\n val_class_loss, val_recon_loss, val_acc = validate(model, val_loader, recon_criterion, class_criterion, device)\n val_total_loss = val_recon_loss + val_class_loss\n train_recon_loss = running_recon_loss/total\n train_class_loss = running_class_loss/total\n train_total_loss = train_recon_loss + train_class_loss\n train_acc = correct/total\n train_recon_losses.append(train_recon_loss)\n train_class_losses.append(train_class_loss)\n train_accs.append(train_acc)\n val_class_losses.append(val_class_loss)\n val_recon_losses.append(val_recon_loss)\n val_accs.append(val_acc)\n scheduler.step(val_class_loss)\n to_print = \"Epoch: {}/{}, Training Time:{:.2f}, Trained Samples: {}/{}, Train Total Loss: {:.5f}, Train Recon Loss: {:.5f}, Train Class Loss: {:.5f} Train Accuracy: {:.5f}, Val Total Loss: {:.5f}, Val Recon Loss: {:.5f}, Val Class Loss: {:.5f}, Val Accuracy: {:.5f}\".format(\n epoch+1, epochs, time.time()-t_start, total, len(train_loader.dataset), train_total_loss, train_recon_loss, train_class_loss, train_acc,\n val_total_loss, val_recon_loss, val_class_loss, val_acc)\n print(to_print)\n if (epoch+1) % 10 == 0:\n saved_model = {\n 'train_epochs': epoch + 1,\n 'model': model.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'recon_criterion': recon_criterion.state_dict(),\n 'class_criterion': class_criterion.state_dict(),\n 'scheduler': scheduler.state_dict(),\n 'train_class_losses': train_class_losses,\n 'train_recon_losses': train_recon_losses,\n 'train_accuracy': train_accs,\n 'valid_class_losses': val_class_losses,\n 'valid_accuracy': val_accs,\n 'val_recon_losses': val_recon_losses,\n }\n torch.save(saved_model, 'gdrive/MyDrive/complete_model{}'.format(epoch+1))\n return train_recon_losses, train_class_losses, train_accs, val_class_losses, val_recon_losses, val_accs\n\n# validate the multitasking model\ndef validate(model, val_loader, recon_criterion, class_criterion, device):\n model.eval()\n correct = 0\n total = 0\n running_recon_loss = 0\n running_class_loss = 0\n\n with torch.no_grad():\n for idx, (images, labels) in enumerate(val_loader):\n images, labels = images.to(device), labels.to(device)\n features, idx_list = model.encoder.forward(images)\n output = model.classifier.forward(features)\n recon_images = model.decoder.forward(features, idx_list)\n class_loss = class_criterion(output, labels)\n recon_loss = recon_criterion(recon_images, images)\n running_recon_loss += float(recon_loss.item() * labels.shape[0])\n running_class_loss += float(class_loss * labels.shape[0])\n total += labels.shape[0]\n preds = torch.argmax(output, dim=1)\n correct += (preds == labels).sum().item()\n \"\"\"\n print(correct)\n print(preds)\n print(labels)\n \"\"\"\n del images\n del labels\n del recon_images\n del features\n del idx_list\n del output\n del recon_loss\n del class_loss\n del preds\n torch.cuda.empty_cache()\n return running_class_loss/total, running_recon_loss/total, correct/total\n\n# only train the autoencoder part of the model\ndef pretrain(model, train_loader, val_loader, criterion, optimizer, scheduler, epochs, device):\n t_start = time.time()\n train_recon_losses = []\n val_recon_losses = []\n for epoch in range(epochs):\n model.train()\n running_recon_loss = 0\n total = 0\n for idx, (images, labels) in enumerate(train_loader):\n images, labels = images.to(device), labels.to(device)\n optimizer.zero_grad()\n features, idx_list = model.encoder.forward(images)\n recon_images = model.decoder.forward(features, idx_list)\n recon_loss = criterion(recon_images, images)\n recon_loss.backward()\n optimizer.step()\n running_recon_loss += float(recon_loss.item() * images.shape[0])\n total += images.shape[0]\n del images\n del labels\n del recon_images\n del features\n del idx_list\n del recon_loss\n torch.cuda.empty_cache()\n val_recon_loss = pre_validate(model, val_loader, criterion, device)\n train_recon_loss = running_recon_loss/total\n train_recon_losses.append(train_recon_loss)\n val_recon_losses.append(val_recon_loss)\n scheduler.step(val_recon_loss)\n to_print = \"Epoch: {}/{}, Training Time:{:.2f}, Trained Samples: {}/{}, Train Recon Loss: {:.5f}, Val Recon Loss: {:.5f}\".format(\n epoch+1, epochs, time.time()-t_start, total, len(train_loader.dataset), train_recon_loss,\n val_recon_loss)\n print(to_print)\n if epoch % 10 == 0:\n saved_model = {\n 'train_epochs': epoch + 1,\n 'model': model.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'recon_criterion': criterion.state_dict(),\n 'scheduler': scheduler.state_dict(),\n }\n torch.save(saved_model, 'gdrive/MyDrive/pre_model{}'.format(epoch))\n return train_recon_losses, val_recon_losses\n\n# only validate the autoencoder part of the model\ndef pre_validate(model, val_loader, recon_criterion, device):\n model.eval()\n total = 0\n running_recon_loss = 0\n with torch.no_grad():\n for idx, (images, labels) in enumerate(val_loader):\n images, labels = images.to(device), labels.to(device)\n features, idx_list = model.encoder.forward(images)\n recon_images = model.decoder.forward(features, idx_list)\n recon_loss = recon_criterion(recon_images, images)\n running_recon_loss += float(recon_loss.item() * labels.shape[0])\n total += images.shape[0]\n del images\n del labels\n del recon_images\n del features\n del idx_list\n del recon_loss\n torch.cuda.empty_cache()\n return running_recon_loss/total\n\n# only train the model's classifier\ndef train_class(model, train_loader, val_loader, criterion, optimizer, scheduler, epochs, device):\n t_start = time.time()\n train_class_losses = []\n train_accs = []\n val_class_losses = []\n val_accs = []\n for epoch in range(epochs):\n model.train()\n running_class_loss = 0\n total = 0\n correct = 0\n for idx, (images, labels) in enumerate(train_loader):\n images, labels = images.to(device), labels.to(device)\n optimizer.zero_grad()\n features, idx_list = model.encoder.forward(images)\n features = features.detach()\n output = model.classifier.forward(features)\n class_loss = criterion(output, labels)\n class_loss.backward()\n optimizer.step()\n preds = torch.argmax(output, dim=1)\n correct += (preds == labels).sum().item()\n running_class_loss += float(class_loss.item() * images.shape[0])\n total += images.shape[0]\n del images\n del labels\n del features\n del idx_list\n del output\n del class_loss\n del preds\n torch.cuda.empty_cache()\n val_class_loss, val_acc = validate_class(model, val_loader, criterion, device)\n train_class_loss = running_class_loss/total\n train_acc = correct/total\n train_class_losses.append(train_class_loss)\n train_accs.append(train_acc)\n val_class_losses.append(val_class_loss)\n val_accs.append(val_acc)\n scheduler.step(val_class_loss)\n to_print = \"Epoch: {}/{}, Training Time:{:.2f}, Trained Samples: {}/{}, Train Class Loss: {:.5f} Train Accuracy: {:.5f}, Val Class Loss: {:.5f}, Val Accuracy: {:.5f}\".format(\n epoch+1, epochs, time.time()-t_start, total, len(train_loader.dataset), train_class_loss, train_acc,\n val_class_loss, val_acc)\n print(to_print)\n if (epoch+1) % 10 == 0:\n saved_model = {\n 'train_epochs': epoch + 1,\n 'model': model.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'criterion': criterion.state_dict(),\n 'scheduler': scheduler.state_dict(),\n 'train_class_losses': train_class_losses,\n 'train_accuracy': train_accs,\n 'valid_class_losses': val_class_losses,\n 'valid_accuracy': val_accs,\n }\n torch.save(saved_model, 'gdrive/MyDrive/complete_model{}'.format(epoch+1))\n return train_class_losses, train_accs, val_class_losses, val_accs\n\n# only validate the model's classifier\ndef validate_class(model, val_loader, criterion, device):\n model.eval()\n correct = 0\n total = 0\n running_class_loss = 0\n\n with torch.no_grad():\n for idx, (images, labels) in enumerate(val_loader):\n images, labels = images.to(device), labels.to(device)\n features, idx_list = model.encoder.forward(images)\n features = features.detach()\n output = model.classifier.forward(features)\n class_loss = class_criterion(output, labels)\n running_class_loss += float(class_loss * labels.shape[0])\n total += labels.shape[0]\n preds = torch.argmax(output, dim=1)\n correct += (preds == labels).sum().item()\n \"\"\"\n print(correct)\n print(preds)\n print(labels)\n \"\"\"\n del images\n del labels\n del features\n del idx_list\n del output\n del class_loss\n del preds\n torch.cuda.empty_cache()\n return running_class_loss/total, correct/total\n\nif __name__ == '__main__':\n splitfolders.ratio('test', output='val_test', seed=1337, ratio=(0, 0.5, 0.5), group_prefix=None)\n\n # check for GPU\n cuda = torch.cuda.is_available()\n device = torch.device('cuda' if cuda else 'cpu')\n print(device)\n\n train_loader, dev_loader, test_loader = preprocessing()\n\n \"\"\"# Dimensionality Reduction \"\"\"\n\n model = AutoClassifier()\n model.to(device)\n\n criterion = nn.MSELoss()\n epochs = 80\n optimizer = torch.optim.Adam(model.parameters(), lr=5e-2)\n scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.75, patience=2, verbose=True)\n\n # train the encoder and decoder\n pre_train_loss, pre_val_loss = pretrain(model, train_loader, dev_loader, criterion, optimizer, scheduler, epochs, device)\n\n make_plots(pre_train_loss, pre_val_loss, \"Autoencoder\", \"Loss\")\n\n #compare the reconstructed image with the original image\n fixed_x = train_dataset[random.randint(1,100)][0].unsqueeze(0).to(device)\n compare_x = compare(fixed_x)\n\n save_image(compare_x.data.cpu(), 'sample_image.png')\n display(Image('sample_image.png', width=700, unconfined=True))\n\n class_criterion = nn.CrossEntropyLoss()\n optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.75, patience=2, verbose=True)\n epoch = 80\n\n train_class_losses, train_accs, val_class_losses, val_accs = train_class(model, train_loader, dev_loader, class_criterion, optimizer, scheduler, epochs, device)\n\n make_plots(train_accs, val_accs, \"Classifier\", \"Accuracy\")\n\n \"\"\"# Train and Test the Multitasking Model\"\"\"\n\n model = AutoClassifier()\n model.to(device)\n\n recon_criterion = nn.MSELoss()\n class_criterion = nn.CrossEntropyLoss()\n optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.75, patience=2, verbose=True)\n epochs = 100\n\n train_recon_losses, train_class_losses, train_accs, val_class_losses, val_recon_losses, val_accs = train(model, train_loader, dev_loader, recon_criterion, class_criterion, optimizer, scheduler, epochs, device)\n\n _, _, test_acc = validate(model, test_loader, recon_criterion, class_criterion, device)\n"
] | [
[
"torch.nn.CrossEntropyLoss",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"torch.utils.data.DataLoader",
"torch.cuda.empty_cache",
"torch.no_grad",
"torch.cuda.is_available",
"torch.device",
"torch.nn.MSELoss",
"torch.argmax"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mingyangzhang/CCGAD | [
"52568aa7892f23c25d516022d27e0bb41b53a6cf"
] | [
"utils/graph_utils.py"
] | [
"import numpy as np\nimport scipy.sparse as sp\n\nnp.random.seed(0)\n\n\ndef nx_sample_neighbor(nx_g, start_node):\n\n neighbors = [nd for nd in nx_g.neighbors(start_node)]\n return np.random.choice(neighbors, size=1)[0]\n\n\ndef random_walk_with_restart(g, node_idx, restart_prob, length):\n trace = [node_idx]\n start_node = node_idx\n for _ in range(length):\n sampled_node = nx_sample_neighbor(g, start_node)\n if np.random.rand() < restart_prob:\n start_node = node_idx\n else:\n start_node = sampled_node\n trace.append(sampled_node)\n return trace\n\n\ndef rwr_sample_subgraph(g, node_idx, subgraph_size, max_try=5):\n\n neighbors = random_walk_with_restart(g, node_idx, restart_prob=1.0, length=subgraph_size*3)\n neighbors = [nd for nd in neighbors if nd>=0 and nd!=node_idx]\n neighbors = np.unique(neighbors).tolist()\n if len(neighbors) > subgraph_size - 1:\n neighbors = neighbors[:subgraph_size-1]\n else:\n retry_time = 0\n while(retry_time<max_try):\n new_nbrs = random_walk_with_restart(g, node_idx, restart_prob=0.9, length=subgraph_size*5)\n new_nbrs = [nd for nd in new_nbrs if nd>0 and nd!=node_idx]\n neighbors = np.unique(neighbors + new_nbrs).tolist()\n if len(neighbors) >= subgraph_size - 1:\n neighbors = neighbors[:subgraph_size-1]\n break\n retry_time += 1\n return [node_idx] + neighbors\n\n\ndef normalize_adj(adj):\n \"\"\"Symmetrically normalize adjacency matrix.\"\"\"\n\n adj = sp.coo_matrix(adj)\n rowsum = np.array(adj.sum(1))\n d_inv_sqrt = np.power(rowsum, -0.5).flatten()\n d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0.\n d_mat_inv_sqrt = sp.diags(d_inv_sqrt)\n return adj.dot(d_mat_inv_sqrt).transpose().dot(d_mat_inv_sqrt).todense()"
] | [
[
"scipy.sparse.coo_matrix",
"numpy.random.seed",
"numpy.random.choice",
"numpy.unique",
"numpy.power",
"scipy.sparse.diags",
"numpy.random.rand",
"numpy.isinf"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"1.3",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"0.16",
"1.8"
],
"tensorflow": []
}
] |
s-shailja/challenge-iclr-2021 | [
"28ad9d126597166bc41715f77c8cf366b8fba975"
] | [
"mihaelanistor/metrics/grassmannian/chordal_distance_2norm.py"
] | [
"from abc import ABC\n\nimport numpy as np\nfrom geomstats.geometry.grassmannian import GrassmannianCanonicalMetric\n\n\nclass GrassmannianChordal2NormMetric(GrassmannianCanonicalMetric, ABC):\n\tdef __init__(self, n, p):\n\t\tsuper().__init__(n, p)\n\n\tdef dist(self, point_a, point_b):\n\t\t\"\"\"Chordal 2-norm distance between two points.\n\t\tParameters\n\t\t----------\n\t\tpoint_a : array-like, shape=[..., dim]\n\t\t\tPoint.\n\t\tpoint_b : array-like, shape=[..., dim]\n\t\t\tPoint.\n\t\tReturns\n\t\t-------\n\t\tdist : array-like, shape=[...,]\n\t\t\tDistance.\n\t\t\"\"\"\n\n\t\toutput = np.sqrt(self.p - np.round(np.square(np.linalg.norm(np.dot(point_a.T, point_b), 2)), 4))\n\n\t\treturn output"
] | [
[
"numpy.dot"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
RaulRPrado/ctamclib | [
"ed18de64724deec403ed5ee06971c377562331ef"
] | [
"simtools/ray_tracing.py"
] | [
"import logging\nimport subprocess\nimport matplotlib.pyplot as plt\nfrom copy import copy\nfrom pathlib import Path\nfrom math import pi, tan\n\nimport numpy as np\nimport astropy.units as u\nfrom astropy.io import ascii\nfrom astropy.table import QTable\n\nimport simtools.config as cfg\nimport simtools.io_handler as io\nimport simtools.util.general as gen\nfrom simtools.psf_analysis import PSFImage\nfrom simtools.util import names\nfrom simtools.util.model import computeTelescopeTransmission\nfrom simtools.model.telescope_model import TelescopeModel\nfrom simtools.simtel.simtel_runner_ray_tracing import SimtelRunnerRayTracing\nfrom simtools import visualize\n\n__all__ = [\"RayTracing\"]\n\n\nclass RayTracing:\n \"\"\"\n Class for handling ray tracing simulations and analysis.\n\n Configurable parameters:\n zenithAngle:\n len: 1\n unit: deg\n default: 20 deg\n offAxisAngle:\n len: null\n unit: deg\n default: [0 deg]\n sourceDistance:\n len: 1\n unit: km\n default: 10 km\n singleMirrorMode:\n len: 1\n default: False\n useRandomFocalLength:\n len: 1\n default: False\n mirrorNumbers:\n len: null\n default: 'all'\n\n Attributes\n ----------\n label: str\n Instance label.\n config: namedtuple\n Contains the configurable parameters (zenithAngle).\n\n Methods\n -------\n simulate(test=False, force=False)\n Simulate RayTracing using SimtelRunnerRayTracing.\n analyse(export=True, force=False, useRX=False, noTelTransmission=False)\n Analyze RayTracing, meaning read simtel files, compute psfs and eff areas and store the\n results in _results.\n exportResults()\n Export results to a csv file.\n plot(key, **kwargs)\n Plot key vs off-axis angle.\n plotHistogram(key, **kwargs)\n Plot histogram of key (d80_cm, d80_deg, eff_area, eff_flen).\n getMean(key)\n Get mean value of key(d80_cm, d80_deg, eff_area, eff_flen).\n getStdDev(key)\n Get std dev of key(d80_cm, d80_deg, eff_area, eff_flen).\n images()\n Get list of PSFImages.\n \"\"\"\n\n YLABEL = {\n \"d80_cm\": r\"$D_{80}$\",\n \"d80_deg\": r\"$D_{80}$\",\n \"eff_area\": \"Eff. mirror area\",\n \"eff_flen\": \"Eff. focal length\",\n }\n\n def __init__(\n self,\n telescopeModel,\n label=None,\n simtelSourcePath=None,\n filesLocation=None,\n configData=None,\n configFile=None,\n ):\n \"\"\"\n RayTracing init.\n\n Parameters\n ----------\n telescopeModel: TelescopeModel\n Instance of the TelescopeModel class.\n label: str\n Instance label.\n simtelSourcePath: str (or Path), optional\n Location of sim_telarray installation. If not given, it will be taken from the\n config.yml file.\n filesLocation: str (or Path), optional\n Parent location of the output files created by this class. If not given, it will be\n taken from the config.yml file.\n configData: dict.\n Dict containing the configurable parameters.\n configFile: str or Path\n Path of the yaml file containing the configurable parameters.\n \"\"\"\n self._logger = logging.getLogger(__name__)\n\n self._simtelSourcePath = Path(cfg.getConfigArg(\"simtelPath\", simtelSourcePath))\n self._filesLocation = cfg.getConfigArg(\"outputLocation\", filesLocation)\n\n self._telescopeModel = self._validateTelescopeModel(telescopeModel)\n\n # Loading configData\n _configDataIn = gen.collectDataFromYamlOrDict(configFile, configData)\n _parameterFile = io.getDataFile(\"parameters\", \"ray-tracing_parameters.yml\")\n _parameters = gen.collectDataFromYamlOrDict(_parameterFile, None)\n self.config = gen.validateConfigData(_configDataIn, _parameters)\n\n self.label = label if label is not None else self._telescopeModel.label\n\n self._outputDirectory = io.getRayTracingOutputDirectory(\n self._filesLocation, self.label\n )\n self._outputDirectory.mkdir(parents=True, exist_ok=True)\n\n # Loading relevant attributes in case of single mirror mode.\n if self.config.singleMirrorMode:\n # Recalculating source distance.\n self._logger.debug(\n \"Single mirror mode is activate - source distance is being recalculated to 2 * flen\"\n )\n mirFlen = self._telescopeModel.getParameterValue(\"mirror_focal_length\")\n self._sourceDistance = 2 * float(mirFlen) * u.cm.to(u.km) # km\n\n # Setting mirror numbers.\n if self.config.mirrorNumbers[0] == \"all\":\n self._mirrorNumbers = list(\n range(0, self._telescopeModel.mirrors.numberOfMirrors)\n )\n else:\n self._mirrorNumbers = self.config.mirrorNumbers\n else:\n self._sourceDistance = self.config.sourceDistance\n\n self._hasResults = False\n\n # Results file\n fileNameResults = names.rayTracingResultsFileName(\n self._telescopeModel.site,\n self._telescopeModel.name,\n self._sourceDistance,\n self.config.zenithAngle,\n self.label,\n )\n self._outputDirectory.joinpath(\"results\").mkdir(parents=True, exist_ok=True)\n self._fileResults = self._outputDirectory.joinpath(\"results\").joinpath(\n fileNameResults\n )\n\n # END of init\n\n @classmethod\n def fromKwargs(cls, **kwargs):\n \"\"\"\n Builds a RayTracing object from kwargs only.\n The configurable parameters can be given as kwargs, instead of using the\n configData or configFile arguments.\n\n Parameters\n ----------\n kwargs\n Containing the arguments and the configurable parameters.\n\n Returns\n -------\n Instance of this class.\n \"\"\"\n args, configData = gen.separateArgsAndConfigData(\n expectedArgs=[\n \"telescopeModel\",\n \"label\",\n \"simtelSourcePath\",\n \"filesLocation\",\n ],\n **kwargs\n )\n return cls(**args, configData=configData)\n\n def __repr__(self):\n return \"RayTracing(label={})\\n\".format(self.label)\n\n def _validateTelescopeModel(self, tel):\n \"\"\"Validate TelescopeModel\"\"\"\n if isinstance(tel, TelescopeModel):\n self._logger.debug(\"RayTracing contains a valid TelescopeModel\")\n return tel\n else:\n msg = \"Invalid TelescopeModel\"\n self._logger.error(msg)\n raise ValueError(msg)\n\n def simulate(self, test=False, force=False):\n \"\"\"\n Simulate RayTracing using SimtelRunnerRayTracing.\n\n Parameters\n ----------\n test: bool\n Test flag will make it faster by simulating much fewer photons.\n force: bool\n Force flag will remove existing files and simulate again.\n \"\"\"\n allMirrors = self._mirrorNumbers if self.config.singleMirrorMode else [0]\n for thisOffAxis in self.config.offAxisAngle:\n for thisMirror in allMirrors:\n self._logger.info(\n \"Simulating RayTracing for offAxis={}, mirror={}\".format(\n thisOffAxis, thisMirror\n )\n )\n simtel = SimtelRunnerRayTracing(\n simtelSourcePath=self._simtelSourcePath,\n filesLocation=self._filesLocation,\n telescopeModel=self._telescopeModel,\n configData={\n \"zenithAngle\": self.config.zenithAngle * u.deg,\n \"sourceDistance\": self._sourceDistance * u.km,\n \"offAxisAngle\": thisOffAxis * u.deg,\n \"mirrorNumber\": thisMirror,\n \"useRandomFocalLength\": self.config.useRandomFocalLength,\n },\n singleMirrorMode=self.config.singleMirrorMode,\n )\n simtel.run(test=test, force=force)\n\n # END of simulate\n\n def analyze(self,\n export=True,\n force=False,\n useRX=False,\n noTelTransmission=False,\n containment_fraction=0.8):\n \"\"\"\n Analyze RayTracing, meaning read simtel files, compute psfs and eff areas and store the\n results in _results.\n\n Parameters\n ----------\n export: bool\n If True, results will be exported to a file automatically. Alternatively,\n exportResults function can be used.\n force: bool\n If True, existing results files will be removed and analysis will be done again.\n useRX: bool\n If True, calculations are done using the rx binary provided by sim_telarray. If False,\n calculations are done internally, by the module psf_analysis.\n noTelTransmission: bool\n If True, the telescope transmission is not applied.\n containment_fraction: float\n Containment fraction for PSF containment calculation. Allowed values are in the\n inverval [0,1]\n \"\"\"\n\n doAnalyze = not self._fileResults.exists() or force\n\n focalLength = float(self._telescopeModel.getParameterValue(\"focal_length\"))\n telTransmissionPars = (\n self._telescopeModel.getTelescopeTransmissionParameters()\n if not noTelTransmission\n else [1, 0, 0, 0]\n )\n\n cmToDeg = 180.0 / pi / focalLength\n\n self._psfImages = dict()\n if doAnalyze:\n _rows = list()\n else:\n self._readResults()\n\n allMirrors = self._mirrorNumbers if self.config.singleMirrorMode else [0]\n for thisOffAxis in self.config.offAxisAngle:\n for thisMirror in allMirrors:\n self._logger.debug(\n \"Analyzing RayTracing for offAxis={}\".format(thisOffAxis)\n )\n if self.config.singleMirrorMode:\n self._logger.debug(\"mirrorNumber={}\".format(thisMirror))\n\n photonsFileName = names.rayTracingFileName(\n self._telescopeModel.site,\n self._telescopeModel.name,\n self._sourceDistance,\n self.config.zenithAngle,\n thisOffAxis,\n thisMirror if self.config.singleMirrorMode else None,\n self.label,\n \"photons\",\n )\n\n photonsFile = self._outputDirectory.joinpath(photonsFileName)\n telTransmission = computeTelescopeTransmission(\n telTransmissionPars, thisOffAxis\n )\n image = PSFImage(focalLength, None)\n image.readPhotonListFromSimtelFile(photonsFile)\n self._psfImages[thisOffAxis] = copy(image)\n\n if not doAnalyze:\n continue\n\n if useRX:\n containment_diameter_cm, centroidX, centroidY, effArea = \\\n self._processRX(photonsFile)\n containment_diameter_deg = containment_diameter_cm * cmToDeg\n image.setPSF(containment_diameter_cm,\n fraction=containment_fraction, unit=\"cm\")\n image.centroidX = centroidX\n image.centroidY = centroidY\n image.setEffectiveArea(effArea * telTransmission)\n else:\n containment_diameter_cm = image.getPSF(containment_fraction, \"cm\")\n containment_diameter_deg = image.getPSF(containment_fraction, \"deg\")\n centroidX = image.centroidX\n centroidY = image.centroidY\n effArea = image.getEffectiveArea() * telTransmission\n\n effFlen = (\n np.nan\n if thisOffAxis == 0\n else centroidX / tan(thisOffAxis * pi / 180.0)\n )\n _currentResults = (\n thisOffAxis * u.deg,\n containment_diameter_cm * u.cm,\n containment_diameter_deg * u.deg,\n effArea * u.m * u.m,\n effFlen * u.cm,\n )\n if self.config.singleMirrorMode:\n _currentResults += (thisMirror,)\n _rows.append(_currentResults)\n # END for offAxis, mirrorNumber\n\n if doAnalyze:\n _columns = [\"Off-axis angle\"]\n _columns.extend(list(self.YLABEL.keys()))\n if self.config.singleMirrorMode:\n _columns.append(\"mirror_number\")\n self._results = QTable(rows=_rows, names=_columns)\n\n self._hasResults = True\n # Exporting\n if export:\n self.exportResults()\n\n # END of analyze\n\n def _processRX(self, file, containment_fraction=0.8):\n \"\"\"\n Process sim_telarray photon list with rx binary and return the results\n (containment_diameter_cm, centroids and eff area).\n\n Parameters\n ----------\n file: str or Path\n Photon list file.\n containment_fraction: float\n Containment fraction for PSF containment calculation. Allowed values are in the\n inverval [0,1]\n\n Returns\n -------\n (containment_diameter_cm, xMean, yMean, effArea)\n \"\"\"\n # Use -n to disable the cog optimization\n rxOutput = subprocess.check_output(\n \"{}/sim_telarray/bin/rx -f {:.2f} -v < {}\".format(\n self._simtelSourcePath, containment_fraction, file\n ),\n shell=True,\n )\n rxOutput = rxOutput.split()\n containment_diameter_cm = 2 * float(rxOutput[0])\n xMean = float(rxOutput[1])\n yMean = float(rxOutput[2])\n effArea = float(rxOutput[5])\n return containment_diameter_cm, xMean, yMean, effArea\n\n def exportResults(self):\n \"\"\"Export results to a csv file.\"\"\"\n if not self._hasResults:\n self._logger.error(\"Cannot export results because it does not exist\")\n else:\n self._logger.info(\"Exporting results to {}\".format(self._fileResults))\n ascii.write(self._results, self._fileResults, format=\"ecsv\", overwrite=True)\n\n def _readResults(self):\n \"\"\"Read existing results file and store it in _results.\"\"\"\n self._results = ascii.read(self._fileResults, format=\"ecsv\")\n self._hasResults = True\n\n def plot(self, key, save=False, **kwargs):\n \"\"\"\n Plot key vs off-axis angle and save the figure in pdf.\n\n Parameters\n ----------\n key: str\n d80_cm, d80_deg, eff_area or eff_flen\n save: bool\n If True, figure will be saved.\n **kwargs:\n kwargs for plt.plot\n\n Raises\n ------\n KeyError\n If key is not among the valid options.\n \"\"\"\n if key not in self.YLABEL.keys():\n msg = \"Invalid key to plot\"\n self._logger.error(msg)\n raise KeyError(msg)\n\n self._logger.info(\"Plotting {} vs off-axis angle\".format(key))\n\n plt = visualize.plotTable(\n self._results[\"Off-axis angle\", key],\n self.YLABEL[key],\n noLegend=True,\n **kwargs\n )\n\n if save:\n plotFileName = names.rayTracingPlotFileName(\n key,\n self._telescopeModel.site,\n self._telescopeModel.name,\n self._sourceDistance,\n self.config.zenithAngle,\n self.label,\n )\n self._outputDirectory.joinpath(\"figures\").mkdir(exist_ok=True)\n plotFile = self._outputDirectory.joinpath(\"figures\").joinpath(plotFileName)\n self._logger.info(\"Saving fig in {}\".format(plotFile))\n plt.savefig(plotFile)\n\n def plotHistogram(self, key, **kwargs):\n \"\"\"\n Plot histogram of key.\n\n Parameters\n ----------\n key: str\n d80_cm, d80_deg, eff_area or eff_flen\n **kwargs:\n kwargs for plt.hist\n\n Raises\n ------\n KeyError\n If key is not among the valid options.\n \"\"\"\n if key not in self.YLABEL.keys():\n msg = \"Invalid key to plot\"\n self._logger.error(msg)\n raise KeyError(msg)\n\n ax = plt.gca()\n ax.hist([r.value for r in self._results[key]], **kwargs)\n\n def getMean(self, key):\n \"\"\"\n Get mean value of key.\n\n Parameters\n ----------\n key: str\n d80_cm, d80_deg, eff_area or eff_flen\n\n Returns\n -------\n float\n Mean value of key.\n\n Raises\n ------\n KeyError\n If key is not among the valid options.\n \"\"\"\n if key not in self.YLABEL.keys():\n msg = \"Invalid key to plot\"\n self._logger.error(msg)\n raise KeyError(msg)\n return np.mean(self._results[key])\n\n def getStdDev(self, key):\n \"\"\"\n Get std dev of key.\n\n Parameters\n ----------\n key: str\n d80_cm, d80_deg, eff_area or eff_flen\n\n Returns\n -------\n float\n Std deviation of key.\n\n Raises\n ------\n KeyError\n If key is not among the valid options.\n \"\"\"\n if key not in self.YLABEL.keys():\n msg = \"Invalid key to plot\"\n self._logger.error(msg)\n raise KeyError(msg)\n return np.std(self._results[key])\n\n def images(self):\n \"\"\"\n Get list of PSFImages.\n\n Returns\n -------\n List of PSFImage's\n \"\"\"\n images = list()\n for thisOffAxis in self.config.offAxisAngle:\n if thisOffAxis in self._psfImages.keys():\n images.append(self._psfImages[thisOffAxis])\n if len(images) == 0:\n self._logger.error(\"No image found\")\n return None\n return images\n\n\n# END of RayTracing\n"
] | [
[
"numpy.std",
"numpy.mean"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
reixd/iexfinance | [
"53848f99e2ed54f61a1971d55a3b1b38dc00d2fa"
] | [
"iexfinance/stats.py"
] | [
"from datetime import datetime, timedelta\r\n\r\nimport pandas as pd\r\n\r\nfrom .base import _IEXBase\r\nfrom iexfinance.utils.exceptions import IEXQueryError\r\n# Data provided for free by IEX\r\n# Data is furnished in compliance with the guidelines promulgated in the IEX\r\n# API terms of service and manual\r\n# See https://iextrading.com/api-exhibit-a/ for additional information\r\n# and conditions of use\r\n\r\n\r\nclass Stats(_IEXBase):\r\n \"\"\"\r\n Base class for obtaining date from the IEX Stats endpoints\r\n of IEX. Subclass of _IEXBase, subclassed by various.\r\n\r\n Reference: https://iextrading.com/developer/docs/#iex-stats\r\n \"\"\"\r\n\r\n def __init__(self, output_format='json', **kwargs):\r\n self.output_format = output_format\r\n super(Stats, self).__init__(**kwargs)\r\n\r\n def _output_format(self, response):\r\n if self.output_format == 'json':\r\n return response\r\n elif self.output_format == 'pandas' and self.acc_pandas:\r\n try:\r\n df = pd.DataFrame(response)\r\n return df\r\n except ValueError:\r\n raise IEXQueryError()\r\n elif self.acc_pandas is False:\r\n raise ValueError(\"Pandas not accepted for this function.\")\r\n else:\r\n raise ValueError(\"Please input valid output format\")\r\n\r\n @staticmethod\r\n def _validate_dates(start, end):\r\n now = datetime.now()\r\n if isinstance(start, datetime):\r\n # Ensure start range is within 4 years\r\n if start.year < (now.year - 4) or start > now:\r\n raise ValueError(\"start: retrieval period must begin from \"\r\n + str(now.year - 4) + \" until now\")\r\n # Ensure end date (if specified is between start and now)\r\n if isinstance(end, datetime):\r\n if end > now or end < start:\r\n raise ValueError(\"end: retrieval period must end\"\r\n \"between start and the current date\")\r\n\r\n return\r\n else:\r\n raise ValueError(\"end: Please enter a valid end date\")\r\n else:\r\n raise ValueError(\"Please specify a valid date range or last value\")\r\n\r\n @property\r\n def acc_pandas(self):\r\n return True\r\n\r\n @property\r\n def url(self):\r\n return \"stats\"\r\n\r\n def fetch(self):\r\n return self._output_format(super(Stats, self).fetch())\r\n\r\n\r\nclass IntradayReader(Stats):\r\n \"\"\"\r\n Class for obtaining data from the Intraday endpoint of IEX Stats\r\n\r\n Reference: https://iextrading.com/developer/docs/#intraday\r\n \"\"\"\r\n @property\r\n def url(self):\r\n return \"stats/intraday\"\r\n\r\n\r\nclass RecentReader(Stats):\r\n \"\"\"\r\n Class for obtaining data from the Recent endpoint of IEX Stats\r\n\r\n Reference: https://iextrading.com/developer/docs/#recent\r\n \"\"\"\r\n\r\n @property\r\n def url(self):\r\n return \"stats/recent\"\r\n\r\n\r\nclass RecordsReader(Stats):\r\n \"\"\"\r\n Class for obtaining data from the Records endpoint of IEX Stats\r\n\r\n Reference: https://iextrading.com/developer/docs/#records\r\n \"\"\"\r\n\r\n @property\r\n def url(self):\r\n return \"stats/records\"\r\n\r\n\r\nclass DailySummaryReader(Stats):\r\n \"\"\"\r\n Class for obtaining data from the Historical Daily endpoint of IEX Stats\r\n\r\n Attributes\r\n ----------\r\n start: datetime.datetime\r\n Desired start of summary period\r\n end: datetime.datetime\r\n Desired end of summary period (if omitted, start\r\n month will be returned)\r\n last: int\r\n Period between 1 and 90 days, overrides dates\r\n output_format: str\r\n Desired output format (json or pandas)\r\n kwargs:\r\n Additional request parameters (see base class)\r\n\r\n\r\n Reference\r\n ---------\r\n https://iextrading.com/developer/docs/#historical-daily\r\n\r\n \"\"\"\r\n\r\n def __init__(self, start=None, end=None, last=None,\r\n output_format='json', **kwargs):\r\n import warnings\r\n warnings.warn('Daily statistics is not working due to issues with the '\r\n 'IEX API')\r\n self.curr_date = start\r\n self.last = last\r\n self.start = start\r\n self.end = end\r\n self.json_parse_int = kwargs.pop(\"json_parse_int\", None)\r\n self.json_parse_float = kwargs.pop(\"json_parse_float\", None)\r\n self._validate_params()\r\n super(DailySummaryReader, self).__init__(output_format=output_format,\r\n **kwargs)\r\n\r\n def _validate_params(self):\r\n if self.last is not None:\r\n if not isinstance(self.last, int) or not (0 < self.last < 90):\r\n raise ValueError(\"last: lease enter an integer value from 1 to\"\r\n \" 90\")\r\n return\r\n else:\r\n self._validate_dates(self.start, self.end)\r\n return\r\n raise ValueError(\"Please enter a date range or number of days for \"\r\n \"retrieval period.\")\r\n\r\n def _validate_response(self, response):\r\n return response.json(\r\n parse_int=self.json_parse_int,\r\n parse_float=self.json_parse_float)\r\n\r\n @property\r\n def url(self):\r\n return \"stats/historical/daily\"\r\n\r\n @property\r\n def islast(self):\r\n return self.last is not None and 1 < self.last < 91\r\n\r\n @property\r\n def params(self):\r\n p = {}\r\n if not self.islast:\r\n p['date'] = self.curr_date.strftime('%Y%m%d')\r\n else:\r\n p['last'] = self.last\r\n return p\r\n\r\n def fetch(self):\r\n \"\"\"Unfortunately, IEX's API can only retrieve data one day or one month\r\n at a time. Rather than specifying a date range, we will have to run\r\n the read function for each date provided.\r\n\r\n :return: DataFrame\r\n \"\"\"\r\n self._validate_params()\r\n if self.islast:\r\n data = super(DailySummaryReader, self).fetch()\r\n else:\r\n data = self._fetch_dates()\r\n if self.output_format == 'pandas':\r\n data.set_index('date', inplace=True)\r\n return data\r\n else:\r\n return data\r\n\r\n def _fetch_dates(self):\r\n tlen = self.end - self.start\r\n dfs = []\r\n for date in (self.start + timedelta(n) for n in range(tlen.days)):\r\n self.curr_date = date\r\n tdf = super(DailySummaryReader, self).fetch()\r\n dfs.append(tdf)\r\n if self.output_format == 'pandas':\r\n return pd.concat(dfs)\r\n else:\r\n return dfs\r\n\r\n\r\nclass MonthlySummaryReader(Stats):\r\n \"\"\"\r\n Class for obtaining data from the Historical Summary endpoint of IEX Stats\r\n\r\n Attributes\r\n ----------\r\n start: datetime.datetime\r\n Desired start of summary period\r\n end: datetime.datetime\r\n Desired end of summary period (if omitted, start\r\n month will be returned)\r\n output_format: str\r\n Desired output format (json or pandas)\r\n kwargs:\r\n Additional request parameters (see base class)\r\n\r\n\r\n Reference\r\n ---------\r\n https://iextrading.com/developer/docs/#historical-summary\r\n\r\n \"\"\"\r\n\r\n def __init__(self, start=None, end=None, output_format='json', **kwargs):\r\n self.curr_date = start\r\n self.date_format = '%Y%m'\r\n self.start = start\r\n self.end = end\r\n self._validate_dates(self.start, self.end)\r\n super(MonthlySummaryReader, self).__init__(output_format=output_format,\r\n **kwargs)\r\n\r\n @property\r\n def url(self):\r\n return \"stats/historical\"\r\n\r\n @property\r\n def params(self):\r\n p = {}\r\n if self.curr_date is not None:\r\n p['date'] = self.curr_date.strftime(self.date_format)\r\n return p\r\n\r\n def fetch(self):\r\n \"\"\"Unfortunately, IEX's API can only retrieve data one day or one month\r\n at a time. Rather than specifying a date range, we will have to run\r\n the read function for each date provided.\r\n\r\n :return: DataFrame\r\n \"\"\"\r\n tlen = self.end - self.start\r\n dfs = []\r\n\r\n # Build list of all dates within the given range\r\n lrange = [x for x in (self.start + timedelta(n)\r\n for n in range(tlen.days))]\r\n\r\n mrange = []\r\n for dt in lrange:\r\n if datetime(dt.year, dt.month, 1) not in mrange:\r\n mrange.append(datetime(dt.year, dt.month, 1))\r\n lrange = mrange\r\n\r\n for date in lrange:\r\n self.curr_date = date\r\n tdf = super(MonthlySummaryReader, self).fetch()\r\n\r\n # We may not return data if this was a weekend/holiday:\r\n if self.output_format == 'pandas':\r\n if not tdf.empty:\r\n tdf['date'] = date.strftime(self.date_format)\r\n dfs.append(tdf)\r\n\r\n # We may not return any data if we failed to specify useful parameters:\r\n if self.output_format == 'pandas':\r\n result = pd.concat(dfs) if len(dfs) > 0 else pd.DataFrame()\r\n return result.set_index('date')\r\n else:\r\n return dfs\r\n"
] | [
[
"pandas.concat",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
ChangQingAAS/MFDDPG_Path_Planning | [
"dd2af3bbb4807b2d248da46b99607153f75b4a56",
"dd2af3bbb4807b2d248da46b99607153f75b4a56"
] | [
"vis/draw_result.py",
"vis/pic.py"
] | [
"import seaborn as sns\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pylab\nimport csv\nimport random\nimport sys\nimport os\n\n\ndef get_data(path):\n epoch = []\n num_reach_target = []\n num_hit_obs = []\n num_out_of_range = []\n num_moving = []\n with open(path, \"r+\", encoding=\"utf-8\") as csvfile:\n reader = csv.DictReader(csvfile)\n for row in reader:\n epoch.append(int(row['epoch']))\n num_reach_target.append(int(row['num_reach_target']))\n num_hit_obs.append(int(row['num_hit_obs']))\n num_out_of_range.append(int(row['num_out_of_range']))\n num_moving.append(int(row['num_moving']))\n return epoch, num_reach_target, num_hit_obs, num_out_of_range, num_moving\n\n\ndef draw(epoch, num_reach_target, num_hit_obs, num_out_of_range, num_moving, color_list, pic_name):\n plt.plot(epoch, num_reach_target, color=color_list[7])\n plt.plot(epoch, num_hit_obs, color=color_list[4])\n # plt.plot(epoch, num_out_of_range, color=color_list[0])\n plt.plot(epoch, num_moving, color=color_list[3])\n\n plt.legend(['num_reach_target', 'num_hit_obs', 'num_moving'], loc='lower right', fontsize=10) # 图例\n plt.ylabel('number', fontsize=10)\n plt.xlabel('episodes', fontsize=10)\n plt.title('result', fontsize=10)\n plt.savefig(pic_name)\n\n\nif __name__ == \"__main__\":\n path = '../output/result.csv'\n pic_name = '../output/result.png'\n color_list = sns.hls_palette(8, l=.3, s=.8)\n epoch, num_reach_target, num_hit_obs, num_out_of_range, num_moving = get_data(path)\n draw(epoch, num_reach_target, num_hit_obs, num_out_of_range, num_moving, color_list, pic_name)\n",
"import matplotlib.pyplot as plt\r\nimport numpy as np\r\nimport etc\r\nimport os\r\n\r\n\r\ndef read_reward_file(self):\r\n # 读取奖励文档\r\n epochs_list = []\r\n reward_list = []\r\n with open(\"%s/final_reward.csv\" % self.OUTPUT_PATH) as f:\r\n con = f.read()\r\n con_lt = con.split(\"\\n\")\r\n for i in range(len(con_lt) - 1):\r\n lt = con_lt[i].split(',')\r\n epochs_list.append(int(lt[0]))\r\n reward_list.append(float(lt[1]))\r\n return epochs_list, reward_list\r\n\r\n\r\ndef read_loss_file(file_name=\"\"):\r\n # 读取损失文档\r\n epochs_list = []\r\n reward_list = []\r\n f = open(file_name)\r\n con = f.read()\r\n f.close()\r\n con_lt = con.split(\"\\n\")\r\n for i in range(len(con_lt) - 1):\r\n lt = con_lt[i].split(',')\r\n epochs_list.append(int(lt[0]))\r\n reward_list.append(float(lt[1]))\r\n return epochs_list, reward_list\r\n\r\n\r\ndef show_reward_pic():\r\n # 画出奖赏值的变化图\r\n epoch_list, reward_list = read_reward_file()\r\n reward_sum = 0.0\r\n for i in range(len(reward_list)):\r\n reward_sum += reward_list[i]\r\n\r\n reward_mean = reward_sum / len(reward_list)\r\n e = np.asarray(epoch_list)\r\n r = np.asarray(reward_list)\r\n plt.figure()\r\n plt.plot(e, r)\r\n plt.xlabel('Epochs')\r\n plt.ylabel('Reward')\r\n plt.show()\r\n plt.close()\r\n\r\n\r\ndef show_loss_pic(loss_name=\"loss_critic\"):\r\n # 画出损失值的变化图\r\n file_name = \"%s/%s.txt\" % (etc.OUTPUT_PATH, loss_name)\r\n step_list, loss_list = read_loss_file(file_name)\r\n e = np.asarray(step_list)\r\n r = np.asarray(loss_list)\r\n plt.figure()\r\n plt.plot(e, r)\r\n plt.xlabel('steps')\r\n plt.ylabel(loss_name)\r\n # 使用plt.show(),然后使用plt.close()并不会关闭图，\r\n # plt.show()\r\n plt.draw()\r\n plt.pause(20)\r\n plt.close()\r\n\r\n\r\ndef show_pic():\r\n # 画图\r\n if etc.SHOW_FIGURE:\r\n # show_reward_pic()\r\n show_loss_pic(\"loss_actor\")\r\n # show_loss_pic(\"loss_critic\")\r\n"
] | [
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.title",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.ylabel"
],
[
"numpy.asarray",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.draw",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.close",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.show",
"matplotlib.pyplot.pause",
"matplotlib.pyplot.ylabel"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Jjschwartz/highway-env | [
"e289d5f513d6162eadba6a54f2541ca7b193ef6a"
] | [
"highway_env/envs/common/observation.py"
] | [
"from typing import List, Dict, TYPE_CHECKING, Optional, Union\nfrom gym import spaces\nimport numpy as np\nimport pandas as pd\n\nfrom highway_env import utils\nfrom highway_env.envs.common.finite_mdp import compute_ttc_grid\nfrom highway_env.road.lane import AbstractLane\nfrom highway_env.utils import distance_to_circle\nfrom highway_env.vehicle.controller import MDPVehicle\n\nif TYPE_CHECKING:\n from highway_env.envs.common.abstract import AbstractEnv\n\n\nclass ObservationType(object):\n def __init__(self, env: 'AbstractEnv', **kwargs) -> None:\n self.env = env\n self.__observer_vehicle = None\n\n def space(self) -> spaces.Space:\n \"\"\"Get the observation space.\"\"\"\n raise NotImplementedError()\n\n def observe(self):\n \"\"\"Get an observation of the environment state.\"\"\"\n raise NotImplementedError()\n\n @property\n def observer_vehicle(self):\n \"\"\"\n The vehicle observing the scene.\n\n If not set, the first controlled vehicle is used by default.\n \"\"\"\n return self.__observer_vehicle or self.env.vehicle\n\n @observer_vehicle.setter\n def observer_vehicle(self, vehicle):\n self.__observer_vehicle = vehicle\n\n\nclass GrayscaleObservation(ObservationType):\n\n \"\"\"\n An observation class that collects directly what the simulator renders\n\n Also stacks the collected frames as in the nature DQN.\n Specific keys are expected in the configuration dictionary passed.\n\n Example of observation dictionary in the environment config:\n observation\": {\n \"type\": \"GrayscaleObservation\",\n \"weights\": [0.2989, 0.5870, 0.1140], #weights for RGB conversion,\n \"stack_size\": 4,\n \"observation_shape\": (84, 84)\n }\n\n Also, the screen_height and screen_width of the environment should match the\n expected observation_shape.\n \"\"\"\n\n def __init__(self, env: 'AbstractEnv', config: dict) -> None:\n super().__init__(env)\n self.config = config\n self.observation_shape = config[\"observation_shape\"]\n self.shape = self.observation_shape + (config[\"stack_size\"], )\n self.state = np.zeros(self.shape)\n\n def space(self) -> spaces.Space:\n try:\n return spaces.Box(shape=self.shape,\n low=0, high=1,\n dtype=np.float32)\n except AttributeError:\n return spaces.Space()\n\n def observe(self) -> np.ndarray:\n new_obs = self._record_to_grayscale()\n new_obs = np.reshape(new_obs, self.observation_shape)\n self.state = np.roll(self.state, -1, axis=-1)\n self.state[:, :, -1] = new_obs\n return self.state\n\n def _record_to_grayscale(self) -> np.ndarray:\n #TODO: center rendering on the observer vehicle\n raw_rgb = self.env.render('rgb_array')\n return np.dot(raw_rgb[..., :3], self.config['weights'])\n\n\nclass TimeToCollisionObservation(ObservationType):\n def __init__(self, env: 'AbstractEnv', horizon: int = 10, **kwargs: dict) -> None:\n super().__init__(env)\n self.horizon = horizon\n\n def space(self) -> spaces.Space:\n try:\n return spaces.Box(shape=self.observe().shape, low=0, high=1, dtype=np.float32)\n except AttributeError:\n return spaces.Space()\n\n def observe(self) -> np.ndarray:\n if not self.env.road:\n return np.zeros((3, 3, int(self.horizon * self.env.config[\"policy_frequency\"])))\n grid = compute_ttc_grid(self.env, vehicle=self.observer_vehicle,\n time_quantization=1/self.env.config[\"policy_frequency\"], horizon=self.horizon)\n padding = np.ones(np.shape(grid))\n padded_grid = np.concatenate([padding, grid, padding], axis=1)\n obs_lanes = 3\n l0 = grid.shape[1] + self.observer_vehicle.lane_index[2] - obs_lanes // 2\n lf = grid.shape[1] + self.observer_vehicle.lane_index[2] + obs_lanes // 2\n clamped_grid = padded_grid[:, l0:lf+1, :]\n repeats = np.ones(clamped_grid.shape[0])\n repeats[np.array([0, -1])] += clamped_grid.shape[0]\n padded_grid = np.repeat(clamped_grid, repeats.astype(int), axis=0)\n obs_speeds = 3\n v0 = grid.shape[0] + self.observer_vehicle.speed_index - obs_speeds // 2\n vf = grid.shape[0] + self.observer_vehicle.speed_index + obs_speeds // 2\n clamped_grid = padded_grid[v0:vf + 1, :, :]\n return clamped_grid\n\n\nclass KinematicObservation(ObservationType):\n\n \"\"\"Observe the kinematics of nearby vehicles.\"\"\"\n\n FEATURES: List[str] = ['presence', 'x', 'y', 'vx', 'vy']\n\n def __init__(self, env: 'AbstractEnv',\n features: List[str] = None,\n vehicles_count: int = 5,\n features_range: Dict[str, List[float]] = None,\n absolute: bool = False,\n order: str = \"sorted\",\n normalize: bool = True,\n clip: bool = True,\n see_behind: bool = False,\n observe_intentions: bool = False,\n **kwargs: dict) -> None:\n \"\"\"\n :param env: The environment to observe\n :param features: Names of features used in the observation\n :param vehicles_count: Number of observed vehicles\n :param absolute: Use absolute coordinates\n :param order: Order of observed vehicles. Values: sorted, shuffled\n :param normalize: Should the observation be normalized\n :param clip: Should the value be clipped in the desired range\n :param see_behind: Should the observation contains the vehicles behind\n :param observe_intentions: Observe the destinations of other vehicles\n \"\"\"\n super().__init__(env)\n self.features = features or self.FEATURES\n self.vehicles_count = vehicles_count\n self.features_range = features_range\n self.absolute = absolute\n self.order = order\n self.normalize = normalize\n self.clip = clip\n self.see_behind = see_behind\n self.observe_intentions = observe_intentions\n\n def space(self) -> spaces.Space:\n return spaces.Box(shape=(self.vehicles_count, len(self.features)), low=-1, high=1, dtype=np.float32)\n\n def normalize_obs(self, df: pd.DataFrame) -> pd.DataFrame:\n \"\"\"\n Normalize the observation values.\n\n For now, assume that the road is straight along the x axis.\n :param Dataframe df: observation data\n \"\"\"\n if not self.features_range:\n side_lanes = self.env.road.network.all_side_lanes(self.observer_vehicle.lane_index)\n self.features_range = {\n \"x\": [-5.0 * MDPVehicle.SPEED_MAX, 5.0 * MDPVehicle.SPEED_MAX],\n \"y\": [-AbstractLane.DEFAULT_WIDTH * len(side_lanes), AbstractLane.DEFAULT_WIDTH * len(side_lanes)],\n \"vx\": [-2*MDPVehicle.SPEED_MAX, 2*MDPVehicle.SPEED_MAX],\n \"vy\": [-2*MDPVehicle.SPEED_MAX, 2*MDPVehicle.SPEED_MAX]\n }\n for feature, f_range in self.features_range.items():\n if feature in df:\n df[feature] = utils.lmap(df[feature], [f_range[0], f_range[1]], [-1, 1])\n if self.clip:\n df[feature] = np.clip(df[feature], -1, 1)\n return df\n\n def observe(self) -> np.ndarray:\n if not self.env.road:\n return np.zeros(self.space().shape)\n\n # Add ego-vehicle\n df = pd.DataFrame.from_records([self.observer_vehicle.to_dict()])[self.features]\n # Add nearby traffic\n # sort = self.order == \"sorted\"\n close_vehicles = self.env.road.close_vehicles_to(self.observer_vehicle,\n self.env.PERCEPTION_DISTANCE,\n count=self.vehicles_count - 1,\n see_behind=self.see_behind)\n if close_vehicles:\n origin = self.observer_vehicle if not self.absolute else None\n df = df.append(pd.DataFrame.from_records(\n [v.to_dict(origin, observe_intentions=self.observe_intentions)\n for v in close_vehicles[-self.vehicles_count + 1:]])[self.features],\n ignore_index=True)\n # Normalize and clip\n if self.normalize:\n df = self.normalize_obs(df)\n # Fill missing rows\n if df.shape[0] < self.vehicles_count:\n rows = np.zeros((self.vehicles_count - df.shape[0], len(self.features)))\n df = df.append(pd.DataFrame(data=rows, columns=self.features), ignore_index=True)\n # Reorder\n df = df[self.features]\n obs = df.values.copy()\n if self.order == \"shuffled\":\n self.env.np_random.shuffle(obs[1:])\n # Flatten\n return obs\n\n\nclass OccupancyGridObservation(ObservationType):\n\n \"\"\"Observe an occupancy grid of nearby vehicles.\"\"\"\n\n FEATURES: List[str] = ['presence', 'vx', 'vy']\n GRID_SIZE: List[List[float]] = [[-5.5*5, 5.5*5], [-5.5*5, 5.5*5]]\n GRID_STEP: List[int] = [5, 5]\n\n def __init__(self,\n env: 'AbstractEnv',\n features: Optional[List[str]] = None,\n grid_size: Optional[List[List[float]]] = None,\n grid_step: Optional[List[int]] = None,\n features_range: Dict[str, List[float]] = None,\n absolute: bool = False,\n **kwargs: dict) -> None:\n \"\"\"\n :param env: The environment to observe\n :param features: Names of features used in the observation\n :param vehicles_count: Number of observed vehicles\n \"\"\"\n super().__init__(env)\n self.features = features if features is not None else self.FEATURES\n self.grid_size = np.array(grid_size) if grid_size is not None else np.array(self.GRID_SIZE)\n self.grid_step = np.array(grid_step) if grid_step is not None else np.array(self.GRID_STEP)\n grid_shape = np.asarray(np.floor((self.grid_size[:, 1] - self.grid_size[:, 0]) / grid_step), dtype=np.int)\n self.grid = np.zeros((len(self.features), *grid_shape))\n self.features_range = features_range\n self.absolute = absolute\n\n def space(self) -> spaces.Space:\n return spaces.Box(shape=self.grid.shape, low=-1, high=1, dtype=np.float32)\n\n def normalize(self, df: pd.DataFrame) -> pd.DataFrame:\n \"\"\"\n Normalize the observation values.\n\n For now, assume that the road is straight along the x axis.\n :param Dataframe df: observation data\n \"\"\"\n if not self.features_range:\n self.features_range = {\n \"vx\": [-2*MDPVehicle.SPEED_MAX, 2*MDPVehicle.SPEED_MAX],\n \"vy\": [-2*MDPVehicle.SPEED_MAX, 2*MDPVehicle.SPEED_MAX]\n }\n for feature, f_range in self.features_range.items():\n if feature in df:\n df[feature] = utils.lmap(df[feature], [f_range[0], f_range[1]], [-1, 1])\n return df\n\n def observe(self) -> np.ndarray:\n if not self.env.road:\n return np.zeros(self.space().shape)\n\n if self.absolute:\n raise NotImplementedError()\n else:\n # Add nearby traffic\n self.grid.fill(0)\n df = pd.DataFrame.from_records(\n [v.to_dict(self.observer_vehicle) for v in self.env.road.vehicles])\n # Normalize\n df = self.normalize(df)\n # Fill-in features\n for layer, feature in enumerate(self.features):\n for _, vehicle in df.iterrows():\n x, y = vehicle[\"x\"], vehicle[\"y\"]\n # Recover unnormalized coordinates for cell index\n if \"x\" in self.features_range:\n x = utils.lmap(x, [-1, 1], [self.features_range[\"x\"][0], self.features_range[\"x\"][1]])\n if \"y\" in self.features_range:\n y = utils.lmap(y, [-1, 1], [self.features_range[\"y\"][0], self.features_range[\"y\"][1]])\n cell = (int((x - self.grid_size[0, 0]) / self.grid_step[0]),\n int((y - self.grid_size[1, 0]) / self.grid_step[1]))\n if 0 <= cell[1] < self.grid.shape[-2] and 0 <= cell[0] < self.grid.shape[-1]:\n self.grid[layer, cell[1], cell[0]] = vehicle[feature]\n # Clip\n obs = np.clip(self.grid, -1, 1)\n return obs\n\n\nclass KinematicsGoalObservation(KinematicObservation):\n def __init__(self, env: 'AbstractEnv', scales: List[float], **kwargs: dict) -> None:\n self.scales = np.array(scales)\n super().__init__(env, **kwargs)\n\n def space(self) -> spaces.Space:\n try:\n obs = self.observe()\n return spaces.Dict(dict(\n desired_goal=spaces.Box(-np.inf, np.inf, shape=obs[\"desired_goal\"].shape, dtype=np.float32),\n achieved_goal=spaces.Box(-np.inf, np.inf, shape=obs[\"achieved_goal\"].shape, dtype=np.float32),\n observation=spaces.Box(-np.inf, np.inf, shape=obs[\"observation\"].shape, dtype=np.float32),\n ))\n except AttributeError:\n return spaces.Space()\n\n def observe(self) -> Dict[str, np.ndarray]:\n if not self.observer_vehicle:\n return {\n \"observation\": np.zeros((len(self.features),)),\n \"achieved_goal\": np.zeros((len(self.features),)),\n \"desired_goal\": np.zeros((len(self.features),))\n }\n\n obs = np.ravel(pd.DataFrame.from_records([self.observer_vehicle.to_dict()])[self.features])\n goal = np.ravel(pd.DataFrame.from_records([self.env.goal.to_dict()])[self.features])\n obs = {\n \"observation\": obs / self.scales,\n \"achieved_goal\": obs / self.scales,\n \"desired_goal\": goal / self.scales\n }\n return obs\n\n\nclass AttributesObservation(ObservationType):\n def __init__(self, env: 'AbstractEnv', attributes: List[str], **kwargs: dict) -> None:\n self.env = env\n self.attributes = attributes\n\n def space(self) -> spaces.Space:\n try:\n obs = self.observe()\n return spaces.Dict({\n attribute: spaces.Box(-np.inf, np.inf, shape=obs[attribute].shape, dtype=np.float32)\n for attribute in self.attributes\n })\n except AttributeError:\n return spaces.Space()\n\n def observe(self) -> Dict[str, np.ndarray]:\n return {\n attribute: getattr(self.env, attribute) for attribute in self.attributes\n }\n\n\nclass MultiAgentObservation(ObservationType):\n def __init__(self,\n env: 'AbstractEnv',\n observation_config: dict,\n **kwargs) -> None:\n super().__init__(env)\n self.observation_config = observation_config\n self.agents_observation_types = []\n for vehicle in self.env.controlled_vehicles:\n obs_type = observation_factory(self.env, self.observation_config)\n obs_type.observer_vehicle = vehicle\n self.agents_observation_types.append(obs_type)\n\n def space(self) -> spaces.Space:\n return spaces.Tuple([obs_type.space() for obs_type in self.agents_observation_types])\n\n def observe(self) -> tuple:\n return tuple(obs_type.observe() for obs_type in self.agents_observation_types)\n\n\nclass LidarObservation(ObservationType):\n DISTANCE = 0\n SPEED = 1\n\n def __init__(self, env,\n cells: int = 16,\n maximum_range: float = 60,\n normalize: bool = True,\n **kwargs):\n super().__init__(env, **kwargs)\n self.cells = cells\n self.maximum_range = maximum_range\n self.normalize = normalize\n self.angle = 2 * np.pi / self.cells\n self.grid = np.ones((self.cells, 1)) * float('inf')\n self.origin = None\n\n def space(self) -> spaces.Space:\n high = 1 if self.normalize else self.maximum_range\n return spaces.Box(shape=(self.cells, 2), low=-high, high=high, dtype=np.float32)\n\n def observe(self) -> np.ndarray:\n obs = self.trace(self.observer_vehicle.position, self.observer_vehicle.velocity).copy()\n if self.normalize:\n obs /= self.maximum_range\n return obs\n\n def trace(self, origin: np.ndarray, origin_velocity: np.ndarray) -> np.ndarray:\n self.origin = origin.copy()\n self.grid = np.ones((self.cells, 2)) * self.maximum_range\n\n for obstacle in self.env.road.vehicles + self.env.road.objects:\n if obstacle is self.observer_vehicle:\n continue\n center_distance = np.linalg.norm(obstacle.position - origin)\n if center_distance > self.maximum_range:\n continue\n center_angle = self.position_to_angle(obstacle.position, origin)\n half_angle = np.arccos(np.sqrt(max(1-(obstacle.WIDTH / 2 / center_distance)**2, 0)))\n center_index = self.angle_to_index(center_angle)\n # self.grid[center_index, self.DISTANCE] = min(self.grid[center_index, self.DISTANCE], )\n distance = center_distance - obstacle.WIDTH / 2\n if distance <= self.grid[center_index, self.DISTANCE]:\n direction = self.index_to_direction(center_index)\n velocity = (obstacle.velocity - origin_velocity).dot(direction)\n self.grid[center_index, :] = [distance, velocity]\n\n start, end = self.angle_to_index(center_angle - half_angle), self.angle_to_index(center_angle + half_angle)\n if start < end:\n indexes = np.arange(start, end+1)\n else:\n indexes = np.hstack([np.arange(start, self.cells), np.arange(0, end + 1)])\n\n for index in indexes:\n direction = self.index_to_direction(index)\n distance = distance_to_circle(obstacle.position - origin, obstacle.WIDTH / 2, direction)\n if distance <= self.grid[index, self.DISTANCE]:\n velocity = (obstacle.velocity - origin_velocity).dot(direction)\n self.grid[index, :] = [distance, velocity]\n return self.grid\n\n def position_to_angle(self, position: np.ndarray, origin: np.ndarray) -> float:\n return np.arctan2(position[1] - origin[1], position[0] - origin[0]) + self.angle/2\n\n def position_to_index(self, position: np.ndarray, origin: np.ndarray) -> int:\n return self.angle_to_index(self.position_to_angle(position, origin))\n\n def angle_to_index(self, angle: float) -> int:\n return int(np.floor(angle / self.angle)) % self.cells\n\n def index_to_direction(self, index: int) -> np.ndarray:\n return np.array([[np.cos(index * self.angle)], [np.sin(index * self.angle)]])\n\n\ndef observation_factory(env: 'AbstractEnv', config: dict) -> ObservationType:\n if config[\"type\"] == \"TimeToCollision\":\n return TimeToCollisionObservation(env, **config)\n elif config[\"type\"] == \"Kinematics\":\n return KinematicObservation(env, **config)\n elif config[\"type\"] == \"OccupancyGrid\":\n return OccupancyGridObservation(env, **config)\n elif config[\"type\"] == \"KinematicsGoal\":\n return KinematicsGoalObservation(env, **config)\n elif config[\"type\"] == \"GrayscaleObservation\":\n return GrayscaleObservation(env, config)\n elif config[\"type\"] == \"AttributesObservation\":\n return AttributesObservation(env, **config)\n elif config[\"type\"] == \"MultiAgentObservation\":\n return MultiAgentObservation(env, **config)\n elif config[\"type\"] == \"LidarObservation\":\n return LidarObservation(env, **config)\n else:\n raise ValueError(\"Unknown observation type\")\n"
] | [
[
"numpy.dot",
"numpy.clip",
"numpy.reshape",
"numpy.arange",
"numpy.linalg.norm",
"pandas.DataFrame",
"numpy.ones",
"numpy.concatenate",
"numpy.arctan2",
"numpy.cos",
"numpy.sin",
"numpy.shape",
"numpy.floor",
"numpy.array",
"numpy.zeros",
"numpy.roll"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
rwalkerlewis/spatialdata | [
"515c8d9dec21d261d0d654b5c30e6759565268d2"
] | [
"tests/pytests/spatialdb/TestGenSimpleDBApp.py"
] | [
"# ======================================================================\n#\n# Brad T. Aagaard, U.S. Geological Survey\n#\n# This code was developed as part of the Computational Infrastructure\n# for Geodynamics (http://geodynamics.org).\n#\n# Copyright (c) 2010-2017 University of California, Davis\n#\n# See COPYING for license information.\n#\n# ======================================================================\n#\n\nimport unittest\n\nimport numpy\n\n\n# ----------------------------------------------------------------------------------------------------------------------\nclass TestGenSimpleDBApp(unittest.TestCase):\n\n def test(self):\n \"\"\"\n Test GenSimpleDBApp with 1-D data in 2-D space.\n \"\"\"\n from spatialdata.spatialdb.generator.GenSimpleDBApp import GenSimpleDBApp\n from spatialdata.geocoords.CSCart import CSCart\n from spatialdata.spatialdb.SimpleDB import SimpleDB\n\n app = GenSimpleDBApp()\n app.run()\n\n # Test write using query\n db = SimpleDB()\n db.inventory.iohandler.inventory.filename = \"data/gen1Din2D.spatialdb\"\n db.inventory.iohandler._configure()\n db.inventory.label = \"test\"\n db.inventory.queryType = \"nearest\"\n db._configure()\n\n qlocs = numpy.array([[-2.0, 2.0], [3.0, -4.0], [0.0, 0.7]], numpy.float64)\n\n dataE = numpy.array([[-0.15, 3.45], [2.4, 6.4], [-0.6, 3.45]], numpy.float64)\n errE = [0, 0, 0]\n\n from spatialdata.geocoords.CSCart import CSCart\n cs = CSCart()\n cs.inventory.spaceDim = 2\n cs._configure()\n\n db.open()\n db.setQueryValues([\"two\", \"one\"])\n data = numpy.zeros(dataE.shape, dtype=numpy.float64)\n err = []\n nlocs = qlocs.shape[0]\n for i in range(nlocs):\n e = db.query(data[i, :], qlocs[i, :], cs)\n err.append(e)\n db.close()\n\n self.assertEqual(len(errE), len(err))\n for vE, v in zip(errE, err):\n self.assertEqual(vE, v)\n\n self.assertEqual(len(dataE.shape), len(data.shape))\n for dE, d in zip(dataE.shape, data.shape):\n self.assertEqual(dE, d)\n for vE, v in zip(numpy.reshape(dataE, -1), numpy.reshape(data, -1)):\n self.assertAlmostEqual(vE, v, 6)\n\n\n# ----------------------------------------------------------------------------------------------------------------------\nif __name__ == '__main__':\n suite = unittest.TestSuite()\n suite.addTest(unittest.makeSuite(TestGenSimpleDBApp))\n unittest.TextTestRunner(verbosity=2).run(suite)\n\n\n# End of file\n"
] | [
[
"numpy.reshape",
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
cadalyjr/molecool | [
"cabbd54b57c847c5c7659fe4be6b0223df6cd753"
] | [
"molecool/measure.py"
] | [
"\"\"\"\nContains functions related to calculations important for characterizing molecule structure.\n\"\"\"\n\nimport numpy as np\n\ndef calculate_distance(rA, rB):\n \"\"\"\n This function calculates the distance between two points given as numpy arrays.\n\n Parameters\n ----------\n rA, rB : np.adarray\n The coordinates of each point.\n\n Returns\n -------\n distance : float\n The distance between the two points.\n\n Examples\n --------\n >>> r1 = np.array([0.0, 0.0, 0.0])\n >>> r2 = np.array([0.0, 0.0, 1.0])\n >>> calculate_distance(r1, r2)\n 1.0\n \"\"\"\n\n if isinstance(rA, np.ndarray) is False or isinstance(rB, np.ndarray) is False:\n raise TypeError(\"rA and rB must be NumPy arrays\")\n d=(rA-rB)\n print(rA, rB)\n dist=np.linalg.norm(d)\n if dist == 0.0:\n raise Exception(\"Two atoms are located at the same point\")\n return dist\n\ndef calculate_angle(rA, rB, rC, degrees=False):\n # Calculate the angle between three points. Answer is given in radians by default, but can be given in degrees\n # by setting degrees=True\n AB = rB - rA\n BC = rB - rC\n theta=np.arccos(np.dot(AB, BC)/(np.linalg.norm(AB)*np.linalg.norm(BC)))\n\n if degrees:\n return np.degrees(theta)\n else:\n return theta\n"
] | [
[
"numpy.dot",
"numpy.degrees",
"numpy.linalg.norm"
]
] | [
{
"matplotlib": [],
"numpy": [
"1.10",
"1.12",
"1.11",
"1.19",
"1.24",
"1.13",
"1.16",
"1.9",
"1.18",
"1.23",
"1.21",
"1.22",
"1.20",
"1.7",
"1.15",
"1.14",
"1.17",
"1.8"
],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mirochaj/ares | [
"b3335ad30435ee0d7f17d0110aa164a35f252d78",
"b3335ad30435ee0d7f17d0110aa164a35f252d78",
"b3335ad30435ee0d7f17d0110aa164a35f252d78",
"b3335ad30435ee0d7f17d0110aa164a35f252d78",
"b3335ad30435ee0d7f17d0110aa164a35f252d78"
] | [
"ares/populations/GalaxyAggregate.py",
"tests/test_sources_bh.py",
"ares/simulations/Simulation.py",
"tests/test_physics_cross_sections.py",
"tests/test_simulations_gs_phenom.py"
] | [
"\"\"\"\n\nGalaxyAggregate.py\n\nAuthor: Jordan Mirocha\nAffiliation: University of Colorado at Boulder\nCreated on: Sat May 23 12:13:03 CDT 2015\n\nDescription:\n\n\"\"\"\n\nimport sys\nimport numpy as np\nfrom ..util import read_lit\nimport os, inspect, re\nfrom types import FunctionType\nfrom .Halo import HaloPopulation\nfrom collections import namedtuple\nfrom ..util.Math import interp1d\nfrom scipy.integrate import quad, simps\nfrom ..util.Warnings import negative_SFRD\nfrom ..util.ParameterFile import get_pq_pars, pop_id_num\nfrom scipy.interpolate import interp1d as interp1d_scipy\nfrom scipy.optimize import fsolve, fmin, curve_fit\nfrom scipy.special import gamma, gammainc, gammaincc\nfrom ..sources import Star, BlackHole, StarQS, SynthesisModel\nfrom ..util import ParameterFile, ProgressBar\nfrom ..phenom.ParameterizedQuantity import ParameterizedQuantity\nfrom ..physics.Constants import s_per_yr, g_per_msun, erg_per_ev, rhodot_cgs, \\\n E_LyA, rho_cgs, s_per_myr, cm_per_mpc, h_p, c, ev_per_hz, E_LL, k_B\n\n_sed_tab_attributes = ['Nion', 'Nlw', 'rad_yield', 'L1600_per_sfr']\ntiny_sfrd = 1e-15\n\nclass GalaxyAggregate(HaloPopulation):\n def __init__(self, **kwargs):\n \"\"\"\n Initializes a GalaxyPopulation object (duh).\n \"\"\"\n\n # This is basically just initializing an instance of the cosmology\n # class. Also creates the parameter file attribute ``pf``.\n HaloPopulation.__init__(self, **kwargs)\n #self.pf.update(**kwargs)\n\n @property\n def _sfrd(self):\n if not hasattr(self, '_sfrd_'):\n if self.pf['pop_sfrd'] is None:\n self._sfrd_ = None\n elif type(self.pf['pop_sfrd']) is FunctionType:\n self._sfrd_ = self.pf['pop_sfrd']\n elif inspect.ismethod(self.pf['pop_sfrd']):\n self._sfrd_ = self.pf['pop_sfrd']\n elif inspect.isclass(self.pf['pop_sfrd']):\n\n # Translate to parameter names used by external class\n pmap = self.pf['pop_user_pmap']\n\n # Need to be careful with pop ID numbers here.\n pars = {}\n for key in pmap:\n\n val = pmap[key]\n\n prefix, popid = pop_id_num(val)\n\n if popid != self.id_num:\n continue\n\n pars[key] = self.pf[prefix]\n\n self._sfrd_ = self.pf['pop_sfrd'](**pars)\n elif type(self.pf['pop_sfrd']) is tuple:\n z, sfrd = self.pf['pop_sfrd']\n\n assert np.all(np.diff(z) > 0), \"Redshifts must be ascending.\"\n\n if self.pf['pop_sfrd_units'] == 'internal':\n sfrd[sfrd * rhodot_cgs <= tiny_sfrd] = tiny_sfrd / rhodot_cgs\n else:\n sfrd[sfrd <= tiny_sfrd] = tiny_sfrd\n\n interp = interp1d(z, np.log(sfrd), kind=self.pf['pop_interp_sfrd'],\n bounds_error=False, fill_value=-np.inf)\n\n self._sfrd_ = lambda **kw: np.exp(interp(kw['z']))\n elif isinstance(self.pf['pop_sfrd'], interp1d_scipy):\n self._sfrd_ = self.pf['pop_sfrd']\n elif self.pf['pop_sfrd'][0:2] == 'pq':\n pars = get_pq_pars(self.pf['pop_sfrd'], self.pf)\n self._sfrd_ = ParameterizedQuantity(**pars)\n else:\n tmp = read_lit(self.pf['pop_sfrd'], verbose=self.pf['verbose'])\n self._sfrd_ = lambda z: tmp.SFRD(z, **self.pf['pop_kwargs'])\n\n return self._sfrd_\n\n @_sfrd.setter\n def _sfrd(self, value):\n self._sfrd_ = value\n\n def _sfrd_func(self, z):\n # This is a cheat so that the SFRD spline isn't constructed\n # until CALLED. Used only for tunneling (see `pop_tunnel` parameter).\n return self.SFRD(z)\n\n def SFRD(self, z):\n \"\"\"\n Compute the comoving star formation rate density (SFRD).\n\n Given that we're in the StellarPopulation class, we are assuming\n that all emissivities are tied to the star formation history. The\n SFRD can be supplied explicitly as a function of redshift, or can\n be computed via the \"collapsed fraction\" formalism. That is, compute\n the SFRD given a minimum virial temperature of star forming halos\n (Tmin) and a star formation efficiency (fstar).\n\n If supplied as a function, the units should be Msun yr**-1 cMpc**-3.\n\n Parameters\n ----------\n z : float\n redshift\n\n Returns\n -------\n Co-moving star-formation rate density at redshift z in units of\n g s**-1 cm**-3.\n\n \"\"\"\n\n on = self.on(z)\n if not np.any(on):\n return z * on\n\n # SFRD given by some function\n if self.is_link_sfrd:\n # Already in the right units\n\n return self._sfrd(z) * on\n elif self.is_user_sfrd:\n if self.pf['pop_sfrd_units'] == 'internal':\n return self._sfrd(z=z) * on\n else:\n return self._sfrd(z=z) * on / rhodot_cgs\n\n if (not self.is_fcoll_model) and (not self.is_user_sfe):\n raise ValueError('Must be an fcoll model!')\n\n # SFRD computed via fcoll parameterization\n sfrd = self.pf['pop_fstar'] * self.cosm.rho_b_z0 * self.dfcolldt(z) * on\n\n if np.any(sfrd < 0):\n negative_SFRD(z, self.pf['pop_Tmin'], self.pf['pop_fstar'],\n self.dfcolldz(z) / self.cosm.dtdz(z), sfrd)\n sys.exit(1)\n\n return sfrd\n\n def _frd_func(self, z):\n return self.FRD(z)\n\n def FRD(self, z):\n \"\"\"\n In the odd units of stars / cm^3 / s.\n \"\"\"\n\n return self.SFRD(z) / self.pf['pop_mass'] / g_per_msun\n\n def Emissivity(self, z, E=None, Emin=None, Emax=None):\n \"\"\"\n Compute the emissivity of this population as a function of redshift\n and rest-frame photon energy [eV].\n\n ..note:: If `E` is not supplied, this is a luminosity density in the\n (Emin, Emax) band. Otherwise, if E is supplied, or the SED is\n a delta function, the result is a monochromatic luminosity. If\n nothing is supplied, it's the luminosity density in the\n reference band.\n\n Parameters\n ----------\n z : int, float\n\n Returns\n -------\n Emissivity in units of erg / s / c-cm**3 [/ eV]\n\n \"\"\"\n\n on = self.on(z)\n if not np.any(on):\n return z * on\n\n if self.pf['pop_sed_model'] and (Emin is not None) \\\n and (Emax is not None):\n if (Emin > self.pf['pop_Emax']):\n return 0.0\n if (Emax < self.pf['pop_Emin']):\n return 0.0\n\n # This assumes we're interested in the (EminNorm, EmaxNorm) band\n rhoL = self.SFRD(z) * self.yield_per_sfr * on\n\n ##\n # Models based on photons / baryon\n ##\n if not self.pf['pop_sed_model']:\n if (round(Emin, 1), round(Emax, 1)) == (10.2, 13.6):\n return rhoL * self.pf['pop_Nlw'] * self.pf['pop_fesc_LW'] \\\n * self._get_energy_per_photon(Emin, Emax) * erg_per_ev \\\n / self.cosm.g_per_baryon\n elif round(Emin, 1) == 13.6:\n return rhoL * self.pf['pop_Nion'] * self.pf['pop_fesc'] \\\n * self._get_energy_per_photon(Emin, Emax) * erg_per_ev \\\n / self.cosm.g_per_baryon #/ (Emax - Emin)\n else:\n return rhoL * self.pf['pop_fX'] * self.pf['pop_cX'] \\\n / (g_per_msun / s_per_yr)\n\n # Convert from reference band to arbitrary band\n rhoL *= self._convert_band(Emin, Emax)\n if (Emax is None) or (Emin is None):\n if self.pf['pop_reproc']:\n rhoL *= (1. - self.pf['pop_fesc']) * self.pf['pop_frep']\n elif Emax > E_LL and Emin < self.pf['pop_Emin_xray']:\n rhoL *= self.pf['pop_fesc']\n elif Emax <= E_LL:\n if self.pf['pop_reproc']:\n fesc = (1. - self.pf['pop_fesc']) * self.pf['pop_frep']\n elif Emin >= E_LyA:\n fesc = self.pf['pop_fesc_LW']\n else:\n fesc = 1.\n\n rhoL *= fesc\n\n if E is not None:\n return rhoL * self.src.Spectrum(E)\n else:\n return rhoL\n\n def NumberEmissivity(self, z, E=None, Emin=None, Emax=None):\n return self.Emissivity(z, E=E, Emin=Emin, Emax=Emax) / (E * erg_per_ev)\n\n def LuminosityDensity(self, z, Emin=None, Emax=None):\n \"\"\"\n Return the luminosity density in the (Emin, Emax) band.\n\n Parameters\n ----------\n z : int, flot\n Redshift of interest.\n\n Returns\n -------\n Luminosity density in erg / s / c-cm**3.\n\n \"\"\"\n\n return self.Emissivity(z, Emin=Emin, Emax=Emax)\n\n def PhotonLuminosityDensity(self, z, Emin=None, Emax=None):\n \"\"\"\n Return the photon luminosity density in the (Emin, Emax) band.\n\n Parameters\n ----------\n z : int, flot\n Redshift of interest.\n\n Returns\n -------\n Photon luminosity density in photons / s / c-cm**3.\n\n \"\"\"\n\n rhoL = self.LuminosityDensity(z, Emin, Emax)\n eV_per_phot = self._get_energy_per_photon(Emin, Emax)\n\n return rhoL / (eV_per_phot * erg_per_ev)\n\n def IonizingEfficiency(self, z):\n \"\"\"\n This is not quite the standard definition of zeta. It has an extra\n factor of fbaryon since fstar is implemented throughout the rest of\n the code as an efficiency wrt baryonic inflow, not matter inflow.\n \"\"\"\n zeta = self.pf['pop_Nion'] * self.pf['pop_fesc'] \\\n * self.pf['pop_fstar'] #* self.cosm.fbaryon\n return zeta\n\n def HeatingEfficiency(self, z, fheat=0.2):\n ucorr = s_per_yr * self.cosm.g_per_b / g_per_msun\n zeta_x = fheat * self.pf['pop_rad_yield'] * ucorr \\\n * (2. / 3. / k_B / self.pf['ps_saturated'] / self.cosm.TCMB(z))\n\n return zeta_x\n",
"\"\"\"\n\ntest_sed_mcd.py\n\nAuthor: Jordan Mirocha\nAffiliation: University of Colorado at Boulder\nCreated on: Thu May 2 10:46:44 2013\n\nDescription: Plot a simple multi-color disk accretion spectrum.\n\n\"\"\"\n\nimport ares\nimport numpy as np\n\ndef test():\n rmax = 1e2\n mass = 10.\n fsc = 0.1\n alpha = -1.5\n Emin = 1e2\n Emax = 1e4\n\n simpl = \\\n {\n 'source_type': 'bh',\n 'source_mass': mass,\n 'source_rmax': rmax,\n 'source_sed': 'simpl',\n 'source_Emin': Emin,\n 'source_Emax': Emax,\n 'source_EminNorm': Emin,\n 'source_EmaxNorm': Emax,\n 'source_alpha': alpha,\n 'source_fsc': fsc,\n 'source_logN': 22.,\n }\n\n mcd = \\\n {\n 'source_type': 'bh',\n 'source_sed': 'mcd',\n 'source_mass': mass,\n 'source_rmax': rmax,\n 'source_Emin': Emin,\n 'source_Emax': Emax,\n 'source_EminNorm': Emin,\n 'source_EmaxNorm': Emax,\n }\n\n agn = \\\n {\n 'source_type': 'bh',\n 'source_sed': 'sazonov2004',\n 'source_Emin': Emin,\n 'source_Emax': Emax,\n 'source_EminNorm': Emin,\n 'source_EmaxNorm': Emax,\n }\n\n bh_mcd = ares.sources.BlackHole(init_tabs=False, **mcd)\n bh_sim = ares.sources.BlackHole(init_tabs=False, **simpl)\n bh_s04 = ares.sources.BlackHole(init_tabs=False, **agn)\n\n Earr = np.logspace(2, 4, 100)\n\n for src in [bh_mcd, bh_sim, bh_s04]:\n sed = bh_mcd.Spectrum(Earr)\n\n\nif __name__ == '__main__':\n test()\n",
"import os\nimport copy\nimport pickle\nimport numpy as np\nfrom types import FunctionType\nfrom ..static import Fluctuations\nfrom .Global21cm import Global21cm\nfrom ..physics.HaloModel import HaloModel\nfrom ..util import ParameterFile, ProgressBar\n#from ..analysis.BlobFactory import BlobFactory\nfrom ..analysis.PowerSpectrum import PowerSpectrum as AnalyzePS\nfrom ..physics.Constants import cm_per_mpc, c, s_per_yr, erg_per_ev, \\\n erg_per_s_per_nW, h_p, cm_per_m\n\nclass Simulation(AnalyzePS): # pragma: no cover\n def __init__(self, pf=None, **kwargs):\n \"\"\" Set up a power spectrum calculation. \"\"\"\n\n # See if this is a tanh model calculation\n if 'problem_type' not in kwargs:\n kwargs['problem_type'] = 102\n\n self.tab_kwargs = kwargs\n\n if pf is None:\n self.pf = ParameterFile(**self.tab_kwargs)\n else:\n self.pf = pf\n\n @property\n def gs(self):\n if not hasattr(self, '_gs'):\n self._gs = Global21cm(**self.tab_kwargs)\n return self._gs\n\n @gs.setter\n def gs(self, value):\n \"\"\" Set global 21cm instance by hand. \"\"\"\n self._gs = value\n\n @property\n def history(self):\n if not hasattr(self, '_history'):\n self._history = {}\n return self._history\n\n @property\n def mean_intensity(self):\n if not hasattr(self, '_mean_intensity'):\n self._mean_intensity = self.gs.medium.field\n return self._mean_intensity\n\n def _cache_ebl(self, waves=None, wave_units='mic', flux_units='SI',\n pops=None):\n if not hasattr(self, '_cache_ebl_'):\n self._cache_ebl_ = {}\n\n # Could be clever and convert units here.\n if (wave_units, flux_units, pops) in self._cache_ebl_:\n _waves, _fluxes = self._cache_ebl_[(wave_units, flux_units, pops)]\n if waves is None:\n return _waves, _fluxes\n elif _waves.size == waves.size:\n if np.all(_waves == waves):\n return _waves, _fluxes\n\n return None\n\n def get_ebl(self, waves=None, wave_units='mic', flux_units='SI',\n pops=None):\n \"\"\"\n Return the extragalactic background light (EBL) over all wavelengths.\n\n Parameters\n ----------\n waves : np.ndarray\n If provided, will interpolate fluxes from each source population\n onto common grid.\n wave_units : str\n Current options: 'eV', 'microns', 'Ang'\n flux_units : str\n Current options: 'cgs', 'SI'\n\n .. note :: 'SI' units means nW / m^2 / sr, 'cgs' means erg/s/Hz/sr.\n\n Returns\n -------\n Tuple containing (observed wavelength, observed flux). Note that if\n `waves` is not None, the returned flux array will have shape\n (num source populations, num waves). If not, it will be 1-D with\n the same length as output observed wavelengths.\n\n \"\"\"\n\n cached_result = self._cache_ebl(waves, wave_units, flux_units,\n pops)\n if cached_result is not None:\n return cached_result\n\n if not self.mean_intensity._run_complete:\n self.mean_intensity.run()\n\n if waves is not None:\n all_x = waves\n all_y = np.zeros((len(self.pops), len(waves)))\n else:\n all_x = []\n all_y = []\n\n for i in range(len(self.pops)):\n if pops is not None:\n if i not in pops:\n continue\n\n zf = self.pops[i].zdead\n E, flux = self.mean_intensity.flux_today(zf=None, popids=i,\n units=flux_units)\n\n if wave_units.lower() == 'ev':\n x = E\n elif wave_units.lower().startswith('mic'):\n x = 1e4 * c / (E * erg_per_ev / h_p)\n elif wave_units.lower().startswith('ang'):\n x = 1e8 * c / (E * erg_per_ev / h_p)\n else:\n raise NotImplemented('Unrecognized `wave_units`={}'.format(\n wave_units\n ))\n\n lo, hi = x.min(), x.max()\n\n # Check for overlap, warn user if they should use `waves`\n if i > 0:\n lo_all, hi_all = np.min(all_x), np.max(all_x)\n\n is_overlap = (lo_all <= lo <= hi_all) or (lo_all <= hi <= hi_all)\n if waves is None and is_overlap:\n print(\"# WARNING: Overlap in spectral coverage of population #{}. Consider using `waves` keyword argument.\".format(i))\n\n #\n\n # Either save EBL as potentially-disjointed array of energies\n # OR interpolate to common wavelength grid if `waves` is not None.\n if waves is not None:\n if not np.all(np.diff(x) > 0):\n all_y[i,:] = np.exp(np.interp(np.log(waves[-1::-1]),\n np.log(x[-1::-1]), np.log(flux[-1::-1])))[-1::-1]\n else:\n all_y[i,:] = np.exp(np.interp(np.log(waves), np.log(x),\n np.log(flux)))\n else:\n all_x.extend(E)\n all_y.extend(flux)\n\n # Put a gap between chunks to avoid weird plotting artifacts\n all_x.append(-np.inf)\n all_y.append(-np.inf)\n\n x = np.array(all_x)\n y = np.array(all_y)\n\n if pops is None:\n hist = self.history # poke\n self._history['ebl'] = x, y\n\n return x, y\n\n def get_ps_galaxies(self, scales, waves, wave_units='mic',\n scale_units='arcmin', flux_units='SI', dimensionless=False, pops=None,\n **kwargs):\n \"\"\"\n Compute power spectrum at some observed wavelength.\n\n Parameters\n ----------\n scales : int, float, np.ndarray\n\n waves : int, float, np.ndarray\n Wavelengths at which to compute power spectra in `wave_units`.\n Note that if 2-D, must have shape (number of bins, 2), in which\n case the power spectra will be computed in series of bandpasses.\n\n wave_units : str\n Current options: 'eV', 'microns', 'Ang'\n flux_units : str\n Current options: 'cgs', 'SI'\n scale_units : str\n Current options: 'arcmin', 'arcsec', 'degrees', 'ell'\n\n Returns\n -------\n Tuple containing (scales, 2 pi / scales or l*l(+z),\n waves, power spectra).\n\n Note that the power spectra are return as 2-D arrays with shape\n (len(scales), len(waves))\n\n \"\"\"\n\n # Make sure we do mean background first in case LW feedback is on.\n if not self.mean_intensity._run_complete:\n self.mean_intensity.run()\n\n # Make sure things are arrays\n if type(scales) != np.ndarray:\n scales = np.array([scales])\n if type(waves) != np.ndarray:\n waves = np.array([waves])\n\n if waves.ndim == 2:\n assert waves.shape[1] == 2, \\\n \"If `waves` is 2-D, must have shape (num waves, 2).\"\n\n # Prep scales\n if scale_units.lower() in ['l', 'ell']:\n scales_inv = np.sqrt(scales * (scales + 1))\n else:\n if scale_units.lower().startswith('deg'):\n scale_rad = scales * (np.pi / 180.)\n elif scale_units.lower() == 'arcmin':\n scale_rad = (scales / 60.) * (np.pi / 180.)\n elif scale_units.lower() == 'arcsec':\n scale_rad = (scales / 3600.) * (np.pi / 180.)\n else:\n raise NotImplemented('help')\n\n scales_inv = np.pi / scale_rad\n\n if wave_units.lower().startswith('mic'):\n pass\n else:\n raise NotImplemented('help')\n\n # Do some error-handling if waves is 2-D: means the user provided\n # bandpasses instead of a set of wavelengths.\n\n ps = np.zeros((len(self.pops), len(scales), len(waves)))\n\n for i, pop in enumerate(self.pops):\n\n if pops is not None:\n if i not in pops:\n continue\n\n for j, wave in enumerate(waves):\n ps[i,:,j] = pop.get_ps_obs(scales, wave_obs=wave,\n scale_units=scale_units, **kwargs)\n\n\n # Modify PS units before return\n if flux_units.lower() == 'si':\n ps *= cm_per_m**4 / erg_per_s_per_nW**2\n\n if pops is None:\n hist = self.history # poke\n self._history['ps_nirb'] = scales, scales_inv, waves, ps\n\n if dimensionless:\n ps *= scales_inv[:,None]**2 / 2. / np.pi**2\n\n return scales, scales_inv, waves, ps\n\n @property\n def pops(self):\n return self.gs.medium.field.pops\n\n @property\n def grid(self):\n return self.gs.medium.field.grid\n\n @property\n def hydr(self):\n return self.grid.hydr\n\n @property\n def field(self):\n if not hasattr(self, '_field'):\n self._field = Fluctuations(**self.tab_kwargs)\n return self._field\n\n @property\n def halos(self):\n if not hasattr(self, '_halos'):\n self._halos = self.pops[0].halos\n return self._halos\n\n @property\n def tab_z(self):\n if not hasattr(self, '_tab_z'):\n self._tab_z = np.array(np.sort(self.pf['ps_output_z'])[-1::-1],\n dtype=np.float64)\n return self._tab_z\n\n def run(self):\n \"\"\"\n Run everything we can.\n \"\"\"\n pass\n\n def run_ebl(self):\n pass\n\n def run_nirb_ps(self):\n pass\n\n def get_ps_21cm(self):\n if 'ps_21cm' not in self.history:\n self.run_ps_21cm()\n\n return self.history['ps_21cm']\n\n def get_gs_21cm(self):\n if 'gs_21cm' not in self.history:\n self.gs.run()\n\n return self.history['gs_21cm']\n\n def run_gs_21cm(self):\n self.gs.run()\n self.history['gs_21cm'] = self.gs.history\n\n def run_ps_21cm(self, z=None, k=None):\n \"\"\"\n Run a simulation, compute power spectrum at each redshift.\n\n Returns\n -------\n Nothing: sets `history` attribute.\n\n \"\"\"\n\n if z is None:\n z = self.tab_z\n if k is None:\n k = self.tab_k\n\n # First, run global signal.\n self.run_gs_21cm()\n\n N = z.size\n pb = self.pb = ProgressBar(N, use=self.pf['progress_bar'],\n name='ps-21cm')\n\n all_ps = []\n for i, (z, data) in enumerate(self._step_ps_21cm()):\n\n # Do stuff\n all_ps.append(data.copy())\n\n if i == 0:\n keys = data.keys()\n\n if not pb.has_pb:\n pb.start()\n\n pb.update(i)\n\n pb.finish()\n\n self.all_ps = all_ps\n\n hist = {}\n for key in keys:\n\n is2d_k = key.startswith('ps')\n is2d_R = key.startswith('jp') or key.startswith('ev') \\\n or key.startswith('cf')\n is2d_B = (key in ['n_i', 'm_i', 'r_i', 'delta_B', 'bsd'])\n\n if is2d_k:\n tmp = np.zeros((len(self.tab_z), len(self.tab_k)))\n elif is2d_R:\n tmp = np.zeros((len(self.tab_z), len(self.tab_R)))\n elif is2d_B:\n tmp = np.zeros((len(self.tab_z), len(all_ps[0]['r_i'])))\n else:\n tmp = np.zeros_like(self.tab_z)\n\n for i, z in enumerate(self.tab_z):\n if key not in all_ps[i].keys():\n continue\n\n tmp[i] = all_ps[i][key]\n\n hist[key] = tmp.copy()\n\n poke = self.history\n\n self.history['ps_21cm'] = hist\n self.history['ps_21cm']['z'] = self.tab_z\n self.history['ps_21cm']['k'] = self.tab_k\n self.history['ps_21cm']['R'] = self.tab_R\n\n @property\n def tab_k(self):\n \"\"\"\n Wavenumbers to output power spectra.\n\n .. note :: Can be far more crude than native resolution of\n matter power spectrum.\n\n \"\"\"\n\n if not hasattr(self, '_k'):\n if self.pf['ps_output_k'] is not None:\n self._k = self.pf['ps_output_k']\n else:\n lnk1 = self.pf['ps_output_lnkmin']\n lnk2 = self.pf['ps_output_lnkmax']\n dlnk = self.pf['ps_output_dlnk']\n self._k = np.exp(np.arange(lnk1, lnk2+dlnk, dlnk))\n\n return self._k\n\n @property\n def tab_R(self):\n \"\"\"\n Scales on which to compute correlation functions.\n\n .. note :: Can be more crude than native resolution of matter\n power spectrum, however, unlike `self.tab_k`, the resolution of\n this quantity matters when converting back to power spectra,\n since that operation requires an integral over R.\n\n \"\"\"\n if not hasattr(self, '_R'):\n if self.pf['ps_output_R'] is not None:\n self._R = self.pf['ps_output_R']\n else:\n lnR1 = self.pf['ps_output_lnRmin']\n lnR2 = self.pf['ps_output_lnRmax']\n dlnR = self.pf['ps_output_dlnR']\n #lnR = np.log(self.halos.tab_R)\n\n self._R = np.exp(np.arange(lnR1, lnR2+dlnR, dlnR))\n\n return self._R\n\n @property\n def tab_Mmin(self):\n if not hasattr(self, '_tab_Mmin'):\n self._tab_Mmin = np.ones_like(self.halos.tab_z) * np.inf\n for j, pop in enumerate(self.pops):\n self._tab_Mmin = np.minimum(self._tab_Mmin, pop._tab_Mmin)\n\n return self._tab_Mmin\n\n\n @property\n def tab_zeta(self):\n return self._tab_zeta\n\n @tab_zeta.setter\n def tab_zeta(self, value):\n self._tab_zeta = value\n\n def _step_ps_21cm(self):\n \"\"\"\n Generator for the power spectrum.\n \"\"\"\n\n # Set a few things before we get moving.\n self.field.tab_Mmin = self.tab_Mmin\n\n for i, z in enumerate(self.tab_z):\n\n data = {}\n\n ##\n # First, loop over populations and determine total\n # UV and X-ray outputs.\n ##\n\n # Prepare for the general case of Mh-dependent things\n Nion = np.zeros_like(self.halos.tab_M)\n Nlya = np.zeros_like(self.halos.tab_M)\n fXcX = np.zeros_like(self.halos.tab_M)\n zeta_ion = zeta = np.zeros_like(self.halos.tab_M)\n zeta_lya = np.zeros_like(self.halos.tab_M)\n zeta_X = np.zeros_like(self.halos.tab_M)\n #Tpro = None\n for j, pop in enumerate(self.pops):\n pop_zeta = pop.IonizingEfficiency(z=z)\n\n if pop.is_src_ion:\n\n if type(pop_zeta) is tuple:\n _Mh, _zeta = pop_zeta\n zeta += np.interp(self.halos.tab_M, _Mh, _zeta)\n Nion += pop.src.Nion\n else:\n zeta += pop_zeta\n Nion += pop.pf['pop_Nion']\n Nlya += pop.pf['pop_Nlw']\n\n zeta = np.maximum(zeta, 1.) # why?\n\n if pop.is_src_heat:\n pop_zeta_X = pop.HeatingEfficiency(z=z)\n zeta_X += pop_zeta_X\n\n if pop.is_src_lya:\n Nlya += pop.pf['pop_Nlw']\n #Nlya += pop.src.Nlw\n\n # Only used if...ps_lya_method==0?\n zeta_lya += zeta * (Nlya / Nion)\n\n ##\n # Make scalar if it's a simple model\n ##\n if np.all(np.diff(zeta) == 0):\n zeta = zeta[0]\n if np.all(np.diff(zeta_X) == 0):\n zeta_X = zeta_X[0]\n if np.all(np.diff(zeta_lya) == 0):\n zeta_lya = zeta_lya[0]\n\n self.field.zeta = zeta\n self.field.zeta_X = zeta_X\n\n self.tab_zeta = zeta\n\n ##\n # Figure out scaling from ionized regions to heated regions.\n # Right now, only constant (relative) scaling is allowed.\n ##\n asize = self.pf['bubble_shell_asize_zone_0']\n if self.pf['ps_include_temp'] and asize is not None:\n\n self.field.is_Rs_const = False\n\n if type(asize) is FunctionType:\n R_s = lambda R, z: R + asize(z)\n else:\n R_s = lambda R, z: R + asize\n\n elif self.pf['ps_include_temp'] and self.pf['ps_include_ion']:\n fvol = self.pf[\"bubble_shell_rvol_zone_0\"]\n frad = self.pf['bubble_shell_rsize_zone_0']\n\n assert (fvol is not None) + (frad is not None) <= 1\n\n if fvol is not None:\n assert frad is None\n\n # Assume independent variable is redshift for now.\n if type(fvol) is FunctionType:\n frad = lambda z: (1. + fvol(z))**(1./3.) - 1.\n self.field.is_Rs_const = False\n else:\n frad = lambda z: (1. + fvol)**(1./3.) - 1.\n\n elif frad is not None:\n if type(frad) is FunctionType:\n self.field.is_Rs_const = False\n else:\n frad = lambda z: frad\n else:\n # If R_s = R_s(z), must re-compute overlap volumes on each\n # step. Should set attribute if this is the case.\n raise NotImplemented('help')\n\n R_s = lambda R, z: R * (1. + frad(z))\n\n\n else:\n R_s = lambda R, z: None\n Th = None\n\n # Must be constant, for now.\n Th = self.pf[\"bubble_shell_ktemp_zone_0\"]\n\n self.tab_R_s = R_s\n self.Th = Th\n\n\n ##\n # First: some global quantities we'll need\n ##\n Tcmb = self.cosm.TCMB(z)\n hist = self.gs.history\n\n Tk = np.interp(z, hist['z'][-1::-1], hist['igm_Tk'][-1::-1])\n Ts = np.interp(z, hist['z'][-1::-1], hist['igm_Ts'][-1::-1])\n Ja = np.interp(z, hist['z'][-1::-1], hist['Ja'][-1::-1])\n xHII, ne = [0] * 2\n\n xa = self.hydr.RadiativeCouplingCoefficient(z, Ja, Tk)\n xc = self.hydr.CollisionalCouplingCoefficient(z, Tk)\n xt = xa + xc\n\n # Won't be terribly meaningful if temp fluctuations are off.\n C = self.field.TempToContrast(z, Th=Th, Tk=Tk, Ts=Ts, Ja=Ja)\n data['c'] = C\n data['Ts'] = Ts\n data['Tk'] = Tk\n data['xa'] = xa\n data['Ja'] = Ja\n\n\n\n # Assumes strong coupling. Mapping between temperature\n # fluctuations and contrast fluctuations.\n #Ts = Tk\n\n\n # Add beta factors to dictionary\n for f1 in ['x', 'd', 'a']:\n func = self.hydr.__getattribute__('beta_%s' % f1)\n data['beta_%s' % f1] = func(z, Tk, xHII, ne, Ja)\n\n Qi_gs = np.interp(z, self.gs.history['z'][-1::-1],\n self.gs.history['cgm_h_2'][-1::-1])\n\n # Ionization fluctuations\n if self.pf['ps_include_ion']:\n\n Ri, Mi, Ni = self.field.BubbleSizeDistribution(z, ion=True)\n\n data['n_i'] = Ni\n data['m_i'] = Mi\n data['r_i'] = Ri\n data['delta_B'] = self.field._B(z, ion=True)\n else:\n Ri = Mi = Ni = None\n\n Qi = self.field.MeanIonizedFraction(z)\n\n Qi_bff = self.field.BubbleFillingFactor(z)\n\n xibar = Qi_gs\n\n\n # Save normalized copy of BSD for easy plotting in post\n dvdr = 4. * np.pi * Ri**2\n dmdr = self.cosm.mean_density0 * (1. + data['delta_B']) * dvdr\n dmdlnr = dmdr * Ri\n dndlnR = Ni * dmdlnr\n V = 4. * np.pi * Ri**3 / 3.\n data['bsd'] = V * dndlnR / Qi\n\n if self.pf['ps_include_temp']:\n # R_s=R_s(Ri,z)\n Qh = self.field.MeanIonizedFraction(z, ion=False)\n data['Qh'] = Qh\n else:\n data['Qh'] = Qh = 0.0\n\n # Interpolate global signal onto new (coarser) redshift grid.\n dTb_ps = np.interp(z, self.gs.history['z'][-1::-1],\n self.gs.history['dTb'][-1::-1])\n\n xavg_gs = np.interp(z, self.gs.history['z'][-1::-1],\n self.gs.history['xavg'][-1::-1])\n\n data['dTb'] = dTb_ps\n\n #data['dTb_bulk'] = np.interp(z, self.gs.history['z'][-1::-1],\n # self.gs.history['dTb_bulk'][-1::-1])\n\n\n ##\n # Correct for fraction of ionized and heated volumes\n # and densities!\n ##\n if self.pf['ps_include_temp']:\n data['dTb_vcorr'] = None#(1 - Qh - Qi) * data['dTb_bulk'] \\\n #+ Qh * self.hydr.dTb(z, 0.0, Th)\n else:\n data['dTb_vcorr'] = None#data['dTb_bulk'] * (1. - Qi)\n\n if self.pf['ps_include_xcorr_ion_rho']:\n pass\n if self.pf['ps_include_xcorr_ion_hot']:\n pass\n\n # Just for now\n data['dTb0'] = data['dTb']\n data['dTb0_2'] = data['dTb0_1'] = data['dTb_vcorr']\n\n #if self.pf['include_ion_fl']:\n # if self.pf['ps_rescale_Qion']:\n # xibar = min(np.interp(z, self.pops[0].halos.z,\n # self.pops[0].halos.fcoll_Tmin) * zeta, 1.)\n # Qi = xibar\n #\n # xibar = np.interp(z, self.mean_history['z'][-1::-1],\n # self.mean_history['cgm_h_2'][-1::-1])\n #\n # else:\n # Qi = self.field.BubbleFillingFactor(z, zeta)\n # xibar = 1. - np.exp(-Qi)\n #else:\n # Qi = 0.\n\n\n\n #if self.pf['ps_force_QHII_gs'] or self.pf['ps_force_QHII_fcoll']:\n # rescale_Q = True\n #else:\n # rescale_Q = False\n\n #Qi = np.mean([QHII_gs, self.field.BubbleFillingFactor(z, zeta)])\n\n #xibar = np.interp(z, self.mean_history['z'][-1::-1],\n # self.mean_history['cgm_h_2'][-1::-1])\n\n # Avoid divide by zeros when reionization is over\n if Qi == 1:\n Tbar = 0.0\n else:\n Tbar = data['dTb0_2']\n\n xbar = 1. - xibar\n data['Qi'] = Qi\n data['xibar'] = xibar\n data['dTb0'] = Tbar\n #data['dTb_bulk'] = dTb_ps / (1. - xavg_gs)\n\n ##\n # 21-cm fluctuations\n ##\n if self.pf['ps_include_21cm']:\n\n data['cf_21'] = self.field.CorrelationFunction(z,\n R=self.tab_R, term='21', R_s=R_s(Ri,z), Ts=Ts, Th=Th,\n Tk=Tk, Ja=Ja, k=self.tab_k)\n\n # Always compute the 21-cm power spectrum. Individual power\n # spectra can be saved by setting ps_save_components=True.\n data['ps_21'] = self.field.PowerSpectrumFromCF(self.tab_k,\n data['cf_21'], self.tab_R,\n split_by_scale=self.pf['ps_split_transform'],\n epsrel=self.pf['ps_fht_rtol'],\n epsabs=self.pf['ps_fht_atol'])\n\n # Should just do the above, and then loop over whatever is in\n # the cache and save also. If ps_save_components is True, then\n # FT everything we haven't already.\n for term in ['dd', 'ii', 'id', 'psi', 'phi']:\n # Should change suffix to _ev\n jp_1 = self.field._cache_jp(z, term)\n cf_1 = self.field._cache_cf(z, term)\n\n if (jp_1 is None and cf_1 is None) and (term not in ['psi', 'phi', 'oo']):\n continue\n\n _cf = self.field.CorrelationFunction(z,\n R=self.tab_R, term=term, R_s=R_s(Ri,z), Ts=Ts, Th=Th,\n Tk=Tk, Ja=Ja, k=self.tab_k)\n\n data['cf_{}'.format(term)] = _cf.copy()\n\n if not self.pf['ps_output_components']:\n continue\n\n data['ps_{}'.format(term)] = \\\n self.field.PowerSpectrumFromCF(self.tab_k,\n data['cf_{}'.format(term)], self.tab_R,\n split_by_scale=self.pf['ps_split_transform'],\n epsrel=self.pf['ps_fht_rtol'],\n epsabs=self.pf['ps_fht_atol'])\n\n # Always save the matter correlation function.\n data['cf_dd'] = self.field.CorrelationFunction(z,\n term='dd', R=self.tab_R)\n\n yield z, data\n\n def save(self, prefix, suffix='pkl', clobber=False, fields=None):\n \"\"\"\n Save results of calculation. Pickle parameter file dict.\n\n Notes\n -----\n 1) will save files as prefix.history.suffix and prefix.parameters.pkl.\n 2) ASCII files will fail if simulation had multiple populations.\n\n Parameters\n ----------\n prefix : str\n Prefix of save filename\n suffix : str\n Suffix of save filename. Can be hdf5 (or h5) or pkl.\n Anything else will be assumed to be ASCII format (e.g., .txt).\n clobber : bool\n Overwrite pre-existing files of same name?\n\n \"\"\"\n\n self.gs.save(prefix, clobber=clobber, fields=fields)\n\n fn = '%s.fluctuations.%s' % (prefix, suffix)\n\n if os.path.exists(fn):\n if clobber:\n os.remove(fn)\n else:\n raise IOError('%s exists! Set clobber=True to overwrite.' % fn)\n\n if suffix == 'pkl':\n f = open(fn, 'wb')\n pickle.dump(self.history._data, f)\n f.close()\n\n try:\n f = open('%s.blobs.%s' % (prefix, suffix), 'wb')\n pickle.dump(self.blobs, f)\n f.close()\n\n if self.pf['verbose']:\n print('Wrote {}.blobs.{}'.format(prefix, suffix))\n except AttributeError:\n print('Error writing {}.blobs.{}'.format(prefix, suffix))\n\n elif suffix in ['hdf5', 'h5']:\n import h5py\n\n f = h5py.File(fn, 'w')\n for key in self.history:\n if fields is not None:\n if key not in fields:\n continue\n f.create_dataset(key, data=np.array(self.history[key]))\n f.close()\n\n # ASCII format\n else:\n f = open(fn, 'w')\n print >> f, \"#\",\n\n for key in self.history:\n if fields is not None:\n if key not in fields:\n continue\n print >> f, '%-18s' % key,\n\n print >> f, ''\n\n # Now, the data\n for i in range(len(self.history[key])):\n s = ''\n\n for key in self.history:\n if fields is not None:\n if key not in fields:\n continue\n\n s += '%-20.8e' % (self.history[key][i])\n\n if not s.strip():\n continue\n\n print >> f, s\n\n f.close()\n\n if self.pf['verbose']:\n print('Wrote {}.fluctuations.{}'.format(prefix, suffix))\n\n #write_pf = True\n #if os.path.exists('%s.parameters.pkl' % prefix):\n # if clobber:\n # os.remove('%s.parameters.pkl' % prefix)\n # else:\n # write_pf = False\n # print 'WARNING: %s.parameters.pkl exists! Set clobber=True to overwrite.' % prefix\n\n #if write_pf:\n #\n # #pf = {}\n # #for key in self.pf:\n # # if key in self.carryover_kwargs():\n # # continue\n # # pf[key] = self.pf[key]\n #\n # if 'revision' not in self.pf:\n # self.pf['revision'] = get_hg_rev()\n #\n # # Save parameter file\n # f = open('%s.parameters.pkl' % prefix, 'wb')\n # pickle.dump(self.pf, f, -1)\n # f.close()\n #\n # if self.pf['verbose']:\n # print 'Wrote %s.parameters.pkl' % prefix\n #\n",
"\"\"\"\n\ntest_physics_cross_sections.py\n\nAuthor: Jordan Mirocha\nAffiliation: University of Colorado at Boulder\nCreated on: Mon Apr 22 10:54:18 2013\n\nDescription:\n\n\"\"\"\n\nimport numpy as np\nfrom ares.physics.CrossSections import PhotoIonizationCrossSection, \\\n ApproximatePhotoIonizationCrossSection\n\ndef test():\n\n E = np.logspace(np.log10(13.6), 4)\n\n sigma = PhotoIonizationCrossSection\n sigma_approx = ApproximatePhotoIonizationCrossSection\n\n for species in [0, 1]:\n _sigma = np.array([sigma(EE, species) for EE in E])\n _sigma_approx = np.array([sigma_approx(EE, species) for EE in E])\n\n assert np.allclose(_sigma, _sigma_approx, rtol=3e-1)\n\nif __name__ == '__main__':\n test()\n",
"\"\"\"\n\ntest_21cm_tanh.py\n\nAuthor: Jordan Mirocha\nAffiliation: University of Colorado at Boulder\nCreated on: Tue Sep 9 20:03:58 MDT 2014\n\nDescription:\n\n\"\"\"\n\nimport ares\nimport numpy as np\n\ndef test():\n\n sim = ares.simulations.Global21cm(tanh_model=True)\n sim.run()\n\n sim2 = ares.simulations.Global21cm(gaussian_model=True)\n sim2.run()\n\n p = \\\n {\n 'parametric_model': True,\n 'pop_Ja': lambda z: 1e-2 * ((1. + z) / 10.)**-4.,\n 'pop_Tk': lambda z: 1e2 * (1. - np.exp(-(15. / z)**4)),\n 'pop_xi': lambda z: 1. - np.exp(-(10. / z)**4),\n }\n\n sim3 = ares.simulations.Global21cm(**p)\n sim3.run()\n \nif __name__ == \"__main__\":\n test()\n"
] | [
[
"numpy.log",
"numpy.diff",
"numpy.any"
],
[
"numpy.logspace"
],
[
"numpy.log",
"numpy.ones_like",
"numpy.sqrt",
"numpy.minimum",
"numpy.min",
"numpy.maximum",
"numpy.arange",
"numpy.sort",
"numpy.all",
"numpy.max",
"numpy.zeros_like",
"numpy.interp",
"numpy.diff",
"numpy.array"
],
[
"numpy.log10",
"numpy.allclose"
],
[
"numpy.exp"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
jaavad/muzero-general | [
"cbe089c63480f983c457518d1768fe2db6f562df"
] | [
"games/spiel.py"
] | [
"import datetime\nimport pathlib\n\nimport numpy\nimport torch\n\nfrom .abstract_game import AbstractGame\n\n\n# This is a Game wrapper for open_spiel games. It allows you to run any game in the open_spiel library.\n\ntry:\n import pyspiel\n\nexcept ImportError:\n import sys\n\n sys.exit(\n \"You need to install open_spiel by running pip install open_spiel. For a full documentation, see: https://github.com/deepmind/open_spiel/blob/master/docs/install.md\"\n )\n\n# The game you want to run. See https://github.com/deepmind/open_spiel/blob/master/docs/games.md for a list of games\ngame = pyspiel.load_game(\"amazons\")\n\n\nclass MuZeroConfig:\n def __init__(self):\n # fmt: off\n # More information is available here: https://github.com/werner-duvaud/muzero-general/wiki/Hyperparameter-Optimization\n\n self.game = game\n\n self.seed = 0 # Seed for numpy, torch and the game\n self.max_num_gpus = None # Fix the maximum number of GPUs to use. It's usually faster to use a single GPU (set it to 1) if it has enough memory. None will use every GPUs available\n\n\n\n ### Game\n self.observation_shape = tuple(self.game.observation_tensor_shape()) # Dimensions of the game observation, must be 3D (channel, height, width). For a 1D array, please reshape it to (1, 1, length of array)\n self.action_space = list(range(self.game.policy_tensor_shape()[0])) # Fixed list of all possible actions. You should only edit the length\n self.players = list(range(self.game.num_players())) # List of players. You should only edit the length\n self.stacked_observations = 0 # Number of previous observations and previous actions to add to the current observation\n\n # Evaluate\n self.muzero_player = 0 # Turn Muzero begins to play (0: MuZero plays first, 1: MuZero plays second)\n self.opponent = \"self\" # Hard coded agent that MuZero faces to assess his progress in multiplayer games. It doesn't influence training. None, \"random\" or \"expert\" if implemented in the Game class\n\n\n\n ### Self-Play\n self.num_workers = 2 # Number of simultaneous threads/workers self-playing to feed the replay buffer\n self.selfplay_on_gpu = False\n self.max_moves = self.game.max_game_length() # Maximum number of moves if game is not finished before\n self.num_simulations = 25 # Number of future moves self-simulated\n self.discount = 0.1 # Chronological discount of the reward\n self.temperature_threshold = None # Number of moves before dropping the temperature given by visit_softmax_temperature_fn to 0 (ie selecting the best action). If None, visit_softmax_temperature_fn is used every time\n\n # Root prior exploration noise\n self.root_dirichlet_alpha = 0.1\n self.root_exploration_fraction = 0.25\n\n # UCB formula\n self.pb_c_base = 19652\n self.pb_c_init = 1.25\n\n\n\n ### Network\n self.network = \"resnet\" # \"resnet\" / \"fullyconnected\"\n self.support_size = 10 # Value and reward are scaled (with almost sqrt) and encoded on a vector with a range of -support_size to support_size. Choose it so that support_size <= sqrt(max(abs(discounted reward)))\n\n # Residual Network\n self.downsample = False # Downsample observations before representation network, False / \"CNN\" (lighter) / \"resnet\" (See paper appendix Network Architecture)\n self.blocks = 2 # Number of blocks in the ResNet\n self.channels = 16 # Number of channels in the ResNet\n self.reduced_channels_reward = 16 # Number of channels in reward head\n self.reduced_channels_value = 16 # Number of channels in value head\n self.reduced_channels_policy = 16 # Number of channels in policy head\n self.resnet_fc_reward_layers = [8] # Define the hidden layers in the reward head of the dynamic network\n self.resnet_fc_value_layers = [8] # Define the hidden layers in the value head of the prediction network\n self.resnet_fc_policy_layers = [8] # Define the hidden layers in the policy head of the prediction network\n\n # Fully Connected Network\n self.encoding_size = 32\n self.fc_representation_layers = [] # Define the hidden layers in the representation network\n self.fc_dynamics_layers = [16] # Define the hidden layers in the dynamics network\n self.fc_reward_layers = [16] # Define the hidden layers in the reward network\n self.fc_value_layers = [] # Define the hidden layers in the value network\n self.fc_policy_layers = [] # Define the hidden layers in the policy network\n\n\n\n ### Training\n self.results_path = pathlib.Path(__file__).resolve().parents[1] / \"results\" / pathlib.Path(__file__).stem / datetime.datetime.now().strftime(\"%Y-%m-%d--%H-%M-%S\") # Path to store the model weights and TensorBoard logs\n self.save_model = True # Save the checkpoint in results_path as model.checkpoint\n self.training_steps = 200000 #1000000 # Total number of training steps (ie weights update according to a batch)\n self.batch_size = 64 # Number of parts of games to train on at each training step\n self.checkpoint_interval = 10 # Number of training steps before using the model for self-playing\n self.value_loss_weight = 0.25 # Scale the value loss to avoid overfitting of the value function, paper recommends 0.25 (See paper appendix Reanalyze)\n self.train_on_gpu = torch.cuda.is_available() # Train on GPU if available\n\n self.optimizer = \"Adam\" # \"Adam\" or \"SGD\". Paper uses SGD\n self.weight_decay = 1e-4 # L2 weights regularization\n self.momentum = 0.9 # Used only if optimizer is SGD\n\n # Exponential learning rate schedule\n self.lr_init = 0.003 # Initial learning rate\n self.lr_decay_rate = 1 # Set it to 1 to use a constant learning rate\n self.lr_decay_steps = 10000\n\n\n\n ### Replay Buffer\n self.replay_buffer_size = 3000 # Number of self-play games to keep in the replay buffer\n self.num_unroll_steps = 20 # Number of game moves to keep for every batch element\n self.td_steps = 20 # Number of steps in the future to take into account for calculating the target value\n self.PER = True # Prioritized Replay (See paper appendix Training), select in priority the elements in the replay buffer which are unexpected for the network\n self.PER_alpha = 0.5 # How much prioritization is used, 0 corresponding to the uniform case, paper suggests 1\n\n # Reanalyze (See paper appendix Reanalyse)\n self.use_last_model_value = True # Use the last model to provide a fresher, stable n-step value (See paper appendix Reanalyze)\n self.reanalyse_on_gpu = False\n\n\n\n ### Adjust the self play / training ratio to avoid over/underfitting\n self.self_play_delay = 0 # Number of seconds to wait after each played game\n self.training_delay = 0 # Number of seconds to wait after each training step\n self.ratio = None # Desired training steps per self played step ratio. Equivalent to a synchronous version, training can take much longer. Set it to None to disable it\n # fmt: on\n\n def visit_softmax_temperature_fn(self, trained_steps):\n \"\"\"\n Parameter to alter the visit count distribution to ensure that the action selection becomes greedier as training progresses.\n The smaller it is, the more likely the best action (ie with the highest visit count) is chosen.\n\n Returns:\n Positive float.\n \"\"\"\n return 1\n\n\nclass Game(AbstractGame):\n \"\"\"\n Game wrapper.\n \"\"\"\n\n def __init__(self, seed=None):\n self.env = Spiel()\n\n def step(self, action):\n \"\"\"\n Apply action to the game.\n\n Args:\n action : action of the action_space to take.\n\n Returns:\n The new observation, the reward and a boolean if the game has ended.\n \"\"\"\n observation, reward, done = self.env.step(action)\n return observation, reward * 20, done\n\n def to_play(self):\n \"\"\"\n Return the current player.\n\n Returns:\n The current player, it should be an element of the players list in the config.\n \"\"\"\n return self.env.to_play()\n\n def legal_actions(self):\n \"\"\"\n Should return the legal actions at each turn, if it is not available, it can return\n the whole action space. At each turn, the game have to be able to handle one of returned actions.\n\n For complex game where calculating legal moves is too long, the idea is to define the legal actions\n equal to the action space but to return a negative reward if the action is illegal.\n\n Returns:\n An array of integers, subset of the action space.\n \"\"\"\n return self.env.legal_actions()\n\n def reset(self):\n \"\"\"\n Reset the game for a new game.\n\n Returns:\n Initial observation of the game.\n \"\"\"\n return self.env.reset()\n\n def render(self):\n \"\"\"\n Display the game observation.\n \"\"\"\n self.env.render()\n input(\"Press enter to take a step \")\n\n def legal_actions_human(self):\n return self.env.human_legal_actions()\n\n def human_to_action(self):\n \"\"\"\n For multiplayer games, ask the user for a legal action\n and return the corresponding action number.\n\n Returns:\n An integer from the action space.\n \"\"\"\n while True:\n try:\n print(\"Legal Actions: \", self.legal_actions_human())\n choice = input(\"Enter your move: \")\n if choice in self.legal_actions_human():\n break\n except:\n pass\n print(\"Wrong input, try again\")\n\n return self.env.board.string_to_action(choice)\n\n def action_to_string(self, action_number):\n \"\"\"\n Convert an action number to a string representing the action.\n\n Args:\n action_number: an integer from the action space.\n\n Returns:\n String representing the action.\n \"\"\"\n row = action_number // 3 + 1\n col = action_number % 3 + 1\n return f\"Play row {row}, column {col}\"\n\n\nclass Spiel:\n def __init__(self):\n self.game = game\n self.board = self.game.new_initial_state()\n self.player = 1\n\n def to_play(self):\n return 0 if self.player == 1 else 1\n\n def reset(self):\n self.board = self.game.new_initial_state()\n self.player = 1\n return self.get_observation()\n\n def step(self, action):\n self.board = self.board.child(action)\n\n done = self.board.is_terminal()\n\n reward = 1 if self.have_winner() else 0\n\n observation = self.get_observation()\n\n self.player *= -1\n\n return observation, reward, done\n\n def get_observation(self):\n if self.player == 1:\n current_player = 1\n else:\n current_player = 0\n return numpy.array(self.board.observation_tensor(current_player)).reshape(\n self.game.observation_tensor_shape()\n )\n\n def legal_actions(self):\n return self.board.legal_actions()\n\n def have_winner(self):\n rewards = self.board.rewards()\n\n if self.player == 1:\n\n if rewards[0] == 1.0:\n return True\n\n elif self.player == -1:\n if rewards[1] == 1.0:\n return True\n\n return False\n\n def human_legal_actions(self):\n return [self.board.action_to_string(x) for x in self.board.legal_actions()]\n\n def render(self):\n print(self.board)\n"
] | [
[
"torch.cuda.is_available"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
daizutabi/ivory | [
"d961e6c05ece112d99b8f8c2d6dad530f60b7303"
] | [
"tests/tensorflow/test_tensorflow_mnist.py"
] | [
"import numpy as np\n\n\ndef test_mnist(client):\n run = client.create_run(\"mnist\")\n run.start(\"train\")\n run.start(\"test\")\n assert run.results.train[\"output\"].shape == (800, 10)\n assert run.results.val[\"output\"].shape == (200, 10)\n assert run.results.test[\"output\"].shape == (100, 10)\n print(run.metrics.val_acc, run.metrics.score)\n assert np.allclose(run.metrics.val_acc, run.metrics.score)\n assert np.allclose(run.metrics.val_acc, run.metrics.callback_score)\n\n assert repr(run.trainer) == \"Trainer()\"\n"
] | [
[
"numpy.allclose"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
iwyoo/tf_ConvWTA | [
"a423f6ff8683e0bcf9b0269e0d4e31d068dfae14"
] | [
"model.py"
] | [
"import tensorflow as tf\n\n\"\"\"\nConvolutioanl Winner-Take-All Autoencoder TensorFlow implementation.\nUsage :\n ae = ConvWTA(sess)\n\n # 1. to train an Autoencoder\n loss = ae.loss(x)\n train = optimizer.minimize(loss)\n sess.run(train, feed_dict={...})\n\n # 2. to get the sparse codes\n h = ae.encoder(x)\n sess.run(h, feed_dict={...})\n\n # 3. to get the reconstructed results\n y = ae.reconstruct(x)\n sess.run(y, feed_dict={...})\n\n # 4. to get the learned features\n f = ae.features() # np.float32 array with shape [11, 11, 1, 16]\n # 4-1. to train a different number of features\n ae = ConvWTA(sess, num_features=32)\n\n # 5. to save & restore the variables\n ae.save(save_path)\n ae.restore(save_path)\n\nReference: \n [1] https://arxiv.org/pdf/1409.2752.pdf\n\"\"\"\n\nclass ConvWTA(object):\n \"\"\"\n Args :\n sess : TensorFlow session.\n x : Input tensor.\n \"\"\"\n def __init__(self, sess, num_features=16, name=\"ConvWTA\"):\n self.sess = sess\n self.name = name\n self.size = [1, 128, 128, num_features] # ref [1]\n\n self._set_variables()\n self.t_vars = tf.get_collection(\n tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name)\n self.sess.run(tf.variables_initializer(self.t_vars))\n self.saver = tf.train.Saver(self.t_vars)\n \n def encoder(self, x):\n with tf.variable_scope(self.name) as vs:\n h = self._conv(x, self.size[1], 5, 5, 1, 1, \"conv_1\")\n h = self._conv(h, self.size[2], 5, 5, 1, 1, \"conv_2\")\n h = self._conv(h, self.size[3], 5, 5, 1, 1, \"conv_3\")\n return h\n\n def _decoder(self, h):\n shape = tf.shape(h)\n out_shape = tf.stack([shape[0], shape[1], shape[2], 1])\n with tf.variable_scope(self.name) as vs:\n y = self._deconv(h, out_shape, self.size[0], \n 11, 11, 1, 1, \"deconv\", end=True)\n return y\n\n def loss(self, x, lifetime_sparsity=0.20):\n h = self.encoder(x)\n h, winner = self._spatial_sparsity(h)\n h = self._lifetime_sparsity(h, winner, lifetime_sparsity)\n y = self._decoder(h)\n\n return tf.reduce_sum(tf.square(y - x))\n\n def reconstruct(self, x):\n h = self.encoder(x)\n h, _ = self._spatial_sparsity(h)\n y = self._decoder(h)\n return y\n \n def _set_variables(self):\n with tf.variable_scope(self.name) as vs:\n self._conv_var(self.size[0], self.size[1], 5, 5, \"conv_1\")\n self._conv_var(self.size[1], self.size[2], 5, 5, \"conv_2\")\n self._conv_var(self.size[2], self.size[3], 5, 5, \"conv_3\")\n self.f, _ = self._deconv_var(\n self.size[-1], self.size[0], 11, 11, \"deconv\")\n \n def _conv_var(self, in_dim, out_dim, k_h, k_w, name, stddev=0.1):\n with tf.variable_scope(name) as vs:\n k = tf.get_variable('filter',\n [k_h, k_w, in_dim, out_dim],\n initializer=tf.truncated_normal_initializer(stddev=stddev))\n b = tf.get_variable('biases', [out_dim],\n initializer=tf.constant_initializer(0.0001))\n return k, b\n\n def _deconv_var(self, in_dim, out_dim, k_h, k_w, name, stddev=0.1):\n with tf.variable_scope(name) as vs:\n k = tf.get_variable('filter',\n [k_h, k_w, out_dim, in_dim],\n initializer=tf.truncated_normal_initializer(stddev=stddev))\n b = tf.get_variable('biases', [out_dim],\n initializer=tf.constant_initializer(0.0001))\n return k, b\n\n def _conv(self, x, out_dim, \n k_h, k_w, s_h, s_w, name, end=False):\n with tf.variable_scope(name, reuse=True) as vs:\n k = tf.get_variable('filter')\n b = tf.get_variable('biases')\n conv = tf.nn.conv2d(x, k, [1, s_h, s_w, 1], \"SAME\") + b\n return conv if end else tf.nn.relu(conv)\n\n def _deconv(self, x, out_shape, out_dim,\n k_h, k_w, s_h, s_w, name, end=False):\n with tf.variable_scope(name, reuse=True) as vs:\n k = tf.get_variable('filter')\n b = tf.get_variable('biases')\n deconv = tf.nn.conv2d_transpose(\n x, k, out_shape, [1, s_h, s_w, 1], \"SAME\") + b\n return deconv if end else tf.nn.relu(deconv)\n\n def _spatial_sparsity(self, h):\n shape = tf.shape(h)\n n = shape[0]\n c = shape[3]\n\n h_t = tf.transpose(h, [0, 3, 1, 2]) # n, c, h, w\n h_r = tf.reshape(h_t, tf.stack([n, c, -1])) # n, c, h*w\n\n th, _ = tf.nn.top_k(h_r, 1) # n, c, 1\n th_r = tf.reshape(th, tf.stack([n, 1, 1, c])) # n, 1, 1, c\n drop = tf.where(h < th_r, \n tf.zeros(shape, tf.float32), tf.ones(shape, tf.float32))\n\n # spatially dropped & winner\n return h*drop, tf.reshape(th, tf.stack([n, c])) # n, c\n \n def _lifetime_sparsity(self, h, winner, rate):\n shape = tf.shape(winner)\n n = shape[0]\n c = shape[1]\n k = tf.cast(rate * tf.cast(n, tf.float32), tf.int32)\n\n winner = tf.transpose(winner) # c, n\n th_k, _ = tf.nn.top_k(winner, k) # c, k\n\n shape_t = tf.stack([c, n])\n drop = tf.where(winner < th_k[:,k-1:k], # c, n\n tf.zeros(shape_t, tf.float32), tf.ones(shape_t, tf.float32))\n drop = tf.transpose(drop) # n, c\n return h * tf.reshape(drop, tf.stack([n, 1, 1, c]))\n\n def features(self): \n return self.sess.run(self.f)\n \n def save(self, ckpt_path):\n self.saver.save(self.sess, ckpt_path)\n\n def restore(self, ckpt_path):\n self.saver.restore(self.sess, ckpt_path)\n"
] | [
[
"tensorflow.nn.relu",
"tensorflow.get_variable",
"tensorflow.transpose",
"tensorflow.shape",
"tensorflow.get_collection",
"tensorflow.stack",
"tensorflow.zeros",
"tensorflow.cast",
"tensorflow.variables_initializer",
"tensorflow.ones",
"tensorflow.truncated_normal_initializer",
"tensorflow.nn.conv2d_transpose",
"tensorflow.constant_initializer",
"tensorflow.nn.top_k",
"tensorflow.variable_scope",
"tensorflow.square",
"tensorflow.train.Saver",
"tensorflow.nn.conv2d"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
shenjean/DeepMicrobes | [
"43b654b0b26a265dd91166eece5c9f74e423d7dc"
] | [
"models/custom_layers.py"
] | [
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport tensorflow as tf\nimport tensorflow.contrib.slim as slim\n\n\ndef embedding_layer(inputs, vocab_size, embedding_dim, initializer):\n \"\"\"Looks up embedding vectors for each k-mer.\"\"\"\n embedding_weights = tf.get_variable(name=\"token_embedding_weights\",\n shape=[vocab_size, embedding_dim],\n initializer=initializer, trainable=True)\n return tf.nn.embedding_lookup(embedding_weights, inputs)\n\n\ndef bidirectional_lstm(inputs, lstm_dim, length_list, batch_size, initializer):\n \"\"\"Computes the hidden state of bidirectional lstm.\"\"\"\n lstm_cell = {}\n initial_state = {}\n\n for direction in [\"forward\", \"backward\"]:\n with tf.variable_scope(direction):\n lstm_cell[direction] = tf.contrib.rnn.CoupledInputForgetGateLSTMCell(\n lstm_dim, forget_bias=1.0, initializer=initializer,\n state_is_tuple=True)\n initial_cell_state = tf.get_variable(\"initial_cell_state\",\n shape=[1, lstm_dim],\n dtype=tf.float32,\n initializer=initializer)\n initial_output_state = tf.get_variable(\"initial_output_state\",\n shape=[1, lstm_dim],\n dtype=tf.float32,\n initializer=initializer)\n c_states = tf.tile(initial_cell_state, tf.stack([batch_size, 1]))\n h_states = tf.tile(initial_output_state, tf.stack([batch_size, 1]))\n initial_state[direction] = tf.contrib.rnn.LSTMStateTuple(c_states, h_states)\n\n (outputs_forward, outputs_backward), final_states = tf.nn.bidirectional_dynamic_rnn(\n lstm_cell[\"forward\"], lstm_cell[\"backward\"], inputs,\n sequence_length=length_list, dtype=tf.float32,\n initial_state_fw=initial_state[\"forward\"], initial_state_bw=initial_state[\"backward\"])\n\n inputs = tf.concat([outputs_forward, outputs_backward], axis=2)\n\n return inputs\n\n\ndef batch_stat(inputs):\n \"\"\"Computes tokenized reads length in a batch and batch size.\n\n Returns:\n length_list: a tensor of tokenized reads length in shape [batch_size].\n length_max: the maximum length in a batch.\n batch_size: dynamically computed batch size.\n \"\"\"\n used = tf.sign(tf.reduce_max(tf.abs(inputs), 2))\n length = tf.reduce_sum(used, 1)\n length_list = tf.cast(length, tf.int32)\n length_max = tf.reduce_max(length_list)\n batch_size = tf.shape(inputs)[0]\n return length_list, length_max, batch_size\n\n\ndef batch_stat_for_kmer_encoding(inputs):\n used = tf.sign(inputs)\n length = tf.reduce_sum(used, 1)\n length_list = tf.cast(length, tf.int32)\n length_max = tf.reduce_max(length_list)\n batch_size = tf.shape(inputs)[0]\n return length_list, length_max, batch_size\n\n\ndef dense_block(input_layer, num_filters_per_size_i, cnn_filter_size_i, num_rep_block_i):\n nodes = []\n a = slim.conv2d(input_layer, num_filters_per_size_i, [1, cnn_filter_size_i],\n weights_initializer=tf.contrib.layers.variance_scaling_initializer(\n factor=1.0, mode='FAN_AVG', uniform=True),\n normalizer_fn=slim.batch_norm)\n nodes.append(a)\n for z in range(num_rep_block_i-1):\n b = slim.conv2d(tf.concat(nodes, 3), num_filters_per_size_i, [1, cnn_filter_size_i],\n weights_initializer=tf.contrib.layers.variance_scaling_initializer(\n factor=1.0, mode='FAN_AVG', uniform=True),\n normalizer_fn=slim.batch_norm)\n nodes.append(b)\n return b\n\n\ndef attention_layer(inputs, lstm_dim, da, row, length_max, initializer):\n \"\"\"Creates the attention layer and applies it to the LSTM hidden state\n to generate the embedding matrix.\n \"\"\"\n ws1 = tf.get_variable(\"ws1\", shape=[2 * lstm_dim, da],\n initializer=initializer, trainable=True)\n intermediate_inputs_1 = tf.reshape(inputs, [-1, 2 * lstm_dim])\n intermediate_inputs_1 = tf.nn.tanh(tf.matmul(intermediate_inputs_1, ws1))\n ws2 = tf.get_variable(\"ws2\", shape=[da, row], initializer=initializer)\n intermediate_inputs_1 = tf.matmul(intermediate_inputs_1, ws2)\n intermediate_inputs_1 = tf.nn.softmax(tf.reshape(\n intermediate_inputs_1, shape=[-1, length_max, row]), axis=1)\n\n intermediate_inputs_2 = tf.transpose(inputs, perm=[0, 2, 1])\n inputs = tf.matmul(intermediate_inputs_2, intermediate_inputs_1)\n\n return inputs\n\n"
] | [
[
"tensorflow.get_variable",
"tensorflow.reduce_max",
"tensorflow.concat",
"tensorflow.sign",
"tensorflow.matmul",
"tensorflow.transpose",
"tensorflow.shape",
"tensorflow.reduce_sum",
"tensorflow.contrib.layers.variance_scaling_initializer",
"tensorflow.cast",
"tensorflow.reshape",
"tensorflow.stack",
"tensorflow.nn.bidirectional_dynamic_rnn",
"tensorflow.contrib.rnn.CoupledInputForgetGateLSTMCell",
"tensorflow.contrib.rnn.LSTMStateTuple",
"tensorflow.variable_scope",
"tensorflow.nn.embedding_lookup",
"tensorflow.abs"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
nfergu/GPflow | [
"d9951946d64542268b85610593495e187343d42e"
] | [
"doc/source/notebooks/intro_to_gpflow2.pct.py"
] | [
"# ---\n# jupyter:\n# jupytext:\n# formats: ipynb,.pct.py:percent\n# text_representation:\n# extension: .py\n# format_name: percent\n# format_version: '1.3'\n# jupytext_version: 1.4.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# %% [markdown]\n# GPflow with TensorFlow 2\n# ===\n#\n# ##### Small steps big changes\n#\n# <br>\n#\n#\n\n# %%\nfrom typing import Tuple, Optional\nimport tempfile\nimport pathlib\n\nimport datetime\nimport io\nimport matplotlib.pyplot as plt\n\nimport numpy as np\nimport tensorflow as tf\nimport gpflow\n\nfrom gpflow.config import default_float\nfrom gpflow.ci_utils import ci_niter\nfrom gpflow.utilities import to_default_float\n\nimport warnings\n\nwarnings.filterwarnings(\"ignore\")\n\n# %% [markdown]\n# Make `tensorboard` work inside notebook:\n\n# %%\noutput_logdir = \"/tmp/tensorboard\"\n\n# !rm -rf \"{output_logdir}\"\n# !mkdir \"{output_logdir}\"\n\n# %load_ext tensorboard\n# %matplotlib inline\n\n\ndef enumerated_logdir(_logdir_id: int = [0]):\n logdir = pathlib.Path(output_logdir, str(_logdir_id[0]))\n _logdir_id[0] += 1\n return str(logdir)\n\n\n# %% [markdown]\n# Set up random seeds and default float for `gpflow` tensors:\n\n# %%\ngpflow.config.set_default_float(np.float64)\nnp.random.seed(0)\ntf.random.set_seed(0)\n\n\n# %% [markdown]\n# ## Loading data using TensorFlow Datasets\n#\n# For this example, we create a synthetic dataset (noisy sine function):\n\n# %%\ndef noisy_sin(x):\n return tf.math.sin(x) + 0.1 * tf.random.normal(x.shape, dtype=default_float())\n\n\nnum_train_data, num_test_data = 100, 500\n\nX = tf.random.uniform((num_train_data, 1), dtype=default_float()) * 10\nXtest = tf.random.uniform((num_test_data, 1), dtype=default_float()) * 10\n\nY = noisy_sin(X)\nYtest = noisy_sin(Xtest)\n\ndata = (X, Y)\n\nplt.plot(X, Y, \"xk\")\nplt.show()\n\n# %% [markdown]\n# Working with TensorFlow Datasets is an efficient way to rapidly shuffle, iterate, and batch from data. For `prefetch` size we use `tf.data.experimental.AUTOTUNE` as recommended by TensorFlow [guidelines](https://www.tensorflow.org/guide/data_performance).\n\n# %%\ntrain_dataset = tf.data.Dataset.from_tensor_slices((X, Y))\ntest_dataset = tf.data.Dataset.from_tensor_slices((Xtest, Ytest))\n\nbatch_size = 32\nnum_features = 10\nprefetch_size = tf.data.experimental.AUTOTUNE\nshuffle_buffer_size = num_train_data // 2\nnum_batches_per_epoch = num_train_data // batch_size\n\noriginal_train_dataset = train_dataset\ntrain_dataset = (\n train_dataset.repeat()\n .prefetch(prefetch_size)\n .shuffle(buffer_size=shuffle_buffer_size)\n .batch(batch_size)\n)\n\nprint(f\"prefetch_size={prefetch_size}\")\nprint(f\"shuffle_buffer_size={shuffle_buffer_size}\")\nprint(f\"num_batches_per_epoch={num_batches_per_epoch}\")\n\n# %% [markdown]\n# ## Define a GP model\n#\n# In GPflow 2.0, we use `tf.Module` (or the very thin `gpflow.base.Module` wrapper) to build all our models, as well as their components (kernels, likelihoods, parameters, and so on).\n\n# %%\nkernel = gpflow.kernels.SquaredExponential(variance=2.0)\nlikelihood = gpflow.likelihoods.Gaussian()\ninducing_variable = np.linspace(0, 10, num_features).reshape(-1, 1)\n\nmodel = gpflow.models.SVGP(\n kernel=kernel, likelihood=likelihood, inducing_variable=inducing_variable\n)\n\n# %% [markdown]\n# You can set a module (or a particular parameter) to be non-trainable using the auxiliary method ```set_trainable(module, False)```:\n\n# %%\nfrom gpflow import set_trainable\n\nset_trainable(likelihood, False)\nset_trainable(kernel.variance, False)\n\nset_trainable(likelihood, True)\nset_trainable(kernel.variance, True)\n\n# %% [markdown]\n# We can use ```param.assign(value)``` to assign a value to a parameter:\n\n# %%\nkernel.lengthscales.assign(0.5)\n\n# %% [markdown]\n# All these changes are reflected when we use ```print_summary(model)``` to print a detailed summary of the model. By default the output is displayed in a minimalistic and simple table.\n\n# %%\nfrom gpflow.utilities import print_summary\n\nprint_summary(model) # same as print_summary(model, fmt=\"fancy_table\")\n\n# %% [markdown]\n# We can change default printing so that it will look nicer in our notebook:\n\n# %%\ngpflow.config.set_default_summary_fmt(\"notebook\")\n\nprint_summary(model) # same as print_summary(model, fmt=\"notebook\")\n\n# %% [markdown]\n# Jupyter notebooks also format GPflow classes (that are subclasses of `gpflow.base.Module`) in the same nice way when at the end of a cell (this is independent of the `default_summary_fmt`):\n\n# %%\nmodel\n\n# %% [markdown]\n# ## Training using training_loss and training_loss_closure\n#\n# GPflow models come with training_loss and training_loss_closure methods to make it easy to train your models.\n# There is a slight difference between models that own their own data (most of them, e.g. GPR, VGP, ...) and models that do not own the data (SVGP).\n#\n# ### Model-internal data\n# For models that own their own data (inheriting from InternalDataTrainingLossMixin), data is provided at model construction time.\n# In this case, model.training_loss does not take any arguments, and can be directly passed to an optimizer's `minimize()` method:\n\n# %%\nvgp_model = gpflow.models.VGP(data, kernel, likelihood)\noptimizer = tf.optimizers.Adam()\noptimizer.minimize(\n vgp_model.training_loss, vgp_model.trainable_variables\n) # Note: this does a single step\n# In practice, you will need to call minimize() many times, this will be further discussed below.\n\n# %% [markdown]\n# This also works for the Scipy optimizer, though it will do the full optimization on a single call to minimize():\n\n# %%\noptimizer = gpflow.optimizers.Scipy()\noptimizer.minimize(\n vgp_model.training_loss, vgp_model.trainable_variables, options=dict(maxiter=ci_niter(1000))\n)\n\n# %% [markdown]\n# You can obtain a compiled version using training_loss_closure, whose `compile` argument is True by default:\n\n# %%\nvgp_model.training_loss_closure() # compiled\nvgp_model.training_loss_closure(compile=True) # compiled\nvgp_model.training_loss_closure(compile=False) # uncompiled, same as vgp_model.training_loss\n\n# %% [markdown]\n# The SVGP model inherits from ExternalDataTrainingLossMixin and expects the data to be passed to training_loss().\n# For SVGP as for the other regression models, `data` is a two-tuple of `(X, Y)`, where `X` is an array/tensor with shape `(num_data, input_dim)` and `Y` is an array/tensor with shape `(num_data, output_dim)`:\n\n# %%\nassert isinstance(model, gpflow.models.SVGP)\nmodel.training_loss(data)\n\n# %% [markdown]\n# To make optimizing it easy, it has a `training_loss_closure()` method, that takes the data and returns a closure that computes the training loss on this data:\n\n# %%\noptimizer = tf.optimizers.Adam()\ntraining_loss = model.training_loss_closure(\n data\n) # We save the compiled closure in a variable so as not to re-compile it each step\noptimizer.minimize(training_loss, model.trainable_variables) # Note that this does a single step\n\n# %% [markdown]\n# SVGP can handle mini-batching, and an iterator from a batched tf.data.Dataset can be passed to the model's training_loss_closure():\n\n# %%\nbatch_size = 5\nbatched_dataset = tf.data.Dataset.from_tensor_slices(data).batch(batch_size)\ntraining_loss = model.training_loss_closure(iter(batched_dataset))\n\noptimizer.minimize(training_loss, model.trainable_variables) # Note that this does a single step\n\n# %% [markdown]\n# As previously, training_loss_closure takes an optional `compile` argument for tf.function compilation (True by default).\n\n# %% [markdown]\n# ## Training using Gradient Tapes\n#\n# For a more elaborate example of a gradient update we can define an `optimization_step` that explicitly computes and applies gradients to the model.\n# In TensorFlow 2, we can optimize (trainable) model parameters with TensorFlow optimizers using `tf.GradientTape`. In this simple example, we perform one gradient update of the Adam optimizer to minimize the training_loss (in this case the negative ELBO) of our model.\n# The `optimization_step` can (and should) be wrapped in `tf.function` to be compiled to a graph if executing it many times.\n\n# %%\ndef optimization_step(model: gpflow.models.SVGP, batch: Tuple[tf.Tensor, tf.Tensor]):\n with tf.GradientTape(watch_accessed_variables=False) as tape:\n tape.watch(model.trainable_variables)\n loss = model.training_loss(batch)\n grads = tape.gradient(loss, model.trainable_variables)\n optimizer.apply_gradients(zip(grads, model.trainable_variables))\n return loss\n\n\n# %% [markdown]\n# We can use the functionality of TensorFlow Datasets to define a simple training loop that iterates over batches of the training dataset:\n\n# %%\ndef simple_training_loop(model: gpflow.models.SVGP, epochs: int = 1, logging_epoch_freq: int = 10):\n tf_optimization_step = tf.function(optimization_step)\n\n batches = iter(train_dataset)\n for epoch in range(epochs):\n for _ in range(ci_niter(num_batches_per_epoch)):\n tf_optimization_step(model, next(batches))\n\n epoch_id = epoch + 1\n if epoch_id % logging_epoch_freq == 0:\n tf.print(f\"Epoch {epoch_id}: ELBO (train) {model.elbo(data)}\")\n\n\n# %%\nsimple_training_loop(model, epochs=10, logging_epoch_freq=2)\n\n# %% [markdown]\n# ## Monitoring\n#\n# `gpflow.monitor` provides a thin wrapper on top of tf.summary that makes it easy to monitor the training procedure.\n# For a more detailed tutorial see the [monitoring notebook](./basics/monitoring.pct.py).\n\n# %%\nfrom gpflow.monitor import (\n ImageToTensorBoard,\n ModelToTensorBoard,\n ExecuteCallback,\n Monitor,\n MonitorTaskGroup,\n ScalarToTensorBoard,\n)\n\n\nsamples_input = np.linspace(0, 10, 100).reshape(-1, 1)\n\n\ndef plot_model(fig, ax):\n tf.print(\"Plotting...\")\n mean, var = model.predict_f(samples_input)\n num_samples = 10\n samples = model.predict_f_samples(samples_input, num_samples)\n ax.plot(samples_input, mean, \"C0\", lw=2)\n ax.fill_between(\n samples_input[:, 0],\n mean[:, 0] - 1.96 * np.sqrt(var[:, 0]),\n mean[:, 0] + 1.96 * np.sqrt(var[:, 0]),\n color=\"C0\",\n alpha=0.2,\n )\n ax.plot(X, Y, \"kx\")\n ax.plot(samples_input, samples[:, :, 0].numpy().T, \"C0\", linewidth=0.5)\n ax.set_ylim(-2.0, +2.0)\n ax.set_xlim(0, 10)\n\n\ndef print_cb(epoch_id=None, data=None):\n tf.print(f\"Epoch {epoch_id}: ELBO (train)\", model.elbo(data))\n\n\ndef elbo_cb(data=None, **_):\n return model.elbo(data)\n\n\noutput_logdir = enumerated_logdir()\n\nmodel_task = ModelToTensorBoard(output_logdir, model)\nelbo_task = ScalarToTensorBoard(output_logdir, elbo_cb, \"elbo\")\nprint_task = ExecuteCallback(callback=print_cb)\n\n# We group these tasks and specify a period of `100` steps for them\nfast_tasks = MonitorTaskGroup([model_task, elbo_task, print_task], period=100)\n\n# We also want to see the model's fit during the optimisation\nimage_task = ImageToTensorBoard(output_logdir, plot_model, \"samples_image\")\n\n# We typically don't want to plot too frequently during optimisation,\n# which is why we specify a larger period for this task.\nslow_taks = MonitorTaskGroup(image_task, period=500)\nmonitor = Monitor(fast_tasks, slow_taks)\n\n\ndef monitored_training_loop(epochs: int):\n tf_optimization_step = tf.function(optimization_step)\n\n batches = iter(train_dataset)\n\n for epoch in range(epochs):\n for _ in range(ci_niter(num_batches_per_epoch)):\n batch = next(batches)\n tf_optimization_step(model, batch)\n\n epoch_id = epoch + 1\n monitor(epoch, epoch_id=epoch_id, data=data)\n\n\n# %% [markdown]\n# NOTE: for optimal performance it is recommended to wrap the monitoring inside `tf.function`.\n# This is detailed in the [monitoring notebook](./basics/monitoring.ipynb).\n\n\n# %%\nmodel = gpflow.models.SVGP(\n kernel=kernel, likelihood=likelihood, inducing_variable=inducing_variable\n)\n\nmonitored_training_loop(epochs=1000)\n\n# %% [markdown]\n# Then, we can use TensorBoard to examine the training procedure in more detail\n\n# %%\n# # %tensorboard --logdir \"{output_logdir}\"\n\n# %% [markdown]\n# ## Saving and loading models\n#\n# ### Checkpointing\n#\n# With the help of `tf.train.CheckpointManager` and `tf.train.Checkpoint`, we can checkpoint the model throughout the training procedure. Let's start with a simple example using checkpointing to save and load a `tf.Variable`:\n\n# %%\ninitial_value = 1.2\na = tf.Variable(initial_value)\n\n# %% [markdown]\n# Create `Checkpoint` object:\n\n# %%\nckpt = tf.train.Checkpoint(a=a)\nmanager = tf.train.CheckpointManager(ckpt, output_logdir, max_to_keep=3)\n\n# %% [markdown]\n# Save the variable `a` and change its value right after:\n\n# %%\nmanager.save()\n_ = a.assign(0.33)\n\n# %% [markdown]\n# Now we can restore the old variable value:\n\n# %%\nprint(f\"Current value of variable a: {a.numpy():0.3f}\")\n\nckpt.restore(manager.latest_checkpoint)\n\nprint(f\"Value of variable a after restore: {a.numpy():0.3f}\")\n\n# %% [markdown]\n# In the example below, we modify a simple training loop to save the model every 100 epochs using the `CheckpointManager`.\n\n# %%\nmodel = gpflow.models.SVGP(\n kernel=kernel, likelihood=likelihood, inducing_variable=inducing_variable\n)\n\n\ndef checkpointing_training_loop(\n model: gpflow.models.SVGP,\n batch_size: int,\n epochs: int,\n manager: tf.train.CheckpointManager,\n logging_epoch_freq: int = 100,\n epoch_var: Optional[tf.Variable] = None,\n step_var: Optional[tf.Variable] = None,\n):\n tf_optimization_step = tf.function(optimization_step)\n\n batches = iter(train_dataset)\n\n for epoch in range(epochs):\n for step in range(ci_niter(num_batches_per_epoch)):\n tf_optimization_step(model, next(batches))\n if step_var is not None:\n step_var.assign(epoch * num_batches_per_epoch + step + 1)\n if epoch_var is not None:\n epoch_var.assign(epoch + 1)\n\n epoch_id = epoch + 1\n if epoch_id % logging_epoch_freq == 0:\n ckpt_path = manager.save()\n tf.print(f\"Epoch {epoch_id}: ELBO (train) {model.elbo(data)}, saved at {ckpt_path}\")\n\n\n# %%\nstep_var = tf.Variable(1, dtype=tf.int32, trainable=False)\nepoch_var = tf.Variable(1, dtype=tf.int32, trainable=False)\nckpt = tf.train.Checkpoint(model=model, step=step_var, epoch=epoch_var)\nmanager = tf.train.CheckpointManager(ckpt, output_logdir, max_to_keep=5)\n\nprint(f\"Checkpoint folder path at: {output_logdir}\")\n\ncheckpointing_training_loop(\n model,\n batch_size=batch_size,\n epochs=1000,\n manager=manager,\n epoch_var=epoch_var,\n step_var=step_var,\n)\n\n# %% [markdown]\n# After the models have been saved, we can restore them using ```tf.train.Checkpoint.restore``` and assert that their performance corresponds to that logged during training.\n\n# %%\nfor i, recorded_checkpoint in enumerate(manager.checkpoints):\n ckpt.restore(recorded_checkpoint)\n print(\n f\"{i} restored model from epoch {int(epoch_var)} [step:{int(step_var)}] : ELBO training set {model.elbo(data)}\"\n )\n\n# %% [markdown]\n# ## Copying (hyper)parameter values between models\n#\n# It is easy to interact with the set of all parameters of a model or a subcomponent programmatically.\n#\n# The following returns a dictionary of all parameters within\n\n# %%\nmodel = gpflow.models.SGPR(data, kernel=kernel, inducing_variable=inducing_variable)\n\n# %%\ngpflow.utilities.parameter_dict(model)\n\n# %% [markdown]\n# Such a dictionary can be assigned back to this model (or another model with the same tree of parameters) as follows:\n\n# %%\nparams = gpflow.utilities.parameter_dict(model)\ngpflow.utilities.multiple_assign(model, params)\n\n# %% [markdown]\n# ### TensorFlow `saved_model`\n#\n# At present, TensorFlow does not support saving custom variables like instances of the `gpflow.base.Parameter` class, see [this TensorFlow github issue](https://github.com/tensorflow/tensorflow/issues/34908).\n#\n# However, once training is complete, it is possible to clone the model and replace all `gpflow.base.Parameter`s with `tf.constant`s holding the same value:\n\n# %%\nmodel\n\n# %%\nfrozen_model = gpflow.utilities.freeze(model)\n\n# %% [markdown]\n# In order to save the model we need to define a `tf.Module` holding the `tf.function`'s that we wish to export, as well as a reference to the underlying model:\n\n# %%\nmodule_to_save = tf.Module()\npredict_fn = tf.function(\n frozen_model.predict_f, input_signature=[tf.TensorSpec(shape=[None, 1], dtype=tf.float64)]\n)\nmodule_to_save.predict = predict_fn\n\n# %% [markdown]\n# Save original result for futher comparison. We also convert `samples_input` to a tensor. For a tensor input a `tf.function` will compile a single graph.\n\n# %%\nsamples_input = tf.convert_to_tensor(samples_input, dtype=default_float())\noriginal_result = module_to_save.predict(samples_input)\n\n# %% [markdown]\n# Let's save the module\n# %%\nsave_dir = str(pathlib.Path(tempfile.gettempdir()))\ntf.saved_model.save(module_to_save, save_dir)\n\n# %% [markdown]\n# Load module back as new instance and compare predict results\n\n# %%\nloaded_model = tf.saved_model.load(save_dir)\nloaded_result = loaded_model.predict(samples_input)\n\nnp.testing.assert_array_equal(loaded_result, original_result)\n\n# %% [markdown]\n# ## User config update\n#\n# In this notebook, we used a lot `gpflow.config` methods for setting and getting default attributes from global configuration. However, GPflow provides a way for local config modification without updating values in global. As you can see below, using `gpflow.config.as_context` replaces temporarily global config with your instance. At creation time, custom config instance uses standard values from the global config:\n\n# %%\nuser_config = gpflow.config.Config(float=tf.float32, positive_bijector=\"exp\")\n\nuser_str = \"User config\\t\"\nglobal_str = \"Global config\\t\"\n\nwith gpflow.config.as_context(user_config):\n print(f\"{user_str} gpflow.config.default_float = {gpflow.config.default_float()}\")\n print(\n f\"{user_str} gpflow.config.positive_bijector = {gpflow.config.default_positive_bijector()}\"\n )\n\nprint(f\"{global_str} gpflow.config.default_float = {gpflow.config.default_float()}\")\nprint(f\"{global_str} gpflow.config.positive_bijector = {gpflow.config.default_positive_bijector()}\")\n\n# %%\nwith gpflow.config.as_context(user_config):\n p = gpflow.Parameter(1.1, transform=gpflow.utilities.positive())\n print(f\"{user_str}{p}\")\n\np = gpflow.Parameter(1.1, transform=gpflow.utilities.positive())\nprint(f\"{global_str}{p}\")\n"
] | [
[
"numpy.sqrt",
"numpy.linspace",
"matplotlib.pyplot.plot",
"tensorflow.random.set_seed",
"tensorflow.Variable",
"tensorflow.saved_model.save",
"tensorflow.math.sin",
"tensorflow.train.CheckpointManager",
"tensorflow.train.Checkpoint",
"tensorflow.function",
"tensorflow.optimizers.Adam",
"tensorflow.print",
"matplotlib.pyplot.show",
"tensorflow.GradientTape",
"tensorflow.saved_model.load",
"numpy.random.seed",
"tensorflow.data.Dataset.from_tensor_slices",
"numpy.testing.assert_array_equal",
"tensorflow.Module",
"tensorflow.TensorSpec"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.7",
"2.6",
"2.2",
"1.13",
"2.3",
"2.4",
"2.9",
"2.5",
"2.8",
"2.10"
]
}
] |
unmeshvrije/scikit-kge | [
"e393d4f09ef95589a9a330fa0bedae2b79fb8a48",
"e393d4f09ef95589a9a330fa0bedae2b79fb8a48"
] | [
"skge/base.py",
"eval-embeddings.py"
] | [
"from __future__ import print_function\nimport argparse\nimport numpy as np\nfrom numpy import argsort\nfrom numpy.random import shuffle\nfrom collections import defaultdict as ddict\nfrom skge.param import Parameter, AdaGrad\nimport timeit\nimport pickle\nimport pdb\nimport logging\nfrom sklearn.metrics import precision_recall_curve, auc, roc_auc_score\nfrom skge import sample\nfrom skge.util import to_tensor\nimport copy\nimport itertools\nimport sys\nfrom skge.util import ccorr\nfrom enum import Enum\nfrom subgraphs import Subgraphs\nimport trident\nSUBTYPE = Enum('SUBTYPE', 'SPO POS')\n\nlogging.basicConfig(level=logging.DEBUG)\nlog = logging.getLogger('EX-KG')\n\n_cutoff = 30\n\n_DEF_NBATCHES = 100\n_DEF_POST_EPOCH = []\n_DEF_LEARNING_RATE = 0.1\n_DEF_SAMPLE_FUN = None\n_DEF_MAX_EPOCHS = 1000\n_DEF_MARGIN = 1.0\n_FILE_GRADIENTS = 'gradients.txt'\n_FILE_EMBEDDINGS = 'embeddings.txt'\n_FILE_TAIL_PREDICTIONS_UNFILTERED = 'tail-predictions-unfiltered.txt'\n_FILE_TAIL_PREDICTIONS_FILTERED = 'tail-predictions-filtered.txt'\n_FILE_HEAD_PREDICTIONS_UNFILTERED = 'head-predictions-unfiltered.txt'\n_FILE_HEAD_PREDICTIONS_FILTERED = 'head-predictions-filtered.txt'\n_FILE_INFO = 'info.txt'\n_SIM_RANK_C = 0.6\n_SIM_RANK_K = 5\n\nall_true_triples = []\ntrident_db = None\n\nnp.random.seed(42)\n\ngraph = ddict()\n\n\ndef num_incoming_neighbours(entity, graph):\n all_lists = list(graph['incoming'][entity].values())\n incoming_neighbours = list(itertools.chain(*all_lists))\n return len(incoming_neighbours)\n\ndef num_outgoing_neighbours(entity, graph):\n all_lists = list(graph['outgoing'][entity].values())\n outgoing_neighbours = list(itertools.chain(*all_lists))\n return len(outgoing_neighbours)\n\ndef num_outgoing_relations(entity, graph):\n all_relations = list(graph['outgoing'][entity].keys())\n return len(all_relations)\n\ndef num_incoming_relations(entity, graph):\n all_relations = list(graph['incoming'][entity].keys())\n return len(all_relations)\n\n\ndef _is_converge(s1, s2, eps=1e-4):\n for i in s1.keys():\n for j in s1[i].keys():\n if abs(s1[i][j] - s2[i][j]) >= eps:\n return False\n return True\n\n\n\n\n\nclass Experiment(object):\n\n def __init__(self):\n self.parser = argparse.ArgumentParser(prog='Knowledge Graph experiment', conflict_handler='resolve')\n self.parser.add_argument('--margin', type=float, help='Margin for loss function')\n self.parser.add_argument('--init', type=str, default='nunif', help='Initialization method')\n self.parser.add_argument('--lr', type=float, help='Learning rate')\n self.parser.add_argument('--me', type=int, help='Maximum number of epochs')\n self.parser.add_argument('--ne', type=int, help='Numer of negative examples', default=1)\n self.parser.add_argument('--nb', type=int, help='Number of batches')\n self.parser.add_argument('--fout', type=str, help='Path to store model and results', default=None)\n self.parser.add_argument('--finfo', type=str, help='Path to store additional debug info', default=None)\n self.parser.add_argument('--fgrad', type=str, help='Path to store gradient vector updates for each entity', default=None)\n self.parser.add_argument('--fpagerank', type=str, help='Path of the page ranks of all entities (in form of python dictionary)', default=None)\n self.parser.add_argument('--fembed', type=str, help='Path to store final embeddings for every entity and relation', default=None)\n self.parser.add_argument('--fin', type=str, help='Path to input data', default=None)\n self.parser.add_argument('--ftax', type=str, help='Path to the taxonomy file', default=None)\n self.parser.add_argument('--fsub', type=str, help='Path to the subgraphs file', default=None)\n self.parser.add_argument('--embed', type=str, help='Strategy to assign embeddings', default='kognac')\n self.parser.add_argument('--test-all', type=int, help='Evaluate Test set after x epochs', default=10)\n self.parser.add_argument('--no-pairwise', action='store_const', default=False, const=True)\n self.parser.add_argument('--incr', type=int, help='Percentage of training data to consider in first step', default=100)\n self.parser.add_argument('--mode', type=str, default='rank')\n self.parser.add_argument('--sampler', type=str, default='random-mode')\n self.parser.add_argument('--norm', type=str, default='l1', help=' Normalization (l1(default) or l2)')\n\n self.parser.add_argument('--subcreate', dest=\"subcreate\", help='Create subgraphs', action='store_true')\n self.parser.add_argument('--subtest', dest = \"subtest\", help='Test with subgraphs', action='store_true')\n self.parser.add_argument('--minsubsize', type=int, help='Minimum subgraph size', default=50)\n self.parser.add_argument('--topk', type=int, help='Number of top subgraphs to check for evaluation', default=5)\n self.parser.add_argument('--subalgo', type=str, help='Algo to use to create subgraphs', default=\"transe\")\n self.parser.add_argument('--subdistance', type=str, help='Distance function to evaluate subgraphs on', default=\"avg\")\n self.neval = -1\n self.best_valid_score = -1.0\n self.exectimes = []\n self.subgraphs = Subgraphs()\n self.avg_embeddings = []\n self.var_embeddings = []\n\n def make_subgraphs(self, subType, sorted_triples, mincard, trn_model, sub_algo):\n similar_entities = []\n current = np.zeros(self.args.ncomp, dtype=np.float64)\n count = 0\n prevo = -1\n prevp = -1\n subgraph_logfile=\"subgraphs-test.log\"\n file_data = \"\"\n cntTriples = len(sorted_triples)\n for i, triple in enumerate(sorted_triples):\n sub = triple[0]\n obj = triple[1]\n rel = triple[2]\n ent = -1\n other_ent = -1\n ER = None\n if subType == SUBTYPE.POS:\n ent = obj\n other_ent = sub\n else:\n #print (\"subtype = \" , subType)\n ent = sub\n other_ent = obj\n #if sub_algo == \"hole\":\n # ER = ccorr(trn_model.R[rel], trn_model.E)\n if ent != prevo or rel != prevp:\n if count > mincard:\n mean = current/count\n self.avg_embeddings.append(mean)\n columnsSquareDiff = np.zeros(self.args.ncomp, dtype=np.float64)\n for se in similar_entities:\n columnsSquareDiff += (trn_model.E[se] - mean) * (trn_model.E[se] - mean)\n if count > 2:\n columnsSquareDiff /= (count-1)\n else:\n columnsSquareDiff = mean\n self.var_embeddings.append(columnsSquareDiff)\n # add subgraph\n self.subgraphs.add_subgraphs(subType, prevo, prevp, count, similar_entities)\n for se in similar_entities:\n file_data += str(se) + \"\\n\"\n #print(similar_entities)\n #else:\n # print(\"count = \", count , \" for \", str(prevo) , \" : \" , str(prevp))\n count = 0\n prevo = ent\n prevp = rel\n current.fill(0.0)\n similar_entities.clear()\n count += 1\n if sub_algo == \"transe\":\n current += trn_model.E[other_ent]\n elif sub_algo == \"hole\":\n if subType == SUBTYPE.POS:\n if not np.any(current):\n current = trn_model.E[other_ent]\n else:\n current = np.dot(trn_model.E[other_ent], current)\n else:\n if not np.any(current):\n current = trn_model.E[other_ent]\n else:\n current = np.dot(current,trn_model.E[other_ent])\n #current += trn_model.E[other_ent]\n similar_entities.append(other_ent)\n # After looping over all triples, add remaining entities to a subgraph\n if count > mincard:\n self.avg_embeddings.append(current/count)\n columnsSquareDiff = np.zeros(self.args.ncomp, dtype=np.float64)\n for se in similar_entities:\n columnsSquareDiff += (trn_model.E[se] - mean) * (trn_model.E[se] - mean)\n if count > 2:\n columnsSquareDiff /= (count-1)\n else:\n columnsSquareDiff = mean\n self.var_embeddings.append(columnsSquareDiff)\n # add subgraph\n self.subgraphs.add_subgraphs(subType, prevo, prevp, count, similar_entities)\n print (\"# of subgraphs : \" , self.subgraphs.get_Nsubgraphs())\n with open(subgraph_logfile, \"w\") as fout:\n fout.write(file_data)\n\n def run(self, *args, **kwargs):\n # parse comandline arguments\n self.args = self.parser.parse_args()\n\n fi = self.args.finfo\n\n self.file_info = None\n if fi is not None:\n self.file_info = open(fi, \"w\")\n\n\n if self.args.mode == 'rank':\n self.callback = self.ranking_callback\n elif self.args.mode == 'lp':\n self.callback = self.lp_callback\n self.evaluator = LinkPredictionEval\n else:\n raise ValueError('Unknown experiment mode (%s)' % self.args.mode)\n\n if self.args.subcreate:\n self.subgraphs_create()\n elif self.args.subtest:\n self.subgraphs_test()\n else:\n self.train()\n\n def subgraph_callback(self, trn_model, topk, sub_algo, sub_dist):\n #TODO: use subgraphs to find ranks, scores\n log.info(\"Computing SUBGRAPH positions and scores for TEST dataset...\")\n time_start = timeit.default_timer()\n pos_test = self.ev_test.subgraph_positions(trn_model, self.subgraphs.subgraphs, sub_algo, sub_dist)\n subgraph_ranking_scores(self.fresult, pos_test, 'TEST', topk)\n time_end = timeit.default_timer()\n log.info(\"Time spent in computing SUBGRAPH positions and scores for TEST dataset = %ds\" % (time_end - time_start))\n self.fresult.close()\n\n def ranking_callback(self, trn, with_eval=False):\n # print basic info\n elapsed = timeit.default_timer() - trn.epoch_start\n self.exectimes.append(elapsed)\n if self.args.no_pairwise:\n log.info(\"[%3d] time = %ds, loss = %f\" % (trn.epoch, elapsed, trn.loss))\n else:\n log.info(\"[%3d] time = %ds, violations = %d\" % (trn.epoch, elapsed, trn.nviolations))\n self.fresult.write(\"[%3d] time = %ds, violations = %d\\n\" % (trn.epoch, elapsed, trn.nviolations))\n\n # if we improved the validation error, store model and calc test error\n if (trn.epoch % self.args.test_all == 0) or with_eval:\n log.info(\"Computing positions and scores for VALIDATION dataset...\")\n time_start = timeit.default_timer()\n\n plot = False\n if trn.epoch == self.args.me:\n #log.info(\"PLOT ME\\n\")\n plot = True\n\n pos_v, fpos_v = self.ev_valid.positions(trn.model)\n fmrr_valid = ranking_scores(self.fresult, pos_v, fpos_v, trn.epoch, 'VALID')\n time_end = timeit.default_timer()\n log.info(\"At epoch %d , Time spent in computing positions and scores for VALIDATION dataset = %ds\" % (trn.epoch, time_end - time_start))\n self.fresult.write(\"At epoch %d , Time spent in computing positions and scores for VALIDATION dataset = %ds\\n\" % (trn.epoch, time_end - time_start))\n\n log.debug(\"FMRR valid = %f, best = %f\" % (fmrr_valid, self.best_valid_score))\n if fmrr_valid > self.best_valid_score or plot:\n self.best_valid_score = fmrr_valid\n\n log.info(\"Computing positions and scores for TEST dataset...\")\n time_start = timeit.default_timer()\n pos_t, fpos_t = self.ev_test.positions(trn.model, plot=plot, pagerankMap=self.pagerankMap)\n ranking_scores(self.fresult, pos_t, fpos_t, trn.epoch, 'TEST')\n time_end = timeit.default_timer()\n log.info(\"At epoch %d, Time spent in computing positions and scores for TEST dataset = %ds\" % (trn.epoch, time_end - time_start))\n self.fresult.write(\"At epoch %d, Time spent in computing positions and scores for TEST dataset = %ds\\n\" % (trn.epoch, time_end - time_start))\n\n if self.args.fout is not None:\n st = {\n 'model': trn.model,\n 'pos test': pos_t,\n 'fpos test': fpos_t,\n 'pos valid': pos_v,\n 'fpos valid': fpos_v,\n 'exectimes': self.exectimes\n }\n with open(self.args.fout, 'wb') as fout:\n pickle.dump(st, fout, protocol=2)\n return True\n\n def lp_callback(self, m, with_eval=False):\n # print basic info\n elapsed = timeit.default_timer() - m.epoch_start\n self.exectimes.append(elapsed)\n if self.args.no_pairwise:\n log.info(\"[%3d] time = %ds, loss = %d\" % (m.epoch, elapsed, m.loss))\n else:\n log.info(\"[%3d] time = %ds, violations = %d\" % (m.epoch, elapsed, m.nviolations))\n\n # if we improved the validation error, store model and calc test error\n if (m.epoch % self.args.test_all == 0) or with_eval:\n auc_valid, roc_valid = self.ev_valid.scores(m)\n\n log.debug(\"AUC PR valid = %f, best = %f\" % (auc_valid, self.best_valid_score))\n if auc_valid > self.best_valid_score:\n self.best_valid_score = auc_valid\n auc_test, roc_test = self.ev_test.scores(m)\n log.debug(\"AUC PR test = %f, AUC ROC test = %f\" % (auc_test, roc_test))\n\n if self.args.fout is not None:\n st = {\n 'model': m,\n 'auc pr test': auc_test,\n 'auc pr valid': auc_valid,\n 'auc roc test': roc_test,\n 'auc roc valid': roc_valid,\n 'exectimes': self.exectimes\n }\n with open(self.args.fout, 'wb') as fout:\n pickle.dump(st, fout, protocol=2)\n return True\n\n def bisect_list_by_percent(self, ll, percentage):\n size = len(ll)\n shuffle(ll)\n first_half_len = (size * percentage) / 100\n second_half_len = size - first_half_len\n first_half = ll[:int(first_half_len)]\n second_half = ll[int(first_half_len):]\n return [first_half, second_half]\n\n\n def subgraphs_test(self):\n train_triples, valid_triples, test_triples, sz = self.get_all_triples()\n true_triples = train_triples + test_triples + valid_triples\n log.info(\"*\"*80)\n log.info(len(true_triples))\n if self.args.mode == 'rank':\n self.ev_test = self.evaluator(test_triples, true_triples, self.neval)\n self.ev_valid = self.evaluator(valid_triples,true_triples, self.neval)\n\n topk = self.args.topk\n self.subgraphs = Subgraphs.load(self.args.fsub)\n trn_model = Model.load(self.args.fout)\n dataset = self.args.fin.split('/')[-1].split('.')[0]\n algo = self.algo\n epochs = self.args.me\n sub_algo = self.args.subalgo\n sub_dist = self.args.subdistance\n mincard = self.args.minsubsize\n subgraph_embeddings_home = \"/var/scratch/uji300/hole/\"\n outfile = subgraph_embeddings_home + dataset + \"_\"+sub_algo+ \"-dist-\" + sub_dist + \"-tau-\" + str(mincard)+\"-topK-\"+ str(topk) + \".result\"\n fresult = open(outfile, \"w\")\n self.fresult = fresult\n self.subgraph_callback(trn_model, topk, sub_algo, sub_dist)\n\n def remove_literals(self, triples):\n global trident_db\n clean_triples = []\n for t in triples:\n if -1 != trident_db.lookup_str(t[0]).find('\"'):\n continue\n if -1 != trident_db.lookup_str(t[1]).find('\"'):\n continue\n if -1 != trident_db.lookup_relstr(t[2]).find('\"'):\n continue\n clean_triples.append(t)\n return clean_triples\n '''\n input:\n\n output:\n Subgraph embeddings (array of objects of Subgraph class)\n\n '''\n def subgraphs_create(self):\n train_triples, valid_triples, test_triples, sz = self.get_all_triples()\n xs = train_triples + valid_triples + test_triples\n print (\"Trying to make subgraphs...\")\n clean_triples = self.remove_literals(xs)\n mincard = self.args.minsubsize\n sub_algo = self.args.subalgo\n sub_dist = self.args.subdistance\n\n dataset = self.args.fin.split('/')[-1].split('.')[0]\n algo = self.algo\n epochs = self.args.me\n\n results = Model.load(self.args.fout)\n trn_model = results['model']\n\n sorted_ps = sorted(clean_triples, key=lambda l : (l[2], l[0]))\n #print (\"calling with type = \", SUBTYPE.SPO)\n #print(sorted_ps)\n self.make_subgraphs(SUBTYPE.SPO, sorted_ps, mincard, trn_model, sub_algo)\n\n sorted_po = sorted(clean_triples, key=lambda l : (l[2], l[1]))\n #print (\"calling with type = \", SUBTYPE.POS)\n self.make_subgraphs(SUBTYPE.POS, sorted_po, mincard, trn_model, sub_algo)\n\n trn_model.add_param('SA', (self.subgraphs.get_Nsubgraphs(), self.args.ncomp))\n trn_model.SA = self.avg_embeddings\n #for sube in trn.model.S:\n # print(type(sube) , \" :\" , sube)\n #print(type(self.avg_embeddings) , \" : \" , self.avg_embeddings[self.subgraphs.get_Nsubgraphs()-1])\n if sub_algo == \"var\" or sub_algo == \"kl\":\n trn_model.add_param('SV', (self.subgraphs.get_Nsubgraphs(), self.args.ncomp))\n trn_model.SV = self.var_embeddings\n\n # Save subgraphs and model\n subgraph_embeddings_home = \"/var/scratch/uji300/hole/\"\n subgraph_file_name= subgraph_embeddings_home + dataset + \"-HolE-epochs-\" + str(epochs) + \"-\" + sub_dist + \"-tau-\" + str(mincard) + \".sub\"\n self.subgraphs.save(subgraph_file_name)\n model_file_name= subgraph_embeddings_home + dataset + \"-HolE-epochs-\" + str(epochs) + \"-\" + sub_dist + \"-tau-\" + str(mincard) + \".mod\"\n trn_model.save(model_file_name)\n\n def fit_model(self, xs, ys, sz, setup_trainer=True, trainer=None):\n # create sampling objects\n # Sample is given the array of triples.\n # So that it can randomly create other triples that is not part of the original array\n # This is useful to make negative samples\n if self.args.sampler == 'corrupted':\n # create type index, here it is ok to use the whole data\n sampler = sample.CorruptedSampler(self.args.ne, xs, ti)\n elif self.args.sampler == 'random-mode':\n sampler = sample.RandomModeSampler(self.args.ne, [0, 1], xs, sz)\n elif self.args.sampler == 'lcwa':\n sampler = sample.LCWASampler(self.args.ne, [0, 1, 2], xs, sz)\n else:\n raise ValueError('Unknown sampler (%s)' % self.args.sampler)\n\n if setup_trainer:\n trn = self.setup_trainer(sz, sampler)\n else:\n trn = trainer\n\n notUpdated = 0\n for count in trn.model.E.updateCounts:\n if count == 0:\n notUpdated += 1\n log.info(\"Fitting model %s with trainer %s and parameters %s\" % (\n trn.model.__class__.__name__,\n trn.__class__.__name__,\n self.args)\n )\n trn.fit(xs, ys)\n # each x in xs is a tuple (SUB, OBJ, PREDicate)\n self.callback(trn, with_eval=True)\n return trn\n\n def make_graph(self, triples, N, M):\n graph_outgoing = [ddict(list) for _ in range(N)]\n graph_incoming = [ddict(list) for _ in range(N)]\n graph_relations_head = [ddict(list)for _ in range(M)]\n graph_relations_tail = [ddict(list)for _ in range(M)]\n for t in triples:\n head = t[0]\n tail = t[1]\n relation = t[2]\n graph_outgoing[head][relation].append(tail)\n graph_incoming[tail][relation].append(head)\n graph_relations_head[relation][head].append(tail)\n graph_relations_tail[relation][tail].append(head)\n\n return {'outgoing': graph_outgoing, 'incoming': graph_incoming, 'relations_head': graph_relations_head, 'relations_tail':graph_relations_tail}\n\n def get_boundaries(self, classes, entity):\n for c in classes:\n if (int(c[2]) <= entity and entity <= int(c[3])):\n return {'left': int(c[2]), 'right':int(c[3])}\n return {'left' : -1, 'right' : -1}\n #raise ValueError(\"Entity %d should not exist\" % (entity))\n\n def get_all_triples(self):\n # read data\n #with open(self.args.fin, 'rb') as fin:\n # data = pickle.load(fin)\n\n global all_true_triples\n global trident_db\n file_path = self.args.fin\n trident_db = trident.Db(file_path)\n batch_size = 1000\n percent_valid_triples = 0.01\n percent_test_triples = 0.01\n all_true_triples = trident_db.all()\n if trident_db.n_triples() < 1000:\n batch_size = 100\n batcher = trident.Batcher(file_path, batch_size, 1, percent_valid_triples, percent_test_triples)\n N = trident_db.n_terms()\n M = trident_db.n_relations()\n\n #N = len(data['entities'])\n #pdb.set_trace()\n #M = len(data['relations'])\n sz = (N, N, M)\n\n if file_path[-1] != '/':\n file_path = file_path + \"/\"\n train_triples_series = batcher.load_triples(file_path+\"_batch\")\n valid_triples_series = batcher.load_triples(file_path+\"_batch_valid\")\n test_triples_series = batcher.load_triples(file_path+\"_batch_test\")\n\n def parse_triples_series(series):\n s_list = [int(x) for x in series[::3]]\n p_list = [int(x) for x in series[1::3]]\n o_list = [int(x) for x in series[2::3]]\n result = []\n for s,p,o in zip(s_list, p_list, o_list):\n # Note that we are returing SUB,OBJ, PRED\n result.append((s,o,p))\n return result\n\n train_triples = parse_triples_series(train_triples_series)\n valid_triples = parse_triples_series(valid_triples_series)\n test_triples = parse_triples_series(test_triples_series)\n return train_triples, valid_triples, test_triples, sz\n\n def train(self):\n train_triples, valid_triples, test_triples, sz = self.get_all_triples()\n N = sz[0]\n M = sz[2]\n print (type(train_triples))\n print (len(train_triples))\n #true_triples = data['train_subs'] + data['test_subs'] + data['valid_subs']\n #test_triples = data['test_subs']\n true_triples = train_triples + test_triples + valid_triples\n\n if self.args.mode == 'rank':\n self.ev_test = self.evaluator(test_triples, true_triples, self.neval)\n self.ev_valid = self.evaluator(valid_triples,true_triples, self.neval)\n #elif self.args.mode == 'lp':\n # self.ev_test = self.evaluator(data['test_subs'], data['test_labels'])\n # self.ev_valid = self.evaluator(data['valid_subs'], data['valid_labels'])\n\n # Construct a name for the result file\n # <dataset>-<size of training>-<strategy>-epochs-<number of epochs>-eval-<Evaluate after X epochs>-margin-<margin>.out\n # lubm-full-transe-epochs-500-eval-50-margin-2.0.out\n dataset = self.args.fin.split('/')[-1].split('.')[0]\n size = \"full\" if self.args.incr == 100 else \"exp\"\n strategy = self.args.embed\n epochs = self.args.me\n ev = self.args.test_all\n margin = self.args.margin\n outfile = dataset + \"-\" + size + \"-\" + strategy + \"-epochs-\" + str(epochs) + \"-eval-\" + str(ev) + \"-margin-\" + str(margin) + \".out\"\n fresult = open(outfile, \"w\")\n self.fresult = fresult\n\n self.pagerankMap = None\n # If pagerank file is given, then extract the entity-pagerank map\n if self.args.fpagerank is not None:\n with open(self.args.fpagerank, 'r') as fp:\n self.pagerankMap = eval(fp.read())\n\n global _FILE_TAIL_PREDICTIONS_UNFILTERED\n global _FILE_TAIL_PREDICTIONS_FILTERED\n global _FILE_HEAD_PREDICTIONS_UNFILTERED\n global _FILE_HEAD_PREDICTIONS_FILTERED\n\n _FILE_TAIL_PREDICTIONS_UNFILTERED = dataset + \"-\" + _FILE_TAIL_PREDICTIONS_UNFILTERED\n _FILE_TAIL_PREDICTIONS_FILTERED = dataset + \"-\" + _FILE_TAIL_PREDICTIONS_FILTERED\n _FILE_HEAD_PREDICTIONS_UNFILTERED = dataset + \"-\" + _FILE_HEAD_PREDICTIONS_UNFILTERED\n _FILE_HEAD_PREDICTIONS_FILTERED = dataset + \"-\" + _FILE_HEAD_PREDICTIONS_FILTERED\n\n with open(_FILE_TAIL_PREDICTIONS_UNFILTERED, 'w') as fplot:\n fplot.write(\"\")\n with open(_FILE_TAIL_PREDICTIONS_FILTERED, 'w') as fplot:\n fplot.write(\"\")\n with open(_FILE_HEAD_PREDICTIONS_UNFILTERED, 'w') as fplot:\n fplot.write(\"\")\n with open(_FILE_HEAD_PREDICTIONS_FILTERED, 'w') as fplot:\n fplot.write(\"\")\n\n # Make a graph from edges in training triples.\n graph_start = timeit.default_timer()\n global graph\n # TODO: for graph use dynamic dict instead of list\n graph = self.make_graph(train_triples, N, M)\n graph_end = timeit.default_timer()\n log.info(\"Time to build the graph = %ds\" %(graph_end - graph_start))\n self.fresult.write(\"Time to build the graph = %ds\\n\" %(graph_end - graph_start))\n\n #sim_start = timeit.default_timer()\n #sim = simrank(graph, N)\n #sim_end = timeit.default_timer()\n\n #log.info(\"Time to compute simranks = %ds\" %(sim_end - sim_start))\n if self.args.incr != 100:\n\n # Select 10% of the tuples here\n\n time_start = timeit.default_timer()\n triples = data['train_subs']\n incremental_batches = self.bisect_list_by_percent(triples, self.args.incr)\n time_end = timeit.default_timer()\n log.info(\"Time to choose %d%% samples = %ds\" % (self.args.incr, time_end-time_start))\n\n log.info(\"Total size = %d, %d%% size = %d, %d%% size = %d\" % (len(data['train_subs']), self.args.incr, len(incremental_batches[0]), 100-self.args.incr, len(incremental_batches[1])))\n\n xs = incremental_batches[0]\n ys = np.ones(len(xs))\n\n time_start = timeit.default_timer()\n trainer = self.fit_model(xs, ys, sz)\n time_end = timeit.default_timer()\n\n log.info(\"### Time to fit model for %d%% samples (%d epochs) = %ds\" % (self.args.incr, self.args.me, time_end - time_start))\n self.fresult.write(\"### Time to fit model for %d%% samples (%d epochs) = %ds\\n\" % (self.args.incr, self.args.me, time_end - time_start))\n\n log.info(\"First step finished : ######################\")\n\n time_start = timeit.default_timer()\n countEntities = [0] * N\n for x in xs:\n countEntities[x[0]] += 1\n countEntities[x[1]] += 1\n\n considered = 0;\n if self.file_info is not None:\n self.file_info.write(\"Entity (is given) => (embedding of) Entity)\\n\")\n\n if self.args.embed is \"kognac\":\n with open (self.args.ftax, 'r') as ftax:\n lines = ftax.readlines()\n\n ranges = [l.split() for l in lines]\n classes = []\n for r in ranges:\n if (len(r) == 4):\n classes.append(r)\n\n classes.sort(key=lambda x:int(x[2]))\n # Apply proper strategy to assign embeddings here\n # If kognac, then read the taxonomy file and based on boundaries of classes, assign embeddings of neighbouring entities.\n # If not, choose other strategy\n # Else, choose random assignment\n lonely = 0\n for entity, count in enumerate(countEntities):\n if count != 0:\n considered += 1\n else:\n if self.args.embed is \"kognac\":\n # Find the six closest entities that were considered before and take their average\n\n boundary = self.get_boundaries(classes, entity)\n quorum = 6\n log.info(\"entity (%d): \" % (entity))\n\n if (boundary['left'] == -1 and boundary['right'] == -1):\n # This entitiy is not a part of any class\n lonely += 1\n continue\n\n neighbours = []\n if (boundary['left'] == entity):\n e = entity + 1\n while(countEntities[e] != 0 and e != boundary['right']-1):\n neighbours.append(e)\n if (len(neighbours) == quorum):\n break\n e += 1\n elif (boundary['right'] == entity):\n e = entity - 1\n while (countEntities[e] != 0 and e != boundary['left']):\n neighbours.append(e)\n if (len(neighbours) == quorum):\n break;\n e -= 1\n else:\n e = entity + 1\n while(countEntities[e] != 0 and e != boundary['right']-1):\n neighbours.append(e)\n if (len(neighbours) == (quorum/2)):\n break\n e += 1\n\n required = quorum - (len(neighbours))\n\n e = entity - 1\n while (countEntities[e] != 0 and e != boundary['left']):\n neighbours.append(e)\n if (len(neighbours) == required):\n break;\n e -= 1\n\n if len(neighbours) > quorum:\n log.info(\"More neighbours than the quorum : %d\" % (len(neighbours)))\n\n quorum = len(neighbours)\n log.info(\" %d neighbours found\\n\" % (quorum))\n if quorum != 0:\n total = np.full((50), 0, dtype=float)\n for n in neighbours:\n total += trainer.model.E[n]\n\n total /= quorum\n if self.file_info is not None:\n for n in neibhours:\n self.file_info.write(\"%d, \" % (n))\n self.file_info.write(\"\\n\")\n\n trainer.model.E[entity] = total\n\n time_end = timeit.default_timer()\n log.info(\"Time spent in assigning new embeddings (Strategy %s) = %ds\" % (self.args.embed, time_end - time_start))\n self.fresult.write(\"Time spent in assigning new embeddings (Strategy %s) = %ds\\n\" % (self.args.embed, time_end - time_start))\n\n log.info(\"!!!!!!!!!!! %d / %d entities were considered in first batch. !!!!!!!!!!!!!!\" % (considered, N))\n log.info(\"@@@@@@@@ %d entities were lonley (i.e. not a part of any class\" % (lonely))\n\n # Select all tuples\n xs = incremental_batches[0] + incremental_batches[1]\n ys = np.ones(len(xs))\n\n # Here the trainer is already set-up. So we don't call setup_trainer again.\n # setup_trainer methods initializes the max_epochs parameter which is the number of iterations.\n # We have added a method to the PairwiseStochasticTrainer class which will set the max_epoch for us\n trainer.set_max_epochs(self.args.me/5)\n time_start= timeit.default_timer()\n self.fit_model(xs, ys, sz, setup_trainer=False, trainer=trainer)\n time_end = timeit.default_timer()\n log.info(\"Time to fit model for 100%% samples (%d epochs) = %ds\" % (trainer.max_epochs, time_end - time_start))\n self.fresult.write(\"Time to fit model for 100%% samples (%d epochs) = %ds\\n\" % (trainer.max_epochs, time_end - time_start))\n else:\n xs = train_triples\n ys = np.ones(len(xs))\n time_start= timeit.default_timer()\n trainer = self.fit_model(xs, ys, sz)\n time_end = timeit.default_timer()\n log.info(\"Time to fit model for 100%% samples (%d epochs) = %ds\" % (trainer.max_epochs, time_end - time_start))\n self.fresult.write(\"Time to fit model for 100%% samples (%d epochs) = %ds\\n\" % (trainer.max_epochs, time_end - time_start))\n\n #self.subgraphs_create(xs, ys, sz, trainer)\n\n\n\nclass FilteredRankingEval(object):\n\n def __init__(self, xs, true_triples, neval=-1):\n idx = ddict(list)\n tt = ddict(lambda: {'ss': ddict(list), 'os': ddict(list)})\n self.neval = neval\n self.sz = len(xs)\n for s, o, p in xs:\n idx[p].append((s, o))\n\n for s, o, p in true_triples:\n tt[p]['os'][s].append(o)\n tt[p]['ss'][o].append(s)\n\n self.idx = dict(idx)\n self.tt = dict(tt)\n\n self.neval = {}\n for p, sos in self.idx.items():\n if neval == -1:\n self.neval[p] = -1\n else:\n self.neval[p] = np.int(np.ceil(neval * len(sos) / len(xs)))\n\n def get_matching_entities(self, sub_type, e, r):\n global all_true_triples\n entities = []\n for triple in all_true_triples:\n if sub_type == SUBTYPE.SPO and triple[0] == e and triple[1] == r:\n entities.append(triple[2])\n if len(entities) == 10:\n return entities\n elif triple[2] == e and triple[1] == r:\n entities.append(triple[0])\n if len(entities) == 10:\n return entities\n return entities\n\n def get_skip_subgraphs(self, subgraphs, ent, rel, sub_type):\n for i in range(len(subgraphs)):\n #print(\"Subgraphs \", str(i+1), \": \", subgraphs[i].ent , \" , \", subgraphs[i].rel)\n if subgraphs[i].subType == sub_type and \\\n subgraphs[i].ent == ent and \\\n subgraphs[i].rel == rel:\n return i\n\n def get_kl_divergence_scores(self, model, subgraphs, ent, rel, sub_type):\n '''\n Get the entities with this ent and rel from db.\n sample some entites for trueAvg and trueVar embeddings\n now find KL divergence with these trueAvg and trueVar embeddings\n with all other subgraphs\n '''\n summation = np.zeros(50, dtype=np.float64)\n count = 0\n scores = []\n ER = ccorr(model.R[rel], model.E)\n # TODO: find true entities with this ent and rel in the database\n me = self.get_matching_entities(sub_type, ent, rel)\n for e in me:\n summation += model.E[e]\n count += 1\n mean = summation / count\n columnsSquareDiff = np.zeros(50, dtype=np.float64)\n for e in me:\n columnsSquareDiff += (model.E[e] - mean) * (model.E[e] - mean)\n if count > 2:\n columnsSquareDiff /= (count - 1)\n else:\n columnsSquareDiff = mean\n true_avg_emb = mean\n true_var_emb = columnsSquareDiff\n\n # Calculate kl scores with all subgraphs\n\n def calc_kl(sa, sv, qa, qv):\n #sa = np.ndarray(50, dtype=np.float64)\n #sv = np.ndarray(50, dtype=np.float64)\n #sa = tempa\n #sv = tempv\n temp = ((qa - sa)**2 + qv**2 / (2*sv*sv))\n sv[sv<0] = sv[sv<0]*-1\n qv[qv<0] = qv[qv<0]*-1\n temp2 = np.log(np.sqrt(sv)/qv)\n temp3 = 0.5\n ans = np.sum(temp + temp2 - temp3)\n return np.sum(temp + temp2 - temp3)\n for i in range(len(subgraphs)):\n scores.append(calc_kl(model.SA[i], model.SV[i], true_avg_emb, true_var_emb))\n return scores\n\n def subgraph_positions(self, mdl, subgraphs, sub_algo, sub_dist):\n pos = {}\n # do equivalent of self.prepare_global(mdl)\n count = 0\n sumTailRanks = 0\n sumHeadRanks = 0\n total = 0\n failfile = \"failed.log\"\n data = \"\"\n for p, sos in self.idx.items():\n # dictionary with 'tail' as the key, will store positions of H after keeping T and P constant\n ppos = {'head': [], 'tail': []}\n\n # do self.prepare(mdl, p ) # calculate ccorr(p , all subgraphs)\n # mdl.S should contain all subgraph embeddings\n if sub_dist == \"var\":\n SR = ccorr(mdl.R[p], mdl.SV)\n else:\n SR = ccorr(mdl.R[p], mdl.SA)\n # for var1 var 2,\n # calculate variance based scores with subgraphs' variance embeddings\n # and rearrange ranks\n for s, o in sos:#[:self.neval[p]]:\n count += 1\n if sub_dist == \"kl\":\n kl_ts = timeit.default_timer()\n scores_o = self.get_kl_divergence_scores(mdl, subgraphs, s, p, SUBTYPE.SPO)\n kl_te = timeit.default_timer()\n #print(\"Time to compute KL div scores = %ds\" % (kl_te-kl_ts))\n else:\n scores_o = np.dot(SR, mdl.E[s]).flatten()\n #print(scores_o)\n\n # are there any subgraphs with this S and P with subgraph type SPO\n # then set their scores to Inf\n skip_sub_index = self.get_skip_subgraphs(subgraphs, s, p, SUBTYPE.SPO)\n scores_o[skip_sub_index] = -np.Inf\n\n #scores_o should contain scores for each subgraph using dot product\n sortidx_o = argsort(scores_o)[::-1]\n # sortidx_o has the indices for sorted subgraph scores\n # Choose topk from this and find out if the answer lies in any of these subgraphs\n found = False\n for rank, index in enumerate(sortidx_o):\n #print(\"index = \", index)\n #print (subgraphs[index].entities)\n if o in subgraphs[index].entities:\n found = True\n break\n\n sumTailRanks += rank\n if False == found:\n data += str(o) + \"\\n\"\n #print (\"For \", str(s) , \", \", str(p), \" subgraph rank(o) = \" , rank, \" expected o = \", o)\n # rank could be 0 which leads to a possible divide by 0 error\n ppos['tail'].append(rank + 1)\n\n ocrr = ccorr(mdl.R[p], mdl.E[o])\n scores_s = np.dot(SR, ocrr).flatten()\n #print(scores_s)\n #scores_o should contain scores for each subgraph using dot product\n sortidx_s = argsort(scores_s)[::-1]\n # sortidx_o has the indices for sorted subgraph scores\n # Choose topk from this and find out if the answer lies in any of these subgraphs\n found = False\n for rank, index in enumerate(sortidx_s):\n if s in subgraphs[index].entities:\n found = True\n break\n\n sumHeadRanks += rank\n total += 1\n if False == found:\n data += str(s) + \"\\n\"\n #print (\"For \", str(o) , \", \", str(p), \" subgraph rank(s) = \" , rank, \" expected s = \", s)\n # rank could be 0 which leads to a possible divide by 0 error\n ppos['head'].append(rank + 1)\n pos[p] = ppos\n\n print(\"Mean tail rank = \", sumTailRanks / total)\n print(\"Mean head rank = \", sumHeadRanks / total)\n with open(failfile, \"w\") as fout:\n fout.write(data)\n return pos\n\n def positions(self, mdl, plot=False, pagerankMap=None):\n pos = {}\n fpos = {}\n\n if hasattr(self, 'prepare_global'):\n self.prepare_global(mdl)\n\n count = 0\n for p, sos in self.idx.items():\n #pdb.set_trace()\n\n # There will be just one item in the idx dictionary in case of the un-labelled graph (single-relation graph)\n # So, there will be just one iteration of outer for loop\n # f stands for filtered\n # For unfiltered evaluation, we consider all entities to compute scores with\n # For filtered evaluation, we exclude the neighbours of the entity to compute scores with\n # p might stand for predicate\n # ppos = positions for predicates, where\n # dictionary with 'head' as the key, will store positions of T after keeping H and P constant\n # dictionary with 'tail' as the key, will store positions of H after keeping T and P constant\n ppos = {'head': [], 'tail': []}\n pfpos = {'head': [], 'tail': []}\n\n # prepare() method adds embeddings of p to embeddings of every entity\n if hasattr(self, 'prepare'):\n #pdb.set_trace()\n # Add the embeddings of p to every entity of this model\n self.prepare(mdl, p)\n\n #log.info(\"Prepared\\n\")\n # For some reason, skip last tuple from all the tuples for relation 'P'\n # neval for every relation is -1\n # self.neval[p] will access the last element and we are skipping the last one by\n # array[:-1]\n #log.info(\"sos len = %d\" % (len(sos)))\n for s, o in sos:#[:self.neval[p]]:\n count += 1\n scores_o = self.scores_o(mdl, s, p).flatten()\n sortidx_o = argsort(scores_o)[::-1]\n # Sort all the entities (As objects) and find out the index of the \"O\" in picture\n # Store the index+1 in the ppos['tail]\n rank = np.where(sortidx_o == o)[0][0] + 1\n ppos['tail'].append(rank)\n\n if plot:\n inDegree_of_o = num_incoming_neighbours(o, graph)\n outDegree_of_o = num_outgoing_neighbours(o, graph)\n totalDegree_of_o = inDegree_of_o + outDegree_of_o\n inRelations = num_incoming_relations(o, graph)\n\n if pagerankMap:\n with open(_FILE_TAIL_PREDICTIONS_UNFILTERED, 'a') as fplot:\n fplot.write(\"%f %d %d %d\\n\" % (float(pagerankMap[o]) * 100000, 1 if rank <= 10 else 2, totalDegree_of_o, inRelations))\n else:\n with open(_FILE_TAIL_PREDICTIONS_UNFILTERED, 'a') as fplot:\n fplot.write(\"%d %d %d %d\\n\" % (inDegree_of_o, 1 if rank <= 10 else 2, totalDegree_of_o, inRelations))\n # In the real data, for relation \"P\", which entities appear as objects for subject \"S\"\n rm_idx = self.tt[p]['os'][s]\n # rm_idx is the list of such entities\n\n # Remove the object \"O\" that we are currently considering from this list\n rm_idx = [i for i in rm_idx if i != o]\n\n # Set the scores of KNOWN objects (known truths) to infinity = Filter the entities that already appear as neighbours\n scores_o[rm_idx] = -np.Inf\n sortidx_o = argsort(scores_o)[::-1]\n rank = np.where(sortidx_o == o)[0][0] + 1\n pfpos['tail'].append(rank)\n\n if plot:\n if pagerankMap:\n with open(_FILE_TAIL_PREDICTIONS_FILTERED, 'a') as fplot:\n fplot.write(\"%f %d %d %d\\n\" % (float(pagerankMap[o]) * 100000, 1 if rank <= 10 else 2, totalDegree_of_o, inRelations))\n else:\n with open(_FILE_TAIL_PREDICTIONS_FILTERED, 'a') as fplot:\n fplot.write(\"%d %d %d %d\\n\" % (inDegree_of_o, 1 if rank <= 10 else 2, totalDegree_of_o, inRelations))\n\n ################ HEAD predictions : Keep TAIL/OBJECT constant #######################\n\n\n # Unfiltered scores: calculate scores with all entities and sort them\n scores_s = self.scores_s(mdl, o, p).flatten()\n sortidx_s = argsort(scores_s)[::-1]\n rank = np.where(sortidx_s == s)[0][0] + 1\n ppos['head'].append(rank)\n\n if plot:\n outDegree_of_s = num_outgoing_neighbours(s, graph)\n inDegree_of_s= num_incoming_neighbours(s, graph)\n totalDegree_of_s = outDegree_of_s + inDegree_of_s\n outRelations = num_outgoing_relations(s, graph)\n # If pagerank file is provided, write the pagerank of the node instead of the degree\n if pagerankMap:\n with open(_FILE_HEAD_PREDICTIONS_UNFILTERED, 'a') as fplot:\n fplot.write(\"%f %d %d %d\\n\" % (float(pagerankMap[s]) * 100000, 1 if rank <= 10 else 2, totalDegree_of_s, outRelations))\n else:\n with open(_FILE_HEAD_PREDICTIONS_UNFILTERED, 'a') as fplot:\n fplot.write(\"%d %d %d %d\\n\" % (outDegree_of_s, 1 if rank <= 10 else 2, totalDegree_of_s, outRelations))\n\n rm_idx = self.tt[p]['ss'][o]\n rm_idx = [i for i in rm_idx if i != s]\n scores_s[rm_idx] = -np.Inf\n sortidx_s = argsort(scores_s)[::-1]\n rank = np.where(sortidx_s == s)[0][0] + 1\n pfpos['head'].append(rank)\n if plot:\n # If pagerank file is provided, write the pagerank of the node instead of the degree\n if pagerankMap:\n with open(_FILE_HEAD_PREDICTIONS_FILTERED, 'a') as fplot:\n fplot.write(\"%f %d %d %d\\n\" % (float(pagerankMap[s]) * 100000, 1 if rank <= 10 else 2, totalDegree_of_s, outRelations))\n else:\n with open(_FILE_HEAD_PREDICTIONS_FILTERED, 'a') as fplot:\n fplot.write(\"%d %d %d %d\\n\" % (outDegree_of_s, 1 if rank <= 10 else 2, totalDegree_of_s, outRelations))\n pos[p] = ppos\n fpos[p] = pfpos\n\n if count != self.sz:\n log.info(\"cnt = %d, self.sz = %d\" % (count, self.sz))\n return pos, fpos\n\n\nclass LinkPredictionEval(object):\n\n def __init__(self, xs, ys):\n ss, os, ps = list(zip(*xs))\n self.ss = list(ss)\n self.ps = list(ps)\n self.os = list(os)\n self.ys = ys\n\n def scores(self, mdl):\n scores = mdl._scores(self.ss, self.ps, self.os)\n pr, rc, _ = precision_recall_curve(self.ys, scores)\n roc = roc_auc_score(self.ys, scores)\n return auc(rc, pr), roc\n\n\ndef ranking_scores(fresult, pos, fpos, epoch, txt):\n hpos = [p for k in pos.keys() for p in pos[k]['head']]\n tpos = [p for k in pos.keys() for p in pos[k]['tail']]\n fhpos = [p for k in fpos.keys() for p in fpos[k]['head']]\n ftpos = [p for k in fpos.keys() for p in fpos[k]['tail']]\n fmrr = _print_pos(fresult,\n np.array(hpos + tpos),\n np.array(fhpos + ftpos),\n epoch, txt)\n return fmrr\n\ndef subgraph_ranking_scores(fresult, pos, txt, topk):\n hpos = [p for k in pos.keys() for p in pos[k]['head']]\n tpos = [p for k in pos.keys() for p in pos[k]['tail']]\n head_mrr, head_mean_pos, head_ans_hits = compute_scores(np.array(hpos), hits=topk)\n tail_mrr, tail_mean_pos, tail_ans_hits = compute_scores(np.array(tpos), hits=topk)\n\n log.info(\"Subgraph ranking scores : \")\n log.info(\n \"%s: MRR(H) = %.2f, Mean Rank(H) = %.2f, Hits@%d(H) = %.2f\" %\n (txt, head_mrr, head_mean_pos, topk, head_ans_hits )\n )\n log.info(\n \"%s: MRR(T) = %.2f, Mean Rank(T) = %.2f, Hits@%d(T) = %.2f\" %\n (txt, tail_mrr, tail_mean_pos, topk, tail_ans_hits )\n )\n fresult.write(\n \"%s: MRR(H) = %.2f, Mean Rank(H) = %.2f, Hits@%d(H) = %.2f\\n\" %\n (txt, head_mrr, head_mean_pos, topk, head_ans_hits)\n )\n fresult.write(\n \"%s: MRR(T) = %.2f, Mean Rank(T) = %.2f, Hits@%d(T) = %.2f\\n\" %\n (txt, tail_mrr, tail_mean_pos, topk, tail_ans_hits)\n )\n\ndef _print_pos(fresult, pos, fpos, epoch, txt):\n mrr, mean_pos, hits = compute_scores(pos)\n fmrr, fmean_pos, fhits = compute_scores(fpos)\n log.info(\n \"[%3d] %s: MRR = %.2f/%.2f, Mean Rank = %.2f/%.2f, Hits@10 = %.2f/%.2f\" %\n (epoch, txt, mrr, fmrr, mean_pos, fmean_pos, hits, fhits)\n )\n fresult.write(\n \"[%3d] %s: MRR = %.2f/%.2f, Mean Rank = %.2f/%.2f, Hits@10 = %.2f/%.2f\\n\" %\n (epoch, txt, mrr, fmrr, mean_pos, fmean_pos, hits, fhits)\n )\n return fmrr\n\n\ndef compute_scores(pos, hits=10):\n mrr = np.mean(1.0 / pos)\n mean_pos = np.mean(pos)\n ans_hits = np.mean(pos <= hits).sum() * 100\n return mrr, mean_pos, ans_hits\n\n\ndef cardinalities(xs, ys, sz):\n T = to_tensor(xs, ys, sz)\n c_head = []\n c_tail = []\n for Ti in T:\n sh = Ti.tocsr().sum(axis=1)\n st = Ti.tocsc().sum(axis=0)\n c_head.append(sh[np.where(sh)].mean())\n c_tail.append(st[np.where(st)].mean())\n\n cards = {'1-1': [], '1-N': [], 'M-1': [], 'M-N': []}\n for k in range(sz[2]):\n if c_head[k] < 1.5 and c_tail[k] < 1.5:\n cards['1-1'].append(k)\n elif c_head[k] < 1.5:\n cards['1-N'].append(k)\n elif c_tail[k] < 1.5:\n cards['M-1'].append(k)\n else:\n cards['M-N'].append(k)\n return cards\nclass Config(object):\n\n def __init__(self, model, trainer):\n self.model = model\n self.trainer = trainer\n\n def __getstate__(self):\n return {\n 'model': self.model,\n 'trainer': self.trainer\n }\n\n\nclass Model(object):\n \"\"\"\n Base class for all Knowledge Graph models\n\n Implements basic setup routines for parameters and serialization methods\n\n Subclasses need to implement:\n - scores(self, ss, ps, os)\n - _gradients(self, xys) for StochasticTrainer\n - _pairwise_gradients(self, pxs, nxs) for PairwiseStochasticTrainer\n C++ : Use virtual functions, make the Model class abstract by having pure virtual functions\n \"\"\"\n\n def __init__(self, *args, **kwargs):\n #super(Model, self).__init__(*args, **)\n self.params = {}\n self.hyperparams = {}\n # C++ : No named parameters. Emulate.\n self.add_hyperparam('init', kwargs.pop('init', 'nunif'))\n\n def add_param(self, param_id, shape, post=None, value=None):\n if value is None:\n value = Parameter(shape, self.init, name=param_id, post=post)\n setattr(self, param_id, value)\n self.params[param_id] = value\n\n def add_hyperparam(self, param_id, value):\n setattr(self, param_id, value)\n self.hyperparams[param_id] = value\n\n def __getstate__(self):\n return {\n 'hyperparams': self.hyperparams,\n 'params': self.params\n }\n\n def __setstate__(self, st):\n self.params = {}\n self.hyperparams = {}\n for pid, p in st['params'].items():\n self.add_param(pid, None, None, value=p)\n for pid, p in st['hyperparams'].items():\n self.add_hyperparam(pid, p)\n\n def save(self, fname, protocol=pickle.HIGHEST_PROTOCOL):\n with open(fname, 'wb') as fout:\n pickle.dump(self, fout, protocol=protocol)\n\n @staticmethod\n def load(fname):\n with open(fname, 'rb') as fin:\n mdl = pickle.load(fin)\n return mdl\n\n\nclass StochasticTrainer(object):\n \"\"\"\n Stochastic gradient descent trainer with scalar loss function.\n\n Models need to implement\n\n _gradients(self, xys)\n\n to be trained with this class.\n\n \"\"\"\n\n def __init__(self, *args, **kwargs):\n self.model = args[0]\n self.hyperparams = {}\n self.add_hyperparam('max_epochs', kwargs.pop('max_epochs', _DEF_MAX_EPOCHS))\n self.add_hyperparam('nbatches', kwargs.pop('nbatches', _DEF_NBATCHES))\n self.add_hyperparam('learning_rate', kwargs.pop('learning_rate', _DEF_LEARNING_RATE))\n\n self.post_epoch = kwargs.pop('post_epoch', _DEF_POST_EPOCH)\n self.samplef = kwargs.pop('samplef', _DEF_SAMPLE_FUN)\n pu = kwargs.pop('param_update', AdaGrad)\n self._updaters = {\n key: pu(param, self.learning_rate)\n for key, param in self.model.params.items()\n }\n\n def set_max_epochs(self, epoch):\n self.max_epochs = epoch\n\n def __getstate__(self):\n return self.hyperparams\n\n def __setstate__(self, st):\n for pid, p in st['hyperparams']:\n self.add_hyperparam(pid, p)\n\n def add_hyperparam(self, param_id, value):\n setattr(self, param_id, value)\n self.hyperparams[param_id] = value\n\n def fit(self, xs, ys):\n self._optim(list(zip(xs, ys)))\n\n def _pre_epoch(self):\n self.loss = 0\n\n def _optim(self, xys):\n # idx = [0,1,2,...., k] where len(xys) = k\n idx = np.arange(len(xys))\n #pdb.set_trace();\n self.batch_size = len(xys) // self.nbatches\n #print (type(self.batch_size))\n #print(type(xys))\n # A-range (start, stop, jump)\n # For batch size 10 and nbatches 100 and len(xys) = 1000\n # batch_idx = [10,20,30,40,....100,110,....990,1000]\n batch_idx = np.arange(self.batch_size, len(xys), self.batch_size)\n #pdb.set_trace()\n for self.epoch in range(1, self.max_epochs + 1):\n # shuffle training examples\n self._pre_epoch()\n shuffle(idx)\n\n # store epoch for callback\n self.epoch_start = timeit.default_timer()\n\n # process mini-batches\n # Split the array idx by indexes given in batch_idx\n # batch_idx contains [1414, 2828, 4242, 5656, 7070,...]\n # Thus, batch will contain array of 1414 elements each time\n # entities with ids 0-1413, 1414-2827, 2828-4241 etc.\n #log.info(\"%d) \" % self.epoch)\n for batch in np.split(idx, batch_idx):\n '''\n xys is array of tuple pairs as follows\n ((S1, O1, P1), 1.0 )\n ((S2, O2, P2), 1.0 )\n ((S3, O3, P3), 1.0 )\n ..\n ..\n ((Sn, On, Pn), 1.0 )\n\n xys[index] will access one of these pairs.\n xys[index][0] will access the triplet.\n xys[index][0][0] will access the subject entity.\n '''\n #log.info(\"length of minibatch[%d] \" % len(batch))\n bxys = [xys[z] for z in batch]\n self._process_batch(bxys)\n\n # check callback function, if false return\n # post_epoch is the self.callback. It was set in setup_trainer() method\n # of TransEExp\n for f in self.post_epoch:\n if not f(self):\n break\n\n def _process_batch(self, xys):\n # if enabled, sample additional examples\n if self.samplef is not None:\n xys += self.samplef(xys)\n\n if hasattr(self.model, '_prepare_batch_step'):\n self.model._prepare_batch_step(xys)\n\n # take step for batch\n grads = self.model._gradients(xys)\n self.loss += self.model.loss\n self._batch_step(grads)\n\n def _batch_step(self, grads):\n for paramID in self._updaters.keys():\n #pdb.set_trace();\n # *grads[paramID] unpacks argument list when calling the function, in this case CTOR\n # Because _updaters is a dictionary\n # _updaters[param] will be the value of type AdaGrad\n # AdaGrad is subclass of ParameterUpdate\n # ParameterUpdate class has a __call__ method\n # This method is called when the instance of ParameterUpdate is called.\n # C++ : functors, overload operator()\n self._updaters[paramID](*grads[paramID])\n #pdb.set_trace();\n\n\nclass PairwiseStochasticTrainer(StochasticTrainer):\n \"\"\"\n Stochastic gradient descent trainer with pairwise ranking loss functions.\n\n Models need to implement\n\n _pairwise_gradients(self, pxs, nxs)\n\n to be trained with this class.\n\n \"\"\"\n\n\n def __init__(self, *args, **kwargs):\n super(PairwiseStochasticTrainer, self).__init__(*args, **kwargs)\n self.model.add_hyperparam('margin', kwargs.pop('margin', _DEF_MARGIN))\n fg = kwargs.pop('file_grad', _FILE_GRADIENTS)\n fe = kwargs.pop('file_embed', _FILE_EMBEDDINGS)\n self.file_gradients = None\n self.file_embeddings = None\n self.pickle_file_embeddings = None\n\n if fg is not None:\n self.file_gradients = open(fg, \"w\")\n if fe is not None:\n self.file_embeddings = open(fe, \"w\")\n self.pickle_file_embeddings = open(fe+\".pkl\", \"wb\")\n\n def fit(self, xs, ys):\n # samplef is RandomModeSample set by setup_trainer() method\n if self.samplef is None:\n pidx = np.where(np.array(ys) == 1)[0]\n nidx = np.where(np.array(ys) != 1)[0]\n pxs = [xs[i] for i in pidx]\n self.nxs = [xs[i] for i in nidx]\n self.pxs = int(len(self.nxs) / len(pxs)) * pxs\n xys = list(range(min(len(pxs), len(self.nxs))))\n self._optim(xys)\n else:\n # make a list of tuples such that every entry is the tuple of two tuples (Xs and Ys)\n log.info(\"Pairwise Stochastic Trainer fit() \")\n self._optim(list(zip(xs, ys)))\n #pdb.set_trace()\n\n for x in xs:\n # each x is (SUB, OBJ, PREDicate)\n self.model.E.neighbours[x[0]] += 1\n self.model.E.neighbours[x[1]] += 1\n\n #pdb.set_trace()\n index = 0\n if self.file_gradients is not None:\n self.file_gradients.write(\"Entity,Degree,#(violations),#(updates)\\n\")\n for en, ev, ec in zip(self.model.E.neighbours, self.model.E.violations, self.model.E.updateCounts):\n self.file_gradients.write(\"%d,%d,%d,%d\\n\" % (index, en, ev, ec))\n index += 1\n\n index = 0\n embeddings_list = []\n for e in self.model.E:\n if self.file_embeddings is not None:\n embeddings = str(e)\n embeddings_list.append(e)\n self.file_embeddings.write(\"%d,%s\\n\" % (index, embeddings))\n index += 1\n if self.pickle_file_embeddings is not None:\n pickle.dump(embeddings_list, self.pickle_file_embeddings, protocol=2)\n\n def _pre_epoch(self):\n self.nviolations = 0\n if self.samplef is None:\n shuffle(self.pxs)\n shuffle(self.nxs)\n\n def _process_batch(self, xys):\n pxs = []\n nxs = []\n\n for xy in xys:\n\n # samplef is RandomModeSampler\n if self.samplef is not None:\n '''\n Change head or tail of the tuple (H, T, R)\n This code introduces the entities that were not originally present in any tuples\n (in case of T% of tuples processing)\n In other words, it adds 2 negative tuples for every positive tuple\n Why 2 : That's how RandomModeSampler works\n '''\n for nx in self.samplef([xy]):\n pxs.append(xy)\n nxs.append(nx)\n else:\n pxs.append((self.pxs[xy], 1))\n nxs.append((self.nxs[xy], 1))\n\n # take step for batch\n if hasattr(self.model, '_prepare_batch_step'):\n # Not set\n self.model._prepare_batch_step(pxs, nxs)\n #pdb.set_trace()\n grads = self.model._pairwise_gradients(pxs, nxs)\n\n #pdb.set_trace()\n # update if examples violate margin\n if grads is not None:\n self.nviolations += self.model.nviolations\n self._batch_step(grads)\n\n\ndef sigmoid(fs):\n # compute elementwise gradient for sigmoid\n for i in range(len(fs)):\n if fs[i] > _cutoff:\n fs[i] = 1.0\n elif fs[i] < -_cutoff:\n fs[i] = 0.0\n else:\n fs[i] = 1.0 / (1 + np.exp(-fs[i]))\n return fs[:, np.newaxis]\n",
"import pickle, pprint, math\nimport sys\nimport pdb\nfrom collections import defaultdict as ddict\nimport operator\nimport numpy\nimport operator\nimport time\nimport logging\n\nlogging.basicConfig(level=logging.DEBUG)\nlog = logging.getLogger('EVAL-EMBED')\n\n\ndef incoming_neighbours(entity, graph):\n relations_entity_is_tail = graph['incoming'][entity].keys()\n incoming_neighbours = []\n for r in relations_entity_is_tail:\n for e in graph['relations_tail'][r].keys():\n incoming_neighbours.append(e)\n\n return incoming_neighbours\n\ndef outgoing_neighbours(entity, graph):\n relations_entity_is_head = graph['outgoing'][entity].keys()\n outgoing_neighbours = []\n for r in relations_entity_is_head:\n for e in graph['relations_head'][r].keys():\n outgoing_neighbours.append(e)\n\n return outgoing_neighbours\n\ndef make_graph(triples, N, M):\n graph_outgoing = [ddict(list) for _ in range(N)]\n graph_incoming = [ddict(list) for _ in range(N)]\n graph_relations_head = [ddict(list)for _ in range(M)]\n graph_relations_tail = [ddict(list)for _ in range(M)]\n for t in triples:\n head = t[0]\n tail = t[1]\n relation = t[2]\n graph_outgoing[head][relation].append(tail)\n graph_incoming[tail][relation].append(head)\n graph_relations_head[relation][head].append(tail)\n graph_relations_tail[relation][tail].append(head)\n\n return {'outgoing': graph_outgoing, 'incoming': graph_incoming, 'relations_head': graph_relations_head, 'relations_tail':graph_relations_tail}\n\ndef processFile(datafile):\n with open(datafile,'r')as fin:\n data = fin.read()\n\n records = data.split(']')\n # Remove the last element (extra newline)\n del(records[-1])\n embeddings = [[] for _ in range(len(records))]\n for i,r in enumerate(records):\n embeddings_str = r.split(',[')[1].split()\n for e in embeddings_str:\n embeddings[i].append(float(e))\n\n return numpy.array(embeddings)\n\ndef processPickleFile(datafile):\n with open(datafile, 'rb') as fin:\n data = pickle.load(fin)\n return data\n\ndef l1Distance(em1, em2):\n distances = []\n for i, (e1, e2) in enumerate(zip(em1, em2)):\n out = 0\n r = numpy.abs(e1 - e2)\n for el in r:\n out += el\n distances.append((i, out))\n return distances\n\n# cosine similarity function\n# http://stackoverflow.com/questions/1746501/can-someone-give-an-example-of-cosine-similarity-in-a-very-simple-graphical-wa\ndef cosTheta(v1, v2):\n dot_product = sum(n1 * n2 for n1, n2 in zip(v1, v2) )\n magnitude1 = math.sqrt(sum(n ** 2 for n in v1))\n magnitude2 = math.sqrt(sum(n ** 2 for n in v2))\n return dot_product / (magnitude1 * magnitude2)\n\n\ndef cosineMatrix(em):\n N = len(em)\n mat = numpy.full((N,N), 2)\n\n for i in range(N):\n mat[i][i] = 1\n\n i = 0\n while (i < N):\n j = i+1\n while (j < N):\n mat[i][j] = mat[j][i] = cosTheta(em[i], em[j])\n j += 1\n i += 1\n\n return mat\n\ndef similarity(em, mat, TOPK, training_graph, test_graph, flog):\n out = [[] for i in range(len(em))]\n for i, e in enumerate(em):\n flog.write (\"Entity (%d): \" %(i))\n log.info (\"Entity (%d): \" %(i))\n cos_dict = ddict()\n #incoming = incoming_neighbours(i, graph)\n #outgoing = outgoing_neighbours(i, graph)\n incoming_train = incoming_neighbours(i, training_graph)\n outgoing_train = outgoing_neighbours(i, training_graph)\n incoming_test = incoming_neighbours(i, test_graph)\n outgoing_test = outgoing_neighbours(i, test_graph)\n for j, obj in enumerate(em):\n if i == j:\n continue\n theta = mat[i][j]\n cos_dict[j] = theta\n #print (\"%d,%f\" % (i, theta))\n\n sorted_dict = sorted(cos_dict.items(), key=operator.itemgetter(1), reverse=True)\n flog.write(\"cosine results collected and sorted, \")\n log.info(\"cosine results collected and sorted, \")\n\n # Add one more column for training/test/Unknown\n for k,v in enumerate(sorted_dict):\n if k == TOPK:\n break\n if k in incoming_train or k in outgoing_train:\n out[i].append((v, True, \"TRAIN\"))\n elif k in incoming_test or k in outgoing_test:\n out[i].append((v, True, \"TEST\"))\n else:\n out[i].append((v, False))\n flog.write(\" Table of evaluation built\\n\")\n log.info(\" Table of evaluation built\\n\")\n return out\n\nif __name__=='__main__':\n if len(sys.argv) != 4:\n print (\"Usage: python %s <embeddings.txt> <kb.bin> <TOPK>\" % (sys.arg[0]))\n sys.exit()\n\n logfile = sys.argv[1] + \".log\"\n flog = open(logfile, 'w')\n\n start = time.time()\n embeddings = processFile(sys.argv[1])\n kb = processPickleFile(sys.argv[2])\n flog.write(\"Time to process files = %ds\" % (time.time() - start))\n log.info(\"Time to process files = %ds\" % (time.time() - start))\n TOPK = int(sys.argv[3])\n N = len(kb['entities'])\n M = len(kb['relations'])\n training = kb['train_subs']\n valid = kb['valid_subs']\n test = kb['test_subs']\n # this is unfiltered evaluation (because the triples from the training sets are supposed to be guessed correctly)\n #dataset = training + valid + test\n start = time.time()\n training_graph = make_graph(training, N, M)\n test_graph = make_graph(test, N, M)\n flog.write(\"Time to build graphs from triples = %ds\\n\" %(time.time() - start))\n log.info(\"Time to build graphs from triples = %ds\\n\" %(time.time() - start))\n\n if N != len(embeddings):\n print(\"Number of entities don't match (embeddings file and database)\")\n sys.exit()\n\n start = time.time()\n mat = cosineMatrix(embeddings)\n flog.write(\"Time to make cosine distance matrix = %ds\\n\" % (time.time() - start))\n log.info(\"Time to make cosine distance matrix = %ds\\n\" % (time.time() - start))\n\n start = time.time()\n cosines = similarity(embeddings, mat, TOPK, training_graph, test_graph, flog)\n flog.write(\"Time to sort and rank best matching objects = %ds\\n\"%(time.time() - start))\n log.info(\"Time to sort and rank best matching objects = %ds\\n\"%(time.time() - start))\n\n start = time.time()\n outFile = sys.argv[2] + \"-\" + \"TOP-\" + str(TOPK) + \".eval.out\"\n data = \"{\"\n for i, pairs in enumerate(cosines):\n data += str(i) + \": {\"\n for p in pairs:\n data += str(p) + \"\\n\"\n data += \"}\"\n data += \"}\"\n with open(outFile, 'w') as fout:\n fout.write(data)\n flog.write(\"Time to write out file = %ds\" % (time.time() - start))\n log.info(\"Time to write out file = %ds\" % (time.time() - start))\n"
] | [
[
"sklearn.metrics.roc_auc_score",
"numpy.split",
"numpy.dot",
"numpy.sqrt",
"numpy.random.seed",
"numpy.random.shuffle",
"sklearn.metrics.precision_recall_curve",
"numpy.exp",
"numpy.full",
"numpy.mean",
"numpy.any",
"numpy.where",
"numpy.argsort",
"sklearn.metrics.auc",
"numpy.array",
"numpy.zeros",
"numpy.sum"
],
[
"numpy.array",
"numpy.abs",
"numpy.full"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
taoualiw/MyMoneyManager-App | [
"d824b4a3d4e23a3f0dee48d9e6da65c87696f08b"
] | [
"mmm/functions.py"
] | [
"import pandas as pd\nimport os\nimport numpy as np\nnp.set_printoptions(precision=2)\n\ndef import_transFileUFCU(path_transfilename):\n df = pd.read_csv(path_transfilename)\n acc = df.account_id.values\n df[\"account\"]= [acc[i] for i in range(len(acc))]\n df[\"date\"] = pd.DatetimeIndex(df['posted_at']).strftime(\"%m/%d/%y\")\n day = pd.DatetimeIndex(df['posted_at']).strftime(\"%y%m%d\")\n dayrank = (df.groupby(['date']).cumcount() + 1).values\n df[\"trans_id\"] = [int(day[i]+np.str(dayrank[i])) for i in range(len(day))]\n df[\"payee\"] = df.original_name.values\n trans_type = np.array(df.transaction_type.values)\n trans_type[trans_type==\"Credit\"] = 1\n trans_type[trans_type==\"Debit\"] = -1\n df[\"amount\"] = df.amount.values*trans_type\n df = df[[\"account\",\"date\",\"trans_id\",\"payee\",\"amount\"]]\n df['categoryGroup'] = [\"To categorize\"]*len(df)\n df['category'] = [\"To categorize\"]*len(df)\n df = df.sort_values(\"trans_id\")\n return df\n\n\ndef import_histFileUFCU(path_histfilename,account_id):\n df = pd.read_csv(path_histfilename,header=None)\n df.columns = [\"date\",\"payee\",\"amount\",\"balance\"]\n df[df.columns[2:4]] = df[df.columns[2:4]].replace('[\\$,]', '', regex=True).astype(float)\n df = df.sort_index(ascending=False)\n day = pd.DatetimeIndex(df['date']).strftime(\"%y%m%d\")\n df[\"date\"] = pd.DatetimeIndex(df['date']).strftime(\"%m/%d/%y\")\n dayrank = (df.groupby(['date']).cumcount() + 1).values\n df[\"trans_id\"] = [int(day[i]+np.str(dayrank[i])) for i in range(len(day))]\n df[\"account\"]= [account_id]*len(df)\n df['categoryGroup'] = [\"To categorize\"]*len(df)\n df['category'] = [\"To categorize\"]*len(df)\n df = df[[\"account\", \"date\", \"trans_id\", \"payee\", \"amount\", \"categoryGroup\",\"category\"]]\n return df\n\ndef df_Income(myDF):\n c = \"Income\"\n monthList = myDF.month.drop_duplicates().values\n pattern = r'.*UT\\sPayroll.*'\n myDF = myDF.replace(pattern, \"UT Payroll\",regex=True)\n dfc = myDF.loc[myDF.categoryGroup==c].groupby([\"month\",\"payee\"])[\"amount\"].sum().unstack(level=0)\n dfc = dfc.reindex(columns=monthList)\n #if correct: dfc = correct_forPayrollDelay(dfc)\n dfc.loc['Total']= dfc.sum()\n avg = dfc.mean(numeric_only=True, axis=1)\n tot = dfc.sum(numeric_only=True, axis=1)\n df = myDF.groupby([\"month\",\"categoryGroup\"])[\"amount\"].sum().unstack(level=0)\n dfc[\"Average\"] = avg\n dfc[\"Total\"] = tot\n return dfc\ndef df_Outcome(myDF):\n monthList = myDF.month.drop_duplicates().values\n categList = [\"Income\",\"Immediate Obligations\", \"Occasional Obligations\", \"General Expenses\",\"Entertainment\",\"Refundable\",\"To categorize\"]\n #if not excludeTravel:\n # categList.append(\"Travel\")\n df = myDF.groupby([\"month\",\"categoryGroup\"])[\"amount\"].sum().unstack(level=0)\n df = df[monthList]\n df = df.reindex(categList[1:])\n df.loc['Total']= df.sum()\n avg = df.mean(numeric_only=True, axis=1)\n tot = df.sum(numeric_only=True, axis=1)\n df[\"Average\"] = avg\n df[\"Total\"] = tot\n return df\ndef df_Balance(df_in,df_out):\n df_in_out = df_in.copy()\n df_in_out.loc[\"Total Income\"] = df_in.loc[\"Total\"]\n df_in_out.loc[\"Total Outcome\"] = df_out.loc[\"Total\"]\n df_in_out = df_in_out.loc[[\"Total Income\",\"Total Outcome\"]]\n #df_in_out.loc[\"Balance\"] = df_in_out.sum()\n return df_in_out\ndef df_CategoryGroup(myDF,c):\n monthList = myDF.month.drop_duplicates().values\n dfc = myDF.loc[myDF.categoryGroup==c]\n if len(dfc)>0:\n dfc = dfc.groupby([\"month\",\"category\"])[\"amount\"].sum().unstack(level=0)\n dfc = dfc.reindex(columns=monthList)\n dfc.loc['Total']= dfc.sum()\n avg = dfc.mean(numeric_only=True, axis=1)\n tot = dfc.sum(numeric_only=True, axis=1)\n df = myDF.groupby([\"month\",\"categoryGroup\"])[\"amount\"].sum().unstack(level=0)\n dfc[\"Average\"] = avg\n dfc[\"Total\"] = tot\n return dfc\n\ndef categMenuOptions(myCategDF):\n cg = list(myCategDF.categoryGroup.drop_duplicates().values)\n categMenuOption = []\n for i in range(len(cg)):\n op = list(myCategDF.category[myCategDF.categoryGroup==cg[i]].drop_duplicates().values)\n op = tuple([cg[i]]+op+[\"To categorize\"])\n categMenuOption.append(op)\n categMenuOption = tuple(categMenuOption)\n return categMenuOption\n#------\ndef search_rows(DF, name, column =\"payee\"):\n DF = DF.reset_index(drop=True)\n return DF[DF[column].str.contains(name,regex=False)].index.values\ndef assign_learned_categories(DF, categoryDF, payee):\n rows = search_rows(categoryDF, payee)\n if len(rows)==1:\n cg = categoryDF.iloc[rows].iloc[0].categoryGroup\n c = categoryDF.iloc[rows].iloc[0].category\n rows = search_rows(DF, payee)\n for r in rows:\n if DF.iloc[r,6]==\"To categorize\":\n DF.iloc[r,6] = c\n DF.iloc[r,5] = cg\n return DF\n#-----\n"
] | [
[
"pandas.read_csv",
"numpy.set_printoptions",
"pandas.DatetimeIndex",
"numpy.array",
"numpy.str"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
CHH3213/two_loggers | [
"11b2016e424753aac85404e6a48f3b15b2448734",
"11b2016e424753aac85404e6a48f3b15b2448734"
] | [
"omni_diff_rl/scripts/TD3-master/CBF.py",
"omni_diff_rl/scripts/maddpg-master/save_data/save_data.py"
] | [
"import numpy as np\r\nfrom scipy.optimize import minimize\r\n\r\n\r\ndef QPfun(ud):\r\n def fun(u):\r\n return (u[0] - ud[0])**2 / 2\r\n return fun\r\n\r\n\r\ndef constrains(State):\r\n '''\r\n State[0] = Xp\r\n State[1] = Yp\r\n State[2] = th_p (rad)\r\n State[3] = Xe\r\n State[4] = Ye\r\n State[5] = th_e (rad)\r\n State[6] = wp\r\n '''\r\n Vp = 1.0\r\n Ve = 0.787\r\n r = 0.3\r\n\r\n Xp, Yp, th_p, Xe, Ye, th_e, wp = State\r\n sinp, cosp, sine, cose = np.sin(th_p), np.cos(\r\n th_p), np.sin(th_e), np.cos(th_e)\r\n Dp = np.array([Xp-Xe, Yp-Ye])\r\n Dv = np.array([Vp*cosp-Ve*cose, Vp*sinp-Ve*sine])\r\n Dvp = np.array([-Vp*sinp, Vp*cosp])\r\n Dve = np.array([-Ve*sine, Ve*cose])\r\n\r\n K0 = 0.8\r\n K1 = 0.4\r\n\r\n def con_we(we):\r\n \r\n return 2*(Vp**2 + Ve**2 - 2*Vp*Ve*np.cos(th_p-th_e)) + 2*wp*np.einsum('i,i->', Dp, Dvp) - \\\r\n 2*we*np.einsum('i,i->', Dp, Dve) + \\\r\n K0*(np.einsum('i,i->', Dp, Dp) - r**2) + \\\r\n 2*K1*(np.einsum('i,i->', Dp, Dv))\r\n\r\n\r\n cons = (\r\n {'type': 'ineq', 'fun': con_we},\r\n {'type': 'ineq', 'fun': lambda u: u[0]+2},\r\n {'type': 'ineq', 'fun': lambda u: 2-u[0]}\r\n )\r\n\r\n return cons\r\n\r\n\r\ndef CBF(u, State):\r\n '''\r\n u=[we]\r\n\r\n State[0] = Xp\r\n State[1] = Yp\r\n State[2] = th_p (rad)\r\n State[3] = Xe\r\n State[4] = Ye\r\n State[5] = th_e (rad)\r\n State[6] = wp\r\n '''\r\n x0 = u\r\n wmax,wmin = 2,-2\r\n if State[6]<0:\r\n State[6]=wmax\r\n elif State[6]>0:\r\n State[6]=wmin\r\n else:\r\n State[6] = 0\r\n\r\n res = minimize(fun=QPfun(u), x0=x0, constraints=constrains(State))\r\n # print(res.success)\r\n return res.x\r\n\r\n\r\nif __name__ == '__main__':\r\n pass\r\n",
"import scipy.io as sio\nfile_path =\"/home/caohuanhui/Downloads/capture&pursue/maddpg-master/save_data/训练数据/policy_22\"\ndef save_data(file_name,**args):\n # file_name=file_path+'/reward.mat'\n for key,values in args.items():\n sio.savemat(file_name, {key:values})\n\n\n\n\n\nif __name__=='__main__':\n # list1={'1':1,\"2\":5}\n # save_data(file_path,list1)\n data=sio.loadmat(file_path+'/network_vs_default-a4_2.4.mat')\n # data=sio.loadmat(file_path+'/rewards.mat')\n # print(data.shape)\n print(data)\n # list = [1,2,3,4,5,6]\n # l = [list[i] for i in range(len(list)) if i == 0 or i==1 or i == 3 or i==5]\n # print(l)\n # p_x = obs_n[0][0] + obs_n[0][2]\n # p_y = obs_n[0][1] + obs_n[0][3]\n # v_x = obs_n[0][4] + obs_n[0][6]\n # v_y = obs_n[0][5] + obs_n[0][7]\n # obs_n[0][2] = p_x\n # obs_n[0][3] = p_y\n # obs_n[0][6] = v_x\n # obs_n[0][7] = v_y\n # # --------------------\n # # 取绝对位置绝对速度时\n # position.append(obs_n[0][0:4])\n # volocity.append(obs_n[0][4:8])\n\n"
] | [
[
"numpy.array",
"numpy.cos",
"numpy.einsum",
"numpy.sin"
],
[
"scipy.io.loadmat",
"scipy.io.savemat"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16",
"1.8"
],
"tensorflow": []
}
] |
j0a8c2k1/pysat | [
"4ae1afd80e15e4449397d39dce8c3e969c32c422",
"4ae1afd80e15e4449397d39dce8c3e969c32c422"
] | [
"pysat/instruments/pysat_testsmall.py",
"pysat/instruments/supermag_magnetometer.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nProduces fake instrument data for testing.\n\"\"\"\n\nimport pandas as pds\nimport numpy as np\nimport pysat\n\n# pysat required parameters\nplatform = 'pysat'\nname = 'testing'\n# dictionary of data 'tags' and corresponding description\ntags = {'':'Regular testing data set'}\n# dictionary of satellite IDs, list of corresponding tags\nsat_ids = {'':['']}\ntest_dates = {'':{'':pysat.datetime(2009,1,1)}}\n\nmeta = pysat.Meta()\nmeta['uts'] = {'units':'s', 'long_name':'Universal Time', 'custom':False}\nmeta['mlt'] = {'units':'hours', 'long_name':'Magnetic Local Time'}\nmeta['slt'] = {'units':'hours', 'long_name':'Solar Local Time'}\n\n \ndef init(self):\n self.new_thing=True \n \ndef load(fnames, tag=None, sat_id=None, sim_multi_file_right=False,\n sim_multi_file_left=False, root_date = None):\n # create an artifical satellite data set\n parts = fnames[0].split('/')\n yr = int('20'+parts[-1][0:2])\n month = int(parts[-3])\n day = int(parts[-2])\n\n date = pysat.datetime(yr, month, day)\n if sim_multi_file_right:\n root_date = root_date or pysat.datetime(2009,1,1,12)\n data_date = date+pds.DateOffset(hours=12)\n elif sim_multi_file_left:\n root_date = root_date or pysat.datetime(2008,12,31,12)\n data_date = date-pds.DateOffset(hours=12)\n else:\n root_date = root_date or pysat.datetime(2009,1,1)\n data_date = date\n num = 100 if tag is '' else int(tag)\n num_array = np.arange(num)\n uts = num_array\n data = pysat.DataFrame(uts, columns=['uts'])\n\n # need to create simple orbits here. Have start of first orbit \n # at 2009,1, 0 UT. 14.84 orbits per day\t\n time_delta = date - root_date\n uts_root = np.mod(time_delta.total_seconds(), 5820)\n mlt = np.mod(uts_root+num_array, 5820)*(24./5820.)\n data['mlt'] = mlt\n \n # fake orbit number\n fake_delta = date - pysat.datetime(2008,1,1) \n fake_uts_root = fake_delta.total_seconds()\n\n data['orbit_num'] = ((fake_uts_root+num_array)/5820.).astype(int)\n \n # create a fake longitude, resets every 6240 seconds\n # sat moves at 360/5820 deg/s, Earth rotates at 360/86400, takes extra time \n # to go around full longitude\n long_uts_root = np.mod(time_delta.total_seconds(), 6240)\n longitude = np.mod(long_uts_root+num_array, 6240)*(360./6240.)\n data['longitude'] = longitude\n\n # create latitude area for testing polar orbits\n latitude = 90.*np.cos(np.mod(uts_root+num_array, 5820)*(2.*np.pi/5820.)) \n data['latitude'] = latitude\n \n # do slt, 20 second offset from mlt\n uts_root = np.mod(time_delta.total_seconds()+20, 5820)\n data['slt'] = np.mod(uts_root+num_array, 5820)*(24./5820.)\n \n # create some fake data to support testing of averaging routines\n mlt_int = data['mlt'].astype(int)\n long_int = (data['longitude']/15.).astype(int)\n data['dummy1'] = mlt_int\n data['dummy2'] = long_int\n data['dummy3'] = mlt_int + long_int*1000.\n data['dummy4'] = num_array\n data['string_dummy'] = ['test']*len(data)\n data['unicode_dummy'] = [u'test'] * len(data)\n data['int8_dummy'] = np.array([1] * len(data), dtype=np.int8)\n data['int16_dummy'] = np.array([1] * len(data), dtype=np.int16)\n data['int32_dummy'] = np.array([1] * len(data), dtype=np.int32)\n data['int64_dummy'] = np.array([1] * len(data), dtype=np.int64)\n # print (data['string_dummy'])\n \n index = pds.date_range(data_date, data_date+pds.DateOffset(seconds=num-1), freq='S')\n data.index=index[0:num]\n data.index.name = 'time'\n return data, meta.copy()\n\ndef list_files(tag=None, sat_id=None, data_path=None, format_str=None):\n \"\"\"Produce a fake list of files spanning a year\"\"\"\n \n index = pds.date_range(pysat.datetime(2008,1,1), pysat.datetime(2010,12,31)) \n names = [ data_path+date.strftime('%D')+'.nofile' for date in index]\n return pysat.Series(names, index=index)\n \ndef download(date_array, tag, sat_id, data_path=None, user=None, password=None):\n pass\n",
"# -*- coding: utf-8 -*-\n\"\"\"Supports SuperMAG ground magnetometer measurements and SML/SMU indices.\nDownloading is supported; please follow their rules of the road:\n http://supermag.jhuapl.edu/info/?page=rulesoftheroad\n\nParameters\n----------\nplatform : string\n 'supermag'\nname : string\n 'magnetometer'\ntag : string\n Select {'indices', '', 'all', 'stations'}\n\nNote\n----\nFiles must be downloaded from the website, and is freely available after\nregistration.\n\nThis material is based upon work supported by the \nNational Science Foundation under Grant Number 1259508. \n\nAny opinions, findings, and conclusions or recommendations expressed in this \nmaterial are those of the author(s) and do not necessarily reflect the views \nof the National Science Foundation.\n\n\nWarnings\n--------\n- Currently no cleaning routine, though the SuperMAG description indicates that\n these products are expected to be good. More information about the processing\n is available \n- Module not written by the SuperMAG team.\n\nCustom Functions\n-----------------\n \n\"\"\"\n\nfrom __future__ import print_function, absolute_import\nimport pandas as pds\nimport numpy as np\nfrom os import path\n\nimport pysat\n\nplatform = 'supermag'\nname = 'magnetometer'\ntags = {'indices':'SMU and SML indices',\n '':'magnetometer measurements',\n 'all':'magnetometer measurements and indices',\n 'stations':'magnetometer stations'}\nsat_ids = {'':tags.keys()}\ntest_dates = {'':{kk:pysat.datetime(2009,1,1) for kk in tags.keys()}}\n\ndef init(self):\n print(\"When using this data please acknowledge the SuperMAG collaboration \"\n + \"according to the request outlined in the metadata attribute \"\n + \"'acknowledgements'\")\n return \n\ndef list_files(tag='', sat_id=None, data_path=None, format_str=None):\n \"\"\"Return a Pandas Series of every file for chosen SuperMAG data\n\n Parameters\n -----------\n tag : (string or NoneType)\n Denotes type of file to load. Accepted types are 'indices', 'all',\n 'stations', and '' (for just magnetometer measurements). (default='')\n sat_id : (string or NoneType)\n Specifies the satellite ID for a constellation. Not used.\n (default=None)\n data_path : (string or NoneType)\n Path to data directory. If None is specified, the value previously\n set in Instrument.files.data_path is used. (default=None)\n format_str : (string or NoneType)\n User specified file format. If None is specified, the default\n formats associated with the supplied tags are used. (default=None)\n\n Returns\n --------\n pysat.Files.from_os : (pysat._files.Files)\n A class containing the verified available files\n \n \"\"\"\n if format_str is None and data_path is not None:\n file_base = 'supermag_magnetometer'\n if tag == \"indices\" or tag == \"all\":\n file_base += '_all' # Can't just download indices\n\n if tag == \"indices\":\n psplit = path.split(data_path[:-1])\n data_path = path.join(psplit[0], \"all\", \"\")\n\n if tag == \"stations\":\n min_fmt = '_'.join([file_base, '{year:4d}.???'])\n doff = pds.DateOffset(years=1)\n else:\n min_fmt = '_'.join([file_base, '{year:4d}{month:02d}{day:02d}.???'])\n doff = pds.DateOffset(days=1)\n files = pysat.Files.from_os(data_path=data_path, format_str=min_fmt)\n\n # station files are once per year but we need to\n # create the illusion there is a file per year \n if not files.empty:\n files = files.sort_index()\n\n if tag == \"stations\":\n orig_files = files.copy()\n new_files = []\n # Assigns the validity of each station file to be 1 year\n for orig in orig_files.iteritems():\n files.ix[orig[0] + doff - pds.DateOffset(days=1)] = orig[1]\n files = files.sort_index()\n new_files.append(files.ix[orig[0]: orig[0] + doff - \\\n pds.DateOffset(days=1)].asfreq('D', method='pad'))\n files = pds.concat(new_files)\n\n files = files.dropna()\n files = files.sort_index()\n # add the date to the filename\n files = files + '_' + files.index.strftime('%Y-%m-%d')\n return files\n elif format_str is None:\n estr = 'A directory must be passed to the loading routine for SuperMAG'\n raise ValueError (estr)\n else:\n return pysat.Files.from_os(data_path=data_path, format_str=format_str)\n \n\ndef load(fnames, tag='', sat_id=None):\n \"\"\" Load the SuperMAG files\n\n Parameters\n -----------\n fnames : (list)\n List of filenames\n tag : (str or NoneType)\n Denotes type of file to load. Accepted types are 'indices', 'all',\n 'stations', and '' (for just magnetometer measurements). (default='')\n sat_id : (str or NoneType)\n Satellite ID for constellations, not used. (default=None)\n\n Returns\n --------\n data : (pandas.DataFrame)\n Object containing satellite data\n meta : (pysat.Meta)\n Object containing metadata such as column names and units\n \n \"\"\"\n\n # Ensure that there are files to load\n if len(fnames) <= 0 :\n return pysat.DataFrame(None), pysat.Meta(None)\n\n # Ensure that the files are in a list\n if isinstance(fnames, str):\n fnames = [fnames]\n\n # Initialise the output data\n data = pds.DataFrame()\n baseline = list()\n\n # Cycle through the files\n for fname in fnames:\n fname = fname[:-11] # Remove date index from end of filename\n file_type = path.splitext(fname)[1].lower()\n\n # Open and load the files for each file type\n if file_type == \".csv\":\n if tag != \"indices\":\n temp = load_csv_data(fname, tag)\n else:\n temp, bline = load_ascii_data(fname, tag)\n\n if bline is not None:\n baseline.append(bline)\n\n # Save the loaded data in the output data structure\n if len(temp.columns) > 0:\n data = pds.concat([data, temp], axis=0)\n del temp\n\n # If data was loaded, update the meta data\n if len(data.columns) > 0:\n meta = pysat.Meta()\n for cc in data.columns:\n meta[cc] = update_smag_metadata(cc)\n\n meta.info = {'baseline':format_baseline_list(baseline)}\n else:\n meta = pysat.Meta(None)\n\n return data, meta\n\ndef load_csv_data(fname, tag):\n \"\"\"Load data from a comma separated SuperMAG file\n\n Parameters\n ------------\n fname : (str)\n CSV SuperMAG file name\n tag : (str)\n Denotes type of file to load. Accepted types are 'indices', 'all',\n 'stations', and '' (for just magnetometer measurements).\n\n Returns\n --------\n data : (pandas.DataFrame)\n Pandas DataFrame\n \n \"\"\"\n import re\n\n if tag == \"stations\":\n # Because there may be multiple operators, the default pandas reader\n # cannot be used.\n ddict = dict()\n dkeys = list()\n date_list = list()\n\n # Open and read the file\n with open(fname, \"r\") as fopen:\n dtime = pds.datetime.strptime(fname.split(\"_\")[-1].split(\".\")[0],\n \"%Y\")\n\n for fline in fopen.readlines():\n sline = [ll for ll in re.split(r'[,\\n]+', fline) if len(ll) > 0]\n\n if len(ddict.items()) == 0:\n for kk in sline:\n kk = re.sub(\"-\", \"_\", kk)\n ddict[kk] = list()\n dkeys.append(kk)\n else:\n date_list.append(dtime)\n for i,ll in enumerate(sline):\n if i >= 1 and i <= 4:\n ddict[dkeys[i]].append(float(ll))\n elif i == 6:\n ddict[dkeys[i]].append(int(ll))\n elif i < len(dkeys):\n ddict[dkeys[i]].append(ll)\n else:\n ddict[dkeys[-1]][-1] += \" {:s}\".format(ll)\n \n # Create a data frame for this file\n data = pds.DataFrame(ddict, index=date_list, columns=ddict.keys())\n else:\n # Define the date parser\n def parse_smag_date(dd): \n return pysat.datetime.strptime(dd, \"%Y-%m-%d %H:%M:%S\")\n\n # Load the file into a data frame\n data = pds.read_csv(fname, parse_dates={'datetime':[0]},\n date_parser=parse_smag_date, index_col='datetime')\n\n return data\n \ndef load_ascii_data(fname, tag):\n \"\"\"Load data from a self-documenting ASCII SuperMAG file\n\n Parameters\n ------------\n fname : (str)\n ASCII SuperMAG filename\n tag : (str)\n Denotes type of file to load. Accepted types are 'indices', 'all',\n 'stations', and '' (for just magnetometer measurements).\n\n Returns\n --------\n data : (pandas.DataFrame)\n Pandas DataFrame\n baseline : (list)\n List of strings denoting the presence of a standard and file-specific\n baselines for each file. None of not present or not applicable.\n \n \"\"\"\n import re\n ndata = {\"indices\":2, \"\":4, \"all\":4, \"stations\":8}\n dkeys = {'stations':list(), '':['IAGA', 'N', 'E', 'Z']}\n data = pds.DataFrame(None)\n baseline = None\n\n # Ensure that the tag indicates a type of data we know how to load\n if not tag in ndata.keys():\n return data, baseline\n\n # Read in the text data, processing the header, indices, and\n # magnetometer data (as desired)\n with open(fname, \"r\") as fopen:\n # Set the processing flags\n hflag = True # header lines\n pflag = False # parameter line\n dflag = False if tag == \"stations\" else True # date line\n snum = 0 # number of magnetometer stations\n ddict = dict()\n date_list = list()\n\n if tag == \"stations\":\n dtime = pds.datetime.strptime(fname.split(\"_\")[-1].split(\".\")[0],\n \"%Y\")\n\n for fline in fopen.readlines():\n # Cycle past the header\n line_len = len(fline)\n\n if hflag:\n if pflag:\n pflag = False # Unset the flag\n if fline.find(\"-mlt\") > 0:\n ndata[''] += 2\n dkeys[''].extend(['MLT', 'MLAT'])\n if fline.find(\"-sza\") > 0:\n ndata[''] += 1\n dkeys[''].append('SZA')\n if fline.find(\"-decl\") > 0:\n ndata[''] += 1\n dkeys[''].append('IGRF_DECL')\n if tag == \"indices\" and fline.find(\"-envelope\") < 0:\n # Indices not included in this file\n break\n\n # Save the baseline information\n lsplit = fline.split()\n idelta = lsplit.index('-delta') + 1\n ibase = lsplit.index('-baseline') + 1\n isd = lsplit.index('-sd') + 1\n ist = lsplit.index('-st') + 1\n iex = lsplit.index('-ex') + 1\n baseline = \" \".join([lsplit[ibase], lsplit[idelta],\n lsplit[isd], lsplit[ist], lsplit[iex]])\n\n if fline.find(\"Selected parameters:\") >= 0:\n pflag = True\n if fline.count(\"=\") == line_len - 1 and line_len > 2:\n hflag = False\n else:\n # Load the desired data\n lsplit = [ll for ll in re.split(r'[\\t\\n]+', fline)\n if len(ll) > 0]\n\n if dflag:\n dflag = False # Unset the date flag\n dstring = \" \".join(lsplit[:6])\n dtime = pysat.datetime.strptime(dstring,\n \"%Y %m %d %H %M %S\")\n snum = int(lsplit[6]) # Set the number of stations\n\n # Load the times\n if tag == \"indices\":\n date_list.append(dtime)\n else:\n date_list.extend([dtime for i in range(snum)])\n elif len(lsplit) == ndata['indices']:\n if tag is not '':\n if lsplit[0] not in ddict.keys():\n ddict[lsplit[0]] = list()\n\n if tag == \"indices\":\n ddict[lsplit[0]].append(int(lsplit[1]))\n else:\n # This works because indices occur before\n # magnetometer measurements\n ddict[lsplit[0]].extend([int(lsplit[1])\n for i in range(snum)])\n else:\n if tag == \"stations\" and len(lsplit) >= ndata[tag]:\n if len(dkeys[tag]) == 0:\n # Station files include column names and data files\n # do not. Read in the column names here\n for ll in lsplit:\n ll = re.sub(\"-\", \"_\", ll)\n dkeys[tag].append(ll)\n ddict[ll] = list()\n else:\n # Because stations can have multiple operators,\n # ndata supplies the minimum number of columns\n date_list.append(dtime)\n for i,ll in enumerate(lsplit):\n if i >= 1 and i <= 4:\n ddict[dkeys[tag][i]].append(float(ll))\n elif i == 6:\n ddict[dkeys[tag][i]].append(int(ll))\n elif i < len(dkeys[tag]):\n ddict[dkeys[tag][i]].append(ll)\n else:\n ddict[dkeys[tag][-1]][-1] += \\\n \" {:s}\".format(ll)\n elif len(lsplit) == ndata['']:\n snum -= 1 # Mark the ingestion of a station\n if tag != \"indices\":\n if len(ddict.keys()) < ndata['']:\n for kk in dkeys['']:\n ddict[kk] = list()\n for i,kk in enumerate(dkeys['']):\n if i == 0:\n ddict[kk].append(lsplit[i])\n else:\n ddict[kk].append(float(lsplit[i]))\n\n if tag != \"stations\" and snum == 0 and len(ddict.items()) >= 2:\n # The previous value was the last value, prepare for\n # next block\n dflag = True\n\n # Create a data frame for this file\n data = pds.DataFrame(ddict, index=date_list, columns=ddict.keys())\n\n fopen.close()\n\n return data, baseline\n\ndef update_smag_metadata(col_name):\n \"\"\"Update SuperMAG metadata\n\n Parameters\n -----------\n col_name : (str)\n Data column name\n\n Returns\n --------\n col_dict : (dict)\n Dictionary of strings detailing the units and long-form name of the data\n \n \"\"\"\n\n smag_units = {'IAGA':'none', 'N':'nT', 'E':'nT', 'Z':'nT', 'MLT':'hours',\n 'MLAT':'degrees', 'SZA':'degrees', 'IGRF_DECL':'degrees',\n 'SMU':'none', 'SML':'none', 'datetime':'YYYY-MM-DD HH:MM:SS',\n 'GEOLON':'degrees', 'GEOLAT':'degrees', 'AACGMLON':'degrees',\n 'AACGMLAT':'degrees', 'STATION_NAME':'none',\n 'OPERATOR_NUM':'none', 'OPERATORS':'none'}\n smag_name = {'IAGA':'Station Code', 'N':'B along local magnetic North',\n 'E':'B along local magnetic East', 'Z':'B vertically downward',\n 'MLT':'Magnetic Local Time', 'MLAT':'Magnetic Latitude',\n 'SZA':'Solar Zenith Angle',\n 'IGRF_DECL':'IGRF magnetic declination',\n 'SMU': 'Maximum eastward auroral electrojets strength.\\n'\n 'Upper envelope of N-component for stations between 40 and '\n '80 degrees magnetic north.',\n 'SML':'Maximum westward auroral electrojets strength.\\n'\n 'Lower envelope of N-component for stations between 40 and 80'\n ' degrees magnetic north.', 'datetime':'UT date and time',\n 'GEOLON':'geographic longitude',\n 'GEOLAT':'geographic latitude',\n 'AACGMLON':'Altitude-Adjusted Corrected Geomagnetic longitude',\n 'AACGMLAT':'Altitude-Adjusted Corrected Geomagnetic latitude',\n 'STATION_NAME':'Long form station name',\n 'OPERATOR_NUM':'Number of station operators',\n 'OPERATORS':'Station operator name(s)',}\n \n ackn = \"When using this data please include the following reference:\\n\"\n ackn += \"Gjerloev, J. W., The SuperMAG data processing technique, \"\n ackn += \"Geophys. Res., 117, A09213, doi:10.1029/2012JA017683, 2012\\n\\n\"\n ackn += \"For publications and presentations, please include the following\"\n ackn += \"acknowledgement:\\nFor the ground magnetometer data we gratefully \"\n ackn += \"acknowledge: Intermagnet; USGS, Jeffrey J. Love; CARISMA, PI Ian \"\n ackn += \"Mann; CANMOS; The S-RAMP Database, PI K. Yumoto and Dr. K. \"\n ackn += \"Shiokawa; The SPIDR database; AARI, PI Oleg Troshichev; The \"\n ackn += \"MACCS program, PI M. Engebretson, Geomagnetism Unit of the \"\n ackn += \"Geological Survey of Canada; GIMA; MEASURE, UCLA IGPP and Florida\"\n ackn += \" Institute of Technology; SAMBA, PI Eftyhia Zesta; 210 Chain, PI \"\n ackn += \"K. Yumoto; SAMNET, PI Farideh Honary; The institutes who maintain\"\n ackn += \" the IMAGE magnetometer array, PI Eija Tanskanen; PENGUIN; AUTUMN,\"\n ackn += \" PI Martin Connors; DTU Space, PI Dr. Rico Behlke; South Pole and \"\n ackn += \" McMurdo Magnetometer, PI's Louis J. Lanzarotti and Alan T. \"\n ackn += \"Weatherwax; ICESTAR; RAPIDMAG; PENGUIn; British Artarctic Survey; \"\n ackn += \"McMac, PI Dr. Peter Chi; BGS, PI Dr. Susan Macmillan; Pushkov \"\n ackn += \"Institute of Terrestrial Magnetism, Ionosphere and Radio Wave \"\n ackn += \"Propagation (IZMIRAN); GFZ, PI Dr. Juergen Matzka; MFGI, PI B. \"\n ackn += \"Heilig; IGFPAS, PI J. Reda; University of L’Aquila, PI M. \"\n ackn += \"Vellante; BCMT, V. Lesur and A. Chambodut; Data obtained in \"\n ackn += \"cooperation with Geoscience Australia, PI Marina Costelloe; \"\n ackn += \"SuperMAG, PI Jesper W. Gjerloev.\"\n \n col_dict = {'units':smag_units[col_name], 'long_name':smag_name[col_name],\n 'acknowledgements':ackn}\n\n return col_dict\n\ndef format_baseline_list(baseline_list):\n \"\"\"Format the list of baseline information from the loaded files into a\n cohesive, informative string\n\n Parameters\n ------------\n baseline_list : (list)\n List of strings specifying the baseline information for each\n SuperMAG file\n\n Returns\n ---------\n base_string : (str)\n Single string containing the relevent data\n \n \"\"\"\n\n uniq_base = dict()\n uniq_delta = dict()\n\n for bline in baseline_list:\n bsplit = bline.split()\n bdate = \" \".join(bsplit[2:])\n if bsplit[0] not in uniq_base.keys():\n uniq_base[bsplit[0]] = \"\"\n if bsplit[1] not in uniq_delta.keys():\n uniq_delta[bsplit[1]] = \"\"\n\n uniq_base[bsplit[0]] += \"{:s}, \".format(bdate)\n uniq_delta[bsplit[1]] += \"{:s}, \".format(bdate)\n\n if len(uniq_base.items()) == 1:\n base_string = \"Baseline {:s}\".format(list(uniq_base.keys())[0])\n else:\n base_string = \"Baseline \"\n\n for i,kk in enumerate(uniq_base.keys()):\n if i == 1:\n base_string += \"{:s}: {:s}\".format(kk, uniq_base[kk][:-2])\n else:\n base_string += \" {:s}: {:s}\".format(kk,\n uniq_base[kk][:-2])\n else:\n base_string += \"unknown\"\n\n if len(uniq_delta.items()) == 1:\n base_string += \"\\nDelta {:s}\".format(list(uniq_delta.keys())[0])\n else:\n base_string += \"\\nDelta \"\n\n for i,kk in enumerate(uniq_delta.keys()):\n if i == 1:\n base_string += \"{:s}: {:s}\".format(kk, uniq_delta[kk][:-2])\n else:\n base_string += \" {:s}: {:s}\".format(kk,\n uniq_delta[kk][:-2])\n else:\n base_string += \"unknown\"\n\n return base_string\n\ndef clean(supermag):\n \"\"\" Data has been cleaned, but should be examined before use\n \"\"\"\n return\n\ndef download(date_array, tag, sat_id='', data_path=None, user=None,\n password=None, baseline='all', delta='none', options='all',\n file_fmt='ascii'):\n \"\"\"Routine to download SuperMAG data\n\n Parameters\n -----------\n date_array : np.array\n Array of datetime objects\n tag : string\n String denoting the type of file to load, accepted values are 'indices',\n 'all', 'stations', and '' (for only magnetometer data)\n sat_id : string\n Not used (default='')\n data_path : string or NoneType\n Data path to save downloaded files to (default=None)\n user : string or NoneType\n SuperMAG requires user registration (default=None)\n password : string or NoneType\n Not used; SuperMAG does not require a password (default=None)\n file_fmt : string\n File format options: 'ascii' and 'csv'. (default='ascii')\n baseline : string\n Baseline to remove from magnetometer data. Options are 'all', 'yearly',\n and 'none'. (default='all')\n delta : string\n Remove a value from the magnetometer data. Options are 'none', 'start',\n and 'median'. (default='none')\n options : string or NoneType\n Additional parameter options for magnetometer data. Includes 'mlt'\n (MLat and MLT), 'decl' (IGRF declination), 'sza' (Solar Zenith Angle),\n 'all', and None. (default='all')\n\n Returns\n -------\n \n \"\"\"\n import sys\n import requests\n \n global platform, name\n\n max_stations = 470\n\n if user is None:\n raise ValueError('SuperMAG requires user registration')\n\n remoteaccess = {'method':'http', 'host':'supermag.jhuapl.edu',\n 'path':'mag/lib/services', 'user':'user={:s}'.format(user),\n 'service':'service=', 'options':'options='}\n remotefmt = \"{method}://{host}/{path}/??{user}&{service}&{filefmt}&{start}\"\n\n # Set the tag information\n if tag == \"indices\":\n tag = \"all\"\n\n if tag != \"stations\":\n remotefmt += \"&{interval}&{stations}&{delta}&{baseline}&{options}\"\n\n # Determine whether station or magnetometer data is requested\n remoteaccess['service'] += tag if tag == \"stations\" else \"mag\"\n\n # Add request for file type\n file_fmt = file_fmt.lower()\n if not file_fmt in ['ascii', 'csv']:\n estr = \"unknown file format [{:s}], using 'ascii'\".format(file_fmt)\n print(\"WARNING: {:s}\".format(estr))\n file_fmt = 'ascii'\n remoteaccess['filefmt'] = 'fmt={:s}'.format(file_fmt)\n\n # If indices are requested, add them now.\n if not tag in [None, 'stations']:\n remoteaccess['options'] += \"+envelope\"\n\n # Add other download options (for non-station files)\n if tag != \"stations\":\n if options is not None:\n options = options.lower()\n if options is 'all':\n remoteaccess['options'] += \"+mlt+sza+decl\"\n else:\n remoteaccess['options'] += \"+{:s}\".format(options)\n\n # Add requests for baseline substraction\n baseline = baseline.lower()\n if not baseline in ['all', 'yearly', 'none']:\n estr = \"unknown baseline [{:s}], using 'all'\".format(baseline)\n print(\"WARNING: {:s}\".format(estr))\n baseline = 'all'\n remoteaccess['baseline'] = \"baseline={:s}\".format(baseline)\n\n delta = delta.lower()\n if not delta in ['none', 'median', 'start']:\n estr = \"unknown delta [{:s}], using 'none'\".format(delta)\n print(\"WARNING: {:s}\".format(estr))\n delta = 'none'\n remoteaccess['delta'] = 'delta={:s}'.format(delta)\n\n # Set the time information and format\n remoteaccess['interval'] = \"interval=23:59\"\n sfmt = \"%Y-%m-%dT00:00:00.000\"\n tag_str = \"_\" if tag is None else \"_all_\" \n ffmt = \"{:s}_{:s}{:s}%Y%m%d.{:s}\".format(platform, name, tag_str,\n \"txt\" if file_fmt == \"ascii\"\n else file_fmt)\n start_str = \"start=\"\n else:\n # Set the time format\n sfmt = \"%Y\"\n ffmt = \"{:s}_{:s}_{:s}_%Y.{:s}\".format(platform, name, tag,\n \"txt\" if file_fmt == \"ascii\"\n else file_fmt)\n start_str = \"year=\"\n\n # Cycle through all of the dates, formatting them to achieve a unique set\n # of times to download data\n date_fmts = list(set([dd.strftime(sfmt) for dd in date_array]))\n\n # Now that the unique dates are known, construct the file names\n name_fmts = [None for dd in date_fmts]\n for dd in date_array:\n i = date_fmts.index(dd.strftime(sfmt))\n name_fmts[i] = dd.strftime(ffmt)\n\n if None in name_fmts:\n raise ValueError(\"unable to construct all unique file names\")\n\n # Cycle through all of the unique dates. Stations lists are yearly and\n # magnetometer data is daily\n station_year = None\n istr = 'SuperMAG {:s}'.format(tag if tag == \"stations\" else \"data\")\n for i,date in enumerate(date_fmts):\n print(\"Downloading {:s} for {:s}\".format(istr, date.split(\"T\")[0]))\n sys.stdout.flush()\n nreq = 1\n\n # Add the start time and download period to query\n remoteaccess['start'] = \"{:s}{:s}\".format(start_str, date)\n if tag != \"stations\":\n # Station lists are for each year, see if this year is loaded\n current_date = pds.datetime.strptime(date, \"%Y-%m-%dT%H:%M:%S.000\")\n\n if current_date.year != station_year:\n # Get all of the stations for this time\n smag_stat = pysat.Instrument(platform=platform, name=name,\n tag='stations')\n # try to load data\n smag_stat.load(date=current_date)\n if smag_stat.empty:\n # no data\n etime = current_date + pds.DateOffset(days=1)\n smag_stat.download(start=current_date, stop=etime,\n user=user, password=password,\n file_fmt=file_fmt)\n smag_stat.load(date=current_date)\n if smag_stat.empty:\n # no data\n estr = \"unable to format station query for \"\n estr += \"[{:d}]\".format(current_date.year)\n raise ValueError(estr)\n\n # Format a string of the station names\n if smag_stat.data.IAGA.shape[0] > max_stations:\n station_year = current_date.year\n nreq = int(np.ceil(smag_stat.data.IAGA.shape[0] /\n float(max_stations)))\n\n out = list()\n for ireq in range(nreq):\n if tag != \"stations\":\n if station_year is None:\n raise RuntimeError(\"unable to load station data\")\n\n stat_str = \",\".join(smag_stat.data.IAGA[ireq*max_stations:\n (ireq+1)*max_stations])\n remoteaccess['stations'] = \"stations={:s}\".format(stat_str)\n\n # Format the query\n url = remotefmt.format(**remoteaccess)\n\n # Set up a request\n try:\n # print (url)\n result = requests.post(url)\n result.encoding = 'ISO-8859-1'\n # handle strings differently for python 2/3\n if sys.version_info.major == 2:\n out.append(str(result.text.encode('ascii', 'replace')))\n else:\n out.append(result.text)\n except:\n raise RuntimeError(\"unable to connect to [{:s}]\".format(url))\n\n # Test the result\n if \"requested URL was rejected\" in out[-1]:\n estr = \"Requested url was rejected:\\n{:s}\".format(url)\n raise RuntimeError(estr)\n\n # Build the output file name\n if tag is '':\n fname = path.join(data_path, name_fmts[i])\n else:\n fname = path.join(data_path, name_fmts[i])\n\n # If more than one data pass was needed, append the files\n if len(out) > 1:\n out_data = append_data(out, file_fmt, tag)\n else:\n out_data = out[0]\n\n # Save the file data\n with open(fname, \"w\") as local_file:\n local_file.write(out_data)\n local_file.close()\n del out_data\n\n return\n\ndef append_data(file_strings, file_fmt, tag):\n \"\"\" Load the SuperMAG files\n\n Parameters\n -----------\n file_strings : array-like\n Lists or arrays of strings, where each string contains one file of data\n file_fmt : str\n String denoting file type (ascii or csv)\n tag : string\n String denoting the type of file to load, accepted values are 'indices',\n 'all', 'stations', and '' (for only magnetometer data)\n\n Returns\n -------\n out_string : string\n String with all data, ready for output to a file\n \n \"\"\"\n # Determine the right appending routine for the file type\n if file_fmt.lower() == \"csv\":\n return append_csv_data(file_strings)\n else:\n return append_ascii_data(file_strings, tag)\n\ndef append_ascii_data(file_strings, tag):\n \"\"\" Append data from multiple files for the same time period\n\n Parameters\n -----------\n file_strings : array-like\n Lists or arrays of strings, where each string contains one file of data\n tag : string\n String denoting the type of file to load, accepted values are 'indices',\n 'all', 'stations', and None (for only magnetometer data)\n\n Returns\n -------\n out_string : string\n String with all data, ready for output to a file\n \n \"\"\"\n import re\n \n # Start with data from the first list element\n out_lines = file_strings[0].split('\\n')\n iparam = -1 # Index for the parameter line\n ihead = -1 # Index for the last header line\n idates = list() # Indices for the date lines\n date_list = list() # List of dates\n num_stations = list() # Number of stations for each date line\n ind_num = 2 if tag in ['all', 'indices', ''] else 0\n # ind_num = 2 if tag == '' else ind_num\n\n # Find the index information for the data\n for i,line in enumerate(out_lines):\n if line == \"Selected parameters:\":\n iparam = i + 1\n elif line.count(\"=\") == len(line) and len(line) > 2:\n ihead = i\n break\n\n # Find the time indices and number of stations for each date line\n i = ihead + 1\n while i < len(out_lines) - 1:\n idates.append(i)\n lsplit = re.split('\\t+', out_lines[i])\n dtime = pds.datetime.strptime(\" \".join(lsplit[0:-1]),\n \"%Y %m %d %H %M %S\")\n date_list.append(dtime)\n num_stations.append(int(lsplit[-1]))\n i += num_stations[-1] + 1 + ind_num\n idates = np.array(idates)\n\n # Initialize a list of station names\n station_names = list()\n \n # Cycle through each additional set of file strings\n for ff in range(len(file_strings)-1):\n file_lines = file_strings[ff+1].split('\\n')\n\n # Find the index information for the data\n head = True\n snum = 0\n for i,line in enumerate(file_lines):\n if head:\n if line.count(\"=\") == len(line) and len(line) > 2:\n head = False\n elif len(line) > 0:\n lsplit = re.split('\\t+', line)\n if snum == 0:\n dtime = pds.datetime.strptime(\" \".join(lsplit[0:-1]),\n \"%Y %m %d %H %M %S\")\n try:\n idate = date_list.index(dtime)\n except:\n # SuperMAG outputs date lines regardless of the\n # number of stations. These files shouldn't be\n # appended together.\n raise ValueError(\"Unexpected date \", dtime)\n\n snum = int(lsplit[-1])\n onum = num_stations[idate]\n inum = ind_num\n\n # Adjust reference data for new number of station lines\n idates[idate+1:] += snum\n num_stations[idate] += snum\n\n # Adjust date line for new number of station lines\n oline = \"{:s}\\t{:d}\".format( \\\n dtime.strftime(\"%Y\\t%m\\t%d\\t%H\\t%M\\t%S\"),\n num_stations[idate])\n out_lines[idates[idate]] = oline\n else:\n if inum > 0:\n inum -= 1\n else:\n # Insert the station line to the end of the date section\n onum += 1\n snum -= 1\n out_lines.insert(idates[idate]+onum, line)\n\n # Save the station name to update the parameter line\n if not lsplit[0] in station_names:\n station_names.append(lsplit[0])\n\n # Update the parameter line\n out_lines[iparam] += \",\" + \",\".join(station_names)\n\n # Join the output lines into a single string\n out_string = \"\\n\".join(out_lines)\n\n return out_string\n\ndef append_csv_data(file_strings):\n \"\"\" Append data from multiple csv files for the same time period\n\n Parameters\n -----------\n file_strings : array-like\n Lists or arrays of strings, where each string contains one file of data\n\n Returns\n -------\n out_string : string\n String with all data, ready for output to a file\n \n \"\"\"\n # Start with data from the first list element\n out_lines = list()\n head_line = None\n\n # Cycle through the lists of file strings, creating a list of line strings\n for fstrings in file_strings:\n file_lines = fstrings.split('\\n')\n\n # Remove and save the header line\n head_line = file_lines.pop(0)\n\n # Save the data lines\n out_lines.extend(file_lines)\n\n # Sort the output lines by date and station (first two columns) in place\n out_lines.sort()\n\n # Remove all zero-length lines from front, add one to back, and add header\n i = 0\n while len(out_lines[i]) == 0:\n out_lines.pop(i)\n\n out_lines.insert(0, head_line)\n out_lines.append('')\n\n # Join the output lines into a single string\n out_string = \"\\n\".join(out_lines)\n\n return out_string\n"
] | [
[
"numpy.mod",
"numpy.arange",
"pandas.DateOffset"
],
[
"pandas.concat",
"pandas.read_csv",
"pandas.DateOffset",
"pandas.DataFrame",
"pandas.datetime.strptime",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"0.19",
"0.24",
"0.20",
"1.0",
"0.25"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
sahareslami/Garfield | [
"b620816fe88b2cb2cef4a889342e6b1ad32a0395",
"b620816fe88b2cb2cef4a889342e6b1ad32a0395",
"b620816fe88b2cb2cef4a889342e6b1ad32a0395",
"b620816fe88b2cb2cef4a889342e6b1ad32a0395"
] | [
"pytorch_impl/libs/garfieldpp/server.py",
"pytorch_impl/applications/Centralized/trainer.py",
"pytorch_impl/libs/garfieldpp/models/vgg.py",
"tensorflow_impl/rsrcs/aggregators/median.py"
] | [
"# coding: utf-8\n###\n # @file server.py\n # @author Arsany Guirguis <[email protected]>\n #\n # @section LICENSE\n #\n # Copyright (c) 2020 Arsany Guirguis.\n #\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n #\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n #\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n #\n # @section DESCRIPTION\n #\n # Parameter Server class.\n###\n\n#!/usr/bin/env python\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport garfieldpp.tools as tools\nfrom garfieldpp.tools import _call_method, _remote_method_sync, _remote_method_async, get_worker, get_server\nfrom garfieldpp.datasets import DatasetManager\nimport torch.distributed.rpc as rpc\nimport torch.optim as optim\nfrom torch.distributed.rpc import RRef, rpc_async, remote\nfrom garfieldpp.worker import Worker\nfrom garfieldpp.byzWorker import ByzWorker\nfrom time import sleep,time\nimport copy\nimport sys\nimport threading\nfrom multiprocessing.dummy import Pool as ThreadPool\n\nclass Server:\n \"\"\" Byzantine-resilient parameter server \"\"\"\n def __init__(self, rank, world_size, num_workers, num_ps, byz_wrk, byz_ps, wrk_base_name, ps_base_name, batch, model, dataset, optimizer, *args, **kwargs):\n \"\"\" Constructor of server Object\n Args\n rank unique ID of this worker node in the deployment\n world_size total number of nodes in the deployment\n num_workers number of workers in the deployment\n num_ps\t number of servers in the deployment\n byz_wrk number of (possible) Byzantine workers in the deployment\n byz_ps number of (possible) Byzantine servers in the deployment\n wrk_base_name the naming convention of workers; used to get the rrefs of remote workers\n ps_base_name the naming convention of servers; used to get the rrefs of remote servers\n batch\t the batch size per worker; used to build the computation graph\n model the name of the NN model to be used\n dataset the name of the dataset to be used for training\n optimizer the name of the optimizer used by the server\n args, kwargs additional arguments to be passed to the optimizer constructor\n \"\"\"\n if torch.cuda.device_count() > 0:\n self.device = torch.device(\"cuda\")\n else:\n self.device = torch.device(\"cpu:0\")\n print(\"Using CPU at rank {}\".format(rank))\n self.rank = rank\n self.world_size = world_size\n self.num_workers = num_workers\n self.byz_wrk = byz_wrk\n self.byz_ps = byz_ps\n if world_size > 1:\n self.workers_types, self.workers_rref = self.get_rrefs(wrk_base_name,0,num_workers, True)\n self.num_ps = num_ps\n self.model = tools.select_model(model, torch.device(\"cpu:0\"), dataset)\t#We should always put the model on CPU because RPC is not supported on GPUs\n manager = DatasetManager(dataset, batch*num_workers, 1, 2, 1)\t\t\t#The parameters actually are dummy\n self.test_set = manager.get_test_set()\n self.train_set = manager.get_train_set()\n self.optimizer = tools.select_optimizer(self.model, optimizer, *args, **kwargs)\n# self.grads = []\t\t\t\t\t\t#placeholder to carry gradients in each iteration\n tools.server_instance = self\n if self.num_ps > 1:\t\t\t#This should be done after the server announces itself; otherwise, we'd fall in deadlock\n self.ps_types, self.ps_rref = self.get_rrefs(ps_base_name,0, num_ps, False)\n# self.pool_wrk = ThreadPool() #No need to specify the number of concurrent processes; try to use max anyway\n self.latest_aggr_grad = None\n\n def get_rrefs(self, base_name, base_id, num_nodes, worker=True):\n \"\"\" get rrefs of remote machines (workers or servers)\n Args\n base_name template name of deployed workers\n base_id the lowest rank of a node in the deployment\n num_nodes the number of nodes of which the server should fetch references\n \"\"\"\n rrefs = [remote(base_name+str(node_id), get_worker if worker else get_server) for node_id in range(base_id, base_id+num_nodes)]\n types = [type(rref.to_here()) for rref in rrefs]\n return types, rrefs\n\n def get_gradients(self, iter_num, num_wait_wrk=-1):\n \"\"\" ask workers to compute gradients and return them\n Args\n iter_num the number of the current iteration, to be passed to workers\n num_wait_wrk number of workers to wait for their response (useful in asynchronous deployments)\n \"\"\"\n if num_wait_wrk < 0:\n num_wait_wrk = self.num_workers - self.byz_wrk\n self.model.train()\n self.optimizer.zero_grad()\n #Fast path\n if num_wait_wrk == self.num_workers:\n def get_grad(fut):\n return fut.wait()[1].to(self.device)\n pool_wrk = ThreadPool()\n futs = [_remote_method_async(wrk_type.compute_gradients, wrk_rref, iter_num, self.model) for wrk_rref, wrk_type in zip(self.workers_rref, self.workers_types)]\n build_th = threading.Thread(target=self.build_graph, args=(iter_num,))\n build_th.start()\n grads = pool_wrk.map(get_grad, futs)\n pool_wrk.terminate()\n pool_wrk.join()\n del pool_wrk\n else: #The call should be done asynchronously, and we should only consider the fastest workers responding\n grads=[None for i in range(self.num_workers)] #placeholder for possible received gradients\n def assign_grad_async(fut):\n \"\"\" callback function that is called when some gradient is received asynchronously\n Args\n fut the future object on which the callback is called\n \"\"\"\n id, gradient, loss = fut.wait()\n grads[id] = gradient.to(self.device)\n for id, (wrk_rref, wrk_type) in enumerate(zip(self.workers_rref,self.workers_types)):\n fut = _remote_method_async(wrk_type.compute_gradients, wrk_rref, iter_num, self.model)\n #fut.then allows to do something after the future object returns a result\n #x here is the future object itself; result of waiting it should return a grad from that worker\n fut.then(assign_grad_async)\n #busy-wait for the replies\n build_th = threading.Thread(target=self.build_graph, args=(iter_num,))\n build_th.start()\n while self.num_workers - grads.count(None) < num_wait_wrk:\n sleep(1)\n #now, I'm sure I have at least \"num_wait_wrk\" replies at least\n #let's remove all \"None\" values\n grads = [grad for grad in grads if grad is not None]\n# del grads\t\t\t\t#empty it for the next iteration\n #make sure that the graph is built (regardless of synchrony or not)\n build_th.join()\n return grads\n\n def get_models(self, num_wait_ps=-1):\n \"\"\" ask servers to get their latest models\n Args\n num_wait_ps number of servers to wait for their response (useful in asynchronous deployments)\n \"\"\"\n if num_wait_ps < 0:\n num_wait_ps = self.num_ps - self.byz_ps\n if num_wait_ps == self.num_ps:\t\t\t#FAST PATH: synchronous\n futs = [_remote_method_async(ps_type.get_model, ps_rref) for ps_rref, ps_type in zip(self.ps_rref, self.ps_types)]\n models = [fut.wait()[1].to(self.device) for fut in futs]\n else:\t\t\t\t\t\t#Asynchronous path\n models_ph=[None for i in range(self.num_ps)] #placeholder for possible received models\n def assign_model_async(fut):\n id, mod = fut.wait()\n models_ph[id] = mod.to(self.device)\n for id, (ps_rref, ps_type) in enumerate(zip(self.ps_rref,self.ps_types)):\n fut = _remote_method_async(ps_type.get_model, ps_rref)\n #fut.then allows to do something after the future object returns a result\n #x here is the future object itself; result of waiting it should return a model from that server\n fut.then(assign_model_async)\n while self.num_ps - models_ph.count(None) < num_wait_ps:\n sleep(1)\n models = [mod for mod in models_ph if mod is not None]\n return models\n\n def build_graph(self, iter_num):\n \"\"\" Prepares the computation graph for the update step\n Args\n iter_num the iteration number\n \"\"\"\n data, _ = self.train_set[iter_num%len(self.train_set)]\n data, self.model = data.to(self.device), self.model.to(self.device)\n self.model(data)\n self.model = self.model.to('cpu')\n\n def get_model(self):\n \"\"\" return the current model\n Args\n \"\"\"\n return self.rank, torch.cat([torch.reshape(param.data.to(\"cpu\"), (-1,)) for param in self.model.parameters()]).to('cpu:0')\n\n def get_latest_aggr_grad(self):\n \"\"\" return the latest aggregated gradient at a server\n Args\n \"\"\"\n while self.latest_aggr_grad is None:\t\t#useful only with initialization\n sleep(1)\n return self.rank, self.latest_aggr_grad.to('cpu:0')\n\n def get_aggr_grads(self, num_wait_ps=-1):\n \"\"\" ask servers to get their latest aggregated gradients\n Args\n num_wait_ps number of servers to wait for their response (useful in asynchronous deployments)\n \"\"\"\n if num_wait_ps < 0:\n num_wait_ps = self.num_ps - self.byz_ps\n if num_wait_ps == self.num_ps: #FAST PATH: synchronous\n futs = [_remote_method_async(ps_type.get_latest_aggr_grad, ps_rref) for ps_rref, ps_type in zip(self.ps_rref, self.ps_types)]\n aggr_grads = [fut.wait()[1].to(self.device) for fut in futs]\n else: #Asynchronous path\n aggr_grads_ph=[None for i in range(self.num_ps)] #placeholder for possible received aggregated gradients\n def assign_grads_async(fut):\n id, aggr_grad = fut.wait()\n aggr_grads_ph[id] = aggr_grad.to(self.device)\n for id, (ps_rref, ps_type) in enumerate(zip(self.ps_rref,self.ps_types)):\n fut = _remote_method_async(ps_type.get_latest_aggr_grad, ps_rref)\n #fut.then allows to do something after the future object returns a result\n #x here is the future object itself; result of waiting it should return a model from that server\n fut.then(assign_grads_async)\n while self.num_ps - aggr_grads_ph.count(None) < num_wait_ps:\n sleep(1)\n aggr_grads = [ag for ag in aggr_grads_ph if ag is not None]\n return aggr_grads\n\n def compute_accuracy(self):\n \"\"\" compute the accuracy of the current model, based on the test set\n Args\n \"\"\"\n correct = 0\n total = 0\n model_cpy = copy.deepcopy(self.model)\n if torch.cuda.is_available():\n model_cpy = model_cpy.cuda()\n\n model_cpy.eval()\n with torch.no_grad():\n for idx, (inputs, targets) in enumerate(self.test_set):\n inputs, targets = inputs.to(self.device), targets.to(self.device)\n outputs = model_cpy(inputs)\n _ , predicted = outputs.max(1)\n total += targets.size(0)\n correct += predicted.eq(targets).sum().item()\n del model_cpy\n return (correct * 100 / total)\n\n def update_model(self, grad):\n \"\"\" update the local model using the updating gradient\n Args\n grad the updating gradient\n \"\"\"\n grad = grad.to(torch.device(\"cpu:0\"))\n cur_pos=0\n for param in self.model.parameters():\n param.grad = torch.reshape(torch.narrow(grad,0,cur_pos,param.nelement()), param.size()).detach()\n cur_pos = cur_pos+param.nelement()\n self.optimizer.step()\n\n def write_model(self, model):\n \"\"\" replace the local model with the one given\n Args\n model the new model (flattened) to replace the old one\n \"\"\"\n cur_pos=0\n for param in self.model.parameters():\n param.data = torch.reshape(torch.narrow(model,0,cur_pos,param.nelement()), param.size())\n cur_pos = cur_pos+param.nelement()\n\n#The next two methods are only used for benchmarking RPC calls\n def get_fake_models(self):\n futs = [_remote_method_async(ps_type.get_fake_model, ps_rref) for ps_rref, ps_type in zip(self.ps_rref, self.ps_types)]\n models = [fut.wait().to(self.device) for fut in futs]\n\n def get_fake_model(self):\n return self.model.to('cpu:0')\n",
"# coding: utf-8\n###\n # @file cent_trainer.py\n # @author Arsany Guirguis <[email protected]>\n #\n # @section LICENSE\n #\n # Copyright (c) 2020 Arsany Guirguis.\n #\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n #\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n #\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n #\n # @section DESCRIPTION\n #\n # Centralized training. This should work as a baseline to our distributed implementation whatsoever.\n###\n\n#!/usr/bin/env python\n\nimport os\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom time import time\nimport argparse\nimport sys\nimport json\nimport threading\n\nimport garfieldpp\nfrom garfieldpp.server import Server\nfrom garfieldpp.worker import Worker\nfrom garfieldpp import tools\nfrom garfieldpp.datasets import DatasetManager\nfrom garfieldpp.tools import adjust_learning_rate\nimport aggregators\n\nCIFAR_NUM_SAMPLES = 50000\n#First, parse the inputs\nparser = argparse.ArgumentParser(description=\"Centralized Training\", formatter_class=argparse.RawTextHelpFormatter)\n\n\nparser.add_argument(\"--dataset\",\n type=str,\n default=\"mnist\",\n help=\"Dataset to be used, e.g., mnist, cifar10,...\")\nparser.add_argument(\"--batch\",\n type=int,\n default=32,\n help=\"Minibatch size to be employed by each worker.\")\nparser.add_argument(\"--model\",\n type=str,\n default='convnet',\n help=\"Model to be trained, e.g., convnet, cifarnet, resnet,...\")\nparser.add_argument(\"--loss\",\n type=str,\n default='nll',\n help=\"Loss function to optimize against.\")\nparser.add_argument(\"--optimizer\",\n type=str,\n default='sgd',\n help=\"Optimizer to use.\")\nparser.add_argument(\"--opt_args\",\n type=json.loads,\n default={'lr':0.1},\n help=\"Optimizer arguments; passed in dict format, e.g., '{\\\"lr\\\":\\\"0.1\\\"}'\")\nparser.add_argument(\"--num_iter\",\n type=int,\n default=100,\n help=\"Number of training iterations to execute.\")\nparser.add_argument(\"--acc_freq\",\n type=int,\n default=100,\n help=\"The frequency of computing accuracy while training.\")\nparser.add_argument('--bench',\n type=bool,\n default=False,\n help=\"If True, time elapsed in each step is printed.\")\nparser.add_argument('--log',\n type=bool,\n default=False,\n help=\"If True, accumulated loss at each iteration is printed.\")\n\n\nFLAGS = parser.parse_args(sys.argv[1:])\n\ndataset = FLAGS.dataset\nassert len(dataset) > 0\nbatch = FLAGS.batch\nassert batch >= 1\nmodel = FLAGS.model\nassert len(model) > 0\nloss = FLAGS.loss\nassert len(loss) > 0\noptimizer = FLAGS.optimizer\nassert len(optimizer) > 0\nopt_args = FLAGS.opt_args\nfor k in opt_args:\n opt_args[k] = float(opt_args[k])\nassert opt_args['lr']\n\nnum_iter = FLAGS.num_iter\nassert num_iter > 0\n\nacc_freq = FLAGS.acc_freq\nassert(acc_freq > 10)\nbench = FLAGS.bench\nif bench:\n from timeit import timeit\nelse:\n timeit = None\nlog = FLAGS.log\n\nprint(\"**** SETUP OF THIS CENTRAL DEPLOYMENT ***\")\nprint(\"Dataset: \", dataset)\nprint(\"Model: \", model)\nprint(\"Batch size: \", batch)\nprint(\"Loss function: \", loss)\nprint(\"Optimizer: \", optimizer)\nprint(\"Optimizer Args\", opt_args)\nprint(\"Benchmarking? \", bench)\nprint(\"Logging loss at each iteration?\", log)\nprint(\"------------------------------------\")\nsys.stdout.flush()\n\nlr = opt_args['lr']\n\ntorch.manual_seed(1234)\t\t\t\t\t#For reproducibility\nif torch.cuda.is_available():\n torch.cuda.manual_seed_all(1234)\nif bench:\n torch.backends.cudnn.benchmark=True\n\nps = Server(0, 1, 1,1, 0, 0, ' ', ' ', batch, model, dataset, optimizer, **opt_args)\nwrk = Worker(1, 2, 1, batch, model, dataset, loss)\ngar = aggregators.gars.get('average')\n\nnum_train_samples = len(wrk.train_set)\niter_per_epoch = CIFAR_NUM_SAMPLES//batch\nassert num_train_samples == iter_per_epoch\nscheduler = torch.optim.lr_scheduler.MultiStepLR(ps.optimizer, milestones=[25, 50], gamma=0.1)\t\t#This line shows sophisticated stuff that can be done out of the Garfield++ library\nstart_time = time()\nprint(\"One EPOCH consists of {} iterations\".format(iter_per_epoch))\nsys.stdout.flush()\n#acc_freq = iter_per_epoch\nif torch.cuda.device_count() > 0:\n device = torch.device(\"cuda\")\nelse:\n device = torch.device(\"cpu:0\")\nscheduler.step()\nfor i in range(num_iter):\n# if i%iter_per_epoch == 0 and model == 'resnet50':\n# if i%(iter_per_epoch*30) == 0:\t\t\t#One hack for better convergence with Cifar10\n# lr*=0.1\n# adjust_learning_rate(ps.optimizer, lr)\n #training loop goes here\n ps.model.train()\n ps.optimizer.zero_grad()\n r, grad, l = wrk.compute_gradients(i, ps.model)\n grad = grad.to(device)\n grad = gar(gradients=[grad], f=0)\n ps.model = ps.model.to('cpu')\n ps.update_model(grad)\n if i%num_train_samples == 0 and i != 0:\n acc = ps.compute_accuracy()\n num_epochs = i/num_train_samples\n print(\"Epoch: {} Accuracy: {} Time: {}\".format(num_epochs,acc,time()-start_time))\n sys.stdout.flush()\n scheduler.step()\n",
"'''VGG11/13/16/19 in Pytorch.'''\nimport torch\nimport torch.nn as nn\n\n\ncfg = {\n 'VGG11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],\n 'VGG13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],\n 'VGG16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],\n 'VGG19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],\n}\n\n\nclass VGG(nn.Module):\n def __init__(self, vgg_name,num_classes=10):\n super(VGG, self).__init__()\n self.features = self._make_layers(cfg[vgg_name])\n self.classifier = nn.Linear(512, num_classes)\n\n def forward(self, x):\n out = self.features(x)\n out = out.view(out.size(0), -1)\n out = self.classifier(out)\n return out\n\n def _make_layers(self, cfg):\n layers = []\n in_channels = 3\n for x in cfg:\n if x == 'M':\n layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\n else:\n layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1),\n nn.BatchNorm2d(x),\n nn.ReLU(inplace=True)]\n in_channels = x\n layers += [nn.AvgPool2d(kernel_size=1, stride=1)]\n return nn.Sequential(*layers)\n\n\ndef test():\n net = VGG('VGG11')\n x = torch.randn(2,3,32,32)\n y = net(x)\n print(y.size())\n\n# test()\n",
"# coding: utf-8\n###\n # @file median.py\n # @author Sébastien Rouault <[email protected]>\n #\n # @section LICENSE\n #\n # Copyright © 2018-2019 Sébastien ROUAULT.\n #\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n #\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n #\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n #\n # @section DESCRIPTION\n #\n # Coordinate-wise median GAR.\n###\n\nimport tensorflow as tf\n\nimport tools\nimport native\nfrom . import _GAR, register\n\n# ---------------------------------------------------------------------------- #\n# Nan-resilient median coordinate-per-coordinate GAR class\n\nclass COMedianGAR(_GAR):\n \"\"\" Full-custom operation median GAR class.\n \"\"\"\n\n # Name of the associated custom operation\n co_name = \"median\"\n\n def __init__(self, nbworkers, nbbyzwrks, args):\n pass\n\n def aggregate(self, gradients):\n # Assertion\n assert len(gradients) > 0, \"Empty list of gradient to aggregate\"\n # Computation\n return native.instantiate_op(type(self).co_name, tf.parallel_stack(gradients))\n\n# ---------------------------------------------------------------------------- #\n# GAR registering\n\n# Register aggregation rule\nif COMedianGAR.co_name in native.itemize_op():\n register(\"median\", COMedianGAR)\nelse:\n tools.warning(\"GAR 'median' could not be registered since the associated custom operation \" + repr(COMedianGAR.co_name) + \" is unavailable\")\n"
] | [
[
"torch.device",
"torch.cuda.device_count",
"torch.no_grad",
"torch.cuda.is_available"
],
[
"torch.optim.lr_scheduler.MultiStepLR",
"torch.manual_seed",
"torch.cuda.is_available",
"torch.cuda.manual_seed_all",
"torch.device",
"torch.cuda.device_count"
],
[
"torch.nn.Sequential",
"torch.randn",
"torch.nn.Conv2d",
"torch.nn.Linear",
"torch.nn.AvgPool2d",
"torch.nn.MaxPool2d",
"torch.nn.BatchNorm2d",
"torch.nn.ReLU"
],
[
"tensorflow.parallel_stack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"1.12",
"2.6",
"2.2",
"1.13",
"2.3",
"2.4",
"1.4",
"2.9",
"1.5",
"1.7",
"2.5",
"1.0",
"2.8",
"1.2",
"2.10"
]
}
] |
dashbrookhart/msds621 | [
"39c4c87d25449b568cbb84fe7ea6eb398113f5b9"
] | [
"code/linreg/reg_support.py"
] | [
"import numpy as np\nimport math\n\ndef diamond(lmbda=1, n=100):\n \"get points along diamond at distance lmbda from origin\"\n points = []\n x = np.linspace(0, lmbda, num=n // 4)\n points.extend(list(zip(x, -x + lmbda)))\n\n x = np.linspace(0, lmbda, num=n // 4)\n points.extend(list(zip(x, x - lmbda)))\n\n x = np.linspace(-lmbda, 0, num=n // 4)\n points.extend(list(zip(x, -x - lmbda)))\n\n x = np.linspace(-lmbda, 0, num=n // 4)\n points.extend(list(zip(x, x + lmbda)))\n\n return np.array(points)\n\n\ndef circle(lmbda=1, n=100):\n # walk radians around circle, using cos, sin to get x,y\n points = []\n for angle in np.linspace(0,np.pi/2, num=n//4):\n x = np.cos(angle) * lmbda\n y = np.sin(angle) * lmbda\n points.append((x,y))\n for angle in np.linspace(np.pi/2,np.pi, num=n//4):\n x = np.cos(angle) * lmbda\n y = np.sin(angle) * lmbda\n points.append((x,y))\n for angle in np.linspace(np.pi, np.pi*3/2, num=n//4):\n x = np.cos(angle) * lmbda\n y = np.sin(angle) * lmbda\n points.append((x,y))\n for angle in np.linspace(np.pi*3/2, 2*np.pi,num=n//4):\n x = np.cos(angle) * lmbda\n y = np.sin(angle) * lmbda\n points.append((x,y))\n return np.array(points)\n\n\ndef loss(b0, b1,\n a = 1,\n b = 1,\n c = 0, # axis stretch\n cx = -10, # shift center x location\n cy = 5): # shift center y\n return a * (b0 - cx) ** 2 + b * (b1 - cy) ** 2 + c * (b0 - cx) * (b1 - cy)\n\n\n# def cirdist(a, b, r):\n# # compute the arctan of 'a' and 'b' then get angle between them\n# # then use ratio of full circle circumference to get distance\n# if np.isclose(a,0.0).any():\n# return\n# else:\n# theta = math.atan(b2/b1)\n# circum = 2*np.pi*r\n# frac_of_circum = circum * (theta / (2*np.pi))\n# return frac_of_circum\n\n#print(circle(1,n=20))"
] | [
[
"numpy.array",
"numpy.cos",
"numpy.linspace",
"numpy.sin"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Combustion-Zhen/flamelet2table | [
"2bc083188308ea5193eaa2abd18fb01021bea4da"
] | [
"FM2csv.py"
] | [
"\"\"\"\nA python script to transfer FlameMaster output to csv tables\n\"\"\"\n\nimport numpy as np\nfrom scipy.interpolate import interp1d\nimport os\nimport sys\nimport glob\nimport argparse\nfrom name_params import params2name\n\ndef FM2csv(mode = 'SLFM', \n flamelet_prefix = 'CH4_p01_0',\n FlameMaster_dir = 'OutSteady', \n csv_dir = 'flamelets'):\n\n if not os.path.exists(FlameMaster_dir):\n sys.exit('FlameMaster output not found')\n\n os.makedirs(csv_dir,exist_ok=True)\n\n # the number of columns in FlameMaster output\n NCOL = 5\n file_suffix = 'csv'\n\n # read the species names into dictionary\n # key: species names in FlameMaster\n # value: species names in Chemkin mechanism\n name_dict = {}\n with open('{}/speciestranslated'.format(FlameMaster_dir),'r') as f:\n for line in f:\n names = line.split()\n name_dict['-'.join(['massfraction',names[1]])] = names[0] \n\n name_dict['temperature'] = 'T'\n name_dict['density'] = 'rho'\n\n extra_var = ['Z', 'chi', 'lambda', 'cp', 'mu', 'D',\n 'ProdRateCO2', 'ProdRateH2O', 'ProdRateCO', 'ProdRateH2',\n 'TotalEnthalpy', 'HeatRelease',\n 'ProgressVariable', 'ProdRateProgressVariable']\n\n prog_var_spe = ['CO2', 'CO', 'H2O', 'H2']\n\n for name in extra_var:\n name_dict[name] = name\n\n for flamelet in glob.glob('{0}/{1}*'.format(FlameMaster_dir, \n flamelet_prefix)):\n\n # skip diverged solution\n if flamelet.endswith('noC'):\n continue\n\n params = {}\n\n params['chi'] = float(\n flamelet[flamelet.find('chi')+3:flamelet.find('tf')])\n\n with open(flamelet,'r') as f:\n\n # read the header part\n for line in f:\n if line.startswith('Z_st'):\n Zst = float(line.split()[2])\n elif line.startswith('gridPoints'):\n npts = int(line.split()[-1])\n nrow = np.ceil(npts/NCOL)\n elif line.startswith('body'):\n break\n\n name_FlameMaster = list(name_dict.keys())\n name_csv = list(name_dict.values())\n\n data = np.zeros((npts, len(name_FlameMaster)),order='F')\n\n for line in f:\n\n if line.strip() == '':\n continue\n elif line.startswith('trailer'):\n break\n\n var_name = line.split()[0]\n\n # read data\n var = []\n for i in np.arange(nrow):\n data_line = f.readline().split()\n var.extend([float(x) for x in data_line])\n\n # map names\n if var_name in name_FlameMaster :\n i = name_csv.index( name_dict[var_name] )\n data[:,i] = np.array( var )\n\n # calculate Diffusivity with Le = 1\n idx_D = name_csv.index( 'D' )\n idx_lambda = name_csv.index( 'lambda' )\n idx_rho = name_csv.index( 'rho' )\n idx_cp = name_csv.index( 'cp' )\n data[:,idx_D] = data[:,idx_lambda]/(data[:,idx_rho]*data[:,idx_cp])\n\n # calculate the progress variable based on the list prog_var_spe\n idx_C = name_csv.index( 'ProgressVariable' )\n idx_C_rate = name_csv.index( 'ProdRateProgressVariable' )\n for spe in prog_var_spe:\n idx_spe = name_csv.index( spe )\n idx_spe_rate = name_csv.index( 'ProdRate{}'.format(spe) )\n\n data[:,idx_C] += data[:,idx_spe]\n data[:,idx_C_rate] += data[:,idx_spe_rate]\n\n\n if mode == 'FPV' :\n params['T'] = float(\n flamelet[flamelet.find('Tst')+3:])\n\n idx_Z = name_csv.index( 'Z' )\n y = interp1d( data[:,idx_Z], data[:,idx_C] )\n params['ProgressVariable'] = y( Zst )\n\n # file name\n file_prefix = params2name( params )\n\n np.savetxt('{}/{}.{}'.format(csv_dir,file_prefix,file_suffix),\n data,\n fmt = '%12.6e',\n delimiter = ',',\n header = ','.join(name_csv),\n comments='')\n\n return\n\nif __name__ == '__main__' :\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '-m', '--mode',\n default = 'SLFM',\n type = str,\n help = 'use of the flamelet solutions: [SLFM]/FPV')\n parser.add_argument(\n '-p', '--prefix',\n default = 'CH4_p01_0',\n type = str,\n help = 'file prefix of the flamelet solution [CH4_p01_0]')\n parser.add_argument(\n '--FlameMasterFolder',\n default = 'OutSteady',\n type = str,\n help = 'folder of the FlameMaster solutions [OutSteady]')\n parser.add_argument(\n '--csvFolder',\n default = 'flamelets',\n type = str,\n help = 'folder for output csv files [flamelets]')\n args = parser.parse_args()\n\n FM2csv(mode = args.mode,\n flamelet_prefix = args.prefix,\n FlameMaster_dir = args.FlameMasterFolder, \n csv_dir = args.csvFolder)\n"
] | [
[
"numpy.arange",
"numpy.array",
"scipy.interpolate.interp1d",
"numpy.ceil"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"0.16",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"1.3",
"1.8"
],
"tensorflow": []
}
] |
Pjer-zhang/LOFAR-Sun-tools | [
"ee0ff1274f6c2894501503c89288fe3096b2700b"
] | [
"lofarSun/IM/IMdata.py"
] | [
"from scipy.io import readsav\nimport matplotlib.dates as mdates\nimport matplotlib as mpl\nimport datetime\nimport glob\nimport os\n\nfrom astropy import units as u\nfrom astropy.coordinates import EarthLocation, SkyCoord\nfrom astropy.io import fits\nfrom astropy.time import Time\n\nimport numpy as np\nfrom skimage import measure\nfrom scipy.ndimage import gaussian_filter\nimport matplotlib.pyplot as plt\nimport cv2\nimport sunpy\nimport sunpy.map\nimport sunpy.coordinates.sun as sun_coord\nfrom sunpy.coordinates.sun import sky_position as sun_position\nfrom sunpy.coordinates import frames\nimport scipy\nimport scipy.ndimage\nfrom matplotlib.patches import Ellipse\n\n# try to use the precise epoch\nmpl.rcParams['date.epoch']='1970-01-01T00:00:00'\ntry:\n mdates.set_epoch('1970-01-01T00:00:00')\nexcept:\n pass\n\n\nclass IMdata:\n def __init__(self):\n self.havedata = False\n\n def load_fits(self,fname):\n if len(fname)>0:\n self.havedata = True\n self.fname = fname\n hdulist = fits.open(fname)\n hdu = hdulist[0]\n self.header = hdu.header\n self.t_obs = sunpy.time.parse_time(self.header['DATE-OBS']).datetime\n self.freq = hdu.header['CRVAL3']/1e6\n data=np.zeros((hdu.header[3],hdu.header[4]), dtype=int)\n data = hdu.data\n self.data=data[0,0,:,:]\n [RA_sun,DEC_sun] = self.get_cur_solar_centroid(t_obs=self.t_obs)\n [RA_obs,DEC_obs] = self.get_obs_image_centroid(self.header)\n [RA_ax ,DEC_ax ] = self.get_axis_obs(self.header)\n\n [self.xx,self.yy] = self.RA_DEC_shift_xy0(RA_ax,DEC_ax,RA_obs,DEC_obs)\n self.data_xy = self.sun_coord_trasform(self.data,self.header,True,True)\n [b_maj,b_min,b_ang] = self.get_beam()\n self.beamArea = (b_maj/180*np.pi)*(b_min/180*np.pi)*np.pi /(4*np.log(2))\n self.data_xy_calib = self.data_xy*(300/self.freq)**2/2/(1.38e-23)/1e26/self.beamArea\n\n \n def get_cur_solar_centroid(self,t_obs):\n # use the observation time to get the solar center\n [RA,DEC] = sun_position(t=t_obs, equinox_of_date=False)\n return [RA.degree%360,DEC.degree%360]\n\n def get_obs_image_centroid(self,header):\n # get the RA DEC center of the image from the solar center\n RA_obs = header['CRVAL1']\n DEC_obs = header['CRVAL2']\n return [RA_obs%360,DEC_obs%360]\n\n def get_axis_obs(self,header):\n # make the header with the image\n # refer to https://www.atnf.csiro.au/computing/software/miriad/progguide/node33.html\n if self.havedata:\n [RA_c,DEC_c] = self.get_obs_image_centroid(self.header)\n RA_ax_obs = RA_c + ((np.arange(header['NAXIS1'])+1) \n -header['CRPIX1'])*header['CDELT1']/np.cos((header['CRVAL2'])/180.*np.pi)\n DEC_ax_obs = DEC_c+ ((np.arange(header['NAXIS2'])+1) \n -header['CRPIX2'])*header['CDELT2']\n return [RA_ax_obs,DEC_ax_obs]\n else:\n print(\"No data loaded\")\n \n def RA_DEC_shift_xy0(self,RA,DEC,RA_cent,DEC_cent):\n # transformation between the observed coordinate and the solar x-y coordinate\n # including the x-y shift\n x_geo = -(RA - RA_cent)*np.cos(DEC_cent/180.*np.pi)*3600\n y_geo = -(DEC_cent - DEC)*3600\n # (in arcsec)\n # the rotation angle of the sun accoording to the date\n return [x_geo,y_geo]\n\n def sun_coord_trasform(self,data,header,act_r=True,act_s=True):\n # act_r : rotation operation\n # act_s : shift operation\n if self.havedata:\n [RA_sun,DEC_sun] = self.get_cur_solar_centroid(self.t_obs);\n [RA_obs,DEC_obs] = self.get_obs_image_centroid(header);\n x_shift_pix = (RA_sun - RA_obs) /header['CDELT1']\n y_shift_pix = (DEC_sun - DEC_obs)/header['CDELT2']\n if act_s==False:\n x_shift_pix = 0\n y_shift_pix = 0\n rotate_angel = sun_coord.P(self.t_obs).degree\n if act_r==False:\n rotate_angel = 0\n data_tmp = scipy.ndimage.shift(data,(x_shift_pix,y_shift_pix))\n data_new = scipy.ndimage.rotate(data_tmp,rotate_angel,reshape=False)\n return data_new\n else:\n print(\"No data loaded\")\n \n \n def get_beam(self):\n if self.havedata:\n solar_PA = sun_coord.P(self.t_obs).degree\n b_maj = self.header['BMAJ']\n b_min = self.header['BMIN']\n b_ang = self.header['BPA']+solar_PA # should consider the beam for the data\n return [b_maj,b_min,b_ang]\n else:\n print(\"No data loaded\")\n\n def make_map(self,fov=2500):\n # still in beta version, use with caution\n # ref : https://gist.github.com/hayesla/42596c72ab686171fe516f9ab43300e2\n hdu = fits.open(self.fname)\n header = hdu[0].header\n data = np.squeeze(hdu[0].data)\n data = np.squeeze(hdu[0].data)\n obstime = Time(header['date-obs'])\n frequency = header['crval3']*u.Hz\n reference_coord = SkyCoord(header['crval1']*u.deg, header['crval2']*u.deg,\n frame='gcrs',\n obstime=obstime,\n distance=sun_coord.earth_distance(obstime),\n equinox='J2000')\n lofar_loc = EarthLocation(lat=52.905329712*u.deg, lon=6.867996528*u.deg) # location of the center of LOFAR\n lofar_coord = SkyCoord(lofar_loc.get_itrs(Time(obstime)))\n reference_coord_arcsec = reference_coord.transform_to(frames.Helioprojective(observer=lofar_coord))\n cdelt1 = (np.abs(header['cdelt1'])*u.deg).to(u.arcsec)\n cdelt2 = (np.abs(header['cdelt2'])*u.deg).to(u.arcsec)\n P1 = sun_coord.P(obstime)\n new_header = sunpy.map.make_fitswcs_header(data, reference_coord_arcsec,\n reference_pixel=u.Quantity([header['crpix1']-1, header['crpix2']-1]*u.pixel),\n scale=u.Quantity([cdelt1, cdelt2]*u.arcsec/u.pix),\n rotation_angle=-P1,\n wavelength=frequency.to(u.MHz),\n observatory='LOFAR')\n lofar_map = sunpy.map.Map(data, new_header)\n lofar_map_rotate = lofar_map.rotate()\n bl = SkyCoord(-fov*u.arcsec, -fov*u.arcsec, frame=lofar_map_rotate.coordinate_frame)\n tr = SkyCoord(fov*u.arcsec, fov*u.arcsec, frame=lofar_map_rotate.coordinate_frame)\n lofar_submap = lofar_map_rotate.submap(bottom_left=bl, top_right=tr)\n return lofar_submap\n\n\n def plot_image(self,vmax_set=np.nan,log_scale=False,fov=2500,FWHM=False,gaussian_sigma=0):\n if self.havedata:\n t_cur_datetime = self.t_obs\n solar_PA = sun_coord.P(self.t_obs).degree\n freq_cur = self.freq\n [b_maj,b_min,b_angel] = self.get_beam()\n b_maj = b_maj*3600\n b_min = b_min*3600\n data_new = gaussian_filter(self.data_xy_calib,sigma=gaussian_sigma)\n xx = self.xx\n yy = self.yy\n\n \n fig=plt.figure()#num=None, figsize=(8, 6),dpi=120)\n ax = plt.gca()\n cmap_now = 'CMRmap_r'\n cmap_now = 'gist_ncar_r'\n cmap_now = 'gist_heat'\n vmin_now = 0\n if log_scale:\n data_new = 10*np.log10(data_new)\n if vmax_set>0:\n vmax_now = vmax_set\n else:\n vmax_now = 1.2*np.nanmax(data_new)\n ax.text(1400,1800, str(int(freq_cur)) + 'MHz',color='w')\n circle1 = plt.Circle((0,0), 960, color='r',fill=False)\n beam0 = Ellipse((-fov*0.3, -fov*0.9), b_maj, b_min, -(b_angel-solar_PA),color='w')\n \n #print(b_maj,b_min,b_angel,solar_PA)\n ax.text(-fov*0.35, -fov*0.9,'Beam shape:',horizontalalignment='right',verticalalignment='center' ,color='w')\n ax.add_artist(circle1)\n ax.add_artist(beam0)\n plt.xlabel('X (ArcSec)')\n plt.ylabel('Y (ArcSec)')\n \n plt.imshow(data_new,vmin=vmin_now, vmax=vmax_now , \n interpolation='nearest',cmap=cmap_now, origin='lower',\n extent=(min(xx),max(xx),min(yy),max(yy)))\n\n if FWHM:\n FWHM_thresh=0.5*(np.max(data_new))\n ax.contour(xx,yy,data_new,levels=[FWHM_thresh],colors=['deepskyblue'])\n \n plt.colorbar()\n plt.xlim([-fov,fov])\n plt.ylim([-fov,fov])\n plt.title(str(t_cur_datetime))\n\n plt.show()\n return [fig,ax]\n\n else:\n print(\"No data loaded\")\n \n"
] | [
[
"numpy.nanmax",
"numpy.squeeze",
"numpy.max",
"matplotlib.pyplot.gca",
"numpy.arange",
"matplotlib.pyplot.Circle",
"numpy.zeros",
"matplotlib.pyplot.figure",
"numpy.log",
"matplotlib.pyplot.ylim",
"scipy.ndimage.rotate",
"numpy.log10",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"matplotlib.patches.Ellipse",
"scipy.ndimage.gaussian_filter",
"numpy.abs",
"numpy.cos",
"matplotlib.dates.set_epoch",
"matplotlib.pyplot.colorbar",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.xlabel",
"scipy.ndimage.shift"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16",
"1.8"
],
"tensorflow": []
}
] |
joncamp/jetbot_ros | [
"c20cc30f0ba421d4c806b5fe6942eb29bb79bed3"
] | [
"gazebo/pygazebo_classifier.py"
] | [
"#!/usr/bin/env python3\r\n# -*- coding: utf-8 -*-\r\n\r\nimport os\r\nimport time\r\nimport signal\r\nimport argparse\r\nimport asyncio\r\nimport pygazebo\r\nimport numpy as np\r\n\r\nfrom PIL import Image\r\nfrom pynput import keyboard\r\nfrom datetime import datetime\r\nfrom navigation_model import NavigationModel\r\n\r\n'''\r\ngz topic -l\r\ngz joint -m 'simple_diff' -j right_wheel_hinge --vel-t 0\r\ngz world --reset-all\r\n\r\nrenice -n 15 $(pgrep gzclient)\r\n'''\r\n\r\nparser = argparse.ArgumentParser()\r\n\r\nparser.add_argument('--host', default='localhost', type=str)\r\nparser.add_argument('--port', default=11346, type=int)\r\nparser.add_argument('--retry', default=30, type=int)\r\n\r\nparser.add_argument('--robot', default='simple_diff', type=str)\r\nparser.add_argument('--camera', default='camera_link', type=str)\r\nparser.add_argument('--left-wheel', default='left_wheel_hinge', type=str)\r\nparser.add_argument('--right-wheel', default='right_wheel_hinge', type=str)\r\nparser.add_argument('--max-speed', default=2.0, type=float)\r\n\r\nparser.add_argument('--model', default='resnet18', type=str)\r\nparser.add_argument('--dataset', default='data/dataset', type=str)\r\nparser.add_argument('--epochs', default=10, type=int)\r\nparser.add_argument('--batch-size', default=1, type=int)\r\n\r\nargs = parser.parse_args()\r\nprint(args)\r\n\r\n\r\n# \r\n# program modes:\r\n# 'collect' (V) save data while driving with WASD/arrow keys\r\n# 'train' (T) train model on collected data\r\n# 'infer' (I) run the model in autonomous inference mode\r\n# 'reset' (R) reset the simulation\r\n#\r\nmode = None\r\n\r\n# current robot wheel velocities\r\nwheel_speed = {'left': None, 'right': None}\r\ndrive_dir = 'stop'\r\n\r\n# load navigation model\r\nnav_model = NavigationModel(args.model)\r\n\r\n# setup dataset\r\ndata_classes = [\r\n #'backward',\r\n 'forward',\r\n 'left',\r\n 'right',\r\n #'stop'\r\n]\r\n\r\nfor cls in data_classes:\r\n os.makedirs(os.path.join(args.dataset, cls), exist_ok=True)\r\n\r\n#\r\n# gazebo connection\r\n#\r\ndef gazebo_connect(host='localhost', port=11346, retry=30):\r\n async def _connect(host, port, retry):\r\n connected = False\r\n for i in range(retry):\r\n try:\r\n print(f'waiting for gazebo connection {host}:{port} (attempt={i+1})')\r\n manager = await pygazebo.connect((host, port))\r\n connected = True\r\n print(f'connected to gazebo server {host}:{port}')\r\n break\r\n except Exception as e:\r\n print(e)\r\n pass\r\n await asyncio.sleep(1)\r\n\r\n if not connected: \r\n raise Exception(\"Timeout connecting to Gazebo.\")\r\n \r\n return manager\r\n\r\n return asyncio.get_event_loop().run_until_complete(\r\n _connect(host, port, retry))\r\n\r\ndef gazebo_advertise(manager, topic_name, msg_type):\r\n async def _advertise(manager, topic_name, msg_type):\r\n print(f'advertising {topic_name} ({msg_type})')\r\n return await manager.advertise(topic_name, msg_type)\r\n \r\n return asyncio.get_event_loop().run_until_complete(\r\n _advertise(manager, topic_name, msg_type))\r\n \r\ndef gazebo_subscribe(manager, topic_name, msg_type, callback):\r\n async def _subscribe(manager, topic_name, msg_type, callback):\r\n print(f'subscribing to {topic_name} ({msg_type})')\r\n subscriber = manager.subscribe(topic_name, msg_type, callback)\r\n await subscriber.wait_for_connection()\r\n return subscriber\r\n \r\n return asyncio.get_event_loop().run_until_complete(\r\n _subscribe(manager, topic_name, msg_type, callback))\r\n\r\n# connect to gazebo server \r\nmanager = gazebo_connect(args.host, args.port, args.retry)\r\n\r\nprint('namespaces')\r\nprint(' ', manager.namespaces())\r\n\r\nprint('publications')\r\nfor topic in manager.publications():\r\n print(' ', topic)\r\n\r\n# subscribe to topics\r\nlast_img = None\r\n\r\ndef on_image(data):\r\n if mode != 'collect' and mode != 'infer':\r\n return\r\n \r\n msg = pygazebo.msg.image_stamped_pb2.ImageStamped()\r\n msg.ParseFromString(data)\r\n \r\n img = np.frombuffer(msg.image.data, dtype=np.uint8)\r\n img = np.reshape(img, (msg.image.height, msg.image.width, 3))\r\n \r\n #print(msg.time)\r\n #print(f'width={msg.image.width} height={msg.image.height} pixel_format={msg.image.pixel_format} step={msg.image.step}')\r\n #print(img.shape)\r\n #print('')\r\n \r\n if mode == 'collect':\r\n if drive_dir in data_classes:\r\n img_path = os.path.join(args.dataset, drive_dir, f\"{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}.jpg\")\r\n Image.fromarray(img).save(img_path)\r\n print(f\"saved {msg.image.width}x{msg.image.height} image to '{img_path}'\")\r\n elif mode == 'infer':\r\n global last_img\r\n last_img = Image.fromarray(img)\r\n \r\nimage_subscriber = gazebo_subscribe(manager, f'/gazebo/default/{args.robot}/{args.camera}/camera/image', 'gazebo.msgs.ImageStamped', on_image)\r\n \r\n# advertise topics\r\njoint_publisher = gazebo_advertise(manager, f'/gazebo/default/{args.robot}/joint_cmd', 'gazebo.msgs.JointCmd')\r\n\r\n \r\n#\r\n# keyboard handler\r\n#\r\nkey_states = {}\r\n\r\ndef on_press(key):\r\n global key_states\r\n\r\n try:\r\n key_states[key.char] = True\r\n except AttributeError:\r\n key_states[key] = True\r\n\r\n\r\ndef on_release(key):\r\n global key_states\r\n global mode\r\n \r\n try:\r\n key_states[key.char] = False\r\n \r\n if key.char == 'v':\r\n mode = 'collect' if mode != 'collect' else None\r\n elif key.char == 't':\r\n mode = 'train' if mode != 'train' else None\r\n elif key.char == 'i':\r\n mode = 'infer' if mode != 'infer' else None\r\n \r\n except AttributeError:\r\n key_states[key] = False\r\n\r\nkeyboard_listener = keyboard.Listener(on_press=on_press, on_release=on_release)\r\nkeyboard_listener.start()\r\n\r\n\r\n#\r\n# robot control\r\n#\r\ndef set_wheel_speed(left, right):\r\n global wheel_speed\r\n changed_speed = False\r\n \r\n if wheel_speed['left'] != left:\r\n left_msg = pygazebo.msg.joint_cmd_pb2.JointCmd()\r\n left_msg.name = f'{args.robot}::{args.left_wheel}'\r\n left_msg.velocity.target = left\r\n joint_publisher.publish(left_msg)\r\n wheel_speed['left'] = left\r\n changed_speed = True\r\n \r\n if wheel_speed['right'] != right:\r\n right_msg = pygazebo.msg.joint_cmd_pb2.JointCmd()\r\n right_msg.name = f'{args.robot}::{args.right_wheel}'\r\n right_msg.velocity.target = right\r\n joint_publisher.publish(right_msg)\r\n wheel_speed['right'] = right\r\n changed_speed = True\r\n \r\n if changed_speed:\r\n print(f\"set_wheel_speed({left}, {right})\")\r\n \r\ndef set_drive_direction(dir, speed=1.0):\r\n global drive_dir \r\n \r\n if not isinstance(dir, str):\r\n dir = data_classes[dir]\r\n \r\n if dir == 'stop':\r\n set_wheel_speed(0,0)\r\n elif dir == 'forward':\r\n set_wheel_speed(speed, speed)\r\n elif dir == 'backward':\r\n set_wheel_speed(-speed, -speed)\r\n elif dir == 'left':\r\n set_wheel_speed(-speed, speed)\r\n elif dir == 'right':\r\n set_wheel_speed(speed, -speed)\r\n else:\r\n raise ValueError(f\"invalid drive direction: {dir}\")\r\n \r\n drive_dir = dir\r\n \r\ndef teleop(speed=1.0):\r\n dir = 'stop'\r\n \r\n if key_states.get(keyboard.Key.left) or key_states.get('a'):\r\n dir = 'left'\r\n elif key_states.get(keyboard.Key.right) or key_states.get('d'):\r\n dir = 'right'\r\n elif key_states.get(keyboard.Key.up) or key_states.get('w'):\r\n dir = 'forward'\r\n elif key_states.get(keyboard.Key.down) or key_states.get('s'):\r\n dir = 'backward'\r\n \r\n set_drive_direction(dir, speed) \r\n\r\n#\r\n# main loop\r\n#\r\nrun_signal = True\r\n\r\ndef signal_handler(sig, frame):\r\n global run_signal\r\n run_signal = False\r\n print('pressed Ctrl+C, exiting...')\r\n\r\nsignal.signal(signal.SIGINT, signal_handler)\r\n\r\n# main loop\r\nasync def run():\r\n global mode\r\n global last_img\r\n \r\n while run_signal:\r\n if mode == 'train':\r\n nav_model.train(args.dataset, epochs=args.epochs, batch_size=args.batch_size)\r\n mode = None\r\n elif mode == 'infer':\r\n if last_img is not None:\r\n dir, prob = nav_model.infer(last_img)\r\n print(f'dir={dir} prob={prob:.8f}')\r\n set_drive_direction(dir, args.max_speed)\r\n last_img = None\r\n else:\r\n teleop(args.max_speed)\r\n \r\n await asyncio.sleep(0.1) # TODO should this be run faster?\r\n \r\n print('shutting down, stopping robot...')\r\n set_wheel_speed(0,0)\r\n await asyncio.sleep(1.0)\r\n \r\nasyncio.get_event_loop().run_until_complete(run())\r\n\r\n "
] | [
[
"numpy.reshape",
"numpy.frombuffer"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
djf604/ribohmm_refactor | [
"6bd0056aa8a9c7851d458995b23d5407821dc38a"
] | [
"ribohmm/core/seq.py"
] | [
"import numpy as np\nfrom pkg_resources import Requirement, resource_listdir, resource_filename\nfrom ribohmm.utils import STARTCODONS, STOPCODONS\n\n# set regex for start and stop codons\nSTARTS = {codon_name: i for i, codon_name in enumerate(STARTCODONS, start=1)}\nSTOPS = {codon_name: i for i, codon_name in enumerate(STOPCODONS, start=1)}\n\n# load pre-computed Kozak model\n# kozak_model = np.load(\"data/kozak_model.npz\")\n# FREQ = dict([(c,np.log2(row)) for c,row in zip(['A','U','G','C'], kozak_model['freq'])])\n# ALTFREQ = dict([(c,np.log2(row)) for c,row in zip(['A','U','G','C'], kozak_model['altfreq'])])\n# for c in ['A','U','G','C']:\n# FREQ[c][9:12] = ALTFREQ[c][9:12]\n\n\n# def get_util_scripts():\n# util_scripts = dict()\n# for util_script_filename in resource_listdir(Requirement.parse('swiftseq'), 'swiftseq/util_scripts'):\n# util_name = util_script_filename.rsplit('.', 1)[FIRST]\n# util_full_filepath = resource_filename(Requirement.parse('swiftseq'), 'swiftseq/util_scripts/{}'.format(\n# util_script_filename\n# ))\n# util_scripts['util_{}'.format(util_name)] = util_full_filepath\n# return util_scripts\n\n\ndef get_resource_kozak_path():\n return resource_filename(Requirement.parse('ribohmm'), 'ribohmm/include/kozak_model.npz')\n\n\ndef inflate_kozak_model(model_path=None):\n \"\"\"\n Inflates and stores the Kozak model as class attributes of ``RnaSequence``\n \"\"\"\n if model_path is None:\n model_path = get_resource_kozak_path()\n kozak_model = np.load(model_path)\n FREQ = dict([(c, np.log2(row)) for c, row in zip(['A', 'U', 'G', 'C'], kozak_model['freq'])])\n ALTFREQ = dict([(c, np.log2(row)) for c, row in zip(['A', 'U', 'G', 'C'], kozak_model['altfreq'])])\n for c in ['A', 'U', 'G', 'C']:\n FREQ[c][9:12] = ALTFREQ[c][9:12]\n\n RnaSequence._kozak_model_freq = FREQ\n RnaSequence._kozak_model_altfreq = ALTFREQ\n\n\nclass RnaSequence(object):\n _kozak_model_freq = None\n _kozak_model_altfreq = None\n\n def __init__(self, sequence):\n self.sequence = sequence\n self.sequence_length = len(self.sequence)\n\n def mark_codons(self):\n # cdef dict codon_flags\n codon_flags = dict()\n\n codon_flags['kozak'] = self._compute_kozak_scores()\n codon_flags['start'] = self._mark_start_codons()\n codon_flags['stop'] = self._mark_stop_codons()\n\n return codon_flags\n\n # @cython.boundscheck(False)\n # @cython.wraparound(False)\n # @cython.nonecheck(False)\n def _mark_start_codons(self):\n offset = 3\n n_triplets = int(self.sequence_length / 3) - 1 # self.S is length of self.sequence\n start_codon_map = np.zeros(shape=(n_triplets, 3), dtype=np.uint8)\n for frame_i in range(3): # For each open reading frame\n for codon_start_pos in range(frame_i, 3 * n_triplets + frame_i, 3): # TODO Python 2/3\n triplet_i = int(codon_start_pos / 3)\n codon_spelling = self.sequence[codon_start_pos + offset:codon_start_pos + offset + 3]\n if codon_spelling in STARTS:\n nearby_stop_codon = [\n self.sequence[codon_start_pos + offset + k:codon_start_pos + offset + 3 + k] in STOPS\n for k in [3, 6, 9, 12]\n ]\n if not any(nearby_stop_codon):\n # print('Adding {} to codon map, seq is {}, or maybe its {}'.format(codon_spelling,\n # self.sequence[triplet_i * 3 + frame_i:(triplet_i + 1) * 3 + frame_i]),\n # 'no'\n # )\n start_codon_map[triplet_i, frame_i] = STARTS[codon_spelling]\n\n return start_codon_map\n\n # @cython.boundscheck(False)\n # @cython.wraparound(False)\n # @cython.nonecheck(False)\n def _mark_stop_codons(self):\n offset = 6\n n_triplets = int(self.sequence_length / 3) - 1\n stop_codon_map = np.zeros(shape=(n_triplets, 3), dtype=np.uint8)\n for frame_i in range(3):\n for codon_start_pos in range(frame_i, 3 * n_triplets + frame_i, 3):\n triplet_i = int(codon_start_pos / 3)\n codon_spelling = self.sequence[codon_start_pos + offset:codon_start_pos + offset + 3]\n if codon_spelling in STOPS:\n stop_codon_map[triplet_i, frame_i] = STOPS[codon_spelling]\n\n return stop_codon_map\n\n # @cython.boundscheck(False)\n # @cython.wraparound(False)\n # @cython.nonecheck(False)\n def _compute_kozak_scores(self):\n\n # cdef int offset, s, f\n # cdef np.ndarray score\n\n offset = 3\n try:\n score = np.zeros((int(self.sequence_length/3) - 1, 3), dtype=float)\n except:\n print('Trying to create dimensions ({}, 3)'.format(int(self.S/3) - 1))\n print('self.__dict__ = {}'.format(self.__dict__))\n raise\n for f in range(3):\n for s in range(2, int((self.sequence_length-f-4-offset) / 3)):\n score[s, f] = RnaSequence.pwm_score(self.sequence[3*s+offset+f-9:3*s+offset+f+4])\n\n return score # np.array[*, *]\n\n # @cython.boundscheck(False)\n # @cython.wraparound(False)\n # @cython.nonecheck(False)\n @classmethod\n def pwm_score(cls, seq):\n\n # cdef long i\n # cdef str s\n # cdef double score\n\n if not (cls._kozak_model_freq and cls._kozak_model_altfreq):\n raise ValueError('Kozak models have no been loaded')\n\n score = 0\n for i, s in enumerate(seq):\n try:\n score = score + cls._kozak_model_freq[s][i] - cls._kozak_model_altfreq[s][i]\n except KeyError:\n pass\n\n return score\n"
] | [
[
"numpy.load",
"numpy.log2",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
bradyneal/covid-xprize-comp | [
"d515f58b009a0a3e2421bc83e7ac893f3c3a1ece"
] | [
"ongoing/prescriptors/prescribe.py"
] | [
"import os\nimport argparse\nimport numpy as np\nimport pandas as pd\nimport time\n\nimport zipfile\nimport os.path\n\nfrom ongoing.prescriptors.neat_multi.neat_prescriptor_many_objective import Neat as Neat2D\nfrom ongoing.prescriptors.neat_13D.neat_prescriptor_many_objective import Neat as Neat13D\nfrom ongoing.prescriptors.bandit.bandit_prescriptor import Bandit\nfrom ongoing.prescriptors.heuristic.heuristic_prescriptor import Heuristic\nfrom ongoing.prescriptors.blind_greedy.blind_greedy_prescriptor import BlindGreedy\nfrom covid_xprize.standard_predictor.xprize_predictor import XPrizePredictor\nimport ongoing.prescriptors.base as base\n\nROOT_DIR = os.path.dirname(os.path.abspath(__file__))\n\n# Path to file containing neat prescriptors. Here we simply use a\n# recent checkpoint of the population from train_prescriptor.py,\n# but this is likely not the most complementary set of prescriptors.\n# Many approaches can be taken to generate/collect more diverse sets.\n# Note: this set can contain up to 10 prescriptors for evaluation.\n\n# Neat2D configs\nNEAT2D_PATH = os.path.join(ROOT_DIR, 'neat_multi/models/5days-results-2d-1-hidden/')\nNEAT2D_CHECKPOINT_0 = 26\nNEAT2D_FILE_0 = os.path.join(NEAT2D_PATH, 'neat-checkpoint-{}'.format(NEAT2D_CHECKPOINT_0))\nNEAT2D_FILE_ZIP_0 = os.path.join(NEAT2D_PATH, 'neat-checkpoint-{}.zip'.format(NEAT2D_CHECKPOINT_0))\nNEAT2D_CONFIG_FILE_0 = NEAT2D_PATH + 'config-prescriptor-{}'.format(NEAT2D_CHECKPOINT_0)\nNEAT2D_CHECKPOINT_1 = 45\nNEAT2D_FILE_1 = os.path.join(NEAT2D_PATH, 'neat-checkpoint-{}'.format(NEAT2D_CHECKPOINT_1))\nNEAT2D_FILE_ZIP_1 = os.path.join(NEAT2D_PATH, 'neat-checkpoint-{}.zip'.format(NEAT2D_CHECKPOINT_1))\nNEAT2D_CONFIG_FILE_1 = NEAT2D_PATH + 'config-prescriptor-{}'.format(NEAT2D_CHECKPOINT_1)\n\n# Neat13D configs\nNEAT13D_PATH = os.path.join(ROOT_DIR, 'neat_13D/models/13d_5days/')\nNEAT13D_CHECKPOINT_0 = 50\nNEAT13D_FILE_0 = os.path.join(NEAT13D_PATH, 'neat-checkpoint-{}'.format(NEAT13D_CHECKPOINT_0))\nNEAT13D_FILE_ZIP_0 = os.path.join(NEAT13D_PATH, 'neat-checkpoint-{}.zip'.format(NEAT13D_CHECKPOINT_0))\nNEAT13D_CONFIG_FILE_0 = NEAT13D_PATH + 'config-prescriptor-{}'.format(NEAT13D_CHECKPOINT_0)\nNEAT13D_CHECKPOINT_1 = 70\nNEAT13D_FILE_1 = os.path.join(NEAT13D_PATH, 'neat-checkpoint-{}'.format(NEAT13D_CHECKPOINT_1))\nNEAT13D_FILE_ZIP_1 = os.path.join(NEAT13D_PATH, 'neat-checkpoint-{}.zip'.format(NEAT13D_CHECKPOINT_1))\nNEAT13D_CONFIG_FILE_1 = NEAT13D_PATH + 'config-prescriptor-{}'.format(NEAT13D_CHECKPOINT_1)\n\nPREDICTOR_PATH = 'covid_xprize/standard_predictor/models/trained_model_weights.h5'\nDATA_DIR = os.path.join(ROOT_DIR, os.pardir, 'data')\nOXFORD_FILEPATH = os.path.join(DATA_DIR, 'OxCGRT_latest.csv')\n\n# number of prescriptions\nNUM_REQUIRED = 10\n\n# limits on the allowed values of stringency for our solutions\nMIN_STRINGENCY = 0.5\nMAX_STRINGENCY = 35\n\ndef prescribe(start_date_str: str,\n end_date_str: str,\n path_to_prior_ips_file: str,\n path_to_cost_file: str,\n output_file_path) -> None:\n\n # Load historical IPs, just to extract the geos\n # we need to prescribe for.\n npi_df = pd.read_csv(path_to_prior_ips_file,\n parse_dates=['Date'],\n encoding=\"ISO-8859-1\",\n error_bad_lines=True)\n npi_df = base.add_geo_id(npi_df)\n\n # Load historical data\n hist_df = base.load_historical_data(update_data=False)\n\n # Load the IP weights, so that we can use them\n # greedily for each geo.\n cost_df = pd.read_csv(path_to_cost_file)\n cost_df = base.add_geo_id(cost_df)\n\n # unpack the model if required\n if os.path.isfile(NEAT2D_FILE_0):\n print(\"Model file exists\")\n else:\n print(\"Un-zipping model file\")\n with zipfile.ZipFile(NEAT2D_FILE_ZIP_0, 'r') as zip_ref:\n zip_ref.extractall(NEAT2D_PATH)\n\n # unpack the model if required\n if os.path.isfile(NEAT2D_FILE_1):\n print(\"Model file exists\")\n else:\n print(\"Un-zipping model file\")\n with zipfile.ZipFile(NEAT2D_FILE_ZIP_1, 'r') as zip_ref:\n zip_ref.extractall(NEAT2D_PATH)\n\n # # unpack the model if required\n # if os.path.isfile(NEAT13D_FILE_0):\n # print(\"Model file exists\")\n # else:\n # print(\"Please unzip model file {}\".format(NEAT13D_FILE_ZIP_0))\n # exit(-2)\n\n # # unpack the model if required\n # if os.path.isfile(NEAT13D_FILE_1):\n # print(\"Model file exists\")\n # else:\n # print(\"Please unzip model file {}\".format(NEAT13D_FILE_ZIP_1))\n # exit(-2)\n\n # instantiate prescriptors\n # bandit = Bandit(load=True, hist_df=hist_df, verbose=False)\n neat2d_ad15_ckp0 = Neat2D(prescriptors_file=NEAT2D_FILE_0, hist_df=hist_df, config_file=NEAT2D_CONFIG_FILE_0, action_duration=15)\n neat2d_ad15_ckp1 = Neat2D(prescriptors_file=NEAT2D_FILE_1, hist_df=hist_df, config_file=NEAT2D_CONFIG_FILE_1, action_duration=15)\n neat2d_ad1 = Neat2D(prescriptors_file=NEAT2D_FILE_0, hist_df=hist_df, config_file=NEAT2D_CONFIG_FILE_0, action_duration=1)\n # neat13d_ckp0 = Neat13D(prescriptors_file=NEAT13D_FILE_0, hist_df=hist_df, config_file=NEAT13D_CONFIG_FILE_0)\n # neat13d_ckp1 = Neat13D(prescriptors_file=NEAT13D_FILE_1, hist_df=hist_df, config_file=NEAT13D_CONFIG_FILE_1)\n heuristic = Heuristic()\n blind_greedy = BlindGreedy()\n prescriptors = {\n # 'Bandit': bandit,\n 'Neat2D_AD1': neat2d_ad1,\n 'Neat2D_AD15_CKP0': neat2d_ad15_ckp0,\n 'Neat2D_AD15_CKP1': neat2d_ad15_ckp1,\n # 'Neat13D_CKP0': neat13d_ckp0,\n # 'Neat13D_CKP1': neat13d_ckp1,\n 'Heuristic': heuristic,\n 'BlindGreedy': blind_greedy,\n }\n\n # generate prescriptions and predictions for all prescriptors\n prescriptions = {}\n eval = []\n predictor = XPrizePredictor(PREDICTOR_PATH, OXFORD_FILEPATH)\n for presc_name, presc in prescriptors.items():\n try: # in case anything goes wrong with this prescriptor, ignore it and move to the next one\n print('Generating prescriptions for {}'.format(presc_name))\n pres_df = presc.prescribe(start_date_str, end_date_str, npi_df, cost_df)\n pres_df = base.add_geo_id(pres_df)\n prescriptions[presc_name] = pres_df\n\n # generate predictions with the given prescriptions\n print('Generating predictions for {}'.format(presc_name))\n pred_dfs = []\n for idx in pres_df['PrescriptionIndex'].unique():\n idx_df = pres_df[pres_df['PrescriptionIndex'] == idx]\n idx_df = idx_df.drop(columns='PrescriptionIndex') # predictor doesn't need this\n last_known_date = predictor.df['Date'].max()\n if last_known_date < pd.to_datetime(idx_df['Date'].min()) - np.timedelta64(1, 'D'):\n # append prior NPIs to the prescripted ones because the predictor will need them\n idx_df = idx_df.append(npi_df[npi_df['Date'] > last_known_date].drop(columns='GeoID'))\n pred_df = predictor.predict(start_date_str, end_date_str, idx_df)\n pred_df['PrescriptionIndex'] = idx\n pred_dfs.append(pred_df)\n pred_df = pd.concat(pred_dfs)\n # aggregate cases by prescription index and geo\n agg_pred_df = pred_df.groupby(['CountryName',\n 'RegionName',\n 'PrescriptionIndex'], dropna=False).mean().reset_index()\n\n # only use costs of geos we've predicted for\n cost_df = cost_df[cost_df['CountryName'].isin(agg_pred_df['CountryName']) &\n cost_df['RegionName'].isin(agg_pred_df['RegionName'])]\n\n # apply weights to prescriptions\n pres_df = base.weight_prescriptions_by_cost(pres_df, cost_df)\n\n # aggregate stringency across npis\n pres_df['Stringency'] = pres_df[base.NPI_COLUMNS].sum(axis=1)\n\n # aggregate stringency by prescription index and geo\n agg_pres_df = pres_df.groupby(['CountryName',\n 'RegionName',\n 'PrescriptionIndex'], dropna=False).mean().reset_index()\n\n # combine stringency and cases into a single df\n df = agg_pres_df.merge(agg_pred_df, how='outer', on=['CountryName',\n 'RegionName',\n 'PrescriptionIndex'])\n\n # only keep columns of interest\n df = df[['CountryName',\n 'RegionName',\n 'PrescriptionIndex',\n 'PredictedDailyNewCases',\n 'Stringency']]\n df['TestName'] = 'NA'\n df['source'] = presc_name\n eval.append(df)\n except:\n print('Something went wrong with {}. Skipping it.'.format(presc_name))\n continue\n\n # run the aggregation to find the best prescriptions\n pareto_presc = aggregate_results(eval)\n\n agg_df_dict = {'CountryName': [],\n 'RegionName': [],\n 'Date': [],\n 'PrescriptionIndex': []}\n for npi in base.NPI_COLUMNS:\n agg_df_dict[npi] = []\n\n # get the best prescription for each prescription index and for each geo\n winner = {presc_name: 0 for presc_name in prescriptors}\n for idx in pareto_presc['PrescriptionIndex'].unique():\n for geo in pareto_presc['GeoID'].unique():\n tmp_df = pareto_presc[(pareto_presc['PrescriptionIndex'] == idx) & (pareto_presc['GeoID'] == geo)]\n src_name = tmp_df['source'].tolist()[0]\n src_idx = tmp_df['source-PrescriptionIndex'].tolist()[0]\n pres_df = prescriptions[src_name][(prescriptions[src_name]['PrescriptionIndex'] == src_idx) & (prescriptions[src_name]['GeoID'] == geo)]\n\n country_name = pres_df['CountryName'].tolist()\n region_name = pres_df['RegionName'].tolist()\n dates = pres_df['Date'].tolist()\n\n agg_df_dict['CountryName'].extend(country_name)\n agg_df_dict['RegionName'].extend(region_name)\n agg_df_dict['Date'].extend(dates)\n agg_df_dict['PrescriptionIndex'].extend([idx for date in dates])\n for npi in base.NPI_COLUMNS:\n agg_df_dict[npi].extend(pres_df[npi].tolist())\n\n winner[src_name] += 1\n\n agg_df = pd.DataFrame(agg_df_dict)\n\n # Create the directory for writing the output file, if necessary.\n try:\n os.makedirs(os.path.dirname(output_file_path), exist_ok=True)\n except:\n pass\n\n # Save output csv file.\n agg_df.to_csv(output_file_path, index=False)\n\n print('No. of times each model was chosen:')\n for presc_name, wins in winner.items():\n print('{}: {}'.format(presc_name, wins))\n\n return\n\ndef get_non_dom_ind(vals_arr, verbose=True):\n res_arr = []\n for i in range(0, len(vals_arr)):\n point1 = vals_arr[i]\n is_dominated = False\n for j in range(0, len(vals_arr)):\n if i == j:\n continue\n point2 = vals_arr[j]\n if ((point2[0] < point1[0]) and (point2[1] <= point1[1])) or (\n (point2[0] <= point1[0]) and (point2[1] < point1[1])):\n if verbose:\n print('{} is dominated by {}'.format(i, j))\n is_dominated = True\n break\n pass\n if not is_dominated:\n res_arr.append(i)\n pass\n return res_arr\n\n\ndef get_best_n_points_no_curve(n, arr_input):\n arr_list = arr_input.tolist()\n arr_list.sort(reverse=True, key=lambda x: x[0])\n arr_list = np.array(arr_list)\n\n # 2. find arc length\n arc_len_arr = []\n for pos in range(0, len(arr_input) - 1):\n p1 = np.array([arr_list[pos][0], arr_list[pos][1]])\n p2 = np.array([arr_list[pos + 1][0], arr_list[pos + 1][1]])\n arc_len_arr.append(np.linalg.norm(p2 - p1))\n arc_len_arr = np.array(arc_len_arr)\n # distance delta\n d = sum(arc_len_arr) / (n - 1)\n # cumul_sum of art length\n arc_len_arr_cum = np.cumsum(arc_len_arr)\n\n # 3. choose ref. points\n # positions of reference points\n points_pos = [0]\n j = 1\n for i in range(0, len(arc_len_arr_cum)):\n if arc_len_arr_cum[i] >= j * d:\n points_pos.append(i + 1)\n j += 1\n if j == n - 1:\n break\n pass\n points_pos.append(len(arr_list) - 1)\n\n chosen_points = []\n for ref_point_pos in points_pos:\n ref_point = arr_list[ref_point_pos]\n dist = np.linalg.norm((arr_input - ref_point), axis=1)\n pos = np.argmin(dist)\n chosen_points.append(pos)\n pass\n\n return chosen_points\n\n\ndef aggregate_results(df_arr):\n\n # get all test\n all_tests = []\n for df in df_arr:\n all_tests.extend(df['TestName'].unique())\n pass\n # remove duplicates\n all_tests = list(set(all_tests))\n\n # test = all_tests[0]\n\n final_dfs = []\n for test in all_tests:\n print('Processing {}'.format(test))\n # generate sub_dfs that will contain only the results for the required test\n test_df_arr = []\n for df in df_arr:\n test_df = df.loc[df['TestName'] == test].copy()\n test_df = base.add_geo_id(test_df)\n test_df_arr.append(test_df)\n pass\n\n # get all geo-s in this test\n all_geos = set()\n for test_df in test_df_arr:\n geos = test_df['GeoID'].unique()\n all_geos.update(set(geos))\n pass\n all_geos = list(all_geos)\n\n # for every geo\n for curr_geo in all_geos:\n # put all prescriptors for the current geo in the same df\n prescr_df = []\n for test_df in test_df_arr:\n df = test_df.loc[test_df['GeoID'] == curr_geo].copy()\n df['source'] = test_df['source']\n prescr_df.append(df)\n pass\n # put them all together and remove duplicates\n prescr_df = pd.concat(prescr_df).drop_duplicates(['PredictedDailyNewCases', 'Stringency'])\n\n # remove solutions with (Stringency < min_stringency) or (Stringency > max_stringency)\n prescr_df.reset_index(inplace=True, drop=True)\n idx_to_drop = prescr_df[(prescr_df['Stringency'] < MIN_STRINGENCY) | (prescr_df['Stringency'] > MAX_STRINGENCY)].index\n prescr_df.drop(idx_to_drop, inplace=True)\n\n # choose non-dominated\n arr = prescr_df[['PredictedDailyNewCases', 'Stringency']].values\n non_dom_idx = get_non_dom_ind(arr, verbose=False)\n\n # check here if we have at least 10\n if len(non_dom_idx) < NUM_REQUIRED:\n # print('less than 10: {}'.format(curr_geo))\n # just copy the first point the required number of times\n chosen_points_pos = non_dom_idx\n num_found = len(chosen_points_pos)\n for i in range(0, NUM_REQUIRED - num_found):\n chosen_points_pos.append(chosen_points_pos[0])\n pass\n chosen_non_dom = chosen_points_pos\n pass\n elif len(non_dom_idx) == NUM_REQUIRED:\n # don't do anything\n chosen_points_pos = non_dom_idx\n chosen_non_dom = chosen_points_pos\n pass\n else:\n # choose points\n chosen_points_pos = get_best_n_points_no_curve(NUM_REQUIRED, arr[non_dom_idx])\n chosen_non_dom = np.array(non_dom_idx)[chosen_points_pos]\n pass\n # create a df with chosen tests for this geo\n geo_df = prescr_df.iloc[chosen_non_dom].copy()\n # geo_df.drop('Unnamed: 0', axis=1, inplace=True)\n tmp = geo_df.copy()\n while len(geo_df) < NUM_REQUIRED:\n geo_df = pd.concat([geo_df, tmp])\n geo_df = geo_df[0: NUM_REQUIRED]\n geo_df['source-PrescriptionIndex'] = geo_df['PrescriptionIndex']\n geo_df['PrescriptionIndex'] = [i for i in range(0, NUM_REQUIRED)]\n final_dfs.append(geo_df)\n pass\n pass\n res_df = pd.concat(final_dfs)\n res_df.reset_index(drop=True, inplace=True)\n return res_df\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-s\", \"--start_date\",\n dest=\"start_date\",\n type=str,\n required=True,\n help=\"Start date from which to prescribe, included, as YYYY-MM-DD.\"\n \"For example 2020-08-01\")\n parser.add_argument(\"-e\", \"--end_date\",\n dest=\"end_date\",\n type=str,\n required=True,\n help=\"End date for the last prescription, included, as YYYY-MM-DD.\"\n \"For example 2020-08-31\")\n parser.add_argument(\"-ip\", \"--interventions_past\",\n dest=\"prev_file\",\n type=str,\n required=True,\n help=\"The path to a .csv file of previous intervention plans\")\n parser.add_argument(\"-c\", \"--intervention_costs\",\n dest=\"cost_file\",\n type=str,\n required=True,\n help=\"Path to a .csv file containing the cost of each IP for each geo\")\n parser.add_argument(\"-o\", \"--output_file\",\n dest=\"output_file\",\n type=str,\n required=True,\n help=\"The path to an intervention plan .csv file\")\n args = parser.parse_args()\n print(f\"Generating prescriptions from {args.start_date} to {args.end_date}...\")\n start = time.time()\n prescribe(args.start_date, args.end_date, args.prev_file, args.cost_file, args.output_file)\n end = time.time()\n print('TIME elapsed:', (end - start) / 60, 'minutes')\n print(\"Done!\")\n"
] | [
[
"pandas.concat",
"pandas.read_csv",
"numpy.cumsum",
"pandas.DataFrame",
"numpy.linalg.norm",
"numpy.timedelta64",
"numpy.argmin",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
manandey/datasets | [
"10d4e5d179d6cd78007acb34829bb32e7cbbff62"
] | [
"src/datasets/features/features.py"
] | [
"# Copyright 2020 The HuggingFace Datasets Authors and the TensorFlow Datasets Authors.\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# Lint as: python3\n\"\"\" This class handle features definition in datasets and some utilities to display table type.\"\"\"\nimport copy\nimport json\nimport re\nimport sys\nfrom collections.abc import Iterable\nfrom dataclasses import InitVar, _asdict_inner, dataclass, field, fields\nfrom functools import reduce, wraps\nfrom operator import mul\nfrom typing import Any, ClassVar, Dict, List, Optional\nfrom typing import Sequence as Sequence_\nfrom typing import Tuple, Union\n\nimport numpy as np\nimport pandas as pd\nimport pyarrow as pa\nimport pyarrow.types\nfrom pandas.api.extensions import ExtensionArray as PandasExtensionArray\nfrom pandas.api.extensions import ExtensionDtype as PandasExtensionDtype\n\nfrom .. import config\nfrom ..utils import logging\nfrom ..utils.py_utils import zip_dict\nfrom .audio import Audio\nfrom .image import Image, encode_pil_image\nfrom .translation import Translation, TranslationVariableLanguages\n\n\nlogger = logging.get_logger(__name__)\n\n\ndef _arrow_to_datasets_dtype(arrow_type: pa.DataType) -> str:\n \"\"\"\n _arrow_to_datasets_dtype takes a pyarrow.DataType and converts it to a datasets string dtype.\n In effect, `dt == string_to_arrow(_arrow_to_datasets_dtype(dt))`\n \"\"\"\n if pyarrow.types.is_null(arrow_type):\n return \"null\"\n elif pyarrow.types.is_boolean(arrow_type):\n return \"bool\"\n elif pyarrow.types.is_int8(arrow_type):\n return \"int8\"\n elif pyarrow.types.is_int16(arrow_type):\n return \"int16\"\n elif pyarrow.types.is_int32(arrow_type):\n return \"int32\"\n elif pyarrow.types.is_int64(arrow_type):\n return \"int64\"\n elif pyarrow.types.is_uint8(arrow_type):\n return \"uint8\"\n elif pyarrow.types.is_uint16(arrow_type):\n return \"uint16\"\n elif pyarrow.types.is_uint32(arrow_type):\n return \"uint32\"\n elif pyarrow.types.is_uint64(arrow_type):\n return \"uint64\"\n elif pyarrow.types.is_float16(arrow_type):\n return \"float16\" # pyarrow dtype is \"halffloat\"\n elif pyarrow.types.is_float32(arrow_type):\n return \"float32\" # pyarrow dtype is \"float\"\n elif pyarrow.types.is_float64(arrow_type):\n return \"float64\" # pyarrow dtype is \"double\"\n elif pyarrow.types.is_time32(arrow_type):\n return f\"time32[{arrow_type.unit}]\"\n elif pyarrow.types.is_time64(arrow_type):\n return f\"time64[{arrow_type.unit}]\"\n elif pyarrow.types.is_timestamp(arrow_type):\n if arrow_type.tz is None:\n return f\"timestamp[{arrow_type.unit}]\"\n elif arrow_type.tz:\n return f\"timestamp[{arrow_type.unit}, tz={arrow_type.tz}]\"\n else:\n raise ValueError(f\"Unexpected timestamp object {arrow_type}.\")\n elif pyarrow.types.is_date32(arrow_type):\n return \"date32\" # pyarrow dtype is \"date32[day]\"\n elif pyarrow.types.is_date64(arrow_type):\n return \"date64\" # pyarrow dtype is \"date64[ms]\"\n elif pyarrow.types.is_duration(arrow_type):\n return f\"duration[{arrow_type.unit}]\"\n elif pyarrow.types.is_decimal128(arrow_type):\n return f\"decimal128({arrow_type.precision}, {arrow_type.scale})\"\n elif pyarrow.types.is_decimal256(arrow_type):\n return f\"decimal256({arrow_type.precision}, {arrow_type.scale})\"\n elif pyarrow.types.is_binary(arrow_type):\n return \"binary\"\n elif pyarrow.types.is_large_binary(arrow_type):\n return \"large_binary\"\n elif pyarrow.types.is_string(arrow_type):\n return \"string\"\n elif pyarrow.types.is_large_string(arrow_type):\n return \"large_string\"\n else:\n raise ValueError(f\"Arrow type {arrow_type} does not have a datasets dtype equivalent.\")\n\n\ndef string_to_arrow(datasets_dtype: str) -> pa.DataType:\n \"\"\"\n string_to_arrow takes a datasets string dtype and converts it to a pyarrow.DataType.\n\n In effect, `dt == string_to_arrow(_arrow_to_datasets_dtype(dt))`\n\n This is necessary because the datasets.Value() primitive type is constructed using a string dtype\n\n Value(dtype=str)\n\n But Features.type (via `get_nested_type()` expects to resolve Features into a pyarrow Schema,\n which means that each Value() must be able to resolve into a corresponding pyarrow.DataType, which is the\n purpose of this function.\n \"\"\"\n\n def _dtype_error_msg(dtype, pa_dtype, examples=None, urls=None):\n msg = f\"{dtype} is not a validly formatted string representation of the pyarrow {pa_dtype} type.\"\n if examples:\n examples = \", \".join(examples[:-1]) + \" or \" + examples[-1] if len(examples) > 1 else examples[0]\n msg += f\"\\nValid examples include: {examples}.\"\n if urls:\n urls = \", \".join(urls[:-1]) + \" and \" + urls[-1] if len(urls) > 1 else urls[0]\n msg += f\"\\nFor more insformation, see: {urls}.\"\n return msg\n\n if datasets_dtype in pa.__dict__:\n return pa.__dict__[datasets_dtype]()\n\n if (datasets_dtype + \"_\") in pa.__dict__:\n return pa.__dict__[datasets_dtype + \"_\"]()\n\n timestamp_matches = re.search(r\"^timestamp\\[(.*)\\]$\", datasets_dtype)\n if timestamp_matches:\n timestamp_internals = timestamp_matches.group(1)\n internals_matches = re.search(r\"^(s|ms|us|ns),\\s*tz=([a-zA-Z0-9/_+\\-:]*)$\", timestamp_internals)\n if timestamp_internals in [\"s\", \"ms\", \"us\", \"ns\"]:\n return pa.timestamp(timestamp_internals)\n elif internals_matches:\n return pa.timestamp(internals_matches.group(1), internals_matches.group(2))\n else:\n raise ValueError(\n _dtype_error_msg(\n datasets_dtype,\n \"timestamp\",\n examples=[\"timestamp[us]\", \"timestamp[us, tz=America/New_York\"],\n urls=[\"https://arrow.apache.org/docs/python/generated/pyarrow.timestamp.html\"],\n )\n )\n\n duration_matches = re.search(r\"^duration\\[(.*)\\]$\", datasets_dtype)\n if duration_matches:\n duration_internals = duration_matches.group(1)\n if duration_internals in [\"s\", \"ms\", \"us\", \"ns\"]:\n return pa.duration(duration_internals)\n else:\n raise ValueError(\n _dtype_error_msg(\n datasets_dtype,\n \"duration\",\n examples=[\"duration[s]\", \"duration[us]\"],\n urls=[\"https://arrow.apache.org/docs/python/generated/pyarrow.duration.html\"],\n )\n )\n\n time_matches = re.search(r\"^time(.*)\\[(.*)\\]$\", datasets_dtype)\n if time_matches:\n time_internals_bits = time_matches.group(1)\n if time_internals_bits == \"32\":\n time_internals_unit = time_matches.group(2)\n if time_internals_unit in [\"s\", \"ms\"]:\n return pa.time32(time_internals_unit)\n else:\n raise ValueError(\n f\"{time_internals_unit} is not a valid unit for the pyarrow time32 type. Supported units: s (second) and ms (millisecond).\"\n )\n elif time_internals_bits == \"64\":\n time_internals_unit = time_matches.group(2)\n if time_internals_unit in [\"us\", \"ns\"]:\n return pa.time64(time_internals_unit)\n else:\n raise ValueError(\n f\"{time_internals_unit} is not a valid unit for the pyarrow time64 type. Supported units: us (microsecond) and ns (nanosecond).\"\n )\n else:\n raise ValueError(\n _dtype_error_msg(\n datasets_dtype,\n \"time\",\n examples=[\"time32[s]\", \"time64[us]\"],\n urls=[\n \"https://arrow.apache.org/docs/python/generated/pyarrow.time32.html\",\n \"https://arrow.apache.org/docs/python/generated/pyarrow.time64.html\",\n ],\n )\n )\n\n decimal_matches = re.search(r\"^decimal(.*)\\((.*)\\)$\", datasets_dtype)\n if decimal_matches:\n decimal_internals_bits = decimal_matches.group(1)\n if decimal_internals_bits == \"128\":\n decimal_internals_precision_and_scale = re.search(r\"^(\\d+),\\s*(-?\\d+)$\", decimal_matches.group(2))\n if decimal_internals_precision_and_scale:\n precision = decimal_internals_precision_and_scale.group(1)\n scale = decimal_internals_precision_and_scale.group(2)\n return pa.decimal128(int(precision), int(scale))\n else:\n raise ValueError(\n _dtype_error_msg(\n datasets_dtype,\n \"decimal128\",\n examples=[\"decimal128(10, 2)\", \"decimal128(4, -2)\"],\n urls=[\"https://arrow.apache.org/docs/python/generated/pyarrow.decimal128.html\"],\n )\n )\n elif decimal_internals_bits == \"256\":\n decimal_internals_precision_and_scale = re.search(r\"^(\\d+),\\s*(-?\\d+)$\", decimal_matches.group(2))\n if decimal_internals_precision_and_scale:\n precision = decimal_internals_precision_and_scale.group(1)\n scale = decimal_internals_precision_and_scale.group(2)\n return pa.decimal256(int(precision), int(scale))\n else:\n raise ValueError(\n _dtype_error_msg(\n datasets_dtype,\n \"decimal256\",\n examples=[\"decimal256(30, 2)\", \"decimal256(38, -4)\"],\n urls=[\"https://arrow.apache.org/docs/python/generated/pyarrow.decimal256.html\"],\n )\n )\n else:\n raise ValueError(\n _dtype_error_msg(\n datasets_dtype,\n \"decimal\",\n examples=[\"decimal128(12, 3)\", \"decimal256(40, 6)\"],\n urls=[\n \"https://arrow.apache.org/docs/python/generated/pyarrow.decimal128.html\",\n \"https://arrow.apache.org/docs/python/generated/pyarrow.decimal256.html\",\n ],\n )\n )\n\n raise ValueError(\n f\"Neither {datasets_dtype} nor {datasets_dtype + '_'} seems to be a pyarrow data type. \"\n f\"Please make sure to use a correct data type, see: \"\n f\"https://arrow.apache.org/docs/python/api/datatypes.html#factory-functions\"\n )\n\n\ndef _cast_to_python_objects(obj: Any, only_1d_for_numpy: bool, optimize_list_casting: bool) -> Tuple[Any, bool]:\n \"\"\"\n Cast pytorch/tensorflow/pandas objects to python numpy array/lists.\n It works recursively.\n\n If `optimize_list_casting` is True, to avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be casted.\n If the first element needs to be casted, then all the elements of the list will be casted, otherwise they'll stay the same.\n This trick allows to cast objects that contain tokenizers outputs without iterating over every single token for example.\n\n Args:\n obj: the object (nested struct) to cast.\n only_1d_for_numpy (bool): whether to keep the full multi-dim tensors as multi-dim numpy arrays, or convert them to\n nested lists of 1-dimensional numpy arrays. This can be useful to keep only 1-d arrays to instantiate Arrow arrays.\n Indeed Arrow only support converting 1-dimensional array values.\n optimize_list_casting (bool): whether to optimize list casting by checking the first non-null element to see if it needs to be casted\n and if it doesn't, not checking the rest of the list elements.\n\n Returns:\n casted_obj: the casted object\n has_changed (bool): True if the object has been changed, False if it is identical\n \"\"\"\n\n if config.TF_AVAILABLE and \"tensorflow\" in sys.modules:\n import tensorflow as tf\n\n if config.TORCH_AVAILABLE and \"torch\" in sys.modules:\n import torch\n\n if config.JAX_AVAILABLE and \"jax\" in sys.modules:\n import jax.numpy as jnp\n\n if config.PIL_AVAILABLE and \"PIL\" in sys.modules:\n import PIL.Image\n\n if isinstance(obj, np.ndarray):\n if not only_1d_for_numpy or obj.ndim == 1:\n return obj, False\n else:\n return [\n _cast_to_python_objects(\n x, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting\n )[0]\n for x in obj\n ], True\n elif config.TORCH_AVAILABLE and \"torch\" in sys.modules and isinstance(obj, torch.Tensor):\n if not only_1d_for_numpy or obj.ndim == 1:\n return obj.detach().cpu().numpy(), True\n else:\n return [\n _cast_to_python_objects(\n x, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting\n )[0]\n for x in obj.detach().cpu().numpy()\n ], True\n elif config.TF_AVAILABLE and \"tensorflow\" in sys.modules and isinstance(obj, tf.Tensor):\n if not only_1d_for_numpy or obj.ndim == 1:\n return obj.numpy(), True\n else:\n return [\n _cast_to_python_objects(\n x, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting\n )[0]\n for x in obj.numpy()\n ], True\n elif config.JAX_AVAILABLE and \"jax\" in sys.modules and isinstance(obj, jnp.ndarray):\n if not only_1d_for_numpy or obj.ndim == 1:\n return np.asarray(obj), True\n else:\n return [\n _cast_to_python_objects(\n x, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting\n )[0]\n for x in np.asarray(obj)\n ], True\n elif config.PIL_AVAILABLE and \"PIL\" in sys.modules and isinstance(obj, PIL.Image.Image):\n return encode_pil_image(obj), True\n elif isinstance(obj, pd.Series):\n return obj.values.tolist(), True\n elif isinstance(obj, pd.DataFrame):\n return obj.to_dict(\"list\"), True\n elif isinstance(obj, dict):\n output = {}\n has_changed = False\n for k, v in obj.items():\n casted_v, has_changed_v = _cast_to_python_objects(\n v, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting\n )\n has_changed |= has_changed_v\n output[k] = casted_v\n return output if has_changed else obj, has_changed\n elif isinstance(obj, (list, tuple)):\n if len(obj) > 0:\n for first_elmt in obj:\n if _check_non_null_non_empty_recursive(first_elmt):\n break\n casted_first_elmt, has_changed_first_elmt = _cast_to_python_objects(\n first_elmt, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting\n )\n if has_changed_first_elmt or not optimize_list_casting:\n return [\n _cast_to_python_objects(\n elmt, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting\n )[0]\n for elmt in obj\n ], True\n else:\n if isinstance(obj, list):\n return obj, False\n else:\n return list(obj), True\n else:\n return obj if isinstance(obj, list) else [], isinstance(obj, tuple)\n else:\n return obj, False\n\n\ndef cast_to_python_objects(obj: Any, only_1d_for_numpy=False, optimize_list_casting=True) -> Any:\n \"\"\"\n Cast numpy/pytorch/tensorflow/pandas objects to python lists.\n It works recursively.\n\n If `optimize_list_casting` is True, To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be casted.\n If the first element needs to be casted, then all the elements of the list will be casted, otherwise they'll stay the same.\n This trick allows to cast objects that contain tokenizers outputs without iterating over every single token for example.\n\n Args:\n obj: the object (nested struct) to cast\n only_1d_for_numpy (bool, default ``False``): whether to keep the full multi-dim tensors as multi-dim numpy arrays, or convert them to\n nested lists of 1-dimensional numpy arrays. This can be useful to keep only 1-d arrays to instantiate Arrow arrays.\n Indeed Arrow only support converting 1-dimensional array values.\n optimize_list_casting (bool, default ``True``): whether to optimize list casting by checking the first non-null element to see if it needs to be casted\n and if it doesn't, not checking the rest of the list elements.\n\n Returns:\n casted_obj: the casted object\n \"\"\"\n return _cast_to_python_objects(\n obj, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting\n )[0]\n\n\n@dataclass\nclass Value:\n \"\"\"\n The Value dtypes are as follows:\n\n null\n bool\n int8\n int16\n int32\n int64\n uint8\n uint16\n uint32\n uint64\n float16\n float32 (alias float)\n float64 (alias double)\n time32[(s|ms)]\n time64[(us|ns)]\n timestamp[(s|ms|us|ns)]\n timestamp[(s|ms|us|ns), tz=(tzstring)]\n date32\n date64\n duration[(s|ms|us|ns)]\n decimal128(precision, scale)\n decimal256(precision, scale)\n binary\n large_binary\n string\n large_string\n \"\"\"\n\n dtype: str\n id: Optional[str] = None\n # Automatically constructed\n pa_type: ClassVar[Any] = None\n _type: str = field(default=\"Value\", init=False, repr=False)\n\n def __post_init__(self):\n if self.dtype == \"double\": # fix inferred type\n self.dtype = \"float64\"\n if self.dtype == \"float\": # fix inferred type\n self.dtype = \"float32\"\n self.pa_type = string_to_arrow(self.dtype)\n\n def __call__(self):\n return self.pa_type\n\n def encode_example(self, value):\n if pa.types.is_boolean(self.pa_type):\n return bool(value)\n elif pa.types.is_integer(self.pa_type):\n return int(value)\n elif pa.types.is_floating(self.pa_type):\n return float(value)\n elif pa.types.is_string(self.pa_type):\n return str(value)\n else:\n return value\n\n\nclass _ArrayXD:\n def __post_init__(self):\n self.shape = tuple(self.shape)\n\n def __call__(self):\n pa_type = globals()[self.__class__.__name__ + \"ExtensionType\"](self.shape, self.dtype)\n return pa_type\n\n def encode_example(self, value):\n if isinstance(value, np.ndarray):\n value = value.tolist()\n return value\n\n\n@dataclass\nclass Array2D(_ArrayXD):\n shape: tuple\n dtype: str\n id: Optional[str] = None\n # Automatically constructed\n _type: str = field(default=\"Array2D\", init=False, repr=False)\n\n\n@dataclass\nclass Array3D(_ArrayXD):\n shape: tuple\n dtype: str\n id: Optional[str] = None\n # Automatically constructed\n _type: str = field(default=\"Array3D\", init=False, repr=False)\n\n\n@dataclass\nclass Array4D(_ArrayXD):\n shape: tuple\n dtype: str\n id: Optional[str] = None\n # Automatically constructed\n _type: str = field(default=\"Array4D\", init=False, repr=False)\n\n\n@dataclass\nclass Array5D(_ArrayXD):\n shape: tuple\n dtype: str\n id: Optional[str] = None\n # Automatically constructed\n _type: str = field(default=\"Array5D\", init=False, repr=False)\n\n\nclass _ArrayXDExtensionType(pa.PyExtensionType):\n ndims: Optional[int] = None\n\n def __init__(self, shape: tuple, dtype: str):\n if self.ndims is None or self.ndims <= 1:\n raise ValueError(\"You must instantiate an array type with a value for dim that is > 1\")\n if len(shape) != self.ndims:\n raise ValueError(f\"shape={shape} and ndims={self.ndims} don't match\")\n self.shape = tuple(shape)\n self.value_type = dtype\n self.storage_dtype = self._generate_dtype(self.value_type)\n pa.PyExtensionType.__init__(self, self.storage_dtype)\n\n def __reduce__(self):\n return self.__class__, (\n self.shape,\n self.value_type,\n )\n\n def __arrow_ext_class__(self):\n return ArrayExtensionArray\n\n def _generate_dtype(self, dtype):\n dtype = string_to_arrow(dtype)\n for d in reversed(self.shape):\n dtype = pa.list_(dtype)\n # Don't specify the size of the list, since fixed length list arrays have issues\n # being validated after slicing in pyarrow 0.17.1\n return dtype\n\n def to_pandas_dtype(self):\n return PandasArrayExtensionDtype(self.value_type)\n\n\nclass Array2DExtensionType(_ArrayXDExtensionType):\n ndims = 2\n\n\nclass Array3DExtensionType(_ArrayXDExtensionType):\n ndims = 3\n\n\nclass Array4DExtensionType(_ArrayXDExtensionType):\n ndims = 4\n\n\nclass Array5DExtensionType(_ArrayXDExtensionType):\n ndims = 5\n\n\ndef _is_zero_copy_only(pa_type: pa.DataType, unnest: bool = False) -> bool:\n \"\"\"\n When converting a pyarrow array to a numpy array, we must know whether this could be done in zero-copy or not.\n This function returns the value of the ``zero_copy_only`` parameter to pass to ``.to_numpy()``, given the type of the pyarrow array.\n\n # zero copy is available for all primitive types except booleans\n # primitive types are types for which the physical representation in arrow and in numpy\n # https://github.com/wesm/arrow/blob/c07b9b48cf3e0bbbab493992a492ae47e5b04cad/python/pyarrow/types.pxi#L821\n # see https://arrow.apache.org/docs/python/generated/pyarrow.Array.html#pyarrow.Array.to_numpy\n # and https://issues.apache.org/jira/browse/ARROW-2871?jql=text%20~%20%22boolean%20to_numpy%22\n \"\"\"\n\n def _unnest_pa_type(pa_type: pa.DataType) -> pa.DataType:\n if pa.types.is_list(pa_type):\n return _unnest_pa_type(pa_type.value_type)\n return pa_type\n\n if unnest:\n pa_type = _unnest_pa_type(pa_type)\n return pa.types.is_primitive(pa_type) and not pa.types.is_boolean(pa_type)\n\n\nclass ArrayExtensionArray(pa.ExtensionArray):\n def __array__(self):\n zero_copy_only = _is_zero_copy_only(self.storage.type, unnest=True)\n return self.to_numpy(zero_copy_only=zero_copy_only)\n\n def __getitem__(self, i):\n return self.storage[i]\n\n def to_numpy(self, zero_copy_only=True):\n storage: pa.ListArray = self.storage\n size = 1\n\n null_indices = np.arange(len(storage))[storage.is_null().to_numpy(zero_copy_only=False)]\n\n for i in range(self.type.ndims):\n size *= self.type.shape[i]\n storage = storage.flatten()\n numpy_arr = storage.to_numpy(zero_copy_only=zero_copy_only)\n numpy_arr = numpy_arr.reshape(len(self) - len(null_indices), *self.type.shape)\n\n if len(null_indices):\n numpy_arr = np.insert(numpy_arr.astype(np.float64), null_indices, np.nan, axis=0)\n\n return numpy_arr\n\n def to_list_of_numpy(self, zero_copy_only=True):\n storage: pa.ListArray = self.storage\n shape = self.type.shape\n ndims = self.type.ndims\n\n for dim in range(1, ndims):\n if shape[dim] is None:\n raise ValueError(f\"Support only dynamic size on first dimension. Got: {shape}\")\n\n arrays = []\n first_dim_offsets = np.array([off.as_py() for off in storage.offsets])\n for i, is_null in enumerate(storage.is_null().to_numpy(zero_copy_only=False)):\n if is_null:\n arrays.append(np.nan)\n else:\n storage_el = storage[i : i + 1]\n first_dim = first_dim_offsets[i + 1] - first_dim_offsets[i]\n # flatten storage\n for _ in range(ndims):\n storage_el = storage_el.flatten()\n\n numpy_arr = storage_el.to_numpy(zero_copy_only=zero_copy_only)\n arrays.append(numpy_arr.reshape(first_dim, *shape[1:]))\n\n return arrays\n\n def to_pylist(self):\n zero_copy_only = _is_zero_copy_only(self.storage.type, unnest=True)\n if self.type.shape[0] is None:\n return self.to_list_of_numpy(zero_copy_only=zero_copy_only)\n else:\n return self.to_numpy(zero_copy_only=zero_copy_only).tolist()\n\n\nclass PandasArrayExtensionDtype(PandasExtensionDtype):\n _metadata = \"value_type\"\n\n def __init__(self, value_type: Union[\"PandasArrayExtensionDtype\", np.dtype]):\n self._value_type = value_type\n\n def __from_arrow__(self, array: Union[pa.Array, pa.ChunkedArray]):\n if array.type.shape[0] is None:\n raise NotImplementedError(\n \"Dynamic first dimension is not supported for \"\n f\"PandasArrayExtensionDtype, dimension: {array.type.shape}\"\n )\n zero_copy_only = _is_zero_copy_only(array.type, unnest=True)\n if isinstance(array, pa.ChunkedArray):\n numpy_arr = np.vstack([chunk.to_numpy(zero_copy_only=zero_copy_only) for chunk in array.chunks])\n else:\n numpy_arr = array.to_numpy(zero_copy_only=zero_copy_only)\n return PandasArrayExtensionArray(numpy_arr)\n\n @classmethod\n def construct_array_type(cls):\n return PandasArrayExtensionArray\n\n @property\n def type(self) -> type:\n return np.ndarray\n\n @property\n def kind(self) -> str:\n return \"O\"\n\n @property\n def name(self) -> str:\n return f\"array[{self.value_type}]\"\n\n @property\n def value_type(self) -> np.dtype:\n return self._value_type\n\n\nclass PandasArrayExtensionArray(PandasExtensionArray):\n def __init__(self, data: np.ndarray, copy: bool = False):\n self._data = data if not copy else np.array(data)\n self._dtype = PandasArrayExtensionDtype(data.dtype)\n\n def __array__(self, dtype=None):\n \"\"\"\n Convert to NumPy Array.\n Note that Pandas expects a 1D array when dtype is set to object.\n But for other dtypes, the returned shape is the same as the one of ``data``.\n\n More info about pandas 1D requirement for PandasExtensionArray here:\n https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.api.extensions.ExtensionArray.html#pandas.api.extensions.ExtensionArray\n\n \"\"\"\n if dtype == object:\n out = np.empty(len(self._data), dtype=object)\n for i in range(len(self._data)):\n out[i] = self._data[i]\n return out\n if dtype is None:\n return self._data\n else:\n return self._data.astype(dtype)\n\n def copy(self, deep: bool = False) -> \"PandasArrayExtensionArray\":\n return PandasArrayExtensionArray(self._data, copy=True)\n\n @classmethod\n def _from_sequence(\n cls, scalars, dtype: Optional[PandasArrayExtensionDtype] = None, copy: bool = False\n ) -> \"PandasArrayExtensionArray\":\n data = np.array(scalars, dtype=dtype if dtype is None else dtype.value_type, copy=copy)\n return cls(data, copy=copy)\n\n @classmethod\n def _concat_same_type(cls, to_concat: Sequence_[\"PandasArrayExtensionArray\"]) -> \"PandasArrayExtensionArray\":\n data = np.vstack([va._data for va in to_concat])\n return cls(data, copy=False)\n\n @property\n def dtype(self) -> PandasArrayExtensionDtype:\n return self._dtype\n\n @property\n def nbytes(self) -> int:\n return self._data.nbytes\n\n def isna(self) -> np.ndarray:\n return np.array([pd.isna(arr).any() for arr in self._data])\n\n def __setitem__(self, key: Union[int, slice, np.ndarray], value: Any) -> None:\n raise NotImplementedError()\n\n def __getitem__(self, item: Union[int, slice, np.ndarray]) -> Union[np.ndarray, \"PandasArrayExtensionArray\"]:\n if isinstance(item, int):\n return self._data[item]\n return PandasArrayExtensionArray(self._data[item], copy=False)\n\n def take(\n self, indices: Sequence_[int], allow_fill: bool = False, fill_value: bool = None\n ) -> \"PandasArrayExtensionArray\":\n indices: np.ndarray = np.asarray(indices, dtype=np.int)\n if allow_fill:\n fill_value = (\n self.dtype.na_value if fill_value is None else np.asarray(fill_value, dtype=self.dtype.value_type)\n )\n mask = indices == -1\n if (indices < -1).any():\n raise ValueError(\"Invalid value in `indices`, must be all >= -1 for `allow_fill` is True\")\n elif len(self) > 0:\n pass\n elif not np.all(mask):\n raise IndexError(\"Invalid take for empty PandasArrayExtensionArray, must be all -1.\")\n else:\n data = np.array([fill_value] * len(indices), dtype=self.dtype.value_type)\n return PandasArrayExtensionArray(data, copy=False)\n took = self._data.take(indices, axis=0)\n if allow_fill and mask.any():\n took[mask] = [fill_value] * np.sum(mask)\n return PandasArrayExtensionArray(took, copy=False)\n\n def __len__(self) -> int:\n return len(self._data)\n\n def __eq__(self, other) -> np.ndarray:\n if not isinstance(other, PandasArrayExtensionArray):\n raise NotImplementedError(f\"Invalid type to compare to: {type(other)}\")\n return (self._data == other._data).all()\n\n\ndef pandas_types_mapper(dtype):\n if isinstance(dtype, _ArrayXDExtensionType):\n return PandasArrayExtensionDtype(dtype.value_type)\n\n\n@dataclass\nclass ClassLabel:\n \"\"\"Feature type for integer class labels.\n\n There are 3 ways to define a `ClassLabel`, which correspond to the 3 arguments:\n\n * `num_classes`: Create 0 to (num_classes-1) labels.\n * `names`: List of label strings.\n * `names_file`: File containing the list of labels.\n\n Args:\n num_classes (:obj:`int`, optional): Number of classes. All labels must be < `num_classes`.\n names (:obj:`list` of :obj:`str`, optional): String names for the integer classes.\n The order in which the names are provided is kept.\n names_file (:obj:`str`, optional): Path to a file with names for the integer classes, one per line.\n \"\"\"\n\n num_classes: int = None\n names: List[str] = None\n names_file: InitVar[Optional[str]] = None # Pseudo-field: ignored by asdict/fields when converting to/from dict\n id: Optional[str] = None\n # Automatically constructed\n dtype: ClassVar[str] = \"int64\"\n pa_type: ClassVar[Any] = pa.int64()\n _str2int: ClassVar[Dict[str, int]] = None\n _int2str: ClassVar[Dict[int, int]] = None\n _type: str = field(default=\"ClassLabel\", init=False, repr=False)\n\n def __post_init__(self, names_file):\n self.names_file = names_file\n if self.names_file is not None and self.names is not None:\n raise ValueError(\"Please provide either names or names_file but not both.\")\n # Set self.names\n if self.names is None:\n if self.names_file is not None:\n self.names = self._load_names_from_file(self.names_file)\n elif self.num_classes is not None:\n self.names = [str(i) for i in range(self.num_classes)]\n else:\n raise ValueError(\"Please provide either num_classes, names or names_file.\")\n # Set self.num_classes\n if self.num_classes is None:\n self.num_classes = len(self.names)\n elif self.num_classes != len(self.names):\n raise ValueError(\n \"ClassLabel number of names do not match the defined num_classes. \"\n f\"Got {len(self.names)} names VS {self.num_classes} num_classes\"\n )\n # Prepare mappings\n self._int2str = [str(name) for name in self.names]\n self._str2int = {name: i for i, name in enumerate(self._int2str)}\n if len(self._int2str) != len(self._str2int):\n raise ValueError(\"Some label names are duplicated. Each label name should be unique.\")\n\n def __call__(self):\n return self.pa_type\n\n def str2int(self, values: Union[str, Iterable]):\n \"\"\"Conversion class name string => integer.\"\"\"\n if not isinstance(values, str) and not isinstance(values, Iterable):\n raise ValueError(\n f\"Values {values} should be a string or an Iterable (list, numpy array, pytorch, tensorflow tensors)\"\n )\n return_list = True\n if isinstance(values, str):\n values = [values]\n return_list = False\n\n output = []\n for value in values:\n if self._str2int:\n # strip key if not in dict\n if value not in self._str2int:\n value = str(value).strip()\n output.append(self._str2int[str(value)])\n else:\n # No names provided, try to integerize\n failed_parse = False\n try:\n output.append(int(value))\n except ValueError:\n failed_parse = True\n if failed_parse or not 0 <= value < self.num_classes:\n raise ValueError(f\"Invalid string class label {value}\")\n return output if return_list else output[0]\n\n def int2str(self, values: Union[int, Iterable]):\n \"\"\"Conversion integer => class name string.\"\"\"\n if not isinstance(values, int) and not isinstance(values, Iterable):\n raise ValueError(\n f\"Values {values} should be an integer or an Iterable (list, numpy array, pytorch, tensorflow tensors)\"\n )\n return_list = True\n if isinstance(values, int):\n values = [values]\n return_list = False\n\n for v in values:\n if not 0 <= v < self.num_classes:\n raise ValueError(f\"Invalid integer class label {v:d}\")\n\n if self._int2str:\n output = [self._int2str[int(v)] for v in values]\n else:\n # No names provided, return str(values)\n output = [str(v) for v in values]\n return output if return_list else output[0]\n\n def encode_example(self, example_data):\n if self.num_classes is None:\n raise ValueError(\n \"Trying to use ClassLabel feature with undefined number of class. \"\n \"Please set ClassLabel.names or num_classes.\"\n )\n\n # If a string is given, convert to associated integer\n if isinstance(example_data, str):\n example_data = self.str2int(example_data)\n\n # Allowing -1 to mean no label.\n if not -1 <= example_data < self.num_classes:\n raise ValueError(f\"Class label {example_data:d} greater than configured num_classes {self.num_classes}\")\n return example_data\n\n @staticmethod\n def _load_names_from_file(names_filepath):\n with open(names_filepath, encoding=\"utf-8\") as f:\n return [name.strip() for name in f.read().split(\"\\n\") if name.strip()] # Filter empty names\n\n\n@dataclass\nclass Sequence:\n \"\"\"Construct a list of feature from a single type or a dict of types.\n Mostly here for compatiblity with tfds.\n \"\"\"\n\n feature: Any\n length: int = -1\n id: Optional[str] = None\n # Automatically constructed\n dtype: ClassVar[str] = \"list\"\n pa_type: ClassVar[Any] = None\n _type: str = field(default=\"Sequence\", init=False, repr=False)\n\n\nFeatureType = Union[\n dict,\n list,\n tuple,\n Value,\n ClassLabel,\n Translation,\n TranslationVariableLanguages,\n Sequence,\n Array2D,\n Array3D,\n Array4D,\n Array5D,\n Audio,\n Image,\n]\n\n\ndef _check_non_null_non_empty_recursive(obj, schema: Optional[FeatureType] = None) -> bool:\n \"\"\"\n Check if the object is not None.\n If the object is a list or a tuple, recursively check the first element of the sequence and stop if at any point the first element is not a sequence or is an empty sequence.\n \"\"\"\n if obj is None:\n return False\n elif isinstance(obj, (list, tuple)) and (schema is None or isinstance(schema, (list, tuple, Sequence))):\n if len(obj) > 0:\n if schema is None:\n pass\n elif isinstance(schema, (list, tuple)):\n schema = schema[0]\n else:\n schema = schema.feature\n return _check_non_null_non_empty_recursive(obj[0], schema)\n else:\n return False\n else:\n return True\n\n\ndef get_nested_type(schema: FeatureType) -> pa.DataType:\n \"\"\"\n get_nested_type() converts a datasets.FeatureType into a pyarrow.DataType, and acts as the inverse of\n generate_from_arrow_type().\n\n It performs double-duty as the implementation of Features.type and handles the conversion of\n datasets.Feature->pa.struct\n \"\"\"\n # Nested structures: we allow dict, list/tuples, sequences\n if isinstance(schema, Features):\n return pa.struct(\n {key: get_nested_type(schema[key]) for key in schema}\n ) # Features is subclass of dict, and dict order is deterministic since Python 3.6\n elif isinstance(schema, dict):\n return pa.struct(\n {key: get_nested_type(schema[key]) for key in schema}\n ) # however don't sort on struct types since the order matters\n elif isinstance(schema, (list, tuple)):\n if len(schema) != 1:\n raise ValueError(\"We defining list feature, you should just provide one example of the inner type\")\n value_type = get_nested_type(schema[0])\n return pa.list_(value_type)\n elif isinstance(schema, Sequence):\n value_type = get_nested_type(schema.feature)\n # We allow to reverse list of dict => dict of list for compatibility with tfds\n if isinstance(schema.feature, dict):\n return pa.struct({f.name: pa.list_(f.type, schema.length) for f in value_type})\n return pa.list_(value_type, schema.length)\n\n # Other objects are callable which returns their data type (ClassLabel, Array2D, Translation, Arrow datatype creation methods)\n return schema()\n\n\ndef encode_nested_example(schema, obj):\n \"\"\"Encode a nested example.\n This is used since some features (in particular ClassLabel) have some logic during encoding.\n\n To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be encoded.\n If the first element needs to be encoded, then all the elements of the list will be encoded, otherwise they'll stay the same.\n \"\"\"\n # Nested structures: we allow dict, list/tuples, sequences\n if isinstance(schema, dict):\n return {k: encode_nested_example(sub_schema, sub_obj) for k, (sub_schema, sub_obj) in zip_dict(schema, obj)}\n elif isinstance(schema, (list, tuple)):\n sub_schema = schema[0]\n if obj is None:\n return None\n else:\n if len(obj) > 0:\n for first_elmt in obj:\n if _check_non_null_non_empty_recursive(first_elmt, sub_schema):\n break\n if encode_nested_example(sub_schema, first_elmt) != first_elmt:\n return [encode_nested_example(sub_schema, o) for o in obj]\n return list(obj)\n elif isinstance(schema, Sequence):\n if obj is None:\n return None\n # We allow to reverse list of dict => dict of list for compatiblity with tfds\n if isinstance(schema.feature, dict):\n # dict of list to fill\n list_dict = {}\n if isinstance(obj, (list, tuple)):\n # obj is a list of dict\n for k, dict_tuples in zip_dict(schema.feature, *obj):\n list_dict[k] = [encode_nested_example(dict_tuples[0], o) for o in dict_tuples[1:]]\n return list_dict\n else:\n # obj is a single dict\n for k, (sub_schema, sub_objs) in zip_dict(schema.feature, obj):\n list_dict[k] = [encode_nested_example(sub_schema, o) for o in sub_objs]\n return list_dict\n # schema.feature is not a dict\n if isinstance(obj, str): # don't interpret a string as a list\n raise ValueError(f\"Got a string but expected a list instead: '{obj}'\")\n else:\n if len(obj) > 0:\n for first_elmt in obj:\n if _check_non_null_non_empty_recursive(first_elmt, schema.feature):\n break\n # be careful when comparing tensors here\n if not isinstance(first_elmt, list) or encode_nested_example(schema.feature, first_elmt) != first_elmt:\n return [encode_nested_example(schema.feature, o) for o in obj]\n return list(obj)\n # Object with special encoding:\n # ClassLabel will convert from string to int, TranslationVariableLanguages does some checks\n elif isinstance(schema, (Audio, Image, ClassLabel, TranslationVariableLanguages, Value, _ArrayXD)):\n return schema.encode_example(obj) if obj is not None else None\n # Other object should be directly convertible to a native Arrow type (like Translation and Translation)\n return obj\n\n\ndef decode_nested_example(schema, obj):\n \"\"\"Decode a nested example.\n This is used since some features (in particular Audio and Image) have some logic during decoding.\n\n To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be decoded.\n If the first element needs to be decoded, then all the elements of the list will be decoded, otherwise they'll stay the same.\n \"\"\"\n # Nested structures: we allow dict, list/tuples, sequences\n if isinstance(schema, dict):\n return {k: decode_nested_example(sub_schema, sub_obj) for k, (sub_schema, sub_obj) in zip_dict(schema, obj)}\n elif isinstance(schema, (list, tuple)):\n sub_schema = schema[0]\n if obj is None:\n return None\n else:\n if len(obj) > 0:\n for first_elmt in obj:\n if _check_non_null_non_empty_recursive(first_elmt, sub_schema):\n break\n if decode_nested_example(sub_schema, first_elmt) != first_elmt:\n return [decode_nested_example(sub_schema, o) for o in obj]\n return list(obj)\n elif isinstance(schema, Sequence):\n # We allow to reverse list of dict => dict of list for compatiblity with tfds\n if isinstance(schema.feature, dict):\n return {k: decode_nested_example([schema.feature[k]], obj[k]) for k in schema.feature}\n else:\n return decode_nested_example([schema.feature], obj)\n # Object with special decoding:\n elif isinstance(schema, (Audio, Image)):\n return schema.decode_example(obj) if obj is not None else None\n return obj\n\n\ndef generate_from_dict(obj: Any):\n \"\"\"Regenerate the nested feature object from a deserialized dict.\n We use the '_type' fields to get the dataclass name to load.\n\n generate_from_dict is the recursive helper for Features.from_dict, and allows for a convenient constructor syntax\n to define features from deserialized JSON dictionaries. This function is used in particular when deserializing\n a :class:`DatasetInfo` that was dumped to a JSON object. This acts as an analogue to\n :meth:`Features.from_arrow_schema` and handles the recursive field-by-field instantiation, but doesn't require any\n mapping to/from pyarrow, except for the fact that it takes advantage of the mapping of pyarrow primitive dtypes\n that :class:`Value` automatically performs.\n \"\"\"\n # Nested structures: we allow dict, list/tuples, sequences\n if isinstance(obj, list):\n return [generate_from_dict(value) for value in obj]\n # Otherwise we have a dict or a dataclass\n if \"_type\" not in obj or isinstance(obj[\"_type\"], dict):\n return {key: generate_from_dict(value) for key, value in obj.items()}\n class_type = globals()[obj.pop(\"_type\")]\n\n if class_type == Sequence:\n return Sequence(feature=generate_from_dict(obj[\"feature\"]), length=obj[\"length\"])\n\n field_names = {f.name for f in fields(class_type)}\n return class_type(**{k: v for k, v in obj.items() if k in field_names})\n\n\ndef generate_from_arrow_type(pa_type: pa.DataType) -> FeatureType:\n \"\"\"\n generate_from_arrow_type accepts an arrow DataType and returns a datasets FeatureType to be used as the type for\n a single field.\n\n This is the high-level arrow->datasets type conversion and is inverted by get_nested_type().\n\n This operates at the individual *field* level, whereas Features.from_arrow_schema() operates at the\n full schema level and holds the methods that represent the bijection from Features<->pyarrow.Schema\n \"\"\"\n if isinstance(pa_type, pa.StructType):\n return {field.name: generate_from_arrow_type(field.type) for field in pa_type}\n elif isinstance(pa_type, pa.FixedSizeListType):\n return Sequence(feature=generate_from_arrow_type(pa_type.value_type), length=pa_type.list_size)\n elif isinstance(pa_type, pa.ListType):\n feature = generate_from_arrow_type(pa_type.value_type)\n if isinstance(feature, (dict, tuple, list)):\n return [feature]\n return Sequence(feature=feature)\n elif isinstance(pa_type, _ArrayXDExtensionType):\n array_feature = [None, None, Array2D, Array3D, Array4D, Array5D][pa_type.ndims]\n return array_feature(shape=pa_type.shape, dtype=pa_type.value_type)\n elif isinstance(pa_type, pa.DictionaryType):\n raise NotImplementedError # TODO(thom) this will need access to the dictionary as well (for labels). I.e. to the py_table\n elif isinstance(pa_type, pa.DataType):\n return Value(dtype=_arrow_to_datasets_dtype(pa_type))\n else:\n raise ValueError(f\"Cannot convert {pa_type} to a Feature type.\")\n\n\ndef numpy_to_pyarrow_listarray(arr: np.ndarray, type: pa.DataType = None) -> pa.ListArray:\n \"\"\"Build a PyArrow ListArray from a multidimensional NumPy array\"\"\"\n arr = np.array(arr)\n values = pa.array(arr.flatten(), type=type)\n for i in range(arr.ndim - 1):\n n_offsets = reduce(mul, arr.shape[: arr.ndim - i - 1], 1)\n step_offsets = arr.shape[arr.ndim - i - 1]\n offsets = pa.array(np.arange(n_offsets + 1) * step_offsets, type=pa.int32())\n values = pa.ListArray.from_arrays(offsets, values)\n return values\n\n\ndef list_of_pa_arrays_to_pyarrow_listarray(l_arr: List[Optional[pa.Array]]) -> pa.ListArray:\n null_indices = [i for i, arr in enumerate(l_arr) if arr is None]\n l_arr = [arr for arr in l_arr if arr is not None]\n offsets = np.cumsum(\n [0] + [len(arr) for arr in l_arr], dtype=np.object\n ) # convert to dtype object to allow None insertion\n offsets = np.insert(offsets, null_indices, None)\n offsets = pa.array(offsets, type=pa.int32())\n values = pa.concat_arrays(l_arr)\n return pa.ListArray.from_arrays(offsets, values)\n\n\ndef list_of_np_array_to_pyarrow_listarray(l_arr: List[np.ndarray], type: pa.DataType = None) -> pa.ListArray:\n \"\"\"Build a PyArrow ListArray from a possibly nested list of NumPy arrays\"\"\"\n if len(l_arr) > 0:\n return list_of_pa_arrays_to_pyarrow_listarray(\n [numpy_to_pyarrow_listarray(arr, type=type) if arr is not None else None for arr in l_arr]\n )\n else:\n return pa.array([], type=type)\n\n\ndef require_decoding(feature: FeatureType, ignore_decode_attribute: bool = False) -> bool:\n \"\"\"Check if a (possibly nested) feature requires decoding.\n\n Args:\n feature (FeatureType): the feature type to be checked\n ignore_decode_attribute (:obj:`bool`, default ``False``): Whether to ignore the current value\n of the `decode` attribute of the decodable feature types.\n Returns:\n :obj:`bool`\n \"\"\"\n if isinstance(feature, dict):\n return any(require_decoding(f) for f in feature.values())\n elif isinstance(feature, (list, tuple)):\n return require_decoding(feature[0])\n elif isinstance(feature, Sequence):\n return require_decoding(feature.feature)\n else:\n return hasattr(feature, \"decode_example\") and (feature.decode if not ignore_decode_attribute else True)\n\n\ndef keep_features_dicts_synced(func):\n \"\"\"\n Wrapper to keep the secondary dictionary, which tracks whether keys are decodable, of the :class:`datasets.Features` object\n in sync with the main dictionary.\n \"\"\"\n\n @wraps(func)\n def wrapper(*args, **kwargs):\n if args:\n self: \"Features\" = args[0]\n args = args[1:]\n else:\n self: \"Features\" = kwargs.pop(\"self\")\n out = func(self, *args, **kwargs)\n assert hasattr(self, \"_column_requires_decoding\")\n self._column_requires_decoding = {col: require_decoding(feature) for col, feature in self.items()}\n return out\n\n wrapper._decorator_name_ = \"_keep_dicts_synced\"\n return wrapper\n\n\nclass Features(dict):\n \"\"\"A special dictionary that defines the internal structure of a dataset.\n\n Instantiated with a dictionary of type ``dict[str, FieldType]``, where keys are the desired column names,\n and values are the type of that column.\n\n ``FieldType`` can be one of the following:\n - a :class:`datasets.Value` feature specifies a single typed value, e.g. ``int64`` or ``string``\n - a :class:`datasets.ClassLabel` feature specifies a field with a predefined set of classes which can have labels\n associated to them and will be stored as integers in the dataset\n - a python :obj:`dict` which specifies that the field is a nested field containing a mapping of sub-fields to sub-fields\n features. It's possible to have nested fields of nested fields in an arbitrary manner\n - a python :obj:`list` or a :class:`datasets.Sequence` specifies that the field contains a list of objects. The python\n :obj:`list` or :class:`datasets.Sequence` should be provided with a single sub-feature as an example of the feature\n type hosted in this list\n\n <Tip>\n\n A :class:`datasets.Sequence` with a internal dictionary feature will be automatically converted into a dictionary of\n lists. This behavior is implemented to have a compatilbity layer with the TensorFlow Datasets library but may be\n un-wanted in some cases. If you don't want this behavior, you can use a python :obj:`list` instead of the\n :class:`datasets.Sequence`.\n\n </Tip>\n\n - a :class:`Array2D`, :class:`Array3D`, :class:`Array4D` or :class:`Array5D` feature for multidimensional arrays\n - an :class:`Audio` feature to store the absolute path to an audio file or a dictionary with the relative path\n to an audio file (\"path\" key) and its bytes content (\"bytes\" key). This feature extracts the audio data.\n - an :class:`Image` feature to store the absolute path to an image file, an :obj:`np.ndarray` object, a :obj:`PIL.Image.Image` object\n or a dictionary with the relative path to an image file (\"path\" key) and its bytes content (\"bytes\" key). This feature extracts the image data.\n - :class:`datasets.Translation` and :class:`datasets.TranslationVariableLanguages`, the two features specific to Machine Translation\n \"\"\"\n\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self._column_requires_decoding: Dict[str, bool] = {\n col: require_decoding(feature) for col, feature in self.items()\n }\n\n __setitem__ = keep_features_dicts_synced(dict.__setitem__)\n __delitem__ = keep_features_dicts_synced(dict.__delitem__)\n update = keep_features_dicts_synced(dict.update)\n setdefault = keep_features_dicts_synced(dict.setdefault)\n pop = keep_features_dicts_synced(dict.pop)\n popitem = keep_features_dicts_synced(dict.popitem)\n clear = keep_features_dicts_synced(dict.clear)\n\n def __reduce__(self):\n return Features, (dict(self),)\n\n @property\n def type(self):\n \"\"\"\n Features field types.\n\n Returns:\n :obj:`pyarrow.DataType`\n \"\"\"\n return get_nested_type(self)\n\n @property\n def arrow_schema(self):\n \"\"\"\n Features schema.\n\n Returns:\n :obj:`pyarrow.Schema`\n \"\"\"\n hf_metadata = {\"info\": {\"features\": self.to_dict()}}\n return pa.schema(self.type).with_metadata({\"huggingface\": json.dumps(hf_metadata)})\n\n @classmethod\n def from_arrow_schema(cls, pa_schema: pa.Schema) -> \"Features\":\n \"\"\"\n Construct Features from Arrow Schema.\n It also checks the schema metadata for Hugging Face Datasets features.\n\n Args:\n pa_schema (:obj:`pyarrow.Schema`): Arrow Schema.\n\n Returns:\n :class:`Features`\n \"\"\"\n # try to load features from the arrow schema metadata\n if pa_schema.metadata is not None and \"huggingface\".encode(\"utf-8\") in pa_schema.metadata:\n metadata = json.loads(pa_schema.metadata[\"huggingface\".encode(\"utf-8\")].decode())\n if \"info\" in metadata and \"features\" in metadata[\"info\"] and metadata[\"info\"][\"features\"] is not None:\n return Features.from_dict(metadata[\"info\"][\"features\"])\n obj = {field.name: generate_from_arrow_type(field.type) for field in pa_schema}\n return cls(**obj)\n\n @classmethod\n def from_dict(cls, dic) -> \"Features\":\n \"\"\"\n Construct Features from dict.\n\n Regenerate the nested feature object from a deserialized dict.\n We use the '_type' key to infer the dataclass name of the feature FieldType.\n\n It allows for a convenient constructor syntax\n to define features from deserialized JSON dictionaries. This function is used in particular when deserializing\n a :class:`DatasetInfo` that was dumped to a JSON object. This acts as an analogue to\n :meth:`Features.from_arrow_schema` and handles the recursive field-by-field instantiation, but doesn't require\n any mapping to/from pyarrow, except for the fact that it takes advantage of the mapping of pyarrow primitive\n dtypes that :class:`Value` automatically performs.\n\n Args:\n dic (:obj:`dict[str, Any]`): Python dictionary.\n\n Returns:\n :class:`Features`\n\n Example::\n >>> Features.from_dict({'_type': {'dtype': 'string', 'id': None, '_type': 'Value'}})\n {'_type': Value(dtype='string', id=None)}\n \"\"\"\n obj = generate_from_dict(dic)\n return cls(**obj)\n\n def to_dict(self):\n return _asdict_inner(self, dict)\n\n def encode_example(self, example):\n \"\"\"\n Encode example into a format for Arrow.\n\n Args:\n example (:obj:`dict[str, Any]`): Data in a Dataset row.\n\n Returns:\n :obj:`dict[str, Any]`\n \"\"\"\n example = cast_to_python_objects(example)\n return encode_nested_example(self, example)\n\n def encode_batch(self, batch):\n \"\"\"\n Encode batch into a format for Arrow.\n\n Args:\n batch (:obj:`dict[str, list[Any]]`): Data in a Dataset batch.\n\n Returns:\n :obj:`dict[str, list[Any]]`\n \"\"\"\n encoded_batch = {}\n if set(batch) != set(self):\n raise ValueError(f\"Column mismatch between batch {set(batch)} and features {set(self)}\")\n for key, column in batch.items():\n column = cast_to_python_objects(column)\n encoded_batch[key] = [encode_nested_example(self[key], obj) for obj in column]\n return encoded_batch\n\n def decode_example(self, example: dict):\n \"\"\"Decode example with custom feature decoding.\n\n Args:\n example (:obj:`dict[str, Any]`): Dataset row data.\n\n Returns:\n :obj:`dict[str, Any]`\n \"\"\"\n\n return {\n column_name: decode_nested_example(feature, value)\n if self._column_requires_decoding[column_name]\n else value\n for column_name, (feature, value) in zip_dict(\n {key: value for key, value in self.items() if key in example}, example\n )\n }\n\n def decode_column(self, column: list, column_name: str):\n \"\"\"Decode column with custom feature decoding.\n\n Args:\n column (:obj:`list[Any]`): Dataset column data.\n column_name (:obj:`str`): Dataset column name.\n\n Returns:\n :obj:`list[Any]`\n \"\"\"\n return (\n [decode_nested_example(self[column_name], value) if value is not None else None for value in column]\n if self._column_requires_decoding[column_name]\n else column\n )\n\n def decode_batch(self, batch: dict):\n \"\"\"Decode batch with custom feature decoding.\n\n Args:\n batch (:obj:`dict[str, list[Any]]`): Dataset batch data.\n\n Returns:\n :obj:`dict[str, list[Any]]`\n \"\"\"\n decoded_batch = {}\n for column_name, column in batch.items():\n decoded_batch[column_name] = (\n [decode_nested_example(self[column_name], value) if value is not None else None for value in column]\n if self._column_requires_decoding[column_name]\n else column\n )\n return decoded_batch\n\n def copy(self) -> \"Features\":\n \"\"\"\n Make a deep copy of Features.\n\n Returns:\n :class:`Features`\n \"\"\"\n return copy.deepcopy(self)\n\n def reorder_fields_as(self, other: \"Features\") -> \"Features\":\n \"\"\"\n Reorder Features fields to match the field order of other Features.\n\n The order of the fields is important since it matters for the underlying arrow data.\n Re-ordering the fields allows to make the underlying arrow data type match.\n\n Args:\n other (:class:`Features`): The other Features to align with.\n\n Returns:\n :class:`Features`\n\n Example::\n\n >>> from datasets import Features, Sequence, Value\n >>> # let's say we have to features with a different order of nested fields (for a and b for example)\n >>> f1 = Features({\"root\": Sequence({\"a\": Value(\"string\"), \"b\": Value(\"string\")})})\n >>> f2 = Features({\"root\": {\"b\": Sequence(Value(\"string\")), \"a\": Sequence(Value(\"string\"))}})\n >>> assert f1.type != f2.type\n >>> # re-ordering keeps the base structure (here Sequence is defined at the root level), but make the fields order match\n >>> f1.reorder_fields_as(f2)\n {'root': Sequence(feature={'b': Value(dtype='string', id=None), 'a': Value(dtype='string', id=None)}, length=-1, id=None)}\n >>> assert f1.reorder_fields_as(f2).type == f2.type\n \"\"\"\n\n def recursive_reorder(source, target, stack=\"\"):\n stack_position = \" at \" + stack[1:] if stack else \"\"\n if isinstance(target, Sequence):\n target = target.feature\n if isinstance(target, dict):\n target = {k: [v] for k, v in target.items()}\n else:\n target = [target]\n if isinstance(source, Sequence):\n source, id_, length = source.feature, source.id, source.length\n if isinstance(source, dict):\n source = {k: [v] for k, v in source.items()}\n reordered = recursive_reorder(source, target, stack)\n return Sequence({k: v[0] for k, v in reordered.items()}, id=id_, length=length)\n else:\n source = [source]\n reordered = recursive_reorder(source, target, stack)\n return Sequence(reordered[0], id=id_, length=length)\n elif isinstance(source, dict):\n if not isinstance(target, dict):\n raise ValueError(f\"Type mismatch: between {source} and {target}\" + stack_position)\n if sorted(source) != sorted(target):\n raise ValueError(f\"Keys mismatch: between {source} and {target}\" + stack_position)\n return {key: recursive_reorder(source[key], target[key], stack + f\".{key}\") for key in target}\n elif isinstance(source, list):\n if not isinstance(target, list):\n raise ValueError(f\"Type mismatch: between {source} and {target}\" + stack_position)\n if len(source) != len(target):\n raise ValueError(f\"Length mismatch: between {source} and {target}\" + stack_position)\n return [recursive_reorder(source[i], target[i], stack + \".<list>\") for i in range(len(target))]\n else:\n return source\n\n return Features(recursive_reorder(self, other))\n\n def flatten(self, max_depth=16) -> \"Features\":\n \"\"\"Flatten the features. Every dictionary column is removed and is replaced by\n all the subfields it contains. The new fields are named by concatenating the\n name of the original column and the subfield name like this: \"<original>.<subfield>\".\n\n If a column contains nested dictionaries, then all the lower-level subfields names are\n also concatenated to form new columns: \"<original>.<subfield>.<subsubfield>\", etc.\n\n Returns:\n Features: the flattened features\n \"\"\"\n for depth in range(1, max_depth):\n no_change = True\n flattened = self.copy()\n for column_name, subfeature in self.items():\n if isinstance(subfeature, dict):\n no_change = False\n flattened.update({f\"{column_name}.{k}\": v for k, v in subfeature.items()})\n del flattened[column_name]\n elif isinstance(subfeature, Sequence) and isinstance(subfeature.feature, dict):\n no_change = False\n flattened.update(\n {\n f\"{column_name}.{k}\": Sequence(v) if not isinstance(v, dict) else [v]\n for k, v in subfeature.feature.items()\n }\n )\n del flattened[column_name]\n elif hasattr(subfeature, \"flatten\") and subfeature.flatten() != subfeature:\n no_change = False\n flattened.update({f\"{column_name}.{k}\": v for k, v in subfeature.flatten().items()})\n del flattened[column_name]\n self = flattened\n if no_change:\n break\n return self\n"
] | [
[
"numpy.asarray",
"numpy.arange",
"numpy.all",
"numpy.insert",
"pandas.isna",
"numpy.array",
"numpy.sum",
"numpy.vstack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"0.24",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
shmulike/robot_snake_10 | [
"d6e34a3ef50e1e022f26853addf3783434529d2e"
] | [
"script/gui_v4.py"
] | [
"#!/usr/bin/env python3\r\n# license removed for brevity\r\n\r\nfrom tkinter import ttk\r\nfrom tkinter import *\r\nimport numpy as np\r\nimport rospy\r\nfrom std_msgs.msg import Float32MultiArray, Int32MultiArray\r\nfrom functools import partial\r\nimport cv2\r\nfrom PIL import Image, ImageTk\r\nimport threading\r\nimport pyrealsense2 as rs\r\n\r\n# from std_msgs.msg import Float32MultiArray, Int32MultiArray\r\n\r\nmax_PWM = 255\r\nN_links = 12\r\nN_joints = N_links\r\nN_motor_each = 2\r\nN_motor = N_links * N_motor_each\r\nslider_dPWM = 1\r\nN_string = N_joints * 2\r\n\r\nvideoloop_stop = [-1, -1]\r\nstarted = [False, False]\r\npipe = rs.pipeline()\r\nthreads = [[],[]]\r\n\r\ndef button1_clicked():\r\n # if not started[0]:\r\n t = threading.Thread(target=videoLoop, args=(videoloop_stop,))\r\n t.start()\r\n threads[0].append(t)\r\n started[0] = True\r\n # else:\r\n # videoloop_stop[0] = False\r\n\r\n\r\ndef button2_clicked():\r\n videoloop_stop[0] = True\r\n\r\n\r\ndef button3_clicked():\r\n # if not started[1]:\r\n t = threading.Thread(target=videoDepthLoop, args=(videoloop_stop,))\r\n t.start()\r\n threads[1].append(t)\r\n started[1] = True\r\n # else:\r\n # videoloop_stop[1] = False\r\n #\r\n\r\ndef button4_clicked():\r\n videoloop_stop[1] = True\r\n\r\n\r\ndef videoDepthLoop(mirror=False):\r\n if videoloop_stop[0] == False:\r\n # if switcher tells to stop then we switch it again and stop videoloop\r\n for t in threads[0]:\r\n t.join()\r\n pipe.stop()\r\n print(\"Frames Captured\")\r\n videoloop_stop[0] = False\r\n No = 1\r\n # pipe = rs.pipeline()\r\n cap1 = cv2.VideoCapture(No)\r\n cap1.set(cv2.CAP_PROP_FRAME_WIDTH, 800)\r\n cap1.set(cv2.CAP_PROP_FRAME_HEIGHT, 600)\r\n colorizer = rs.colorizer()\r\n cfg = rs.config()\r\n profile = pipe.start(cfg)\r\n # Skip 5 first frames to give the Auto-Exposure time to adjust\r\n for x in range(5):\r\n pipe.wait_for_frames()\r\n\r\n while True:\r\n videoloop_stop[1] = False\r\n # Store next frameset for later processing:\r\n frameset = pipe.wait_for_frames()\r\n depth_frame = frameset.get_depth_frame()\r\n # Render images\r\n colorized_depth = np.asanyarray(colorizer.colorize(depth_frame).get_data())\r\n img = Image.fromarray(colorized_depth)\r\n image = ImageTk.PhotoImage(image=img)\r\n panel = Label(image=image)\r\n panel.image = image\r\n panel.place(x=50, y=50)\r\n # check switcher value\r\n if videoloop_stop[1]:\r\n # if switcher tells to stop then we switch it again and stop videoloop\r\n pipe.stop()\r\n print(\"Frames Captured\")\r\n\r\n videoloop_stop[1] = False\r\n panel.destroy()\r\n cap1.release()\r\n\r\n break\r\n\r\n\r\ndef videoLoop(mirror=False):\r\n if videoloop_stop[1] == False:\r\n # if switcher tells to stop then we switch it again and stop videoloop\r\n for t in threads[1]:\r\n t.join()\r\n pipe.stop()\r\n print(\"Frames Captured\")\r\n videoloop_stop[1] = False\r\n No = 1\r\n # pipe = rs.pipeline()\r\n cap1 = cv2.VideoCapture(No)\r\n cap1.set(cv2.CAP_PROP_FRAME_WIDTH, 800)\r\n cap1.set(cv2.CAP_PROP_FRAME_HEIGHT, 600)\r\n cfg = rs.config()\r\n profile = pipe.start(cfg)\r\n # Skip 5 first frames to give the Auto-Exposure time to adjust\r\n for x in range(5):\r\n pipe.wait_for_frames()\r\n\r\n while True:\r\n videoloop_stop[0] = False\r\n # Store next frameset for later processing:\r\n frameset = pipe.wait_for_frames()\r\n color_frame = frameset.get_color_frame()\r\n color_image = np.asanyarray(color_frame.get_data())\r\n # Render images\r\n img = Image.fromarray(color_image)\r\n image = ImageTk.PhotoImage(image=img)\r\n panel = Label(image=image)\r\n panel.image = image\r\n panel.place(x=50, y=50)\r\n # check switcher value\r\n if videoloop_stop[0]:\r\n # if switcher tells to stop then we switch it again and stop videoloop\r\n pipe.stop()\r\n print(\"Frames Captured\")\r\n videoloop_stop[0] = False\r\n panel.destroy()\r\n cap1.release()\r\n\r\n break\r\n\r\n # No = 0\r\n # cap = cv2.VideoCapture(No)\r\n # cap.set(cv2.CAP_PROP_FRAME_WIDTH, 800)\r\n # cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 600)\r\n #\r\n # while True:\r\n # ret, to_draw = cap.read()\r\n # if mirror is True:\r\n # to_draw = to_draw[:, ::-1]\r\n #\r\n # image = cv2.cvtColor(to_draw, cv2.COLOR_BGR2RGB)\r\n # image = Image.fromarray(image)\r\n # image = ImageTk.PhotoImage(image)\r\n # panel = Label(image=image)\r\n # panel.image = image\r\n # panel.place(x=50, y=50)\r\n #\r\n # # check switcher value\r\n # if videoloop_stop[0]:\r\n # # if switcher tells to stop then we switch it again and stop videoloop\r\n # videoloop_stop[0] = False\r\n # panel.destroy()\r\n # cap.release()\r\n # break\r\n\r\n\r\n\r\n\r\n\r\nclass APP:\r\n\r\n def __init__(self):\r\n # ROS\r\n rospy.init_node(\"GUI\", anonymous=True)\r\n self.motor_pwm_pub = rospy.Publisher(\"/robot_snake_4/motor_cmd\", Int32MultiArray, queue_size=10)\r\n self.joint_cmd_pub = rospy.Publisher(\"/robot_snake_10/joint_cmd\", Float32MultiArray, queue_size=10)\r\n rospy.Subscriber(\"/robot_snake_1/tension_val\", Float32MultiArray, self.tension_val_update)\r\n rospy.Subscriber(\"/robot_snake_10/joint_val\", Float32MultiArray, self.joint_val_update)\r\n\r\n # tkinter\r\n self.root = Tk()\r\n self.root.title(\"Tab Widget\")\r\n self.tabControl = ttk.Notebook(self.root)\r\n\r\n self.tab1 = ttk.Frame(self.tabControl)\r\n self.tab1.pack(fill=BOTH, expand=1)\r\n self.tab2 = ttk.Frame(self.tabControl)\r\n self.tab2.pack(fill=BOTH, expand=1)\r\n self.tab3 = ttk.Frame(self.tabControl)\r\n self.tab3.pack(fill=BOTH, expand=1)\r\n self.tab4 = ttk.Frame(self.tabControl)\r\n self.tab4.pack(fill=BOTH, expand=1)\r\n\r\n self.tabControl.add(self.tab1, text='Tab 1')\r\n self.tabControl.add(self.tab2, text='Tab 2')\r\n self.tabControl.add(self.tab3, text='Tab 3')\r\n self.tabControl.add(self.tab4, text='Tab 4')\r\n self.tabControl.pack(expand=1, fill=\"both\")\r\n\r\n self.my_canvas_tab1 = Canvas(self.tab1)\r\n self.my_canvas_tab2 = Canvas(self.tab2)\r\n self.my_canvas_tab3 = Canvas(self.tab3)\r\n self.my_canvas_tab4 = Canvas(self.tab4)\r\n\r\n self.my_canvas_tab1.pack(side=TOP, fill=BOTH, expand=1)\r\n self.my_canvas_tab2.pack(side=TOP, fill=BOTH, expand=1)\r\n self.my_canvas_tab3.pack(side=TOP, fill=BOTH, expand=1)\r\n self.my_canvas_tab4.pack(side=TOP, fill=BOTH, expand=1)\r\n\r\n # y_scrollbar.pack(side=RIGHT, fill=Y)\r\n\r\n self.frame_tab1 = Frame(self.my_canvas_tab1, width=1000, height=10000)\r\n self.frame_tab2 = Frame(self.my_canvas_tab2, width=1000, height=10000)\r\n self.frame_tab3 = Frame(self.my_canvas_tab3, width=1000, height=10000)\r\n self.frame_tab4 = Frame(self.my_canvas_tab4, width=1000, height=10000)\r\n\r\n self.my_canvas_tab1.create_window(500, 38 * N_motor, window=self.frame_tab1)\r\n self.my_canvas_tab2.create_window(700, 34 * N_joints, window=self.frame_tab2)\r\n self.my_canvas_tab3.create_window(700, 34 * N_joints, window=self.frame_tab3)\r\n self.my_canvas_tab4.create_window(700, 34 * N_joints, window=self.frame_tab4)\r\n\r\n self.y_scrollbar_tab1 = ttk.Scrollbar(self.my_canvas_tab1, orient=VERTICAL, command=self.my_canvas_tab1.yview)\r\n self.y_scrollbar_tab2 = ttk.Scrollbar(self.my_canvas_tab2, orient=VERTICAL, command=self.my_canvas_tab2.yview)\r\n self.y_scrollbar_tab3 = ttk.Scrollbar(self.my_canvas_tab3, orient=VERTICAL, command=self.my_canvas_tab3.yview)\r\n self.y_scrollbar_tab4 = ttk.Scrollbar(self.my_canvas_tab4, orient=VERTICAL, command=self.my_canvas_tab4.yview)\r\n\r\n self.my_canvas_tab1.config(yscrollcommand=self.y_scrollbar_tab1.set, scrollregion=(0, 0, 1000, 2000))\r\n self.my_canvas_tab2.config(yscrollcommand=self.y_scrollbar_tab2.set, scrollregion=(0, 0, 1000, 2000))\r\n self.my_canvas_tab3.config(yscrollcommand=self.y_scrollbar_tab3.set, scrollregion=(0, 0, 1000, 2000))\r\n self.my_canvas_tab4.config(yscrollcommand=self.y_scrollbar_tab3.set, scrollregion=(0, 0, 1000, 2000))\r\n\r\n self.y_scrollbar_tab1.pack(side=RIGHT, fill=Y)\r\n self.y_scrollbar_tab2.pack(side=RIGHT, fill=Y)\r\n self.y_scrollbar_tab3.pack(side=RIGHT, fill=Y)\r\n self.y_scrollbar_tab4.pack(side=RIGHT, fill=Y)\r\n\r\n self.tab3_button1 = Button(\r\n self.my_canvas_tab3, text=\"start\", bg=\"#fff\", font=(\"\", 20),\r\n command=lambda: button1_clicked())\r\n self.tab3_button1.place(x=350, y=750, width=200, height=100)\r\n self.tab3_button2 = Button(\r\n self.my_canvas_tab3, text=\"stop\", bg=\"#fff\", font=(\"\", 20),\r\n command=lambda: button2_clicked())\r\n self.tab3_button2.place(x=150, y=750, width=200, height=100)\r\n\r\n self.tab4_button3 = Button(\r\n self.my_canvas_tab4, text=\"start\", bg=\"#fff\", font=(\"\", 20),\r\n command=lambda: button3_clicked())\r\n self.tab4_button3.place(x=350, y=750, width=200, height=100)\r\n self.tab4_button4 = Button(\r\n self.my_canvas_tab4, text=\"stop\", bg=\"#fff\", font=(\"\", 20),\r\n command=lambda: button4_clicked())\r\n self.tab4_button4.place(x=150, y=750, width=200, height=100)\r\n\r\n self.joint_val_text_tab1 = [0 for x in range(N_joints)]\r\n self.joint_val_tab1 = [0 for x in range(N_joints)]\r\n self.joint_val_text_tab2 = [0 for x in range(N_joints)]\r\n self.joint_val_tab2 = [0 for x in range(N_joints)]\r\n self.tension_label_tab1 = [[0 for i in range(N_motor_each)] for j in range(N_string)]\r\n self.tension_label_tab2 = [[0 for i in range(N_motor_each)] for j in range(N_string)]\r\n self.tension_text = [[0 for i in range(N_motor_each)] for j in range(N_string)]\r\n self.motor_label_tab1 = [[0 for i in range(N_motor_each)] for j in range(N_string)]\r\n self.motor_text = [[0 for i in range(N_motor_each)] for j in range(N_string)]\r\n self.sliders_tab1 = [0 for x in range(N_motor)]\r\n self.sliders_tab2 = [0 for x in range(N_joints)]\r\n self.buttons_up_tab2 = [0 for x in range(N_joints)]\r\n self.buttons_down_tab2 = [0 for x in range(N_joints)]\r\n self.buttons_reset_tab2 = [0 for x in range(N_joints)]\r\n self.joint_cmd = [0 for x in range(N_joints)]\r\n j_row = 0\r\n for i in range(N_links):\r\n V_i = 0.123\r\n V_cmd = 0.124\r\n # joint for tab2\r\n self.joint_val_text_tab1[i] = StringVar()\r\n self.joint_val_text_tab1[i].set(\"Joint {}: {} deg\".format(i + 1, V_i))\r\n self.joint_val_tab1[i] = ttk.Label(self.frame_tab1, textvariable=self.joint_val_text_tab1[i])\r\n self.joint_val_tab1[i].grid(column=0, row=j_row, padx=0)\r\n # joint for tab2\r\n self.joint_val_text_tab2[i] = StringVar()\r\n\r\n self.joint_val_text_tab2[i].set(\"Joint {}: {} deg/{}\".format(i + 1, V_i, V_cmd))\r\n self.joint_val_tab2[i] = ttk.Label(self.frame_tab2, textvariable=self.joint_val_text_tab2[i])\r\n self.joint_val_tab2[i].grid(column=0, row=i, padx=30)\r\n\r\n self.sliders_tab2[i] = Scale(self.frame_tab2, length=300, from_=-max_PWM, to=max_PWM, orient=HORIZONTAL,\r\n tickinterval=max_PWM / 2)\r\n self.sliders_tab2[i].grid(column=3, row=i)\r\n self.sliders_tab2[i].bind(\"<B1-Motion>\",\r\n lambda event, arg1=i: self.slider_joint_change(event, arg1))\r\n self.buttons_down_tab2[i] = Button(self.frame_tab2, text=\"A{}1\".format(i),\r\n command=partial(self.slider_joint_buttons, -1, i))\r\n self.buttons_down_tab2[i].grid(column=2, row=i)\r\n self.buttons_up_tab2[i] = Button(self.frame_tab2, text=\"A{}2\".format(i),\r\n command=partial(self.slider_joint_buttons, 1, i))\r\n self.buttons_up_tab2[i].grid(column=4, row=i)\r\n self.buttons_reset_tab2[i] = Button(self.frame_tab2, text=\"reset\",\r\n command=partial(self.slider_joint_buttons, 0, i))\r\n self.buttons_reset_tab2[i].grid(column=1, row=i)\r\n\r\n for j in range(N_motor_each):\r\n cnt = i * 2 + j\r\n self.sliders_tab1[cnt] = Scale(self.frame_tab1, length=300, from_=-max_PWM, to=max_PWM,\r\n orient=HORIZONTAL, tickinterval=max_PWM / 2)\r\n self.sliders_tab1[cnt].grid(column=2, row=j_row + j + 1)\r\n self.sliders_tab1[cnt].bind(\"<ButtonRelease-1>\",\r\n lambda event, arg1=cnt: self.slider_pwm_reset(event, arg1))\r\n self.sliders_tab1[cnt].bind(\"<B1-Motion>\",\r\n lambda event, arg1=cnt: self.slider_pwm_change(event, arg1))\r\n self.tension_text[i][j] = StringVar()\r\n self.tension_label_tab1[i][j] = ttk.Label(self.frame_tab1, textvariable=self.tension_text[i][j])\r\n self.tension_label_tab1[i][j].grid(column=3, row=j_row + j + 1, padx=0)\r\n self.tension_text[i][j].set(\"String #{}: Waite for connection\".format(j + 1))\r\n self.motor_text[i][j] = StringVar()\r\n self.motor_label_tab1[i][j] = ttk.Label(self.frame_tab1, textvariable=self.motor_text[i][j])\r\n self.motor_label_tab1[i][j].grid(column=1, row=j_row + j + 1, padx=30)\r\n self.motor_text[i][j].set(\"Motor {}: {} deg\".format(cnt + 1, \"pmw val\"))\r\n self.tension_label_tab2[i][j] = ttk.Label(self.frame_tab2, textvariable=self.tension_text[i][j])\r\n self.tension_label_tab2[i][j].grid(column=5 + j, row=i, padx=30)\r\n j_row += 3\r\n self.home_position()\r\n\r\n # while not rospy.is_shutdown():\r\n # rospy.Rate(100).sleep()\r\n\r\n def slider_pwm_change(self, event, i):\r\n # print(self.slider_pwm[i][j].get())\r\n arr = np.zeros(N_string)\r\n arr[i] = self.sliders_tab1[i].get()\r\n self.send_motor_cmd(arr)\r\n\r\n def send_motor_cmd(self, arr):\r\n msg = Int32MultiArray(data=arr.astype(int))\r\n self.motor_pwm_pub.publish(msg)\r\n\r\n def slider_joint_buttons(self, diff, i):\r\n if diff == 0:\r\n self.sliders_tab2[i].set(0)\r\n self.joint_cmd[i] = self.sliders_tab2[i].get()\r\n self.send_joint_cmd(self.joint_cmd)\r\n self.sliders_tab2[i].set(self.sliders_tab2[i].get() + diff)\r\n self.joint_cmd[i] = self.sliders_tab2[i].get()\r\n self.send_joint_cmd(self.joint_cmd)\r\n\r\n def slider_joint_change(self, event, i):\r\n self.joint_cmd[i] = self.sliders_tab2[i].get()\r\n self.send_joint_cmd(self.joint_cmd)\r\n\r\n def slider_pwm_reset(self, event, i):\r\n self.sliders_tab1[i].set(0)\r\n arr = np.zeros(N_string)\r\n self.send_motor_cmd(arr)\r\n return\r\n\r\n def joint_val_update(self, msg):\r\n if len(msg.data) > 0:\r\n for i in range(N_links):\r\n self.joint_val_text_tab1[i].set(\"Joint {}: {:.3f} deg\".format(i + 1, msg.data[i]))\r\n self.joint_val_text_tab2[i].set(\"Joint {}: {:.3f} deg\".format(i + 1, msg.data[i]))\r\n\r\n def send_joint_cmd(self, arr):\r\n msg = Float32MultiArray(data=arr)\r\n self.joint_cmd_pub.publish(msg)\r\n\r\n def home_position(self):\r\n for i in range(N_joints):\r\n self.sliders_tab2[i].set(0)\r\n self.joint_cmd[i] = self.sliders_tab2[i].get()\r\n self.send_joint_cmd(self.joint_cmd)\r\n\r\n def tension_val_update(self, msg):\r\n if len(msg.data) > 0:\r\n for i in range(N_string):\r\n row = int(np.floor(i / 2))\r\n col = int(i % 2)\r\n if msg.data[i] > 0:\r\n text = \"String #{}: {:.2f} Kg\".format(i + 1, msg.data[i])\r\n else:\r\n text = \"String #{}: {:.2f} Kg -- Error\".format(i + 1, msg.data[i])\r\n self.tension_text[row][col].set(text)\r\n\r\n\r\nif __name__ == '__main__':\r\n a = APP()\r\n rate = rospy.Rate(100)\r\n a.root.mainloop()\r\n rospy.spin()\r\n"
] | [
[
"numpy.zeros",
"numpy.floor"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
alitekin2fx/KiKit | [
"bd7400aafe058e0794635af04da77a13e892c2db"
] | [
"kikit/panelize.py"
] | [
"from kikit import pcbnew_compatibility\nfrom kikit.pcbnew_compatibility import pcbnew\nfrom kikit.common import normalize\nfrom pcbnew import (GetBoard, LoadBoard,\n FromMM, ToMM, wxPoint, wxRect, wxRectMM, wxPointMM)\nfrom enum import Enum, IntEnum\nfrom shapely.geometry import (Polygon, MultiPolygon, Point, LineString, box,\n GeometryCollection, MultiLineString)\nfrom shapely.prepared import prep\nimport shapely\nfrom itertools import product, chain\nimport numpy as np\nimport os\n\nfrom kikit import substrate\nfrom kikit import units\nfrom kikit.substrate import Substrate, linestringToKicad, extractRings\nfrom kikit.defs import STROKE_T, Layer, EDA_TEXT_HJUSTIFY_T, EDA_TEXT_VJUSTIFY_T\n\nfrom kikit.common import *\n\nclass PanelError(RuntimeError):\n pass\n\ndef identity(x):\n return x\n\nclass BasicGridPosition:\n \"\"\"\n Specify board position in the grid. This class\n \"\"\"\n def __init__(self, destination, boardSize, horSpace, verSpace):\n self.destination = destination\n self.boardSize = boardSize\n self.horSpace = horSpace\n self.verSpace = verSpace\n\n def position(self, i, j):\n return wxPoint(self.destination[0] + j * (self.boardSize.GetWidth() + self.horSpace),\n self.destination[1] + i * (self.boardSize.GetHeight() + self.verSpace))\n\n def rotation(self, i, j):\n return 0\n\nclass OddEvenRowsPosition(BasicGridPosition):\n \"\"\"\n Rotate boards by 180° for every row\n \"\"\"\n def rotation(self, i, j):\n if i % 2 == 0:\n return 0\n return 1800\n\nclass OddEvenColumnPosition(BasicGridPosition):\n \"\"\"\n Rotate boards by 180° for every column\n \"\"\"\n def rotation(self, i, j):\n if j % 2 == 0:\n return 0\n return 1800\n\nclass OddEvenRowsColumnsPosition(BasicGridPosition):\n \"\"\"\n Rotate boards by 180 for every row and column\n \"\"\"\n def rotation(self, i, j):\n if (i * j) % 2 == 0:\n return 0\n return 1800\n\n\nclass Origin(Enum):\n Center = 0\n TopLeft = 1\n TopRight = 2\n BottomLeft = 3\n BottomRight = 4\n\ndef getOriginCoord(origin, bBox):\n \"\"\"Returns real coordinates (wxPoint) of the origin for given bounding box\"\"\"\n if origin == Origin.Center:\n return wxPoint(bBox.GetX() + bBox.GetWidth() // 2,\n bBox.GetY() + bBox.GetHeight() // 2)\n if origin == Origin.TopLeft:\n return wxPoint(bBox.GetX(), bBox.GetY())\n if origin == Origin.TopRight:\n return wxPoint(bBox.GetX() + bBox.GetWidth(), bBox.GetY())\n if origin == Origin.BottomLeft:\n return wxPoint(bBox.GetX(), bBox.GetY() + bBox.GetHeight())\n if origin == Origin.BottomRight:\n return wxPoint(bBox.GetX() + bBox.GetWidth(), bBox.GetY() + bBox.GetHeight())\n\ndef appendItem(board, item):\n \"\"\"\n Make a coppy of the item and append it to the board. Allows to append items\n from one board to another.\n \"\"\"\n try:\n newItem = item.Duplicate()\n except TypeError: # Footprint has overridden the method, cannot be called directly\n newItem = pcbnew.Cast_to_BOARD_ITEM(item).Duplicate().Cast()\n board.Add(newItem)\n\ndef transformArea(board, sourceArea, translate, origin, rotationAngle):\n \"\"\"\n Rotates and translates all board items in given source area\n \"\"\"\n for drawing in collectItems(board.GetDrawings(), sourceArea):\n drawing.Rotate(origin, rotationAngle)\n drawing.Move(translate)\n for footprint in collectItems(board.GetFootprints(), sourceArea):\n footprint.Rotate(origin, rotationAngle)\n footprint.Move(translate)\n for track in collectItems(board.GetTracks(), sourceArea):\n track.Rotate(origin, rotationAngle)\n track.Move(translate)\n for zone in collectItems(board.Zones(), sourceArea):\n zone.Rotate(origin, rotationAngle)\n zone.Move(translate)\n\ndef collectNetNames(board):\n return [str(x) for x in board.GetNetInfo().NetsByName() if len(str(x)) > 0]\n\ndef remapNets(collection, mapping):\n for item in collection:\n item.SetNetCode(mapping[item.GetNetname()].GetNetCode())\n\ndef toPolygon(entity):\n if isinstance(entity, list):\n return list([toPolygon(e) for e in entity])\n if isinstance(entity, Polygon) or isinstance(entity, MultiPolygon):\n return entity\n if isinstance(entity, wxRect):\n return Polygon([\n (entity.GetX(), entity.GetY()),\n (entity.GetX() + entity.GetWidth(), entity.GetY()),\n (entity.GetX() + entity.GetWidth(), entity.GetY() + entity.GetHeight()),\n (entity.GetX(), entity.GetY() + entity.GetHeight())])\n raise NotImplementedError(\"Cannot convert {} to Polygon\".format(type(entity)))\n\ndef rectString(rect):\n return \"({}, {}) w: {}, h: {}\".format(\n ToMM(rect.GetX()), ToMM(rect.GetY()),\n ToMM(rect.GetWidth()), ToMM(rect.GetHeight()))\n\ndef expandRect(rect, offsetX, offsetY=None):\n \"\"\"\n Given a wxRect returns a new rectangle, which is larger in all directions\n by offset. If only offsetX is passed, it used for both X and Y offset\n \"\"\"\n if offsetY is None:\n offsetY = offsetX\n offsetX = int(offsetX)\n offsetY = int(offsetY)\n return wxRect(rect.GetX() - offsetX, rect.GetY() - offsetY,\n rect.GetWidth() + 2 * offsetX, rect.GetHeight() + 2 * offsetY)\n\ndef rectToRing(rect):\n return [\n (rect.GetX(), rect.GetY()),\n (rect.GetX() + rect.GetWidth(), rect.GetY()),\n (rect.GetX() + rect.GetWidth(), rect.GetY() + rect.GetHeight()),\n (rect.GetX(), rect.GetY() + rect.GetHeight())\n ]\n\ndef roundPoint(point, precision=-4):\n if isinstance(point, Point):\n return Point(round(point.x, precision), round(point.y, precision))\n return Point(round(point[0], precision), round(point[1], precision))\n\ndef undoTransformation(point, rotation, origin, translation):\n \"\"\"\n We apply a transformation \"Rotate around origin and then translate\" when\n placing a board. Given a point and original transformation parameters,\n return the original point position.\n \"\"\"\n # Abuse PcbNew to do so\n segment = pcbnew.PCB_SHAPE()\n segment.SetShape(STROKE_T.S_SEGMENT)\n segment.SetStart(wxPoint(point[0], point[1]))\n segment.SetEnd(wxPoint(0, 0))\n segment.Move(wxPoint(-translation[0], -translation[1]))\n segment.Rotate(origin, -rotation)\n return segment.GetStart()\n\ndef removeCutsFromFootprint(footprint):\n \"\"\"\n Find all graphical items in the footprint, remove them and return them as a\n list\n \"\"\"\n edges = []\n for edge in footprint.GraphicalItems():\n if edge.GetLayerName() != \"Edge.Cuts\":\n continue\n footprint.Remove(edge)\n edges.append(edge)\n return edges\n\ndef renameNets(board, renamer):\n \"\"\"\n Given a board and renaming function (taking original name, returning new\n name) renames the nets\n \"\"\"\n originalNetNames = collectNetNames(board)\n netinfo = board.GetNetInfo()\n\n newNetMapping = { \"\": netinfo.GetNetItem(\"\") }\n newNames = set()\n for name in originalNetNames:\n newName = renamer(name)\n newNet = pcbnew.NETINFO_ITEM(board, newName)\n newNetMapping[name] = newNet\n board.Add(newNet)\n newNames.add(newName)\n\n remapNets(board.GetPads(), newNetMapping)\n remapNets(board.GetTracks(), newNetMapping)\n remapNets(board.Zones(), newNetMapping)\n\n for name in originalNetNames:\n if name != \"\" and name not in newNames:\n board.RemoveNative(netinfo.GetNetItem(name))\n\ndef renameRefs(board, renamer):\n \"\"\"\n Given a board and renaming function (taking original name, returning new\n name) renames the references\n \"\"\"\n for footprint in board.GetFootprints():\n ref = footprint.Reference().GetText()\n footprint.Reference().SetText(renamer(ref))\n\ndef isBoardEdge(edge):\n \"\"\"\n Decide whether the drawing is a board edge or not.\n\n The rule is: all drawings on Edge.Cuts layer are edges.\n \"\"\"\n return isinstance(edge, pcbnew.PCB_SHAPE) and edge.GetLayerName() == \"Edge.Cuts\"\n\ndef increaseZonePriorities(board, amount=1):\n for zone in board.Zones():\n zone.SetPriority(zone.GetPriority() + amount)\n\ndef tabSpacing(width, count):\n \"\"\"\n Given a width of board edge and tab count, return an iterable with tab\n offsets.\n \"\"\"\n return [width * i / (count + 1) for i in range(1, count + 1)]\n\ndef prolongCut(cut, prolongation):\n \"\"\"\n Given a cut (Shapely LineString) it tangentially prolongs it by prolongation\n \"\"\"\n c = list([np.array(x) for x in cut.coords])\n c[0] += normalize(c[0] - c[1]) * prolongation\n c[-1] += normalize(c[-1] - c[-2]) * prolongation\n return LineString(c)\n\ndef polygonToZone(polygon, board):\n \"\"\"\n Given a polygon and target board, creates a KiCAD zone. The zone has to be\n added to the board.\n \"\"\"\n zone = pcbnew.ZONE(board)\n boundary = polygon.exterior\n zone.Outline().AddOutline(linestringToKicad(boundary))\n for hole in polygon.interiors:\n boundary = hole.exterior\n zone.Outline().AddHole(linestringToKicad(boundary))\n return zone\n\ndef isAnnotation(footprint):\n \"\"\"\n Given a footprint, decide if it is KiKit annotation\n \"\"\"\n info = footprint.GetFPID()\n if info.GetLibNickname() != \"kikit\":\n return False\n return info.GetLibItemName() in [\"Tab\", \"Board\"]\n\ndef readKiKitProps(footprint):\n \"\"\"\n Given a footprint, returns a string containing KiKit annotations.\n Annotations are in FP_TEXT starting with prefix `KIKIT:`.\n\n Returns a dictionary of key-value pairs.\n \"\"\"\n for x in footprint.GraphicalItems():\n if not isinstance(x, pcbnew.FP_TEXT):\n continue\n text = x.GetText()\n if text.startswith(\"KIKIT:\"):\n return readParameterList(text[len(\"KIKIT:\"):])\n return {}\n\nclass TabAnnotation:\n def __init__(self, ref, origin, direction, width, maxLength=fromMm(100)):\n self.ref = ref\n self.origin = origin\n self.direction = direction\n self.width = width\n self.maxLength = maxLength\n\n @staticmethod\n def fromFootprint(footprint):\n origin = footprint.GetPosition()\n radOrientaion = footprint.GetOrientationRadians()\n direction = (np.cos(radOrientaion), -np.sin(radOrientaion))\n props = readKiKitProps(footprint)\n width = units.readLength(props[\"width\"])\n return TabAnnotation(footprint.GetReference(), origin, direction, width)\n\ndef convertToAnnotation(footprint):\n \"\"\"\n Given a footprint, convert it into an annotation. One footprint might\n represent a zero or multiple annotations, so this function returns a list.\n \"\"\"\n name = footprint.GetFPID().GetLibItemName()\n if name == \"Tab\":\n return [TabAnnotation.fromFootprint(footprint)]\n # We ignore Board annotation\n return []\n\ndef buildTabs(substrate, partitionLines, tabAnnotations):\n \"\"\"\n Given substrate, partitionLines of the substrate and an iterable of tab\n annotations, build tabs. Note that if the tab does not hit the partition\n line, it is not included in the design.\n\n Return a pair of lists: tabs and cuts.\n \"\"\"\n tabs, cuts = [], []\n for annotation in tabAnnotations:\n t, c = substrate.tab(annotation.origin, annotation.direction,\n annotation.width, partitionLines, annotation.maxLength)\n if t is not None:\n tabs.append(t)\n cuts.append(c)\n return tabs, cuts\n\ndef normalizePartitionLineOrientation(line):\n \"\"\"\n Given a LineString or MultiLineString, normalize orientation of the\n partition line. For open linestrings, the orientation does not matter. For\n closed linerings, it has to be counter-clock-wise.\n \"\"\"\n if isinstance(line, MultiLineString):\n return MultiLineString([normalizePartitionLineOrientation(x) for x in line.geoms])\n if isinstance(line, GeometryCollection):\n return GeometryCollection([normalizePartitionLineOrientation(l) for l in line.geoms])\n if not isLinestringCyclic(line):\n return line\n r = LinearRing(line.coords)\n if not r.is_ccw:\n return line\n return LineString(list(r.coords)[::-1])\n\ndef maxTabCount(edgeLen, width, minDistance):\n \"\"\"\n Given a length of edge, tab width and their minimal distance, return maximal\n number of tabs.\n \"\"\"\n if edgeLen < width:\n return 0\n c = 1 + (edgeLen - minDistance) // (minDistance + width)\n return max(0, int(c))\n\nclass Panel:\n \"\"\"\n Basic interface for panel building. Instance of this class represents a\n single panel. You can append boards, add substrate pieces, make cuts or add\n holes to the panel. Once you finish, you have to save the panel to a file.\n \"\"\"\n def __init__(self):\n \"\"\"\n Initializes empty panel.\n \"\"\"\n self.board = pcbnew.BOARD()\n self.substrates = [] # Substrates of the individual boards; e.g. for masking\n self.boardSubstrate = Substrate([]) # Keep substrate in internal representation,\n # Draw it just before saving\n self.backboneLines = []\n self.hVCuts = set() # Keep V-cuts as numbers and append them just before saving\n self.vVCuts = set() # to make them truly span the whole panel\n self.vCutLayer = Layer.Cmts_User\n self.vCutClearance = 0\n self.copperLayerCount = None\n self.zonesToRefill = pcbnew.ZONES()\n\n def save(self, filename):\n \"\"\"\n Saves the panel to a file.\n \"\"\"\n for edge in self.boardSubstrate.serialize():\n self.board.Add(edge)\n vcuts = self._renderVCutH() + self._renderVCutV()\n keepouts = []\n for cut, clearanceArea in vcuts:\n self.board.Add(cut)\n if clearanceArea is not None:\n keepouts.append(self.addKeepout(clearanceArea))\n fillerTool = pcbnew.ZONE_FILLER(self.board)\n fillerTool.Fill(self.zonesToRefill)\n self.board.Save(filename)\n # Remove cuts\n for cut, _ in vcuts:\n self.board.Remove(cut)\n # Remove V-cuts keepouts\n for keepout in keepouts:\n self.board.Remove(keepout)\n # Remove edges\n for edge in collectEdges(self.board, \"Edge.Cuts\"):\n self.board.Remove(edge)\n\n def _uniquePrefix(self):\n return \"Board_{}-\".format(len(self.substrates))\n\n def inheritDesignSettings(self, boardFilename):\n \"\"\"\n Inherit design settings from the given board specified by a filename\n \"\"\"\n b = pcbnew.LoadBoard(boardFilename)\n self.setDesignSettings(b.GetDesignSettings())\n\n def setDesignSettings(self, designSettings):\n \"\"\"\n Set design settings\n \"\"\"\n #self.board.SetDesignSettings(designSettings)\n\n def inheritProperties(self, boardFilename):\n \"\"\"\n Inherit text properties from a board specified by a properties\n \"\"\"\n b = pcbnew.LoadBoard(boardFilename)\n self.setDesignSettings(b.GetDesignSettings())\n\n def setProperties(self, properties):\n \"\"\"\n Set text properties cached in the board\n \"\"\"\n self.board.SetProperties(designSettings)\n\n def appendBoard(self, filename, destination, sourceArea=None,\n origin=Origin.Center, rotationAngle=0, shrink=False,\n tolerance=0, bufferOutline=fromMm(0.001), netRenamer=None,\n refRenamer=None):\n \"\"\"\n Appends a board to the panel.\n\n The sourceArea (wxRect) of the board specified by filename is extracted\n and placed at destination (wxPoint). The source area (wxRect) can be\n auto detected if it is not provided. Only board items which fit entirely\n into the source area are selected. You can also specify rotation. Both\n translation and rotation origin are specified by origin. Origin\n specifies which point of the sourceArea is used for translation and\n rotation (origin it is placed to destination). It is possible to specify\n coarse source area and automatically shrink it if shrink is True.\n Tolerance enlarges (even shrinked) source area - useful for inclusion of\n filled zones which can reach out of the board edges.\n\n You can also specify functions which will rename the net and ref names.\n By default, nets are renamed to \"Board_{n}-{orig}\", refs are unchanged.\n The renamers are given board seq number and original name\n\n Returns bounding box (wxRect) of the extracted area placed at the\n destination and the extracted substrate of the board.\n \"\"\"\n board = LoadBoard(filename)\n thickness = board.GetDesignSettings().GetBoardThickness()\n if len(self.substrates) == 0:\n self.board.GetDesignSettings().SetBoardThickness(thickness)\n else:\n panelThickness = self.board.GetDesignSettings().GetBoardThickness()\n if panelThickness != thickness:\n raise PanelError(f\"Cannot append board {filename} as its \" \\\n f\"thickness ({toMm(thickness)} mm) differs from \" \\\n f\"thickness of the panel ({toMm(panelThickness)}) mm\")\n self.inheritCopperLayers(board)\n\n if not sourceArea:\n sourceArea = findBoardBoundingBox(board)\n elif shrink:\n sourceArea = findBoardBoundingBox(board, sourceArea)\n enlargedSourceArea = expandRect(sourceArea, tolerance)\n originPoint = getOriginCoord(origin, sourceArea)\n translation = wxPoint(destination[0] - originPoint[0],\n destination[1] - originPoint[1])\n\n if netRenamer is None:\n netRenamer = lambda x, y: self._uniquePrefix() + y\n renameNets(board, lambda x: netRenamer(len(self.substrates), x))\n if refRenamer is not None:\n renameRefs(board, lambda x: refRenamer(len(self.substrates), x))\n\n drawings = collectItems(board.GetDrawings(), enlargedSourceArea)\n footprints = collectFootprints(board.GetFootprints(), enlargedSourceArea)\n tracks = collectItems(board.GetTracks(), enlargedSourceArea)\n zones = collectItems(board.Zones(), enlargedSourceArea)\n\n edges = []\n annotations = []\n for footprint in footprints:\n footprint.Rotate(originPoint, rotationAngle)\n footprint.Move(translation)\n edges += removeCutsFromFootprint(footprint)\n if isAnnotation(footprint):\n annotations.extend(convertToAnnotation(footprint))\n else:\n appendItem(self.board, footprint)\n for track in tracks:\n track.Rotate(originPoint, rotationAngle)\n track.Move(translation)\n appendItem(self.board, track)\n for zone in zones:\n zone.Rotate(originPoint, rotationAngle)\n zone.Move(translation)\n appendItem(self.board, zone)\n for netId in board.GetNetInfo().NetsByNetcode():\n self.board.Add(board.GetNetInfo().GetNetItem(netId))\n\n # Treat drawings differently since they contains board edges\n for drawing in drawings:\n drawing.Rotate(originPoint, rotationAngle)\n drawing.Move(translation)\n edges += [edge for edge in drawings if isBoardEdge(edge)]\n otherDrawings = [edge for edge in drawings if not isBoardEdge(edge)]\n try:\n o = Substrate(edges, -bufferOutline)\n s = Substrate(edges, bufferOutline)\n self.boardSubstrate.union(s)\n self.substrates.append(o)\n self.substrates[-1].annotations = annotations\n except substrate.PositionError as e:\n point = undoTransformation(e.point, rotationAngle, originPoint, translation)\n raise substrate.PositionError(filename + \": \" + e.origMessage, point)\n for drawing in otherDrawings:\n appendItem(self.board, drawing)\n return findBoundingBox(edges)\n\n def appendSubstrate(self, substrate):\n \"\"\"\n Append a piece of substrate or a list of pieces to the panel. Substrate\n can be either wxRect or Shapely polygon. Newly appended corners can be\n rounded by specifying non-zero filletRadius.\n \"\"\"\n polygon = toPolygon(substrate)\n self.boardSubstrate.union(polygon)\n\n def boardsBBox(self):\n \"\"\"\n Return common bounding box for all boards in the design (ignores the\n individual pieces of substrate) as a shapely box.\n \"\"\"\n if len(self.substrates) == 0:\n raise RuntimeError(\"There are no substrates, cannot compute bounding box\")\n bbox = self.substrates[0].bounds()\n for p in islice(self.substrates, 1, None):\n bbox = shpBBoxMerge(bbox, p.bounds())\n return bbox\n\n def panelBBox(self):\n \"\"\"\n Return bounding box of the panel as a shapely box.\n \"\"\"\n return self.boardSubstrate.bounds()\n\n def addVCutH(self, pos):\n \"\"\"\n Adds a horizontal V-CUT at pos (integer in KiCAD units).\n \"\"\"\n self.hVCuts.add(pos)\n\n def addVCutV(self, pos):\n \"\"\"\n Adds a horizontal V-CUT at pos (integer in KiCAD units).\n \"\"\"\n self.vVCuts.add(pos)\n\n def setVCutLayer(self, layer):\n \"\"\"\n Set layer on which the V-Cuts will be rendered\n \"\"\"\n self.vCutLayer = layer\n\n def setVCutClearance(self, clearance):\n \"\"\"\n Set V-cut clearance\n \"\"\"\n self.vCutClearance = clearance\n\n def _setVCutSegmentStyle(self, segment, layer):\n segment.SetShape(STROKE_T.S_SEGMENT)\n segment.SetLayer(layer)\n segment.SetWidth(fromMm(0.4))\n\n def _setVCutLabelStyle(self, label, layer):\n label.SetText(\"V-CUT\")\n label.SetLayer(layer)\n label.SetTextThickness(fromMm(0.4))\n label.SetTextSize(pcbnew.wxSizeMM(2, 2))\n label.SetHorizJustify(EDA_TEXT_HJUSTIFY_T.GR_TEXT_HJUSTIFY_LEFT)\n\n def _renderVCutV(self):\n \"\"\" return list of PCB_SHAPE V-Cuts \"\"\"\n bBox = self.boardSubstrate.boundingBox()\n minY, maxY = bBox.GetY() - fromMm(3), bBox.GetY() + bBox.GetHeight() + fromMm(3)\n segments = []\n for cut in self.vVCuts:\n segment = pcbnew.PCB_SHAPE()\n self._setVCutSegmentStyle(segment, self.vCutLayer)\n segment.SetStart(pcbnew.wxPoint(cut, minY))\n segment.SetEnd(pcbnew.wxPoint(cut, maxY))\n\n keepout = None\n if self.vCutClearance != 0:\n keepout = shapely.geometry.box(\n cut - self.vCutClearance / 2,\n bBox.GetY(),\n cut + self.vCutClearance / 2,\n bBox.GetY() + bBox.GetHeight())\n segments.append((segment, keepout))\n\n label = pcbnew.PCB_TEXT(segment)\n self._setVCutLabelStyle(label, self.vCutLayer)\n label.SetPosition(wxPoint(cut, minY - fromMm(3)))\n label.SetTextAngle(900)\n segments.append((label, None))\n return segments\n\n def _renderVCutH(self):\n \"\"\" return list of PCB_SHAPE V-Cuts \"\"\"\n bBox = self.boardSubstrate.boundingBox()\n minX, maxX = bBox.GetX() - fromMm(3), bBox.GetX() + bBox.GetWidth() + fromMm(3)\n segments = []\n for cut in self.hVCuts:\n segment = pcbnew.PCB_SHAPE()\n self._setVCutSegmentStyle(segment, self.vCutLayer)\n segment.SetStart(pcbnew.wxPoint(minX, cut))\n segment.SetEnd(pcbnew.wxPoint(maxX, cut))\n\n keepout = None\n if self.vCutClearance != 0:\n keepout = shapely.geometry.box(\n bBox.GetX(),\n cut - self.vCutClearance / 2,\n bBox.GetX() + bBox.GetWidth(),\n cut + self.vCutClearance / 2)\n segments.append((segment, keepout))\n\n\n label = pcbnew.PCB_TEXT(segment)\n self._setVCutLabelStyle(label, self.vCutLayer)\n label.SetPosition(wxPoint(maxX + fromMm(3), cut))\n segments.append((label, None))\n return segments\n\n def _placeBoardsInGrid(self, boardfile, rows, cols, destination, sourceArea, tolerance,\n verSpace, horSpace, rotation, netRenamer, refRenamer,\n placementClass):\n \"\"\"\n Create a grid of boards, return source board size aligned at the top\n left corner\n \"\"\"\n boardSize = wxRect(0, 0, 0, 0)\n topLeftSize = None\n placement = placementClass(destination, boardSize, horSpace, verSpace)\n for i, j in product(range(rows), range(cols)):\n placement.boardSize = boardSize\n dest = placement.position(i, j)\n boardRotation = rotation + placement.rotation(i, j)\n boardSize = self.appendBoard(\n boardfile, dest, sourceArea=sourceArea,\n tolerance=tolerance, origin=Origin.Center,\n rotationAngle=boardRotation, netRenamer=netRenamer,\n refRenamer=refRenamer)\n if not topLeftSize:\n topLeftSize = boardSize\n return topLeftSize\n\n def makeGrid(self, boardfile, sourceArea, rows, cols, destination,\n verSpace, horSpace, rotation,\n placementClass=BasicGridPosition,\n netRenamePattern=\"Board_{n}-{orig}\",\n refRenamePattern=\"Board_{n}-{orig}\"):\n \"\"\"\n Place the given board in a regular grid pattern with given spacing\n (verSpace, horSpace). The board position can be fine-tuned via\n placementClass. The nets and references are renamed according to the\n patterns.\n\n Returns a list of the placed substrates. You can use these to generate\n tabs, frames, backbones, etc.\n \"\"\"\n substrateCount = len(self.substrates)\n netRenamer = lambda x, y: netRenamePattern.format(n=x, orig=y)\n refRenamer = lambda x, y: refRenamePattern.format(n=x, orig=y)\n self._placeBoardsInGrid(boardfile, rows, cols, destination,\n sourceArea, 0, verSpace, horSpace,\n rotation, netRenamer, refRenamer, placementClass)\n return self.substrates[substrateCount:]\n\n def makeFrame(self, width, hspace, vspace):\n \"\"\"\n Build a frame around the board. Specify width and spacing between the\n boards substrates and the frame. Return frame cuts\n \"\"\"\n frameInnerRect = expandRect(shpBoxToRect(self.boardsBBox()),\n hspace - SHP_EPSILON, vspace + SHP_EPSILON)\n frameOuterRect = expandRect(frameInnerRect, width + SHP_EPSILON)\n outerRing = rectToRing(frameOuterRect)\n innerRing = rectToRing(frameInnerRect)\n polygon = Polygon(outerRing, [innerRing])\n self.appendSubstrate(polygon)\n\n innerArea = self.substrates[0].boundingBox()\n for s in self.substrates:\n innerArea = combineBoundingBoxes(innerArea, s.boundingBox())\n frameCutsV = self.makeFrameCutsV(innerArea, frameInnerRect, frameOuterRect)\n frameCutsH = self.makeFrameCutsH(innerArea, frameInnerRect, frameOuterRect)\n return chain(frameCutsV, frameCutsH)\n\n def makeTightFrame(self, width, slotwidth, hspace, vspace):\n \"\"\"\n Build a full frame with board perimeter milled out.\n \"\"\"\n self.makeFrame(width, hspace, vspace)\n boardSlot = GeometryCollection()\n for s in self.substrates:\n boardSlot = boardSlot.union(s.exterior())\n boardSlot = boardSlot.buffer(slotwidth)\n frameBody = box(*self.boardSubstrate.bounds()).difference(boardSlot)\n self.appendSubstrate(frameBody)\n\n def makeRailsTb(self, thickness):\n \"\"\"\n Adds a rail to top and bottom.\n \"\"\"\n minx, miny, maxx, maxy = self.panelBBox()\n thickness -= SHP_EPSILON\n topRail = box(minx, maxy - SHP_EPSILON, maxx, maxy + thickness)\n bottomRail = box(minx, miny + SHP_EPSILON, maxx, miny - thickness)\n self.appendSubstrate(topRail)\n self.appendSubstrate(bottomRail)\n\n def makeRailsLr(self, thickness):\n \"\"\"\n Adds a rail to left and right.\n \"\"\"\n minx, miny, maxx, maxy = self.panelBBox()\n thickness -= SHP_EPSILON\n leftRail = box(minx - thickness + SHP_EPSILON, miny, minx, maxy)\n rightRail = box(maxx - SHP_EPSILON, miny, maxx + thickness, maxy)\n self.appendSubstrate(leftRail)\n self.appendSubstrate(rightRail)\n\n def makeFrameCutsV(self, innerArea, frameInnerArea, outerArea):\n \"\"\"\n Generate vertical cuts for the frame corners and return them\n \"\"\"\n x_coords = [ innerArea.GetX(),\n innerArea.GetX() + innerArea.GetWidth() ]\n y_coords = sorted([ frameInnerArea.GetY(),\n frameInnerArea.GetY() + frameInnerArea.GetHeight(),\n outerArea.GetY(),\n outerArea.GetY() + outerArea.GetHeight() ])\n cuts = [ [(x_coord, y_coords[0]), (x_coord, y_coords[1])] for x_coord in x_coords ]\n cuts += [ [(x_coord, y_coords[2]), (x_coord, y_coords[3])] for x_coord in x_coords ]\n return map(LineString, cuts)\n\n def makeFrameCutsH(self, innerArea, frameInnerArea, outerArea):\n \"\"\"\n Generate horizontal cuts for the frame corners and return them\n \"\"\"\n y_coords = [ innerArea.GetY(),\n innerArea.GetY() + innerArea.GetHeight() ]\n x_coords = sorted([ frameInnerArea.GetX(),\n frameInnerArea.GetX() + frameInnerArea.GetWidth(),\n outerArea.GetX(),\n outerArea.GetX() + outerArea.GetWidth() ])\n cuts = [ [(x_coords[0], y_coord), (x_coords[1], y_coord)] for y_coord in y_coords ]\n cuts += [ [(x_coords[2], y_coord), (x_coords[3], y_coord)] for y_coord in y_coords ]\n return map(LineString, cuts)\n\n def makeVCuts(self, cuts, boundCurves=False):\n \"\"\"\n Take a list of lines to cut and performs V-CUTS. When boundCurves is\n set, approximate curved cuts by a line from the first and last point.\n Otherwise, raise an exception.\n \"\"\"\n for cut in cuts:\n if len(cut.simplify(SHP_EPSILON).coords) > 2 and not boundCurves:\n raise RuntimeError(\"Cannot V-Cut a curve\")\n start = roundPoint(cut.coords[0])\n end = roundPoint(cut.coords[-1])\n if start.x == end.x or (abs(start.x - end.x) <= fromMm(0.5) and boundCurves):\n self.addVCutV((start.x + end.x) / 2)\n elif start.y == end.y or (abs(start.y - end.y) <= fromMm(0.5) and boundCurves):\n self.addVCutH((start.y + end.y) / 2)\n else:\n raise RuntimeError(\"Cannot perform V-Cut which is not horizontal or vertical\")\n\n def makeMouseBites(self, cuts, diameter, spacing, offset=fromMm(0.25),\n prolongation=fromMm(0.5)):\n \"\"\"\n Take a list of cuts and perform mouse bites. The cuts can be prolonged\n to\n \"\"\"\n bloatedSubstrate = prep(self.boardSubstrate.substrates.buffer(SHP_EPSILON))\n for cut in cuts:\n cut = cut.simplify(SHP_EPSILON) # Remove self-intersecting geometry\n cut = prolongCut(cut, prolongation)\n offsetCut = cut.parallel_offset(offset, \"left\")\n length = offsetCut.length\n count = int(length / spacing) + 1\n for i in range(count):\n if count == 1:\n hole = offsetCut.interpolate(0.5, normalized=True)\n else:\n hole = offsetCut.interpolate( i * length / (count - 1) )\n if bloatedSubstrate.intersects(hole):\n self.addNPTHole(wxPoint(hole.x, hole.y), diameter)\n\n def addNPTHole(self, position, diameter, paste=False):\n \"\"\"\n Add a drilled non-plated hole to the position (`wxPoint`) with given\n diameter. The paste option allows to place the hole on the paste layers.\n \"\"\"\n module = pcbnew.PCB_IO().FootprintLoad(KIKIT_LIB, \"NPTH\")\n module.SetPosition(position)\n self.board.Add(module)\n for pad in module.Pads():\n pad.SetDrillSize(pcbnew.wxSize(diameter, diameter))\n pad.SetSize(pcbnew.wxSize(diameter, diameter))\n if paste:\n layerSet = pad.GetLayerSet()\n layerSet.AddLayer(Layer.F_Paste)\n layerSet.AddLayer(Layer.B_Paste)\n pad.SetLayerSet(layerSet)\n\n def addFiducial(self, position, copperDiameter, openingDiameter, bottom=False):\n \"\"\"\n Add fiducial, i.e round copper pad with solder mask opening to the position (`wxPoint`),\n with given copperDiameter and openingDiameter. By setting bottom to True, the fiducial\n is placed on bottom side.\n \"\"\"\n module = pcbnew.PCB_IO().FootprintLoad(KIKIT_LIB, \"Fiducial\")\n module.SetPosition(position)\n self.board.Add(module)\n if(bottom):\n if pcbnew_compatibility.isV6(pcbnew_compatibility.pcbnewVersion):\n module.Flip(position, False)\n else:\n module.Flip(position)\n for pad in module.Pads():\n pad.SetSize(pcbnew.wxSize(copperDiameter, copperDiameter))\n pad.SetLocalSolderMaskMargin(int((openingDiameter - copperDiameter) / 2))\n pad.SetLocalClearance(int((openingDiameter - copperDiameter) / 2))\n\n def panelCorners(self, horizontalOffset=0, verticalOffset=0):\n \"\"\"\n Return the list of top-left, top-right, bottom-left and bottom-right\n corners of the panel. You can specify offsets.\n \"\"\"\n minx, miny, maxx, maxy = self.panelBBox()\n topLeft = wxPoint(minx + horizontalOffset, miny + verticalOffset)\n topRight = wxPoint(maxx - horizontalOffset, miny + verticalOffset)\n bottomLeft = wxPoint(minx + horizontalOffset, maxy - verticalOffset)\n bottomRight = wxPoint(maxx - horizontalOffset, maxy - verticalOffset)\n return [topLeft, topRight, bottomLeft, bottomRight]\n\n def addCornerFiducials(self, fidCount, horizontalOffset, verticalOffset,\n copperDiameter, openingDiameter):\n \"\"\"\n Add up to 4 fiducials to the top-left, top-right, bottom-left and\n bottom-right corner of the board (in this order). This function expects\n there is enough space on the board/frame/rail to place the feature.\n\n The offsets are measured from the outer edges of the substrate.\n \"\"\"\n for pos in self.panelCorners(horizontalOffset, verticalOffset)[:fidCount]:\n self.addFiducial(pos, copperDiameter, openingDiameter, False)\n self.addFiducial(pos, copperDiameter, openingDiameter, True)\n\n def addCornerTooling(self, holeCount, horizontalOffset, verticalOffset,\n diameter, paste=False):\n \"\"\"\n Add up to 4 tooling holes to the top-left, top-right, bottom-left and\n bottom-right corner of the board (in this order). This function expects\n there is enough space on the board/frame/rail to place the feature.\n\n The offsets are measured from the outer edges of the substrate.\n \"\"\"\n for pos in self.panelCorners(horizontalOffset, verticalOffset)[:holeCount]:\n self.addNPTHole(pos, diameter, paste)\n\n def addMillFillets(self, millRadius):\n \"\"\"\n Add fillets to inner conernes which will be produced a by mill with\n given radius.\n \"\"\"\n self.boardSubstrate.millFillets(millRadius)\n\n def clearTabsAnnotations(self):\n \"\"\"\n Remove all existing tab annotations from the panel.\n \"\"\"\n for s in self.substrates:\n s.annotations = list(\n filter(lambda x: not isinstance(x, TabAnnotation), s.annotations))\n\n def buildTabsFromAnnotations(self):\n \"\"\"\n Given annotations for the individual substrates, create tabs for them.\n Tabs are appended to the panel, cuts are returned.\n\n Expects that a valid partition line is assigned to the the panel.\n \"\"\"\n tabs, cuts = [], []\n for s in self.substrates:\n t, c = buildTabs(s, s.partitionLine, s.annotations)\n tabs.extend(t)\n cuts.extend(c)\n self.boardSubstrate.union(tabs)\n return cuts\n\n def _buildTabAnnotationForEdge(self, edge, dir, count, width):\n \"\"\"\n Given an edge as AxialLine, dir and count, return a list of\n annotations.\n \"\"\"\n pos = lambda offset: (\n abs(dir[0]) * edge.x + abs(dir[1]) * (edge.min + offset),\n abs(dir[1]) * edge.x + abs(dir[0]) * (edge.min + offset))\n return [TabAnnotation(None, pos(offset), dir, width)\n for offset in tabSpacing(edge.length, count)]\n\n def _buildTabAnnotations(self, countFn, widthFn, ghostSubstrates):\n \"\"\"\n Add tab annotations for the individual substrates based on their\n bounding boxes. Assign tabs annotations to the edges of the bounding\n box. You provides a function countFn, widthFn that take edge length and\n direction that return number of tabs per edge or tab width\n respectively.\n\n You can also specify ghost substrates (for the future framing).\n \"\"\"\n neighbors = substrate.SubstrateNeighbors(self.substrates + ghostSubstrates)\n S = substrate.SubstrateNeighbors\n sides = [\n (S.leftC, shpBBoxLeft, [1, 0]),\n (S.rightC, shpBBoxRight,[-1, 0]),\n (S.topC, shpBBoxTop, [0, 1]),\n (S.bottomC, shpBBoxBottom,[0, -1])\n ]\n for i, s in enumerate(self.substrates):\n for query, side, dir in sides:\n for n, shadow in query(neighbors, s):\n edge = side(s.bounds())\n for section in shadow.intervals:\n edge.min, edge.max = section.min, section.max\n tWidth = widthFn(edge.length, dir)\n tCount = countFn(edge.length, dir)\n a = self._buildTabAnnotationForEdge(edge, dir, tCount, tWidth)\n self.substrates[i].annotations.extend(a)\n\n def buildTabAnnotationsFixed(self, hcount, vcount, hwidth, vwidth,\n minDistance, ghostSubstrates):\n \"\"\"\n Add tab annotations for the individual substrates based on number of\n tabs in horizontal and vertical direction. You can specify individual\n width in each direction.\n\n If the edge is short for the specified number of tabs with given minimal\n spacing, the count is reduced.\n\n You can also specify ghost substrates (for the future framing).\n \"\"\"\n def widthFn(edgeLength, dir):\n return abs(dir[0]) * hwidth + abs(dir[1]) * vwidth\n def countFn(edgeLength, dir):\n countLimit = abs(dir[0]) * hcount + abs(dir[1]) * vcount\n width = widthFn(edgeLength, dir)\n return min(countLimit, maxTabCount(edgeLength, width, minDistance))\n return self._buildTabAnnotations(countFn, widthFn, ghostSubstrates)\n\n\n def buildTabAnnotationsSpacing(self, spacing, hwidth, vwidth, ghostSubstrates):\n \"\"\"\n Add tab annotations for the individual substrates based on their spacing.\n\n You can also specify ghost substrates (for the future framing).\n \"\"\"\n def widthFn(edgeLength, dir):\n return abs(dir[0]) * hwidth + abs(dir[1]) * vwidth\n def countFn(edgeLength, dir):\n return maxTabCount(edgeLength, widthFn(edgeLength, dir), spacing)\n return self._buildTabAnnotations(countFn, widthFn, ghostSubstrates)\n\n def buildTabAnnotationsCorners(self, width):\n \"\"\"\n Add tab annotations to the corners of the individual substrates.\n \"\"\"\n for i, s in enumerate(self.substrates):\n minx, miny, maxx, maxy = s.bounds()\n midx = (minx + maxx) / 2\n midy = (miny + maxy) / 2\n\n for x, y in product([minx, maxx], [miny, maxy]):\n dir = normalize((midx - x, midy - y))\n a = TabAnnotation(None, (x, y), dir, width)\n self.substrates[i].annotations.append(a)\n\n\n def buildFullTabs(self):\n \"\"\"\n Make full tabs. This strategy basically cuts the bounding boxes of the\n PCBs. Not suitable for mousebites. Expects there is a valid partition\n line.\n\n Return a list of cuts.\n \"\"\"\n # Compute the bounding box gap polygon. Note that we cannot just merge a\n # rectangle as that would remove internal holes\n bBoxes = box(*self.substrates[0].bounds())\n for s in islice(self.substrates, 1, None):\n bBoxes = bBoxes.union(box(*s.bounds()))\n outerBounds = self.substrates[0].partitionLine.bounds\n for s in islice(self.substrates, 1, None):\n outerBounds = shpBBoxMerge(outerBounds, s.partitionLine.bounds)\n fill = box(*outerBounds).difference(bBoxes.buffer(SHP_EPSILON))\n self.appendSubstrate(fill.buffer(SHP_EPSILON))\n\n # Make the cuts\n substrateBoundaries = [linestringToSegments(s.partitionLine)\n for s in self.substrates]\n substrateCuts = [LineString(x) for x in chain(*substrateBoundaries)]\n return substrateCuts\n\n def inheritCopperLayers(self, board):\n \"\"\"\n Update the panel's layer count to match the design being panelized.\n Raise an error if this is attempted twice with inconsistent layer count\n boards.\n \"\"\"\n if(self.copperLayerCount is None):\n self.copperLayerCount = board.GetCopperLayerCount()\n self.board.SetCopperLayerCount(self.copperLayerCount)\n\n elif(self.copperLayerCount != board.GetCopperLayerCount()):\n raise RuntimeError(\"Attempting to panelize boards together of mixed layer counts\")\n\n def copperFillNonBoardAreas(self):\n \"\"\"\n Fill top and bottom layers with copper on unused areas of the panel\n (frame, rails and tabs)\n \"\"\"\n if not self.boardSubstrate.isSinglePiece():\n raise RuntimeError(\"The substrate has to be a single piece to fill unused areas\")\n increaseZonePriorities(self.board)\n\n zoneContainer = pcbnew.ZONE(self.board)\n boundary = self.boardSubstrate.exterior().boundary\n zoneContainer.Outline().AddOutline(linestringToKicad(boundary))\n for substrate in self.substrates:\n boundary = substrate.exterior().boundary\n zoneContainer.Outline().AddHole(linestringToKicad(boundary))\n zoneContainer.SetPriority(0)\n\n zoneContainer.SetLayer(Layer.F_Cu)\n self.board.Add(zoneContainer)\n self.zonesToRefill.append(zoneContainer)\n\n zoneContainer = zoneContainer.Duplicate()\n zoneContainer.SetLayer(Layer.B_Cu)\n self.board.Add(zoneContainer)\n self.zonesToRefill.append(zoneContainer)\n\n def addKeepout(self, area, noTracks=True, noVias=True, noCopper=True):\n \"\"\"\n Add a keepout area from top and bottom layers. Area is a shapely\n polygon. Return the keepout area.\n \"\"\"\n zone = polygonToZone(area, self.board)\n zone.SetIsKeepout(True)\n zone.SetDoNotAllowTracks(noTracks)\n zone.SetDoNotAllowVias(noVias)\n zone.SetDoNotAllowCopperPour(noCopper)\n\n zone.SetLayer(Layer.F_Cu)\n layerSet = zone.GetLayerSet()\n layerSet.AddLayer(Layer.B_Cu)\n zone.SetLayerSet(layerSet)\n\n self.board.Add(zone)\n return zone\n\n def addText(self, text, position, orientation=0,\n width=fromMm(1.5), height=fromMm(1.5), thickness=fromMm(0.3),\n hJustify=EDA_TEXT_HJUSTIFY_T.GR_TEXT_HJUSTIFY_CENTER,\n vJustify=EDA_TEXT_VJUSTIFY_T.GR_TEXT_VJUSTIFY_CENTER,\n layer=Layer.F_SilkS):\n \"\"\"\n Add text at given position to the panel. If appending to the bottom\n side, text is automatically mirrored.\n \"\"\"\n textObject = pcbnew.PCB_TEXT(self.board)\n textObject.SetText(text)\n textObject.SetTextX(position[0])\n textObject.SetTextY(position[1])\n textObject.SetThickness(thickness)\n textObject.SetTextSize(pcbnew.wxSize(width, height))\n textObject.SetHorizJustify(hJustify)\n textObject.SetVertJustify(vJustify)\n textObject.SetTextAngle(orientation)\n textObject.SetLayer(layer)\n textObject.SetMirrored(isBottomLayer(layer))\n self.board.Add(textObject)\n\n def setAuxiliaryOrigin(self, point):\n \"\"\"\n Set the auxiliary origin used e.g., for drill files\n \"\"\"\n self.board.SetAuxOrigin(point)\n\n def setGridOrigin(self, point):\n \"\"\"\n Set grid origin\n \"\"\"\n self.board.SetGridOrigin(point)\n\n def _buildPartitionLineFromBB(self, partition):\n for s in self.substrates:\n hLines, vLines = partition.partitionSubstrate(s)\n hSLines = [((l.min, l.x), (l.max, l.x)) for l in hLines]\n vSLines = [((l.x, l.min), (l.x, l.max)) for l in vLines]\n lines = hSLines + vSLines\n multiline = shapely.ops.linemerge(lines)\n multiline = normalizePartitionLineOrientation(multiline)\n\n s.partitionLine = multiline\n\n def _buildBackboneLineFromBB(self, partition, boundarySubstrates):\n hBoneLines, vBoneLines = set(), set()\n for s in self.substrates:\n hLines, vLines = partition.partitionSubstrate(s)\n hBoneLines.update(hLines)\n vBoneLines.update(vLines)\n for s in boundarySubstrates:\n hLines, vLines = partition.partitionSubstrate(s)\n for l in hLines:\n hBoneLines.remove(l)\n for l in vLines:\n vBoneLines.remove(l)\n minx, miny, maxx, maxy = self.boardSubstrate.bounds()\n # Cut backbone on substrates boundaries:\n cut = lambda xs, y: chain(*[x.cut(y) for x in xs])\n hBoneLines = cut(cut(hBoneLines, minx), maxx)\n vBoneLines = cut(cut(vBoneLines, miny), maxy)\n hBLines = [LineString([(l.min, l.x), (l.max, l.x)]) for l in hBoneLines]\n vBLines = [LineString([(l.x, l.min), (l.x, l.max)]) for l in vBoneLines]\n self.backboneLines = list(chain(hBLines, vBLines))\n\n def buildPartitionLineFromBB(self, boundarySubstrates=[], safeMargin=0):\n \"\"\"\n Builds partition & backbone line from bounding boxes of the substrates.\n You can optionally pass extra substrates (e.g., for frame).\n \"\"\"\n partition = substrate.SubstratePartitionLines(\n self.substrates, boundarySubstrates,\n safeMargin, safeMargin)\n self._buildPartitionLineFromBB(partition)\n self._buildBackboneLineFromBB(partition, boundarySubstrates)\n\n def addLine(self, start, end, thickness, layer):\n \"\"\"\n Add a line to the panel based on starting and ending point\n \"\"\"\n segment = pcbnew.PCB_SHAPE()\n segment.SetShape(STROKE_T.S_SEGMENT)\n segment.SetLayer(layer)\n segment.SetWidth(thickness)\n segment.SetStart(pcbnew.wxPoint(start[0], start[1]))\n segment.SetEnd(pcbnew.wxPoint(end[0], end[1]))\n self.board.Add(segment)\n return segment\n\n def _renderLines(self, lines, layer, thickness=fromMm(0.5)):\n for geom in lines:\n for linestring in listGeometries(geom):\n for start, end in linestringToSegments(linestring):\n self.addLine(start, end, thickness, layer)\n\n def debugRenderPartitionLines(self):\n \"\"\"\n Render partition line to the panel to be easily able to inspect them via\n Pcbnew.\n \"\"\"\n lines = [s.partitionLine for s in self.substrates]\n self._renderLines(lines, Layer.Eco1_User, fromMm(0.5))\n\n def debugRenderBackboneLines(self):\n \"\"\"\n Render partition line to the panel to be easily able to inspect them via\n Pcbnew.\n \"\"\"\n self._renderLines(self.backboneLines, Layer.Eco2_User, fromMm(0.5))\n\n def debugRenderBoundingBoxes(self):\n lines = [box(*s.bounds()).exterior for s in self.substrates]\n self._renderLines(lines, Layer.Cmts_User, fromMm(0.5))\n\n def renderBackbone(self, vthickness, hthickness, vcut, hcut):\n \"\"\"\n Render horizontal and vertical backbone lines. If zero thickness is\n specified, no backbone is rendered.\n\n vcut, hcut specifies if vertical or horizontal backbones should be cut.\n\n Return a list of cuts\n \"\"\"\n cutpoints = commonPoints(self.backboneLines)\n pieces, cuts = [], []\n for l in self.backboneLines:\n start = l.coords[0]\n end = l.coords[1]\n if isHorizontal(start, end) and hthickness > 0:\n minX = min(start[0], end[0])\n maxX = max(start[0], end[0])\n bb = box(minX, start[1] - hthickness // 2,\n maxX, start[1] + hthickness // 2)\n pieces.append(bb)\n if not hcut:\n continue\n\n candidates = []\n\n if cutpoints[start] > 2:\n candidates.append(((start[0] + vthickness // 2, start[1]), -1))\n\n if cutpoints[end] == 2:\n candidates.append((end, 1))\n elif cutpoints[end] > 2:\n candidates.append(((end[0] - vthickness // 2, end[1]), 1))\n\n for x, c in candidates:\n cut = LineString([\n (x[0], x[1] - c * hthickness // 2),\n (x[0], x[1] + c * hthickness // 2)])\n cuts.append(cut)\n if isVertical(start, end) and vthickness > 0:\n minY = min(start[1], end[1])\n maxY = max(start[1], end[1])\n bb = box(start[0] - vthickness // 2, minY,\n start[0] + vthickness // 2, maxY)\n pieces.append(bb)\n if not vcut:\n continue\n\n candidates = []\n\n if cutpoints[start] > 2:\n candidates.append(((start[0], start[1] + hthickness // 2), 1))\n\n if cutpoints[end] == 2:\n candidates.append((end, -1))\n elif cutpoints[end] > 2:\n candidates.append(((end[0], end[1] - hthickness // 2), -1))\n\n for x, c in candidates:\n cut = LineString([\n (x[0] - c * vthickness // 2, x[1]),\n (x[0] + c * vthickness // 2, x[1])])\n cuts.append(cut)\n backbones = list([b.buffer(SHP_EPSILON, join_style=2) for b in pieces])\n self.appendSubstrate(backbones)\n return cuts\n\ndef getFootprintByReference(board, reference):\n \"\"\"\n Return a footprint by with given reference\n \"\"\"\n for f in board.GetFootprints():\n if f.GetReference() == reference:\n return f\n raise RuntimeError(f\"Footprint with reference '{reference}' not found\")\n\ndef extractSourceAreaByAnnotation(board, reference):\n \"\"\"\n Given a board and a reference to annotation in the form of symbol\n `kikit:Board`, extract the source area. The source area is a bounding box of\n continuous lines in the Edge.Cuts on which the arrow in reference point.\n \"\"\"\n annotation = getFootprintByReference(board, reference)\n tip = annotation.GetPosition()\n edges = collectEdges(board, \"Edge.Cuts\")\n # KiCAD 6 will need an adjustment - method Collide was introduced with\n # different parameters. But v6 API is not available yet, so we leave this\n # to future ourselves.\n pointedAt = indexOf(edges, lambda x: x.HitTest(tip))\n rings = extractRings(edges)\n ringPointedAt = indexOf(rings, lambda x: pointedAt in x)\n if ringPointedAt == -1:\n raise RuntimeError(\"Annotation symbol '{reference}' does not point to a board edge\")\n return findBoundingBox([edges[i] for i in rings[ringPointedAt]])\n\n\n"
] | [
[
"numpy.array",
"numpy.cos",
"numpy.sin"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
johnpeterflynn/surface-texture-inpainting-net | [
"b2de05eaa47c9bcca53b9aee12b6012ac2c05156"
] | [
"datasets/imagegraph_dataloader.py"
] | [
"import os\nimport glob\nimport random\nimport cv2\nimport numpy as np\nimport torch\nimport matplotlib.pyplot as plt\nimport open3d\nfrom skimage import io, img_as_float32\nfrom scipy import ndimage\nfrom torch_geometric.data import Data, DataListLoader\nfrom torch_geometric.loader import DataLoader as GraphLevelDataLoader\nfrom torch.utils.data import DataLoader, Dataset\nfrom torchvision import transforms\nimport transform\nfrom typing import List\nfrom easydict import EasyDict\nfrom utils import math_utils, data_utils, unit_tests\n\n\nclass ImageGraphTextureDataSet(Dataset):\n def __init__(self, image_files, end_level, is_train, benchmark, img_size, crop_half_width, circle_radius, num_circles=4, max_items=None,\n no_train_cropped=False, transform=None, random_mask=False):\n self._is_train = is_train\n self._benchmark = benchmark\n self.img_size = img_size\n self.crop_half_width = crop_half_width\n self._end_level = end_level\n self._transform = transform\n self._no_train_cropped = no_train_cropped\n self.image_files = np.array(image_files)\n self.random_mask = random_mask\n self.circle_radius = circle_radius\n self.num_circles = num_circles\n self.circle = torch.zeros((self.circle_radius * 2, self.circle_radius * 2, 1), dtype=torch.bool)\n for row in range(self.circle.shape[0]):\n for col in range(self.circle.shape[1]):\n if abs(row - self.circle_radius) ** 2 + abs(col - self.circle_radius) ** 2 <= self.circle_radius ** 2:\n self.circle[row, col] = True\n\n self.traces_list = []\n self.edge_indices_list = []\n self.num_vertices_list = []\n self.decimation = 2\n # Build fake traces\n for level in range(self._end_level):\n level_img_size = self.img_size // (self.decimation ** level)\n num_verties = level_img_size ** 2\n self.num_vertices_list.append(num_verties)\n if level > 0:\n trace = np.arange(num_verties).reshape(level_img_size, level_img_size)\n trace = np.repeat(trace, self.decimation, axis=1).repeat(self.decimation, axis=0)\n trace = np.reshape(trace, (-1,))\n #trace = torch.from_numpy(trace)\n #trace = torch.cat((trace, trace + level_img_size * level_img_size), dim=0)\n print(level, 'Trace shape:', trace.shape)\n self.traces_list.append(trace)\n\n # Build fake decimated edges\n for level in range(self._end_level):\n level_img_size = self.img_size // (self.decimation ** level)\n edge_indices = self._generate_image_graph_edges(level_img_size)\n #edge_indices = torch.from_numpy(edge_indices)\n #edge_indices = torch.cat((edge_indices, edge_indices + level_img_size * level_img_size), dim=0)\n #edge_indices = edge_indices.t().contiguous()\n print(level, 'Number of edge indices:', edge_indices.shape)\n self.edge_indices_list.append(edge_indices)\n\n def _generate_image_graph_edges(self, img_size):\n def double_set_add(s, a, b):\n s.add((a, b))\n s.add((b, a))\n\n def get_neighbor_coords_list(r, c, max_size):\n coords_list = []\n # TODO: Should we add self-loops?\n # Maybe not since most graph algorithms explicitly include the vertex they're operating on\n #coords_list.append((r, c))\n if r > 0:\n coords_list.append((r - 1, c + 0))\n #if c > 0:\n # coords_list.append((r - 1, c - 1))\n #if c < max_size - 1:\n # coords_list.append((r - 1, c + 1))\n if c > 0:\n coords_list.append((r + 0, c - 1))\n if c < max_size - 1:\n coords_list.append((r + 0, c + 1))\n\n if r < max_size - 1:\n coords_list.append((r + 1, c + 0))\n #if c > 0:\n # coords_list.append((r + 1, c - 1))\n #if c < max_size - 1:\n # coords_list.append((r + 1, c + 1))\n return coords_list\n\n edge_indices = set()\n for r in range(img_size):\n for c in range(img_size):\n index = r * img_size + c\n neighbor_coords = get_neighbor_coords_list(r, c, img_size)\n for neighbor_coord in neighbor_coords:\n neighbor_index = neighbor_coord[0] * img_size + neighbor_coord[1]\n double_set_add(edge_indices, index, neighbor_index)\n\n edge_indices = np.asarray(list(edge_indices))\n return edge_indices\n\n def __len__(self):\n return len(self.image_files)\n\n def __getitem__(self, index: int):\n img_path = self.image_files[index]\n img = io.imread(img_path)\n img = np.array(img)\n\n sample = {'color': img}\n\n if self._transform:\n sample = self._transform(sample)\n\n img = sample['color']\n\n # Create circular masks\n mask = torch.zeros((self.img_size, self.img_size, 1), dtype=torch.bool)\n for i in range(self.num_circles):\n if self._is_train and self.random_mask:\n x_offset = int((self.img_size / 2 - self.crop_half_width) * (random.random() * 2.0 - 1.0) * 0.95)\n y_offset = int((self.img_size / 2 - self.crop_half_width) * (random.random() * 2.0 - 1.0) * 0.95)\n else:\n x_offset = ((i % 2) * 2 - 1) * self.img_size // 4\n y_offset = ((i // 2) * 2 - 1) * self.img_size // 4\n\n row_start = self.img_size//2-self.circle_radius + x_offset\n row_end = self.img_size//2+self.circle_radius + x_offset\n col_start = self.img_size//2-self.circle_radius + y_offset\n col_end = self.img_size//2+self.circle_radius + y_offset\n mask[row_start:row_end, col_start:col_end] += self.circle\n\n img = torch.reshape(img, (-1, 3))\n mask = torch.reshape(mask, (-1, 1))\n\n sample = data_utils.HierarchicalData(x=torch.cat([img * ~mask, mask], dim=-1),\n color=img,\n mask=mask,\n edge_index=torch.from_numpy(self.edge_indices_list[0]).t().contiguous(),\n #num_vertices=self.num_vertices_list,\n )\n\n ##sample.num_vertices = torch.tensor(self.num_vertices_list)\n num_vertices = [sample.x.shape[0]]\n sample.num_vertices = torch.tensor(self.num_vertices_list, dtype=torch.int)\n for level in range(1, self._end_level):\n setattr(sample, f\"hierarchy_edge_index_{level}\", torch.from_numpy(self.edge_indices_list[level]).t().contiguous())\n setattr(sample, f\"hierarchy_trace_index_{level}\", torch.from_numpy(self.traces_list[level - 1]))\n num_vertices.append(int(sample[f\"hierarchy_trace_index_{level}\"].max() + 1))\n sample.num_vertices = torch.tensor(num_vertices, dtype=torch.int)\n\n return sample\n\n\nclass Normalize(object):\n \"\"\"Normalize color images between [-1,1].\"\"\"\n\n def __call__(self, sample):\n color_image = sample['color']\n # NOTE: Don't normalize input_image. It's just a matrix of coordinates\n\n color_image = img_as_float32(color_image)\n color_image = (color_image * 2.0) - 1\n #color_image = color_image - 0.5\n\n return {'color': color_image}\n\n\nclass Rescale(object):\n \"\"\"Rescale the image in a sample to a given size.\n\n Args:\n output_size (tuple or int): Desired output size. If tuple, output is\n matched to output_size. If int, smaller of image edges is matched\n to output_size keeping aspect ratio the same.\n \"\"\"\n\n def __init__(self, min_size, max_size):\n # For now size is defined as the smaller size of an image\n assert isinstance(min_size, int)\n assert isinstance(max_size, int)\n assert min_size <= max_size\n self.min_size = min_size\n self.max_size = max_size\n\n def __call__(self, sample):\n input_image = sample['color']\n\n h, w = input_image.shape[:2]\n\n output_size = np.random.randint(self.min_size, self.max_size + 1)\n\n if isinstance(output_size, int):\n if h > w:\n new_h, new_w = output_size * h / w, output_size\n else:\n new_h, new_w = output_size, output_size * w / h\n else:\n new_h, new_w = output_size\n\n new_h, new_w = int(new_h), int(new_w)\n\n # TODO: Use pillow library for resizing images\n # Nearest neighbor for input_image since we can't interpolate across discontinuities in uv coordinates\n #input_image = transform.resize(input_image, (new_h, new_w))\n #input_image = cv2.resize(input_image, (new_w, new_h), interpolation=cv2.INTER_NEAREST)\n input_image = cv2.resize(input_image, (new_w, new_h), interpolation=cv2.INTER_AREA)\n\n return {'color': input_image}\n\n\nclass CenterCrop(object):\n def __init__(self, crop_size):\n assert isinstance(crop_size, tuple)\n self.crop_size = crop_size\n\n def __call__(self, sample):\n input_image = sample['color']\n\n # Assuming input_image and color_image are the same shape\n h, w, _ = input_image.shape\n\n size_crop_h, size_crop_w = self.crop_size\n\n # Get a valid starting and end positions\n h_start = int((h - size_crop_h) / 2)\n w_start = int((w - size_crop_w) / 2)\n h_end = h_start + size_crop_h\n w_end = w_start + size_crop_w\n\n # Crop the input and target\n input_image = input_image[h_start:h_end, w_start:w_end, :]\n\n return {'color': input_image}\n\n\nclass RandomRotation(object):\n def __init__(self):\n self.angles = [0, 90, 180, 270]\n\n def __call__(self, sample):\n input_image = sample['color']\n angle = random.choice(self.angles)\n input_image = ndimage.rotate(input_image, angle, reshape=False, mode='constant')\n return {'color': input_image}\n\n\nclass RandomFlip(object):\n def __init__(self, flip_axis):\n self.flip_axis = flip_axis\n\n def __call__(self, sample):\n input_image = sample['color']\n\n if np.random.choice(a=[False, True]):\n input_image = np.flip(input_image, axis=self.flip_axis).copy()\n\n return {'color': input_image}\n\n\nclass ToTensor(object):\n \"\"\"Convert ndarrays in sample to Tensors.\"\"\"\n\n def __call__(self, sample):\n input_image = sample['color']\n\n # NOTE: Axis swapping is not necessary for uv coords since\n # it is not an image, but rather a matrix of coordinates\n\n # swap color axis because\n # numpy image: H x W x C\n # torch image: C X H X W\n #input_image = input_image.transpose((2, 0, 1))\n return {'color': torch.from_numpy(input_image)}\n\n\nclass ImageGraphTextureDataLoader:\n def __init__(self, config, multi_gpu):\n self.config = EasyDict(config)\n\n self.train_files = self._load(os.path.join(self.config.root_dir, 'train'))\n self.val_files = self._load(os.path.join(self.config.root_dir, 'val'))\n len_train_files, len_val_files = len(self.train_files), len(self.val_files)\n total_num_files = len_train_files + len_val_files\n frac_train_files = len_train_files / total_num_files\n if 0 <= self.config.max_items <= total_num_files:\n max_train_files = int(self.config.max_items * frac_train_files)\n max_val_files = int(self.config.max_items * (1 - frac_train_files))\n else:\n max_train_files = int(total_num_files * frac_train_files)\n max_val_files = int(total_num_files * (1 - frac_train_files))\n self.train_files = self.train_files[:max_train_files]\n self.val_files = self.val_files[:max_val_files]\n\n transf_list_train = [\n Normalize(),\n Rescale(self.config.img_size, self.config.img_size),\n CenterCrop((self.config.img_size, self.config.img_size)),\n ]\n if self.config.random_augmentation:\n transf_list_train += [\n RandomRotation(),\n RandomFlip(flip_axis=1),\n ]\n transf_list_train.append(ToTensor())\n\n # Build val/test transformation\n transf_list_valid = [\n Normalize(),\n Rescale(self.config.img_size, self.config.img_size),\n CenterCrop((self.config.img_size, self.config.img_size)),\n #RandomFlip(flip_axis=1),\n ToTensor()\n ]\n\n transf_train = transforms.Compose(transf_list_train)\n transf_valid = transforms.Compose(transf_list_valid)\n\n if multi_gpu:\n dataloader_class = DataListLoader\n else:\n dataloader_class = GraphLevelDataLoader\n\n self.train_dataset = ImageGraphTextureDataSet(self.train_files, self.config.end_level, is_train=True,\n circle_radius=self.config.circle_radius,\n transform=transf_train, random_mask=self.config.random_mask,\n no_train_cropped=self.config.no_train_cropped, benchmark=False,\n img_size=self.config.img_size, max_items=self.config.max_items,\n crop_half_width=self.config.crop_half_width)\n\n print('train dataset len', len(self.train_dataset))\n self.train_loader = dataloader_class(self.train_dataset, batch_size=self.config.train_batch_size,\n shuffle=True, pin_memory=True, persistent_workers=self.config.num_workers > 0,\n num_workers=self.config.num_workers)\n self.sample_train_loader = dataloader_class(self.train_dataset, batch_size=self.config.train_batch_size,\n shuffle=False, pin_memory=True,\n num_workers=self.config.num_workers)\n self.sample_train_dataset = torch.utils.data.Subset(self.train_dataset,\n np.arange(min(self.config.num_static_samples,\n len(self.train_dataset))))\n self.sample_train_loader = dataloader_class(self.sample_train_dataset, batch_size=self.config.train_batch_size,\n shuffle=False, pin_memory=True,\n num_workers=self.config.num_workers)\n\n # TODO: Update val dataset so that it doesn't have to be treated like a train dataset\n # includes is_train=False and no_train_cropped=self.config.no_train_cropped\n self.val_dataset = ImageGraphTextureDataSet(self.val_files, self.config.end_level, is_train=False,\n circle_radius=self.config.circle_radius,\n transform=transf_valid, benchmark=False,\n no_train_cropped=self.config.no_train_cropped,\n img_size=self.config.img_size, max_items=self.config.max_items,\n crop_half_width=self.config.crop_half_width)\n print('val dataset len', len(self.val_dataset))\n\n #unit_tests.compare_train_val(self.train_colors, self.val_colors)\n\n self.val_loader = dataloader_class(self.val_dataset, batch_size=self.config.test_batch_size, shuffle=False,\n pin_memory=True, persistent_workers=self.config.num_workers > 0,\n num_workers=self.config.num_workers)\n self.sample_val_dataset = torch.utils.data.Subset(self.val_dataset,\n np.arange(min(self.config.num_static_samples,\n len(self.val_dataset))))\n self.sample_val_loader = dataloader_class(self.sample_val_dataset, batch_size=self.config.test_batch_size,\n shuffle=False, pin_memory=True,\n num_workers=self.config.num_workers)\n\n def _load(self, root_dir, seed=42) -> List[str]:\n filenames = glob.glob(f\"{root_dir}/*.png\")\n filenames = sorted(filenames)\n random.Random(seed).shuffle(filenames)\n return filenames"
] | [
[
"torch.zeros",
"numpy.random.choice",
"numpy.reshape",
"torch.reshape",
"torch.cat",
"numpy.arange",
"torch.from_numpy",
"scipy.ndimage.rotate",
"torch.tensor",
"numpy.repeat",
"numpy.array",
"numpy.flip",
"numpy.random.randint"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16",
"1.8"
],
"tensorflow": []
}
] |
monarch-initiative/N2V | [
"8ae02ca125f1d24ca158c2849f2d9bb1711920b9",
"8ae02ca125f1d24ca158c2849f2d9bb1711920b9",
"8ae02ca125f1d24ca158c2849f2d9bb1711920b9",
"8ae02ca125f1d24ca158c2849f2d9bb1711920b9"
] | [
"embiggen/edge_prediction/edge_prediction_sklearn/random_forest_edge_prediction.py",
"embiggen/sequences/tensorflow_sequences/gcn_edge_label_prediction_training_sequence.py",
"embiggen/sequences/tensorflow_sequences/node_label_prediction_sequence.py",
"embiggen/layers/tensorflow/ElementWiseL2.py"
] | [
"\"\"\"Submodule wrapping Random Forest for edge prediction.\"\"\"\nfrom typing import Dict, Any\nfrom sklearn.ensemble import RandomForestClassifier\nfrom embiggen.edge_prediction.edge_prediction_sklearn.decision_tree_edge_prediction import DecisionTreeEdgePrediction\nfrom embiggen.edge_prediction.edge_prediction_sklearn.sklearn_edge_prediction_adapter import SklearnEdgePredictionAdapter\n\n\nclass RandomForestEdgePrediction(SklearnEdgePredictionAdapter):\n \"\"\"Create wrapper over Sklearn Random Forest classifier for edge prediction.\"\"\"\n\n def __init__(\n self,\n n_estimators: int = 1000,\n criterion: str = \"gini\",\n max_depth: int = 10,\n min_samples_split: int = 2,\n min_samples_leaf: int = 1,\n min_weight_fraction_leaf: float = 0.,\n max_features=\"auto\",\n max_leaf_nodes=None,\n min_impurity_decrease=0.,\n bootstrap=True,\n oob_score=False,\n n_jobs=-1,\n verbose=0,\n warm_start=False,\n class_weight=None,\n ccp_alpha=0.0,\n max_samples=None,\n edge_embedding_method: str = \"Concatenate\",\n training_unbalance_rate: float = 1.0,\n training_sample_only_edges_with_heterogeneous_node_types: bool = False,\n use_edge_metrics: bool = False,\n use_zipfian_sampling: bool = True,\n prediction_batch_size: int = 2**12,\n random_state: int = 42\n ):\n \"\"\"Create the Random Forest for Edge Prediction.\"\"\"\n self._n_estimators = n_estimators\n self._criterion = criterion\n self._max_depth = max_depth\n self._min_samples_split = min_samples_split\n self._min_samples_leaf = min_samples_leaf\n self._min_weight_fraction_leaf = min_weight_fraction_leaf\n self._max_features = max_features\n self._max_leaf_nodes = max_leaf_nodes\n self._min_impurity_decrease = min_impurity_decrease\n self._bootstrap = bootstrap\n self._oob_score = oob_score\n self._n_jobs = n_jobs\n self._random_state = random_state\n self._verbose = verbose\n self._warm_start = warm_start\n self._class_weight = class_weight\n self._ccp_alpha = ccp_alpha\n self._max_samples = max_samples\n\n super().__init__(\n RandomForestClassifier(\n n_estimators=n_estimators,\n criterion=criterion,\n max_depth=max_depth,\n min_samples_split=min_samples_split,\n min_samples_leaf=min_samples_leaf,\n min_weight_fraction_leaf=min_weight_fraction_leaf,\n max_features=max_features,\n max_leaf_nodes=max_leaf_nodes,\n min_impurity_decrease=min_impurity_decrease,\n bootstrap=bootstrap,\n oob_score=oob_score,\n n_jobs=n_jobs,\n random_state=random_state,\n verbose=verbose,\n warm_start=warm_start,\n class_weight=class_weight,\n ccp_alpha=ccp_alpha,\n max_samples=max_samples\n ),\n edge_embedding_method=edge_embedding_method,\n training_unbalance_rate=training_unbalance_rate,\n use_edge_metrics=use_edge_metrics,\n use_zipfian_sampling=use_zipfian_sampling,\n training_sample_only_edges_with_heterogeneous_node_types=training_sample_only_edges_with_heterogeneous_node_types,\n prediction_batch_size=prediction_batch_size,\n random_state=random_state\n )\n\n @staticmethod\n def smoke_test_parameters() -> Dict[str, Any]:\n \"\"\"Returns parameters for smoke test.\"\"\"\n return dict(\n **DecisionTreeEdgePrediction.smoke_test_parameters(),\n n_estimators=1\n )\n\n def parameters(self) -> Dict[str, Any]:\n \"\"\"Returns parameters used for this model.\"\"\"\n return {\n **super().parameters(),\n **dict(\n n_estimators = self._n_estimators,\n criterion = self._criterion,\n max_depth = self._max_depth,\n min_samples_split = self._min_samples_split,\n min_samples_leaf = self._min_samples_leaf,\n min_weight_fraction_leaf = self._min_weight_fraction_leaf,\n max_features = self._max_features,\n max_leaf_nodes = self._max_leaf_nodes,\n min_impurity_decrease = self._min_impurity_decrease,\n bootstrap = self._bootstrap,\n oob_score = self._oob_score,\n n_jobs = self._n_jobs,\n random_state = self._random_state,\n verbose = self._verbose,\n warm_start = self._warm_start,\n class_weight = self._class_weight,\n ccp_alpha = self._ccp_alpha,\n max_samples = self._max_samples,\n )\n }\n\n \n @staticmethod\n def model_name() -> str:\n return \"Random Forest Classifier\"",
"\"\"\"Keras Sequence for Open-world assumption GCN.\"\"\"\nfrom typing import List, Optional\n\nimport numpy as np\nimport tensorflow as tf\nfrom ensmallen import Graph # pylint: disable=no-name-in-module\nfrom keras_mixed_sequence import VectorSequence\nfrom embiggen.sequences.tensorflow_sequences.gcn_edge_prediction_sequence import GCNEdgePredictionSequence\n\n\nclass GCNEdgeLabelPredictionTrainingSequence(GCNEdgePredictionSequence):\n \"\"\"Keras Sequence for running Neural Network on graph edge-label prediction.\"\"\"\n\n def __init__(\n self,\n graph: Graph,\n support: Graph,\n kernel: tf.SparseTensor,\n return_node_types: bool = False,\n return_node_ids: bool = False,\n node_features: Optional[List[np.ndarray]] = None,\n node_type_features: Optional[List[np.ndarray]] = None,\n edge_features: Optional[List[np.ndarray]] = None,\n use_edge_metrics: bool = False,\n ):\n \"\"\"Create new Open-world assumption GCN training sequence for edge prediction.\n\n Parameters\n --------------------------------\n graph: Graph,\n The graph from which to sample the edges.\n support: Graph\n The graph to be used for the topological metrics.\n kernel: tf.SparseTensor\n The kernel to be used for the convolutions.\n return_node_types: bool = False\n Whether to return the node types.\n return_edge_types: bool = False\n Whether to return the edge types.\n return_node_ids: bool = False\n Whether to return the node IDs.\n These are needed when an embedding layer is used.\n node_features: List[np.ndarray]\n The node features to be used.\n node_type_features: Optional[List[np.ndarray]]\n The node type features to be used.\n For instance, these could be BERT embeddings of the\n description of the node types.\n When the graph has multilabel node types,\n we will average the features.\n edge_features: Optional[List[np.ndarray]] = None,\n\n use_edge_metrics: bool = False\n Whether to return the edge metrics.\n \"\"\"\n super().__init__(\n graph=graph,\n support=support,\n kernel=kernel,\n return_node_types=return_node_types,\n return_edge_types=True,\n return_node_ids=return_node_ids,\n node_features=node_features,\n node_type_features=node_type_features,\n edge_features=edge_features,\n use_edge_metrics=use_edge_metrics,\n )\n\n self._known_edge_types_mask_sequence = VectorSequence(\n graph.get_known_edge_types_mask().astype(np.float32),\n batch_size=graph.get_nodes_number(),\n shuffle=False\n )\n\n # The index in the returned sequence that contains the\n # edge label is 2 (source and destination nodes).\n self._edge_label_index = 2\n\n def __call__(self):\n \"\"\"Return next batch using an infinite generator model.\"\"\"\n self._current_index += 1\n return (self[self._current_index],) \n\n def into_dataset(self) -> tf.data.Dataset:\n \"\"\"Return dataset generated out of the current sequence instance.\n\n Implementative details\n ---------------------------------\n This method handles the conversion of this Keras Sequence into\n a TensorFlow dataset, also handling the proper dispatching according\n to what version of TensorFlow is installed in this system.\n\n Returns\n ----------------------------------\n Dataset to be used for the training of a model\n \"\"\"\n raise NotImplementedError(\"TODO!\")\n\n def __getitem__(self, idx: int):\n \"\"\"Return batch corresponding to given index.\n\n Parameters\n ---------------\n idx: int,\n Index corresponding to batch to be returned.\n\n Returns\n ---------------\n Return Tuple containing X and Y numpy arrays corresponding to given batch index.\n \"\"\"\n batch = super().__getitem__(idx)[0]\n mask = self._known_edge_types_mask_sequence[idx]\n delta = self.batch_size - mask.size\n if delta > 0:\n mask = np.pad(mask, (0, delta))\n\n return (\n tuple([\n value\n for value in (\n *batch[:self._edge_label_index],\n *batch[self._edge_label_index+1:]\n )\n ]),\n batch[self._edge_label_index],\n mask\n )\n",
"\"\"\"Keras Sequence for running Neural Network on graph node-label embedding.\"\"\"\nfrom typing import Tuple, Union, Optional\n\nimport numpy as np\nimport tensorflow as tf\nfrom ensmallen import Graph\nfrom keras_mixed_sequence import Sequence\n\n\nclass NodeLabelPredictionSequence(Sequence):\n \"\"\"Keras Sequence for running Neural Network on graph node-label prediction.\"\"\"\n\n def __init__(\n self,\n graph: Graph,\n max_neighbours: Optional[int] = 100,\n include_central_node: bool = False,\n return_edge_weights: bool = False,\n batch_size: int = 2**8,\n elapsed_epochs: int = 0,\n random_state: int = 42,\n ):\n \"\"\"Create new Node Label Prediction Sequence.\n \"\"\"\n self._graph = graph\n self._random_state = random_state\n self._include_central_node = include_central_node\n self._return_edge_weights = return_edge_weights\n self._max_neighbours = max_neighbours\n super().__init__(\n sample_number=graph.get_number_of_directed_edges(),\n batch_size=batch_size,\n elapsed_epochs=elapsed_epochs\n )\n\n def __getitem__(self, idx: int) -> Tuple[Union[tf.RaggedTensor, Tuple[tf.RaggedTensor]], np.ndarray]:\n \"\"\"Return batch corresponding to given index.\n\n Parameters\n ---------------\n idx: int,\n Index corresponding to batch to be returned.\n\n Returns\n ---------------\n Return Tuple containing X and Y numpy arrays corresponding to given batch index.\n \"\"\"\n neighbours, weights, labels = self._graph.get_node_label_prediction_mini_batch(\n idx=(self._random_state + idx) * (1 + self.elapsed_epochs),\n batch_size=self._batch_size,\n include_central_node=self._include_central_node,\n return_edge_weights=self._return_edge_weights,\n max_neighbours=self._max_neighbours\n )\n\n if self._return_edge_weights:\n return (tf.ragged.constant(neighbours), tf.ragged.constant(weights)), labels\n return tf.ragged.constant(neighbours), labels\n",
"\"\"\"Submodule providing element-wise L2 distance layer.\"\"\"\nfrom typing import Tuple, Dict\nimport tensorflow as tf\nfrom tensorflow.keras import backend as K\nfrom tensorflow.keras.layers import Subtract, Lambda, Layer # pylint: disable=import-error,no-name-in-module\n\n\nclass ElementWiseL2(Layer):\n \"\"\"Layer implementing element-wise L2 distance layer.\"\"\"\n\n def __init__(\n self,\n **kwargs: Dict\n ):\n \"\"\"Create new element-wise L2 distance layer.\n\n Parameters\n ----------------------\n **kwargs: Dict,\n Kwargs to pass to the parent Layer class.\n \"\"\"\n super().__init__(**kwargs)\n self._subtraction = None\n self._squaring = None\n\n def build(self, input_shape) -> None:\n \"\"\"Build the element-wise L2 distance layer.\n\n Parameters\n ------------------------------\n input_shape\n Shape of the output of the previous layer.\n \"\"\"\n self._subtraction = Subtract()\n self._squaring = Lambda(lambda x: K.pow(x, 2))\n super().build(input_shape)\n\n def call(\n self,\n inputs: Tuple[tf.Tensor],\n ) -> tf.Tensor:\n return self._squaring(self._subtraction(inputs))\n"
] | [
[
"sklearn.ensemble.RandomForestClassifier"
],
[
"numpy.pad"
],
[
"tensorflow.ragged.constant"
],
[
"tensorflow.keras.backend.pow",
"tensorflow.keras.layers.Subtract"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"2.6",
"2.4",
"2.3",
"2.5",
"2.2"
]
}
] |
robotastic/tensorflow | [
"b88f9f60de706dbe78acf9189b9fa04bdc7a6836"
] | [
"tensorflow/python/framework/dtypes_test.py"
] | [
"# Copyright 2015 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 tensorflow.python.framework.dtypes.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\n\nfrom tensorflow.core.framework import types_pb2\nfrom tensorflow.python import tf2\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.platform import googletest\n\n\ndef _is_numeric_dtype_enum(datatype_enum):\n non_numeric_dtypes = [types_pb2.DT_VARIANT,\n types_pb2.DT_VARIANT_REF,\n types_pb2.DT_INVALID,\n types_pb2.DT_RESOURCE,\n types_pb2.DT_RESOURCE_REF]\n return datatype_enum not in non_numeric_dtypes\n\n\nclass TypesTest(test_util.TensorFlowTestCase):\n\n def testAllTypesConstructible(self):\n for datatype_enum in types_pb2.DataType.values():\n if datatype_enum == types_pb2.DT_INVALID:\n continue\n self.assertEqual(datatype_enum,\n dtypes.DType(datatype_enum).as_datatype_enum)\n\n def testAllTypesConvertibleToDType(self):\n for datatype_enum in types_pb2.DataType.values():\n if datatype_enum == types_pb2.DT_INVALID:\n continue\n dt = dtypes.as_dtype(datatype_enum)\n self.assertEqual(datatype_enum, dt.as_datatype_enum)\n\n def testAllTypesConvertibleToNumpyDtype(self):\n for datatype_enum in types_pb2.DataType.values():\n if not _is_numeric_dtype_enum(datatype_enum):\n continue\n dtype = dtypes.as_dtype(datatype_enum)\n numpy_dtype = dtype.as_numpy_dtype\n _ = np.empty((1, 1, 1, 1), dtype=numpy_dtype)\n if dtype.base_dtype != dtypes.bfloat16:\n # NOTE(touts): Intentionally no way to feed a DT_BFLOAT16.\n self.assertEqual(\n dtypes.as_dtype(datatype_enum).base_dtype,\n dtypes.as_dtype(numpy_dtype))\n\n def testInvalid(self):\n with self.assertRaises(TypeError):\n dtypes.DType(types_pb2.DT_INVALID)\n with self.assertRaises(TypeError):\n dtypes.as_dtype(types_pb2.DT_INVALID)\n\n def testNumpyConversion(self):\n self.assertIs(dtypes.float32, dtypes.as_dtype(np.float32))\n self.assertIs(dtypes.float64, dtypes.as_dtype(np.float64))\n self.assertIs(dtypes.int32, dtypes.as_dtype(np.int32))\n self.assertIs(dtypes.int64, dtypes.as_dtype(np.int64))\n self.assertIs(dtypes.uint8, dtypes.as_dtype(np.uint8))\n self.assertIs(dtypes.uint16, dtypes.as_dtype(np.uint16))\n self.assertIs(dtypes.int16, dtypes.as_dtype(np.int16))\n self.assertIs(dtypes.int8, dtypes.as_dtype(np.int8))\n self.assertIs(dtypes.complex64, dtypes.as_dtype(np.complex64))\n self.assertIs(dtypes.complex128, dtypes.as_dtype(np.complex128))\n self.assertIs(dtypes.string, dtypes.as_dtype(np.object_))\n self.assertIs(dtypes.string,\n dtypes.as_dtype(np.array([\"foo\", \"bar\"]).dtype))\n self.assertIs(dtypes.bool, dtypes.as_dtype(np.bool_))\n with self.assertRaises(TypeError):\n dtypes.as_dtype(np.dtype([(\"f1\", np.uint), (\"f2\", np.int32)]))\n\n def testRealDtype(self):\n for dtype in [\n dtypes.float32, dtypes.float64, dtypes.bool, dtypes.uint8, dtypes.int8,\n dtypes.int16, dtypes.int32, dtypes.int64\n ]:\n self.assertIs(dtype.real_dtype, dtype)\n self.assertIs(dtypes.complex64.real_dtype, dtypes.float32)\n self.assertIs(dtypes.complex128.real_dtype, dtypes.float64)\n\n def testStringConversion(self):\n self.assertIs(dtypes.float32, dtypes.as_dtype(\"float32\"))\n self.assertIs(dtypes.float64, dtypes.as_dtype(\"float64\"))\n self.assertIs(dtypes.int32, dtypes.as_dtype(\"int32\"))\n self.assertIs(dtypes.uint8, dtypes.as_dtype(\"uint8\"))\n self.assertIs(dtypes.uint16, dtypes.as_dtype(\"uint16\"))\n self.assertIs(dtypes.int16, dtypes.as_dtype(\"int16\"))\n self.assertIs(dtypes.int8, dtypes.as_dtype(\"int8\"))\n self.assertIs(dtypes.string, dtypes.as_dtype(\"string\"))\n self.assertIs(dtypes.complex64, dtypes.as_dtype(\"complex64\"))\n self.assertIs(dtypes.complex128, dtypes.as_dtype(\"complex128\"))\n self.assertIs(dtypes.int64, dtypes.as_dtype(\"int64\"))\n self.assertIs(dtypes.bool, dtypes.as_dtype(\"bool\"))\n self.assertIs(dtypes.qint8, dtypes.as_dtype(\"qint8\"))\n self.assertIs(dtypes.quint8, dtypes.as_dtype(\"quint8\"))\n self.assertIs(dtypes.qint32, dtypes.as_dtype(\"qint32\"))\n self.assertIs(dtypes.bfloat16, dtypes.as_dtype(\"bfloat16\"))\n self.assertIs(dtypes.float32_ref, dtypes.as_dtype(\"float32_ref\"))\n self.assertIs(dtypes.float64_ref, dtypes.as_dtype(\"float64_ref\"))\n self.assertIs(dtypes.int32_ref, dtypes.as_dtype(\"int32_ref\"))\n self.assertIs(dtypes.uint8_ref, dtypes.as_dtype(\"uint8_ref\"))\n self.assertIs(dtypes.int16_ref, dtypes.as_dtype(\"int16_ref\"))\n self.assertIs(dtypes.int8_ref, dtypes.as_dtype(\"int8_ref\"))\n self.assertIs(dtypes.string_ref, dtypes.as_dtype(\"string_ref\"))\n self.assertIs(dtypes.complex64_ref, dtypes.as_dtype(\"complex64_ref\"))\n self.assertIs(dtypes.complex128_ref, dtypes.as_dtype(\"complex128_ref\"))\n self.assertIs(dtypes.int64_ref, dtypes.as_dtype(\"int64_ref\"))\n self.assertIs(dtypes.bool_ref, dtypes.as_dtype(\"bool_ref\"))\n self.assertIs(dtypes.qint8_ref, dtypes.as_dtype(\"qint8_ref\"))\n self.assertIs(dtypes.quint8_ref, dtypes.as_dtype(\"quint8_ref\"))\n self.assertIs(dtypes.qint32_ref, dtypes.as_dtype(\"qint32_ref\"))\n self.assertIs(dtypes.bfloat16_ref, dtypes.as_dtype(\"bfloat16_ref\"))\n with self.assertRaises(TypeError):\n dtypes.as_dtype(\"not_a_type\")\n\n def testDTypesHaveUniqueNames(self):\n dtypez = []\n names = set()\n for datatype_enum in types_pb2.DataType.values():\n if datatype_enum == types_pb2.DT_INVALID:\n continue\n dtype = dtypes.as_dtype(datatype_enum)\n dtypez.append(dtype)\n names.add(dtype.name)\n self.assertEqual(len(dtypez), len(names))\n\n def testIsInteger(self):\n self.assertEqual(dtypes.as_dtype(\"int8\").is_integer, True)\n self.assertEqual(dtypes.as_dtype(\"int16\").is_integer, True)\n self.assertEqual(dtypes.as_dtype(\"int32\").is_integer, True)\n self.assertEqual(dtypes.as_dtype(\"int64\").is_integer, True)\n self.assertEqual(dtypes.as_dtype(\"uint8\").is_integer, True)\n self.assertEqual(dtypes.as_dtype(\"uint16\").is_integer, True)\n self.assertEqual(dtypes.as_dtype(\"complex64\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"complex128\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"float\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"double\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"string\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"bool\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"bfloat16\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"qint8\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"qint16\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"qint32\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"quint8\").is_integer, False)\n self.assertEqual(dtypes.as_dtype(\"quint16\").is_integer, False)\n\n def testIsFloating(self):\n self.assertEqual(dtypes.as_dtype(\"int8\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"int16\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"int32\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"int64\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"uint8\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"uint16\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"complex64\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"complex128\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"float32\").is_floating, True)\n self.assertEqual(dtypes.as_dtype(\"float64\").is_floating, True)\n self.assertEqual(dtypes.as_dtype(\"string\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"bool\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"bfloat16\").is_floating, True)\n self.assertEqual(dtypes.as_dtype(\"qint8\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"qint16\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"qint32\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"quint8\").is_floating, False)\n self.assertEqual(dtypes.as_dtype(\"quint16\").is_floating, False)\n\n def testIsComplex(self):\n self.assertEqual(dtypes.as_dtype(\"int8\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"int16\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"int32\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"int64\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"uint8\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"uint16\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"complex64\").is_complex, True)\n self.assertEqual(dtypes.as_dtype(\"complex128\").is_complex, True)\n self.assertEqual(dtypes.as_dtype(\"float32\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"float64\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"string\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"bool\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"bfloat16\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"qint8\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"qint16\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"qint32\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"quint8\").is_complex, False)\n self.assertEqual(dtypes.as_dtype(\"quint16\").is_complex, False)\n\n def testIsUnsigned(self):\n self.assertEqual(dtypes.as_dtype(\"int8\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"int16\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"int32\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"int64\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"uint8\").is_unsigned, True)\n self.assertEqual(dtypes.as_dtype(\"uint16\").is_unsigned, True)\n self.assertEqual(dtypes.as_dtype(\"float32\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"float64\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"bool\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"string\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"complex64\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"complex128\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"bfloat16\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"qint8\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"qint16\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"qint32\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"quint8\").is_unsigned, False)\n self.assertEqual(dtypes.as_dtype(\"quint16\").is_unsigned, False)\n\n def testMinMax(self):\n # make sure min/max evaluates for all data types that have min/max\n for datatype_enum in types_pb2.DataType.values():\n if not _is_numeric_dtype_enum(datatype_enum):\n continue\n dtype = dtypes.as_dtype(datatype_enum)\n numpy_dtype = dtype.as_numpy_dtype\n\n # ignore types for which there are no minimum/maximum (or we cannot\n # compute it, such as for the q* types)\n if (dtype.is_quantized or dtype.base_dtype == dtypes.bool or\n dtype.base_dtype == dtypes.string or\n dtype.base_dtype == dtypes.complex64 or\n dtype.base_dtype == dtypes.complex128):\n continue\n\n print(\"%s: %s - %s\" % (dtype, dtype.min, dtype.max))\n\n # check some values that are known\n if numpy_dtype == np.bool_:\n self.assertEquals(dtype.min, 0)\n self.assertEquals(dtype.max, 1)\n if numpy_dtype == np.int8:\n self.assertEquals(dtype.min, -128)\n self.assertEquals(dtype.max, 127)\n if numpy_dtype == np.int16:\n self.assertEquals(dtype.min, -32768)\n self.assertEquals(dtype.max, 32767)\n if numpy_dtype == np.int32:\n self.assertEquals(dtype.min, -2147483648)\n self.assertEquals(dtype.max, 2147483647)\n if numpy_dtype == np.int64:\n self.assertEquals(dtype.min, -9223372036854775808)\n self.assertEquals(dtype.max, 9223372036854775807)\n if numpy_dtype == np.uint8:\n self.assertEquals(dtype.min, 0)\n self.assertEquals(dtype.max, 255)\n if numpy_dtype == np.uint16:\n if dtype == dtypes.uint16:\n self.assertEquals(dtype.min, 0)\n self.assertEquals(dtype.max, 65535)\n elif dtype == dtypes.bfloat16:\n self.assertEquals(dtype.min, 0)\n self.assertEquals(dtype.max, 4294967295)\n if numpy_dtype == np.uint32:\n self.assertEquals(dtype.min, 0)\n self.assertEquals(dtype.max, 4294967295)\n if numpy_dtype == np.uint64:\n self.assertEquals(dtype.min, 0)\n self.assertEquals(dtype.max, 18446744073709551615)\n if numpy_dtype in (np.float16, np.float32, np.float64):\n self.assertEquals(dtype.min, np.finfo(numpy_dtype).min)\n self.assertEquals(dtype.max, np.finfo(numpy_dtype).max)\n if numpy_dtype == dtypes.bfloat16.as_numpy_dtype:\n self.assertEquals(dtype.min, float.fromhex(\"-0x1.FEp127\"))\n self.assertEquals(dtype.max, float.fromhex(\"0x1.FEp127\"))\n\n def testRepr(self):\n if tf2.enabled():\n self.skipTest(\"b/142725777\")\n for enum, name in dtypes._TYPE_TO_STRING.items():\n if enum > 100:\n continue\n dtype = dtypes.DType(enum)\n self.assertEquals(repr(dtype), \"tf.\" + name)\n import tensorflow as tf\n dtype2 = eval(repr(dtype))\n self.assertEquals(type(dtype2), dtypes.DType)\n self.assertEquals(dtype, dtype2)\n\n def testEqWithNonTFTypes(self):\n self.assertNotEqual(dtypes.int32, int)\n self.assertNotEqual(dtypes.float64, 2.1)\n\n def testPythonLongConversion(self):\n self.assertIs(dtypes.int64, dtypes.as_dtype(np.array(2**32).dtype))\n\n def testPythonTypesConversion(self):\n self.assertIs(dtypes.float32, dtypes.as_dtype(float))\n self.assertIs(dtypes.bool, dtypes.as_dtype(bool))\n\n def testReduce(self):\n for enum in dtypes._TYPE_TO_STRING:\n dtype = dtypes.DType(enum)\n ctor, args = dtype.__reduce__()\n self.assertEquals(ctor, dtypes.as_dtype)\n self.assertEquals(args, (dtype.name,))\n reconstructed = ctor(*args)\n self.assertEquals(reconstructed, dtype)\n\n def testAsDtypeInvalidArgument(self):\n with self.assertRaises(TypeError):\n dtypes.as_dtype((dtypes.int32, dtypes.float32))\n\n\nif __name__ == \"__main__\":\n googletest.main()\n\n"
] | [
[
"tensorflow.core.framework.types_pb2.DataType.values",
"numpy.dtype",
"numpy.finfo",
"tensorflow.python.framework.dtypes.as_dtype",
"tensorflow.python.framework.dtypes._TYPE_TO_STRING.items",
"tensorflow.python.tf2.enabled",
"tensorflow.python.framework.dtypes.DType",
"tensorflow.python.platform.googletest.main",
"numpy.array",
"numpy.empty"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.7",
"2.6",
"2.2",
"1.13",
"2.3",
"2.4",
"2.9",
"2.5",
"2.8",
"2.10"
]
}
] |
sksingh22698/Breast-Cancer-Detection | [
"c474341e0dd570fee59c139380ac094c6d6a7561"
] | [
"proj.py"
] | [
"import sys\r\nimport numpy\r\nimport matplotlib\r\nimport pandas\r\nimport sklearn\r\n\r\n\r\nprint('Python: {}'.format(sys.version))\r\nprint('Numpy: {}'.format(numpy.__version__))\r\nprint('matplotlib: {}'.format(matplotlib.__version__))\r\nprint('Python: {}'.format(pandas.__version__))\r\nprint('Python: {}'.format(sklearn.__version__))\r\nimport numpy as np\r\nfrom sklearn import preprocessing\r\n#from sklearn import cross_validation\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.neighbors import KNeighborsClassifier\r\nfrom sklearn.svm import SVC\r\nfrom sklearn import model_selection\r\nfrom sklearn.metrics import classification_report, accuracy_score\r\nfrom pandas.plotting import scatter_matrix\r\nimport matplotlib.pyplot as plt\r\nimport pandas as pd\r\n\r\n#loading the data\r\nnames = ['id', 'clump_thickness','uniform_cell_size','uniform_cell_shape',\r\n 'marginal_adhesion','signle_epithelial_size','bare_nuclei',\r\n\t\t 'bland_chromatin','normal_nucleoli','mitoses','class']\r\n\t\t \r\ndf = pd.read_csv(\"data1.csv\", names=names)\r\n\r\n#preprocess the data\r\ndf.replace('?', -99999, inplace=True)\r\nprint(df.axes)\r\n\r\ndf.drop(['id'], 1, inplace=True)\r\n\r\n#print the shape of dataset\r\nprint(df.shape)\r\n\r\n#do dataset visualization\r\nprint(df.loc[6])\r\nprint(df.describe())\r\n\r\n#plot histograms for each variable\r\ndf.hist(figsize = (10,10))\r\nplt.show()\r\n\r\n#create scatter plot matrix\r\nscatter_matrix(df, figsize = (18,18))\r\nplt.show()\r\n\r\n# create X and Y datasets for training\r\nX = np.array(df.drop(['class'], 1))\r\nY = np.array(df['class'])\r\n\"\"\"\"\r\nX_train = cross_validation.train_test_split(X,Y,test_size = 0.2)\r\nX_test = cross_validation.train_test_split(X,Y,test_size = 0.2)\r\nY_train = cross_validation.train_test_split(X,Y,test_size = 0.2)\r\nY_test = cross_validation.train_test_split(X,Y,test_size = 0.2)\r\n\"\"\"\r\nX_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.2)\r\n#specify testing options\r\nseed = 8\r\nscoring = 'accuracy'\r\n\r\n#define the models to train\r\nmodels = []\r\nmodels.append(('KNN', KNeighborsClassifier(n_neighbors =5)))\r\nmodels.append(('SVM',SVC()))\r\n\r\n\r\n#evaluation each model in turn\r\nresult = []\r\nnames = []\r\n\r\nfor name, model in models:\r\n\tkfold = model_selection.KFold(n_splits=10, random_state=seed)\r\n\tcv_results = model_selection.cross_val_score(model, X_train , Y_train, cv=kfold, scoring=scoring)\r\n\tresult.append(cv_results)\r\n\tnames.append(name)\r\n\tmsg = \"%s: %f (%f)\" % (name, cv_results.mean(), cv_results.std())\r\n\tprint(msg)\r\n\t\r\n#make prediction on valid dataset\r\nfor name, model in models:\r\n\tmodel.fit(X_train,Y_train)\r\n\tpredictions = model.predict(X_test)\r\n\tprint(name)\r\n\tprint(accuracy_score(Y_test,predictions))\r\n\tprint(classification_report(Y_test,predictions))\r\n \r\nclf = SVC()\r\nclf.fit(X_train, Y_train)\r\naccuracy = clf.score(X_test, Y_test)\r\nprint(accuracy)\r\n\r\nexample = np.array([[4,2,1,1,1,2,3,2,10]])\r\nexample = example.reshape(len(example), -1)\r\nprediction = clf.predict(example)\r\nprint(prediction)"
] | [
[
"pandas.read_csv",
"sklearn.model_selection.cross_val_score",
"sklearn.model_selection.train_test_split",
"sklearn.model_selection.KFold",
"sklearn.neighbors.KNeighborsClassifier",
"sklearn.metrics.classification_report",
"sklearn.svm.SVC",
"numpy.array",
"pandas.plotting.scatter_matrix",
"matplotlib.pyplot.show",
"sklearn.metrics.accuracy_score"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
DennissimOS/platform_external_tensorflow | [
"8ee732dae6202eac9c9ef1f14a94ba96fde677ce",
"e5a536fbd36ed64a7a63516299a3061944864080"
] | [
"tensorflow/python/tools/freeze_graph.py",
"tensorflow/python/layers/utils.py"
] | [
"# Copyright 2015 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# ==============================================================================\nr\"\"\"Converts checkpoint variables into Const ops in a standalone GraphDef file.\n\nThis script is designed to take a GraphDef proto, a SaverDef proto, and a set of\nvariable values stored in a checkpoint file, and output a GraphDef with all of\nthe variable ops converted into const ops containing the values of the\nvariables.\n\nIt's useful to do this when we need to load a single file in C++, especially in\nenvironments like mobile or embedded where we may not have access to the\nRestoreTensor ops and file loading calls that they rely on.\n\nAn example of command-line usage is:\nbazel build tensorflow/python/tools:freeze_graph && \\\nbazel-bin/tensorflow/python/tools/freeze_graph \\\n--input_graph=some_graph_def.pb \\\n--input_checkpoint=model.ckpt-8361242 \\\n--output_graph=/tmp/frozen_graph.pb --output_node_names=softmax\n\nYou can also look at freeze_graph_test.py for an example of how to use it.\n\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport argparse\nimport sys\n\nfrom google.protobuf import text_format\n\nfrom tensorflow.core.framework import graph_pb2\nfrom tensorflow.core.protobuf import saver_pb2\nfrom tensorflow.core.protobuf.meta_graph_pb2 import MetaGraphDef\nfrom tensorflow.python import pywrap_tensorflow\nfrom tensorflow.python.client import session\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import importer\nfrom tensorflow.python.platform import app\nfrom tensorflow.python.platform import gfile\nfrom tensorflow.python.saved_model import loader\nfrom tensorflow.python.saved_model import tag_constants\nfrom tensorflow.python.tools import saved_model_utils\nfrom tensorflow.python.training import saver as saver_lib\n\nFLAGS = None\n\n\ndef freeze_graph_with_def_protos(input_graph_def,\n input_saver_def,\n input_checkpoint,\n output_node_names,\n restore_op_name,\n filename_tensor_name,\n output_graph,\n clear_devices,\n initializer_nodes,\n variable_names_whitelist=\"\",\n variable_names_blacklist=\"\",\n input_meta_graph_def=None,\n input_saved_model_dir=None,\n saved_model_tags=None,\n checkpoint_version=saver_pb2.SaverDef.V2):\n \"\"\"Converts all variables in a graph and checkpoint into constants.\"\"\"\n del restore_op_name, filename_tensor_name # Unused by updated loading code.\n\n # 'input_checkpoint' may be a prefix if we're using Saver V2 format\n if (not input_saved_model_dir and\n not saver_lib.checkpoint_exists(input_checkpoint)):\n print(\"Input checkpoint '\" + input_checkpoint + \"' doesn't exist!\")\n return -1\n\n if not output_node_names:\n print(\"You need to supply the name of a node to --output_node_names.\")\n return -1\n\n # Remove all the explicit device specifications for this node. This helps to\n # make the graph more portable.\n if clear_devices:\n if input_meta_graph_def:\n for node in input_meta_graph_def.graph_def.node:\n node.device = \"\"\n elif input_graph_def:\n for node in input_graph_def.node:\n node.device = \"\"\n\n if input_graph_def:\n _ = importer.import_graph_def(input_graph_def, name=\"\")\n with session.Session() as sess:\n if input_saver_def:\n saver = saver_lib.Saver(\n saver_def=input_saver_def, write_version=checkpoint_version)\n saver.restore(sess, input_checkpoint)\n elif input_meta_graph_def:\n restorer = saver_lib.import_meta_graph(\n input_meta_graph_def, clear_devices=True)\n restorer.restore(sess, input_checkpoint)\n if initializer_nodes:\n sess.run(initializer_nodes.replace(' ', '').split(\",\"))\n elif input_saved_model_dir:\n if saved_model_tags is None:\n saved_model_tags = []\n loader.load(sess, saved_model_tags, input_saved_model_dir)\n else:\n var_list = {}\n reader = pywrap_tensorflow.NewCheckpointReader(input_checkpoint)\n var_to_shape_map = reader.get_variable_to_shape_map()\n for key in var_to_shape_map:\n try:\n tensor = sess.graph.get_tensor_by_name(key + \":0\")\n except KeyError:\n # This tensor doesn't exist in the graph (for example it's\n # 'global_step' or a similar housekeeping element) so skip it.\n continue\n var_list[key] = tensor\n saver = saver_lib.Saver(\n var_list=var_list, write_version=checkpoint_version)\n saver.restore(sess, input_checkpoint)\n if initializer_nodes:\n sess.run(initializer_nodes.replace(' ', '').split(\",\"))\n\n variable_names_whitelist = (\n variable_names_whitelist.replace(' ', '').split(\",\")\n if variable_names_whitelist else None)\n variable_names_blacklist = (\n variable_names_blacklist.replace(' ', '').split(\",\")\n if variable_names_blacklist else None)\n\n if input_meta_graph_def:\n output_graph_def = graph_util.convert_variables_to_constants(\n sess,\n input_meta_graph_def.graph_def,\n output_node_names.replace(' ', '').split(\",\"),\n variable_names_whitelist=variable_names_whitelist,\n variable_names_blacklist=variable_names_blacklist)\n else:\n output_graph_def = graph_util.convert_variables_to_constants(\n sess,\n input_graph_def,\n output_node_names.replace(' ', '').split(\",\"),\n variable_names_whitelist=variable_names_whitelist,\n variable_names_blacklist=variable_names_blacklist)\n\n # Write GraphDef to file if output path has been given.\n if output_graph:\n with gfile.GFile(output_graph, \"wb\") as f:\n f.write(output_graph_def.SerializeToString())\n\n return output_graph_def\n\n\ndef _parse_input_graph_proto(input_graph, input_binary):\n \"\"\"Parser input tensorflow graph into GraphDef proto.\"\"\"\n if not gfile.Exists(input_graph):\n print(\"Input graph file '\" + input_graph + \"' does not exist!\")\n return -1\n input_graph_def = graph_pb2.GraphDef()\n mode = \"rb\" if input_binary else \"r\"\n with gfile.FastGFile(input_graph, mode) as f:\n if input_binary:\n input_graph_def.ParseFromString(f.read())\n else:\n text_format.Merge(f.read(), input_graph_def)\n return input_graph_def\n\n\ndef _parse_input_meta_graph_proto(input_graph, input_binary):\n \"\"\"Parser input tensorflow graph into MetaGraphDef proto.\"\"\"\n if not gfile.Exists(input_graph):\n print(\"Input meta graph file '\" + input_graph + \"' does not exist!\")\n return -1\n input_meta_graph_def = MetaGraphDef()\n mode = \"rb\" if input_binary else \"r\"\n with gfile.FastGFile(input_graph, mode) as f:\n if input_binary:\n input_meta_graph_def.ParseFromString(f.read())\n else:\n text_format.Merge(f.read(), input_meta_graph_def)\n print(\"Loaded meta graph file '\" + input_graph)\n return input_meta_graph_def\n\n\ndef _parse_input_saver_proto(input_saver, input_binary):\n \"\"\"Parser input tensorflow Saver into SaverDef proto.\"\"\"\n if not gfile.Exists(input_saver):\n print(\"Input saver file '\" + input_saver + \"' does not exist!\")\n return -1\n mode = \"rb\" if input_binary else \"r\"\n with gfile.FastGFile(input_saver, mode) as f:\n saver_def = saver_pb2.SaverDef()\n if input_binary:\n saver_def.ParseFromString(f.read())\n else:\n text_format.Merge(f.read(), saver_def)\n return saver_def\n\n\ndef freeze_graph(input_graph,\n input_saver,\n input_binary,\n input_checkpoint,\n output_node_names,\n restore_op_name,\n filename_tensor_name,\n output_graph,\n clear_devices,\n initializer_nodes,\n variable_names_whitelist=\"\",\n variable_names_blacklist=\"\",\n input_meta_graph=None,\n input_saved_model_dir=None,\n saved_model_tags=tag_constants.SERVING,\n checkpoint_version=saver_pb2.SaverDef.V2):\n \"\"\"Converts all variables in a graph and checkpoint into constants.\"\"\"\n input_graph_def = None\n if input_saved_model_dir:\n input_graph_def = saved_model_utils.get_meta_graph_def(\n input_saved_model_dir, saved_model_tags).graph_def\n elif input_graph:\n input_graph_def = _parse_input_graph_proto(input_graph, input_binary)\n input_meta_graph_def = None\n if input_meta_graph:\n input_meta_graph_def = _parse_input_meta_graph_proto(\n input_meta_graph, input_binary)\n input_saver_def = None\n if input_saver:\n input_saver_def = _parse_input_saver_proto(input_saver, input_binary)\n freeze_graph_with_def_protos(\n input_graph_def,\n input_saver_def,\n input_checkpoint,\n output_node_names,\n restore_op_name,\n filename_tensor_name,\n output_graph,\n clear_devices,\n initializer_nodes,\n variable_names_whitelist,\n variable_names_blacklist,\n input_meta_graph_def,\n input_saved_model_dir,\n saved_model_tags.replace(' ', '').split(\",\"),\n checkpoint_version=checkpoint_version)\n\n\ndef main(unused_args):\n if FLAGS.checkpoint_version == 1:\n checkpoint_version = saver_pb2.SaverDef.V1\n elif FLAGS.checkpoint_version == 2:\n checkpoint_version = saver_pb2.SaverDef.V2\n else:\n print(\"Invalid checkpoint version (must be '1' or '2'): %d\" %\n FLAGS.checkpoint_version)\n return -1\n freeze_graph(FLAGS.input_graph, FLAGS.input_saver, FLAGS.input_binary,\n FLAGS.input_checkpoint, FLAGS.output_node_names,\n FLAGS.restore_op_name, FLAGS.filename_tensor_name,\n FLAGS.output_graph, FLAGS.clear_devices, FLAGS.initializer_nodes,\n FLAGS.variable_names_whitelist, FLAGS.variable_names_blacklist,\n FLAGS.input_meta_graph, FLAGS.input_saved_model_dir,\n FLAGS.saved_model_tags, checkpoint_version)\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.register(\"type\", \"bool\", lambda v: v.lower() == \"true\")\n parser.add_argument(\n \"--input_graph\",\n type=str,\n default=\"\",\n help=\"TensorFlow \\'GraphDef\\' file to load.\")\n parser.add_argument(\n \"--input_saver\",\n type=str,\n default=\"\",\n help=\"TensorFlow saver file to load.\")\n parser.add_argument(\n \"--input_checkpoint\",\n type=str,\n default=\"\",\n help=\"TensorFlow variables file to load.\")\n parser.add_argument(\n \"--checkpoint_version\",\n type=int,\n default=2,\n help=\"Tensorflow variable file format\")\n parser.add_argument(\n \"--output_graph\",\n type=str,\n default=\"\",\n help=\"Output \\'GraphDef\\' file name.\")\n parser.add_argument(\n \"--input_binary\",\n nargs=\"?\",\n const=True,\n type=\"bool\",\n default=False,\n help=\"Whether the input files are in binary format.\")\n parser.add_argument(\n \"--output_node_names\",\n type=str,\n default=\"\",\n help=\"The name of the output nodes, comma separated.\")\n parser.add_argument(\n \"--restore_op_name\",\n type=str,\n default=\"save/restore_all\",\n help=\"\"\"\\\n The name of the master restore operator. Deprecated, unused by updated \\\n loading code.\n \"\"\")\n parser.add_argument(\n \"--filename_tensor_name\",\n type=str,\n default=\"save/Const:0\",\n help=\"\"\"\\\n The name of the tensor holding the save path. Deprecated, unused by \\\n updated loading code.\n \"\"\")\n parser.add_argument(\n \"--clear_devices\",\n nargs=\"?\",\n const=True,\n type=\"bool\",\n default=True,\n help=\"Whether to remove device specifications.\")\n parser.add_argument(\n \"--initializer_nodes\",\n type=str,\n default=\"\",\n help=\"Comma separated list of initializer nodes to run before freezing.\")\n parser.add_argument(\n \"--variable_names_whitelist\",\n type=str,\n default=\"\",\n help=\"\"\"\\\n Comma separated list of variables to convert to constants. If specified, \\\n only those variables will be converted to constants.\\\n \"\"\")\n parser.add_argument(\n \"--variable_names_blacklist\",\n type=str,\n default=\"\",\n help=\"\"\"\\\n Comma separated list of variables to skip converting to constants.\\\n \"\"\")\n parser.add_argument(\n \"--input_meta_graph\",\n type=str,\n default=\"\",\n help=\"TensorFlow \\'MetaGraphDef\\' file to load.\")\n parser.add_argument(\n \"--input_saved_model_dir\",\n type=str,\n default=\"\",\n help=\"Path to the dir with TensorFlow \\'SavedModel\\' file and variables.\")\n parser.add_argument(\n \"--saved_model_tags\",\n type=str,\n default=\"serve\",\n help=\"\"\"\\\n Group of tag(s) of the MetaGraphDef to load, in string format,\\\n separated by \\',\\'. For tag-set contains multiple tags, all tags \\\n must be passed in.\\\n \"\"\")\n FLAGS, unparsed = parser.parse_known_args()\n app.run(main=main, argv=[sys.argv[0]] + unparsed)\n",
"# Copyright 2015 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\n# pylint: disable=unused-import,g-bad-import-order\n\"\"\"Contains layer utilies for input validation and format conversion.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.ops import variables\nfrom tensorflow.python.ops import control_flow_ops\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import tensor_util\nfrom tensorflow.python.util import nest\n\n\ndef convert_data_format(data_format, ndim):\n if data_format == 'channels_last':\n if ndim == 3:\n return 'NWC'\n elif ndim == 4:\n return 'NHWC'\n elif ndim == 5:\n return 'NDHWC'\n else:\n raise ValueError('Input rank not supported:', ndim)\n elif data_format == 'channels_first':\n if ndim == 3:\n return 'NCW'\n elif ndim == 4:\n return 'NCHW'\n elif ndim == 5:\n return 'NCDHW'\n else:\n raise ValueError('Input rank not supported:', ndim)\n else:\n raise ValueError('Invalid data_format:', data_format)\n\n\ndef normalize_tuple(value, n, name):\n \"\"\"Transforms a single integer or iterable of integers into an integer tuple.\n\n Arguments:\n value: The value to validate and convert. Could an int, or any iterable\n of ints.\n n: The size of the tuple to be returned.\n name: The name of the argument being validated, e.g. \"strides\" or\n \"kernel_size\". This is only used to format error messages.\n\n Returns:\n A tuple of n integers.\n\n Raises:\n ValueError: If something else than an int/long or iterable thereof was\n passed.\n \"\"\"\n if isinstance(value, int):\n return (value,) * n\n else:\n try:\n value_tuple = tuple(value)\n except TypeError:\n raise ValueError('The `' + name + '` argument must be a tuple of ' +\n str(n) + ' integers. Received: ' + str(value))\n if len(value_tuple) != n:\n raise ValueError('The `' + name + '` argument must be a tuple of ' +\n str(n) + ' integers. Received: ' + str(value))\n for single_value in value_tuple:\n try:\n int(single_value)\n except (ValueError, TypeError):\n raise ValueError('The `' + name + '` argument must be a tuple of ' +\n str(n) + ' integers. Received: ' + str(value) + ' '\n 'including element ' + str(single_value) + ' of type' +\n ' ' + str(type(single_value)))\n return value_tuple\n\n\ndef normalize_data_format(value):\n data_format = value.lower()\n if data_format not in {'channels_first', 'channels_last'}:\n raise ValueError('The `data_format` argument must be one of '\n '\"channels_first\", \"channels_last\". Received: ' +\n str(value))\n return data_format\n\n\ndef normalize_padding(value):\n padding = value.lower()\n if padding not in {'valid', 'same'}:\n raise ValueError('The `padding` argument must be one of \"valid\", \"same\". '\n 'Received: ' + str(padding))\n return padding\n\n\ndef conv_output_length(input_length, filter_size, padding, stride, dilation=1):\n \"\"\"Determines output length of a convolution given input length.\n\n Arguments:\n input_length: integer.\n filter_size: integer.\n padding: one of \"same\", \"valid\", \"full\".\n stride: integer.\n dilation: dilation rate, integer.\n\n Returns:\n The output length (integer).\n \"\"\"\n if input_length is None:\n return None\n assert padding in {'same', 'valid', 'full'}\n dilated_filter_size = filter_size + (filter_size - 1) * (dilation - 1)\n if padding == 'same':\n output_length = input_length\n elif padding == 'valid':\n output_length = input_length - dilated_filter_size + 1\n elif padding == 'full':\n output_length = input_length + dilated_filter_size - 1\n return (output_length + stride - 1) // stride\n\n\ndef conv_input_length(output_length, filter_size, padding, stride):\n \"\"\"Determines input length of a convolution given output length.\n\n Arguments:\n output_length: integer.\n filter_size: integer.\n padding: one of \"same\", \"valid\", \"full\".\n stride: integer.\n\n Returns:\n The input length (integer).\n \"\"\"\n if output_length is None:\n return None\n assert padding in {'same', 'valid', 'full'}\n if padding == 'same':\n pad = filter_size // 2\n elif padding == 'valid':\n pad = 0\n elif padding == 'full':\n pad = filter_size - 1\n return (output_length - 1) * stride - 2 * pad + filter_size\n\n\ndef deconv_output_length(input_length, filter_size, padding, stride):\n \"\"\"Determines output length of a transposed convolution given input length.\n\n Arguments:\n input_length: integer.\n filter_size: integer.\n padding: one of \"same\", \"valid\", \"full\".\n stride: integer.\n\n Returns:\n The output length (integer).\n \"\"\"\n if input_length is None:\n return None\n input_length *= stride\n if padding == 'valid':\n input_length += max(filter_size - stride, 0)\n elif padding == 'full':\n input_length -= (stride + filter_size - 2)\n return input_length\n\n\ndef smart_cond(pred, true_fn=None, false_fn=None, name=None):\n \"\"\"Return either `true_fn()` if predicate `pred` is true else `false_fn()`.\n\n If `pred` is a bool or has a constant value, we return either `true_fn()`\n or `false_fn()`, otherwise we use `tf.cond` to dynamically route to both.\n\n Arguments:\n pred: A scalar determining whether to return the result of `true_fn` or\n `false_fn`.\n true_fn: The callable to be performed if pred is true.\n false_fn: The callable to be performed if pred is false.\n name: Optional name prefix when using `tf.cond`.\n\n Returns:\n Tensors returned by the call to either `true_fn` or `false_fn`.\n\n Raises:\n TypeError: If `true_fn` or `false_fn` is not callable.\n \"\"\"\n if isinstance(pred, variables.Variable):\n return control_flow_ops.cond(pred, true_fn=true_fn, false_fn=false_fn,\n name=name)\n return control_flow_ops.smart_cond(pred, true_fn=true_fn,\n false_fn=false_fn, name=name)\n\n\ndef constant_value(pred):\n \"\"\"Return the bool value for `pred`, or None if `pred` had a dynamic value.\n\n Arguments:\n pred: A scalar, either a Python bool or a TensorFlow boolean variable\n or tensor, or the Python integer 1 or 0.\n\n Returns:\n True or False if `pred` has a constant boolean value, None otherwise.\n\n Raises:\n TypeError: If `pred` is not a Variable, Tensor or bool, or Python\n interger 1 or 0.\n \"\"\"\n # Allow integer booleans.\n if isinstance(pred, int):\n if pred == 1:\n pred = True\n elif pred == 0:\n pred = False\n \n if isinstance(pred, variables.Variable):\n return None\n return control_flow_ops.smart_constant_value(pred)\n\n\ndef object_list_uid(object_list):\n \"\"\"Creates a single string from object ids.\"\"\"\n object_list = nest.flatten(object_list)\n return ', '.join([str(abs(id(x))) for x in object_list])\n\n\ndef static_shape(x):\n \"\"\"Get the static shape of a Tensor, or None if it is unavailable.\"\"\"\n if x is None:\n return None\n try:\n return tuple(x.get_shape().as_list())\n except ValueError:\n return None\n\n\ndef get_reachable_from_inputs(inputs, targets=None):\n \"\"\"Returns the set of tensors reachable from `inputs`.\n\n Stops if all targets have been found (target is optional).\n\n Only valid in Symbolic mode, not Eager mode.\n\n Args:\n inputs: List of tensors.\n targets: List of tensors.\n\n Returns:\n A set of tensors reachable from the inputs (includes the inputs themselves).\n \"\"\"\n reachable = set(inputs)\n if targets:\n targets = set(targets)\n queue = inputs[:]\n\n while queue:\n x = queue.pop()\n outputs = []\n try:\n consumers = x.consumers()\n except AttributeError:\n # Case where x is a variable type\n consumers = [x.op]\n for z in consumers:\n consumer_outputs = z.outputs\n if consumer_outputs: # May be None\n outputs += consumer_outputs\n\n for y in outputs:\n if y not in reachable:\n reachable.add(y)\n queue.insert(0, y)\n\n if targets and targets.issubset(reachable):\n return reachable\n return reachable\n"
] | [
[
"tensorflow.core.protobuf.meta_graph_pb2.MetaGraphDef",
"tensorflow.python.platform.app.run",
"tensorflow.python.training.saver.Saver",
"tensorflow.python.tools.saved_model_utils.get_meta_graph_def",
"tensorflow.python.framework.importer.import_graph_def",
"tensorflow.python.training.saver.import_meta_graph",
"tensorflow.python.platform.gfile.GFile",
"tensorflow.python.pywrap_tensorflow.NewCheckpointReader",
"tensorflow.core.protobuf.saver_pb2.SaverDef",
"tensorflow.python.platform.gfile.Exists",
"tensorflow.python.client.session.Session",
"tensorflow.python.saved_model.loader.load",
"tensorflow.python.platform.gfile.FastGFile",
"tensorflow.python.training.saver.checkpoint_exists",
"tensorflow.core.framework.graph_pb2.GraphDef"
],
[
"tensorflow.python.ops.control_flow_ops.smart_constant_value",
"tensorflow.python.ops.control_flow_ops.smart_cond",
"tensorflow.python.ops.control_flow_ops.cond",
"tensorflow.python.util.nest.flatten"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.8",
"1.10",
"2.7",
"1.4",
"2.6",
"2.3",
"2.4",
"2.9",
"1.5",
"1.7",
"2.5",
"0.12",
"1.0",
"2.2",
"1.2",
"2.10"
]
}
] |
RadjaHachilif/agotool | [
"2fcc3fd5a156053b528ec927bab79ddaf7af2dec",
"2fcc3fd5a156053b528ec927bab79ddaf7af2dec"
] | [
"app/python/testing/modules_and_functions/test_userinput_old.py",
"app/runserver.py"
] | [
"import sys, os\nsys.path.insert(0, os.path.dirname(os.path.abspath(os.path.realpath(__file__))))\n\nimport pandas as pd\nimport numpy as np\nfrom itertools import zip_longest\nimport pytest\n\nimport userinput, variables\n\nTEST_FN_DIR = os.path.join(os.path.dirname(os.path.abspath(os.path.realpath(__file__))), \"test\")\n\nNUM_BINS = 100\nDEFAULT_MISSING_BIN = -1\n\n### empty DF, edge case\nforeground_empty = pd.Series(name=\"foreground\", data={0: np.nan, 1: np.nan, 2: np.nan})\nbackground_empty = pd.DataFrame({\"background\": {0: np.nan, 1: np.nan, 2: np.nan},\n \"intensity\": {0: np.nan, 1: np.nan, 2: np.nan}})\nforeground_empty_1 = pd.Series(dtype=\"float64\")\nbackground_empty_1 = pd.DataFrame()\nforeground_empty_2 = [[], []]\nbackground_empty_2 = [[], []]\nforeground_empty_3 = []\nbackground_empty_3 = []\nforeground_empty_4 = None\nbackground_empty_4 = None\n\nforeground_almost_empty = pd.Series(name=\"foreground\", data={0: np.nan, 1: \"Q9UHI6\", 2: np.nan})\n\n### example0: nonesense AccessionNumbers, foreground is proper subset of background, everything has an abundance value\nforeground_nonsense = pd.Series(name='foreground', data={0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J'})\nbackground_nonsense = pd.DataFrame({'background': {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O'},\n 'intensity': {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: 1.0, 6: 2.0, 7: 3.0, 8: 4.0, 9: 5.0, 10: 6.0, 11: 7.0, 12: 8.0, 13: 9.0, 14: 10.0}})\n\n# without intensity values and nonsense ANs\nforeground_no_intensity_nonsense = pd.Series(name='foreground', data={0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J'})\nbackground_no_intensity_nonsense = pd.DataFrame({'background': {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O'},\n 'intensity': {0: np.nan, 1: np.nan, 2: np.nan, 3: np.nan, 4: np.nan, 5: np.nan, 6: np.nan, 7: np.nan, 8: np.nan, 9: np.nan, 10: np.nan, 11: np.nan, 12: np.nan, 13: np.nan, 14: np.nan}})\nfg_bg_no_intensity_nonsense = [foreground_no_intensity_nonsense, background_no_intensity_nonsense]\n\n# without intensity values\nforeground_no_intensity = pd.Series(name='foreground', data={0: 'Q9UHI6', 1: 'Q13075', 2: 'A6NDB9', 3: 'A6NFR9', 4: 'O95359', 5: 'D6RGG6', 6: 'Q9BRQ0', 7: 'P09629', 8: 'Q9Y6G5', 9: 'Q96KG9'})\nbackground_no_intensity = pd.DataFrame({'background': {0: 'P13747', 1: 'Q6VB85', 2: 'Q8N8S7', 3: 'Q8WXE0', 4: 'Q9UHI6', 5: 'Q9UQ03', 6: 'Q13075', 7: 'A6NDB9', 8: 'A6NFR9', 9: 'O95359', 10: 'D6RGG6', 11: 'Q9BRQ0', 12: 'P09629', 13: 'Q9Y6G5', 14: 'Q96KG9'},\n 'intensity': {0: np.nan, 1: np.nan, 2: np.nan, 3: np.nan, 4: np.nan, 5: np.nan, 6: np.nan, 7: np.nan, 8: np.nan, 9: np.nan, 10: np.nan, 11: np.nan, 12: np.nan, 13: np.nan, 14: np.nan}})\nfg_bg_no_intensity = [foreground_no_intensity, background_no_intensity]\n\n### example1: foreground is a proper subset of the background, everything has an abundance value\nforeground_1 = pd.Series(name='foreground', data={0: 'Q9UHI6', 1: 'Q13075', 2: 'A6NDB9', 3: 'A6NFR9', 4: 'O95359', 5: 'D6RGG6', 6: 'Q9BRQ0', 7: 'P09629', 8: 'Q9Y6G5', 9: 'Q96KG9'})\nbackground_1 = pd.DataFrame({'background': {0: 'P13747', 1: 'Q6VB85', 2: 'Q8N8S7', 3: 'Q8WXE0', 4: 'Q9UHI6', 5: 'Q9UQ03', 6: 'Q13075', 7: 'A6NDB9', 8: 'A6NFR9', 9: 'O95359', 10: 'D6RGG6', 11: 'Q9BRQ0', 12: 'P09629', 13: 'Q9Y6G5', 14: 'Q96KG9'},\n 'intensity': {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: 1.0, 6: 2.0, 7: 3.0, 8: 4.0, 9: 5.0, 10: 6.0, 11: 7.0, 12: 8.0, 13: 9.0, 14: 10.0}})\n\n### example2: foreground is a proper subset of the background, not everything has an abundance value\nforeground_2 = pd.Series(name='foreground', data={0: 'Q9UHI6', 1: 'Q13075', 2: 'A6NDB9', 3: 'A6NFR9', 4: 'O95359', 5: 'D6RGG6', 6: 'Q9BRQ0', 7: 'P09629', 8: 'Q9Y6G5', 9: 'Q96KG9'})\nbackground_2 = pd.DataFrame({'background': {0: 'Q9UHI6', 1: 'Q13075', 2: 'A6NDB9', 3: 'A6NFR9', 4: 'O95359', 5: 'D6RGG6', 6: 'Q9BRQ0', 7: 'P09629', 8: 'Q9Y6G5', 9: 'Q96KG9', 10: 'Q8WXE0', 11: 'Q6VB85', 12: 'P13747', 13: 'Q9UQ03', 14: 'Q8N8S7'},\n 'intensity': {0: 1.0, 1: 2.0, 2: 3.0, 3: 4.0, 4: 5.0, 5: 6.0, 6: 7.0, 7: 8.0, 8: -1.0, 9: -1.0, 10: -1.0, 11: -1.0, 12: -1.0, 13: -1.0, 14: -1.0}})\n\n### example3: foreground is not a proper subset of the background, not everything has an abundance value\nforeground_3 = pd.Series(name='foreground', data={0: 'Q9UHI6', 1: 'Q13075', 2: 'A6NDB9', 3: 'A6NFR9', 4: 'O95359', 5: 'D6RGG6', 6: 'Q9BRQ0', 7: 'P09629', 8: 'Q9Y6G5', 9: 'Q96KG9'})\nbackground_3 = pd.DataFrame({'background': {0: 'ABC123', 1: 'Q13075', 2: 'A6NDB9', 3: 'A6NFR9', 4: 'O95359', 5: 'D6RGG6', 6: 'Q9BRQ0', 7: 'P09629', 8: 'Q9Y6G5', 9: 'Q96KG9', 10: 'Q8WXE0', 11: 'Q6VB85', 12: 'P13747', 13: 'Q9UQ03', 14: 'Q8N8S7'},\n 'intensity': {0: 1.0, 1: 2.0, 2: 3.0, 3: 4.0, 4: 5.0, 5: 6.0, 6: 7.0, 7: 8.0, 8: -1.0, 9: -1.0, 10: -1.0, 11: -1.0, 12: -1.0, 13: -1.0, 14: -1.0}})\n\n### example4: foreground and background don't intersect at all\nforeground_4 = pd.Series(name='foreground', data={0: 'Q9UHI6', 1: 'Q13075', 2: 'A6NDB9'})\nbackground_4 = pd.DataFrame({'background': {0: 'ABC123', 1: 'BCD234', 2: 'CDE345'},\n 'intensity': {0: 1.0, 1: 2.0, 2: 3.0}})\n\n\nfg_bg_meth_all = [pytest.mark.xfail((foreground_empty, background_empty, \"abundance_correction\"), strict=True),\n pytest.mark.xfail((foreground_empty_2, background_empty_2, \"abundance_correction\")),\n pytest.mark.xfail((foreground_empty_3, background_empty_3, \"abundance_correction\")),\n pytest.mark.xfail((foreground_empty_4, background_empty_4, \"abundance_correction\")),\n (foreground_nonsense, background_nonsense, \"abundance_correction\"),\n (foreground_almost_empty, background_no_intensity, \"compare_samples\"),\n (foreground_1, background_1, \"abundance_correction\"),\n (foreground_2, background_2, \"abundance_correction\"),\n (foreground_3, background_3, \"abundance_correction\")]\n\nfg_bg_meth_all_ids = [\"edge case, empty DFs with NaNs\",\n \"edge case: nested empty list\",\n \"edge case: empty list\",\n \"edge case: None\",\n \"edge case: nonsense ANs\",\n \"foreground almost empty, many NaNs\",\n \"example1: foreground is proper subset of background, everything has an abundance value\",\n \"example2: foreground is proper subset of background, not everything has an abundance value\",\n \"example3: foreground is not a proper subset of background, not everything has an abundance value\"]\n\[email protected](params=fg_bg_meth_all, ids=fg_bg_meth_all_ids)\ndef fixture_fg_bg_meth_all(request):\n return request.param\n\n\nfg_bg_meth_expected_cases_DFs = [(foreground_1, background_1, \"abundance_correction\"),\n (foreground_2, background_2, \"abundance_correction\"),\n (foreground_3, background_3, \"abundance_correction\")]\n\nfg_bg_meth_expected_cases_ids = [\"example1: foreground is proper subset of background, everything has an abundance value\",\n \"example2: foreground is proper subset of background, not everything has an abundance value\",\n \"example3: foreground is not a proper subset of background, not everything has an abundance value\"]\n\[email protected](params=fg_bg_meth_expected_cases_DFs, ids=fg_bg_meth_expected_cases_ids)\ndef fixture_fg_bg_meth_expected_cases(request):\n return request.param\n\n\nfg_bg_meth_edge_cases_DFs = [pytest.mark.xfail((foreground_empty, background_empty, \"abundance_correction\")),\n pytest.mark.xfail((foreground_empty_2, background_empty_2, \"abundance_correction\")),\n pytest.mark.xfail((foreground_empty_3, background_empty_3, \"abundance_correction\")),\n pytest.mark.xfail((foreground_empty_4, background_empty_4, \"abundance_correction\")),\n (foreground_nonsense, background_nonsense, \"abundance_correction\"),\n (foreground_almost_empty, background_no_intensity, \"compare_samples\")]\n\nfg_bg_meth_edge_cases_ids = [\"edge case, empty DFs with NaNs\",\n \"edge case: nested empty list\",\n \"edge case: empty list\",\n \"edge case: None\",\n \"edge case: nonsense ANs\",\n \"foreground almost empty, many NaNs\"]\n\[email protected](params=fg_bg_meth_edge_cases_DFs, ids=fg_bg_meth_edge_cases_ids)\ndef fixture_fg_bg_edge_cases(request):\n return request.param\n\n\nfg_bg_iter_bins_DFs = [pytest.mark.xfail((foreground_empty, background_empty, \"abundance_correction\"), strict=True),\n pytest.mark.xfail((foreground_empty_2, background_empty_2, \"abundance_correction\")),\n pytest.mark.xfail((foreground_empty_3, background_empty_3, \"abundance_correction\")),\n pytest.mark.xfail((foreground_empty_4, background_empty_4, \"abundance_correction\")),\n (foreground_nonsense, background_nonsense, \"abundance_correction\"),\n (foreground_1, background_1, \"abundance_correction\"),\n (foreground_2, background_2, \"abundance_correction\"),\n (foreground_3, background_3, \"abundance_correction\")]\n\nfg_bg_iter_bins_ids = [\"edge case, empty DFs with NaNs\",\n \"edge case: nested empty list\",\n \"edge case: empty list\",\n \"edge case: None\",\n \"edge case: nonsense ANs\",\n \"example1: foreground is proper subset of background, everything has an abundance value\",\n \"example2: foreground is proper subset of background, not everything has an abundance value\",\n \"example3: foreground is not a proper subset of background, not everything has an abundance value\"]\n\[email protected](params=fg_bg_iter_bins_DFs, ids=fg_bg_iter_bins_ids)\ndef fixture_fg_bg_iter_bins(request):\n return request.param\n#\n# # ToDo #!!!\n# # def test_compare_file_2_copypaste_2_RestAPI():\n# # assert 1 == 2\n\ndef test_ui_API_check(pqo, fixture_fg_bg_meth_all):\n foreground, background, enrichment_method = fixture_fg_bg_meth_all\n fg = format_for_REST_API(foreground[foreground.notnull()])\n bg = format_for_REST_API(background.loc[background.background.notnull(), \"background\"])\n in_ = format_for_REST_API(background.loc[background.intensity.notnull(), \"intensity\"])\n\n ui = userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n assert ui.check_parse == True\n assert ui.check_cleanup == True\n assert ui.check == True\n\ndef test_check_parse_and_cleanup_FN_point(pqo):\n fn_example_data = os.path.join(variables.EXAMPLE_FOLDER, \"ExampleData.txt\")\n ui = userinput.Userinput(pqo=pqo, fn=fn_example_data, num_bins=NUM_BINS)\n assert ui.check_parse == True\n assert ui.check_cleanup == True\n assert ui.check == True\n\ndef test_check_parse_and_cleanup_FN_comma(pqo):\n fn_example_data = os.path.join(variables.EXAMPLE_FOLDER, \"HeLa_Ubi_exampledata.txt\")\n ui = userinput.Userinput(pqo=pqo, fn=fn_example_data, num_bins=NUM_BINS)\n assert ui.check_parse == True\n assert ui.check_cleanup == True\n assert ui.check == True\n\ndef test_check_parse_and_cleanup_FN_missing(pqo):\n fn_example_data = os.path.join(variables.EXAMPLE_FOLDER, \"This_does_not_exist_and_therefore_can_not_be_parsed.txt\")\n ui = userinput.Userinput(pqo=pqo, fn=fn_example_data, num_bins=NUM_BINS)\n assert ui.check_parse == False\n assert ui.check_cleanup == False\n assert ui.check == False\n\[email protected](\"foreground, background, enrichment_method\", [(foreground_4, background_4, \"abundance_correction\")])\ndef test_check_parse_and_fail_cleanup_0(foreground, background, enrichment_method, pqo):\n fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n bg = \"\\n\".join(background.loc[background.background.notnull(), \"background\"].tolist())\n ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=bg, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n assert ui.check_parse == False\n assert ui.check_cleanup == False\n assert ui.check == False\n\n# @pytest.mark.parametrize(\"foreground, background, enrichment_method\", [(foreground_4, background_4, \"abundance_correction\")])\n# def test_check_parse_and_fail_cleanup_1(foreground, background, enrichment_method, pqo):\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = \"\\n\".join(background.loc[background.background.notnull(), \"background\"].tolist())\n# in_ = [str(ele) for ele in background.loc[background.intensity.notnull(), \"intensity\"].tolist()]\n# background_string = \"\"\n# for ele in zip(bg, in_):\n# an, in_ = ele\n# background_string += an + \"\\t\" + in_ + \"\\n\"\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=background_string, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# assert ui.check_parse == True\n# assert ui.check_cleanup == False\n# assert ui.check == False\n#\n# @pytest.mark.parametrize(\"foreground, background, enrichment_method\", [(foreground_empty, background_1, \"compare_samples\"), (foreground_1, background_empty, \"compare_samples\")])\n# def test_check_parse_and_fail_cleanup_2(foreground, background, enrichment_method, pqo):\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = \"\\n\".join(background.loc[background.background.notnull(), \"background\"].tolist())\n# in_ = [str(ele) for ele in background.loc[background.intensity.notnull(), \"intensity\"].tolist()]\n# background_string = \"\"\n# for ele in zip(bg, in_):\n# an, in_ = ele\n# background_string += an + \"\\t\" + in_ + \"\\n\"\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=background_string, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# assert ui.check_parse == True\n# assert ui.check_cleanup == False\n# assert ui.check == False\n#\n#\n#\n# fg_bg_0 = [(foreground_1, background_1, \"compare_samples\"),\n# (foreground_1, background_1, \"compare_groups\"),\n# (foreground_1, background_1, \"compare_samples\")]\n#\n# # example_1: foreground is a proper subset of the background, everything has an abundance value, one row of NaNs\n# # example_2: same as example_1 with \",\" instead of \".\" as decimal delimiter\n# ### FileName_EnrichmentMethod\n# fn_em_0 = [(os.path.join(TEST_FN_DIR, \"example_1.txt\"), \"compare_samples\"),\n# (os.path.join(TEST_FN_DIR, \"example_1.txt\"), \"compare_groups\"),\n# (os.path.join(TEST_FN_DIR, \"example_1.txt\"), \"characterize_foreground\"),\n# pytest.mark.xfail((os.path.join(TEST_FN_DIR, \"example_1.txt\"), \"unknown_method\")),\n# (os.path.join(TEST_FN_DIR, \"example_2.txt\"), \"compare_samples\"),\n# (os.path.join(TEST_FN_DIR, \"example_2.txt\"), \"compare_groups\"),\n# (os.path.join(TEST_FN_DIR, \"example_2.txt\"), \"characterize_foreground\"),\n# pytest.mark.xfail((os.path.join(TEST_FN_DIR, \"example_2.txt\"), \"unknown_method\")),\n# pytest.mark.xfail((os.path.join(TEST_FN_DIR, \"file_does_not_exist.txt\"), \"compare_samples\"))]\n#\n# # @pytest.mark.factory\n# @pytest.mark.parametrize(\"fn, enrichment_method\", fn_em_0)\n# def test_factory(fn, enrichment_method, pqo):\n# ui_1 = get_ui_copy_and_paste(pqo=pqo, fn=fn, enrichment_method=enrichment_method)\n# test_check_parse_cleanup_check(ui_1, check_parse=True, check_cleanup=True, check=True)\n# assert ui_1.foreground.shape == (10, 1)\n# if enrichment_method != \"characterize_foreground\":\n# assert ui_1.background.shape == (15, 1)\n#\n# ui_2 = get_ui_fn(pqo=pqo, fn=fn, enrichment_method=enrichment_method)\n# test_check_parse_cleanup_check(ui_2, check_parse=True, check_cleanup=True, check=True)\n# assert ui_2.foreground.shape == (10, 1)\n# if enrichment_method != \"characterize_foreground\":\n# assert ui_2.background.shape == (15, 1)\n#\n# ui_3 = get_ui_fn(pqo=pqo, fn=fn, enrichment_method=enrichment_method)\n# test_check_parse_cleanup_check(ui_3, check_parse=True, check_cleanup=True, check=True)\n# assert ui_3.foreground.shape == (10, 1)\n# if enrichment_method != \"characterize_foreground\":\n# assert ui_3.background.shape == (15, 1)\n#\n# ### Check if the results are equal regardless if file, copy&paste, or REST-API\n# assert ui_1.foreground.equals(ui_2.foreground)\n# assert ui_2.foreground.equals(ui_3.foreground)\n# if enrichment_method == \"characterize_foreground\":\n# assert ui_1.background is None\n# assert ui_2.background is None\n# assert ui_3.background is None\n# else:\n# assert ui_1.background.equals(ui_2.background)\n# assert ui_2.background.equals(ui_3.background)\n#\n#\n# fn_em_1 = [(os.path.join(TEST_FN_DIR, \"example_1.txt\"), \"abundance_correction\"),\n# (os.path.join(TEST_FN_DIR, \"example_2.txt\"), \"abundance_correction\"),\n# pytest.mark.xfail((os.path.join(TEST_FN_DIR, \"file_does_not_exist.txt\"), \"compare_samples\"))]\n# # example_1: foreground is a proper subset of the background, everything has an abundance value, one row of NaNs\n# # example_2: same as above with \",\" instead of \".\" as decimal delimiter\n#\n# # @pytest.mark.factory\n# @pytest.mark.parametrize(\"fn, enrichment_method\", fn_em_1)\n# def test_factory_abundance(fn, enrichment_method, pqo):\n# ui_1 = get_ui_copy_and_paste(pqo=pqo, fn=fn, enrichment_method=enrichment_method, with_abundance=True)\n# test_check_parse_cleanup_check(ui_1, check_parse=True, check_cleanup=True, check=True)\n# assert ui_1.foreground.shape == (10, 2)\n# assert ui_1.background.shape == (15, 2)\n#\n# ui_2 = get_ui_fn(pqo=pqo, fn=fn, enrichment_method=enrichment_method)\n# test_check_parse_cleanup_check(ui_2, check_parse=True, check_cleanup=True, check=True)\n# assert ui_2.foreground.shape == (10, 2)\n# assert ui_2.background.shape == (15, 2)\n#\n# ui_3 = get_ui_rest_api(pqo=pqo, fn=fn, enrichment_method=enrichment_method, with_abundance=True)\n# test_check_parse_cleanup_check(ui_3, check_parse=True, check_cleanup=True, check=True)\n# assert ui_3.foreground.shape == (10, 2)\n# assert ui_3.background.shape == (15, 2)\n#\n# ### Check if the results are equal regardless if file, copy&paste, or REST-API\n# assert ui_1.foreground.equals(ui_2.foreground)\n# assert ui_2.foreground.equals(ui_3.foreground)\n# if enrichment_method == \"characterize_foreground\":\n# assert ui_1.background is None\n# assert ui_2.background is None\n# assert ui_3.background is None\n# else:\n# assert ui_1.background.equals(ui_2.background)\n# assert ui_2.background.equals(ui_3.background)\n#\n# @pytest.mark.parametrize(\"fn, enrichment_method\", [(os.path.join(TEST_FN_DIR, \"example_5.txt\"), \"abundance_correction\")])\n# def test_protein_groups(fn, enrichment_method, pqo):\n# pass\n#\n# @pytest.mark.parametrize(\"foreground, background, enrichment_method\", fg_bg_0)\n# def test_check_parse_with_copy_and_paste_0(foreground, background, enrichment_method, pqo):\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = \"\\n\".join(background.loc[background.background.notnull(), \"background\"].tolist())\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=bg, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# assert ui.check_parse == True\n# assert ui.foreground.shape == (10, 1)\n#\n#\n# fg_bg_1 = [(foreground_1, background_1, \"abundance_correction\")]\n#\n# @pytest.mark.parametrize(\"foreground, background, enrichment_method\", fg_bg_1)\n# def test_check_parse_with_copy_and_paste_1(foreground, background, enrichment_method, pqo):\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = background.loc[background.background.notnull(), \"background\"].tolist()\n# in_ = [str(ele) for ele in background.loc[background.intensity.notnull(), \"intensity\"].tolist()]\n# background_string = \"\"\n# for ele in zip_longest(bg, in_, fillvalue=np.nan):\n# an, in_ = ele\n# background_string += an + \"\\t\" + str(in_) + \"\\n\"\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=background_string, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# assert ui.check_parse == True\n# assert ui.foreground.shape == (10, 2)\n#\n#\n# @pytest.mark.parametrize(\"foreground, background, enrichment_method\", [(foreground_1, background_1, \"compare_samples\")])\n# def test_check_parse_and_cleanup_copy_and_paste_2(foreground, background, enrichment_method, pqo):\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = \"\\n\".join(background.loc[background.background.notnull(), \"background\"].tolist())\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=bg, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# assert ui.check_parse == True\n#\n#\n# edge_cases_0 = [(foreground_empty, background_empty, \"abundance_correction\")] #,\n# # (foreground_empty_1, background_empty_1, \"abundance_correction\"),\n# # (foreground_empty_2, background_empty_2, \"abundance_correction\")]\n#\n# @pytest.mark.parametrize(\"foreground, background, enrichment_method\", edge_cases_0)\n# def test_check_parse_and_cleanup_copy_and_paste_0(foreground, background, enrichment_method, pqo):\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = \"\\n\".join(background.loc[background.background.notnull(), \"background\"].tolist())\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=bg, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# assert ui.check_parse == False\n# assert ui.check_cleanup == False\n# assert ui.check == False\n#\n# fg_bg_meth_cp_abu = [pytest.mark.xfail((foreground_empty, background_empty, \"abundance_correction\"), strict=True),\n# pytest.mark.xfail((foreground_empty_2, background_empty_2, \"abundance_correction\")),\n# pytest.mark.xfail((foreground_empty_3, background_empty_3, \"abundance_correction\")),\n# pytest.mark.xfail((foreground_empty_4, background_empty_4, \"abundance_correction\")),\n# (foreground_nonsense, background_nonsense, \"abundance_correction\"),\n# (foreground_1, background_1, \"abundance_correction\"),\n# (foreground_2, background_2, \"abundance_correction\"),\n# (foreground_3, background_3, \"abundance_correction\")]\n#\n# @pytest.mark.parametrize(\"foreground, background, enrichment_method\", fg_bg_meth_cp_abu)\n# def test_check_parse_and_cleanup_copy_and_paste_1(foreground, background, enrichment_method, pqo):\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = background.loc[background.background.notnull(), \"background\"].tolist()\n# in_ = [str(ele) for ele in background.loc[background.intensity.notnull(), \"intensity\"].tolist()]\n# background_string = \"\"\n# for ele in zip_longest(bg, in_, fillvalue=np.nan):\n# an, in_ = ele\n# background_string += an + \"\\t\" + str(in_) + \"\\n\"\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=background_string, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# assert ui.check_parse == True\n# assert ui.check_cleanup == True\n# assert ui.check == True\n#\n# # @pytest.mark.parametrize(\"foreground, background, enrichment_method\", [(foreground_almost_empty, background_no_intensity, \"compare_samples\")])\n# # def test_check_parse_and_cleanup_copy_and_paste_2(foreground, background, enrichment_method, pqo):\n# # fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# # bg = background.loc[background.background.notnull(), \"background\"].tolist()\n# # in_ = [str(ele) for ele in background.loc[background.intensity.notnull(), \"intensity\"].tolist()]\n# # background_string = \"\"\n# # for ele in zip_longest(bg, in_, fillvalue=np.nan):\n# # an, in_ = ele\n# # background_string += an + \"\\t\" + str(in_) + \"\\n\"\n# # ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=background_string, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# # assert ui.check_parse == True\n# # assert ui.check_cleanup == False\n# # assert ui.check == False\n#\n#\n# def test_iter_bins_API_input(pqo, fixture_fg_bg_iter_bins):\n# foreground, background, enrichment_method = fixture_fg_bg_iter_bins\n# fg = format_for_REST_API(foreground[foreground.notnull()])\n# bg = format_for_REST_API(background.loc[background.background.notnull(), \"background\"])\n# in_ = format_for_REST_API(background.loc[background.intensity.notnull(), \"intensity\"])\n#\n# ui = userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# counter = 0\n# for ans, weight_fac in ui.iter_bins():\n# # every weighting factor is a float\n# assert type(weight_fac) == float\n# counter += 1\n# number_of_bins_used = pd.cut(ui.foreground[\"intensity\"], bins=100, retbins=False).drop_duplicates().shape[0]\n# assert counter == number_of_bins_used\n#\n# def test_iter_bins_API_input_missing_bin(pqo, fixture_fg_bg_iter_bins):\n# \"\"\"\n# this test only works if ANs fall within separate bins,\n# e.g. for negative example:\n# background intensity foreground\n# 0 A 1.0 A\n# 1 B 1.0 B\n# 2 C 1.0 C\n# \"\"\"\n# foreground, background, enrichment_method = fixture_fg_bg_iter_bins\n# fg = format_for_REST_API(foreground[foreground.notnull()])\n# bg = format_for_REST_API(background.loc[background.background.notnull(), \"background\"])\n# in_ = format_for_REST_API(background.loc[background.intensity.notnull(), \"intensity\"])\n#\n# ui = userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n# counter = 0\n# for ans, weight_fac in ui.iter_bins():\n# # every weighting factor is a float\n# assert type(weight_fac) == float\n# counter += 1\n# # since integers instead of floats are being used for test data, the number of unique bins can be determined by sets\n# num_iterations_expected = len({int(ele) for ele in ui.foreground[\"intensity\"].tolist()})\n# assert counter == num_iterations_expected\n#\n#\n#\n# ### test cleanup for analysis for all 4 different enrichment methods\n# ### via class REST_API_input\n# def test_cleanupforanalysis_abundance_correction_REST_API(pqo, fixture_fg_bg_meth_expected_cases):\n# \"\"\"\n# using fixture_fg_bg_meth_all\n# python/test_userinput.py::test_cleanupforanalysis_abundance_correction_REST_API[edge case, empty DFs with NaNs] XPASS\n# XPASS: should fail but passes.\n# --> should not be tested at all, but doesn't matter\n# \"\"\"\n# foreground, background, _ = fixture_fg_bg_meth_expected_cases\n# enrichment_method = \"abundance_correction\"\n# foreground_n = None\n# background_n = None\n# fg = format_for_REST_API(foreground)\n# bg = format_for_REST_API(background[\"background\"])\n# in_ = format_for_REST_API(background[\"intensity\"])\n# ui = userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS,\n# enrichment_method=enrichment_method, foreground_n=foreground_n, background_n=background_n)\n#\n# # no NaNs where ANs are expected\n# foreground = ui.foreground[ui.col_foreground]\n# assert sum(foreground.isnull()) == 0\n# assert sum(foreground.notnull()) > 0\n# background = ui.background[ui.col_background]\n# assert sum(background.isnull()) == 0\n# assert sum(background.notnull()) > 0\n#\n# # every AN has an abundance val\n# foreground_intensity = ui.foreground[ui.col_intensity]\n# assert sum(foreground_intensity.isnull()) == 0\n# assert sum(foreground_intensity.notnull()) > 0\n# background_intensity = ui.background[ui.col_intensity]\n# assert sum(background_intensity.isnull()) == 0\n# assert sum(background_intensity.notnull()) > 0\n#\n# # foreground and background are strings and abundance values are floats\n# assert isinstance(foreground.iloc[0], str)\n# assert isinstance(background.iloc[0], str)\n# assert isinstance(foreground_intensity.iloc[0], float)\n# assert isinstance(background_intensity.iloc[0], float)\n#\n# # no duplicates\n# assert foreground.duplicated().any() == False\n# assert background.duplicated().any() == False\n#\n# # sorted abundance values\n# assert non_decreasing(foreground_intensity.tolist()) == True\n# assert non_decreasing(background_intensity.tolist()) == True\n#\n# def test_cleanupforanalysis_characterize_foreground_REST_API(pqo, fixture_fg_bg_meth_expected_cases):\n# \"\"\"\n# python/test_userinput.py::test_cleanupforanalysis_characterize_foreground_REST_API[edge case, empty DFs with NaNs] XPASS\n# \"\"\"\n# foreground, background, _ = fixture_fg_bg_meth_expected_cases\n# enrichment_method = \"characterize_foreground\"\n# foreground_n = None\n# background_n = None\n# fg = format_for_REST_API(foreground)\n# bg = None\n# in_ = None\n# ui = userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS,\n# enrichment_method=enrichment_method, foreground_n=foreground_n, background_n=background_n)\n#\n# # no NaNs where ANs are expected\n# foreground = ui.foreground[ui.col_foreground]\n# assert sum(foreground.isnull()) == 0\n# assert sum(foreground.notnull()) > 0\n#\n# # foreground\n# assert isinstance(foreground.iloc[0], str)\n#\n# # no duplicates\n# assert foreground.duplicated().any() == False\n#\n# def test_cleanupforanalysis_compare_samples_REST_API(pqo, fixture_fg_bg_meth_expected_cases):\n# \"\"\"\n# python/test_userinput.py::test_cleanupforanalysis_compare_samples_REST_API[edge case, empty DFs with NaNs] XPASS\n# \"\"\"\n# foreground, background, _ = fixture_fg_bg_meth_expected_cases\n# enrichment_method = \"compare_samples\"\n# foreground_n = None\n# background_n = None\n# fg = format_for_REST_API(foreground)\n# bg = format_for_REST_API(background[\"background\"])\n# in_ = None\n# ui = userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS,\n# enrichment_method=enrichment_method, foreground_n=foreground_n, background_n=background_n)\n#\n# # no NaNs where ANs are expected\n# foreground = ui.foreground[ui.col_foreground]\n# assert sum(foreground.isnull()) == 0\n# assert sum(foreground.notnull()) > 0\n# background = ui.background[ui.col_background]\n# assert sum(background.isnull()) == 0\n# assert sum(background.notnull()) > 0\n#\n# # foreground and background are strings\n# assert isinstance(foreground.iloc[0], str)\n# assert isinstance(background.iloc[0], str)\n#\n# # no duplicates\n# assert foreground.duplicated().any() == False\n# assert background.duplicated().any() == False\n#\n# def test_cleanupforanalysis_compare_groups_REST_API(pqo, fixture_fg_bg_meth_all):\n# foreground, background, _ = fixture_fg_bg_meth_all\n# enrichment_method = \"compare_groups\"\n# foreground_n = None\n# background_n = None\n# fg = format_for_REST_API(foreground)\n# bg = \"%0d\".join(background.loc[:, \"background\"].tolist())\n# in_ = None\n# ui = userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, background_intensity=in_, num_bins=NUM_BINS,\n# enrichment_method=enrichment_method, foreground_n=foreground_n, background_n=background_n)\n#\n# # no NaNs where ANs are expected\n# foreground = ui.foreground[ui.col_foreground]\n# assert sum(foreground.isnull()) == 0\n# assert sum(foreground.notnull()) > 0\n# background = ui.background[ui.col_background]\n# assert sum(background.isnull()) == 0\n# assert sum(background.notnull()) > 0\n#\n# # foreground and background are strings\n# assert isinstance(foreground.iloc[0], str)\n# assert isinstance(background.iloc[0], str)\n#\n# # if there were duplicates in the original input they should still be preserved in the cleaned up DF\n# # not equal because of splice variants\n# # remove NaNs from df_orig\n# foreground_df_orig = ui.df_orig[ui.col_foreground]\n# background_df_orig = ui.df_orig[ui.col_background]\n# assert foreground.duplicated().sum() >= foreground_df_orig[foreground_df_orig.notnull()].duplicated().sum()\n# assert background.duplicated().sum() >= background_df_orig[background_df_orig.notnull()].duplicated().sum()\n#\n# ### via class Userinput\n# def test_cleanupforanalysis_abundance_correction_Userinput(pqo, fixture_fg_bg_meth_all):\n# foreground, background, enrichment_method = fixture_fg_bg_meth_all\n# if enrichment_method != \"abundance_correction\":\n# # assert 1 == 1\n# return None\n#\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = background.loc[background.background.notnull(), \"background\"].tolist()\n# in_ = [str(ele) for ele in background.loc[background.intensity.notnull(), \"intensity\"].tolist()]\n# background_string = \"\"\n# for ele in zip(bg, in_):\n# an, in_ = ele\n# background_string += an + \"\\t\" + in_ + \"\\n\"\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=background_string, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n#\n# # no NaNs where ANs are expected\n# foreground = ui.foreground[ui.col_foreground]\n# assert sum(foreground.isnull()) == 0\n# assert sum(foreground.notnull()) > 0\n# background = ui.background[ui.col_background]\n# assert sum(background.isnull()) == 0\n# assert sum(background.notnull()) > 0\n#\n# # every AN has an abundance val\n# foreground_intensity = ui.foreground[ui.col_intensity]\n# assert sum(foreground_intensity.isnull()) == 0\n# assert sum(foreground_intensity.notnull()) > 0\n# background_intensity = ui.background[ui.col_intensity]\n# assert sum(background_intensity.isnull()) == 0\n# assert sum(background_intensity.notnull()) > 0\n#\n# # foreground and background are strings and abundance values are floats\n# assert isinstance(foreground.iloc[0], str)\n# assert isinstance(background.iloc[0], str)\n# assert isinstance(foreground_intensity.iloc[0], float)\n# assert isinstance(background_intensity.iloc[0], float)\n#\n# # no duplicates\n# assert foreground.duplicated().any() == False\n# assert background.duplicated().any() == False\n#\n# # sorted abundance values\n# assert non_decreasing(foreground_intensity.tolist()) == True\n# assert non_decreasing(background_intensity.tolist()) == True\n#\n# def test_cleanupforanalysis_characterize_foreground_Userinput(pqo, fixture_fg_bg_meth_all):\n# foreground, background, _ = fixture_fg_bg_meth_all\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# enrichment_method = \"characterize_foreground\"\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=None, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n#\n# # no NaNs where ANs are expected\n# foreground = ui.foreground[ui.col_foreground]\n# assert sum(foreground.isnull()) == 0\n# assert sum(foreground.notnull()) > 0\n#\n# # foreground\n# assert isinstance(foreground.iloc[0], str)\n#\n# # no duplicates\n# assert foreground.duplicated().any() == False\n#\n# def test_cleanupforanalysis_compare_samples_Userinput(pqo, fixture_fg_bg_meth_all):\n# enrichment_method = \"compare_samples\"\n# foreground, background, _ = fixture_fg_bg_meth_all\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = \"\\n\".join(background.loc[background.background.notnull(), \"background\"].tolist())\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=bg, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n#\n# # no NaNs where ANs are expected\n# foreground = ui.foreground[ui.col_foreground]\n# assert sum(foreground.isnull()) == 0\n# assert sum(foreground.notnull()) > 0\n# background = ui.background[ui.col_background]\n# assert sum(background.isnull()) == 0\n# assert sum(background.notnull()) > 0\n#\n# # foreground and background are strings\n# assert isinstance(foreground.iloc[0], str)\n# assert isinstance(background.iloc[0], str)\n#\n# # no duplicates\n# assert foreground.duplicated().any() == False\n# assert background.duplicated().any() == False\n#\n# def test_cleanupforanalysis_compare_groups_Userinput(pqo, fixture_fg_bg_meth_all):\n# enrichment_method = \"compare_groups\"\n# foreground, background, _ = fixture_fg_bg_meth_all\n# fg = \"\\n\".join(foreground[foreground.notnull()].tolist())\n# bg = \"\\n\".join(background.loc[background.background.notnull(), \"background\"].tolist())\n# ui = userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=bg, num_bins=NUM_BINS, enrichment_method=enrichment_method)\n#\n# # no NaNs where ANs are expected\n# foreground = ui.foreground[ui.col_foreground]\n# assert sum(foreground.isnull()) == 0\n# assert sum(foreground.notnull()) > 0\n# background = ui.background[ui.col_background]\n# assert sum(background.isnull()) == 0\n# assert sum(background.notnull()) > 0\n#\n# # foreground and background are strings\n# assert isinstance(foreground.iloc[0], str)\n# assert isinstance(background.iloc[0], str)\n#\n# # if there were duplicates in the original input they should still be preserved in the cleaned up DF\n# # not equal because of splice variants\n# # remove NaNs from df_orig\n# foreground_df_orig = ui.df_orig[ui.col_foreground]\n# background_df_orig = ui.df_orig[ui.col_background]\n# assert foreground.duplicated().sum() >= foreground_df_orig[foreground_df_orig.notnull()].duplicated().sum()\n# assert background.duplicated().sum() >= background_df_orig[background_df_orig.notnull()].duplicated().sum()\n#\n### helper functions\ndef non_decreasing(L):\n \"\"\"\n https://stackoverflow.com/questions/4983258/python-how-to-check-list-monotonicity\n \"\"\"\n return all(x<=y for x, y in zip(L, L[1:]))\n\ndef format_for_REST_API(pd_series):\n return \"%0d\".join([str(ele) for ele in pd_series.tolist()])\n\ndef get_ui_copy_and_paste(pqo, fn, enrichment_method, with_abundance=False, num_bins=NUM_BINS):\n df = pd.read_csv(fn, sep='\\t')\n fg = \"\\n\".join(df.loc[df[\"foreground\"].notnull(), \"foreground\"].tolist())\n if not with_abundance:\n bg = \"\\n\".join(df.loc[df[\"background\"].notnull(), \"background\"].tolist())\n return userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=bg, num_bins=num_bins, enrichment_method=enrichment_method)\n else:\n bg = df.loc[df[\"background\"].notnull(), \"background\"].tolist()\n in_ = [str(ele) for ele in df.loc[df[\"intensity\"].notnull(), \"intensity\"].tolist()]\n background_string = \"\"\n for ele in zip(bg, in_):\n an, in_ = ele\n background_string += an + \"\\t\" + in_ + \"\\n\"\n return userinput.Userinput(pqo=pqo, foreground_string=fg, background_string=background_string, num_bins=num_bins, enrichment_method=enrichment_method)\n\ndef get_ui_rest_api(pqo, fn, enrichment_method, with_abundance=False, num_bins=NUM_BINS):\n df = pd.read_csv(fn, sep='\\t')\n fg = format_for_REST_API(df.loc[df[\"foreground\"].notnull(), \"foreground\"])\n bg = format_for_REST_API(df.loc[df[\"background\"].notnull(), \"background\"])\n in_ = format_for_REST_API(df.loc[df[\"intensity\"].notnull(), \"intensity\"])\n if with_abundance:\n return userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, background_intensity=in_, enrichment_method=enrichment_method)\n else:\n return userinput.REST_API_input(pqo=pqo, foreground_string=fg, background_string=bg, enrichment_method=enrichment_method, num_bins=num_bins)\n\ndef get_ui_fn(pqo, fn, enrichment_method, num_bins=NUM_BINS):\n return userinput.Userinput(pqo=pqo, fn=fn, enrichment_method=enrichment_method, num_bins=num_bins)\n\[email protected](reason=\"this test is being used internally, but will fail if run on its own since 'ui' is not a fixture but a parameter\")\ndef test_check_parse_cleanup_check(ui, check_parse=True, check_cleanup=True, check=True):\n assert ui.check_parse == check_parse\n assert ui.check_cleanup == check_cleanup\n assert ui.check == check",
"import os, sys, logging, time, argparse, json\nfrom collections import defaultdict\nimport numpy as np\nimport pandas as pd\npd.set_option('display.max_colwidth', 300) # in order to prevent 50 character cutoff of to_html export / ellipsis\nfrom lxml import etree\nimport flask\nfrom flask import render_template, request, send_from_directory, jsonify\nfrom flask_restful import reqparse, Api, Resource\nfrom werkzeug.wrappers import Response\nimport wtforms\nfrom wtforms import fields\n# from wtforms import widgets, SelectMultipleField\nimport markdown\nfrom flaskext.markdown import Markdown\nfrom ast import literal_eval\n\nsys.path.insert(0, os.path.abspath(os.path.realpath('python')))\nimport query, userinput, run, variables, taxonomy, plot_and_table\nimport colnames as cn\n\nversion_temp = \"0\"\ntry:\n with open(\"version_temp.txt\", \"r\") as fh:\n for line in fh:\n version_temp = str( int(line.strip()) + 1 )\nexcept:\n pass\nwith open(\"version_temp.txt\", \"w\") as fh:\n fh.write(version_temp)\nprint(\"loading version \", version_temp)\n\n###############################################################################\nvariables.makedirs_()\nEXAMPLE_FOLDER = variables.EXAMPLE_FOLDER\nSESSION_FOLDER_ABSOLUTE = variables.SESSION_FOLDER_ABSOLUTE\nSESSION_FOLDER_RELATIVE = variables.SESSION_FOLDER_RELATIVE\nTEMPLATES_FOLDER_ABSOLUTE = variables.TEMPLATES_FOLDER_ABSOLUTE\nDOWNLOADS_DIR = variables.DOWNLOADS_DIR\nLOG_FN_WARNINGS_ERRORS = variables.LOG_FN_WARNINGS_ERRORS\nLOG_FN_ACTIVITY = variables.LOG_FN_ACTIVITY\nFN_KEYWORDS = variables.FN_KEYWORDS\nFN_GO_SLIM = variables.FN_GO_SLIM\nFN_GO_BASIC = variables.FN_GO_BASIC\nDEBUG = variables.DEBUG\nPRELOAD = variables.PRELOAD\nPROFILING = variables.PROFILING\nfunctionType_2_entityType_dict = variables.functionType_2_entityType_dict\nARGPARSE = variables.ARGPARSE\n###############################################################################\ndef error_(parser):\n sys.stderr.write(\"The arguments passed are invalid.\\nPlease check the input parameters.\\n\\n\")\n parser.print_help()\n sys.exit(2)\nif ARGPARSE:\n argparse_parser = argparse.ArgumentParser()\n argparse_parser.add_argument(\"IP\", help=\"IP address without port, e.g. '127.0.0.1' (is also the default)\", type=str, default=\"127.0.0.1\", nargs='?')\n argparse_parser.add_argument(\"port\", help=\"port number, e.g. '10110' (is also the default)\", type=str, default=\"10110\", nargs='?')\n argparse_parser.add_argument(\"verbose\", help=\"add 'verbose' as an argument to print more information\", type=str, default=\"False\", nargs=\"?\")\n args = argparse_parser.parse_args()\n for arg in sorted(vars(args)):\n if getattr(args, arg) is None:\n error_(argparse_parser)\n IP, port = args.IP, args.port\n if args.verbose == \"verbose\" or args.verbose == \"v\":\n variables.VERBOSE = True\n###############################################################################\n# ToDo\n# - change to chain reloading for ago_UP\n# - change uwsgi.ini files --> to ago_STRINGv11 in PMID_autoupdate\n# - pytest of flatfiles, only for big files (remove all the small AFC/KS files)\n# - zerg mode\n# - emperor mode?\n# - create log of usage\n# - test if there is any downtime between reload of vassals\n# - check if Viruses work for UniProt Reference Proteomes\n# - cast to lower caps for all parameters passed via API\n# - update help and examples, fix Ufuk comments on math formulas, parameters page\n# - add symbol/icon to expand menu options\n# - add minimum count for foreground --> replace with minimum count, but make backwards compatible with REST API\n# - lineage_dict_direct.p --> in Snakemake pipeline?\n# - sticky footer Firefox\n# - code REST API analogous to STRING --> also adapt column names accordingly\n# - fix javascript colnames\n# - create compare_samples_with_values --> KS test method\n# - filter_parents for \"genome\" not working for InterPro --> discussion point with Christian/Damian\n# - export parameters (args_dict) to file\n# - update example page\n# - check if \"Filter foreground count one button\" works, doesn't work on agotool.org but does work in local version\n# - DF_file_dimensions_log.txt --> check that it is part of git repo (exception in .gitignore), and that new entries get added with each auto-update\n# characterize_foreground --> cap at 100 PMIDs with checkbox\n# - add example to API with abundance correction method --> input fg_string with abundance values\n# - add check to size of downloads. e.g. documents_protein2function.tsv.gz == URL_protein_2_function_PMID\n# --> to be >= previous size\n# - checkboxes for limit_2_entity_types instead of drop_down_list\n# add poster from ASMS\n# single help page with FAQ section\n# - report userinput 2 mapped ID and make available as download\n# - return unused identifiers\n# - multiple entity type results to be displayed\n# - debug copy&paste fields\n# - debug file upload field\n# - replace example file\n# - update \"info_check_input.html\" with REST API usage infos\n# - offer option to omit testing GO-terms with few associations (e.g. 10)\n# - update documentation specifically about foreground and background\n# ? - background proteome with protein groups --> does it get mapped to single protein in foreground ?\n# - version of tool/ dates of files downloaded\n# - one version per year that is fixed. if you need that particular annotation extra submission with some wait time and email results?\n###############################################################################\n###############################################################################\ndef getitem(obj, item, default):\n if item not in obj:\n return default\n else:\n return obj[item]\n###############################################################################\n### Create the Flask application\n# SECRET_KEY = 'development'\ndef init_app():\n app = flask.Flask(__name__, template_folder=TEMPLATES_FOLDER_ABSOLUTE)\n Markdown(app)\n return app\n\napp = init_app()\n# app.config.from_object(__name__)\n\nif PROFILING:\n # from werkzeug.contrib.profiler import ProfilerMiddleware\n from werkzeug.middleware.profiler import ProfilerMiddleware\n app.config['PROFILE'] = True\n # app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[50]) # to view profiled code in shell\n app.wsgi_app = ProfilerMiddleware(app.wsgi_app, profile_dir=variables.DATA_DIR) # use qcachegrind to visualize\n ## iterm: \"qcachegrind\"\n ## source activate agotool\n ## pyprof2calltree -i somethingsomething.prof -o something.prof\n ## open \"something.prof\" with qcachegrind -o something.prof\n\napp.config['EXAMPLE_FOLDER'] = EXAMPLE_FOLDER\napp.config['SESSION_FOLDER'] = SESSION_FOLDER_ABSOLUTE\nALLOWED_EXTENSIONS = {'txt', 'tsv'}\napp.config['MAX_CONTENT_LENGTH'] = 100 * 2 ** 20\n\nlogger = logging.getLogger()\nlogger.level = logging.DEBUG\nstream_handler = logging.StreamHandler(sys.stdout)\nlogger.addHandler(stream_handler)\n\nif not app.debug:\n #########################\n # log warnings and errors\n from logging import FileHandler\n file_handler = FileHandler(LOG_FN_WARNINGS_ERRORS, mode=\"a\", encoding=\"UTF-8\")\n file_handler.setFormatter(logging.Formatter(\"#\"*80 + \"\\n\" + '%(asctime)s %(levelname)s: %(message)s'))\n file_handler.setLevel(logging.WARNING)\n app.logger.addHandler(file_handler)\n log_activity_fh = open(LOG_FN_ACTIVITY, \"a\")\n\ndef log_activity(string2log):\n string2log_prefix = \"\\n\" + \"Current date & time \" + time.strftime(\"%c\") + \"\\n\"\n string2log = string2log_prefix + string2log\n log_activity_fh.write(string2log)\n log_activity_fh.flush()\n\n################################################################################\n# pre-load objects\n################################################################################\nif PRELOAD:\n if variables.VERSION_ == \"STRING\" or variables.VERSION_ == \"UniProt\":\n # import pickle\n # lineage_dict = pickle.load(open(os.path.join(variables.TABLES_DIR, \"lineage_dict_direct.p\"), \"rb\"))\n # print(\"done with lineage_dict\")\n # import create_SQL_tables_snakemake as cst\n print(\"getting lineage_dict\")\n # lineage_dict = cst.get_lineage_dict_for_all_entity_types_with_ontologies(direct_or_allParents=\"direct\")\n pqo = query.PersistentQueryObject_STRING(low_memory=variables.LOW_MEMORY, read_from_flat_files=variables.READ_FROM_FLAT_FILES)\n lineage_dict = pqo.lineage_dict\n last_updated_text = query.get_last_updated_text()\n else:\n print(\"VERSION_ {} not implemented\".format(variables.VERSION_))\n raise NotImplementedError\nelse:\n pqo = None # just for mocking\n import pickle\n lineage_dict = pickle.load(open(variables.tables_dict[\"lineage_dict_direct\"], \"rb\"))\n last_updated_text = \"you're in debug mode baby, so stop bugging\"\n\nNCBI_autocomplete_list = query.get_UniProt_NCBI_TaxID_and_TaxName_for_autocomplete_list()\n\n### from http://flask-restful.readthedocs.io/en/latest/quickstart.html#a-minimal-api\n### API\napi = Api(app)\nparser = reqparse.RequestParser()\n################################################################################\n### API arguments/parameters\nparser.add_argument(\"taxid\", type=int,help=\"NCBI taxon identifiers (e.g. Human is 9606, see: STRING organisms).\", default=9606)\nparser.add_argument(\"species\", type=int,help=\"deprecated please use 'taxid' instead, NCBI taxon identifiers (e.g. Human is 9606, see: STRING organisms).\",default=None)\nparser.add_argument(\"organism\", type=int,help=\"deprecated please use 'taxid' instead, NCBI taxon identifiers (e.g. Human is 9606, see: STRING organisms).\",default=None)\nparser.add_argument(\"output_format\", type=str, help=\"The desired format of the output, one of {tsv, tsv-no-header, json, xml}\", default=\"tsv\")\n### Boolean arguments encoded as str on purpose\nparser.add_argument(\"filter_parents\", type=str,\n help=\"Remove parent terms (keep GO terms and UniProt Keywords of lowest leaf) if they are associated with exactly the same foreground.\",\n default=\"True\")\nparser.add_argument(\"filter_foreground_count_one\", type=str, help=\"Keep only those terms with foreground_count > 1\", default=\"True\")\nparser.add_argument(\"privileged\", type=str, default=\"False\")\nparser.add_argument(\"multiple_testing_per_etype\", type=str, help=\"If True calculate multiple testing correction separately per entity type (functional category), in contrast to performing the correction together for all results.\", default=\"True\")\nparser.add_argument(\"filter_PMID_top_n\", type=int, default=100, help=\"Filter the top n PMIDs (e.g. 100, default=100), sorting by low p value and recent publication date.\")\nparser.add_argument(\"caller_identity\", type=str, help=\"Your identifier for us e.g. www.my_awesome_app.com\", default=None) # ? do I need default value ?\nparser.add_argument(\"FDR_cutoff\", type=float, help=\"False Discovery Rate cutoff (cutoff for multiple testing corrected p values) e.g. 0.05, default=0.05 meaning 5%. Set to 1 for no cutoff.\", default=0.05)\nparser.add_argument(\"p_value_cutoff\", type=float, help=\"Apply a filter (value between 0 and 1) for maximum cutoff value of the uncorrected p value. '1' means nothing will be filtered, '0.01' means all uncorected p_values <= 0.01 will be removed from the results (but still tested for multiple correction).\", default=1)\nparser.add_argument(\"limit_2_entity_type\", type=str, help=\"Limit the enrichment analysis to a specific or multiple entity types, e.g. '-21' (for GO molecular function) or '-21;-22;-23;-51' (for all GO terms as well as UniProt Keywords).\", default=None) # -53 missing for UniProt version # \"-20;-21;-22;-23;-51;-52;-54;-55;-56;-57;-58\"\nparser.add_argument(\"foreground\", type=str, help=\"ENSP identifiers for all proteins in the test group (the foreground, the sample, the group you want to examine for GO term enrichment) \"\n \"separate the list of Accession Number using '%0d' e.g. '4932.YAR019C%0d4932.YFR028C%0d4932.YGR092W'\",\n default=None)\nparser.add_argument(\"background\", type=str,\n help=\"ENSP identifiers for all proteins in the background (the population, the group you want to compare your foreground to) \"\n \"separate the list of Accession Number using '%0d'e.g. '4932.YAR019C%0d4932.YFR028C%0d4932.YGR092W'\",\n default=None)\nparser.add_argument(\"background_intensity\", type=str,\n help=\"Protein abundance (intensity) for all proteins (copy number, iBAQ, or any other measure of abundance). \"\n \"Separate the list using '%0d'. The number of items should correspond to the number of Accession Numbers of the 'background'\"\n \"e.g. '12.3%0d3.4' \",\n default=None)\nparser.add_argument(\"intensity\", type=str,\n help=\"This argument is deprecated. Please use 'background_intensity' or 'foreground_intensity' instead to be specific.\",\n default=None)\nparser.add_argument(\"enrichment_method\", type=str,\n help=\"\"\"'genome': provided foreground vs genome;\n 'compare_samples': Foreground vs Background (no abundance correction); \n 'characterize_foreground': list all functional annotations for provided foreground;\n 'abundance_correction': Foreground vs Background abundance corrected\"\"\",\n default=\"characterize_foreground\")\nparser.add_argument(\"goslim\", type=str, help=\"GO basic or a slim subset {generic, agr, aspergillus, candida, chembl, flybase_ribbon, metagenomics, mouse, pir, plant, pombe, synapse, yeast}. Choose between the full Gene Ontology ('basic') or one of the GO slim subsets (e.g. 'generic' or 'mouse'). GO slim is a subset of GO terms that are less fine grained. 'basic' does not exclude anything, select 'generic' for a subset of broad GO terms, the other subsets are tailor made for a specific taxons / analysis (see http://geneontology.org/docs/go-subset-guide)\", default=\"basic\")\nparser.add_argument(\"o_or_u_or_both\", type=str, help=\"over- or under-represented or both, one of {overrepresented, underrepresented, both}. Choose to only test and report overrepresented or underrepresented GO-terms, or to report both of them.\", default=\"both\")\nparser.add_argument(\"num_bins\", type=int, help=\"The number of bins created based on the abundance values provided. Only relevant if 'Abundance correction' is selected.\", default=100)\nparser.add_argument(\"STRING_beta\", type=str, default=\"False\")\nparser.add_argument(\"translate\", type=str, help=\"\"\"Map/Translate one of: ENSP_2_UniProtAC, ENSP_2_UniProtEntryName, UniProtAC_2_ENSP, UniProtEntryName_2_ENSP, UniProtAC_2_UniProtEntryName, UniProtEntryName_2_UniProtAC\"\"\", default=\"ENSP_2_UniProtAC\")\n# parser.add_argument(\"IDs_2_translate\", type=str, help=\"identifiers to translate/map. Separate the list of e.g. ENSPs '%0d' e.g. '4932.YAR019C%0d4932.YFR028C%0d4932.YGR092W'\", default=None)\n\nclass API_STRING(Resource):\n \"\"\"\n get enrichment for all available functional associations not 'just' one category\n \"\"\"\n def get(self):\n return self.post()\n\n @staticmethod\n def post():\n \"\"\"\n watch out for difference between passing parameter through\n - part of the path (url) is variable in resource\n - or parameters of form\n \"\"\"\n args_dict = defaultdict(lambda: None)\n args_dict[\"foreground\"] = request.form.get(\"foreground\") # ? what about the background ?\n args_dict[\"background\"] = request.form.get(\"background\")\n args_dict[\"output_format\"] = request.form.get(\"output_format\")\n args_dict[\"enrichment_method\"] = request.form.get(\"enrichment_method\")\n args_dict[\"taxid\"] = request.form.get(\"taxid\")\n args_dict.update(parser.parse_args())\n args_dict = convert_string_2_bool(args_dict)\n if variables.VERBOSE:\n print(\"-\" * 50)\n for key, val in sorted(args_dict.items()):\n print(key, val, type(val))\n ui = userinput.REST_API_input(pqo, args_dict)\n args_dict = ui.args_dict\n if not ui.check:\n args_dict[\"ERROR_UserInput\"] = \"ERROR_UserInput: Something went wrong parsing your input, please check your input and/or compare it to the examples.\"\n return help_page(args_dict)\n\n if args_dict[\"enrichment_method\"] == \"genome\":\n taxid_orig = args_dict[\"taxid\"]\n taxid, is_taxid_valid = query.check_if_TaxID_valid_for_GENOME_and_try_2_map_otherwise(args_dict[\"taxid\"], pqo, args_dict)\n if is_taxid_valid:\n args_dict[\"taxid\"] = taxid\n if variables.VERBOSE:\n if taxid_orig != taxid:\n print(\"taxid changed from {} to {}\".format(taxid_orig, taxid))\n else:\n print(\"valid taxid {}\".format(taxid))\n print(\"-\" * 50)\n else:\n return help_page(args_dict)\n\n ### DEBUG start\n if variables.DEBUG_HTML:\n df_all_etypes = pd.read_csv(variables.fn_example, sep=\"\\t\")\n results_all_function_types = df_all_etypes.groupby(cn.etype).head(20)\n # debug stop\n else:\n results_all_function_types = run.run_UniProt_enrichment(pqo, ui, args_dict, api_call=True)\n\n if results_all_function_types is False:\n print(\"returning help page\")\n return help_page(args_dict)\n else:\n # if variables.VERBOSE:\n # print(results_all_function_types[:500])\n # print(\"-\" * 50)\n # print(\"Version: \", version_temp)\n # print(\"-\" * 50)\n return format_multiple_results(args_dict, results_all_function_types, pqo)\n\napi.add_resource(API_STRING, \"/api\", \"/api_string\", \"/api_agotool\", \"/api_string/<output_format>\", \"/api_string/<output_format>/enrichment\")\n\nresources_last_updated_time = query.get_last_updated_text()\ncurrent_time_and_date_nicely_formatted = query.get_current_time_and_date()\nstatus_dict = {\"flat files last updated\": resources_last_updated_time,\n \"uWSGI instance last updated\": current_time_and_date_nicely_formatted}\n\nclass API_status(Resource):\n \"\"\"\n get information about the timestamp of files used, when were the resources updated and when was the uWSGI instance last updated\n \"\"\"\n @staticmethod\n def get():\n return jsonify(status_dict)\n\n def post(self):\n return self.get()\n\napi.add_resource(API_status, \"/status\", \"/info\")\n\n\n# class API_translate(Resource):\n# \"\"\"\n# translate one of:\n# ENSP_2_UniProtAC\n# ENSP_2_UniProtEntryName\n# UniProtAC_2_ENSP\n# UniProtEntryName_2_ENSP\n# UniProtAC_2_UniProtEntryName\n# UniProtEntryName_2_UniProtAC\n# \"\"\"\n# def get(self):\n# return self.post()\n#\n# def post(self):\n# args_dict = defaultdict(lambda: None)\n# args_dict.update(parser.parse_args())\n# args_dict = convert_string_2_bool(args_dict)\n# args_dict[\"foreground\"] = request.form.get(\"foreground\") # ? what about the background ?\n# IDs_2_translate = args_dict[\"foreground\"]\n# translate = args_dict[\"translate\"]\n#\n# if translate == \"ENSP_2_UniProtEntryName\":\n# dict_2_return = query.map_secondary_2_primary_ANs(ids_2_map=IDs_2_translate)\n# elif translate == \"UniProtEntryName_2_UniProtAC\":\n# dict_2_return = query.map_primary_2_secondary_ANs(ids_2_map=IDs_2_translate, no_ENSPs=True)\n# elif translate == \"UniProtEntryName_2_ENSP\":\n# dict_2_return = query.map_primary_2_secondary_ANs(ids_2_map=IDs_2_translate, ENSPs_only=True)\n#\n# elif translate == \"UniProtAC_2_ENSP\":\n# # dict_2_return = query.\n# pass\n# elif translate == \"ENSP_2_UniProtAC\":\n# tempDict_ENSP_2_UniProtEntryName = query.map_secondary_2_primary_ANs(ids_2_map=IDs_2_translate)\n# tempDict_UniProtEntryName_2_UniProtAC_and_ENSP = query.map_primary_2_secondary_ANs(ids_2_map=tempDict_ENSP_2_UniProtEntryName.values())\n#\n# return jsonify(dict_2_return)\n#\n# api.add_resource(API_translate, \"/translate\")\n\n\ndef PMID_description_to_year(string_):\n try:\n return int(string_[1:5])\n except ValueError or IndexError:\n return np.nan\n\ndef create_xml_tree(header, rows):\n xml_tree = etree.Element(\"EnrichmentResult\")\n header = header.split(\"\\t\")\n for row in rows:\n child = etree.SubElement(xml_tree, \"record\")\n for tag_content in zip(header, row.split(\"\\t\")):\n tag, content = tag_content\n etree.SubElement(child, tag).text = content\n return etree.tostring(xml_tree, pretty_print=True, xml_declaration=True, encoding=\"utf-8\")#.decode(\"UTF-8\")\n\ndef check_all_ENSPs_of_given_taxid(protein_ans_list, taxid):\n taxid_string = str(taxid)\n for an in protein_ans_list:\n if not an.startswith(taxid_string):\n return False\n return True\n\ndef check_taxids(args_dict):\n if args_dict[\"taxid\"] is not None:\n return args_dict[\"taxid\"]\n if args_dict[\"species\"] is not None:\n args_dict[\"ERROR_species\"] = \"ERROR_species: argument 'species' is deprecated, please use 'taxid' instead. You've provided is '{}'.\".format(args_dict[\"species\"])\n return False\n if args_dict[\"organism\"] is not None:\n args_dict[\"ERROR_organism\"] = \"ERROR_organism: argument 'organism' is deprecated, please use 'taxid' instead. You've provided is '{}'.\".format(args_dict[\"organism\"])\n return False\n\ndef convert_string_2_bool(args_dict):\n for key, val in args_dict.items():\n if isinstance(val, str):\n if val.lower() == \"true\":\n args_dict[key] = True\n elif val.lower() == \"false\":\n args_dict[key] = False\n else:\n pass\n return args_dict\n\ndef write2file(fn, tsv):\n with open(fn, 'w') as f:\n f.write(tsv)\n\nclass API_STRING_HELP(Resource):\n \"\"\"\n get enrichment for all available functional associations not 'just' one category\n \"\"\"\n @staticmethod\n def get():\n args_dict = defaultdict(lambda: None)\n args_dict.update(parser.parse_args())\n args_dict = parser.parse_args()\n args_dict[\"1_INFO\"] = \"INFO: default values are are shown unless you've provided arguments\"\n args_dict[\"2_INFO_Name_2_EntityType\"] = variables.functionType_2_entityType_dict\n args_dict[\"3_INFO_limit_2_entity_type\"] = \"comma separate desired entity_types e.g. '-21;-51;-52' (for GO biological process; UniProt keyword; SMART), default get all available.\"\n return help_page(args_dict)\n\n def post(self):\n return self.get()\n\napi.add_resource(API_STRING_HELP, \"/api_help\", \"/api_string_help\")\n\ndef help_page(args_dict):\n try:\n del args_dict[\"privileged\"]\n except KeyError:\n pass\n return jsonify(args_dict)\n\ndef format_multiple_results(args_dict, results_all_entity_types, pqo):\n output_format = args_dict[\"output_format\"]\n if output_format in {\"tsv\", \"tsv_no_header\", \"tsv-no-header\"}:\n return Response(results_all_entity_types, mimetype='text')\n elif output_format == \"json\":\n return app.response_class(response=results_all_entity_types, status=200, mimetype='application/json')\n elif output_format == \"xml\":\n return results_all_entity_types\n else:\n raise NotImplementedError\n\n################################################################################\n# index.html\n################################################################################\[email protected]('/index')\ndef index():\n return render_template('index.html')\n\n################################################################################\n# about.html\n################################################################################\[email protected]('/about')\ndef about():\n return render_template('about.html', last_updated_text=last_updated_text)\n\[email protected]('/doro')\ndef doro():\n return render_template('doro.html')\n\n################################################################################\n# parameters.html\n################################################################################\[email protected]('/parameters')\ndef parameters():\n with open(variables.FN_HELP_ENTITY_TYPES, \"r\") as fh:\n content = fh.read()\n content_entity_types = format_markdown(content)\n return render_template('parameters.html', **locals())\n\n################################################################################\n# results_zero.html\n################################################################################\[email protected]('/results_zero')\ndef gotupk_results_zero():\n return render_template('results_zero.html')\n\n################################################################################\n# page_not_found.html\n################################################################################\[email protected](404)\ndef page_not_found(e):\n return render_template('page_not_found.html'), 404\n\n################################################################################\n# example.html\n################################################################################\[email protected]('/example')\ndef example():\n return render_template('example.html', **locals())\n\[email protected]('/example/<path:filename>', methods=['GET', 'POST'])\ndef download_example_data(filename):\n uploads = app.config['EXAMPLE_FOLDER']\n return send_from_directory(directory=uploads, filename=filename)\n\[email protected]('/results/<path:filename>', methods=['GET', 'POST'])\ndef download_results_data(filename):\n uploads = app.config['SESSION_FOLDER']\n return send_from_directory(directory=uploads, filename=filename)\n\n################################################################################\n# db_schema.html\n################################################################################\n# @app.route(\"/db_schema\")\n# def db_schema():\n# with open(variables.FN_DATABASE_SCHEMA, \"r\") as fh:\n# content = fh.read()\n# # content = content.replace(\"{\", \"\\{\").replace(\"}\", \"\\}\")\n# # content = markdown.markdown(content, extensions=['extra', 'smarty'], output_format='html5')\n# # content = content.replace(r\"<table>\", r'<table id=\"table_id\" class=\"table table-striped hover\">').replace(\"<thead>\", '<thead class=\"table_header\">').replace(\"{\", \"\\{\").replace(\"}\", \"\\}\")\n# content = format_markdown(content)\n# return render_template(\"db_schema.html\", **locals())\n\n################################################################################\n# FAQ.html\n################################################################################\[email protected]('/FAQ')\ndef FAQ():\n return render_template('FAQ.html')\n\[email protected]('/API_Help')\ndef api_help():\n return render_template('API_Help.html')\n\n################################################################################\n# helper functions\n################################################################################\ndef format_markdown(content):\n content = content.replace(\"{\", \"\\{\").replace(\"}\", \"\\}\")\n content = markdown.markdown(content, extensions=['extra', 'smarty'], output_format='html5')\n return content.replace(r\"<table>\", r'<table id=\"table_id\" class=\"table table-striped hover text-center\">').replace(\"<thead>\", '<thead class=\"table_header\">')\n\n##### validation of user inputs\ndef validate_float_larger_zero_smaller_one(form, field):\n if not 0 < field.data < 1:\n raise wtforms.ValidationError(\" number must be: 0 < number < 1\")\n\ndef validate_float_between_zero_and_one(form, field):\n if not 0 <= field.data <= 1:\n print(\"validation failed what's next?\")\n raise wtforms.ValidationError(\" number must be: 0 <= number <= 1\")\n else:\n print(\"couldn't validate float between zero and one\")\n\ndef validate_float_between_zero_and_five(form, field):\n if not 0 <= field.data <= 5:\n raise wtforms.ValidationError(\" number must be: 0 <= number <= 5\")\n\ndef validate_integer(form, field):\n if not isinstance(field.data, int):\n raise wtforms.ValidationError()\n\ndef validate_number(form, field):\n if not isinstance(field.data, (int, float)):\n raise wtforms.ValidationError(\"\")\n\ndef validate_inflation_factor(form, field):\n if not field.data >= 1.0:\n raise wtforms.ValidationError(\" number must be larger than 1\")\n\ndef generate_session_id():\n pid = str(os.getpid())\n time_ = str(time.time())\n return \"_\" + pid + \"_\" + time_\n\ndef read_results_file(fn):\n \"\"\"\n :return: Tuple(header=String, results=ListOfString)\n \"\"\"\n with open(fn, 'r') as fh:\n lines_split = [ele.strip() for ele in fh.readlines()]\n return lines_split[0], lines_split[1:]\n\n################################################################################\n# enrichment.html\n################################################################################\nclass Enrichment_Form(wtforms.Form):\n userinput_file = fields.FileField('Expects a tab-delimited text-file',\n description=\"\"\"see 'Parameters' page for details\"\"\")\n# userinput_file = fields.FileField(label=None, description=None)\n foreground_textarea = fields.TextAreaField(\"Foreground\")\n background_textarea = fields.TextAreaField(\"Background & Intensity\")\n limit_2_entity_type = fields.SelectField(\"Category of functional associations\", # # (\"-53\", \"SMART domains\"), # not available in UniProt version\n choices = ((None, \"all available\"),\n (\"-21;-22;-23\", \"all GO categories\"),\n (\"-25\", \"Brenda Tissue Ontology\"),\n (\"-26\", \"Disease Ontology IDs\"),\n (\"-51\", \"UniProt keywords\"),\n (\"-57\", \"Reactome\"),\n (\"-56\", \"Publications\"),\n (\"-52\", \"KEGG pathways\"),\n (\"-21\", \"GO Biological Process\"),\n (\"-23\", \"GO Molecular Function\"),\n (\"-22\", \"GO Celluar Compartment\"),\n (\"-20\", \"GO Cellular Compartment from Textmining\"),\n (\"-58\", \"Wiki pathways\"),\n (\"-54\", \"InterPro domains\"),\n (\"-55\", \"Pfam domains\")),\n description=\"\"\"Select either a functional category, one or all three GO categories (molecular function, biological process, cellular component), UniProt keywords, KEGG pathways, etc.\"\"\")\n enrichment_method = fields.SelectField(\"Enrichment method\",\n choices = ((\"abundance_correction\", \"abundance_correction\"),\n (\"characterize_foreground\", \"characterize_foreground\"),\n (\"compare_samples\", \"compare_samples\"),\n (\"genome\", \"genome\")), # (\"compare_groups\", \"compare_groups\"),\n description=\"\"\"abundance_correction: Foreground vs Background abundance corrected\ncompare_samples: Foreground vs Background (no abundance correction)\ncharacterize_foreground: Foreground only\"\"\")\n go_slim_or_basic = fields.SelectField(\"GO basic or a slim subset\",\n choices = ((None, \"no subset\"),\n (\"generic\", \"Generic GO slim by GO Consortium\"),\n (\"agr\", \"Alliance of Genomes Resources (AGR)\"),\n (\"aspergillus\", \"Aspergillus Genome Data\"),\n (\"candida\", \"Candida (albicans) Genome Database\"),\n (\"chembl\", \"ChEMBL Drug Target\"),\n (\"flybase_ribbon\", \"FlyBase\"),\n (\"metagenomics\", \"EBI Metagenomics group\"),\n (\"mouse\", \"Mouse Genome Informatics\"),\n (\"pir\", \"Protein Information Resource\"),\n (\"plant\", \"Plant subset by The Arabidopsis Information Resource (TAIR)\"),\n (\"pombe\", \"Schizosaccharomyces pombe subset PomBase\"),\n (\"synapse\", \"Synapse GO slim SynGO\"),\n (\"yeast\", \"Yeast subset Saccharomyces Genome Database\")),\n description=\"\"\"Choose between the full Gene Ontology or GO slim subset a subset of GO terms that are less fine grained.\"\"\")\n o_or_u_or_both = fields.SelectField(\"Over-, under-represented or both\", choices = ((\"both\", \"both\"), (\"overrepresented\", \"overrepresented\"), (\"underrepresented\", \"underrepresented\")), description=\"\"\"Choose to only test and report overrepresented or underrepresented GO-terms, or to report both of them.\"\"\")\n # num_bins = fields.IntegerField(\"Number of bins\", [validate_integer], default = 100, description=\"\"\"The number of bins created based on the abundance values provided. Only relevant if \"Abundance correction\" is selected.\"\"\")\n # fold_enrichment_for2background = fields.FloatField(\"fold enrichment foreground/background\", [validate_number], default = 0, description=\"\"\"Minimum cutoff value of \"fold_enrichment_foreground_2_background\".\"\"\")\n p_value_cutoff = fields.FloatField(\"p value cutoff\", [validate_float_between_zero_and_one], default = 0.01, description=\"\"\"Maximum cutoff value of uncorrected p value. Default is 1%\"\"\")\n FDR_cutoff = fields.FloatField(\"corrected p value (FDR) cutoff\", [validate_float_between_zero_and_one], default = 0.05, description=\"\"\"Maximum False Discovery Rate (Benjamini-Hochberg corrected p values) cutoff value (1 means no cutoff). Default is 5%\"\"\")\n filter_foreground_count_one = fields.BooleanField(\"Filter foreground count one\", default=\"checked\", description=\"Remove all functional terms if they have only a single protein association in the foreground (default=checked)\")\n filter_PMID_top_n = fields.IntegerField(\"Filter top n publications\", [validate_integer], default=20, description=\"\"\"Reduce the number of publications to be reported to the given number (default 20). The publications are sorted as follows and the top n selected: \n 'characterize_foreground': foreground_count and year. \n all other methods: FDR, year, and foreground_count\"\"\")\n filter_parents = fields.BooleanField(\"Filter redundant parent terms\", default=\"checked\", description=\"Retain the most specific (deepest hierarchical level) and remove all parent terms if they share the exact same foreground proteins (default=checked)\")\n taxid = fields.IntegerField(\"NCBI TaxID\", [validate_integer], default=9606, description=\"NCBI Taxonomy IDentifier, please use the taxonomic rank of species e.g. '9606' for Homo sapiens. Only relevant if 'enrichment_method' is 'genome' (default=9606)\")\n multiple_testing_per_etype = fields.BooleanField(\"Multiple testing per category\", default=\"checked\", description=\"If True calculate multiple testing correction separately per functional category, in contrast to performing the correction together for all results (default=checked).\")\n\nclass Example_1(Enrichment_Form):\n \"\"\"\n example 1\n Yeast acetylation,\n abundance_correction. Example_Yeast_acetylation_abundance_correction.txt\n \"\"\"\n df = pd.read_csv(os.path.join(variables.EXAMPLE_FOLDER, \"Example_Yeast_acetylation_abundance_correction.txt\"), sep='\\t')\n fg = \"\\n\".join(df.loc[df[\"Foreground\"].notnull(), \"Foreground\"].tolist())\n bg_int = \"\"\n for bg_ele, int_ele in zip(df[\"Background\"].values, df[\"Intensity\"].values):\n bg_int += bg_ele + \"\\t\" + str(int_ele) + \"\\n\"\n foreground_textarea = fields.TextAreaField(\"Foreground\", default=fg)\n background_textarea = fields.TextAreaField(\"Background & Intensity\", default=bg_int.strip())\n enrichment_method = fields.SelectField(\"Enrichment method\", choices=((\"abundance_correction\", \"abundance_correction\"), (\"compare_samples\", \"compare_samples\"), (\"genome\", \"genome\"), (\"characterize_foreground\", \"characterize_foreground\")), description=\"\"\"abundance_correction: Foreground vs Background abundance corrected\n compare_samples: Foreground vs Background (no abundance correction)\n characterize_foreground: Foreground only\"\"\")\n\nclass Example_2(Enrichment_Form):\n \"\"\"\n example 2\n Human hemoglobin\n genome\n \"\"\"\n foreground_textarea = fields.TextAreaField(\"Foreground\", default=\"\"\"P69905\\nP68871\\nP02042\\nP02100\"\"\")\n # foreground_textarea = fields.TextAreaField(\"Foreground\", default=\"\"\"HBA_HUMAN\\nHBB_HUMAN\\nHBD_HUMAN\\nHBE_HUMAN\"\"\")\n background_textarea = fields.TextAreaField(\"Background & Intensity\", default=\"no data necessary (in this field) since enrichment method 'genome' is being used, which uses pre-selected background reference proteome from UniProt\")\n enrichment_method = fields.SelectField(\"Enrichment method\", choices=((\"genome\", \"genome\"), (\"compare_samples\", \"compare_samples\"), (\"abundance_correction\", \"abundance_correction\"), (\"characterize_foreground\", \"characterize_foreground\")), description=\"\"\"abundance_correction: Foreground vs Background abundance corrected\n compare_samples: Foreground vs Background (no abundance correction)\n characterize_foreground: Foreground only\"\"\")\n taxid = fields.IntegerField(\"NCBI TaxID\", [validate_integer], default=9606, description=\"NCBI Taxonomy IDentifier e.g. '9606' for Homo sapiens. Only relevant if 'enrichment_method' is 'genome' (default=9606 for Homo sapiens)\")\n\nclass Example_3(Enrichment_Form):\n \"\"\"\n example 3\n Mouse interferon (STRING network)\n compare_samples\n \"\"\"\n foreground_textarea = fields.TextAreaField(\"Foreground\", default=\"\"\"Q9R117\\nP33896\\nO35664\\nO35716\\nP01575\\nP42225\\nP07351\\nP52332\\nQ9WVL2\\nQ61179\\nQ61716\"\"\")\n background_input = \"\\n\".join(query.get_proteins_of_taxid(10090, read_from_flat_files=True))\n background_textarea = fields.TextAreaField(\"Background & Intensity\", default=background_input)\n enrichment_method = fields.SelectField(\"Enrichment method\", choices=((\"compare_samples\", \"compare_samples\"), (\"abundance_correction\", \"abundance_correction\"), (\"genome\", \"genome\"), (\"characterize_foreground\", \"characterize_foreground\")), description=\"\"\"abundance_correction: Foreground vs Background abundance corrected\n compare_samples: Foreground vs Background (no abundance correction)\n characterize_foreground: Foreground only\"\"\")\n\nclass Example_4(Enrichment_Form):\n \"\"\"\n example 4\n characterize_foreground\n replace with Covid-19 example\n previously example 4: Cation-dependent mannose-6-phosphate receptor, MPRD_HUMAN, Gene M6PR\n \"\"\"\n foreground_textarea = fields.TextAreaField(\"Foreground\", default=\"\"\"O15393\\nP09958\\nQ92499\\nQ9BYF1\\nO43765\\nP05231\\nP08887\\nP20701\\nP35232\\nP40189\\nP52292\\nP84022\\nQ10589\\nQ8N3R9\\nQ99623\\nP0C6U8\\nP0C6X7\\nP0DTC1\\nP0DTD1\\nP0DTC2\\nP59594\\nP59595\\nP59632\\nP59635\\nP59636\\nP59637\\nP59596\\nP59633\\nP59634\\nP0DTC3\\nP0DTC5\\nP0DTC7\\nP0DTC9\\nP0DTC4\\nP0DTC6\\nP0DTC8\\nP0DTD2\\nQ7TFA1\\nQ7TLC7\\nQ80H93\\nP0DTD3\\nP0DTD8\\nQ7TFA0\\nA0A663DJA2\"\"\")\n enrichment_method = fields.SelectField(\"Enrichment method\", choices=((\"characterize_foreground\", \"characterize_foreground\"), (\"compare_samples\", \"compare_samples\"), (\"abundance_correction\", \"abundance_correction\"), (\"genome\", \"genome\")), description=\"\"\"abundance_correction: Foreground vs Background abundance corrected # compare_samples: Foreground vs Background (no abundance correction) # characterize_foreground: Foreground only\"\"\")\n\n\[email protected]('/example_1')\ndef example_1():\n return render_template('enrichment.html', form=Example_1(), example_status=\"example_1\", example_title=\"Yeast acetylation\", example_description=\"\"\"comparing acetylated yeast (Saccharomyces cerevisiae) proteins to the experimentally observed proteome using the 'abundance_correction' method. Data was taken from the original publication (see 'About' page).\"\"\", last_updated_text=last_updated_text, NCBI_autocomplete_list=NCBI_autocomplete_list, taxid=\"\")\n\[email protected]('/example_2')\ndef example_2():\n return render_template('enrichment.html', form=Example_2(), example_status=\"example_2\", example_title=\"Human haemoglobin\", example_description=\"\"\"comparing human haemoglobin proteins to the UniProt reference proteome. When using the 'genome' method a specific NCBI taxonomic identifier (TaxID) has to be provided. In this case it is '9606' for Homo sapiens. In case don't know the TaxID of your organism of choice, please search at NCBI (link provided below).\"\"\", last_updated_text=last_updated_text, NCBI_autocomplete_list=NCBI_autocomplete_list, taxid=\"Homo sapiens (Human), 9606, UP000005640, 20610\")\n\[email protected]('/example_3')\ndef example_3():\n return render_template('enrichment.html', form=Example_3(), example_status=\"example_3\", example_title=\"Mouse interferon\", example_description=\"\"\"comparing a couple of mouse interferons to the reference proteome, applying the 'compare_samples' method.\"\"\", last_updated_text=last_updated_text, NCBI_autocomplete_list=NCBI_autocomplete_list, taxid=\"\")\n\[email protected]('/example_4')\ndef example_4():\n return render_template('enrichment.html', form=Example_4(), example_status=\"example_4\", example_title=\"SARS-CoV-2 coronavirus and other entries relating to the COVID-19 outbreak\", example_description=\"\"\"characterize the foreground: SARS-CoV-2 coronavirus and other entries relating to the COVID-19 outbreak (from https://covid-19.uniprot.org).\"\"\", last_updated_text=last_updated_text, NCBI_autocomplete_list=NCBI_autocomplete_list, taxid=\"\")\n\[email protected]('/')\ndef enrichment():\n return render_template('enrichment.html', form=Enrichment_Form(), example_status=\"example_None\", last_updated_text=last_updated_text, NCBI_autocomplete_list=NCBI_autocomplete_list, taxid=\"\")\n\[email protected]('/help')\ndef help_():\n return render_template('help.html', form=Enrichment_Form())\n\ndef generate_interactive_result_page(df, args_dict, session_id, form, errors=()):\n file_name = \"results_orig\" + session_id + \".tsv\"\n fn_results_orig_absolute = os.path.join(SESSION_FOLDER_ABSOLUTE, file_name)\n df.to_csv(fn_results_orig_absolute, sep=\"\\t\", header=True, index=False)\n enrichment_method = args_dict[\"enrichment_method\"]\n df, term_2_edges_dict_json, sizeref = plot_and_table.ready_df_for_plot(df, lineage_dict, enrichment_method)\n dict_per_category, term_2_positionInArr_dict, term_2_category_dict = plot_and_table.df_2_dict_per_category_for_traces(df, enrichment_method)\n cols_sort_order = cn.enrichmentMethod_2_colsSortOrder_dict[enrichment_method]\n table_as_text = plot_and_table.df_2_html_table_with_data_bars(df, cols_sort_order, enrichment_method, session_id, SESSION_FOLDER_ABSOLUTE)\n # if enrichment_method != \"characterize_foreground\":\n # x_min, x_max, y_min, y_max = df[cn.logFDR].min(), df[cn.logFDR].max(), df[cn.effect_size].min(), df[cn.effect_size].max()\n # x_range_start, x_range_stop, y_range_start, y_range_stop = x_min * 0.93, x_max * 1.085, y_min * 0.9, y_max * 1.1\n # else:\n # x_range_start, x_range_stop, y_range_start, y_range_stop = -1, -1, -1, -1\n return render_template('results_interactive.html', form=Enrichment_Form(),\n term_2_edges_dict_json=term_2_edges_dict_json, sizeref=sizeref,\n dict_per_category=dict_per_category, term_2_positionInArr_dict=term_2_positionInArr_dict, term_2_category_dict=term_2_category_dict,\n df_as_html_dict=table_as_text, enrichment_method=enrichment_method,\n file_path=file_name) #,\n # x_range_start=x_range_start, x_range_stop=x_range_stop, y_range_start=y_range_start, y_range_stop=y_range_stop)\n\n################################################################################\n# results.html\n################################################################################\nclass Results_Form(wtforms.Form):\n pass\n\[email protected]('/results', methods=[\"GET\", \"POST\"])\ndef results():\n \"\"\"\n cluster_list: nested ListOfString corresponding to indices of results\n results_filtered = filter(header, results, indent)\n results_filtered: reduced version of results\n \"\"\"\n form = Enrichment_Form(request.form)\n if request.method == 'POST':\n try:\n fileobject = request.files['userinput_file']\n except KeyError:\n fileobject = None\n # filename = secure_filename(fileobject.filename) # necessary if saving the file to disk\n args_dict = {\"limit_2_entity_type\": form.limit_2_entity_type.data,\n \"go_slim_subset\": form.go_slim_or_basic.data,\n \"p_value_cutoff\": form.p_value_cutoff.data,\n \"FDR_cutoff\": form.FDR_cutoff.data,\n \"o_or_u_or_both\": form.o_or_u_or_both.data,\n \"filter_PMID_top_n\": form.filter_PMID_top_n.data,\n \"filter_foreground_count_one\": form.filter_foreground_count_one.data,\n \"filter_parents\": form.filter_parents.data,\n # \"taxid\": form.taxid.data,\n # \"taxid\": request.form[\"NCBI_TaxID\"],\n \"output_format\": \"dataframe\",\n \"enrichment_method\": form.enrichment_method.data,\n \"multiple_testing_per_etype\": form.multiple_testing_per_etype.data,\n }\n if args_dict[\"enrichment_method\"] == \"genome\":\n try:\n taxid = request.form[\"NCBI_TaxID\"]\n taxid_split = taxid.split(\", \")\n if len(taxid_split) == 4: # user selected from suggestion\n taxid = int(taxid_split[1])\n else: # hopefully only NCBI taxid entered\n taxid = int(taxid)\n args_dict[\"taxid\"] = taxid\n except:\n args_dict[\"ERROR_taxid\"] = \"We're having issues parsing your NCBI taxonomy input '{}'. Please select an entry from the autocomplete suggestions or enter a valid NCBI taxonomy ID that has a UniProt reference proteome.\".format(request.form[\"NCBI_TaxID\"])\n\n ui = userinput.Userinput(pqo, fn=fileobject,\n foreground_string=form.foreground_textarea.data,\n background_string=form.background_textarea.data,\n decimal='.', args_dict=args_dict)\n args_dict = dict(ui.args_dict) # since args_dict was copied\n # if variables.VERBOSE:\n # print(\"-\" * 80)\n # print(\"Version A preload True\")\n # for key, val in args_dict.items():\n # print(key, val, type(val))\n # print(\"-\" * 80)\n if variables.DEBUG_HTML:\n ui.check = True # ToDo comment #!!! DEBUG\n if ui.check:\n ip = request.environ['REMOTE_ADDR']\n string2log = \"ip: \" + ip + \"\\n\" + \"Request: results\" + \"\\n\"\n string2log += \"\"\"limit_2_entity_type: {}\\ngo_slim_or_basic: {}\\no_or_u_or_both: {}\\np_value_cutoff: {}\\np_value_mulitpletesting: {}\\n\"\"\".format(form.limit_2_entity_type.data, form.go_slim_or_basic.data, form.o_or_u_or_both.data, form.p_value_cutoff.data, form.FDR_cutoff.data, form.enrichment_method.data)\n if not app.debug:\n log_activity(string2log)\n ## DEBUG start\n if variables.DEBUG_HTML:\n df_all_etypes = pd.read_csv(variables.fn_example, sep=\"\\t\")\n df_all_etypes = df_all_etypes.groupby(cn.etype).head(20)\n args_dict[\"enrichment_method\"] = \"genome\"\n else:\n df_all_etypes = run.run_UniProt_enrichment(pqo, ui, args_dict)\n ### DEBUG stop\n else:\n errors_dict, args_dict_minus_errors = helper_split_errors_from_dict(args_dict)\n return render_template('info_check_input.html', args_dict=args_dict_minus_errors, errors_dict=errors_dict)\n if type(df_all_etypes) == bool:\n errors_dict, args_dict_minus_errors = helper_split_errors_from_dict(args_dict)\n return render_template('info_check_input.html', args_dict=args_dict_minus_errors, errors_dict=errors_dict)\n elif len(df_all_etypes) == 0:\n return render_template('results_zero.html')\n else:\n ### old version with compact and comprehensive results\n # return generate_result_page(df_all_etypes, args_dict, generate_session_id(), form=Results_Form())\n return generate_interactive_result_page(df_all_etypes, args_dict, generate_session_id(), form=Results_Form())\n return render_template('enrichment.html', form=form, last_updated_text=last_updated_text, NCBI_autocomplete_list=NCBI_autocomplete_list, taxid=\"\")\n\ndef helper_split_errors_from_dict(args_dict):\n errors_dict, args_dict_minus_errors = {}, {}\n for key, val in args_dict.items():\n if key.lower().startswith(\"error\"):\n errors_dict[key] = val\n else:\n args_dict_minus_errors[key] = val\n return errors_dict, args_dict_minus_errors\n\ndef generate_result_page_table_only(df_all_etypes, args_dict, session_id, form, errors=(), compact_or_comprehensive=\"compact\"):\n file_name = \"results_orig\" + session_id + \".tsv\"\n fn_results_orig_absolute = os.path.join(SESSION_FOLDER_ABSOLUTE, file_name)\n df_all_etypes.to_csv(fn_results_orig_absolute, sep=\"\\t\", header=True, index=False)\n if args_dict[\"enrichment_method\"] != \"characterize_foreground\":\n df_all_etypes = df_all_etypes.sort_values([cn.etype, cn.rank])\n etype_2_rowsCount_dict, etype_2_df_as_html_dict = {}, {}\n p_value = \"p value\"\n FDR = \"p value corrected\"\n effect_size = \"effect size\"\n over_under = \"over under\"\n hierarchical_level = \"level\"\n s_value = \"s value\"\n ratio_in_FG = \"ratio in FG\"\n ratio_in_BG = \"ratio in BG\"\n FG_IDs = \"FG IDs\"\n BG_IDs = \"BG IDs\"\n FG_count = \"FG count\"\n BG_count = \"BG count\"\n FG_n = \"FG n\"\n BG_n = \"BG n\"\n rank = \"rank\"\n df_all_etypes = df_all_etypes.rename(columns={\"over_under\": over_under, \"hierarchical_level\": hierarchical_level, \"p_value\": p_value, \"FDR\": FDR, \"effectSize\": effect_size, \"s_value\": s_value, \"ratio_in_FG\": ratio_in_FG, \"ratio_in_BG\": ratio_in_BG, \"FG_IDs\": FG_IDs, \"BG_IDs\": BG_IDs, \"FG_count\": FG_count, \"BG_count\": BG_count, \"FG_n\": FG_n, \"BG_n\": BG_n})\n pd.set_option('colheader_justify', 'center')\n ### compact results\n if compact_or_comprehensive == \"compact\":\n if args_dict[\"enrichment_method\"] == \"characterize_foreground\":\n cols_compact = [rank, \"term\", \"description\", ratio_in_FG] # [FG_count, \"term\", \"description\", ratio_in_FG]\n for etype, group in df_all_etypes.groupby(\"etype\"):\n num_rows = group.shape[0]\n if num_rows > 0:\n etype_2_rowsCount_dict[etype] = num_rows\n if etype in variables.PMID: # .sort_values([\"FG_count\", \"year\"], ascending=[False, False])\n etype_2_df_as_html_dict[etype] = group[cols_compact + [\"year\"]].to_html(index=False, border=0, classes=[\"table table_etype dataTable display\"], table_id=\"table_etype\", justify=\"left\", formatters={effect_size: lambda x: \"{:.2f}\".format(x), FDR: lambda x: \"{:.2E}\".format(x)})\n elif etype in variables.entity_types_with_ontology:\n etype_2_df_as_html_dict[etype] = group[cols_compact + [hierarchical_level]].to_html(index=False, border=0, classes=[\"table table_etype dataTable display\"], table_id=\"table_etype\", justify=\"left\", formatters={effect_size: lambda x: \"{:.2f}\".format(x), FDR: lambda x: \"{:.2E}\".format(x)})\n else:\n etype_2_df_as_html_dict[etype] = group[cols_compact + [FG_n]].to_html(index=False, border=0, classes=[\"table table_etype dataTable display\"], table_id=\"table_etype\", justify=\"left\", formatters={effect_size: lambda x: \"{:.2f}\".format(x), FDR: lambda x: \"{:.2E}\".format(x)})\n else:\n cols_compact = [\"rank\", \"term\", \"description\", FDR, effect_size]\n for etype, group in df_all_etypes.groupby(\"etype\"):\n num_rows = group.shape[0]\n if num_rows > 0:\n etype_2_rowsCount_dict[etype] = num_rows\n etype_2_df_as_html_dict[etype] = group[cols_compact].to_html(index=False, border=0, classes=[\"table table_etype dataTable display\"], table_id=\"table_etype\", justify=\"left\", formatters={effect_size: lambda x: \"{:.2f}\".format(x), FDR: lambda x: \"{:.2E}\".format(x)})\n return render_template('results_compact_table.html', etype_2_rowsCount_dict=etype_2_rowsCount_dict, etype_2_df_as_html_dict=etype_2_df_as_html_dict, errors=errors, file_path=file_name, session_id=session_id, form=form, args_dict=args_dict, df_all_etypes=df_all_etypes)\n\n ### comprehensive results\n elif compact_or_comprehensive == \"comprehensive\":\n # show year, not hierarchy\n cols_sort_order_PMID = ['rank', 'term', 'description', 'year', over_under, p_value, FDR, effect_size, s_value, ratio_in_FG, ratio_in_BG, FG_count, FG_n, BG_count, BG_n, FG_IDs, BG_IDs]\n # show hierarchy, not year\n cols_sort_order_hierarchy = ['rank', 'term', 'description', hierarchical_level, over_under, p_value, FDR, effect_size, s_value, ratio_in_FG, ratio_in_BG, FG_count, FG_n, BG_count, BG_n, FG_IDs, BG_IDs]\n # not hiearachy, not year\n cols_sort_order_rest = ['rank', 'term', 'description', over_under, p_value, FDR, effect_size, s_value, ratio_in_FG, ratio_in_BG, FG_count, FG_n, BG_count, BG_n, FG_IDs, BG_IDs]\n\n def helper_format_to_html(df):\n return df.to_html(index=False, border=0, classes=[\"table table_etype dataTable display\"], table_id=\"table_etype\", justify=\"left\",\n formatters={\"effect size\": lambda x: \"{:.2f}\".format(x), FDR: lambda x: \"{:.2E}\".format(x), p_value: lambda x: \"{:.2E}\".format(x), s_value: lambda x: \"{:.2f}\".format(x),\n ratio_in_FG: lambda x: \"{:.2f}\".format(x), ratio_in_BG: lambda x: \"{:.2f}\".format(x), FG_count: lambda x: \"{:.0f}\".format(x)})\n\n if args_dict[\"o_or_u_or_both\"] != \"both\": # don't hide \"over under\"\n cols_sort_order_PMID.remove(over_under)\n cols_sort_order_hierarchy.remove(over_under)\n cols_sort_order_rest.remove(over_under)\n\n if args_dict[\"enrichment_method\"] not in {\"compare_samples\"}: # \"compare_groups\"\n cols_sort_order_PMID.remove(BG_IDs)\n cols_sort_order_hierarchy.remove(BG_IDs)\n cols_sort_order_rest.remove(BG_IDs)\n\n if args_dict[\"enrichment_method\"] == \"characterize_foreground\":\n cols_2_remove = (BG_IDs, BG_n, BG_count, ratio_in_BG, over_under, p_value, FDR, effect_size, s_value, rank)\n cols_sort_order_PMID = [ele for ele in cols_sort_order_PMID if ele not in cols_2_remove]\n cols_sort_order_hierarchy = [ele for ele in cols_sort_order_hierarchy if ele not in cols_2_remove]\n cols_sort_order_rest = [ele for ele in cols_sort_order_rest if ele not in cols_2_remove]\n\n for etype, group in df_all_etypes.groupby(\"etype\"):\n num_rows = group.shape[0]\n if num_rows > 0:\n etype_2_rowsCount_dict[etype] = num_rows\n if etype in variables.PMID: # -56 is the only one with \"year\"\n etype_2_df_as_html_dict[etype] = helper_format_to_html(group[cols_sort_order_PMID])\n elif etype in variables.entity_types_with_ontology:\n etype_2_df_as_html_dict[etype] = helper_format_to_html(group[cols_sort_order_hierarchy])\n else:\n etype_2_df_as_html_dict[etype] = helper_format_to_html(group[cols_sort_order_rest])\n\n return render_template('results_comprehensive_table.html', etype_2_rowsCount_dict=etype_2_rowsCount_dict, etype_2_df_as_html_dict=etype_2_df_as_html_dict, errors=errors, file_path=file_name, session_id=session_id, form=form, args_dict=args_dict)\n else:\n print(\"compact_or_comprehensive is '{}' {}, which is not understood\".format(compact_or_comprehensive, type(compact_or_comprehensive)))\n\[email protected]('/results_comprehensive_table', methods=[\"GET\", \"POST\"])\ndef results_comprehensive():\n file_path = request.form['file_path']\n df_all_etypes = pd.read_csv(os.path.join(SESSION_FOLDER_ABSOLUTE, file_path), sep='\\t')\n args_dict = request.form['args_dict'] # cast to dict from defaultdict\n args_dict = literal_eval(args_dict)\n session_id = request.form['session_id']\n compact_or_comprehensive = request.form['compact_or_comprehensive']\n return generate_result_page_table_only(df_all_etypes, args_dict, session_id, Results_Form(), errors=(), compact_or_comprehensive=compact_or_comprehensive)\n\ndef fn_suffix2abs_rel_path(suffix, session_id):\n file_name = \"results_\" + suffix + session_id + \".tsv\"\n fn_results_absolute = os.path.join(SESSION_FOLDER_ABSOLUTE, file_name)\n fn_results_relative = os.path.join(SESSION_FOLDER_RELATIVE, file_name)\n return file_name, fn_results_absolute, fn_results_relative\n\ndef compact_count_2_n_cols(row):\n return \"{}/{} {}/{}\".format(row[\"FG_count\"], row[\"FG_n\"], row[\"BG_count\"], row[\"BG_n\"])\n\ndef compact_count_2_n_cols_FG(row):\n return \"{}/{}\".format(row[\"FG_count\"], row[\"FG_n\"])\n\n\nif __name__ == \"__main__\":\n ################################################################################\n # app.run(host='0.0.0.0', DEBUG=True, processes=8)\n # processes should be \"1\", otherwise nginx throws 502 errors with large files\n ### SAN port 10110\n ### PISCES IP 127.0.0.1 port 10110\n ### ATLAS IP 0.0.0.0 port 5911\n ### Aquarius port 5911 (via docker-compose)\n # print(\"#\" * 80)\n # print(\"running aGOtool on IP {} port {}\".format(IP, port))\n # app.run(host=IP, port=port, processes=1, debug=variables.DEBUG)\n if ARGPARSE:\n print(IP, port)\n print(\"#\" * 80)\n print(\"running aGOtool on IP {} port {}\".format(IP, port))\n app.run(host=IP, port=port, processes=1, debug=variables.DEBUG)\n else:\n app.run(processes=1, port=5911, debug=variables.DEBUG)\n\n # curl \"https://agotool.org/api?taxid=9606&output_format=tsv&enrichment_method=genome&taxid=9606&caller_identity=test&foreground=P69905%0dP68871%0dP02042%0dP02100\" > response.txt\n # curl \"https://agotool.org/api?STRING_beta=True&taxid=9606&output_format=tsv&enrichment_method=genome&taxid=9606&caller_identity=test&foreground=P69905%0dP68871%0dP02042%0dP02100\" > response.txt\n # curl \"https://agotool.org/api?STRING_beta=True&taxid=9606&output_format=tsv&enrichment_method=characterize_foreground&taxid=9606&caller_identity=test&foreground=P69905%0dP68871%0dP02042%0dP02100\" > response.txt\n # curl \"127.0.0.1:5911/api?taxid=9606&output_format=tsv&enrichment_method=genome&caller_identity=bubu&foreground=P69905%0dP68871%0dP02042%0dP02100\" > response.txt\n # curl \"0.0.0.0:5911/api?taxid=9606&output_format=tsv&enrichment_method=genome&caller_identity=bubu&foreground=P69905%0dP68871%0dP02042%0dP02100\" > response.txt\n # curl \"localhost:5911/api?taxid=9606&output_format=tsv&enrichment_method=genome&caller_identity=bubu&foreground=P69905%0dP68871%0dP02042%0dP02100\" > response.txt\n # curl \"http://localhost:5911/api?taxid=9606&output_format=tsv&enrichment_method=genome&caller_identity=bubu&foreground=P69905%0dP68871%0dP02042%0dP02100\" > response.txt\n ### Corona example of 13 UniProt ENSPs\n # import requests\n # from io import StringIO\n # import pandas as pd\n # url_ = r\"https://agotool.meringlab.org/api\"\n # ensps = ['9606.ENSP00000221566', '9606.ENSP00000252593', '9606.ENSP00000332973', '9606.ENSP00000349252', '9606.ENSP00000357470', '9606.ENSP00000370698', '9606.ENSP00000381588', '9606.ENSP00000385675', '9606.ENSP00000389326', '9606.ENSP00000438483', '9606.ENSP00000441875', '9606.ENSP00000479488', '9606.ENSP00000483552']\n # fg = \"%0d\".join(ensps)\n # result = requests.post(url_, params={\"output_format\": \"tsv\", \"enrichment_method\": \"genome\", \"taxid\": 9606}, data={\"foreground\": fg})\n # df = pd.read_csv(StringIO(result.text), sep='\\t')\n # print(df.groupby(\"etype\")[\"term\"].count())\n\n### PyTest on Pisces --> could fix permissions\n# -o cache_dir=/home/dblyon/pytest_cache\n# -p no:cacheprovider"
] | [
[
"pandas.read_csv",
"pandas.Series",
"pandas.DataFrame"
],
[
"pandas.set_option",
"pandas.read_csv"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
CPJKU/score_following_game | [
"f04e977b09cceb49588dcf8e216909d815a54519"
] | [
"score_following_game/agents/optim_utils.py"
] | [
"\nimport numpy as np\nimport torch.optim as optim\n\nfrom ast import literal_eval as make_tuple\n\n\ndef cast_optim_params(optim_params):\n \"\"\"\n\n :param optim_params:\n :return:\n \"\"\"\n for k in optim_params.keys():\n\n # check if argument is a parameter tuple\n if isinstance(optim_params[k], str) and '(' in optim_params[k]:\n optim_params[k] = make_tuple(optim_params[k])\n else:\n try:\n optim_params[k] = np.float(optim_params[k])\n except:\n pass\n\n return optim_params\n\n\ndef get_optimizer(optimizer_name, params, **kwargs):\n \"\"\"\n Compile pytorch optimizer\n\n :param optimizer_name:\n :param params:\n :param kwargs:\n :return:\n \"\"\"\n constructor = getattr(optim, optimizer_name)\n optimizer = constructor(params, **kwargs)\n return optimizer\n"
] | [
[
"numpy.float"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
p-koo/exponential_activations | [
"9032a360c1abb0f07b824e3ce6d20707efe306fd",
"9032a360c1abb0f07b824e3ce6d20707efe306fd",
"9032a360c1abb0f07b824e3ce6d20707efe306fd"
] | [
"code/controls/initialization_sweep_step3_filter_match.py",
"code/model_zoo/basset.py",
"code/tfomics/explain.py"
] | [
"import os, sys\nfrom six.moves import cPickle\nimport numpy as np\nimport pandas as pd\nimport helper\nfrom tfomics import utils\n\n#------------------------------------------------------------------------------------------------\n# JASPAR filter indices\n\narid3 = ['MA0151.1', 'MA0601.1', 'PB0001.1']\ncebpb = ['MA0466.1', 'MA0466.2']\nfosl1 = ['MA0477.1']\ngabpa = ['MA0062.1', 'MA0062.2']\nmafk = ['MA0496.1', 'MA0496.2']\nmax1 = ['MA0058.1', 'MA0058.2', 'MA0058.3']\nmef2a = ['MA0052.1', 'MA0052.2', 'MA0052.3']\nnfyb = ['MA0502.1', 'MA0060.1', 'MA0060.2']\nsp1 = ['MA0079.1', 'MA0079.2', 'MA0079.3']\nsrf = ['MA0083.1', 'MA0083.2', 'MA0083.3']\nstat1 = ['MA0137.1', 'MA0137.2', 'MA0137.3', 'MA0660.1', 'MA0773.1']\nyy1 = ['MA0095.1', 'MA0095.2']\n\n\nGmeb1 = ['MA0615.1']\n\nmotifs = [[''],arid3, cebpb, fosl1, gabpa, mafk, max1, mef2a, nfyb, sp1, srf, stat1, yy1]\nmotifnames = [ '','arid3', 'cebpb', 'fosl1', 'gabpa', 'mafk', 'max', 'mef2a', 'nfyb', 'sp1', 'srf', 'stat1', 'yy1']\n\n#----------------------------------------------------------------------------------------------------\n\n\n\nnum_trials = 10\nmodel_name = 'cnn-deep'\nactivations = ['relu', 'exp']\nsigmas = [0.001, 0.005, 0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.75, 1.0, 2.0, 3, 4, 5]\nresults_path = utils.make_directory('../../results', 'initialization_sweep')\nsave_path = utils.make_directory(results_path, 'conv_filters')\nsize = 32\n\n# save results to file\nwith open(os.path.join(results_path, 'filter_results.tsv'), 'w') as f:\n f.write('%s\\t%s\\t%s\\n'%('model', 'match JASPAR', 'match ground truth'))\n\n results = {}\n for activation in activations:\n results[activation] = {}\n for sigma in sigmas:\n trial_match_any = []\n trial_qvalue = []\n trial_match_fraction = []\n trial_coverage = []\n for trial in range(num_trials):\n\n file_path = os.path.join(save_path, model_name+'_'+activation+'_'+str(sigma)+'_'+str(trial), 'tomtom.tsv')\n best_qvalues, best_match, min_qvalue, match_fraction, match_any = helper.match_hits_to_ground_truth(file_path, motifs, size)\n\n # store results\n trial_qvalue.append(min_qvalue)\n trial_match_fraction.append(match_fraction)\n trial_coverage.append((len(np.where(min_qvalue != 1)[0])-1)/12) # percentage of motifs that are covered\n trial_match_any.append(match_any)\n\n f.write(\"%s\\t%.3f+/-%.3f\\t%.3f+/-%.3f\\n\"%(str(sigma)+'_'+activation, \n np.mean(trial_match_any), \n np.std(trial_match_any),\n np.mean(trial_match_fraction), \n np.std(trial_match_fraction) ) )\n results[activation][sigma] = {}\n results[activation][sigma]['match_fraction'] = np.array(trial_match_fraction)\n results[activation][sigma]['match_any'] = np.array(trial_match_any)\n \n# pickle results\nfile_path = os.path.join(results_path, \"intialization_sweep_filter_results.pickle\")\nwith open(file_path, 'wb') as f:\n cPickle.dump(results, f, protocol=cPickle.HIGHEST_PROTOCOL)\n\n\n\n\n\n",
"from tensorflow import keras\nfrom tfomics import layers, utils\n\n\ndef model(activation='relu'):\n\n # input layer\n inputs = keras.layers.Input(shape=(600,4))\n \n activation = utils.activation_fn(activation)\n \n # layer 1\n nn = layers.conv_layer(inputs,\n num_filters=300, \n kernel_size=19, # 192\n padding='same', \n activation=activation, \n dropout=0.2,\n l2=1e-6, \n bn=True)\n nn = keras.layers.MaxPool1D(pool_size=3)(nn)\n\n # layer 2\n nn = layers.conv_layer(nn,\n num_filters=200, \n kernel_size=11, # 56\n padding='valid', \n activation='relu', \n dropout=0.2,\n l2=1e-6, \n bn=True)\n nn = keras.layers.MaxPool1D(pool_size=4)(nn)\n\n # layer 3\n nn = layers.conv_layer(nn,\n num_filters=200, \n kernel_size=7, # 56\n padding='valid', \n activation='relu', \n dropout=0.2,\n l2=1e-6, \n bn=True)\n nn = keras.layers.MaxPool1D(pool_size=4)(nn)\n\n # layer 4\n nn = keras.layers.Flatten()(nn)\n nn = layers.dense_layer(nn, num_units=1000, activation='relu', dropout=0.5, l2=1e-6, bn=True)\n\n # layer 5\n nn = layers.dense_layer(nn, num_units=1000, activation='relu', dropout=0.5, l2=1e-6, bn=True)\n\n # Output layer \n logits = keras.layers.Dense(164, activation='linear', use_bias=True)(nn)\n outputs = keras.layers.Activation('sigmoid')(logits)\n \n model = keras.Model(inputs=inputs, outputs=outputs)\n\n return model\n\n",
"import numpy as np\nimport pandas as pd\nimport logomaker\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\ntf.compat.v1.disable_eager_execution()\nfrom tensorflow import keras\nfrom tensorflow.keras import backend as K\nimport tensorflow.compat.v1.keras.backend as K1\nimport shap\n\n\n\ndef saliency(model, X, class_index=0, layer=-2, batch_size=256):\n saliency = K1.gradients(model.layers[layer].output[:,class_index], model.input)[0]\n sess = K1.get_session()\n\n N = len(X)\n num_batches = int(np.floor(N/batch_size))\n\n attr_score = []\n for i in range(num_batches):\n attr_score.append(sess.run(saliency, {model.inputs[0]: X[i*batch_size:(i+1)*batch_size]}))\n if num_batches*batch_size < N:\n attr_score.append(sess.run(saliency, {model.inputs[0]: X[num_batches*batch_size:N]}))\n\n return np.concatenate(attr_score, axis=0)\n\n\ndef mutagenesis(model, X, class_index=0, layer=-2):\n\n def generate_mutagenesis(X):\n L,A = X.shape \n\n X_mut = []\n for l in range(L):\n for a in range(A):\n X_new = np.copy(X)\n X_new[l,:] = 0\n X_new[l,a] = 1\n X_mut.append(X_new)\n return np.array(X_mut)\n\n N, L, A = X.shape \n intermediate = keras.Model(inputs=model.inputs, outputs=model.layers[layer].output)\n\n attr_score = []\n for x in X:\n\n # get baseline wildtype score\n wt_score = intermediate.predict(np.expand_dims(x, axis=0))[:, class_index]\n\n # generate mutagenized sequences\n x_mut = generate_mutagenesis(x)\n \n # get predictions of mutagenized sequences\n predictions = intermediate.predict(x_mut)[:,class_index]\n\n # reshape mutagenesis predictiosn\n mut_score = np.zeros((L,A))\n k = 0\n for l in range(L):\n for a in range(A):\n mut_score[l,a] = predictions[k]\n k += 1\n \n attr_score.append(mut_score - wt_score)\n return np.array(attr_score)\n\n\ndef deepshap(model, X, class_index=0, layer=-2, num_background=10, reference='shuffle'):\n\n N, L, A = X.shape \n if reference is not 'shuffle':\n num_background = 1\n \n # set of background sequences to take expectation over\n shap_values = []\n for j, x in enumerate(X):\n if np.mod(j, 50) == 0:\n print(\"%d out of %d\"%(j,N))\n if reference == 'shuffle':\n background = []\n for i in range(num_background):\n shuffle = np.random.permutation(L)\n background.append(x[shuffle, :])\n background = np.array(background)\n else: \n background = np.zeros([1,L,A]) \n\n x = np.expand_dims(x, axis=0)\n # calculate SHAPLEY values \n background.shape\n e = shap.DeepExplainer(model, background)\n shap_values.append(e.shap_values(x)[0])\n\n attr_score = np.concatenate(shap_values, axis=0)\n return attr_score\n\n\n \n\ndef integrated_grad(model, X, class_index=0, layer=-2, num_background=10, num_steps=20, reference='shuffle'):\n\n def linear_path_sequences(x, num_background, num_steps, reference):\n def linear_interpolate(x, base, num_steps=20):\n x_interp = np.zeros(tuple([num_steps] +[i for i in x.shape]))\n for s in range(num_steps):\n x_interp[s] = base + (x - base)*(s*1.0/num_steps)\n return x_interp\n\n L, A = x.shape \n seq = []\n for i in range(num_background):\n if reference == 'shuffle':\n shuffle = np.random.permutation(L)\n background = x[shuffle, :]\n else: \n background = np.zeros(x.shape) \n seq.append(linear_interpolate(x, background, num_steps))\n return np.concatenate(seq, axis=0)\n\n # setup op to get gradients from class-specific outputs to inputs\n saliency = K1.gradients(model.layers[layer].output[:,class_index], model.input)[0]\n\n # start session\n sess = K1.get_session()\n\n attr_score = []\n for x in X:\n # generate num_background reference sequences that follow linear path towards x in num_steps\n seq = linear_path_sequences(x, num_background, num_steps, reference)\n \n # average/\"integrate\" the saliencies along path -- average across different references\n attr_score.append([np.mean(sess.run(saliency, {model.inputs[0]: seq}), axis=0)])\n attr_score = np.concatenate(attr_score, axis=0)\n\n return attr_score\n\n\n \ndef attribution_score(model, X, method='saliency', norm='times_input', class_index=0, layer=-2, **kwargs):\n\n N, L, A = X.shape \n if method == 'saliency':\n if 'batch_size' in kwargs:\n batch_size = kwargs['batch_size']\n else:\n batch_size=256\n \n attr_score = saliency(model, X, class_index, layer, batch_size)\n\n \n elif method == 'mutagenesis':\n \n attr_score = mutagenesis(model, X, class_index, layer)\n \n elif method == 'deepshap':\n if 'num_background' in kwargs:\n num_background = kwargs['num_background']\n else:\n num_background = 5\n if 'reference' in kwargs:\n reference = kwargs['reference']\n else:\n reference = 'shuffle'\n \n attr_score = deepshap(model, X, class_index, num_background, reference)\n\n \n elif method == 'integrated_grad':\n if 'num_background' in kwargs:\n num_background = kwargs['num_background']\n else:\n num_background = 10\n if 'num_steps' in kwargs:\n num_steps = kwargs['num_steps']\n else:\n num_steps = 20\n if 'reference' in kwargs:\n reference = kwargs['reference']\n else:\n reference = 'shuffle'\n \n attr_score = integrated_grad(model, X, class_index, layer, num_background, num_steps, reference)\n\n if norm == 'l2norm':\n attr_score = np.sqrt(np.sum(np.squeeze(attr_score)**2, axis=2, keepdims=True) + 1e-10)\n attr_score = X * np.matmul(attr_score, np.ones((1, X.shape[-1])))\n \n elif norm == 'times_input':\n attr_score *= X\n\n return attr_score\n\n\n#-------------------------------------------------------------------------------------------------\n# Plot conv filters\n#-------------------------------------------------------------------------------------------------\n\n\ndef plot_filers(model, x_test, layer=3, threshold=0.5, window=20, num_cols=8, figsize=(30,5)):\n\n intermediate = keras.Model(inputs=model.inputs, outputs=model.layers[layer].output)\n fmap = intermediate.predict(x_test)\n W = activation_pwm(fmap, x_test, threshold=threshold, window=window)\n\n num_filters = len(W)\n num_widths = int(np.ceil(num_filters/num_cols))\n\n fig = plt.figure(figsize=figsize)\n fig.subplots_adjust(hspace=0.1, wspace=0.1)\n\n logos = []\n for n, w in enumerate(W):\n ax = fig.add_subplot(num_widths, num_cols, n+1)\n \n # calculate sequence logo heights\n I = np.log2(4) + np.sum(w * np.log2(w+1e-10), axis=1, keepdims=True)\n logo = np.maximum(I*w, 1e-7)\n\n L, A = w.shape\n counts_df = pd.DataFrame(data=0.0, columns=list('ACGT'), index=list(range(L)))\n for a in range(A):\n for l in range(L):\n counts_df.iloc[l,a] = logo[l,a]\n\n logomaker.Logo(counts_df, ax=ax)\n ax = plt.gca()\n ax.set_ylim(0,2)\n ax.spines['right'].set_visible(False)\n ax.spines['top'].set_visible(False)\n ax.yaxis.set_ticks_position('none')\n ax.xaxis.set_ticks_position('none')\n plt.xticks([])\n plt.yticks([])\n \n logos.append(logo)\n \n return fig, W, logo\n\n\n\ndef activation_pwm(fmap, X, threshold=0.5, window=20):\n\n # extract sequences with aligned activation\n window_left = int(window/2)\n window_right = window - window_left\n\n N,L,A = X.shape\n num_filters = fmap.shape[-1]\n\n W = []\n for filter_index in range(num_filters):\n\n # find regions above threshold\n coords = np.where(fmap[:,:,filter_index] > np.max(fmap[:,:,filter_index])*threshold)\n\n if len(coords) > 1:\n x, y = coords\n\n # sort score\n index = np.argsort(fmap[x,y,filter_index])[::-1]\n data_index = x[index].astype(int)\n pos_index = y[index].astype(int)\n\n # make a sequence alignment centered about each activation (above threshold)\n seq_align = []\n for i in range(len(pos_index)):\n\n # determine position of window about each filter activation\n start_window = pos_index[i] - window_left\n end_window = pos_index[i] + window_right\n\n # check to make sure positions are valid\n if (start_window > 0) & (end_window < L):\n seq = X[data_index[i], start_window:end_window, :]\n seq_align.append(seq)\n\n # calculate position probability matrix\n if len(seq_align) > 1:#try:\n W.append(np.mean(seq_align, axis=0))\n else: \n W.append(np.ones((window,4))/4)\n else:\n W.append(np.ones((window,4))/4)\n\n return np.array(W)\n\n"
] | [
[
"numpy.std",
"numpy.array",
"numpy.mean",
"numpy.where"
],
[
"tensorflow.keras.layers.Activation",
"tensorflow.keras.layers.MaxPool1D",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.Model",
"tensorflow.keras.layers.Flatten",
"tensorflow.keras.layers.Input"
],
[
"numpy.expand_dims",
"numpy.squeeze",
"numpy.concatenate",
"numpy.max",
"numpy.mean",
"matplotlib.pyplot.gca",
"numpy.ceil",
"numpy.copy",
"numpy.zeros",
"matplotlib.pyplot.figure",
"tensorflow.compat.v1.keras.backend.get_session",
"tensorflow.keras.Model",
"numpy.floor",
"tensorflow.compat.v1.disable_eager_execution",
"numpy.argsort",
"numpy.array",
"matplotlib.pyplot.xticks",
"tensorflow.compat.v1.keras.backend.gradients",
"numpy.log2",
"numpy.maximum",
"numpy.ones",
"numpy.random.permutation",
"numpy.mod",
"matplotlib.pyplot.yticks"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"2.6",
"2.4",
"2.3",
"2.5",
"2.2"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
dark-ai/pypytorch | [
"d28e0f858ad7c33a14e4bb71dc68ae56ba97c5cf"
] | [
"examples/pypytorchscripts/cifar10/dataset/cifar10.py"
] | [
"# -*- coding: utf-8 -*-\n\nimport os\nimport pickle\nimport numpy as np\nfrom PIL import Image\nimport pypytorch as ppt\nfrom pypytorch.data import Dataset\nimport pypytorch.data.transform as transform\n\n\ndef load_data(filename):\n with open(filename, 'rb') as f:\n data = pickle.load(f, encoding='latin1')\n X = data['data']\n y = data['labels']\n # X = X.reshape(10000, 3, 32, 32).transpose(0, 2, 3, 1)\n return X, y\n\n\nclass Cifar10(Dataset):\n\n\n def __init__(self, root, filenames, train=True):\n super(Cifar10, self).__init__()\n X, y = None, None\n for fname in filenames:\n path = os.path.join(root, fname)\n if X is not None and y is not None:\n X_new, y_new = load_data(path)\n X = np.concatenate([X, X_new], axis=0)\n y = np.concatenate([y, y_new], axis=0)\n else:\n X, y = load_data(path)\n self.transforms = transform.Compose(\n transform.Resize(224),\n transform.ToTensor(),\n # transform.Norm()\n )\n self.imgs = X.reshape(len(X), 3, 32, 32).transpose(0, 2, 3, 1)\n self.labels = y\n \n def __getitem__(self, idx):\n img = self.transforms(self.imgs[idx])\n label = ppt.utils.ensure_one_hot(self.labels[idx], 10)\n return img, label\n\n def __len__(self):\n return len(self.imgs)\n\n\ndef main():\n root = '../../../data/cifar10/'\n cifar10 = Cifar10(root, \\\n ['data_batch_1', 'data_batch_2', 'data_batch_3', 'data_batch_4', 'data_batch_5'])\n x, y = cifar10[0]\n img = transform.ToPILImage()(x)\n img.show()\n\n\nif __name__ == \"__main__\":\n main()\n"
] | [
[
"numpy.concatenate"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mofumofuchan/attention_branch_network | [
"4634fe927bf7a9a6a4486d923a05933fd6bd5df4"
] | [
"models/cifar/wrn.py"
] | [
"import math\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n__all__ = ['wrn']\n\nclass BasicBlock(nn.Module):\n def __init__(self, in_planes, out_planes, stride, dropRate=0.0):\n super(BasicBlock, self).__init__()\n self.bn1 = nn.BatchNorm2d(in_planes)\n self.relu1 = nn.ReLU(inplace=True)\n self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,\n padding=1, bias=False)\n self.bn2 = nn.BatchNorm2d(out_planes)\n self.relu2 = nn.ReLU(inplace=True)\n self.conv2 = nn.Conv2d(out_planes, out_planes, kernel_size=3, stride=1,\n padding=1, bias=False)\n self.droprate = dropRate\n self.equalInOut = (in_planes == out_planes)\n self.convShortcut = (not self.equalInOut) and nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride,\n padding=0, bias=False) or None\n def forward(self, x):\n if not self.equalInOut:\n x = self.relu1(self.bn1(x))\n else:\n out = self.relu1(self.bn1(x))\n out = self.relu2(self.bn2(self.conv1(out if self.equalInOut else x)))\n if self.droprate > 0:\n out = F.dropout(out, p=self.droprate, training=self.training)\n out = self.conv2(out)\n return torch.add(x if self.equalInOut else self.convShortcut(x), out)\n\nclass NetworkBlock(nn.Module):\n def __init__(self, nb_layers, in_planes, out_planes, block, stride, dropRate=0.0):\n super(NetworkBlock, self).__init__()\n self.layer = self._make_layer(block, in_planes, out_planes, nb_layers, stride, dropRate)\n def _make_layer(self, block, in_planes, out_planes, nb_layers, stride, dropRate):\n layers = []\n for i in range(nb_layers):\n layers.append(block(i == 0 and in_planes or out_planes, out_planes, i == 0 and stride or 1, dropRate))\n return nn.Sequential(*layers)\n def forward(self, x):\n return self.layer(x)\n\nclass WideResNet(nn.Module):\n def __init__(self, depth, num_classes, widen_factor=1, dropRate=0.0):\n super(WideResNet, self).__init__()\n nChannels = [16, 16*widen_factor, 32*widen_factor, 64*widen_factor]\n assert (depth - 4) % 6 == 0, 'depth should be 6n+4'\n n = (depth - 4) // 6\n block = BasicBlock\n # 1st conv before any network block\n self.conv1 = nn.Conv2d(3, nChannels[0], kernel_size=3, stride=1,\n padding=1, bias=False)\n # 1st block\n self.block1 = NetworkBlock(n, nChannels[0], nChannels[1], block, 1, dropRate)\n # 2nd block\n self.block2 = NetworkBlock(n, nChannels[1], nChannels[2], block, 2, dropRate)\n # 3rd block\n self.block3 = NetworkBlock(n, nChannels[2], nChannels[3], block, 2, dropRate)\n # global average pooling and classifier\n self.bn1 = nn.BatchNorm2d(nChannels[3])\n self.relu = nn.ReLU(inplace=True)\n\n self.att_block3 = NetworkBlock(n, nChannels[2], nChannels[3], block, 1, dropRate)\n self.bn_att = nn.BatchNorm2d(nChannels[3])\n self.att_conv = nn.Conv2d(nChannels[3], num_classes, kernel_size=1, padding=0,\n bias=False)\n self.bn_att2 = nn.BatchNorm2d(num_classes)\n self.att_conv2 = nn.Conv2d(num_classes, num_classes, kernel_size=1, padding=0,\n bias=False)\n self.att_conv3 = nn.Conv2d(num_classes, 1, kernel_size=3, padding=1,\n bias=False)\n self.bn_att3 = nn.BatchNorm2d(1)\n self.att_gap = nn.AvgPool2d(16)\n self.sigmoid = nn.Sigmoid()\n\n self.fc = nn.Linear(nChannels[3], num_classes)\n self.nChannels = nChannels[3]\n\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 elif isinstance(m, nn.Linear):\n m.bias.data.zero_()\n\n def forward(self, x):\n out = self.conv1(x)\n out = self.block1(out)\n out = self.block2(out)\n\n ax = self.bn_att(self.att_block3(out))\n ax = self.relu(self.bn_att2(self.att_conv(ax)))\n bs, cs, ys, xs = ax.shape\n self.att = self.sigmoid(self.bn_att3(self.att_conv3(ax)))\n # self.att = self.att.view(bs, 1, ys, xs)\n ax = self.att_conv2(ax)\n ax = self.att_gap(ax)\n ax = ax.view(ax.size(0), -1)\n\n rx = out * self.att\n rx = rx + out\n rx = self.block3(rx)\n rx = self.relu(self.bn1(rx))\n rx = F.avg_pool2d(rx, 8)\n rx = rx.view(-1, self.nChannels)\n rx = self.fc(rx)\n\n return ax, rx, self.att\n\ndef wrn(**kwargs):\n \"\"\"\n Constructs a Wide Residual Networks.\n \"\"\"\n model = WideResNet(**kwargs)\n return model\n"
] | [
[
"torch.nn.Sequential",
"torch.nn.functional.dropout",
"torch.nn.functional.avg_pool2d",
"torch.nn.Conv2d",
"torch.nn.Sigmoid",
"torch.nn.Linear",
"torch.nn.AvgPool2d",
"torch.nn.BatchNorm2d",
"torch.nn.ReLU"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Juddd/ignite | [
"00a208a4e7a7783e9ddac18931085fca2f0dec47",
"00a208a4e7a7783e9ddac18931085fca2f0dec47"
] | [
"tests/ignite/engine/test_deterministic.py",
"tests/ignite/distributed/comp_models/test_xla.py"
] | [
"import os\nimport random\nimport sys\nfrom unittest.mock import patch\n\nimport numpy as np\nimport pytest\nimport torch\nimport torch.nn as nn\nfrom torch.optim import SGD\nfrom torch.utils.data import BatchSampler, DataLoader, RandomSampler\n\nimport ignite.distributed as idist\nfrom ignite.engine import Events\nfrom ignite.engine.deterministic import (\n DeterministicEngine,\n ReproducibleBatchSampler,\n keep_random_state,\n update_dataloader,\n)\nfrom ignite.utils import manual_seed\nfrom tests.ignite.engine import BatchChecker, setup_sampler\n\n\ndef test_dengine_setup_seed_div_by_zero():\n with pytest.raises(ValueError, match=r\"iter_counter should be positive value\"):\n DeterministicEngine(lambda e, b: None)._setup_seed(iter_counter=0)\n\n\ndef test_update_dataloader():\n def _test(sampler_type=None):\n num_epochs = 3\n total_batch_size = 4\n num_iters = 17\n data = torch.randint(0, 1000, size=(num_iters * total_batch_size,))\n num_workers = 2\n\n sampler, batch_size = setup_sampler(sampler_type, num_iters, total_batch_size)\n dataloader = DataLoader(\n data,\n batch_size=batch_size,\n num_workers=num_workers,\n pin_memory=False,\n sampler=sampler,\n drop_last=True,\n shuffle=sampler is None,\n )\n\n torch.manual_seed(12)\n seen_batches = []\n for i in range(num_epochs):\n t = []\n if sampler_type == \"distributed\":\n sampler.set_epoch(i)\n for b in dataloader:\n t.append(b)\n seen_batches.append(t)\n\n sampler, batch_size = setup_sampler(sampler_type, num_iters, total_batch_size)\n dataloader = DataLoader(\n data,\n batch_size=batch_size,\n num_workers=num_workers,\n pin_memory=False,\n sampler=sampler,\n drop_last=True,\n shuffle=sampler is None,\n )\n batch_sampler = dataloader.batch_sampler\n new_dataloader = update_dataloader(dataloader, ReproducibleBatchSampler(batch_sampler))\n\n torch.manual_seed(12)\n new_batches = []\n for i in range(num_epochs):\n t = []\n if sampler_type == \"distributed\":\n sampler.set_epoch(i)\n for b in new_dataloader:\n t.append(b)\n new_batches.append(t)\n\n for i in range(num_epochs):\n assert all([(b1 == b2).all() for b1, b2 in zip(seen_batches[i], new_batches[i])])\n\n _test()\n _test(\"weighted\")\n _test(\"distributed\")\n\n\ndef test_reproducible_batch_sampler_wrong_input():\n with pytest.raises(TypeError, match=r\"Argument batch_sampler should be torch.utils.data.sampler.BatchSampler\"):\n ReproducibleBatchSampler(\"abc\")\n\n\ndef test_reproducible_batch_sampler():\n\n data = list(range(100))\n dataloader = DataLoader(data, batch_size=12, num_workers=0, shuffle=True, drop_last=True)\n\n torch.manual_seed(12 + 0)\n dataloader_ = update_dataloader(dataloader, ReproducibleBatchSampler(dataloader.batch_sampler))\n\n seen_batches = []\n num_epochs = 3\n for i in range(num_epochs):\n t = []\n for b in dataloader_:\n t.append(b)\n seen_batches.append(t)\n torch.manual_seed(12 + i + 1)\n\n for i in range(num_epochs - 1):\n for j in range(i + 1, num_epochs):\n assert not all([(b1 == b2).all() for b1, b2 in zip(seen_batches[i], seen_batches[j])])\n\n for resume_epoch in range(num_epochs):\n torch.manual_seed(12 + resume_epoch)\n dataloader_ = update_dataloader(dataloader, ReproducibleBatchSampler(dataloader.batch_sampler))\n resumed_seen_batches = []\n for b in dataloader_:\n resumed_seen_batches.append(b)\n\n assert all([(b1 == b2).all() for b1, b2 in zip(seen_batches[resume_epoch], resumed_seen_batches)])\n\n\ndef _test_keep_random_state(with_numpy):\n\n manual_seed(54)\n true_values = []\n for _ in range(5):\n t = [\n torch.tensor([random.random()]),\n torch.rand(2),\n ]\n if with_numpy:\n t.append(torch.from_numpy(np.random.rand(2)))\n true_values.append(t)\n\n @keep_random_state\n def user_handler():\n manual_seed(22)\n _ = [\n random.random(),\n torch.rand(2),\n ]\n if with_numpy:\n _ = np.random.rand(2)\n\n manual_seed(54)\n res_values = []\n for _ in range(5):\n r = [\n torch.tensor([random.random()]),\n torch.rand(2),\n ]\n if with_numpy:\n r.append(torch.from_numpy(np.random.rand(2)))\n res_values.append(r)\n user_handler()\n\n for a, b in zip(true_values, res_values):\n for i, j in zip(a, b):\n assert (i == j).all()\n\n\ndef test_keep_random_state():\n _test_keep_random_state(with_numpy=True)\n\n\ndef test_keep_random_state_without_numpy():\n with patch.dict(\"sys.modules\", {\"numpy\": None}):\n _test_keep_random_state(with_numpy=False)\n\n\ndef test_strict_resume_from_iter():\n def _test(epoch_length=None):\n\n max_epochs = 5\n num_iters = 21\n torch.manual_seed(0)\n data = torch.randint(0, 1000, size=(num_iters,))\n if epoch_length is None:\n epoch_length = num_iters\n\n for resume_iteration in range(2, min(num_iters * max_epochs, epoch_length * max_epochs), 4):\n batch_checker = BatchChecker(data, init_counter=resume_iteration)\n\n def update_fn(_, batch):\n assert batch_checker.check(\n batch\n ), f\"{resume_iteration} | {batch_checker.counter}: {batch_checker.true_batch} vs {batch}\"\n\n engine = DeterministicEngine(update_fn)\n\n @engine.on(Events.EPOCH_COMPLETED)\n def check_iteration(_):\n assert engine.state.iteration == batch_checker.counter\n\n resume_state_dict = dict(\n iteration=resume_iteration, max_epochs=max_epochs, epoch_length=epoch_length, rng_states=None\n )\n engine.load_state_dict(resume_state_dict)\n engine.run(data)\n assert engine.state.epoch == max_epochs\n assert engine.state.iteration == epoch_length * max_epochs\n\n _test()\n _test(60)\n _test(15)\n\n\ndef test_strict_resume_from_epoch():\n def _test(epoch_length=None):\n max_epochs = 10\n num_iters = 21\n torch.manual_seed(0)\n data = torch.randint(0, 1000, size=(num_iters,))\n if epoch_length is None:\n epoch_length = num_iters\n\n for resume_epoch in range(1, max_epochs):\n batch_checker = BatchChecker(data, init_counter=resume_epoch * epoch_length)\n\n def update_fn(_, batch):\n assert batch_checker.check(\n batch\n ), f\"{resume_epoch} | {batch_checker.counter}: {batch_checker.true_batch} vs {batch}\"\n\n engine = DeterministicEngine(update_fn)\n\n resume_state_dict = dict(\n epoch=resume_epoch, max_epochs=max_epochs, epoch_length=epoch_length, rng_states=None\n )\n engine.load_state_dict(resume_state_dict)\n engine.run(data)\n assert engine.state.epoch == max_epochs\n assert engine.state.iteration == epoch_length * max_epochs\n\n _test()\n _test(60)\n _test(15)\n\n\ndef _test_resume_random_dataloader_from_epoch(device, _setup_sampler, sampler_type=None):\n def _test(epoch_length=None):\n\n max_epochs = 5\n total_batch_size = 4\n num_iters = 21\n torch.manual_seed(0)\n data = torch.randint(0, 1000, size=(num_iters * total_batch_size,))\n\n if epoch_length is None:\n epoch_length = num_iters\n\n for resume_epoch in range(1, max_epochs, 2):\n\n for num_workers in [0, 2]:\n sampler, batch_size = _setup_sampler(sampler_type, num_iters, total_batch_size)\n\n orig_dataloader = DataLoader(\n data,\n batch_size=batch_size,\n num_workers=num_workers,\n pin_memory=\"cuda\" in torch.device(device).type,\n sampler=sampler,\n drop_last=True,\n shuffle=sampler is None,\n )\n\n seen_batchs = []\n\n def update_fn(_, batch):\n batch_to_device = batch.to(device)\n seen_batchs.append(batch)\n\n engine = DeterministicEngine(update_fn)\n\n if sampler_type == \"distributed\":\n\n @engine.on(Events.EPOCH_STARTED)\n def _(engine):\n sampler.set_epoch(engine.state.epoch - 1)\n\n torch.manual_seed(87)\n engine.run(\n orig_dataloader, max_epochs=max_epochs, epoch_length=epoch_length,\n )\n\n batch_checker = BatchChecker(seen_batchs, init_counter=resume_epoch * epoch_length)\n\n sampler, batch_size = _setup_sampler(sampler_type, num_iters, total_batch_size)\n resume_dataloader = DataLoader(\n data,\n batch_size=batch_size,\n num_workers=num_workers,\n pin_memory=\"cuda\" in torch.device(device).type,\n sampler=sampler,\n drop_last=True,\n shuffle=sampler is None,\n )\n\n def update_fn(_, batch):\n batch_to_device = batch.to(device)\n assert batch_checker.check(\n batch\n ), f\"{num_workers} {resume_epoch} | {batch_checker.counter}: {batch_checker.true_batch} vs {batch}\"\n\n engine = DeterministicEngine(update_fn)\n\n if sampler_type == \"distributed\":\n\n @engine.on(Events.EPOCH_STARTED)\n def _(engine):\n sampler.set_epoch(engine.state.epoch - 1)\n\n resume_state_dict = dict(\n epoch=resume_epoch, max_epochs=max_epochs, epoch_length=epoch_length, rng_states=None\n )\n engine.load_state_dict(resume_state_dict)\n torch.manual_seed(87)\n engine.run(resume_dataloader)\n assert engine.state.epoch == max_epochs\n assert engine.state.iteration == epoch_length * max_epochs\n\n _test()\n if sampler_type != \"distributed\":\n _test(60)\n _test(15)\n\n\[email protected](\"win\" in sys.platform, reason=\"Skip extremely slow test on Windows/MacOSX\")\ndef test_resume_random_dataloader_from_epoch():\n _test_resume_random_dataloader_from_epoch(\"cpu\", setup_sampler)\n _test_resume_random_dataloader_from_epoch(\"cpu\", setup_sampler, sampler_type=\"weighted\")\n _test_resume_random_dataloader_from_epoch(\"cpu\", setup_sampler, sampler_type=\"distributed\")\n\n\nclass AugmentedData:\n def __init__(self, data, enabled=True):\n self.data = data\n self.enabled = enabled\n\n def __getitem__(self, i):\n dp = self.data[i]\n r = torch.randint_like(dp, -100, 100) if self.enabled else 0.0\n return dp + r * 0.01\n\n def __len__(self):\n return len(self.data)\n\n\ndef _test_resume_random_dataloader_from_iter(device, _setup_sampler, sampler_type=None):\n def _test(epoch_length=None):\n max_epochs = 3\n total_batch_size = 4\n num_iters = 17\n torch.manual_seed(0)\n data = torch.randint(0, 1000, size=(num_iters * total_batch_size,))\n\n if epoch_length is None:\n epoch_length = num_iters\n\n for resume_iteration in range(2, min(num_iters * max_epochs, epoch_length * max_epochs), 13):\n\n for num_workers in [0, 2]:\n\n sampler, batch_size = _setup_sampler(sampler_type, num_iters, total_batch_size)\n orig_dataloader = DataLoader(\n data,\n batch_size=batch_size,\n num_workers=num_workers,\n pin_memory=\"cuda\" in torch.device(device).type,\n sampler=sampler,\n drop_last=True,\n shuffle=sampler is None,\n )\n seen_batchs = []\n\n def update_fn(_, batch):\n batch_to_device = batch.to(device)\n seen_batchs.append(batch)\n\n engine = DeterministicEngine(update_fn)\n\n if sampler_type == \"distributed\":\n\n @engine.on(Events.EPOCH_STARTED)\n def _(engine):\n sampler.set_epoch(engine.state.epoch)\n\n torch.manual_seed(12)\n engine.run(\n orig_dataloader, max_epochs=max_epochs, epoch_length=epoch_length,\n )\n\n batch_checker = BatchChecker(seen_batchs, init_counter=resume_iteration)\n\n sampler, batch_size = _setup_sampler(sampler_type, num_iters, total_batch_size)\n resume_dataloader = DataLoader(\n data,\n batch_size=batch_size,\n num_workers=num_workers,\n pin_memory=\"cuda\" in torch.device(device).type,\n sampler=sampler,\n drop_last=True,\n shuffle=sampler is None,\n )\n\n def update_fn(_, batch):\n batch_to_device = batch.to(device)\n cfg_msg = f\"{num_workers} {resume_iteration}\"\n assert batch_checker.check(\n batch\n ), f\"{cfg_msg} | {batch_checker.counter}: {batch_checker.true_batch} vs {batch}\"\n\n engine = DeterministicEngine(update_fn)\n\n if sampler_type == \"distributed\":\n\n @engine.on(Events.EPOCH_STARTED)\n def _(engine):\n sampler.set_epoch(engine.state.epoch)\n\n resume_state_dict = dict(\n iteration=resume_iteration, max_epochs=max_epochs, epoch_length=epoch_length, rng_states=None\n )\n engine.load_state_dict(resume_state_dict)\n torch.manual_seed(12)\n engine.run(resume_dataloader)\n assert engine.state.epoch == max_epochs\n assert (\n engine.state.iteration == epoch_length * max_epochs\n ), f\"{num_workers}, {resume_iteration} | {engine.state.iteration} vs {epoch_length * max_epochs}\"\n\n _test()\n if sampler_type != \"distributed\":\n _test(40)\n _test(11)\n\n\[email protected](\"win\" in sys.platform, reason=\"Skip extremely slow test on Windows/MacOSX\")\ndef test_resume_random_dataloader_from_iter():\n _test_resume_random_dataloader_from_iter(\"cpu\", setup_sampler)\n _test_resume_random_dataloader_from_iter(\"cpu\", setup_sampler, sampler_type=\"weighted\")\n _test_resume_random_dataloader_from_iter(\"cpu\", setup_sampler, sampler_type=\"distributed\")\n\n\ndef _test_resume_random_data_iterator_from_epoch(device):\n def _test(epoch_length=None):\n max_epochs = 5\n batch_size = 4\n num_iters = 21\n\n def infinite_data_iterator():\n while True:\n for _ in range(num_iters):\n data = torch.randint(0, 1000, size=(batch_size,), device=device)\n yield data\n\n if epoch_length is None:\n epoch_length = num_iters\n\n for resume_epoch in range(1, max_epochs):\n seen_batchs = []\n\n def update_fn(_, batch):\n # if there is a random op when using data batch etc, we can not resume correctly\n # torch.rand(1)\n seen_batchs.append(batch)\n\n engine = DeterministicEngine(update_fn)\n torch.manual_seed(121)\n engine.run(\n infinite_data_iterator(), max_epochs=max_epochs, epoch_length=epoch_length,\n )\n\n batch_checker = BatchChecker(seen_batchs, init_counter=resume_epoch * epoch_length)\n\n def update_fn(_, batch):\n assert batch_checker.check(\n batch\n ), f\"{resume_epoch} | {batch_checker.counter}: {batch_checker.true_batch} vs {batch}\"\n\n engine = DeterministicEngine(update_fn)\n\n resume_state_dict = dict(\n epoch=resume_epoch, max_epochs=max_epochs, epoch_length=epoch_length, rng_states=None\n )\n engine.load_state_dict(resume_state_dict)\n torch.manual_seed(121)\n engine.run(infinite_data_iterator())\n assert engine.state.epoch == max_epochs\n assert engine.state.iteration == epoch_length * max_epochs\n\n _test()\n _test(60)\n _test(15)\n\n\ndef test_resume_random_data_iterator_from_epoch():\n _test_resume_random_data_iterator_from_epoch(\"cpu\")\n\n\ndef _test_resume_random_data_iterator_from_iter(device):\n def _test(epoch_length=None):\n max_epochs = 3\n batch_size = 4\n num_iters = 17\n\n def infinite_data_iterator():\n while True:\n for _ in range(num_iters):\n data = torch.randint(0, 1000, size=(batch_size,), device=device)\n yield data\n\n if epoch_length is None:\n epoch_length = num_iters\n\n for resume_iteration in range(1, min(num_iters * max_epochs, epoch_length * max_epochs), 7):\n\n seen_batchs = []\n\n def update_fn(_, batch):\n seen_batchs.append(batch)\n\n engine = DeterministicEngine(update_fn)\n\n torch.manual_seed(24)\n engine.run(\n infinite_data_iterator(), max_epochs=max_epochs, epoch_length=epoch_length,\n )\n\n batch_checker = BatchChecker(seen_batchs, init_counter=resume_iteration)\n\n def update_fn(_, batch):\n assert batch_checker.check(\n batch\n ), f\"{resume_iteration} | {batch_checker.counter}: {batch_checker.true_batch} vs {batch}\"\n\n engine = DeterministicEngine(update_fn)\n\n resume_state_dict = dict(\n iteration=resume_iteration, max_epochs=max_epochs, epoch_length=epoch_length, rng_states=None\n )\n engine.load_state_dict(resume_state_dict)\n torch.manual_seed(24)\n engine.run(infinite_data_iterator())\n assert engine.state.epoch == max_epochs\n assert (\n engine.state.iteration == epoch_length * max_epochs\n ), f\"{resume_iteration} | {engine.state.iteration} vs {epoch_length * max_epochs}\"\n\n _test()\n _test(50)\n _test(11)\n\n\ndef test_resume_random_data_iterator_from_iter():\n _test_resume_random_data_iterator_from_iter(\"cpu\")\n\n\[email protected]\[email protected](not idist.has_native_dist_support, reason=\"Skip if no native dist support\")\[email protected](torch.cuda.device_count() < 1, reason=\"Skip if no GPU\")\ndef test_distrib_nccl_gpu(distributed_context_single_node_nccl):\n\n device = idist.device()\n _test_resume_random_dataloader_from_iter(device, setup_sampler, sampler_type=\"distributed\")\n _test_resume_random_dataloader_from_epoch(device, setup_sampler, sampler_type=\"distributed\")\n\n\[email protected]\[email protected](not idist.has_native_dist_support, reason=\"Skip if no native dist support\")\ndef test_distrib_gloo_cpu_or_gpu(distributed_context_single_node_gloo):\n\n device = idist.device()\n _test_resume_random_dataloader_from_iter(device, setup_sampler, sampler_type=\"distributed\")\n _test_resume_random_dataloader_from_epoch(device, setup_sampler, sampler_type=\"distributed\")\n\n\[email protected]\[email protected]_distributed\[email protected](not idist.has_native_dist_support, reason=\"Skip if no native dist support\")\[email protected](\"MULTINODE_DISTRIB\" not in os.environ, reason=\"Skip if not multi-node distributed\")\ndef test_multinode_distrib_gloo_cpu_or_gpu(distributed_context_multi_node_gloo):\n\n device = idist.device()\n _test_resume_random_dataloader_from_iter(device, setup_sampler, sampler_type=\"distributed\")\n _test_resume_random_dataloader_from_epoch(device, setup_sampler, sampler_type=\"distributed\")\n\n\[email protected]_distributed\[email protected](not idist.has_native_dist_support, reason=\"Skip if no native dist support\")\[email protected](\"GPU_MULTINODE_DISTRIB\" not in os.environ, reason=\"Skip if not multi-node distributed\")\ndef test_multinode_distrib_nccl_gpu(distributed_context_multi_node_nccl):\n\n device = idist.device()\n _test_resume_random_dataloader_from_iter(device, setup_sampler, sampler_type=\"distributed\")\n _test_resume_random_dataloader_from_epoch(device, setup_sampler, sampler_type=\"distributed\")\n\n\ndef test_concepts_snippet_resume():\n\n # Commented imports required in the snippet\n # import torch\n # from torch.utils.data import DataLoader\n\n # from ignite.engine import DeterministicEngine\n # from ignite.utils import manual_seed\n\n seen_batches = []\n manual_seed(seed=15)\n\n def random_train_data_loader(size):\n data = torch.arange(0, size)\n return DataLoader(data, batch_size=4, shuffle=True)\n\n def print_train_data(engine, batch):\n i = engine.state.iteration\n e = engine.state.epoch\n print(\"train\", e, i, batch.tolist())\n seen_batches.append(batch)\n\n trainer = DeterministicEngine(print_train_data)\n\n print(\"Original Run\")\n manual_seed(56)\n trainer.run(random_train_data_loader(40), max_epochs=2, epoch_length=5)\n\n original_batches = list(seen_batches)\n seen_batches = []\n\n print(\"Resumed Run\")\n trainer.load_state_dict({\"epoch\": 1, \"epoch_length\": 5, \"max_epochs\": 2, \"rng_states\": None})\n manual_seed(56)\n trainer.run(random_train_data_loader(40))\n\n resumed_batches = list(seen_batches)\n seen_batches = []\n for b1, b2 in zip(original_batches[5:], resumed_batches):\n assert (b1 == b2).all()\n\n\ndef test_concepts_snippet_warning():\n def random_train_data_generator():\n while True:\n yield torch.randint(0, 100, size=(1,))\n\n def print_train_data(engine, batch):\n i = engine.state.iteration\n e = engine.state.epoch\n print(\"train\", e, i, batch.tolist())\n\n trainer = DeterministicEngine(print_train_data)\n\n @trainer.on(Events.ITERATION_COMPLETED(every=3))\n def user_handler(_):\n # handler synchronizes the random state\n torch.manual_seed(12)\n a = torch.rand(1)\n\n trainer.run(random_train_data_generator(), max_epochs=3, epoch_length=5)\n\n\ndef _test_gradients_on_resume(\n dirname, device, with_dropout=True, with_dataaugs=True, data_size=24, batch_size=4, save_iter=None, save_epoch=None\n):\n\n debug = False\n\n def random_train_data_loader(size):\n d = AugmentedData(torch.rand(size, 3, 32, 32), enabled=with_dataaugs)\n return DataLoader(d, batch_size=batch_size, shuffle=True, num_workers=2)\n\n def _train(save_iter=None, save_epoch=None, sd=None):\n w_norms = []\n grad_norms = []\n data = []\n chkpt = []\n\n manual_seed(12)\n arch = [\n nn.Conv2d(3, 10, 3),\n nn.ReLU(),\n nn.Conv2d(10, 10, 3),\n nn.ReLU(),\n nn.AdaptiveAvgPool2d(1),\n nn.Flatten(),\n nn.Linear(10, 5),\n nn.ReLU(),\n nn.Linear(5, 2),\n ]\n if with_dropout:\n arch.insert(2, nn.Dropout2d())\n arch.insert(-2, nn.Dropout())\n\n model = nn.Sequential(*arch).to(device)\n opt = SGD(model.parameters(), lr=0.001)\n\n def proc_fn(e, b):\n from ignite.engine.deterministic import _get_rng_states, _repr_rng_state\n\n s = _repr_rng_state(_get_rng_states())\n model.train()\n opt.zero_grad()\n y = model(b.to(device))\n y.sum().backward()\n opt.step()\n if debug:\n print(\n trainer.state.iteration, trainer.state.epoch, \"proc_fn - b.shape\", b.shape, torch.norm(y).item(), s\n )\n\n trainer = DeterministicEngine(proc_fn)\n\n if save_iter is not None:\n ev = Events.ITERATION_COMPLETED(once=save_iter)\n elif save_epoch is not None:\n ev = Events.EPOCH_COMPLETED(once=save_epoch)\n save_iter = save_epoch * (data_size // batch_size)\n\n @trainer.on(ev)\n def save_chkpt(_):\n if debug:\n print(trainer.state.iteration, \"save_chkpt\")\n fp = os.path.join(dirname, \"test.pt\")\n from ignite.engine.deterministic import _repr_rng_state\n\n tsd = trainer.state_dict()\n if debug:\n print(\"->\", _repr_rng_state(tsd[\"rng_states\"]))\n torch.save([model.state_dict(), opt.state_dict(), tsd], fp)\n chkpt.append(fp)\n\n def log_event_filter(_, event):\n if (event // save_iter == 1) and 1 <= (event % save_iter) <= 5:\n return True\n return False\n\n @trainer.on(Events.ITERATION_COMPLETED(event_filter=log_event_filter))\n def write_data_grads_weights(e):\n x = e.state.batch\n i = e.state.iteration\n data.append([i, x.mean().item(), x.std().item()])\n\n total = [0.0, 0.0]\n out1 = []\n out2 = []\n for p in model.parameters():\n n1 = torch.norm(p).item()\n n2 = torch.norm(p.grad).item()\n out1.append(n1)\n out2.append(n2)\n total[0] += n1\n total[1] += n2\n w_norms.append([i, total[0]] + out1)\n grad_norms.append([i, total[1]] + out2)\n\n if sd is not None:\n sd = torch.load(sd)\n model.load_state_dict(sd[0])\n opt.load_state_dict(sd[1])\n from ignite.engine.deterministic import _repr_rng_state\n\n if debug:\n print(\"-->\", _repr_rng_state(sd[2][\"rng_states\"]))\n trainer.load_state_dict(sd[2])\n\n manual_seed(32)\n trainer.run(random_train_data_loader(size=data_size), max_epochs=5)\n return {\"sd\": chkpt, \"data\": data, \"grads\": grad_norms, \"weights\": w_norms}\n\n out_original = _train(save_iter=save_iter, save_epoch=save_epoch)\n assert len(out_original[\"sd\"]) > 0\n\n out_resumed = _train(save_iter=save_iter, save_epoch=save_epoch, sd=out_original[\"sd\"][0])\n\n if debug:\n print(\"Original:\")\n print(\" data:\", out_original[\"data\"])\n print(\"grads:\", out_original[\"grads\"])\n print(\" W:\", out_original[\"weights\"])\n print(\"Resume:\")\n print(\" data:\", out_resumed[\"data\"])\n print(\"grads:\", out_resumed[\"grads\"])\n print(\" W:\", out_resumed[\"weights\"])\n\n # check data:\n for d1, d2 in zip(out_original[\"data\"], out_resumed[\"data\"]):\n assert d1 == d2\n\n # check grads:\n for d1, d2 in zip(out_original[\"grads\"], out_resumed[\"grads\"]):\n assert d1 == d2\n\n # check weights:\n for d1, d2 in zip(out_original[\"weights\"], out_resumed[\"weights\"]):\n assert d1 == d2\n\n\ndef test_gradients_on_resume_cpu(dirname):\n with pytest.raises(AssertionError):\n _test_gradients_on_resume(dirname, \"cpu\", with_dataaugs=True, save_iter=25)\n _test_gradients_on_resume(dirname, \"cpu\", with_dataaugs=False, save_iter=25)\n # resume from epoch\n _test_gradients_on_resume(dirname, \"cpu\", with_dataaugs=True, save_epoch=3)\n _test_gradients_on_resume(dirname, \"cpu\", with_dataaugs=False, save_epoch=3)\n\n\[email protected](not torch.cuda.is_available(), reason=\"Skip if no GPU\")\ndef test_gradients_on_resume_on_cuda(dirname):\n with pytest.raises(AssertionError):\n _test_gradients_on_resume(dirname, \"cuda\", with_dataaugs=True, save_iter=25)\n with pytest.raises(AssertionError):\n _test_gradients_on_resume(dirname, \"cuda\", with_dataaugs=False, save_iter=25)\n # resume from epoch\n _test_gradients_on_resume(dirname, \"cuda\", with_dataaugs=True, save_epoch=3)\n _test_gradients_on_resume(dirname, \"cuda\", with_dataaugs=False, save_epoch=3)\n\n\ndef test_engine_with_dataloader_no_auto_batching():\n # tests https://github.com/pytorch/ignite/issues/941\n\n data = torch.rand(64, 4, 10)\n data_loader = DataLoader(\n data, batch_size=None, sampler=BatchSampler(RandomSampler(data), batch_size=8, drop_last=True)\n )\n\n counter = [0]\n\n def foo(e, b):\n print(f\"{e.state.epoch}-{e.state.iteration}: {b}\")\n counter[0] += 1\n\n engine = DeterministicEngine(foo)\n engine.run(data_loader, epoch_length=10, max_epochs=5)\n\n assert counter[0] == 50\n\n\ndef test_run_finite_iterator_no_epoch_length():\n # FR: https://github.com/pytorch/ignite/issues/871\n unknown_size = 11\n\n def finite_unk_size_data_iter():\n for i in range(unknown_size):\n yield i\n\n bc = BatchChecker(data=list(range(unknown_size)))\n\n engine = DeterministicEngine(lambda e, b: bc.check(b))\n\n @engine.on(Events.DATALOADER_STOP_ITERATION)\n def restart_iter():\n engine.state.dataloader = finite_unk_size_data_iter()\n\n data_iter = finite_unk_size_data_iter()\n engine.run(data_iter, max_epochs=5)\n\n assert engine.state.epoch == 5\n assert engine.state.iteration == unknown_size * 5\n\n\nclass OldDataLoader(DataLoader):\n def __init__(self, dl, *args, **kwargs):\n self.dl = dl\n self.sampler = self.dl.sampler\n self.batch_sampler = self.dl.batch_sampler\n\n def __len__(self):\n return len(self.dl)\n\n def __iter__(self):\n return iter(self.dl)\n\n\ndef test_dataloader_no_dataset_kind():\n # tests issue : https://github.com/pytorch/ignite/issues/1022\n\n engine = DeterministicEngine(lambda e, b: None)\n\n data = torch.randint(0, 1000, size=(100 * 4,))\n dataloader = DataLoader(data, batch_size=4)\n dataloader = OldDataLoader(dataloader)\n\n engine.run(dataloader)\n",
"import os\n\nimport pytest\nimport torch\n\nfrom ignite.distributed.comp_models import has_xla_support\n\nif not has_xla_support:\n pytest.skip(\"Skip if no XLA support\", allow_module_level=True)\nelse:\n from ignite.distributed.comp_models.xla import _XlaDistModel\n\n\[email protected]\[email protected](not has_xla_support, reason=\"Skip if no PyTorch XLA package\")\ndef test__xla_model():\n available_backends = _XlaDistModel.available_backends\n assert \"xla-tpu\" in available_backends\n\n with pytest.raises(ValueError, match=r\"Backend should be one of\"):\n _XlaDistModel.create_from_backend(\"abc\")\n\n\ndef _test_xla_spawn_fn(local_rank, world_size, device):\n from ignite.distributed.utils import _model\n\n assert isinstance(_model, _XlaDistModel), f\"{type(_model)} vs _XlaDistModel\"\n\n assert _model.get_local_rank() == local_rank\n assert _model.get_world_size() == world_size\n d = _model.device()\n assert isinstance(d, torch.device) and d.type == device\n\n assert _model.get_rank() == local_rank\n assert _model.get_nproc_per_node() == world_size\n assert _model.get_node_rank() == 0\n assert _model.get_nnodes() == 1\n\n\[email protected]\[email protected](\"NUM_TPU_WORKERS\" in os.environ, reason=\"Skip if NUM_TPU_WORKERS is in env vars\")\[email protected](not has_xla_support, reason=\"Skip if no PyTorch XLA package\")\ndef test__xla_dist_model_spawn_one_proc():\n try:\n _XlaDistModel.spawn(\n _test_xla_spawn_fn, args=(1, \"xla\"), kwargs_dict={}, nproc_per_node=1,\n )\n except SystemExit:\n pass\n\n\[email protected]\[email protected](\"NUM_TPU_WORKERS\" not in os.environ, reason=\"Skip if no NUM_TPU_WORKERS in env vars\")\[email protected](not has_xla_support, reason=\"Skip if no PyTorch XLA package\")\ndef test__xla_dist_model_spawn_n_procs():\n n = int(os.environ[\"NUM_TPU_WORKERS\"])\n try:\n _XlaDistModel.spawn(\n _test_xla_spawn_fn, args=(n, \"xla\"), kwargs_dict={}, nproc_per_node=n,\n )\n except SystemExit:\n pass\n\n\ndef _assert_model(model, true_conf):\n\n assert model.device() == true_conf[\"device\"]\n assert model.get_local_rank() == true_conf[\"local_rank\"]\n assert model.get_rank() == true_conf[\"rank\"]\n assert model.get_world_size() == true_conf[\"world_size\"]\n\n assert model.get_node_rank() == true_conf[\"node_index\"]\n assert model.get_nnodes() == true_conf[\"nnodes\"]\n assert model.get_nproc_per_node() == true_conf[\"nproc_per_node\"]\n\n\[email protected]\[email protected](\"NUM_TPU_WORKERS\" in os.environ, reason=\"Skip if NUM_TPU_WORKERS is in env vars\")\[email protected](not has_xla_support, reason=\"Skip if no PyTorch XLA package\")\ndef test__xla_dist_model_create_from_backend():\n # without spawn\n model = _XlaDistModel.create_from_backend(\"xla-tpu\")\n\n import torch_xla.core.xla_model as xm\n\n _assert_model(\n model,\n {\n \"device\": xm.xla_device(),\n \"local_rank\": 0,\n \"rank\": 0,\n \"world_size\": 1,\n \"node_index\": 0,\n \"nnodes\": 1,\n \"nproc_per_node\": 1,\n },\n )\n\n model.finalize()\n\n\[email protected]\[email protected](\"NUM_TPU_WORKERS\" in os.environ, reason=\"Skip if NUM_TPU_WORKERS is in env vars\")\[email protected](not has_xla_support, reason=\"Skip if no PyTorch XLA package\")\ndef test__xla_dist_model_create_from_context():\n # without spawn\n model = _XlaDistModel.create_from_context()\n\n assert model.backend() == \"xla-tpu\"\n\n import torch_xla.core.xla_model as xm\n\n _assert_model(\n model,\n {\n \"device\": xm.xla_device(),\n \"local_rank\": 0,\n \"rank\": 0,\n \"world_size\": 1,\n \"node_index\": 0,\n \"nnodes\": 1,\n \"nproc_per_node\": 1,\n },\n )\n\n\ndef _test__xla_dist_model_create_from_context_in_child_proc(index):\n model = _XlaDistModel.create_from_context()\n\n assert model.backend() == \"xla-tpu\"\n\n import torch_xla.core.xla_model as xm\n\n _assert_model(\n model,\n {\n \"device\": xm.xla_device(),\n \"local_rank\": index,\n \"rank\": xm.get_ordinal(),\n \"world_size\": xm.xrt_world_size(),\n \"node_index\": 0,\n \"nnodes\": 1,\n \"nproc_per_node\": xm.xrt_world_size(),\n },\n )\n\n\[email protected]\[email protected](\"NUM_TPU_WORKERS\" not in os.environ, reason=\"Skip if no NUM_TPU_WORKERS in env vars\")\[email protected](not has_xla_support, reason=\"Skip if no PyTorch XLA package\")\ndef test__xla_dist_model_create_from_context_in_child_proc(xmp_executor):\n n = int(os.environ[\"NUM_TPU_WORKERS\"])\n xmp_executor(_test__xla_dist_model_create_from_context_in_child_proc, args=(), nprocs=n)\n\n\ndef main_fold(fold):\n import time\n\n import torch.nn as nn\n import torch.optim as optim\n import torch_xla.core.xla_model as xm\n\n from ignite.engine import Engine\n\n device = xm.xla_device(fold)\n\n comp_model = _XlaDistModel.create_from_context()\n assert comp_model.device() == device\n\n model = nn.Linear(100, 10)\n\n model.to(device) # Move model before creating optimizer\n optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n\n def training_step(engine, _):\n data = torch.rand(4, 100, device=device)\n model.train()\n data = data.to(device)\n optimizer.zero_grad()\n output = model(data)\n loss = output.sum()\n loss.backward()\n xm.optimizer_step(optimizer, barrier=True)\n return loss.item()\n\n trainer = Engine(training_step)\n\n # THIS CAN BE A CAUSE OF CRASH if DEVICE is OTHER THAN device\n tensor = torch.tensor([fold + 1.0], dtype=torch.float).to(comp_model.device())\n xm.all_reduce(\"max\", [tensor,])\n\n time.sleep(0.01 * fold)\n\n trainer.run([0] * 100, max_epochs=2)\n\n\[email protected]\[email protected](\"NUM_TPU_WORKERS\" in os.environ, reason=\"Skip if no NUM_TPU_WORKERS in env vars\")\[email protected](not has_xla_support, reason=\"Skip if no PyTorch XLA package\")\ndef test__xla_dist_model_run_parallel_n_threads_without_sync():\n # tests issue : https://github.com/pytorch/ignite/issues/1096\n import torch_xla.core.xla_model as xm\n from joblib import Parallel, delayed\n\n devices = xm.get_xla_supported_devices()\n folds = 1\n d = 0\n if len(devices) > 5:\n folds = 5\n d = 1\n Parallel(n_jobs=folds, backend=\"threading\")(delayed(main_fold)(i + d) for i in range(folds))\n"
] | [
[
"torch.randint",
"torch.nn.Dropout2d",
"torch.load",
"torch.utils.data.DataLoader",
"torch.cuda.is_available",
"torch.device",
"torch.nn.Dropout",
"torch.norm",
"torch.rand",
"torch.arange",
"torch.nn.Sequential",
"torch.nn.Conv2d",
"torch.randint_like",
"torch.nn.Linear",
"numpy.random.rand",
"torch.cuda.device_count",
"torch.manual_seed",
"torch.nn.Flatten",
"torch.utils.data.RandomSampler",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.ReLU"
],
[
"torch.nn.Linear",
"torch.rand",
"torch.tensor"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
CT83/Independent-Coursework | [
"5c7f93a7e05e64b13cb821f603efc54c92ad96c6"
] | [
"Machine-Learning-A-Z-Udemy-master/Machine Learning A-Z Template Folder/Part 3 - Classification/Section 14 - Logistic Regression/Logistic_Regression/Mlogistic_regression.py"
] | [
"# Logistic Regression\n\n# Importing the libraries\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\n# Importing the dataset\ndataset = pd.read_csv('Social_Network_Ads.csv')\nX = dataset.iloc[:,[2,3]].values\ny = dataset.iloc[:, 4].values\n\n# Splitting the dataset into the Training set and Test set\nfrom sklearn.cross_validation import train_test_split\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n\n# Feature Scaling\nfrom sklearn.preprocessing import StandardScaler\nsc_X = StandardScaler()\nX_train = sc_X.fit_transform(X_train)\nX_test = sc_X.transform(X_test)\n\n# Fitting Logistic Regression to Traingin Set\nfrom sklearn.linear_model import LogisticRegression\nclassifier = LogisticRegression(random_state = 0)\nclassifier.fit(X_train, y_train)\n\n# Predicting the Test Set reults\ny_pred = classifier.predict(X_test)\n\n\n# Making the Confusion Matrix\nfrom sklearn.metrics import confusion_matrix\ncm = confusion_matrix(y_test, y_pred)\n\n# Vi\n# Visualising the Training set results\nfrom matplotlib.colors import ListedColormap\nX_set, y_set = X_train, y_train\nX1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),\n np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\nplt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),\n alpha = 0.75, cmap = ListedColormap(('red', 'green')))\nplt.xlim(X1.min(), X1.max())\nplt.ylim(X2.min(), X2.max())\nfor i, j in enumerate(np.unique(y_set)):\n plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n c = ListedColormap(('red', 'green'))(i), label = j)\nplt.title('Logistic Regression (Training set)')\nplt.xlabel('Age')\nplt.ylabel('Estimated Salary')\nplt.legend()\nplt.show()\n\n# Visualising the Test set results\nfrom matplotlib.colors import ListedColormap\nX_set, y_set = X_test, y_test\nX1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),\n np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\nplt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),\n alpha = 0.75, cmap = ListedColormap(('red', 'green')))\nplt.xlim(X1.min(), X1.max())\nplt.ylim(X2.min(), X2.max())\nfor i, j in enumerate(np.unique(y_set)):\n plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n c = ListedColormap(('red', 'green'))(i), label = j)\nplt.title('Logistic Regression (Test set)')\nplt.xlabel('Age')\nplt.ylabel('Estimated Salary')\nplt.legend()\nplt.show()"
] | [
[
"matplotlib.pyplot.legend",
"sklearn.cross_validation.train_test_split",
"pandas.read_csv",
"sklearn.linear_model.LogisticRegression",
"matplotlib.pyplot.title",
"numpy.unique",
"sklearn.metrics.confusion_matrix",
"matplotlib.colors.ListedColormap",
"matplotlib.pyplot.xlabel",
"sklearn.preprocessing.StandardScaler",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
therealjtgill/mixture_density_network | [
"0851e56365762c5752ed21254a5d01e784568ff5"
] | [
"mdn_synthesis.py"
] | [
"import tensorflow as tf\r\nimport numpy as np\r\nimport os\r\nimport sys\r\nfrom window_cell import WindowCell\r\n\r\nnp.set_printoptions(threshold=sys.maxsize)\r\n\r\nclass AttentionMDN(object):\r\n '''\r\n Contains useful methods for training, testing, and validating a mixture\r\n density network.\r\n '''\r\n\r\n def __init__(self, session, input_size, num_att_gaussians=3, num_mix_gaussians=3, lstm_cell_size=300,\r\n alphabet_size=None, save=False, dropout=1.0, l2_penalty=0.0, num_lstms=1):\r\n '''\r\n Sets up the computation graph for the MDN.\r\n Bishop, et. al, use a mixture of univariate gaussians, which allows them\r\n to avoid futzing around with off-diagonal covariance matrix terms.\r\n Univariate gaussians have proven to be insufficient for prediction, so this\r\n model uses full covariance matrices for the mixture components.\r\n '''\r\n\r\n dtype = tf.float32\r\n self.session = session\r\n self.weights = []\r\n self.biases = []\r\n self.layers = []\r\n self.init_states = []\r\n self.dropout = dropout\r\n self.num_mix_gaussians = num_mix_gaussians\r\n self.num_att_gaussians = num_att_gaussians\r\n self.num_lstms = num_lstms\r\n self.input_size = input_size\r\n self.l2_penalty = l2_penalty\r\n self.alphabet_size = alphabet_size\r\n \r\n num_means = num_mix_gaussians*(input_size - 1)\r\n num_variances = num_mix_gaussians*(input_size - 1)\r\n num_correlations = num_mix_gaussians*(1)\r\n output_size = num_mix_gaussians + num_means + num_variances \\\r\n + num_correlations + 1\r\n\r\n print(\"output size:\", output_size)\r\n print(\"output size per gaussian:\", (output_size - 1)/num_mix_gaussians)\r\n\r\n with tf.variable_scope(\"mdn\"):\r\n\r\n # [batch_size, seq_length, input_size]\r\n self.input_data = tf.placeholder(dtype=dtype,\r\n shape=[None, None, input_size], name=\"batch_input\")\r\n # [batch_size, num_chars, alphabet_size]\r\n self.input_ascii = tf.placeholder(dtype=dtype,\r\n shape=[None, None, alphabet_size], name=\"ascii_input\")\r\n # [batch_size, seq_length, input_size] \r\n self.output_data = tf.placeholder(dtype=dtype,\r\n shape=[None, None, input_size], name=\"batch_targets\")\r\n # []\r\n self.input_mixture_bias = tf.placeholder(dtype=dtype,\r\n shape=[], name=\"bias\")\r\n\r\n # Initial states for recurrent parts of the network\r\n self.zero_states = []\r\n self.init_states = []\r\n ph_c = tf.placeholder(dtype=dtype, shape=[None, lstm_cell_size])\r\n ph_h = tf.placeholder(dtype=dtype, shape=[None, lstm_cell_size])\r\n self.init_states.append(tf.nn.rnn_cell.LSTMStateTuple(ph_c, ph_h))\r\n\r\n ph_v = tf.placeholder(dtype=dtype, shape=[None, num_att_gaussians])\r\n self.init_states.append(ph_v)\r\n\r\n #ph_c = tf.placeholder(dtype=dtype, shape=[None, lstm_cell_size])\r\n #ph_h = tf.placeholder(dtype=dtype, shape=[None, lstm_cell_size])\r\n #self.init_states.append(tf.nn.rnn_cell.LSTMStateTuple(ph_c, ph_h))\r\n\r\n #ph_c = tf.placeholder(dtype=dtype, shape=[None, lstm_cell_size])\r\n #ph_h = tf.placeholder(dtype=dtype, shape=[None, lstm_cell_size])\r\n #self.init_states.append(tf.nn.rnn_cell.LSTMStateTuple(ph_c, ph_h))\r\n\r\n for i in range(self.num_lstms):\r\n ph_c = tf.placeholder(dtype=dtype, shape=[None, lstm_cell_size])\r\n ph_h = tf.placeholder(dtype=dtype, shape=[None, lstm_cell_size])\r\n self.init_states.append(tf.nn.rnn_cell.LSTMStateTuple(ph_c, ph_h))\r\n\r\n self.init_states = tuple(self.init_states)\r\n # End initial states\r\n\r\n batch_size = tf.cast(tf.shape(self.input_data)[0], tf.int32)\r\n seq_length = tf.cast(tf.shape(self.input_data)[1], tf.int32)\r\n num_chars = tf.cast(tf.shape(self.input_ascii)[1], tf.int32)\r\n\r\n # The attention mechanism from the paper requires an LSTM above it. Only\r\n # one of the parameters of the attention mechanism is recurrent, which\r\n # means that we need to split the output of the LSTM between recurrent\r\n # and non-recurrent output.\r\n\r\n # Attention mechanism\r\n self.recurrent_states = []\r\n lstm_1 = tf.nn.rnn_cell.BasicLSTMCell(lstm_cell_size, name=\"mdn_lstm_a\")\r\n lstm_1_dropout = tf.nn.rnn_cell.DropoutWrapper(lstm_1, output_keep_prob=self.dropout)\r\n window = WindowCell(lstm_cell_size, num_chars, self.num_att_gaussians)\r\n self.zero_states.append(lstm_1.zero_state(batch_size, dtype=dtype))\r\n self.zero_states.append(window.zero_state(batch_size, dtype=dtype))\r\n # Get back num_att_gaussians tensors of shape [bs, sl, 3], which is a\r\n # tensor of attention window parameters for each attention gaussian.\r\n # size(attention_params) = [num_att_gaussians, bs, sl, 3]\r\n # (technically a list of size 'num_att_gaussians' with [bs, sl, 3] size \r\n # tensors at each element of the list)\r\n\r\n if self.dropout == 1.0:\r\n lstm_1_out, lstm_1_state = tf.nn.dynamic_rnn(lstm_1, self.input_data, dtype=dtype,\r\n initial_state=self.init_states[0])\r\n else:\r\n lstm_1_out, lstm_1_state = tf.nn.dynamic_rnn(lstm_1_dropout, self.input_data, dtype=dtype,\r\n initial_state=self.init_states[0])\r\n self.layers.append(lstm_1_out)\r\n self.recurrent_states.append(lstm_1_state)\r\n\r\n #self.phi, attention_state = tf.nn.dynamic_rnn(window, lstm_1_out, dtype=dtype,\r\n # initial_state=self.init_states[1])\r\n #self.layers.append(self.phi)\r\n self.phi_plus, attention_state = tf.nn.dynamic_rnn(window, lstm_1_out, dtype=dtype,\r\n initial_state=self.init_states[1])\r\n self.phi, self.stop_check = tf.split(self.phi_plus, [num_chars, 1], axis=-1)\r\n self.layers.append(self.phi)\r\n self.recurrent_states.append(attention_state)\r\n # Need to evaluate each gaussian at an index value corresponding to a\r\n # character position in the ASCII input (axis=1).\r\n # Tile the parameters on the last axis by the number of characters in\r\n # the ascii sequence to ensure proper broadcasting. Need to get a\r\n # tensor with the following shape for phi\r\n # [bs, sl, nc] (nc = num_chars)\r\n # and a tensor with the following shape for the soft window weight.\r\n # [bs, sl, as] (as = alphabet_size)\r\n\r\n # shape(self.phi) = [bs, sl, nc]\r\n # shape(ascii_input) = [bs, nc, as]\r\n # shape(self.alphabet_weights) = [bs, sl, as]\r\n self.alphabet_weights = tf.matmul(self.phi, self.input_ascii)\r\n self.layers.append(self.alphabet_weights)\r\n # End attention mechanism\r\n\r\n # Final recurrent layer\r\n #lstm_2 = tf.nn.rnn_cell.BasicLSTMCell(lstm_cell_size, name=\"mdn_lstm_b\")\r\n #lstm_2_dropout = tf.nn.rnn_cell.DropoutWrapper(lstm_2, output_keep_prob=self.dropout)\r\n #lstm_3 = tf.nn.rnn_cell.BasicLSTMCell(lstm_cell_size, name=\"mdn_lstm_c\")\r\n #lstm_3_dropout = tf.nn.rnn_cell.DropoutWrapper(lstm_3, output_keep_prob=self.dropout)\r\n output_lstms = []\r\n output_lstms_dropout = []\r\n for i in range(self.num_lstms):\r\n output_lstms.append(tf.nn.rnn_cell.BasicLSTMCell(lstm_cell_size, name=\"mdn_lstm_\" + chr(ord(\"b\") + i)))\r\n output_lstms_dropout.append(tf.nn.rnn_cell.DropoutWrapper(output_lstms[-1], output_keep_prob=self.dropout))\r\n self.zero_states.append(output_lstms[-1].zero_state(batch_size, dtype=dtype))\r\n\r\n #lstm_2_input = tf.concat([self.alphabet_weights, self.input_data, lstm_1_out], axis=-1)\r\n output_lstms_input = tf.concat([self.alphabet_weights, self.input_data, lstm_1_out], axis=-1)\r\n if self.dropout == 1.0:\r\n #last_lstm_cells = tf.nn.rnn_cell.MultiRNNCell([lstm_2,])\r\n #last_lstm_cells = tf.nn.rnn_cell.MultiRNNCell([lstm_2, lstm_3])\r\n last_lstm_cells = tf.nn.rnn_cell.MultiRNNCell(output_lstms)\r\n else:\r\n #last_lstm_cells = tf.nn.rnn_cell.MultiRNNCell([lstm_2_dropout,])\r\n #last_lstm_cells = tf.nn.rnn_cell.MultiRNNCell([lstm_2_dropout, lstm_3_dropout])\r\n last_lstm_cells = tf.nn.rnn_cell.MultiRNNCell(output_lstms_dropout)\r\n #outputs, outputs_state = \\\r\n # tf.nn.dynamic_rnn(last_lstm_cells, lstm_2_input, dtype=dtype,\r\n # initial_state=self.init_states[2:3])\r\n #outputs, outputs_state = \\\r\n # tf.nn.dynamic_rnn(last_lstm_cells, lstm_2_input, dtype=dtype,\r\n # initial_state=self.init_states[2:])\r\n outputs, outputs_state = \\\r\n tf.nn.dynamic_rnn(last_lstm_cells, output_lstms_input, dtype=dtype,\r\n initial_state=self.init_states[2:])\r\n outputs_flat = tf.reshape(outputs, [-1, lstm_cell_size], name=\"dynamic_rnn_reshape\")\r\n self.recurrent_states += outputs_state\r\n print(\"len outputs state:\", len(outputs_state))\r\n print(\"len outputs state[0]:\", len(outputs_state[0]))\r\n print(\"len recurrent states:\", len(self.recurrent_states))\r\n self.layers.append(outputs_flat)\r\n #self.zero_states.append(lstm_2.zero_state(batch_size, dtype=dtype))\r\n #self.zero_states.append(lstm_3.zero_state(batch_size, dtype=dtype))\r\n # End final recurrent layer\r\n\r\n # Output layer\r\n shape = [lstm_cell_size, output_size]\r\n self.layers.append(self._linear_op(self.layers[-1], shape, \"output_mixture_layer\"))\r\n\r\n # Get the mixture components\r\n splits = [num_means, num_variances, num_correlations, num_mix_gaussians, 1]\r\n pieces = tf.split(self.layers[-1], splits, axis=1)\r\n self.mixture_bias = tf.nn.relu(self.input_mixture_bias)\r\n self.means = pieces[0]\r\n self.stdevs = tf.exp(pieces[1] - self.mixture_bias)\r\n self.correls = tf.nn.tanh(pieces[2])\r\n self.mix_weights = tf.nn.softmax(pieces[3]*(1 + self.mixture_bias))\r\n self.stroke = tf.nn.sigmoid(pieces[4])\r\n\r\n # Reshape the means, stdevs, correlations, and mixture weights for\r\n # friendly returns\r\n means_shape = [batch_size, seq_length, num_mix_gaussians, 2]\r\n stdevs_shape = [batch_size, seq_length, num_mix_gaussians, 2]\r\n mixes_shape = [batch_size, seq_length, num_mix_gaussians, 1]\r\n correls_shape = [batch_size, seq_length, num_mix_gaussians, 2]\r\n self.means_ = tf.reshape(self.means, means_shape)\r\n self.stdevs_ = tf.reshape(self.stdevs, stdevs_shape)\r\n self.mix_weights_ = tf.reshape(self.mix_weights, mixes_shape)\r\n self.correls_ = tf.reshape(self.correls, correls_shape)\r\n\r\n outputs_flat = tf.reshape(self.output_data, [-1, input_size])\r\n\r\n gauss_values, stroke = tf.split(outputs_flat, [input_size-1, 1], axis=1)\r\n\r\n # Grab Gaussian parameters for sampling from the network.\r\n self.gauss_params = \\\r\n self._get_gaussian_params(self.means, self.stdevs, self.correls,\r\n num_mix_gaussians)\r\n\r\n # These are for training or evaluating the network.\r\n self.gauss_evals = self._eval_gaussians(gauss_values, self.means,\r\n self.stdevs, self.correls,\r\n num_mix_gaussians)\r\n\r\n print(self.gauss_evals.shape, self.mix_weights.shape)\r\n print(pieces[3].shape)\r\n\r\n self.mixture = tf.reduce_sum(self.gauss_evals*self.mix_weights, axis=-1)\r\n stroke_loss = \\\r\n tf.nn.sigmoid_cross_entropy_with_logits(labels=stroke, logits=pieces[4])\r\n print(\"unreduced stroke loss shape:\", stroke_loss.shape)\r\n #a = self.gauss_evals*self.mix_weights\r\n #print(\"unreduced mixture shape:\", a.shape)\r\n self.stroke_loss = tf.reduce_sum(stroke_loss, axis=-1)\r\n print(self.stroke_loss.shape)\r\n\r\n #self.loss = tf.reduce_mean(-1*tf.log(tf.maximum(self.mixture, 1e-8)) + self.stroke_loss, name=\"loss\")\r\n self.loss = tf.reduce_mean(-1*tf.log(self.mixture + 1e-8) + self.stroke_loss, name=\"loss\")\r\n self.loss += self.l2_penalty*tf.reduce_sum([tf.nn.l2_loss(v) for v in tf.trainable_variables()])\r\n optimizer = tf.train.RMSPropOptimizer(learning_rate=0.0001, momentum=0.9)\r\n self.train_op = optimizer.minimize(self.loss)\r\n #gradients = optimizer.compute_gradients(self.loss)\r\n #print(\"lstm vars:\", [var.name for grad, var in gradients if \"mdn_lstm_\" in var.name])\r\n #print(\"output mixture vars:\", [var.name for grad, var in gradients if \"output_mixture_layer\" in var.name])\r\n #capped_norm_grads = [(tf.clip_by_norm(grad, 10), var) for grad, var in gradients]\r\n #self.train_op = optimizer.apply_gradients(capped_norm_grads)\r\n\r\n if save:\r\n self.saver = tf.train.Saver(max_to_keep=20)\r\n\r\n\r\n def _get_weights(self, shape, name=\"requested_weight\"):\r\n '''\r\n Returns a location of a Rank(2) tensor of weights and a Rank(1) tensor of\r\n biases within the self.weights and self.biases lists.\r\n '''\r\n\r\n weights = tf.Variable(tf.random_normal(shape, stddev=0.1), name=name)\r\n biases = tf.Variable(tf.random_normal([shape[-1]], stddev=0.1), name=name)\r\n\r\n self.weights.append(weights)\r\n self.biases.append(biases)\r\n\r\n return (len(self.weights) - 1, len(self.biases) - 1)\r\n\r\n\r\n def _linear_op(self, input_tensor, shape, name=\"linear_op_weights\"):\r\n '''\r\n Perform simple matmul and bias offset between the input_tensor and a tensor\r\n of weights that will be generated in this method.\r\n So you specify an input tensor and the shape of the weight matrix, and this\r\n method does the following:\r\n\r\n create weight: W with shape = \"shape\"\r\n create bias: b with shape = \"shape[1]\"\r\n\r\n matmul(input_tensor, W) + b\r\n '''\r\n\r\n (W_loc, b_loc) = self._get_weights(shape, name)\r\n\r\n return tf.matmul(input_tensor, self.weights[W_loc]) + self.biases[b_loc]\r\n\r\n\r\n def _get_gaussian_params(self, means, stdevs, correls, num_mix_gaussians):\r\n '''\r\n Returns the parameters of the densities in the GMM.\r\n '''\r\n\r\n with tf.variable_scope(\"gmm_breakdown\"):\r\n comp_means = tf.split(means, num_mix_gaussians, axis=1)\r\n comp_stdevs = tf.split(stdevs, num_mix_gaussians, axis=1)\r\n comp_correls = tf.split(correls, num_mix_gaussians, axis=1)\r\n\r\n return (comp_means, comp_stdevs, comp_correls)\r\n\r\n\r\n def _eval_gaussians(self, values, means, stdevs, correls, num_mix_gaussians):\r\n '''\r\n Takes tensors of values, means, and stdevs, and returns tensors of\r\n gaussians parametrized by 'means', 'stdevs', and 'correls' evaluated at\r\n 'values'. Here we assume that 'values' only contains components relevant\r\n to the GMM on the output.\r\n\r\n values -> [bs*sl, M]\r\n stdevs -> [bs*sl, num_mix_gaussians*M]\r\n means -> [bs*sl, num_mix_gaussians*M]\r\n correls -> [bs*sl, num_mix_gaussians]\r\n '''\r\n\r\n print(\"gaussian component shapes:\")\r\n print(\"\\tvalues:\", values.shape)\r\n print(\"\\tstdevs:\", stdevs.shape)\r\n print(\"\\tmeans:\", means.shape)\r\n print(\"\\tcorrels:\", correls.shape)\r\n\r\n with tf.variable_scope(\"gmm_evaluation\"):\r\n comp_means = tf.split(means, num_mix_gaussians, axis=1)\r\n comp_stdevs = tf.split(stdevs, num_mix_gaussians, axis=1)\r\n comp_correls = tf.split(correls, num_mix_gaussians, axis=1)\r\n \r\n gaussians = []\r\n for i in range(num_mix_gaussians):\r\n correls_denom = tf.reduce_sum(1 - comp_correls[i]*comp_correls[i], axis=1)\r\n factor = 1./(2*np.pi*tf.reduce_prod(comp_stdevs[i], axis=1)*tf.sqrt(correls_denom + 1e-8))\r\n print(\"\\tfactor\", i, \":\", factor.shape)\r\n #print(self.session.run([tf.shape(comp_means[i]), tf.shape(comp_stdevs[i])]))\r\n norms = (values - comp_means[i])/(comp_stdevs[i] + 1e-8)\r\n exponents = -(1/(2*correls_denom + 1e-8))*(tf.reduce_sum(norms*norms, axis=1) - tf.reduce_prod(norms, axis=1)*2*tf.reduce_sum(comp_correls[i], axis=1))\r\n print(\"\\texponents\", i, \":\", exponents.shape)\r\n #ind_gaussians.append(factors*tf.exp(exponents))\r\n gaussians.append(factor*tf.exp(exponents))\r\n\r\n # You have a gaussian for each set of components of the mixture model,\r\n # now you just have to reduce those components into the pieces of the GMM.\r\n stacked_gaussians = tf.stack(gaussians, axis=1)\r\n print(\"stacked gaussians shape:\", stacked_gaussians.shape)\r\n\r\n return stacked_gaussians\r\n\r\n\r\n def _get_mixture_sample(self, params, mix):\r\n '''\r\n Returns a single sample from the GMM defined by params and the mixture\r\n weights.\r\n Assumes that 'params' is a list of GMM parameters.\r\n Assumes that 'mix' is a simple numpy array, where the mixture's shape is\r\n one-dimensional, and its size is the number of gaussians in the mixture.\r\n '''\r\n\r\n # params[0] --> means\r\n # params[1] --> variance terms\r\n # params[2] --> correlation terms\r\n # Variance terms aren't in matrix form, but we know what a 2D gaussian\r\n # with correlated variables looks like, so we use this form to construct\r\n # a 2D gaussian by filling in the covariance matrix and means.\r\n\r\n sample = np.zeros_like(params[0][0])\r\n for i in range(self.num_mix_gaussians):\r\n mean = params[0][i]\r\n #print(\" mixture_sample mean shape:\", mean.shape)\r\n cov = np.zeros((self.input_size - 1, self.input_size - 1))\r\n for j in range(self.input_size - 1):\r\n #print(\" mixture_sample cov shape:\", params[1][i].shape)\r\n cov[j,j] = params[1][i][j]\r\n #cov[j,1-j] = params[2][i][0]\r\n cov[j,1-j] = params[2][i] # Zero probably removed by squeeze operation\r\n #print(\"covariance: \", cov)\r\n sample += mix[i]*np.random.multivariate_normal(mean, cov)\r\n return sample[np.newaxis, np.newaxis, :]\r\n\r\n\r\n def train_batch(self, batch_in, batch_one_hots, batch_out):\r\n '''\r\n Trains the MDN on a single batch of input.\r\n Returns the loss, parameters of each gaussian, and the weights associated\r\n with each density in the Gaussian Mixture.\r\n '''\r\n\r\n (batch_size, sequence_length, input_size) = batch_in.shape\r\n #zero_states_ = self.multi_lstm_cell.zero_state(batch_size, dtype=dtype)\r\n #zero_states = self.session.run(zero_states_)\r\n\r\n feeds = {\r\n self.input_data: batch_in,\r\n self.output_data: batch_out,\r\n self.input_ascii: batch_one_hots,\r\n self.input_mixture_bias: 0\r\n }\r\n\r\n zero_states = self.session.run(self.zero_states, feed_dict=feeds)\r\n\r\n feeds[self.init_states[0][0]] = zero_states[0][0]\r\n feeds[self.init_states[0][1]] = zero_states[0][1]\r\n feeds[self.init_states[1]] = zero_states[1]\r\n #feeds[self.init_states[2][0]] = zero_states[2][0]\r\n #feeds[self.init_states[2][1]] = zero_states[2][1]\r\n #feeds[self.init_states[3][0]] = zero_states[3][0]\r\n #feeds[self.init_states[3][1]] = zero_states[3][1]\r\n for i in range(self.num_lstms):\r\n feeds[self.init_states[i+2][0]] = zero_states[i+2][0]\r\n feeds[self.init_states[i+2][1]] = zero_states[i+2][1]\r\n\r\n fetches = [\r\n self.train_op,\r\n self.loss,\r\n self.gauss_evals,\r\n self.mixture,\r\n self.means_,\r\n self.stdevs_,\r\n self.mix_weights_,\r\n self.stroke,\r\n self.gauss_params,\r\n self.alphabet_weights,\r\n self.phi\r\n ]\r\n\r\n _, loss, gauss_eval, mix_eval, means_, stdevs_, mix, stroke, params, aw, phi = self.session.run(fetches, feed_dict=feeds)\r\n #print(\"shape of means:\", means_.shape)\r\n #print(\"shape of stdevs:\", stdevs_.shape)\r\n #print(\"attention_params for first batch:\", atp[0, :, :])\r\n #print(\"atp shape:\", atp.shape)\r\n correls = params[2]\r\n max_correl = 0\r\n for i in range(self.num_mix_gaussians):\r\n max_correl = max(max_correl, np.amax(np.sum((correls[i]*correls[i]), axis=1)))\r\n #print(\"max_correl denom:\", max_correl)\r\n if max_correl > 1:\r\n print(\"OUT OF BOUNDS VALUE FOR MAX_CORREL\")\r\n sys.exit(-1)\r\n if np.isnan(loss):\r\n print(\"LOSS IS NAN. ABORTING.\")\r\n with open(\"failmode.dat\", \"w\") as f:\r\n for i, item in enumerate((loss, means_, stdevs_, mix, gauss_eval, mix_eval, stroke, aw, phi)):\r\n f.write(str(item))\r\n sys.exit(-1)\r\n return (loss, means_, stdevs_, mix, gauss_eval, mix_eval, stroke, aw, phi)\r\n\r\n\r\n def validate_batch(self, batch_in, batch_one_hots, batch_out):\r\n '''\r\n Runs the network on the given input batch and calculates a loss using the\r\n output batch. No training is performed.\r\n '''\r\n\r\n (batch_size, sequence_length, input_size) = batch_in.shape\r\n #zero_states_ = self.multi_lstm_cell.zero_state(batch_size, dtype=dtype)\r\n #zero_states = self.session.run(zero_states_)\r\n #zero_states = self.session.run(self.zero_states)\r\n\r\n feeds = {\r\n self.input_data: batch_in,\r\n self.output_data: batch_out,\r\n self.input_ascii: batch_one_hots,\r\n self.input_mixture_bias: 0\r\n }\r\n\r\n zero_states = self.session.run(self.zero_states, feed_dict=feeds)\r\n\r\n feeds[self.init_states[0][0]] = zero_states[0][0]\r\n feeds[self.init_states[0][1]] = zero_states[0][1]\r\n feeds[self.init_states[1]] = zero_states[1]\r\n #feeds[self.init_states[2][0]] = zero_states[2][0]\r\n #feeds[self.init_states[2][1]] = zero_states[2][1]\r\n #feeds[self.init_states[3][0]] = zero_states[3][0]\r\n #feeds[self.init_states[3][1]] = zero_states[3][1]\r\n for i in range(self.num_lstms):\r\n feeds[self.init_states[i+2][0]] = zero_states[i+2][0]\r\n feeds[self.init_states[i+2][1]] = zero_states[i+2][1]\r\n \r\n fetches = [\r\n self.loss,\r\n self.gauss_evals,\r\n self.mixture,\r\n self.means_,\r\n self.stdevs_,\r\n self.mix_weights_,\r\n self.stroke,\r\n self.gauss_params,\r\n self.alphabet_weights,\r\n self.phi\r\n ]\r\n\r\n loss, gauss_eval, mix_eval, means_, stdevs_, mix, stroke, params, aw, phi = self.session.run(fetches, feed_dict=feeds)\r\n if np.isnan(loss):\r\n print(\"LOSS IS NAN. ABORTING.\")\r\n with open(\"failmode.dat\", \"w\") as f:\r\n for i, item in enumerate((loss, means_, stdevs_, mix, gauss_eval, mix_eval, stroke, aw, phi)):\r\n f.write(str(item))\r\n sys.exit(-1)\r\n\r\n return (loss, means_, stdevs_, mix, gauss_eval, mix_eval, stroke, aw, phi)\r\n\r\n\r\n def _run_once(self, input_, stroke_, initial_states, ascii, bias):\r\n '''\r\n Takes a single input, (e.g. batch_size = 1, sequence_length = 1), passes it\r\n to the MDN, grabs the mixture parameters and final recurrent state of the \r\n MDN. Then it takes the mixture parameters and samples from them.\r\n The MDN returns the sampled value, other outputs, and the final recurrent\r\n state.\r\n Assumes input_.shape = [1, 1, input_size - 1]\r\n Assumes stroke_.shape = [1, 1, 1]\r\n '''\r\n\r\n #zero_states = self.multi_lstm_cell.zero_state(1, dtype=dtype)\r\n #zero_states = self.session.run(self.zero_states)\r\n #print('run_once input and stroke shapes:', input_.shape, stroke_.shape)\r\n\r\n # Concatenate stroke and (dx, dy) input to get (1, 1, 3) input tensor.\r\n feeds = {\r\n self.input_data: np.concatenate([input_, stroke_], axis=-1),\r\n self.input_ascii: ascii,\r\n self.mixture_bias: bias\r\n }\r\n\r\n #print(\"len initial states[2]:\", len(initial_states[2])) \r\n #print(\"len initial states:\", len(initial_states))\r\n\r\n # Initialize recurrent states with the states from the previous timestep.\r\n feeds[self.init_states[0][0]] = initial_states[0][0]\r\n feeds[self.init_states[0][1]] = initial_states[0][1]\r\n feeds[self.init_states[1]] = initial_states[1]\r\n #feeds[self.init_states[2][0]] = initial_states[2][0][0] # Ugly because of multirnncell\r\n #feeds[self.init_states[2][1]] = initial_states[2][0][1] # Ugly because of multirnncell\r\n #feeds[self.init_states[3][0]] = initial_states[2][1][0] # Ugly because of multirnncell\r\n #feeds[self.init_states[3][1]] = initial_states[2][1][1] # Ugly because of multirnncell\r\n # The two lines above shouldn't have an extra [0] iterator, but it'll have to\r\n # stay until you get rid of the multirnncell on the last LSTM layer.\r\n for i in range(self.num_lstms):\r\n feeds[self.init_states[i+2][0]] = initial_states[i+2][0]\r\n feeds[self.init_states[i+2][1]] = initial_states[i+2][1]\r\n\r\n fetches = [\r\n self.mix_weights,\r\n self.gauss_params,\r\n self.stroke,\r\n self.recurrent_states,\r\n self.alphabet_weights,\r\n self.phi,\r\n self.stop_check\r\n ]\r\n #print('input_ shape:', input_.shape)\r\n\r\n mix, params, stroke, state, aw, phi, stop = self.session.run(fetches, feed_dict=feeds)\r\n mix = np.squeeze(mix)\r\n squeezed_params = []\r\n squeezed_params.append([np.squeeze(p) for p in params[0]])\r\n squeezed_params.append([np.squeeze(p) for p in params[1]])\r\n squeezed_params.append([np.squeeze(p) for p in params[2]])\r\n\r\n # Need to add a way to sample from this distribution, then return the\r\n # value that was sampled, and the stroke probability.\r\n # np.random.multivariate_normal, et voila.\r\n \r\n # Assumptions about dimensionality of the outputs are covered in the\r\n # docstring.\r\n pos_sample = self._get_mixture_sample(squeezed_params, mix)\r\n stroke_sample = np.random.binomial(1, stroke)\r\n\r\n #return (sample, stroke, state)\r\n return (pos_sample, stroke_sample, state, squeezed_params, mix, aw, phi, stop)\r\n\r\n\r\n def run_cyclically(self, input_, ascii, num_steps, bias):\r\n '''\r\n Takes a seed value, passes it to the MDN, the mixture density is sampled,\r\n and the sample is fed into the input of the MDN at the next timestep.\r\n Assumes that the shape of input_ is [1, T, input_size].\r\n '''\r\n\r\n if len(input_.shape) == 2:\r\n input_ = np.expand_dims(input_, axis=0)\r\n elif len(input_.shape) == 1:\r\n input_ = np.expand_dims(input_, axis=0)\r\n input_ = np.expand_dims(input_, axis=0)\r\n print(\"run_cyclically input_ shape:\", input_.shape)\r\n\r\n (batch_size, sequence_length, input_size) = input_.shape\r\n\r\n feeds = {\r\n self.input_data: input_,\r\n self.input_ascii: ascii,\r\n self.input_mixture_bias: bias\r\n }\r\n\r\n zero_states = self.session.run(self.zero_states, feed_dict=feeds)\r\n print(\"len zero states:\", len(zero_states))\r\n print(\"len init states:\", len(self.init_states))\r\n\r\n feeds[self.init_states[0][0]] = zero_states[0][0]\r\n feeds[self.init_states[0][1]] = zero_states[0][1]\r\n feeds[self.init_states[1]] = zero_states[1]\r\n #feeds[self.init_states[2][0]] = zero_states[2][0]\r\n #feeds[self.init_states[2][1]] = zero_states[2][1]\r\n #feeds[self.init_states[3][0]] = zero_states[3][0]\r\n #feeds[self.init_states[3][1]] = zero_states[3][1]\r\n for i in range(self.num_lstms):\r\n feeds[self.init_states[i+2][0]] = zero_states[i+2][0]\r\n feeds[self.init_states[i+2][1]] = zero_states[i+2][1]\r\n\r\n fetches = [\r\n self.mix_weights,\r\n self.gauss_params,\r\n self.stroke,\r\n self.recurrent_states,\r\n self.alphabet_weights,\r\n self.phi,\r\n self.stop_check\r\n ]\r\n\r\n mix, params, stroke, init_state, aw, phi, stop = \\\r\n self.session.run(fetches, feed_dict=feeds)\r\n print(\"mix shape:\", mix.shape)\r\n print(\"params shape:\", len(params), len(params[1]), params[1][0].shape)\r\n print(\"stroke shape:\", stroke.shape)\r\n print(\"state lens:\", [len(s) for s in init_state])\r\n print(\"init state[2][0] len\", len(init_state[2][0]))\r\n print(\"type init_state[2][0]\", type(init_state[2][0]))\r\n print(\"init state len:\", len(init_state))\r\n\r\n # Need to loop over the method \"_run_once\" and constantly update its\r\n # initial recurrent state and input value.\r\n dots = []\r\n strokes = []\r\n init_means = []\r\n init_covs = []\r\n init_correls = []\r\n phis = [phi,]\r\n alphabet_weights = [aw,]\r\n states = []\r\n state = np.zeros_like(zero_states)\r\n\r\n for j in range(self.num_mix_gaussians):\r\n init_means.append(params[0][j][-1,:])\r\n init_covs.append(params[1][j][-1,:])\r\n init_correls.append(params[2][j][-1,:])\r\n\r\n sample = self._get_mixture_sample([init_means, init_covs, init_correls], mix[-1,:])\r\n print(\"sample shape:\", sample.shape)\r\n dots.append(sample)\r\n strokes.append(stroke[np.newaxis, np.newaxis,-1,:])\r\n states.append(init_state)\r\n\r\n stop_cycle = False\r\n i = 1\r\n #for i in range(1, num_steps):\r\n while (not stop_cycle) and i < num_steps:\r\n temp_dot, temp_stroke, temp_state, params_, mix_, temp_aw, temp_phi, temp_stop = \\\r\n self._run_once(dots[i-1], strokes[i-1], states[i-1], ascii, bias)\r\n dots.append(temp_dot)\r\n strokes.append(temp_stroke[np.newaxis,:,:])\r\n #state = init_state\r\n #init_state = state\r\n states.append(temp_state)\r\n alphabet_weights.append(temp_aw)\r\n phis.append(temp_phi)\r\n #for u in range(len(ascii)):\r\n # if temp_stop[0,0,0] > temp_phi[0,0,u]:\r\n # stop_cycle = True\r\n # else:\r\n # stop_cycle = False\r\n # print(\"\\tStopping the cyclical run after\", i, \"steps\")\r\n # break\r\n if np.all(temp_stop[0,0,0] > temp_phi[0,0,:]):\r\n print(\"\\tStopping the cyclical run after\", i, \"steps\")\r\n stop_cycle = True\r\n i += 1\r\n\r\n return (np.concatenate(dots, axis=1), np.concatenate(strokes, axis=1), np.concatenate(alphabet_weights, axis=1), np.concatenate(phis, axis=1)) # Getting shapes with three items: (1, sl, 2)\r\n\r\n\r\n def save_params(self, location, global_step):\r\n '''\r\n Simple call to save all of the parameters in the model.\r\n '''\r\n\r\n self.saver.save(self.session, location, global_step=global_step)\r\n #self.saver.save(self.session, location)\r\n\r\n\r\n def load_params(self, checkpoint_file):\r\n '''\r\n The checkpoint_file is filename.ckpt, which contains values of the model's\r\n trained parameters.\r\n The meta_file is filename.meta <-- don't need to import a meta graph, we\r\n already know what the model architecture is.\r\n '''\r\n\r\n #if not os.path.isfile(checkpoint_file):\r\n # print(\"The checkpoint file\", checkpoint_file, \"could not be found.\")\r\n # return\r\n\r\n print(\"Loading checkpoint file\", checkpoint_file, \"into the MDN model.\")\r\n #self.saver = tf.train.restore(self.session, checkpoint_file)\r\n self.saver.restore(self.session, checkpoint_file)\r\n\r\n\r\nif __name__ == \"__main__\":\r\n \r\n print(\"This is just the script that contains the MDN class. Go away!\")\r\n"
] | [
[
"tensorflow.nn.dynamic_rnn",
"numpy.expand_dims",
"tensorflow.concat",
"tensorflow.nn.rnn_cell.LSTMStateTuple",
"tensorflow.reduce_sum",
"numpy.squeeze",
"tensorflow.stack",
"numpy.random.multivariate_normal",
"tensorflow.nn.sigmoid_cross_entropy_with_logits",
"numpy.concatenate",
"numpy.all",
"tensorflow.nn.l2_loss",
"numpy.zeros_like",
"tensorflow.nn.rnn_cell.MultiRNNCell",
"tensorflow.train.Saver",
"tensorflow.trainable_variables",
"numpy.zeros",
"tensorflow.nn.rnn_cell.BasicLSTMCell",
"tensorflow.matmul",
"tensorflow.nn.sigmoid",
"tensorflow.train.RMSPropOptimizer",
"tensorflow.shape",
"numpy.isnan",
"tensorflow.placeholder",
"tensorflow.exp",
"tensorflow.nn.tanh",
"tensorflow.reduce_prod",
"numpy.random.binomial",
"tensorflow.split",
"numpy.sum",
"tensorflow.nn.relu",
"tensorflow.nn.rnn_cell.DropoutWrapper",
"tensorflow.nn.softmax",
"numpy.set_printoptions",
"tensorflow.reshape",
"tensorflow.log",
"tensorflow.variable_scope",
"tensorflow.sqrt",
"tensorflow.random_normal"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
Meteor-han/ReLMole | [
"ec8f2d3ec7b8edb6cd34aede36a980bab3dc35c2",
"ec8f2d3ec7b8edb6cd34aede36a980bab3dc35c2"
] | [
"task_ddi/run_ddi.py",
"models/siamese_network.py"
] | [
"import os, sys, argparse, time\nimport json\nfrom tqdm import tqdm\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom torch_geometric.data import DataLoader\nfrom tensorboardX import SummaryWriter\nsys.path.append('..')\nfrom models.ddi_predictor import DDIPredictor\nfrom models.series_gin_edge import SerGINE\nfrom loader import DDIDataset\nfrom chem import *\nfrom utils import *\n\n\ndef parse_args():\n parser = argparse.ArgumentParser()\n # environment arguments\n parser.add_argument('--cpu', default=False, action='store_true', help=\"train on cpu\")\n parser.add_argument('--gpu', default=0, type=int, help=\"gpu id\")\n # directory arguments\n parser.add_argument('--dataset', default='ZhangDDI', choices=['ZhangDDI', 'ChChMiner', 'DeepDDI'], help=\"DDI Dataset\")\n parser.add_argument('--output_dir', default='result', type=str, help=\"output directory\")\n parser.add_argument('--model_name', default='f1_best_model.pth', help=\"saved model name\")\n parser.add_argument('--time', default=1, type=int, help=\"time of experiment\")\n # network arguments\n parser.add_argument('--gnn', default='SerGINE', type=str, help=\"GNN architecture\")\n parser.add_argument('--num_atom_layers', default=3, type=int, help=\"num of atom-level gnn layers\")\n parser.add_argument('--num_fg_layers', default=2, type=int, help=\"num of FG-level gnn layers\")\n parser.add_argument('--emb_dim', default=128, type=int, help=\"embedding dimension\")\n parser.add_argument('--num_tasks', default=1, type=int, help=\"number of tasks\")\n parser.add_argument('--dropout', default=0.5, type=float, help=\"dropout rate\")\n # training arguments\n parser.add_argument('--from_scratch', default=False, action='store_true', help=\"train from scratch\")\n parser.add_argument('--pretrain_dir', default='../pretrained_model_cl_zinc15_250k', type=str, help=\"directory of pretrained models\")\n parser.add_argument('--pretrain_model_name', default='model.pth', type=str, help=\"pretrained model name\")\n parser.add_argument('--metric', default='CosineSimilarity', type=str, help=\"criterion of embedding distance\")\n parser.add_argument('--margin', default=1.0, type=float, help=\"margin of contrastive loss\")\n parser.add_argument('--pre_lr', default=1e-3, type=float, help=\"learning rate of pretraining\")\n parser.add_argument('--batch_size', default=512, type=int, help=\"batch size\")\n parser.add_argument('--lr0', default=1e-3, type=float, help=\"learning rate of encoder\")\n parser.add_argument('--lr1', default=1e-3, type=float, help=\"learning rate of predictor\")\n parser.add_argument('--num_epochs', default=20, type=int, help=\"number of training epoch\")\n parser.add_argument('--log_interval', default=50, type=int, help=\"log interval (batch/log)\")\n parser.add_argument('--early_stop', default=False, action='store_true', help=\"use early stop strategy\")\n parser.add_argument('--patience', default=20, type=int, help=\"num of waiting epoch\")\n parser.add_argument('--weight_decay', default=0, type=float, help=\"weight decay\")\n parser.add_argument('--checkpoint_interval', default=10, type=int, help=\"checkpoint interval (epoch/checkpoint)\")\n\n args = parser.parse_args()\n\n return args\n\n\ndef train(model, data_loader, optimizer, device):\n model.train()\n criterion = nn.BCEWithLogitsLoss()\n log_loss = 0\n for i, data in enumerate(data_loader):\n mol1, mol2, label = data\n mol1, mol2, label = mol1.to(device), mol2.to(device), label.to(device)\n\n optimizer.zero_grad()\n output = model(mol1, mol2)\n loss = criterion(output, label.reshape(-1, 1))\n loss.backward()\n optimizer.step()\n log_loss += loss.item()\n\n # log\n if (i+1) % args.log_interval == 0:\n log_loss = log_loss/args.log_interval\n print(f\"batch: {i+1}/{len(data_loader)} | loss: {log_loss :.8f} | time: {time.time()-start_time :.4f}\")\n log_loss = 0\n\n\ndef test(model, data_loader, device, threshold: float = 0.5, opt_thr: bool = True):\n model.eval()\n sigmoid = nn.Sigmoid()\n criterion = nn.BCEWithLogitsLoss()\n with torch.no_grad():\n avg_loss = 0\n true_label, pred_score = [], []\n for data in data_loader:\n mol1, mol2, label = data\n mol1, mol2, label = mol1.to(device), mol2.to(device), label.to(device)\n\n output = model(mol1, mol2)\n loss = criterion(output, label.reshape(-1, 1))\n avg_loss += loss.item()\n\n output = sigmoid(output)\n for true, pred in zip(label, output):\n true_label.append(true.item())\n pred_score.append(pred.item())\n\n avg_loss = avg_loss/len(data_loader)\n auc_roc, auc_prc, f1, mat, acc, threshold = eval_ddi_model(true_label, pred_score, threshold, opt_thr)\n return avg_loss, auc_roc, auc_prc, f1, mat, acc, threshold\n\n\nargs = parse_args()\nstart_time = time.time()\n\noutput_dir = args.gnn+'_dim'+str(args.emb_dim)\noutput_dir = os.path.join(args.output_dir, args.dataset, output_dir,\n 'margin'+str(args.margin) + '_lr0_'+str(args.lr0) + '_lr1_'+str(args.lr1) + '_dropout'+str(args.dropout),\n 'time'+str(args.time))\nif args.from_scratch:\n output_dir = os.path.join(output_dir, 'scratch')\next_setting = None\nif args.weight_decay > 0:\n output_dir = os.path.join(output_dir, 'decay'+str(args.weight_decay))\n\n\ndef main():\n os.makedirs(output_dir, exist_ok=True)\n logger = create_file_logger(os.path.join(output_dir, 'log.txt'))\n logger.info(\"=======Setting=======\")\n for k in args.__dict__:\n v = args.__dict__[k]\n logger.info(f\"{k}: {v}\")\n device = torch.device('cpu' if args.cpu else ('cuda:' + str(args.gpu)))\n logger.info(f\"\\nUtilized device as {device}\")\n\n # load data\n logger.info(\"\\n=======Load Dataset=======\")\n if args.dataset == 'ZhangDDI':\n drug_fn = 'drug_list_zhang.csv'\n elif args.dataset == 'ChChMiner':\n drug_fn = 'drug_list_miner.csv'\n elif args.dataset == 'DeepDDI':\n drug_fn = 'drug_list_deep.csv'\n else:\n raise ValueError(f\"{args.dataset} dataset is not found!\")\n train_set = DDIDataset(root=os.path.join('../data/DDI', args.dataset), drug_filename=drug_fn, ddi_filename=f'{args.dataset}_train.csv')\n valid_set = DDIDataset(root=os.path.join('../data/DDI', args.dataset), drug_filename=drug_fn, ddi_filename=f'{args.dataset}_valid.csv')\n test_set = DDIDataset(root=os.path.join('../data/DDI', args.dataset), drug_filename=drug_fn, ddi_filename=f'{args.dataset}_test.csv')\n logger.info(f\"train data num: {len(train_set)} | valid data num: {len(valid_set)} | test data num: {len(test_set)}\")\n train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=True, follow_batch=['fg_x'])\n valid_loader = DataLoader(valid_set, batch_size=args.batch_size, shuffle=False, follow_batch=['fg_x'])\n test_loader = DataLoader(test_set, batch_size=args.batch_size, shuffle=False, follow_batch=['fg_x'])\n\n # define model\n if args.gnn == 'SerGINE':\n encoder = SerGINE(num_atom_layers=args.num_atom_layers, num_fg_layers=args.num_fg_layers, latent_dim=args.emb_dim,\n atom_dim=ATOM_DIM, fg_dim=FG_DIM, bond_dim=BOND_DIM, fg_edge_dim=FG_EDGE_DIM,\n dropout=args.dropout)\n # elif args.gnn == : # more GNN\n else:\n raise ValueError(\"Undefined GNN!\")\n model = DDIPredictor(encoder=encoder, latent_dim=args.emb_dim, num_tasks=args.num_tasks, dropout=args.dropout)\n model.to(device)\n\n # load pre-trained model\n if not args.from_scratch:\n logger.info(\"\\n=======Load Pre-trained Model=======\")\n pre_path = args.gnn\n pre_path += '_dim'+str(args.emb_dim) + '_'+args.metric + '_margin'+str(args.margin) + '_lr'+str(args.pre_lr)\n pre_path = os.path.join(args.pretrain_dir, pre_path, args.pretrain_model_name)\n model.from_pretrained(model_path=pre_path, device=device)\n logger.info(f\"Load pre-trained model from {pre_path}\")\n\n logger.info(\"\\n=======Train=======\")\n os.chdir(output_dir)\n optimizer = optim.Adam([{'params': model.encoder.parameters(), 'lr': args.lr0},\n {'params': model.predictor.parameters()}], lr=args.lr1, weight_decay=args.weight_decay)\n start_epoch = 0\n best = [0, 0, 0] # [epoch, valid_f1, test_f1]\n early_stop_cnt = 0\n record = [[], [], [], # [train roc, train prc, train f1,\n [], [], [], # valid_roc, valid orc, valid f1,\n [], [], []] # test roc, test prc, test f1]\n\n # load checkpoint\n if os.path.exists('checkpoint.pth'):\n checkpoint = torch.load('checkpoint.pth', map_location=device)\n model.load_state_dict(checkpoint['model_state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n start_epoch = checkpoint['epoch']\n best = checkpoint['best']\n record = checkpoint['record']\n logger.info(f\"Resume training from Epoch {start_epoch+1 :03d}\")\n\n # train\n for epoch in range(start_epoch, args.num_epochs):\n logger.info(f\"Epoch {epoch+1 :03d}\")\n early_stop_cnt += 1\n train(model, train_loader, optimizer, device)\n # record\n train_roc, train_prc, train_f1 = 0, 0, 0\n # _, train_roc, train_prc, train_f1, _, _, _ = test(model, train_loader, device)\n record[0].append(train_roc)\n record[1].append(train_prc)\n record[2].append(train_f1)\n _, valid_roc, valid_prc, valid_f1, _, _, _ = test(model, valid_loader, device)\n record[3].append(valid_roc)\n record[4].append(valid_prc)\n record[5].append(valid_f1)\n _, test_roc, test_prc, test_f1, _, _, _ = test(model, test_loader, device)\n record[6].append(test_roc)\n record[7].append(test_prc)\n record[8].append(test_f1)\n logger.info(f\"Train AUC_ROC: {train_roc :.8f} | AUC_PRC: {train_prc :.8f} | F1: {train_f1 :.8f}\")\n logger.info(f\"Valid AUC_ROC: {valid_roc :.8f} | AUC_PRC: {valid_prc :.8f} | F1: {valid_f1 :.8f}\")\n logger.info(f\"Test AUC_ROC: {test_roc :.8f} | AUC_PRC: {test_prc :.8f} | F1: {test_f1 :.8f}\")\n # update model\n if valid_f1 > best[1]:\n best = [epoch+1, valid_f1, test_f1]\n torch.save(model.state_dict(), args.model_name)\n print(f\"Saved model of Epoch {epoch+1 :03d} into '{args.model_name}'\")\n early_stop_cnt = 0\n else:\n print(f\"No improvement since Epoch {best[0] :03d} with Valid F1: {best[1] :.8f} | Test F1: {best[2] :.8f}\")\n # save checkpoint\n if (epoch+1) % args.checkpoint_interval == 0:\n checkpoint = {'model_state_dict': model.state_dict(),\n 'optimizer_state_dict': optimizer.state_dict(),\n 'epoch': epoch+1,\n 'best': best,\n 'record': record}\n torch.save(checkpoint, 'checkpoint.pth')\n # early stop\n if args.early_stop and (early_stop_cnt == args.patience):\n logger.info(f\"Early stop at Epoch {epoch+1 :03d}\")\n break\n\n logger.info(f\"\\n'{args.model_name}' | Epoch: {best[0] :03d} | F1: {best[1] :.8f}\")\n\n logger.info(\"\\n=======Test=======\")\n logger.info(f\"{args.model_name}\")\n model.load_state_dict(torch.load(args.model_name, map_location=device))\n logger.info(\"Train set:\")\n _, auc_roc, auc_prc, f1, _, _, _ = test(model, train_loader, device)\n logger.info(f\"AUC_ROC: {auc_roc :.8f} | AUC_PRC: {auc_prc :.8f} | F1: {f1 :.8f}\")\n logger.info(\"Valid set:\")\n _, auc_roc, auc_prc, f1, _, _, _ = test(model, valid_loader, device)\n logger.info(f\"AUC_ROC: {auc_roc :.8f} | AUC_PRC: {auc_prc :.8f} | F1: {f1 :.8f}\")\n logger.info(\"Test set:\")\n _, auc_roc, auc_prc, f1, _, _, _ = test(model, test_loader, device)\n logger.info(f\"AUC_ROC: {auc_roc :.8f} | AUC_PRC: {auc_prc :.8f} | F1: {f1 :.8f}\")\n\n logger.info(\"\\n=======Finish=======\")\n\n\nif __name__ == '__main__':\n main()\n",
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\ndtype = torch.float32\n\n\nclass SiameseNetwork(nn.Module):\n def __init__(self, encoder, latent_dim=128, dropout=0, **kwargs):\n super().__init__()\n self.encoder = encoder\n self.projector = nn.Sequential(\n nn.Linear(latent_dim, latent_dim*4), nn.ReLU(), nn.Dropout(dropout), nn.Linear(latent_dim*4, latent_dim)\n )\n\n def forward(self, x):\n emb = self.encoder(x)\n emb = self.projector(emb)\n return emb\n"
] | [
[
"torch.load",
"torch.nn.Sigmoid",
"torch.nn.BCEWithLogitsLoss",
"torch.no_grad",
"torch.save"
],
[
"torch.nn.Dropout",
"torch.nn.Linear",
"torch.nn.ReLU"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
opengeostat/pygslib | [
"7fb0c201eba6304b1914cf88a437aa9dc42e7021"
] | [
"setup.py"
] | [
"\"\"\"\r\npygslib: GSLIB in python\r\n\r\nCopyright 2020, Adrian Martinez Vargas.\r\nLicensed under MIT.\r\n\r\n\"\"\"\r\nimport setuptools #required to build wheels\r\nimport sys\r\nimport os\r\n\r\n# get version from package\r\nexec(open('pygslib/version.py').read())\r\n\r\nversion = __version__\r\ndescription = 'Python module for mineral resource estimation and geostatistics'\r\nname='pygslib'\r\nlong_description=open(\"README.md\").read()\r\nclassifiers=[\r\n 'Development Status :: 7 - Alpha',\r\n 'Programming Language :: Python',\r\n 'Intended Audience :: Science/Research',\r\n 'License :: OSI Approved :: MIT License and GPL',\r\n 'Topic :: Scientific/Engineering :: Mathematics',\r\n 'Topic :: Scientific/Engineering :: GIS']\r\nkeywords='geostatistics kriging variogram estimation simulation blockmodel drillhole wireframe'\r\nauthor='Adrian Martinez Vargas'\r\nauthor_email='[email protected]'\r\nurl='https://github.com/opengeostat/pygslib'\r\n\r\n\r\nif __name__ == '__main__':\r\n\r\n #FORTRAN code extension\r\n #-------------------------------------------------------------------\r\n #make sure you use the setup from numpy\r\n from numpy.distutils.core import setup # this is numpy's setup\r\n from numpy.distutils.core import Extension\r\n #from numpy import get_include\r\n from Cython.Build import cythonize\r\n\r\n # these are the almost intact gslib code\r\n gslib_kt3d = Extension(name = 'pygslib.gslib.__gslib__kt3d',\r\n sources = ['for_code/kt3d/kt3d.f90',\r\n 'for_code/kt3d/gslib/setrot.f90',\r\n 'for_code/kt3d/gslib/getindx.f90',\r\n 'for_code/kt3d/gslib/picksupr.f90',\r\n 'for_code/kt3d/gslib/setsupr.f90',\r\n 'for_code/kt3d/gslib/sqdist.f90',\r\n 'for_code/kt3d/gslib/cova3.f90',\r\n 'for_code/kt3d/gslib/ktsol.f90',\r\n 'for_code/kt3d/gslib/sortem.f90',\r\n 'for_code/kt3d/gslib/srchsupr.f90'],\r\n f2py_options=[ 'only:', 'pykt3d', 'set_unest', ':'])\r\n\r\n gslib_postik = Extension(name = 'pygslib.gslib.__gslib__postik',\r\n sources = ['for_code/postik/postik.f90',\r\n 'for_code/postik/gslib/beyond.f90',\r\n 'for_code/postik/gslib/locate.f90',\r\n 'for_code/postik/gslib/powint.f90',\r\n 'for_code/postik/gslib/sortem.f90'],\r\n f2py_options=[ 'only:', 'postik', 'set_unest', 'get_unest', ':'])\r\n\r\n\r\n # this is the gslib code too modified\r\n # define extensions here:\r\n #-----------------------------------------------------\r\n gslib_rotscale = Extension(name = 'pygslib.gslib.__rotscale',\r\n sources = ['for_code/rotscale.f90'],\r\n\t\t\t\t\t\t\t\textra_link_args= ['-static'] )\r\n\r\n gslib_block_covariance = Extension(name = 'pygslib.gslib.__block_covariance',\r\n sources = ['for_code/block_covariance.f90'] )\r\n\r\n gslib_read_gslib = Extension(name = 'pygslib.gslib.__read_gslib',\r\n sources = ['for_code/read_gslib.f90'] )\r\n\r\n gslib_addcoord = Extension(name = 'pygslib.gslib.__addcoord',\r\n sources = ['for_code/addcoord.f90'] )\r\n\r\n gslib_general = Extension(name = 'pygslib.gslib.__general',\r\n sources = ['for_code/general.f90'] )\r\n\r\n gslib_plot = Extension(name = 'pygslib.gslib.__plot',\r\n sources = ['for_code/plot.f90'] )\r\n\r\n gslib_declus = Extension(name = 'pygslib.gslib.__declus',\r\n sources = ['for_code/declus.f90'] )\r\n\r\n gslib_dist_transf = Extension(name = 'pygslib.gslib.__dist_transf',\r\n sources = ['for_code/dist_transf.f90'],\r\n f2py_options=[ 'only:', 'backtr', 'anatbl',\r\n 'nscore', 'ns_ttable', ':'] )\r\n\r\n gslib_variograms = Extension(name = 'pygslib.gslib.__variograms',\r\n sources = ['for_code/variograms.f90'] ) # extra_link_args=['-fbacktrace', '-fcheck=all']\r\n\r\n gslib_bigaus = Extension(name = 'pygslib.gslib.__bigaus',\r\n sources = ['for_code/bigaus.f90'] )\r\n\r\n gslib_bicalib = Extension(name = 'pygslib.gslib.__bicalib',\r\n sources = ['for_code/bicalib.f90'] )\r\n\r\n\r\n gslib_trans = Extension(name = 'pygslib.gslib.__trans',\r\n sources = ['for_code/trans.f90'] )\r\n\r\n gslib_draw = Extension(name = 'pygslib.gslib.__draw',\r\n sources = ['for_code/draw.f90'] )\r\n\r\n gslib_dm2csv = Extension(name = 'pygslib.gslib.__dm2csv',\r\n sources = ['for_code/dm2csv.f90'] )\r\n\r\n\r\n # Cython\r\n\r\n drillhole = Extension(name ='pygslib.drillhole', sources =['cython_code/drillhole.pyx'])\r\n blockmodel= Extension(name ='pygslib.blockmodel', sources =['cython_code/blockmodel.pyx'])\r\n vtktools= Extension(name ='pygslib.vtktools', sources =['cython_code/vtktools.pyx'])\r\n nonlinear= Extension(name ='pygslib.nonlinear',sources =['cython_code/nonlinear.pyx'])\r\n sandbox= Extension(name ='pygslib.sandbox',sources =['cython_code/sandbox.pyx'])\r\n\r\n #pure python\r\n progress= Extension(name ='pygslib.progress',sources =['pygslib/progress.py'])\r\n surpac= Extension(name ='pygslib.surpac',sources =['pygslib/surpac.py'])\r\n\r\n\t# All extensions Fortran + Cython\r\n\r\n extensions =[gslib_variograms,\r\n\t\t\t\t gslib_bigaus,\r\n\t\t\t\t gslib_bicalib,\r\n\t\t\t\t gslib_trans,\r\n\t\t\t\t gslib_draw,\r\n\t\t\t\t gslib_dm2csv,\r\n\t\t\t\t gslib_addcoord,\r\n\t\t\t\t gslib_rotscale,\r\n\t\t\t\t gslib_read_gslib,\r\n\t\t\t\t gslib_declus,\r\n\t\t\t\t gslib_dist_transf,\r\n\t\t\t\t gslib_block_covariance,\r\n\t\t\t\t gslib_plot,\r\n\t\t\t\t gslib_kt3d,\r\n\t\t\t\t gslib_postik,\r\n\t\t\t\t gslib_general,\r\n\t\t\t\t drillhole,\r\n\t\t\t\t blockmodel,\r\n\t\t\t\t vtktools,\r\n\t\t\t\t nonlinear,\r\n\t\t\t\t sandbox,\r\n progress,\r\n\t\t\t\t surpac]\r\n\r\n extensions = cythonize(extensions, gdb_debug=True)\r\n\r\n setup(name=name,\r\n version=version,\r\n description= description,\r\n long_description=long_description,\r\n classifiers=classifiers,\r\n keywords=keywords,\r\n author=author,\r\n author_email=author_email,\r\n url=url,\r\n license='GPL and MIT',\r\n zip_safe=False,\r\n setup_requires = ['cython',\r\n 'numpy',\r\n 'setuptools',\r\n ],\r\n install_requires = ['ipython',\r\n 'matplotlib',\r\n 'jupyter',\r\n 'vtk>=8.0',\r\n 'bokeh',\r\n 'colour',\r\n 'numpy>=0.19',\r\n 'scipy',\r\n 'pandas'\r\n ],\r\n tests_require=['pytest'],\r\n packages=['pygslib',\r\n 'pygslib.gslib',\r\n 'pygslib.plothtml',\r\n 'pygslib.charttable'],\r\n include_package_data=True,\r\n package_data={'pygslib': ['data/*.*']},\r\n ext_modules = extensions)\r\n\r\n\r\n\t# copy dll if so is windows\r\n if os.name=='nt':\r\n mayor = sys.version_info[0]\r\n minor = sys.version_info[1]\r\n os.system('copy build\\\\lib.win-amd64-{}.{}\\\\pygslib\\\\.libs\\\\*.dll build\\\\lib.win-amd64-{}.{}\\\\pygslib\\\\gslib'.format(mayor,minor,mayor,minor))\r\n os.system('del /s /q build\\\\lib.win-amd64-{}.{}\\\\pygslib\\\\.libs'.format(mayor,minor))\r\n\r\n # running tests\r\n os.system('pytest --doctest-modules -v tests/') #pytest style tests\r\n\r\n print (\" OPENGEOSTAT SAYS CYTHON/FORTRAN CODE COMPILED\")\r\n"
] | [
[
"numpy.distutils.core.Extension",
"numpy.distutils.core.setup"
]
] | [
{
"matplotlib": [],
"numpy": [
"1.11",
"1.19",
"1.24",
"1.16",
"1.23",
"1.20",
"1.7",
"1.12",
"1.21",
"1.22",
"1.14",
"1.6",
"1.13",
"1.9",
"1.17",
"1.10",
"1.18",
"1.15",
"1.8"
],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
parkinkon1/simclr | [
"2c1a19baf28e91db119ab32df75d3a6e474dc1b1"
] | [
"stl10_pky.py"
] | [
"\nimport argparse\nimport time\nimport torchvision\nimport torch\nfrom torchvision import transforms as T\nfrom PIL import Image\nimport importlib.util\n\nimport tensorflow_datasets as tfds\nimport tensorflow_hub as hub\nimport sys\nimport os\nimport yaml\nimport re\nimport numpy as np\nimport subprocess\nimport random\n\n# import tensorflow.compat.v1 as tf\nimport tensorflow as tf\n# tf.disable_eager_execution()\n\n# subprocess.check_call([\"gcloud\", \"auth\", \"application-default\", \"login\"])\nseed = 201711075\ntorch.manual_seed(seed)\nnp.random.seed(seed) # Numpy module.\nrandom.seed(seed) # Python random module.\ntorch.manual_seed(seed)\n\n\ndef _init_fn(worker_id):\n seed_s = seed + worker_id\n np.random.seed(seed_s)\n random.seed(seed_s)\n torch.manual_seed(seed_s)\n return\n\n\nparser = argparse.ArgumentParser(description='feature extraction')\nparser.add_argument('-d', '--data', required=True,\n type=str, help='dataType(train/val)')\nparser.add_argument('-t', '--type', required=True, type=str,\n help='modelType(pretrained/supervised)')\nargs = parser.parse_args()\n\n\n# 1-3. Load data\ndataType = args.data # datatype (train / test)\nmodel_type = args.type # supervised / pretrained\nmodel_spec = 'r50_1x_sk0'\ndataPath = '/home/user/Desktop/pky/simclr/save/Imagenet/dataset/'\nprint('dataPath:', dataPath)\n\ndata_total = 50000\nbatch_size = 100\nnum_batch = data_total // batch_size\n# device\ndevice = '/gpu:0'\n\nsavePath = '/home/user/Desktop/pky/simclr/save/STL10/' # save path\ntimestr = time.strftime(\"%m%d-%H%M\") # time stamp\nprint('savePath:', savePath)\nprint('timeStamp:', timestr)\n\nprint('load hub modules...')\n# model_type = 'supervised'\n# model_spec = 'r50_1x_sk0'\nmodel_name = model_type+'_'+model_spec\nhub_path = 'gs://simclr-checkpoints/simclrv2/'+model_type+'/'+model_spec+'/hub/'\nmodule = hub.Module(hub_path, trainable=False)\nprint('load finished!')\n\n\nfile_total = 5\n\n\ndef _load_stl10(prefix=\"train\"):\n transform = T.Compose([T.Resize(224), T.ToTensor()])\n data = np.fromfile('./stl10_binary/' + prefix +\n '_X.bin', dtype=np.uint8)\n label = np.fromfile('./stl10_binary/' + prefix +\n '_y.bin', dtype=np.uint8)\n data = (transform(data).numpy()).transpose(0, 2, 3, 1)\n label = label - 1\n\n print(\"{} images\".format(prefix))\n print(data.shape, label.shape)\n for i in range(0, data.shape[0], batch_size):\n yield data[i: i+batch_size], label[i: i+batch_size]\n\n\n# def _load_imagenet():\n# for file_num in range(file_total):\n# data = np.load(dataPath+dataType+'_images_{}.npy'.format(file_num))\n# label = np.load(dataPath+dataType+'_labels_{}.npy'.format(file_num))\n# for i in range(0, data.shape[0], batch_size):\n# yield data[i: i+batch_size], label[i: i+batch_size]\n\n\n# with tf.device(\"/gpu:0\"):\n# input_tensor = tf.placeholder(tf.float32, shape=[None, 224, 224, 3])\n# keys = module(inputs=input_tensor, signature=\"default\", as_dict=True)\n# features = keys['default']\n# logits = keys['logits_sup']\n\ninput_tensor = tf.placeholder(tf.float32, shape=[None, 224, 224, 3])\nkeys = module(inputs=input_tensor, signature=\"default\", as_dict=True)\nfeatures = keys['default']\nlogits = keys['logits_sup']\n\nprint(\"initializing sessions...\")\nsess = tf.Session()\nsess.run(tf.global_variables_initializer())\nprint(\"initializing finished!\")\n\nfeatures_total = np.empty((0, 2048))\nlogits_total = np.empty((0, 1000))\nlabels_total = np.array([])\n\nprint(\"batch computation start...\")\nfor batch_data, batch_label in _load_stl10(dataType):\n features_, logits_ = sess.run((features, logits), feed_dict={\n input_tensor: batch_data})\n features_total = np.append(features_total, features_, axis=0)\n logits_total = np.append(logits_total, logits_, axis=0)\n labels_total = np.append(labels_total, batch_label, axis=0)\nprint(\"batch Finished!\")\n\n# 저장\nnp.save(savePath+timestr+'_'+dataType+'_features_'+model_name, features_total)\nnp.save(savePath+timestr+'_'+dataType+'_logits_'+model_name, logits_total)\nnp.save(savePath+timestr+'_'+dataType+'_labels_'+model_name, labels_total)\n\nprint(\"features:\", str(features_total.shape))\nprint(\"logits:\", str(logits_total.shape))\nprint(\"labels:\", str(labels_total.shape))\n"
] | [
[
"numpy.fromfile",
"numpy.random.seed",
"torch.manual_seed",
"tensorflow.placeholder",
"numpy.save",
"tensorflow.global_variables_initializer",
"numpy.append",
"tensorflow.Session",
"numpy.array",
"numpy.empty"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
}
] |
UniHD-CEG/camuy | [
"6f651a41ff3eb30d8ab3233ce20cc5f48f9cbfcb"
] | [
"mpusim_separable_conv2d/mpusim_separable_conv2d_op_impl.py"
] | [
"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n# Modifications copyright (c) 2020 Computing Systems Group.\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\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport math\n\nimport tensorflow.compat.v1 as tf\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import function\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import candidate_sampling_ops\nfrom tensorflow.python.ops import control_flow_ops\nfrom tensorflow.python.ops import embedding_ops\nfrom tensorflow.python.ops import gen_array_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import nn_ops\nfrom tensorflow.python.ops import sparse_ops\nfrom tensorflow.python.ops import variables\nfrom tensorflow.python.util.deprecation import deprecated_args\nfrom tensorflow.python.util.deprecation import deprecated_argument_lookup\nfrom tensorflow.python.util.tf_export import tf_export\n\nmpu_sim_conv2d_lib = tf.load_op_library('../../bin/build_mpusim_conv2d_release/mpusim-conv2d.so')\n\ndef mpusim_separable_conv2d_impl(input,\n depthwise_filter,\n pointwise_filter,\n strides,\n padding,\n rate=None,\n name=None,\n data_format=None,\n activations_datatype_size_byte=1,\n weights_datatype_size_byte=1,\n results_datatype_size_byte=4,\n systolic_array_height=256,\n systolic_array_width=256,\n activation_fifo_depth=8,\n accumulator_array_height=4096,\n log_file_output_dir='.',\n model_name='unnamed'):\n \n with ops.name_scope(name, \"mpusim_separable_conv2d_impl\",\n [input, depthwise_filter, pointwise_filter]) as name:\n \n input = ops.convert_to_tensor(input, name=\"tensor_in\")\n \n depthwise_filter = ops.convert_to_tensor(depthwise_filter,\n name=\"depthwise_filter\")\n \n pointwise_filter = ops.convert_to_tensor(pointwise_filter,\n name=\"pointwise_filter\")\n\n depthwise_filter_shape = depthwise_filter.get_shape().with_rank(4)\n \n channels = depthwise_filter_shape.dims[3]\n\n pointwise_filter_shape = pointwise_filter.get_shape().with_rank(4)\n pointwise_filter_shape.dims[0].assert_is_compatible_with(1)\n pointwise_filter_shape.dims[1].assert_is_compatible_with(1)\n\n if rate is None:\n rate = [1, 1]\n\n # The layout of the ops in the graph are expected to be as follows:\n # depthwise_conv2d // Conv2D op corresponding to deptwise convolution\n # separable_conv2d // Conv2D op corresponding to the pointwise convolution\n\n def op(input_converted, _, padding):\n \n inputs = tf.split(input_converted, channels, 3)\n kernels = tf.split(depthwise_filter, channels, 3)\n outputs = [mpu_sim_conv2d_lib.mpu_sim_conv2d(input_block,\n kernel_block,\n activations_datatype_size_byte,\n weights_datatype_size_byte,\n results_datatype_size_byte,\n systolic_array_height,\n systolic_array_width,\n activation_fifo_depth,\n accumulator_array_height,\n log_file_output_dir,\n model_name,\n strides=strides,\n padding=padding)\n for input_block, kernel_block in zip(inputs, kernels)]\n \n print('Executed depthwise convolution')\n \n return tf.concat(outputs, 3)\n\n depthwise = nn_ops.with_space_to_batch(input=input,\n filter_shape=array_ops.shape(depthwise_filter),\n dilation_rate=rate,\n padding=padding,\n data_format=data_format,\n op=op)\n\n return mpu_sim_conv2d_lib.mpu_sim_conv2d(depthwise,\n pointwise_filter,\n activations_datatype_size_byte,\n weights_datatype_size_byte,\n results_datatype_size_byte,\n systolic_array_height,\n systolic_array_width,\n activation_fifo_depth,\n accumulator_array_height,\n log_file_output_dir,\n model_name,\n strides=[1, 1, 1, 1],\n padding=\"VALID\",\n data_format=data_format,\n name=name)\n"
] | [
[
"tensorflow.python.ops.array_ops.shape",
"tensorflow.compat.v1.concat",
"tensorflow.compat.v1.split",
"tensorflow.python.framework.ops.name_scope",
"tensorflow.python.framework.ops.convert_to_tensor",
"tensorflow.compat.v1.load_op_library"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
seawavve/Random_CNN | [
"5dee90ddc8a79d4b4f2d9c5bd83e62e910c6fc83"
] | [
"CNN/0902_rand_cnn.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"0902_rand_cnn.ipynb\n\nAutomatically generated by Colaboratory.\n\nOriginal file is located at\n https://colab.research.google.com/drive/1p6_O9ie0cDHaiKxQBn935uTVwj85cEz9\n\"\"\"\n\n'''\npilab seawavve\nrandom cnn\n2020.05.20~\n\nAcc: 91.28% Epoch:75\n\n\n****PATCH NOTE****\n0520 cnn network구성\n0000 EarlyStopping&ModelCheckpoint\n0000 이미지증강\n0621 bypass\n0902 random\n depth&add확률 조정 요망\n summary에 체크한 레이어 수보다 많이 나오는 오류 디버깅 요망\n\n\n'''\n\nimport warnings\nwarnings.simplefilter(action='ignore', category=FutureWarning)\nimport sys\nimport random\nimport numpy as np\nfrom tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom tensorflow.keras import datasets\n\n\ndef make_rand(net_list): #파생된 레이어들을 list에 담아 반환\n lis=list()\n re_seed=random.randint(1,4) #파생레이어 1~4개 생성\n for i in range(re_seed):\n seed=random.randint(1,4) #한 레이어에서 파생레이어 생성\n if seed==1:\n im_output= layers.Conv2D(filters=64, kernel_size=[3,3], padding='same', activation='relu')(output)\n elif seed==2:\n im_output= layers.Dropout(rate=0.25)(output)\n elif seed==3:\n im_output= layers.MaxPooling2D(pool_size=[3, 3], padding='same', strides=1)(output)\n elif seed==4:\n im_output = layers.Activation('relu')(output)\n lis.append(im_output)\n return lis\n\ndef make_short_cut(a_layer,b_layer): # 받은 두개의 레이어로 shortcut을 만들어 반환\n im_output = layers.Add()([a_layer,b_layer])\n return im_output\n\nprint('Python version : ', sys.version)\nprint('Keras version : ', keras.__version__)\n\nimg_rows = 28\nimg_cols = 28\n\n(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()\n\ninput_shape = (img_rows, img_cols, 1)\nx_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\nx_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n\nx_train = x_train.astype('float32') / 255.\nx_test = x_test.astype('float32') / 255.\n\nprint('x_train shape:', x_train.shape)\nprint(x_train.shape[0], 'train samples')\nprint(x_test.shape[0], 'test samples')\n\nbatch_size = 128\nnum_classes = 10\nepochs = 300\nfilename = 'checkpoint.h5'.format(epochs, batch_size)\n\nearly_stopping=EarlyStopping(monitor='val_loss',mode='min',patience=15,verbose=1) #얼리스타핑\ncheckpoint=ModelCheckpoint(filename,monitor='val_loss',verbose=1,save_best_only=True,mode='auto') #체크포인트\n\n\ny_train = keras.utils.to_categorical(y_train, num_classes)\ny_test = keras.utils.to_categorical(y_test, num_classes)\n\ninputs = keras.Input(shape=input_shape, name='input' )\noutput= layers.Conv2D(filters=64, kernel_size=[3,3], padding='same', activation='relu')(inputs)\n\nnet_list=list()\nadd_num=0\n\nfor depth in range(5): #깊이정하기\n a=make_rand(net_list) #랜덤레이어 생성\n net_list.extend(a)\n print('make_list로 만든 리스트의 길이:',len(a))\n if len(a)==1:r_num=0 #a 중에서 하나 레이어 골라서 output에 붙이기\n else:r_num=random.randint(0,len(a)-1) \n print('랜덤 index number:',r_num+1) \n output=a[r_num] \n short_cut_dec=random.randint(1,5) #20%확률적으로 shortcut\n if short_cut_dec==1 or short_cut_dec==2:\n add_num=add_num+1\n a_layer_num=random.randint(0,len(net_list)-1)\n c=make_short_cut(net_list[a_layer_num],output) \n output=c\n\nprint('\\n',depth+1,'개 레이어추가',add_num,'개 shortcut추가')\n\noutput = layers.GlobalAveragePooling2D()(output)\noutput = layers.Dense(1000, activation='relu')(output)\ndropout = layers.Dropout(rate=0.25)(output)\noutput = layers.Dense(10, activation='softmax')(dropout)\n\nmodel = keras.Model(inputs=inputs, outputs=output)\n\nmodel.summary()\n\nmodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\nhistory = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test),callbacks=[checkpoint,early_stopping])\n\nscore = model.evaluate(x_test, y_test, verbose=0)\nprint('Test loss:', score[0])\nprint('Test accuracy:', score[1])\nmodel.save('MNIST_CNN_model.h5')\n"
] | [
[
"tensorflow.keras.callbacks.ModelCheckpoint",
"tensorflow.keras.datasets.fashion_mnist.load_data",
"tensorflow.keras.layers.GlobalAveragePooling2D",
"tensorflow.keras.Input",
"tensorflow.keras.layers.Activation",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.layers.Conv2D",
"tensorflow.keras.Model",
"tensorflow.keras.layers.Add",
"tensorflow.keras.layers.MaxPooling2D",
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.callbacks.EarlyStopping",
"tensorflow.keras.utils.to_categorical"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.7",
"2.2",
"2.3",
"2.4",
"2.5",
"2.6"
]
}
] |
mcernak/asteroid | [
"ed25e166a3bd338547248938116ba614ecfa4b3e",
"ed25e166a3bd338547248938116ba614ecfa4b3e"
] | [
"asteroid/filterbanks/griffin_lim.py",
"asteroid/models/dccrnet.py"
] | [
"import torch\nimport math\n\nfrom . import Encoder, Decoder, STFTFB # noqa\nfrom .stft_fb import perfect_synthesis_window\nfrom . import transforms\nfrom ..dsp.consistency import mixture_consistency\n\n\ndef griffin_lim(mag_specgram, stft_enc, angles=None, istft_dec=None, n_iter=6, momentum=0.9):\n \"\"\"Estimates matching phase from magnitude spectogram using the\n 'fast' Griffin Lim algorithm [1].\n\n Args:\n mag_specgram (torch.Tensor): (any, dim, ension, freq, frames) as\n returned by `Encoder(STFTFB)`, the magnitude spectrogram to be\n inverted.\n stft_enc (Encoder[STFTFB]): The `Encoder(STFTFB())` object that was\n used to compute the input `mag_spec`.\n angles (None or Tensor): Angles to use to initialize the algorithm.\n If None (default), angles are init with uniform ditribution.\n istft_dec (None or Decoder[STFTFB]): Optional Decoder to use to get\n back to the time domain. If None (default), a perfect\n reconstruction Decoder is built from `stft_enc`.\n n_iter (int): Number of griffin-lim iterations to run.\n momentum (float): The momentum of fast Griffin-Lim. Original\n Griffin-Lim is obtained for momentum=0.\n\n Returns:\n torch.Tensor: estimated waveforms of shape (any, dim, ension, time).\n\n Examples\n >>> stft = Encoder(STFTFB(n_filters=256, kernel_size=256, stride=128))\n >>> wav = torch.randn(2, 1, 8000)\n >>> spec = stft(wav)\n >>> masked_spec = spec * torch.sigmoid(torch.randn_like(spec))\n >>> mag = transforms.mag(masked_spec, -2)\n >>> est_wav = griffin_lim(mag, stft, n_iter=32)\n\n References\n - [1] Perraudin et al. \"A fast Griffin-Lim algorithm,\" WASPAA 2013.\n - [2] D. W. Griffin and J. S. Lim: \"Signal estimation from modified\n short-time Fourier transform,\" ASSP 1984.\n\n \"\"\"\n # We can create perfect iSTFT from STFT Encoder\n if istft_dec is None:\n # Compute window for perfect resynthesis\n syn_win = perfect_synthesis_window(stft_enc.filterbank.window, stft_enc.stride)\n istft_dec = Decoder(STFTFB(**stft_enc.get_config(), window=syn_win))\n\n # If no intitial phase is provided initialize uniformly\n if angles is None:\n angles = 2 * math.pi * torch.rand_like(mag_specgram, device=mag_specgram.device)\n else:\n angles = angles.view(*mag_specgram.shape)\n\n # Initialize rebuilt (useful to use momentum)\n rebuilt = 0.0\n for _ in range(n_iter):\n prev_built = rebuilt\n # Go to the time domain\n complex_specgram = transforms.from_magphase(mag_specgram, angles)\n waveform = istft_dec(complex_specgram)\n # And back to TF domain\n rebuilt = stft_enc(waveform)\n # Update phase estimates (with momentum)\n diff = rebuilt - momentum / (1 + momentum) * prev_built\n angles = transforms.angle(diff)\n\n final_complex_spec = transforms.from_magphase(mag_specgram, angles)\n return istft_dec(final_complex_spec)\n\n\ndef misi(\n mixture_wav,\n mag_specgrams,\n stft_enc,\n angles=None,\n istft_dec=None,\n n_iter=6,\n momentum=0.0,\n src_weights=None,\n dim=1,\n):\n \"\"\"Jointly estimates matching phase from magnitude spectograms using the\n Multiple Input Spectrogram Inversion (MISI) algorithm [1].\n\n Args:\n mixture_wav (torch.Tensor): (batch, time)\n mag_specgrams (torch.Tensor): (batch, n_src, freq, frames) as\n returned by `Encoder(STFTFB)`, the magnitude spectrograms to be\n jointly inverted using MISI (modified or not).\n stft_enc (Encoder[STFTFB]): The `Encoder(STFTFB())` object that was\n used to compute the input `mag_spec`.\n angles (None or Tensor): Angles to use to initialize the algorithm.\n If None (default), angles are init with uniform ditribution.\n istft_dec (None or Decoder[STFTFB]): Optional Decoder to use to get\n back to the time domain. If None (default), a perfect\n reconstruction Decoder is built from `stft_enc`.\n n_iter (int): Number of MISI iterations to run.\n momentum (float): Momentum on updates (this argument comes from\n GriffinLim). Defaults to 0 as it was never proposed anywhere.\n src_weights (None or torch.Tensor): Consistency weight for each source.\n Shape needs to be broadcastable to `istft_dec(mag_specgrams)`.\n We make sure that the weights sum up to 1 along dim `dim`.\n If `src_weights` is None, compute them based on relative power.\n dim (int): Axis which contains the sources in `mag_specgrams`.\n Used for consistency constraint.\n\n Returns:\n torch.Tensor: estimated waveforms of shape (batch, n_src, time).\n\n Examples\n >>> stft = Encoder(STFTFB(n_filters=256, kernel_size=256, stride=128))\n >>> wav = torch.randn(2, 3, 8000)\n >>> specs = stft(wav)\n >>> masked_specs = specs * torch.sigmoid(torch.randn_like(specs))\n >>> mag = transforms.mag(masked_specs, -2)\n >>> est_wav = misi(wav.sum(1), mag, stft, n_iter=32)\n\n References\n [1] Gunawan and Sen, \"Iterative Phase Estimation for the Synthesis of\n Separated Sources From Single-Channel Mixtures,\" in IEEE Signal\n Processing Letters, 2010.\n [2] Wang, LeRoux et al. “End-to-End Speech Separation with Unfolded\n Iterative Phase Reconstruction.” Interspeech 2018 (2018)\n \"\"\"\n # We can create perfect iSTFT from STFT Encoder\n if istft_dec is None:\n # Compute window for perfect resynthesis\n syn_win = perfect_synthesis_window(stft_enc.filterbank.window, stft_enc.stride)\n istft_dec = Decoder(STFTFB(**stft_enc.get_config(), window=syn_win))\n\n # If no intitial phase is provided initialize uniformly\n if angles is None:\n angles = 2 * math.pi * torch.rand_like(mag_specgrams, device=mag_specgrams.device)\n # wav_dim is used in mixture_consistency.\n # Transform spec src dim to wav src dim for positive and negative dim\n wav_dim = dim if dim >= 0 else dim + 1\n\n # We forward/backward the mixture through STFT to have matching shapes\n # with the input spectrograms as well as account for potential modulations\n # if the window were not chosen to enable perfect reconstruction.\n mixture_wav = istft_dec(stft_enc(mixture_wav))\n\n # Initialize rebuilt (useful to use momentum)\n rebuilt = 0.0\n for _ in range(n_iter):\n prev_built = rebuilt\n # Go to the time domain\n complex_specgram = transforms.from_magphase(mag_specgrams, angles)\n wavs = istft_dec(complex_specgram)\n # Make wavs sum up to the mixture\n consistent_wavs = mixture_consistency(\n mixture_wav, wavs, src_weights=src_weights, dim=wav_dim\n )\n # Back to TF domain\n rebuilt = stft_enc(consistent_wavs)\n # Update phase estimates (with momentum). Keep the momentum here\n # in case. Was shown useful in GF, might be here. We'll see.\n diff = rebuilt - momentum / (1 + momentum) * prev_built\n angles = transforms.angle(diff)\n # Final source estimates\n final_complex_spec = transforms.from_magphase(mag_specgrams, angles)\n return istft_dec(final_complex_spec)\n",
"import torch\nfrom .. import complex_nn\nfrom ..filterbanks.transforms import from_torchaudio\nfrom ..masknn.recurrent import DCCRMaskNet\nfrom .dcunet import BaseDCUNet\n\n\nclass DCCRNet(BaseDCUNet):\n \"\"\"DCCRNet as proposed in [1].\n\n Args:\n architecture (str): The architecture to use, must be \"DCCRN-CL\".\n stft_kernel_size (int): STFT frame length to use\n stft_stride (int, optional): STFT hop length to use.\n sample_rate (float): Sampling rate of the model.\n masknet_kwargs (optional): Passed to :class:`DCCRMaskNet`\n\n References\n - [1] : \"DCCRN: Deep Complex Convolution Recurrent Network for Phase-Aware Speech Enhancement\",\n Yanxin Hu et al. https://arxiv.org/abs/2008.00264\n \"\"\"\n\n masknet_class = DCCRMaskNet\n\n def __init__(self, *args, stft_kernel_size=512, **masknet_kwargs):\n masknet_kwargs.setdefault(\"n_freqs\", stft_kernel_size // 2)\n super().__init__(\n *args,\n stft_kernel_size=stft_kernel_size,\n **masknet_kwargs,\n )\n\n def forward_encoder(self, wav):\n tf_rep = self.encoder(wav)\n # Remove Nyquist frequency bin\n return complex_nn.as_torch_complex(tf_rep)[..., :-1, :]\n\n def apply_masks(self, tf_rep, est_masks):\n masked_tf_rep = est_masks * tf_rep.unsqueeze(1)\n # Pad Nyquist frequency bin\n return from_torchaudio(\n torch.view_as_real(torch.nn.functional.pad(masked_tf_rep, (0, 0, 0, 1)))\n )\n"
] | [
[
"torch.rand_like"
],
[
"torch.nn.functional.pad"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
RJRL12138/Regression-Examples | [
"8819818e74395d98a9cd6d7fb7ef06f316a8c233"
] | [
"dataHandler.py"
] | [
"import pandas as pd\nfrom sklearn.model_selection import train_test_split\n\nclass DataLoader:\n def __init__(self):\n self.dataset = None\n self.sensor = None\n self.target = None\n\n def load(self,file,isTest=False):\n if not isTest:\n print(\"loading\")\n self.dataset = pd.read_csv(file)\n print(\"loaded\")\n self.target = self.dataset[['target_carbon_monoxide', 'target_benzene', 'target_nitrogen_oxides']]\n self.sensor = self.dataset[list(self.dataset.columns[1:-3])]\n self.sensor.columns = ['deg_C', 'rel_h', 'abs_h','s_1', 's_2', 's_3', 's_4', 's_5']\n else:\n print(\"loading test files\")\n self.dataset = pd.read_csv(file)\n print(\"Test files loaded\")\n self.sensor = self.dataset[list(self.dataset.columns[1:])]\n self.sensor.columns = ['deg_C', 'rel_h', 'abs_h', 's_1', 's_2', 's_3', 's_4', 's_5']\n\n def process(self):\n col = ['s_1', 's_2', 's_3', 's_4', 's_5']\n df = self.sensor[col].values/1000\n self.sensor.update(pd.DataFrame(df))\n\n\n def split(self):\n if type(self.target) == None:\n print(\"This is test data\")\n return\n X_train, X_test, y_train, y_test = \\\n train_test_split(self.sensor, self.target, test_size=0.33, random_state=42)\n return X_train, X_test, y_train, y_test\n\n"
] | [
[
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
dataminer996/DSTC10_Track3_QS_Goal_Diggers | [
"24fe45c9a7098cf21c3278758fa8d9d073644a36",
"24fe45c9a7098cf21c3278758fa8d9d073644a36",
"24fe45c9a7098cf21c3278758fa8d9d073644a36",
"24fe45c9a7098cf21c3278758fa8d9d073644a36",
"24fe45c9a7098cf21c3278758fa8d9d073644a36"
] | [
"task4/generate/generagefeature/tools/test_sg_net.py",
"task4/generate/generagefeature/from_system_bin.py",
"task4/generate/generagefeature/scene_graph_benchmark/scene_parser.py",
"task4/retrieval/oscar_retri_v1/oscar/run_genanswer.py",
"task4/generate/generagefeature/track3_saveobj_rep.py"
] | [
"# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n# Copyright (c) 2021 Microsoft Corporation. Licensed under the MIT license. \n# Set up custom environment before nearly anything else is imported\n# NOTE: this should be the first import (no not reorder)\nimport sys\nimport os\nsys.path.append(os.getcwd())\nfrom maskrcnn_benchmark.utils.env import setup_environment # noqa F401 isort:skip\n\nimport argparse\nimport os\nimport json\n\nimport torch\nfrom maskrcnn_benchmark.config import cfg\nfrom scene_graph_benchmark.config import sg_cfg\nfrom maskrcnn_benchmark.data import make_data_loader\nfrom maskrcnn_benchmark.data.datasets.utils.load_files import config_dataset_file\nfrom maskrcnn_benchmark.engine.inference import inference\nfrom scene_graph_benchmark.scene_parser import SceneParser\nfrom scene_graph_benchmark.AttrRCNN import AttrRCNN\nfrom maskrcnn_benchmark.utils.checkpoint import DetectronCheckpointer\nfrom maskrcnn_benchmark.utils.collect_env import collect_env_info\nfrom maskrcnn_benchmark.utils.comm import synchronize, get_rank\nfrom maskrcnn_benchmark.utils.logger import setup_logger\nfrom maskrcnn_benchmark.utils.miscellaneous import mkdir\n\n\ndef run_test(cfg, model, distributed, model_name):\n #print(\"model ===================\",model)\n if distributed and hasattr(model, 'module'):\n model = model.module\n torch.cuda.empty_cache() # TODO check if it helps\n iou_types = (\"bbox\",)\n if cfg.MODEL.MASK_ON:\n iou_types = iou_types + (\"segm\",)\n if cfg.MODEL.KEYPOINT_ON:\n iou_types = iou_types + (\"keypoints\",)\n output_folders = [None] * len(cfg.DATASETS.TEST)\n dataset_names = cfg.DATASETS.TEST\n if cfg.OUTPUT_DIR:\n if len(dataset_names) == 1:\n output_folder = os.path.join(\n cfg.OUTPUT_DIR, \"inference\",\n os.path.splitext(model_name)[0]\n )\n mkdir(output_folder)\n output_folders = [output_folder]\n else:\n for idx, dataset_name in enumerate(dataset_names):\n dataset_name1 = dataset_name.replace('/', '_')\n output_folder = os.path.join(\n cfg.OUTPUT_DIR, \"inference\",\n dataset_name1,\n os.path.splitext(model_name)[0]\n )\n mkdir(output_folder)\n output_folders[idx] = output_folder\n data_loaders_val = make_data_loader(cfg, is_train=False, is_distributed=distributed)\n labelmap_file = config_dataset_file(cfg.DATA_DIR, cfg.DATASETS.LABELMAP_FILE)\n for output_folder, dataset_name, data_loader_val in zip(output_folders, dataset_names, data_loaders_val):\n results = inference(\n model,\n cfg,\n data_loader_val,\n dataset_name=dataset_name,\n iou_types=iou_types,\n box_only=False if cfg.MODEL.RETINANET_ON else cfg.MODEL.RPN_ONLY,\n bbox_aug=cfg.TEST.BBOX_AUG.ENABLED,\n device=cfg.MODEL.DEVICE,\n expected_results=cfg.TEST.EXPECTED_RESULTS,\n expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL,\n output_folder=output_folder,\n skip_performance_eval=cfg.TEST.SKIP_PERFORMANCE_EVAL,\n labelmap_file=labelmap_file,\n save_predictions=cfg.TEST.SAVE_PREDICTIONS,\n )\n print(\"++++++++++++++++++++++++++++++++\")\n print(\"result\",results)\n print(\"++++++++++++++++++++++++++++++++\")\n # renaming box_proposals metric to rpn_proposals if RPN_ONLY is True\n if results and 'box_proposal' in results and cfg.MODEL.RPN_ONLY:\n results['rpn_proposal'] = results.pop('box_proposal')\n\n if results and output_folder:\n results_path = os.path.join(output_folder, \"results.json\")\n # checking if this file already exists and only updating tasks\n # that are already present. This is useful for including\n # e.g. RPN_ONLY metrics\n if os.path.isfile(results_path):\n with open(results_path, 'rt') as fin:\n old_results = json.load(fin)\n old_results.update(results)\n results = old_results\n with open(results_path, 'wt') as fout:\n json.dump(results, fout)\n\n synchronize()\n\n # evaluate attribute detection\n if not cfg.MODEL.RPN_ONLY and cfg.MODEL.ATTRIBUTE_ON and (not cfg.TEST.SKIP_PERFORMANCE_EVAL):\n data_loaders_val = make_data_loader(cfg, is_train=False, is_distributed=distributed)\n for output_folder, dataset_name, data_loader_val in zip(\n output_folders, dataset_names, data_loaders_val\n ):\n results_attr = inference(\n model,\n cfg,\n data_loader_val,\n dataset_name=dataset_name,\n iou_types=iou_types,\n box_only=False if cfg.MODEL.RETINANET_ON else cfg.MODEL.RPN_ONLY,\n device=cfg.MODEL.DEVICE,\n expected_results=cfg.TEST.EXPECTED_RESULTS,\n expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL,\n output_folder=output_folder,\n skip_performance_eval=cfg.TEST.SKIP_PERFORMANCE_EVAL,\n labelmap_file=labelmap_file,\n save_predictions=cfg.TEST.SAVE_PREDICTIONS,\n eval_attributes=True,\n )\n print(\"++++++++++++++++++++++++++++++++\")\n print(\"result_attr\",results_attr)\n print(\"++++++++++++++++++++++++++++++++\")\n\n if results_attr and output_folder:\n results_path = os.path.join(output_folder, \"results.json\")\n # checking if this file already exists and only updating tasks\n # that are already present. This is useful for including\n # e.g. RPN_ONLY metrics\n if os.path.isfile(results_path):\n with open(results_path, 'rt') as fin:\n old_results = json.load(fin)\n old_results.update(results_attr)\n results_attr = old_results\n with open(results_path, 'wt') as fout:\n json.dump(results_attr, fout)\n\n synchronize()\n\n\ndef main():\n parser = argparse.ArgumentParser(description=\"PyTorch Object Detection Inference\")\n parser.add_argument(\n \"--config-file\",\n default=\"/private/home/fmassa/github/detectron.pytorch_v2/configs/e2e_faster_rcnn_R_50_C4_1x_caffe2.yaml\",\n metavar=\"FILE\",\n help=\"path to config file\",\n )\n parser.add_argument(\"--local_rank\", type=int, default=0)\n parser.add_argument(\n \"--ckpt\",\n help=\"The path to the checkpoint for test, default is the latest checkpoint.\",\n default=None,\n )\n parser.add_argument(\n \"opts\",\n help=\"Modify config options using the command-line\",\n default=None,\n nargs=argparse.REMAINDER,\n )\n\n args = parser.parse_args()\n\n num_gpus = int(os.environ[\"WORLD_SIZE\"]) if \"WORLD_SIZE\" in os.environ else 1\n args.distributed = num_gpus > 1\n\n cfg.set_new_allowed(True)\n cfg.merge_from_other_cfg(sg_cfg)\n cfg.set_new_allowed(False)\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n cfg.freeze()\n\n if args.distributed:\n torch.cuda.set_device(args.local_rank)\n torch.distributed.init_process_group(\n backend=cfg.DISTRIBUTED_BACKEND, init_method=\"env://\"\n )\n synchronize()\n\n save_dir = \"\"\n logger = setup_logger(\"maskrcnn_benchmark\", save_dir, get_rank())\n logger.info(\"Using {} GPUs\".format(num_gpus))\n logger.info(cfg)\n\n logger.info(\"Collecting env info (might take some time)\")\n logger.info(\"\\n\" + collect_env_info())\n\n if cfg.MODEL.META_ARCHITECTURE == \"SceneParser\":\n model = SceneParser(cfg)\n elif cfg.MODEL.META_ARCHITECTURE == \"AttrRCNN\":\n model = AttrRCNN(cfg)\n model.to(cfg.MODEL.DEVICE)\n\n output_dir = cfg.OUTPUT_DIR\n checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir)\n ckpt = cfg.MODEL.WEIGHT if args.ckpt is None else args.ckpt\n _ = checkpointer.load(ckpt, use_latest=args.ckpt is None)\n model_name = os.path.basename(ckpt)\n print(\"==================================\")\n # print(\"cfg\",cfg)\n # print(\"model_name\",model_name)\n # print(\"args.distributed\",args.distributed)\n print(\"==================================\")\n run_test(cfg, model, args.distributed, model_name)\n\n\nif __name__ == \"__main__\":\n main()\n",
"import json\r\nimport jsonpath\r\nimport torch\r\nimport numpy as np\r\nimport pickle\r\nimport os, sys\r\nimport argparse\r\nimport copy\r\nimport numpy as np\r\n\r\ndef from_system_bin(dir_json, dir_binfile, dir_output):\r\n def getNonRepeatList(data):\r\n new_data = []\r\n for i in range(len(data)):\r\n if data[i] not in new_data:\r\n new_data.append(data[i])\r\n return new_data\r\n def get_dict_value(date, keys, default=None):\r\n # default=None，在key值不存在的情况下，返回None\r\n keys_list = keys.split('.')\r\n # 以“.”为间隔，将字符串分裂为多个字符串，其实字符串为字典的键，保存在列表keys_list里\r\n if isinstance(date, dict):\r\n # 如果传入的数据为字典\r\n dictionary = dict(date)\r\n # 初始化字典\r\n for i in keys_list:\r\n # 按照keys_list顺序循环键值\r\n try:\r\n if dictionary.get(i) != None:\r\n dict_values = dictionary.get(i)\r\n # 如果键对应的值不为空，返回对应的值\r\n elif dictionary.get(i) == None:\r\n dict_values = dictionary.get(int(i))\r\n # 如果键对应的值为空，将字符串型的键转换为整数型，返回对应的值\r\n except:\r\n return default\r\n # 如果字符串型的键转换整数型错误，返回None\r\n dictionary = dict_values\r\n return dictionary\r\n else:\r\n # 如果传入的数据为非字典\r\n try:\r\n dictionary = dict(eval(date))\r\n # 如果传入的字符串数据格式为字典格式，转字典类型，不然返回None\r\n if isinstance(dictionary, dict):\r\n for i in keys_list:\r\n # 按照keys_list顺序循环键值\r\n try:\r\n if dictionary.get(i) != None:\r\n dict_values = dictionary.get(i)\r\n # 如果键对应的值不为空，返回对应的值\r\n elif dictionary.get(i) == None:\r\n dict_values = dictionary.get(int(i))\r\n # 如果键对应的值为空，将字符串型的键转换为整数型，返回对应的值\r\n except:\r\n return default\r\n # 如果字符串型的键转换整数型错误，返回None\r\n dictionary = dict_values\r\n return dictionary\r\n except:\r\n return default\r\n def get_json_value(json_data, key_name):\r\n key_value = jsonpath.jsonpath(json_data, '$..{key_name}'.format(key_name=key_name))\r\n return key_value\r\n\r\n with open(str(dir_binfile), 'rb') as f:\r\n binfile = pickle.load(f)\r\n with open(dir_json, 'rb') as j:\r\n jsonfile = json.load(j)\r\n\r\n # 1.打开bin文件\r\n # 2.获取did/拆解did\r\n # 3.生成json文件的from_system列表\r\n # 4.生成所有的s_object列表\r\n # 5.根据did生成的round和track在from_system列表中查找，如果是1，则获取s_object\r\n # 6.根据s_object对应bin文件中的all_object获取需要的下标\r\n # 7.生成新的objectid以及对应的bbox..列表\r\n # 8.替换bin文件中的内容\r\n # 9.dump出新的文件\r\n\r\n # 生成所有的s_object/from_system（通过列表就可以访问）\r\n dialogue = get_json_value(jsonfile, 'dialogue')\r\n dialogue_data = get_json_value(jsonfile, 'dialogue_data')[0]\r\n count = list(range(len(dialogue)))\r\n s_object_all = []\r\n from_system_all = []\r\n for i in count:\r\n # 统计这一轮所有的对话数量\r\n dialogue = get_dict_value(dialogue_data[i], 'dialogue', None)\r\n length_thisround = np.arange(len(dialogue))\r\n s_object_thisround = []\r\n from_system_thisround = []\r\n for j in length_thisround:\r\n s_object_thistrack = get_json_value(dialogue[j], 's_objects')\r\n s_object_thisround.append(s_object_thistrack[0])\r\n from_system_thistrack = get_json_value(dialogue[j], 'from_system')\r\n from_system_thisround.append(from_system_thistrack[0])\r\n s_object_thisround.append([s_object_thistrack])\r\n from_system_thisround.append(from_system_thistrack)\r\n s_object_all.append(s_object_thisround)\r\n from_system_all.append(from_system_thisround)\r\n\r\n\r\n bin_length = list(range(len(binfile)))\r\n for a in bin_length:\r\n binfile[a] = list(binfile[a])\r\n\r\n did = binfile[a][2]\r\n round = int(did / 100)\r\n track = did % 100\r\n\r\n objectid = binfile[a][3]\r\n type_all = binfile[a][4]\r\n bbox = binfile[a][5]\r\n label = binfile[a][6]\r\n image_feature = binfile[a][7]\r\n\r\n #if did != 166301:\r\n # continue\r\n #print('object_id',objectid)\r\n if from_system_all[round][track] == str(1):\r\n type_new = []\r\n bbox_new = []\r\n label_new = []\r\n id_new = []\r\n feature_new = []\r\n feature_new.append(image_feature[0])\r\n object_new = s_object_all[round][track]\r\n #print(\"sobjectid\",object_new)\r\n objectid_length = list(range(len(objectid)))\r\n findindexs = []\r\n #print(\"objectid_length\",objectid_length)\r\n for b in objectid_length:\r\n if objectid[b] in object_new:\r\n findindexs.append(b)\r\n #print(\"objectid_length remove\",findindexs)\r\n \r\n for c in findindexs:\r\n type_new.append(type_all[c])\r\n bbox_new.append(bbox[c])\r\n label_new.append(label[c])\r\n id_new.append(objectid[c])\r\n feature_new.append(image_feature[c+1])\r\n\r\n binfile[a][3] = np.array(id_new)\r\n binfile[a][4] = np.array(type_new)\r\n binfile[a][5] = np.array(bbox_new)\r\n binfile[a][6] = np.array(label_new)\r\n binfile[a][7] = np.array(feature_new)\r\n #print('id_new',id_new)\r\n binfile[a] = tuple(binfile[a])\r\n\r\n\r\n with open(dir_output, 'wb') as save:\r\n pickle.dump(binfile, save)\r\n\r\n print('更换完毕')\r\n\r\ndir_json = sys.argv[1]\r\ndir_binfile = sys.argv[2]\r\ndir_output = sys.argv[3]\r\n\r\nfrom_system_bin(dir_json, dir_binfile, dir_output)\r\n",
"# Copyright (c) 2021 Microsoft Corporation. Licensed under the MIT license. \n\"\"\"\nImplements the Scene Parser framework\n\"\"\"\nimport numpy as np\nimport torch\n\nfrom maskrcnn_benchmark.structures.bounding_box import BoxList\nfrom maskrcnn_benchmark.structures.image_list import to_image_list\nfrom maskrcnn_benchmark.modeling.detector.generalized_rcnn import GeneralizedRCNN\nfrom .relation_head.relation_head import build_roi_relation_head\nfrom maskrcnn_benchmark.modeling.backbone import build_backbone\nfrom .relation_head.roi_relation_box_feature_extractors import make_roi_relation_box_feature_extractor\nfrom .attribute_head.attribute_head import build_roi_attribute_head\n\n\nclass SceneParserOutputs(object):\n \"\"\"\n Structure that holds SceneParser output object predicitions and relation predictions,\n and provide .to function to be able to move all nececssary tensors\n between gpu and cpu. (Inspired from SCANEmbedding)\n \"\"\"\n def __init__(self, predictions, prediction_pairs=None):\n self.predictions = predictions\n self.prediction_pairs = prediction_pairs\n\n def to(self, *args, **kwargs):\n cast_predictions = self.predictions.to(*args, *kwargs)\n if self.prediction_pairs is not None:\n cast_prediction_pairs = self.prediction_pairs.to(*args, *kwargs)\n else:\n cast_prediction_pairs = None\n return SceneParserOutputs(cast_predictions, cast_prediction_pairs)\n\n\nSCENE_PAESER_DICT = [\"sg_baseline\", \"sg_imp\", \"sg_msdn\", \"sg_grcnn\", \"sg_reldn\", \"sg_neuralmotif\"]\n\n\nclass SceneParser(GeneralizedRCNN):\n \"\"\"\n Main class for Generalized Relation R-CNN.\n It consists of three main parts:\n - backbone\n - rpn\n - object detection (roi_heads)\n - Scene graph parser model: IMP, MSDN, MOTIF, graph-rcnn, ect\n \"\"\"\n\n def __init__(self, cfg):\n super(SceneParser, self).__init__(cfg)\n self.cfg = cfg\n self.device = cfg.MODEL.DEVICE\n self.detector_pre_calculated = self.cfg.MODEL.ROI_RELATION_HEAD.DETECTOR_PRE_CALCULATED\n self.detector_force_boxes = self.cfg.MODEL.ROI_BOX_HEAD.FORCE_BOXES\n self.cfg_check()\n \n feature_dim = self.backbone.out_channels\n if not self.cfg.MODEL.ROI_RELATION_HEAD.SHARE_CONV_BACKBONE:\n self.rel_backbone = build_backbone(cfg)\n feature_dim = self.rel_backbone.out_channels\n print(\"=============iSceneParser\")\n # TODO: add force_relations logic\n self.force_relations = cfg.MODEL.ROI_RELATION_HEAD.FORCE_RELATIONS\n if cfg.MODEL.RELATION_ON and self.cfg.MODEL.ROI_RELATION_HEAD.ALGORITHM in SCENE_PAESER_DICT:\n self.relation_head = build_roi_relation_head(cfg, feature_dim)\n \n if cfg.MODEL.ATTRIBUTE_ON:\n self.attribute_head = build_roi_attribute_head(cfg, feature_dim)\n\n # self._freeze_components(self.cfg)\n for p in self.backbone.parameters():\n p.requires_grad = False\n for p in self.rpn.parameters():\n p.requires_grad = False\n for p in self.roi_heads.parameters():\n p.requires_grad = False\n \n if not self.cfg.MODEL.ROI_RELATION_HEAD.SHARE_BOX_FEATURE_EXTRACTOR:\n if self.cfg.MODEL.ROI_RELATION_HEAD.SEPERATE_SO_FEATURE_EXTRACTOR:\n self.subj_feature_extractor = make_roi_relation_box_feature_extractor(cfg, feature_dim)\n self.obj_feature_extractor = make_roi_relation_box_feature_extractor(cfg, feature_dim)\n else:\n self.obj_feature_extractor = make_roi_relation_box_feature_extractor(cfg, feature_dim)\n\n def cfg_check(self):\n if self.cfg.MODEL.ROI_RELATION_HEAD.MODE=='predcls':\n assert self.cfg.MODEL.ROI_RELATION_HEAD.DETECTOR_PRE_CALCULATED==False and self.cfg.MODEL.ROI_RELATION_HEAD.FORCE_RELATIONS==False\n if self.cfg.MODEL.ROI_RELATION_HEAD.MODE=='sgcls':\n assert self.cfg.MODEL.ROI_BOX_HEAD.FORCE_BOXES==True and self.cfg.MODEL.ROI_RELATION_HEAD.DETECTOR_PRE_CALCULATED==False\n\n def to(self, device, **kwargs):\n super(SceneParser, self).to(device, **kwargs)\n if self.cfg.MODEL.RELATION_ON:\n self.relation_head.to(device, **kwargs)\n if self.cfg.MODEL.ATTRIBUTE_ON:\n self.attribute_head.to(device, **kwargs)\n # if self.detector_pre_calculated:\n # self.backbone.to('cpu')\n # self.rpn.to('cpu')\n # self.roi_heads.to('cpu')\n\n def _post_processing_constrained(self, result_obj, result_pred):\n \"\"\"\n Arguments:\n object_predictions, predicate_predictions\n\n Returns:\n sort the object-predicate triplets, and output the top\n \"\"\"\n result_obj_new, result_pred_new = [], []\n assert len(result_obj) == len(result_pred), \"object list must have equal number to predicate list\"\n for result_obj_i, result_pred_i in zip(result_obj, result_pred):\n obj_scores = result_obj_i.get_field(\"scores\")\n rel_inds = result_pred_i.get_field(\"idx_pairs\")\n pred_scores = result_pred_i.get_field(\"scores\")\n scores = torch.stack((\n obj_scores[rel_inds[:,0]],\n obj_scores[rel_inds[:,1]],\n pred_scores[:,1:].max(1)[0]\n ), 1).prod(1)\n scores_sorted, order = scores.sort(0, descending=True)\n result_pred_i = result_pred_i[order[:self.cfg.MODEL.ROI_RELATION_HEAD.TRIPLETS_PER_IMG]]\n result_obj_new.append(result_obj_i)\n\n result_pred_i.add_field('labels', result_pred_i.get_field(\"scores\")[:, 1:].argmax(dim=1)) # not include background\n result_pred_i.add_field('scores_all', result_pred_i.get_field('scores'))\n result_pred_i.add_field('scores', scores[order[:self.cfg.MODEL.ROI_RELATION_HEAD.TRIPLETS_PER_IMG]])\n # filter out bad prediction\n inds = result_pred_i.get_field('scores') > self.cfg.MODEL.ROI_RELATION_HEAD.POSTPROCESS_SCORE_THRESH\n result_pred_i = result_pred_i[inds]\n\n result_pred_new.append(result_pred_i)\n return result_obj_new, result_pred_new\n\n def _post_processing_unconstrained(self, result_obj, result_pred):\n \"\"\"\n Arguments:\n object_predictions, predicate_predictions\n\n Returns:\n sort the object-predicate triplets, and output the top\n \"\"\"\n result_obj_new, result_pred_new = [], []\n assert len(result_obj) == len(result_pred), \"object list must have equal number to predicate list\"\n for result_obj_i, result_pred_i in zip(result_obj, result_pred):\n obj_scores = result_obj_i.get_field(\"scores\").cpu().numpy()\n rel_inds = result_pred_i.get_field(\"idx_pairs\").cpu().numpy()\n pred_scores = result_pred_i.get_field(\"scores\").cpu().numpy()[:, 1:]\n \n det_labels_prd = np.argsort(-pred_scores, axis=1)\n det_scores_prd = -np.sort(-pred_scores, axis=1)\n\n det_scores_so = obj_scores[rel_inds[:,0]] * obj_scores[rel_inds[:,1]]\n det_scores_spo = det_scores_so[:, None] * det_scores_prd[:, :2]\n\n det_scores_inds = argsort_desc(det_scores_spo)[:self.cfg.MODEL.ROI_RELATION_HEAD.TRIPLETS_PER_IMG]\n\n result_labels = det_labels_prd[det_scores_inds[:, 0], det_scores_inds[:, 1]]\n\n result_pred_i = result_pred_i[det_scores_inds[:, 0]]\n result_pred_i.add_field('labels', torch.from_numpy(result_labels))\n result_pred_i.add_field('scores_all', result_pred_i.get_field('scores'))\n result_pred_i.add_field('scores', torch.from_numpy(det_scores_spo[det_scores_inds[:, 0], det_scores_inds[:, 1]]))\n # filter out bad prediction\n inds = result_pred_i.get_field('scores') > self.cfg.MODEL.ROI_RELATION_HEAD.POSTPROCESS_SCORE_THRESH\n result_pred_i = result_pred_i[inds]\n \n result_obj_new.append(result_obj_i)\n result_pred_new.append(result_pred_i)\n return result_obj_new, result_pred_new\n\n def forward(self, images, targets=None):\n \"\"\"\n Arguments:\n images (list[Tensor] or ImageList): images to be processed\n targets (list[BoxList]): ground-truth boxes present in the image (optional)\n We can assume that gt_boxlist contains two other fields:\n \"relation_labels\": list of [subj_id, obj_id, predicate_category]\n \"pred_labels\": n*n matrix with predicate_category (including BG) as values.\n\n Returns:\n result (list[BoxList] or dict[Tensor]): the output from the model.\n During training, it returns a dict[Tensor] which contains the losses.\n During testing, it returns list[BoxList] contains additional fields\n like `scores`, `labels` and `mask` (for Mask R-CNN models).\n\n \"\"\"\n if self.training and targets is None:\n raise ValueError(\"In training mode, targets should be passed\")\n if self.force_relations and targets is None:\n # note targets cannot be None but could have 0 box.\n raise ValueError(\"In force_relations setting, targets should be passed\")\n # set the object detector to evaluation mode and run the object detection model\n self.backbone.eval()\n self.rpn.eval()\n self.roi_heads.eval()\n\n images = to_image_list(images)\n if targets:\n if self.detector_pre_calculated:\n predictions = [prediction.to(self.device) for (target, prediction) in targets if prediction is not None]\n targets = [target.to(self.device) for (target, prediction) in targets if target is not None]\n else:\n targets = [target.to(self.device)\n for target in targets if target is not None]\n\n scene_parser_losses = {}\n\n if not self.detector_pre_calculated:\n features = self.backbone(images.tensors)\n print(\"============================screenfeatures\",features.shape)\n\n proposals, proposal_losses = self.rpn(images, features, targets)\n\n if self.detector_force_boxes:\n proposals = [BoxList(target.bbox, target.size, target.mode) for target in targets]\n x, predictions, detector_losses = self.roi_heads(features, proposals, targets)\n else:\n x, predictions, detector_losses = self.roi_heads(features, proposals, targets)\n scene_parser_losses.update(detector_losses)\n else:\n proposal_losses = {}\n if targets is not None or len(targets) != 0:\n predictions = self.roi_heads['box'].loss_evaluator.prepare_labels(predictions, targets)\n \n if (self.force_relations or self.cfg.MODEL.ROI_RELATION_HEAD.MODE=='predcls') and not self.training:\n predictions = targets\n for pred in predictions:\n pred.add_field('scores', torch.tensor([1.0]*len(pred)).to(self.device))\n if self.cfg.TEST.OUTPUT_FEATURE:\n gt_labels = pred.get_field('labels')\n gt_pseudo_scores_all = torch.zeros(len(pred), self.cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES).to(gt_labels.device)\n gt_pseudo_scores_all.scatter_(1, gt_labels.unsqueeze(0).view(-1, 1), 1)\n pred.add_field('scores_all', gt_pseudo_scores_all)\n gt_boxes = pred.bbox\n gt_pseudo_boxes_all = gt_boxes.unsqueeze(1).repeat(1, self.cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES, 1)\n pred.add_field('boxes_all', gt_pseudo_boxes_all)\n if self.cfg.TEST.OUTPUT_FEATURE:\n gt_features = self.roi_heads.box.feature_extractor(features, predictions)\n if gt_features.ndimension() == 4:\n gt_features = torch.nn.functional.adaptive_avg_pool2d(gt_features, 1)\n gt_features = gt_features.view(gt_features.size(0), -1)\n gt_boxes_per_image = [len(box) for box in predictions]\n assert sum(gt_boxes_per_image)==len(gt_features), \"gt_boxes_per_image and len(gt_features) do not match!\"\n gt_features = gt_features.split(gt_boxes_per_image, dim=0)\n for pred, gt_feature in zip(predictions, gt_features):\n pred.add_field('box_features', gt_feature)\n\n if not self.cfg.MODEL.ROI_RELATION_HEAD.SHARE_CONV_BACKBONE:\n features = self.rel_backbone(images.tensors)\n else:\n features = [feature.detach() for feature in features]\n\n # relation classification network\n # optimization: during training, if we share the feature extractor between\n # the box and the relation heads, then we can reuse the features already computed\n if not self.cfg.MODEL.ROI_RELATION_HEAD.SHARE_BOX_FEATURE_EXTRACTOR:\n obj_features = self.obj_feature_extractor(features, predictions, use_relu=False)\n if obj_features.ndimension() == 4:\n obj_features = torch.nn.functional.adaptive_avg_pool2d(obj_features, 1)\n obj_features = obj_features.view(obj_features.size(0), -1)\n boxes_per_image = [len(box) for box in predictions]\n obj_features = obj_features.split(boxes_per_image, dim=0)\n for prediction, obj_feature in zip(predictions, obj_features):\n prediction.add_field('box_features', obj_feature)\n\n if self.cfg.MODEL.ROI_RELATION_HEAD.SEPERATE_SO_FEATURE_EXTRACTOR:\n subj_features = self.subj_feature_extractor(features, predictions, use_relu=False)\n if subj_features.ndimension() == 4:\n subj_features = torch.nn.functional.adaptive_avg_pool2d(subj_features, 1)\n subj_features = subj_features.view(subj_features.size(0), -1)\n boxes_per_image = [len(box) for box in predictions]\n subj_features = subj_features.split(boxes_per_image, dim=0)\n for prediction, subj_feature, obj_feature in zip(predictions, subj_features, obj_features):\n prediction.add_field('subj_box_features', subj_feature)\n prediction.add_field('obj_box_features', obj_feature)\n\n if self.training:\n if not self.cfg.MODEL.ROI_RELATION_HEAD.SHARE_BOX_FEATURE_EXTRACTOR:\n gt_features = self.obj_feature_extractor(features, targets, use_relu=False)\n else:\n gt_features = self.roi_heads.box.feature_extractor(features, targets)\n if gt_features.ndimension() == 4:\n gt_features = torch.nn.functional.adaptive_avg_pool2d(gt_features, 1)\n gt_features = gt_features.view(gt_features.size(0), -1)\n gt_boxes_per_image = [len(box) for box in targets]\n assert sum(gt_boxes_per_image)==len(gt_features), \"gt_boxes_per_image and len(gt_features) do not match!\"\n gt_features = gt_features.split(gt_boxes_per_image, dim=0)\n for target, gt_feature in zip(targets, gt_features):\n target.add_field('box_features', gt_feature)\n target.add_field('gt_labels', target.get_field('labels'))\n # if self.cfg.TEST.OUTPUT_SCORES_ALL:\n # gt_labels = target.get_field('labels')\n # gt_pseudo_scores_all = torch.zeros(len(target), self.cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES).to(gt_labels.device)\n # gt_pseudo_scores_all.scatter_(1, gt_labels.unsqueeze(0).view(-1, 1), 1)\n # target.add_field('scores_all', gt_pseudo_scores_all)\n # gt_boxes = target.bbox\n # gt_pseudo_boxes_all = gt_boxes.unsqueeze(1).repeat(1, self.cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES, 1)\n # target.add_field('boxes_all', gt_pseudo_boxes_all)\n \n if self.cfg.MODEL.ROI_RELATION_HEAD.SEPERATE_SO_FEATURE_EXTRACTOR:\n gt_subj_features = self.subj_feature_extractor(features, targets, use_relu=False)\n if gt_subj_features.ndimension() == 4:\n gt_subj_features = torch.nn.functional.adaptive_avg_pool2d(gt_subj_features, 1)\n gt_subj_features = gt_subj_features.view(gt_subj_features.size(0), -1)\n gt_boxes_per_image = [len(box) for box in targets]\n gt_subj_features = gt_subj_features.split(gt_boxes_per_image, dim=0)\n for target, gt_subj_feature, gt_feature in zip(targets, gt_subj_features, gt_features):\n target.add_field('subj_box_features', gt_subj_feature)\n target.add_field('obj_box_features', gt_feature)\n \n # if not self.cfg.MODEL.ROI_RELATION_HEAD.SHARE_CONV_BACKBONE:\n # features = self.rel_backbone(images.tensors)\n # else:\n # features = [feature.detach() for feature in features]\n\n # The predictions_pred contains idx_pairs (M*2) and scores (M*Pred_Cat); see Jianwei's code\n # TODO: add force_relations logic\n # pdb.set_trace()\n x_pairs, prediction_pairs, relation_losses = self.relation_head(features, predictions, targets)\n # pdb.set_trace()\n scene_parser_losses.update(relation_losses)\n\n # attribute head\n if self.cfg.MODEL.ATTRIBUTE_ON:\n x_attr, predictions, attribute_losses = self.attribute_head(features, predictions, targets)\n\n if self.training:\n losses = {}\n losses.update(scene_parser_losses)\n losses.update(proposal_losses)\n if self.cfg.MODEL.ATTRIBUTE_ON:\n losses.update(attribute_losses)\n return losses\n\n # NOTE: if object scores are updated in rel_heads, we need to ensure detections are updated accordingly\n if self.cfg.MODEL.ROI_RELATION_HEAD.POSTPROCESS_METHOD == 'constrained':\n predictions, prediction_pairs = self._post_processing_constrained(predictions, prediction_pairs)\n else:\n predictions, prediction_pairs = self._post_processing_unconstrained(predictions, prediction_pairs)\n\n return [SceneParserOutputs(prediction, prediction_pair)\n for prediction, prediction_pair in zip(predictions, prediction_pairs)]\n\n\ndef argsort_desc(scores):\n \"\"\"\n Returns the indices that sort scores descending in a smart way\n :param scores: Numpy array of arbitrary size\n :return: an array of size [numel(scores), dim(scores)] where each row is the index you'd\n need to get the score.\n \"\"\"\n return np.column_stack(np.unravel_index(np.argsort(-scores.ravel()), scores.shape))\n",
"# Copyright (c) 2021 Microsoft Corporation. Licensed under the MIT license.\n\nimport os\nimport sys\nsys.path.append(os.getcwd())\nimport pickle\nimport argparse\nimport base64\nimport numpy as np\nimport os.path as op\nimport random, time, json\nimport torch\nimport torch.distributed as dist\nfrom torch.utils.data import Dataset\nfrom tqdm import tqdm\n\nfrom oscar.utils.logger import setup_logger\nfrom oscar.utils.tsv_file import TSVFile\nfrom oscar.utils.tsv_file_ops import (tsv_writer, concat_tsv_files,\n delete_tsv_files, reorder_tsv_keys)\nfrom oscar.utils.misc import (mkdir, set_seed, \n load_from_yaml_file, find_file_path_in_yaml)\nfrom oscar.utils.caption_evaluate import (ScstRewardCriterion)\n#from oscar.utils.caption_evaluate import (evaluate_on_coco_caption,\n # ScstRewardCriterion)\n\nfrom oscar.utils.cbs import ConstraintFilter, ConstraintBoxesReader\nfrom oscar.utils.cbs import FiniteStateMachineBuilder\nfrom oscar.modeling.modeling_bert import BertForImageCaptioning\nfrom transformersm.pytorch_transformers import BertTokenizer, BertConfig\nfrom transformersm.pytorch_transformers import AdamW, WarmupLinearSchedule, WarmupConstantSchedule\n\n\nclass CaptionTSVDataset(Dataset):\n def __init__(self, data_dir, tokenizer=None, add_od_labels=True,\n max_img_seq_length=50, max_seq_length=70, max_seq_a_length=40, \n is_train=True, mask_prob=0.15, max_masked_tokens=3, **kwargs):\n \"\"\"Constructor.\n Args:\n yaml file with all required data (image feature, caption, labels, etc)\n tokenizer: tokenizer for text processing.\n add_od_labels: whether to add labels from yaml file to BERT. \n max_img_seq_length: max image sequence length.\n max_seq_length: max text sequence length.\n max_seq_a_length: max caption sequence length.\n is_train: train or test mode.\n mask_prob: probability to mask a input token.\n max_masked_tokens: maximum number of tokens to be masked in one sentence.\n kwargs: other arguments.\n \"\"\"\n if 0:\n self.yaml_file = yaml_file\n self.cfg = load_from_yaml_file(yaml_file)\n self.root = op.dirname(yaml_file)\n self.label_file = find_file_path_in_yaml(self.cfg['label'], self.root)\n self.feat_file = find_file_path_in_yaml(self.cfg['feature'], self.root)\n self.caption_file = find_file_path_in_yaml(self.cfg.get('caption'), self.root)\n \n assert op.isfile(self.feat_file)\n if add_od_labels: assert op.isfile(self.label_file)\n if is_train: assert op.isfile(self.caption_file) and tokenizer is not None\n \n self.label_tsv = None if not self.label_file else TSVFile(self.label_file)\n self.feat_tsv = TSVFile(self.feat_file)\n self.captions = []\n if self.caption_file and op.isfile(self.caption_file):\n with open(self.caption_file, 'r') as f:\n self.captions = json.load(f)\n\n\n \n devfile = data_dir \n trainfile = data_dir\n print(\"datasheet file\",trainfile)\n\n with open(trainfile,'rb') as f:\n self.feature = pickle.load(f)\n random.shuffle(self.feature)\n print(\"datasheet example num\",len(self.feature))\n\n # with open(devfile,'rb') as f:\n # self.devfeature = pickle.load(f)\n # print(\"dev example num\",len(self.devfeature))\n\n\n self.tokenizer = tokenizer\n self.tensorizer = CaptionTensorizer(self.tokenizer, max_img_seq_length,\n max_seq_length, max_seq_a_length, mask_prob, max_masked_tokens,\n is_train=is_train)\n self.is_train = is_train\n self.kwargs = kwargs\n if 0:\n self.add_od_labels = add_od_labels\n self.image_keys = self.prepare_image_keys()\n self.key2index = self.prepare_image_key_to_index()\n self.key2captions = self.prepare_image_key_to_captions()\n\n def get_valid_tsv(self):\n # based on the order of file size\n if self.label_tsv:\n return self.label_tsv\n if self.feat_tsv:\n return self.feat_tsv\n\n def prepare_image_keys(self):\n tsv = self.get_valid_tsv()\n return [tsv.seek(i)[0] for i in range(tsv.num_rows())]\n\n def prepare_image_key_to_index(self):\n tsv = self.get_valid_tsv()\n return {tsv.seek(i)[0] : i for i in range(tsv.num_rows())}\n\n def prepare_image_key_to_captions(self):\n if self.captions:\n key2captions = {key: [] for key in self.image_keys}\n for cap in self.captions:\n key2captions[cap['image_id']].append(cap['caption'])\n return key2captions\n\n def get_image_index(self, idx):\n if self.is_train:\n img_cap_pair = self.captions[idx]\n img_key = img_cap_pair['image_id']\n return self.key2index[img_key]\n return idx\n\n def get_image_key(self, idx):\n img_idx = self.get_image_index(idx)\n return self.image_keys[img_idx]\n\n def get_image_features(self, img_idx):\n feat_info = json.loads(self.feat_tsv.seek(img_idx)[1])\n num_boxes = feat_info['num_boxes']\n features = np.frombuffer(base64.b64decode(feat_info['features']), np.float32\n ).reshape((num_boxes, -1))\n return torch.Tensor(features)\n\n def get_caption(self, index):\n # return self.key2captions[key]\n # if self.is_train:\n dialogue_final, scene_thisround,dialog_id, id_final, type_final, bbox_final, slotvalue_final, image_feature = self.feature[index]\n # else:\n # dialogue_final, scene_thisround,dialog_id, id_final, type_final, bbox_final, slotvalue_final, image_feature = self.devfeature[index]\n caption = dialogue_final[-1:]\n\n \n if self.is_train:\n return caption\n\n return \"\"\n\n def get_od_labels(self, img_idx):\n od_labels = None\n if self.add_od_labels:\n label_info = json.loads(self.label_tsv.seek(img_idx)[1])\n od_labels = \" \".join([l['class'] for l in label_info])\n return od_labels\n\n def get_caption_file_in_coco_format(self):\n cap_file = op.splitext(self.caption_file)[0] + '_coco_format.json'\n return cap_file\n\n def get_captions_by_key(self, index):\n # return self.key2captions[key]\n # if self.is_train:\n dialogue_final, scene_thisround,dialog_id, id_final, type_final, bbox_final, slotvalue_final, image_feature = self.feature[index]\n# else:\n# dialogue_final, scene_thisround,dialog_id, id_final, type_final, bbox_final, slotvalue_final, image_feature = self.devfeature[index]\n caption = dialogue_final[-1:]\n return caption\n\n\n def get_one_item(self,index):\n #if self.is_train:\n dialogue_final, scene_thisround,dialog_id, id_final, type_final, bbox_final, slotvalue_final, image_feature = self.feature[index]\n #else:\n # dialogue_final, scene_thisround,dialog_id, id_final, type_final, bbox_final, slotvalue_final, image_feature = self.devfeature[index]\n\n \n textc_list = dialogue_final[:-1]\n textc = ''\n for text in textc_list:\n textc = textc + text\n\n caption_list = dialogue_final[-1:]\n caption = ''\n for text in caption_list:\n caption = caption + text\n\n\n textd_list = slotvalue_final\n if len(textd_list) <= 1:\n textd = ''\n else:\n textd = \"first:\"\n \n num = 0\n #print(textb_list) \n for text in textd_list:\n #print(\"type\",type(text))\n num = num + 1\n if textd == '':\n textd = text\n else:\n if num == 1:\n textd = \"first:\" + text \n if num == 2:\n textd = textd + ' second:' + text\n if num == 3:\n textd = textd + ' third:' + text\n if num == 4:\n textd = textd + ' fourth:' + text\n if num == 5:\n textd = textd + ' fifth:' + text\n if num == 6:\n textd = textd + ' sixth:' + text\n if num == 7:\n textd = textd + ' seventh:' + text\n if num == 8:\n textd = textd + ' eighth:' + text\n if num == 9:\n textd = textd + ' ninth:' + text\n if num == 10:\n textd = textd + ' tenth:' + text \n\n #print(texta)\n textb = ' '\n textb_list = type_final\n #print(textb_list) \n for text in textb_list:\n if textb == ' ':\n textb = text\n else:\n textb = textb + ' ' + text\n\n #print(textb)\n #print(image_feature)\n image_feature = np.array(image_feature)\n #print(image_feature.shape)\n #print(label_final)\n return caption,str(textb),str(textc),str(textd),image_feature,dialog_id\n\n def __getitem__(self, idx):\n #img_idx = self.get_image_index(idx)\n #img_key = self.image_keys[img_idx]\n #features = self.get_image_features(img_idx)\n #caption = self.get_caption(idx)\n #od_labels = self.get_od_labels(img_idx)\n #textc history textb type textd slot value\n caption,textb,textc,textd,image_feature,dialog_id = self.get_one_item(idx)\n #print(\"caption\",caption)\n #print(\"textb\",textb)\n #print(\"textc\",textc)\n #print(\"textd\",textd)\n # #print(\"image_feature\",image_feature.shape)\n \n\n image_feature= torch.tensor(image_feature, dtype=torch.float32)\n #print(image_feature.shape)\n if self.is_train:\n caption = caption\n else:\n caption = \"\"\n\n \n #example = self.tensorize_example(texta, image_feature, label_final=label_final, text_b=textb) \n example = self.tensorizer.tensorize_example(caption, image_feature,textc, textd,textb,dialog_id)\n # print(\"example\",example)\n return idx, example\n\n def __len__(self):\n# if not self.is_train:\n return len(self.feature)\n\n\n\nclass CaptionTSVDatasetWithConstraints(CaptionTSVDataset):\n r\"\"\"\n Providing inputs for inference with Constraint Beam Search\n\n nms_threshold: float, optional (default = 0.85)\n NMS threshold for suppressing generic object class names during constraint filtering,\n for two boxes with IoU higher than this threshold, \"dog\" suppresses \"animal\".\n max_given_constraints: int, optional (default = 3)\n Maximum number of constraints which can be specified for CBS decoding. Constraints are\n selected based on the prediction confidence score of their corresponding bounding boxes.\n \"\"\"\n\n def __init__(\n self, yaml_file,\n nms_threshold=0.85,\n max_given_constraints=3, **kwargs\n ):\n super().__init__(yaml_file, **kwargs)\n boxes_tsvpath = find_file_path_in_yaml(self.cfg['cbs_box'], self.root)\n constraint2tokens_tsvpath = find_file_path_in_yaml(self.cfg['cbs_constraint'], self.root)\n tokenforms_tsvpath = find_file_path_in_yaml(self.cfg['cbs_tokenforms'], self.root)\n hierarchy_jsonpath = find_file_path_in_yaml(self.cfg['cbs_hierarchy'], self.root)\n\n self._boxes_reader = ConstraintBoxesReader(boxes_tsvpath)\n self._constraint_filter = ConstraintFilter(\n hierarchy_jsonpath, nms_threshold, max_given_constraints\n )\n self._fsm_builder = FiniteStateMachineBuilder(self.tokenizer,\n constraint2tokens_tsvpath, tokenforms_tsvpath,\n max_given_constraints)\n\n def __getitem__(self, index):\n img_key, example = super().__getitem__(index)\n\n # Apply constraint filtering to object class names.\n constraint_boxes = self._boxes_reader[img_key]\n\n candidates = self._constraint_filter(\n constraint_boxes[\"boxes\"], constraint_boxes[\"class_names\"], constraint_boxes[\"scores\"]\n )\n num_constraints = len(candidates)\n fsm, nstates = self._fsm_builder.build(candidates)\n\n return img_key, example + (fsm, num_constraints, )\n\n\nclass CaptionTensorizer(object):\n def __init__(self, tokenizer, max_img_seq_length=50, max_seq_length=70, \n max_seq_a_length=40, mask_prob=0.15, max_masked_tokens=3,\n is_train=True):\n \"\"\"Constructor.\n Args:\n tokenizer: tokenizer for text processing.\n max_img_seq_length: max image sequence length.\n max_seq_length: max text sequence length.\n max_seq_a_length: max caption sequence length.\n is_train: train or test mode.\n mask_prob: probability to mask a input token.\n max_masked_tokens: maximum number of tokens to be masked in one sentence.\n \"\"\"\n self.tokenizer = tokenizer\n self.is_train = is_train\n self.max_img_seq_len = max_img_seq_length\n self.max_seq_len = max_seq_length\n self.max_seq_a_len = max_seq_a_length\n self.mask_prob = mask_prob\n self.max_masked_tokens = max_masked_tokens\n self._triangle_mask = torch.tril(torch.ones((self.max_seq_len, \n self.max_seq_len), dtype=torch.long))\n\n def tensorize_example(self, text_a, img_feat,text_c=None, text_d=None,text_b=None,dialog_id=None,\n cls_token_segment_id=0, pad_token_segment_id=0,\n sequence_a_segment_id=0, sequence_b_segment_id=1):\n if self.is_train:\n tokens_a = self.tokenizer.tokenize(text_a)\n else:\n # fake tokens to generate masks\n tokens_a = [self.tokenizer.mask_token] * (self.max_seq_a_len - 2)\n if len(tokens_a) > self.max_seq_a_len - 2:\n tokens_a = tokens_a[:(self.max_seq_a_len - 2)]\n\n tokens = [self.tokenizer.cls_token] + tokens_a + [self.tokenizer.sep_token]\n segment_ids = [cls_token_segment_id] + [sequence_a_segment_id] * (len(tokens) - 1)\n seq_a_len = len(tokens)\n if text_b:\n # pad text_a to keep it in fixed length for better inference.\n padding_a_len = self.max_seq_a_len - seq_a_len\n tokens += [self.tokenizer.pad_token] * padding_a_len\n segment_ids += ([pad_token_segment_id] * padding_a_len)\n #print(\"text_d type\",type(text_d))\n #print(\"text_c type\",type(text_c))\n #print(\"text_b type\",type(text_b))\n\n tokens_c = self.tokenizer.tokenize(text_c)\n tokens_d = self.tokenizer.tokenize(text_d)\n \n tokens_b = self.tokenizer.tokenize(text_b)\n\n if len(tokens_c) > self.max_seq_len - len(tokens) - 3 - len(tokens_b) - len(tokens_d):\n tokens_c = tokens_c[-(self.max_seq_len - len(tokens) - 3 - len(tokens_b) - len(tokens_d)): ]\n tokens += tokens_c + [self.tokenizer.sep_token]\n \n\n tokens += tokens_d + [self.tokenizer.sep_token]\n \n\n if len(tokens_b) > self.max_seq_len - len(tokens) - 1:\n tokens_b = tokens_b[: (self.max_seq_len - len(tokens) - 1)]\n tokens += tokens_b + [self.tokenizer.sep_token]\n segment_ids += [sequence_b_segment_id] * (len(tokens_b) + len(tokens_c) + len(tokens_d) + 3)\n\n seq_len = len(tokens)\n if self.is_train:\n masked_pos = torch.zeros(self.max_seq_len, dtype=torch.int)\n # randomly mask words for prediction, ignore [CLS]\n candidate_masked_idx = list(range(1, seq_a_len)) # only mask text_a\n random.shuffle(candidate_masked_idx)\n num_masked = min(max(round(self.mask_prob * seq_a_len), 1), self.max_masked_tokens)\n num_masked = int(num_masked)\n masked_idx = candidate_masked_idx[:num_masked]\n masked_idx = sorted(masked_idx)\n masked_token = [tokens[i] for i in masked_idx]\n for pos in masked_idx:\n if random.random() <= 0.8:\n # 80% chance to be a ['MASK'] token\n tokens[pos] = self.tokenizer.mask_token\n elif random.random() <= 0.5:\n # 10% chance to be a random word ((1-0.8)*0.5)\n from random import randint\n i = randint(0, len(self.tokenizer.vocab))\n self.tokenizer._convert_id_to_token(i)\n tokens[pos] = self.tokenizer._convert_id_to_token(i)\n else:\n # 10% chance to remain the same (1-0.8-0.1)\n pass\n\n masked_pos[masked_idx] = 1 \n # pad masked tokens to the same length\n if num_masked < self.max_masked_tokens:\n masked_token = masked_token + ([self.tokenizer.pad_token] *\n (self.max_masked_tokens - num_masked))\n masked_ids = self.tokenizer.convert_tokens_to_ids(masked_token)\n else:\n masked_pos = torch.ones(self.max_seq_len, dtype=torch.int)\n\n # pad on the right for image captioning\n padding_len = self.max_seq_len - seq_len\n tokens = tokens + ([self.tokenizer.pad_token] * padding_len)\n segment_ids += ([pad_token_segment_id] * padding_len)\n input_ids = self.tokenizer.convert_tokens_to_ids(tokens)\n\n # image features\n #print(\"img_feat\",img_feat.shape)\n \n img_len = img_feat.shape[0]\n if img_len > self.max_img_seq_len:\n img_feat = img_feat[0 : self.max_img_seq_len, ]\n img_len = img_feat.shape[0]\n else:\n padding_matrix = torch.zeros((self.max_img_seq_len - img_len,\n img_feat.shape[1]))\n img_feat = torch.cat((img_feat, padding_matrix), 0)\n\n # prepare attention mask:\n # note that there is no attention from caption to image\n # because otherwise it will violate the triangle attention \n # for caption as caption will have full attention on image. \n max_len = self.max_seq_len + self.max_img_seq_len\n attention_mask = torch.zeros((max_len, max_len), dtype=torch.long)\n # C: caption, L: label, R: image region\n c_start, c_end = 0, seq_a_len\n l_start, l_end = self.max_seq_a_len, seq_len\n r_start, r_end = self.max_seq_len, self.max_seq_len + img_len\n # triangle mask for caption to caption\n attention_mask[c_start : c_end, c_start : c_end].copy_(self._triangle_mask[0 : seq_a_len, 0 : seq_a_len])\n # full attention for L-L, R-R\n attention_mask[l_start : l_end, l_start : l_end] = 1\n attention_mask[r_start : r_end, r_start : r_end] = 1\n # full attention for C-L, C-R\n attention_mask[c_start : c_end, l_start : l_end] = 1\n attention_mask[c_start : c_end, r_start : r_end] = 1\n # full attention for L-R:\n attention_mask[l_start : l_end, r_start : r_end] = 1\n attention_mask[r_start : r_end, l_start : l_end] = 1\n\n input_ids = torch.tensor(input_ids, dtype=torch.long)\n segment_ids = torch.tensor(segment_ids, dtype=torch.long)\n\n if self.is_train:\n masked_ids = torch.tensor(masked_ids, dtype=torch.long)\n return (input_ids, attention_mask, segment_ids, img_feat, masked_pos, masked_ids)\n if ((input_ids.shape[0] != self.max_seq_len) or (segment_ids.shape[0] != self.max_seq_len) or (masked_pos.shape[0] != self.max_seq_len)):\n print(input_ids.shape,attention_mask.shape,segment_ids.shape,masked_pos.shape)\n return (input_ids, attention_mask, segment_ids, img_feat, masked_pos,dialog_id)\n\n\ndef build_dataset(data_dir, tokenizer, args, is_train=True,scst=False):\n #if not op.isfile(yaml_file):\n # yaml_file = op.join(args.data_dir, yaml_file)\n # assert op.isfile(yaml_file)\n \n if is_train:\n if scst:\n return CaptionTSVDataset(data_dir+\"/train.bin\", tokenizer=tokenizer,\n add_od_labels=args.add_od_labels, max_img_seq_length=args.max_img_seq_length,\n max_seq_length=args.max_seq_length, max_seq_a_length=args.max_seq_a_length,\n is_train=False, mask_prob=args.mask_prob, max_masked_tokens=args.max_masked_tokens)\n else:\n return CaptionTSVDataset(data_dir+\"/train.bin\", tokenizer=tokenizer,\n add_od_labels=args.add_od_labels, max_img_seq_length=args.max_img_seq_length,\n max_seq_length=args.max_seq_length, max_seq_a_length=args.max_seq_a_length,\n is_train=True, mask_prob=args.mask_prob, max_masked_tokens=args.max_masked_tokens) \n if args.use_cbs:\n dataset_class = CaptionTSVDatasetWithConstraints\n else:\n dataset_class = CaptionTSVDataset\n return dataset_class(data_dir+\"/dev.bin\", tokenizer=tokenizer,\n add_od_labels=args.add_od_labels, max_img_seq_length=args.max_img_seq_length,\n max_seq_length=args.max_seq_length, max_seq_a_length=args.max_gen_length,\n is_train=False)\n\n\ndef make_data_sampler(dataset, shuffle, distributed):\n if distributed:\n return torch.utils.data.distributed.DistributedSampler(dataset, shuffle=shuffle)\n if shuffle:\n sampler = torch.utils.data.sampler.RandomSampler(dataset)\n else:\n sampler = torch.utils.data.sampler.SequentialSampler(dataset)\n return sampler\n\n\ndef make_data_loader(args, data_dir, tokenizer, is_distributed=True, \n is_train=True):\n dataset = build_dataset(data_dir, tokenizer, args, \n is_train,args.scst)\n if is_train:\n shuffle = True\n images_per_gpu = args.per_gpu_train_batch_size\n images_per_batch = images_per_gpu * args.num_gpus\n iters_per_batch = len(dataset) // images_per_batch\n num_iters = iters_per_batch * args.num_train_epochs\n logger.info(\"Train with {} images per GPU.\".format(images_per_gpu))\n logger.info(\"Total batch size {}\".format(images_per_batch))\n logger.info(\"Total training steps {}\".format(num_iters))\n else:\n shuffle = False\n images_per_gpu = args.per_gpu_eval_batch_size\n\n sampler = make_data_sampler(dataset, shuffle, is_distributed)\n data_loader = torch.utils.data.DataLoader(\n dataset, num_workers=args.num_workers, sampler=sampler,\n batch_size=images_per_gpu,\n pin_memory=True,\n )\n return data_loader\n\n\ndef save_checkpoint(model, tokenizer, args, epoch, iteration, num_trial=10):\n checkpoint_dir = op.join(args.output_dir, 'checkpoint-{}-{}'.format(\n epoch, iteration))\n if not is_main_process():\n return checkpoint_dir\n mkdir(checkpoint_dir)\n model_to_save = model.module if hasattr(model, 'module') else model\n for i in range(num_trial):\n try:\n model_to_save.save_pretrained(checkpoint_dir)\n torch.save(args, op.join(checkpoint_dir, 'training_args.bin'))\n tokenizer.save_pretrained(checkpoint_dir)\n logger.info(\"Save checkpoint to {}\".format(checkpoint_dir))\n break\n except:\n pass\n else:\n logger.info(\"Failed to save checkpoint after {} trails.\".format(num_trial))\n return checkpoint_dir\n\n\ndef compute_score_with_logits(logits, labels):\n logits = torch.max(logits, -1)[1].data # argmax\n scores = logits == labels \n return scores\n\n\ndef train(args, train_dataloader, val_dataset, model, tokenizer):\n if args.distributed:\n model = torch.nn.parallel.DistributedDataParallel(\n model, device_ids=[args.local_rank], \n output_device=args.local_rank,\n find_unused_parameters=True,\n )\n\n\n if args.max_steps > 0:\n t_total = args.max_steps\n args.num_train_epochs = args.max_steps // (len(train_dataloader) // \\\n args.gradient_accumulation_steps) + 1\n else:\n t_total = len(train_dataloader) // args.gradient_accumulation_steps \\\n * args.num_train_epochs\n\n # Prepare optimizer and scheduler\n no_decay = ['bias', 'LayerNorm.weight']\n grouped_parameters = [\n {'params': [p for n, p in model.named_parameters() if not \\\n any(nd in n for nd in no_decay)], 'weight_decay': args.weight_decay},\n {'params': [p for n, p in model.named_parameters() if \\\n any(nd in n for nd in no_decay)], 'weight_decay': 0.0}\n ]\n optimizer = AdamW(grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)\n if args.scheduler == \"constant\":\n scheduler = WarmupConstantSchedule(\n optimizer, warmup_steps=args.warmup_steps)\n elif args.scheduler == \"linear\":\n scheduler = WarmupLinearSchedule(\n optimizer, warmup_steps=args.warmup_steps, t_total=t_total)\n else:\n raise ValueError(\"Unknown scheduler type: {}\".format(args.scheduler))\n\n logger.info(\"***** Running training *****\")\n logger.info(\" Num Epochs = %d\", args.num_train_epochs)\n logger.info(\" Batch size per GPU = %d\", args.per_gpu_train_batch_size)\n logger.info(\" Total train batch size (w. parallel, & accumulation) = %d\",\n args.per_gpu_train_batch_size * args.num_gpus * args.gradient_accumulation_steps)\n logger.info(\" Gradient Accumulation steps = %d\", args.gradient_accumulation_steps)\n logger.info(\" Total optimization steps = %d\", t_total)\n\n if args.scst:\n scst_criterion = ScstRewardCriterion(\n cider_cached_tokens=op.join(args.data_dir, args.cider_cached_tokens),\n baseline_type=args.sc_baseline_type,\n )\n logger.info(\" SCST training...\")\n\n if args.num_gpus > 1:\n model = torch.nn.DataParallel(model)\n\n global_step, global_loss, global_acc =0, 0.0, 0.0\n model.zero_grad()\n eval_log = []\n best_score = 0\n for epoch in range(int(args.num_train_epochs)):\n for step, (img_keys, batch) in enumerate(train_dataloader):\n batch = tuple(t.to(args.device) for t in batch)\n\n if not args.scst:\n model.train()\n inputs = {'input_ids': batch[0], 'attention_mask': batch[1],\n 'token_type_ids': batch[2], 'img_feats': batch[3], \n 'masked_pos': batch[4], 'masked_ids': batch[5]\n }\n outputs = model(**inputs)\n loss, logits = outputs[:2]\n masked_ids = inputs['masked_ids']\n try:\n masked_ids = masked_ids[masked_ids != 0]\n batch_score = compute_score_with_logits(logits, masked_ids)\n batch_acc = torch.sum(batch_score.float()) / torch.sum(inputs['masked_pos'])\n except:\n batch_score = 0 \n batch_acc = 0\n else:\n loss = scst_train_iter(args, train_dataloader, model, scst_criterion, img_keys, batch, tokenizer)\n batch_acc = scst_criterion.get_score()\n\n if args.gradient_accumulation_steps > 1:\n loss = loss / args.gradient_accumulation_steps\n loss.backward()\n torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)\n global_loss += loss.item()\n global_acc += batch_acc\n if (step + 1) % args.gradient_accumulation_steps == 0:\n global_step += 1\n scheduler.step()\n optimizer.step()\n model.zero_grad()\n if global_step % args.logging_steps == 0:\n logger.info(\"Epoch: {}, global_step: {}, lr: {:.6f}, loss: {:.4f} ({:.4f}), \" \\\n \"score: {:.4f} ({:.4f})\".format(epoch, global_step, \n optimizer.param_groups[0][\"lr\"], loss, global_loss / global_step, \n batch_acc, global_acc / global_step)\n )\n\n if (args.save_steps > 0 and global_step % args.save_steps == 0) or \\\n global_step == t_total:\n checkpoint_dir = save_checkpoint(model, tokenizer, args, epoch, global_step) \n # evaluation\n if args.evaluate_during_training: \n logger.info(\"Perform evaluation at step: %d\" % (global_step))\n evaluate_file = test(args, val_dataset, model, tokenizer)\n # with open(evaluate_file, 'r') as f:\n # res = json.load(f)\n # best_score = max(best_score, res['CIDEr'])\n # res['epoch'] = epoch\n # res['global_step'] = step\n # res['best_CIDEr'] = best_score\n # eval_log.append(res)\n # with open(args.output_dir + '/eval_logs.json', 'w') as f:\n # json.dump(eval_log, f)\n return checkpoint_dir\n\n\ndef scst_train_iter(args, train_dataloader, model, scst_criterion, \n img_keys, batch, tokenizer):\n cls_token_id, sep_token_id, pad_token_id, mask_token_id = \\\n tokenizer.convert_tokens_to_ids([tokenizer.cls_token, \n tokenizer.sep_token, tokenizer.pad_token, tokenizer.mask_token]\n )\n inputs = {'is_decode': True,\n 'input_ids': batch[0], 'attention_mask': batch[1],\n 'token_type_ids': batch[2], 'img_feats': batch[3],\n 'masked_pos': batch[4],\n 'do_sample': False,\n 'bos_token_id': cls_token_id,\n 'pad_token_id': pad_token_id,\n 'eos_token_ids': [sep_token_id],\n 'mask_token_id': mask_token_id,\n # for adding od labels\n 'add_od_labels': args.add_od_labels, 'od_labels_start_posid': args.max_seq_a_length,\n # hyperparameters of beam search\n 'max_length': args.max_gen_length,\n 'num_beams': args.sc_beam_size,\n \"temperature\": args.temperature,\n \"top_k\": args.top_k,\n \"top_p\": args.top_p,\n \"repetition_penalty\": args.repetition_penalty,\n \"length_penalty\": args.length_penalty,\n \"num_return_sequences\": 1,\n \"num_keep_best\": 1,\n }\n\n def _ids_to_captions(all_ids):\n captions = []\n for ids in all_ids:\n c = tokenizer.decode(ids.tolist(), skip_special_tokens=True)\n captions.append(c)\n return captions\n\n if args.sc_baseline_type == 'greedy':\n model.eval()\n with torch.no_grad():\n greedy_res_raw, _ = model(**inputs)\n greedy_res_raw.squeeze_(1) # batch_size * max_len\n greedy_res = _ids_to_captions(greedy_res_raw)\n else:\n greedy_res = None\n\n model.train()\n inputs['do_sample'] = True\n inputs['num_return_sequences'] = args.sc_train_sample_n\n sample_res_raw, sample_logprobs = model(**inputs)\n sample_res_raw.squeeze_(1)\n sample_logprobs.squeeze_(1)\n assert sample_logprobs.requires_grad == True\n assert sample_res_raw.requires_grad == False\n sample_res = _ids_to_captions(sample_res_raw)\n\n gt_res = [train_dataloader.dataset.get_captions_by_key(k) for k in img_keys]\n loss = scst_criterion(gt_res, greedy_res, sample_res, sample_logprobs)\n return loss\n\n\ndef get_predict_file(output_dir, yaml_file, args):\n cc = ['pred']\n # make sure it works with/without / in end of the path.\n data = op.basename(op.join(args.data_dir, '')[:-1])\n split = op.basename(yaml_file)\n assert split.endswith('.yaml')\n split = split[:-5]\n cc.append(data)\n cc.append(split)\n cc.append('beam{}'.format(args.num_beams))\n cc.append('max{}'.format(args.max_gen_length))\n if args.add_od_labels:\n cc.append('odlabels')\n if args.num_keep_best != 1:\n cc.append('best{}'.format(args.num_keep_best))\n if args.use_cbs:\n cc.append('cbs{}'.format(args.min_constraints_to_satisfy))\n if args.output_hidden_states:\n cc.append('hidden')\n return op.join(output_dir, '{}.tsv'.format('.'.join(cc)))\n\n\ndef get_evaluate_file(predict_file):\n assert predict_file.endswith('.tsv')\n fpath = op.splitext(predict_file)[0]\n return fpath + '.eval.json'\n\n\ndef get_evaluate_method(predict_file):\n if 'nocaps' in op.basename(predict_file):\n return 'nocaps'\n else:\n return 'coco'\n\n\ndef evaluate(args, val_dataloader, model, tokenizer, output_dir):\n #predict_file = get_predict_file(output_dir,\n # val_dataloader.dataset.yaml_file, args)\n test(args, val_dataloader, model, tokenizer)\n return \"test\"\n if get_world_size() > 1:\n torch.distributed.barrier()\n evaluate_file = get_evaluate_file(predict_file)\n if is_main_process():\n caption_file = val_dataloader.dataset.get_caption_file_in_coco_format()\n data = val_dataloader.dataset.yaml_file.split('/')[-2]\n # if 'nocaps' not in data:\n # result = evaluate_on_coco_caption(predict_file, caption_file, outfile=evaluate_file)\n # logger.info('evaluation result: {}'.format(str(result)))\n # logger.info('evaluation result saved to {}'.format(evaluate_file))\n if get_world_size() > 1:\n torch.distributed.barrier()\n return evaluate_file\n\n\ndef test(args, test_dataloader, model, tokenizer):\n cls_token_id, sep_token_id, pad_token_id, mask_token_id, period_token_id = \\\n tokenizer.convert_tokens_to_ids([tokenizer.cls_token, tokenizer.sep_token, \n tokenizer.pad_token, tokenizer.mask_token, '.'])\n world_size = get_world_size()\n # if world_size == 1:\n # cache_file = predict_file\n # else:\n # cache_file = op.splitext(predict_file)[0] + '_{}_{}'.format(get_rank(), \n # world_size) + op.splitext(predict_file)[1]\n if args.num_gpus > 1:\n model = torch.nn.DataParallel(model)\n\n model.eval()\n inputs_param = {'is_decode': True,\n 'do_sample': False,\n 'bos_token_id': cls_token_id,\n 'pad_token_id': pad_token_id,\n 'eos_token_ids': [sep_token_id],\n 'mask_token_id': mask_token_id,\n # for adding od labels\n 'add_od_labels': args.add_od_labels, 'od_labels_start_posid': args.max_seq_a_length,\n\n # hyperparameters of beam search\n 'max_length': args.max_gen_length,\n 'num_beams': args.num_beams,\n \"temperature\": args.temperature,\n \"top_k\": args.top_k,\n \"top_p\": args.top_p,\n \"repetition_penalty\": args.repetition_penalty,\n \"length_penalty\": args.length_penalty,\n \"num_return_sequences\": args.num_return_sequences,\n \"num_keep_best\": args.num_keep_best,\n }\n if args.use_cbs:\n inputs_param.update({'use_cbs': True,\n 'min_constraints_to_satisfy': args.min_constraints_to_satisfy,\n })\n def gen_rows():\n time_meter = 0\n\n with torch.no_grad():\n for step, (img_keys, batch) in tqdm(enumerate(test_dataloader)):\n batch = tuple(t.to(args.device) for t in batch)\n inputs = {\n 'input_ids': batch[0], 'attention_mask': batch[1],\n 'token_type_ids': batch[2], 'img_feats': batch[3],\n 'masked_pos': batch[4],\n }\n if args.use_cbs:\n inputs.update({\n 'fsm': batch[5],\n 'num_constraints': batch[6],\n })\n inputs.update(inputs_param)\n tic = time.time()\n # captions, logprobs\n outputs = model(**inputs)\n time_meter += time.time() - tic\n all_caps = outputs[0] # batch_size * num_keep_best * max_len\n all_confs = torch.exp(outputs[1])\n\n for img_key, caps, confs in zip(batch[5], all_caps, all_confs):\n res = []\n for cap, conf in zip(caps, confs):\n cap = tokenizer.decode(cap.tolist(), skip_special_tokens=True)\n print(img_key.cpu())\n res.append({'caption': cap, 'conf': conf.item(), \"img_key\":int(img_key.cpu()) })\n if isinstance(img_key, torch.Tensor):\n img_key = img_key.item()\n yield img_key, json.dumps(res)\n\n logger.info(\"Inference model computing time: {} seconds per batch\".format(time_meter / (step+1)))\n if args.eval_model_dir:\n tsv_writer(gen_rows(), args.eval_model_dir + \"/resulefile.txt\")\n else:\n tsv_writer(gen_rows(), args.output_dir + \"/resulefile.txt\")\n \n # if world_size > 1:\n # torch.distributed.barrier()\n # if world_size > 1 and is_main_process():\n # cache_files = [op.splitext(predict_file)[0] + '_{}_{}'.format(i, world_size) + \\\n # op.splitext(predict_file)[1] for i in range(world_size)]\n # concat_tsv_files(cache_files, predict_file)\n # delete_tsv_files(cache_files)\n # reorder_tsv_keys(predict_file, test_dataloader.dataset.image_keys, predict_file)\n # if world_size > 1:\n # torch.distributed.barrier()\n\n\ndef restore_training_settings(args):\n if args.do_train:\n if not args.scst:\n return args\n checkpoint = args.model_name_or_path\n else:\n assert args.do_test or args.do_eval\n checkpoint = args.eval_model_dir\n # restore training settings, check hasattr for backward compatibility\n train_args = torch.load(op.join(checkpoint, 'training_args.bin'))\n if hasattr(train_args, 'max_seq_a_length'):\n if hasattr(train_args, 'scst') and train_args.scst:\n max_od_labels_len = train_args.max_seq_length - train_args.max_gen_length\n else:\n max_od_labels_len = train_args.max_seq_length - train_args.max_seq_a_length\n max_seq_length = args.max_gen_length + max_od_labels_len\n args.max_seq_length = max_seq_length\n logger.warning('Override max_seq_length to {} = max_gen_length:{} + od_labels_len:{}'.format(\n max_seq_length, args.max_gen_length, max_od_labels_len))\n\n\n override_params = ['max_seq_a_length', 'do_lower_case', 'add_od_labels',\n 'max_img_seq_length']\n for param in override_params:\n if hasattr(train_args, param):\n train_v = getattr(train_args, param)\n test_v = getattr(args, param)\n if train_v != test_v:\n logger.warning('Override {} with train args: {} -> {}'.format(param,\n test_v, train_v))\n setattr(args, param, train_v)\n return args\n\n\ndef get_world_size():\n #return torch.cuda.device_count()\n if not dist.is_available():\n return 1\n if not dist.is_initialized():\n return 1\n return dist.get_world_size()\n\n\ndef get_rank():\n if not dist.is_available():\n return 0\n if not dist.is_initialized():\n return 0\n return dist.get_rank()\n\n\ndef is_main_process():\n return get_rank() == 0\n\n\ndef synchronize():\n \"\"\"\n Helper function to synchronize (barrier) among all processes when\n using distributed training\n \"\"\"\n if not dist.is_available():\n return\n if not dist.is_initialized():\n return\n world_size = dist.get_world_size()\n if world_size == 1:\n return\n dist.barrier()\n\n\ndef ensure_init_process_group(local_rank=None, port=12345):\n # init with env\n world_size = int(os.environ['WORLD_SIZE']) if 'WORLD_SIZE' in os.environ else 1\n if world_size > 1 and not dist.is_initialized():\n assert local_rank is not None\n print(\"Init distributed training on local rank {}\".format(local_rank))\n torch.cuda.set_device(local_rank)\n dist.init_process_group(\n backend='nccl', init_method='env://'\n )\n return local_rank\n\n\ndef main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--data_dir\", default='datasets/coco_caption', type=str, required=False,\n help=\"The input data dir with all required files.\")\n parser.add_argument(\"--train_yaml\", default='train.yaml', type=str, required=False, \n help=\"yaml file for training.\")\n parser.add_argument(\"--test_yaml\", default='test.yaml', type=str, required=False,\n help=\"yaml file for testing.\")\n parser.add_argument(\"--val_yaml\", default='val.yaml', type=str, required=False, \n help=\"yaml file used for validation during training.\")\n parser.add_argument(\"--model_name_or_path\", default=None, type=str, required=False,\n help=\"Path to pre-trained model or model type.\")\n parser.add_argument(\"--output_dir\", default='output/', type=str, required=False,\n help=\"The output directory to save checkpoint and test results.\")\n parser.add_argument(\"--loss_type\", default='sfmx', type=str, \n help=\"Loss function types: support kl, x2, sfmx\")\n parser.add_argument(\"--config_name\", default=\"\", type=str, \n help=\"Pretrained config name or path if not the same as model_name.\")\n parser.add_argument(\"--tokenizer_name\", default=\"\", type=str, \n help=\"Pretrained tokenizer name or path if not the same as model_name.\")\n parser.add_argument(\"--max_seq_length\", default=450, type=int,\n help=\"The maximum total input sequence length after tokenization. \"\n \"Sequences longer than this will be truncated, \"\n \"sequences shorter will be padded.\")\n parser.add_argument(\"--max_seq_a_length\", default=40, type=int, \n help=\"The maximum sequence length for caption.\")\n parser.add_argument(\"--do_train\", action='store_true', help=\"Whether to run training.\")\n parser.add_argument(\"--do_test\", action='store_true', help=\"Whether to run inference.\")\n parser.add_argument(\"--do_eval\", action='store_true', help=\"Whether to run evaluation.\")\n parser.add_argument(\"--do_lower_case\", action='store_true', \n help=\"Set this flag if you are using an uncased model.\")\n parser.add_argument(\"--mask_prob\", default=0.15, type=float,\n help= \"Probability to mask input sentence during training.\")\n parser.add_argument(\"--max_masked_tokens\", type=int, default=3,\n help=\"The max number of masked tokens per sentence.\")\n parser.add_argument(\"--add_od_labels\", default=False, action='store_true', \n help=\"Whether to add object detection labels or not\")\n parser.add_argument(\"--drop_out\", default=0.1, type=float, help=\"Drop out in BERT.\")\n parser.add_argument(\"--max_img_seq_length\", default=12, type=int, \n help=\"The maximum total input image sequence length.\")\n parser.add_argument(\"--img_feature_dim\", default=2054, type=int, \n help=\"The Image Feature Dimension.\")\n parser.add_argument(\"--img_feature_type\", default='frcnn', type=str,\n help=\"Image feature type.\")\n parser.add_argument(\"--tie_weights\", default=False, action='store_true', \n help=\"Whether to tie decoding weights to that of encoding\")\n parser.add_argument(\"--freeze_embedding\", default=False, action='store_true', \n help=\"Whether to freeze word embeddings in Bert\")\n parser.add_argument(\"--label_smoothing\", default=0, type=float, \n help=\".\")\n parser.add_argument(\"--drop_worst_ratio\", default=0, type=float, \n help=\".\")\n parser.add_argument(\"--drop_worst_after\", default=0, type=int, \n help=\".\")\n parser.add_argument(\"--per_gpu_train_batch_size\", default=12, type=int, \n help=\"Batch size per GPU/CPU for training.\")\n parser.add_argument(\"--per_gpu_eval_batch_size\", default=2, type=int, \n help=\"Batch size per GPU/CPU for evaluation.\")\n parser.add_argument(\"--output_mode\", default='classification', type=str,\n help=\"output mode, support classification or regression.\")\n parser.add_argument(\"--num_labels\", default=2, type=int, \n help=\"num_labels is 2 for classification and 1 for regression.\")\n parser.add_argument('--gradient_accumulation_steps', type=int, default=1,\n help=\"Number of updates steps to accumulate before backward.\")\n parser.add_argument(\"--learning_rate\", default=3e-5, type=float, help=\"The initial lr.\")\n parser.add_argument(\"--weight_decay\", default=0.05, type=float, help=\"Weight deay.\")\n parser.add_argument(\"--adam_epsilon\", default=1e-8, type=float, help=\"Epsilon for Adam.\")\n parser.add_argument(\"--max_grad_norm\", default=1.0, type=float, help=\"Max gradient norm.\")\n parser.add_argument(\"--warmup_steps\", default=0, type=int, help=\"Linear warmup.\")\n parser.add_argument(\"--scheduler\", default='linear', type=str, help=\"constant or linear or\")\n parser.add_argument(\"--num_workers\", default=4, type=int, help=\"Workers in dataloader.\")\n parser.add_argument(\"--num_train_epochs\", default=40, type=int, \n help=\"Total number of training epochs to perform.\")\n parser.add_argument(\"--max_steps\", default=-1, type=int, \n help=\"Total number of training steps. Override num_train_epochs.\")\n parser.add_argument('--logging_steps', type=int, default=20, help=\"Log every X steps.\")\n parser.add_argument('--save_steps', type=int, default=-1, \n help=\"Save checkpoint every X steps. Will also perform evaluatin.\")\n parser.add_argument(\"--evaluate_during_training\", action='store_true', \n help=\"Run evaluation during training at each save_steps.\")\n parser.add_argument(\"--no_cuda\", action='store_true', help=\"Avoid using CUDA.\")\n parser.add_argument(\"--local_rank\", type=int, default=0, \n help=\"For distributed training.\")\n parser.add_argument('--seed', type=int, default=88, help=\"random seed for initialization.\")\n # for self-critical sequence training\n parser.add_argument('--scst', action='store_true', help='Self-critical sequence training')\n parser.add_argument('--sc_train_sample_n', type=int, default=5,\n help=\"number of sampled captions for sc training\")\n parser.add_argument('--sc_baseline_type', type=str, default='greedy',\n help=\"baseline tyep of REINFORCE algorithm\")\n parser.add_argument('--sc_beam_size', type=int, default=1,\n help=\"beam size for scst training\")\n parser.add_argument('--cider_cached_tokens', type=str, default='coco-train-words.p',\n help=\"path to cached cPickle file used to calculate CIDEr scores\")\n # for generation\n\n\n parser.add_argument(\"--eval_model_dir\", type=str, default='', \n help=\"Model directory for evaluation.\")\n parser.add_argument('--max_gen_length', type=int, default=40,\n help=\"max length of generated sentences\")\n parser.add_argument('--output_hidden_states', action='store_true',\n help=\"Turn on for fast decoding\")\n parser.add_argument('--num_return_sequences', type=int, default=1,\n help=\"repeating times per image\")\n parser.add_argument('--num_beams', type=int, default=1, help=\"beam search width\")\n parser.add_argument('--num_keep_best', type=int, default=1,\n help=\"number of hypotheses to keep in beam search\")\n parser.add_argument('--temperature', type=float, default=1,\n help=\"temperature in softmax for sampling\")\n parser.add_argument('--top_k', type=int, default=0,\n help=\"filter distribution for sampling\")\n parser.add_argument('--top_p', type=float, default=1,\n help=\"filter distribution for sampling\")\n parser.add_argument('--repetition_penalty', type=int, default=1,\n help=\"repetition penalty from CTRL paper (https://arxiv.org/abs/1909.05858)\")\n parser.add_argument('--length_penalty', type=int, default=1,\n help=\"beam search length penalty\")\n # for Constrained Beam Search\n parser.add_argument('--use_cbs', action='store_true',\n help='Use constrained beam search for decoding')\n parser.add_argument('--min_constraints_to_satisfy', type=int, default=2,\n help=\"minimum number of constraints to satisfy\")\n args = parser.parse_args()\n\n global logger\n \n os.system(\"nvidia-smi\")\n # Setup CUDA, GPU & distributed training\n local_rank = ensure_init_process_group(local_rank=args.local_rank)\n args.local_rank = local_rank\n #args.num_gpus = get_world_size()\n args.num_gpus = torch.cuda.device_count()\n\n #args.distributed = args.num_gpus > 1\n args.distributed =0\n #args.num_gpus = get_world_size() \n args.device = torch.device('cuda')\n synchronize()\n\n output_dir = args.output_dir\n mkdir(output_dir)\n\n logger = setup_logger(\"vlpretrain\", output_dir, args.local_rank)\n logger.warning(\"Device: %s, n_gpu: %s\", args.device, args.num_gpus)\n set_seed(args.seed, args.num_gpus)\n args = restore_training_settings(args)\n\n # Load pretrained model and tokenizer\n config_class, model_class, tokenizer_class = BertConfig, BertForImageCaptioning, BertTokenizer\n if args.do_train:\n assert args.model_name_or_path is not None\n config = config_class.from_pretrained(args.config_name if args.config_name else \\\n args.model_name_or_path, num_labels=args.num_labels, finetuning_task='image_captioning')\n if args.scst:\n # avoid using too much memory\n config.output_hidden_states = True\n tokenizer = tokenizer_class.from_pretrained(args.tokenizer_name if args.tokenizer_name \\\n else args.model_name_or_path, do_lower_case=args.do_lower_case)\n config.img_feature_dim = args.img_feature_dim\n config.img_feature_type = args.img_feature_type\n config.hidden_dropout_prob = args.drop_out\n config.loss_type = args.loss_type\n config.tie_weights = args.tie_weights\n config.freeze_embedding = args.freeze_embedding\n config.label_smoothing = args.label_smoothing\n config.drop_worst_ratio = args.drop_worst_ratio\n config.drop_worst_after = args.drop_worst_after\n model = model_class.from_pretrained(args.model_name_or_path,\n from_tf=bool('.ckpt' in args.model_name_or_path), config=config)\n else:\n checkpoint = args.eval_model_dir\n assert op.isdir(checkpoint)\n config = config_class.from_pretrained(checkpoint)\n config.output_hidden_states = args.output_hidden_states\n tokenizer = tokenizer_class.from_pretrained(checkpoint)\n logger.info(\"Evaluate the following checkpoint: %s\", checkpoint)\n model = model_class.from_pretrained(checkpoint, config=config)\n\n model.to(args.device)\n logger.info(\"Training/evaluation parameters %s\", args)\n if args.do_train:\n train_dataloader = make_data_loader(args, args.data_dir, tokenizer,\n args.distributed, is_train=True)\n val_dataloader = None\n if args.evaluate_during_training:\n val_dataloader = make_data_loader(args, args.data_dir, tokenizer,\n args.distributed, is_train=False)\n last_checkpoint = train(args, train_dataloader, val_dataloader, model, tokenizer)\n\n # test the last checkpoint after training\n if args.do_test:\n logger.info(\"Evaluate on dataset: \" + args.data_dir)\n test_dataloader = make_data_loader(args, args.data_dir, \n tokenizer, args.distributed, is_train=False)\n evaluate(args, test_dataloader, model, tokenizer, last_checkpoint)\n # inference and evaluation\n elif args.do_test or args.do_eval:\n logger.info(\"Evaluate on dataset: \" + args.data_dir)\n test_dataloader = make_data_loader(args, args.data_dir,\n tokenizer, args.distributed, is_train=False)\n\n if not args.do_eval:\n #predict_file = get_predict_file(checkpoint, test_dataloader.dataset.yaml_file, args)\n #predict_file = \n test(args, test_dataloader, model, tokenizer)\n logger.info(\"Prediction results saved to:\")\n else:\n evaluate_file = evaluate(args, test_dataloader, model, tokenizer,\n checkpoint)\n logger.info(\"Evaluation results saved to: {}\".format(evaluate_file))\n\nif __name__ == \"__main__\":\n main()\n",
"import json\r\nimport pickle\r\nimport utils_img\r\nimport jsonpath\r\nimport numpy as np\r\nimport os\r\nimport sys\r\n#json_name = 'simmc2_dials_dstc10_train.json'\r\n#json_name = 'simmc2_dials_dstc10_devtest.json'\r\njson_name = sys.argv[1]\r\n#'simmc2_dials_dstc10_dev.json'\r\n\r\ndir_name = './data/'\r\n\r\n\r\ndef search(json_name, dir_name, startid, endid):\r\n\r\n#——————————————————————————————函数定义————————————————————————————————————————————————————————————\r\n # 数组去重\r\n def getNonRepeatList(data):\r\n new_data = []\r\n for i in range(len(data)):\r\n if data[i] not in new_data:\r\n new_data.append(data[i])\r\n return new_data\r\n\r\n # 数组分割\r\n def split_list_by_n(list_collection, n):\r\n \"\"\"\r\n 将集合均分，每份n个元素\r\n :param list_collection:\r\n :param n:\r\n :return:返回的结果为评分后的每份可迭代对象\r\n \"\"\"\r\n for i in range(0, len(list_collection), n):\r\n yield list_collection[i: i + n]\r\n\r\n # 定义查找json文件内部值的函数\r\n # 模糊搜索json内部文件value\r\n def get_json_value(json_data, key_name):\r\n key_value = jsonpath.jsonpath(json_data, '$..{key_name}'.format(key_name=key_name))\r\n return key_value\r\n\r\n # 字典中查找嵌套的key\r\n def get_dict_value(date, keys, default=None):\r\n # default=None，在key值不存在的情况下，返回None\r\n keys_list = keys.split('.')\r\n # 以“.”为间隔，将字符串分裂为多个字符串，其实字符串为字典的键，保存在列表keys_list里\r\n if isinstance(date, dict):\r\n # 如果传入的数据为字典\r\n dictionary = dict(date)\r\n # 初始化字典\r\n for i in keys_list:\r\n # 按照keys_list顺序循环键值\r\n try:\r\n if dictionary.get(i) != None:\r\n dict_values = dictionary.get(i)\r\n # 如果键对应的值不为空，返回对应的值\r\n elif dictionary.get(i) == None:\r\n dict_values = dictionary.get(int(i))\r\n # 如果键对应的值为空，将字符串型的键转换为整数型，返回对应的值\r\n except:\r\n return default\r\n # 如果字符串型的键转换整数型错误，返回None\r\n dictionary = dict_values\r\n return dictionary\r\n else:\r\n # 如果传入的数据为非字典\r\n try:\r\n dictionary = dict(eval(date))\r\n # 如果传入的字符串数据格式为字典格式，转字典类型，不然返回None\r\n if isinstance(dictionary, dict):\r\n for i in keys_list:\r\n # 按照keys_list顺序循环键值\r\n try:\r\n if dictionary.get(i) != None:\r\n dict_values = dictionary.get(i)\r\n # 如果键对应的值不为空，返回对应的值\r\n elif dictionary.get(i) == None:\r\n dict_values = dictionary.get(int(i))\r\n # 如果键对应的值为空，将字符串型的键转换为整数型，返回对应的值\r\n except:\r\n return default\r\n # 如果字符串型的键转换整数型错误，返回None\r\n dictionary = dict_values\r\n return dictionary\r\n except:\r\n return default\r\n\r\n def get_replace_flag(pathlist, bbox_list):\r\n with open('./obj_thred.json', 'r') as f:\r\n data = json.load(f)\r\n for path, bbox in zip(pathlist, bbox_list):\r\n path = path.replace('/', '_')\r\n h_w, thred = data[path]\r\n yield (bbox[3] - bbox[0] if h_w == 'w' else bbox[2] - bbox[1]) >= thred\r\n # a = get_replace_flag(['MensCollection_Prefabs_Rearranged_long_coat_12'], [(1, 1, 70, 80)])\r\n\r\n def read_thisturn(dialogue_thisround, scenefile,did):\r\n\r\n # 统计本轮有多少个dialogue对话字典\r\n count_dialogue = np.arange(len(dialogue_thisround))\r\n\r\n # 1.获取对话内容（先用户后系统）\r\n dialogue_final = [] # 需要return\r\n objectsid = []\r\n # 进入本轮对话字典\r\n for x in count_dialogue:\r\n dialogue_final.append(get_dict_value(dialogue_thisround[x], 'transcript', None))\r\n dialogue_final.append(get_dict_value(dialogue_thisround[x], 'system_transcript', None))\r\n objectsid.append(get_dict_value(dialogue_thisround[x], 'transcript_annotated.act_attributes.objects', None))\r\n # 2.获取图片名称(将计数数组翻转后取第0个数字为下标)\r\n scene_thisround = scenefile # 需要return\r\n\r\n # 3.获取对应图片文件里所有的index\r\n # 3.1打开文件\r\n scene = str(dir_name)+\"public/\" + str(scene_thisround) + '_scene.json'\r\n with open(str(scene), 'r', encoding='utf-8-sig', errors='ignore') as f:\r\n metadatafile = json.load(f, strict=False)\r\n\r\n # 3.2获取index\r\n all_id = get_json_value(metadatafile, 'index') # 需要return\r\n all_prefab = get_json_value(metadatafile, 'prefab_path')\r\n all_bbox = get_json_value(metadatafile, 'bbox')\r\n\r\n\r\n if 1:\r\n final_total = []\r\n # 4.获取index对应的type\r\n # 4.1给出all_id对应的all_prefab列表（指该index下对应的prefabpath）\r\n for a in all_bbox:\r\n third = a[0] + a[3]\r\n fourth = a[1] + a[2]\r\n a[2] = third\r\n a[3] = fourth\r\n\r\n # 4.2将id和prefab打包成字典\r\n id_prefab = list(zip(all_id, all_prefab, all_bbox))\r\n sorted_id_prefab = sorted(id_prefab, key=lambda tup: tup[0])\r\n\r\n id_final = []\r\n prefab_final = []\r\n bbox_final = []\r\n for y in sorted_id_prefab:\r\n id_final.append(y[0])\r\n prefab_final.append(y[1])\r\n bbox_final.append(y[2])\r\n\r\n # 4.3.2进入循环添加all_type\r\n prefab_len = np.arange(len(id_prefab))\r\n type_final = []\r\n for l in prefab_len:\r\n temp = get_json_value(fashion, str(prefab_final[l]))\r\n if temp != False:\r\n type_temp = get_json_value(temp[0], 'type')\r\n type_final.append(type_temp[0])\r\n if temp == False:\r\n temp = get_json_value(furniture, str(prefab_final[l]))\r\n type_temp = get_json_value(temp[0], 'type')\r\n type_final.append(type_temp[0])\r\n\r\n # label(需要这一轮对话所检索出的objectid)\r\n objects = objectsid[len(objectsid) - 1]\r\n objects_new = list(set(objects))\r\n # 将检索出的objects与indexid（sorted）相比较，生成label\r\n # 获取一致的元素的下标\r\n label_locate = []\r\n for p in objects:\r\n for q in prefab_len:\r\n if p == id_final[q]:\r\n label_locate.append(q)\r\n\r\n # 生成新数组\r\n label_final = [0] * prefab_len\r\n for e in prefab_len:\r\n for f in label_locate:\r\n if e == f:\r\n label_final[e] = 1\r\n\r\n # 获取image——feature\r\n scene_thisround_old = scene_thisround\r\n scene_thisround_new = scene_thisround[2:] + \".png\"\r\n scene_thisround_1 = scene_thisround + \".png\"\r\n part1 = 'data/simmc2_scene_images_dstc10_public_part1'\r\n part2 = 'data/simmc2_scene_images_dstc10_public_part2'\r\n if os.path.exists(part1+\"/\"+scene_thisround_1):\r\n scene_thisround = part1+\"/\"+scene_thisround_1\r\n elif os.path.exists(part2+\"/\"+scene_thisround_1):\r\n scene_thisround = part2+\"/\"+scene_thisround_1\r\n elif os.path.exists(part2+\"/\"+scene_thisround_new):\r\n scene_thisround = part2+\"/\"+scene_thisround_new\r\n elif os.path.exists(part1+\"/\"+scene_thisround_new):\r\n scene_thisround = part1+\"/\"+scene_thisround_new\r\n else: \r\n utils_f.save_imagef(scene_thisround + \".bin\")\r\n print(\"error can't find===========image file \",scene_thisround)\r\n exit(0)\r\n \r\n print(\"===========image file \",scene_thisround)\r\n\r\n\r\n # if os.path.basename(scene_thisround) == 'cloth_store_1416238_woman_4_8.png' or os.path.basename(scene_thisround) == 'cloth_store_1416238_woman_19_0.png':\r\n # return (-2,scene_thisround,id_final,type_final,bbox_final,label_final,None,prefab_final,0,0)\r\n\r\n bbox_length = list(range(len(bbox_final)))\r\n\r\n objname_final = []\r\n for prefab in prefab_final:\r\n prefab = prefab.replace(\"/\",\"_\")\r\n prefab = prefab.replace(\" \",\"_\")\r\n prefab = prefab.replace(\"(\",\"_\")\r\n prefab = prefab.replace(\")\",\"_\") \r\n objname_final.append(prefab)\r\n save_dir_root = sys.argv[2]\r\n\t\t\t\r\n obj_num = 0\r\n for label in label_final:\r\n if label == 1:\r\n obj_num = obj_num + 1\r\n if (len(objects_new) != obj_num):\r\n print(\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++find the error objnum and objid\", len(objects),obj_num,objects,id_final)\r\n if obj_num != 0 or len(objects) == 0:\r\n #image_feature = readimage_feature(scene_thisround, bbox_final)\r\n image_feature = utils_img.save_pred_image_otherview(scene_thisround_old,scene_thisround, bbox_final,type_final,id_final,save_dir_root,prefab_final)\r\n #image_feature = readimagefrombin_feature(scene_thisround, bbox_final)\r\n else: \r\n return (-1,scene_thisround,id_final,type_final,bbox_final,label_final,None,prefab_final,0,0)\t\t\t\r\n #for r in bbox_length:\r\n # bool_bbox = get_replace_flag(list(prefab_final[r]), list(bbox_final[r]))\r\n # flag_list.append(bool_bbox[0])\r\n\r\n #image_feature = utils_img.save_image(scene_thisround, bbox_final,type_final,objname_final,save_dir_root)\r\n #image_feature = utils_img.save_pred_image(did,scene_thisround, bbox_final,type_final,id_final,save_dir_root)\r\n #image_feature = utils_f.readimagefrombin_feature(scene_thisround, bbox_final,flag_list,prefab_final)\r\n # image_feature = readimage_feature(scene_thisround, bbox_final)\r\n return (dialogue_final,scene_thisround,id_final,type_final,bbox_final,label_final,image_feature,prefab_final,len(objects_new),obj_num)\r\n\r\n\r\n train = open(str(json_name), 'r')\r\n data = json.load(train)\r\n\r\n # 伪函数，read_image\r\n def readimage_feature(imagename, bbox_list):\r\n image_feature = []\r\n for i in range(len(bbox_list)):\r\n a = np.zeros((2054))\r\n image_feature.append(a)\r\n\r\n return image_feature\r\n\r\n # ——————————————————————————————————————————————————————————————————————————————————————————————————————————\r\n\r\n # metadata打开\r\n meta1 = open(str(dir_name)+'fashion_prefab_metadata_all.json', 'r')\r\n fashion = json.load(meta1)\r\n meta2 = open(str(dir_name)+'furniture_prefab_metadata_all.json', 'r')\r\n furniture = json.load(meta2)\r\n\r\n # 全局通用\r\n dialogue = (get_json_value(data, 'dialogue'))\r\n dialogue_data = get_json_value(data, 'dialogue_data')[0]\r\n sceneid = get_json_value(data, 'scene_ids')\r\n\r\n # 计数 用于标记dialogue_data下的对话\r\n # count = []\r\n # for index, value in enumerate(dialogue):\r\n # if value:\r\n # count.append(index)\r\n len_d = len(dialogue_data)\r\n if endid > len_d:\r\n count = np.arange(startid, len_d)\r\n else:\r\n count = np.arange(startid, endid)\r\n count_num = 0 \r\n save = []\r\n picture_mistake = []\r\n picture_mistake_all =[]\r\n \r\n for i in count:\r\n print('进入对话第', i, '轮') # 进入对话（例如对话第零轮）\r\n #print(\"========================================start convert count\",i)\r\n # 统计这一轮所有的对话数量\r\n dialogue = get_dict_value(dialogue_data[i], 'dialogue', None)\r\n length_thisround = np.arange(len(dialogue))\r\n\r\n # 统计这一轮所有对应的scenefile(即对应的图片文件名称，用列表保存，需要时按下标访问即可)\r\n scenefile = sceneid[i]\r\n\r\n\r\n # 建立一个大的list包含所有的\r\n for j in length_thisround:\r\n print('已经进入本轮中第', j, '个用例')\r\n scene_track = \"-1\"\r\n if len(list(scenefile.keys())) >= 2:\r\n if j >= int(list(scenefile.keys())[1]):\r\n scene_round = list(scenefile.values())[1]\r\n scene_track = list(scenefile.values())[0]\r\n\r\n else:\r\n scene_round = list(scenefile.values())[0] \r\n scene_track = list(scenefile.values())[1]\r\n else:\r\n scene_round = list(scenefile.values())[0]\r\n\r\n # 拆分对话，本轮对话为0,1,2,...j总和\r\n count_j = np.arange(j + 1)\r\n # print('本次用例涵盖的dialogue有', count_j)\r\n dialogue_thisround = [] # 这一次使用的具体用例\r\n for k in count_j:\r\n dialogue_thisround.append(dialogue[k])\r\n # print('本轮使用的dialogue是', dialogue_thisround)\r\n diag_id = i * 100 + j\r\n # 调用函数read_oneturn\r\n if 1:\r\n dialogue_final,scene_thisround,id_final,type_final,bbox_final,label_final,image_feature,prefab_final,objnum,findnum = read_thisturn(dialogue_thisround, scene_round,diag_id)\r\n if dialogue_final == -2:\r\n continue\r\n #if dialogue_final != -1 and objnum > findnum: \r\n # save.append((dialogue_final,scene_thisround,diag_id,id_final,type_final,bbox_final,label_final,image_feature,prefab_final))\r\n \r\n if dialogue_final == -1 or objnum > findnum:\r\n if scene_track != '-1':\r\n dialogue_final,scene_thisround,id_final,type_final,bbox_final,label_final,image_feature,prefab_final,objnum1,findnum1 = read_thisturn(dialogue_thisround, scene_track,diag_id)\r\n if dialogue_final == -1:\r\n print('+++++++++++++++find the error id', int(i*100+j),objnum,objnum1,findnum,findnum1)\r\n picture_mistake_all.append(int(i * 100 + j))\r\n elif objnum1 <= findnum + findnum1:\r\n picture_mistake.append(int(i * 100 + j))\r\n else:\r\n picture_mistake_all.append(int(i * 100 + j)) \r\n print('+++++++++++++++find the error id', int(i*100+j),objnum,findnum,findnum1)\r\n else:\r\n picture_mistake_all.append(int(i * 100 + j))\r\n print('+++++++++++++++find the error id', int(i*100+j),objnum,findnum)\r\n continue\r\n \r\n print('picture_mistake_did', int(i*100+j),objnum,findnum,findnum1)\r\n # except: \r\n # picture_mistake_all.append(int(i * 100 + j))\r\n # print(\"++++++++++++++++++++++++++++find the error ===\",diag_id)\r\n # continue\r\n\r\n # if len(image_feature) < len(label_final):\r\n # print(\"\")\r\n # continue \r\n #first_image_feature = [image_feature[0]]\r\n #print(len(image_feature[0]+image_feature[1:2]))\r\n #print((image_feature[0]+image_feature[1:2]))\r\n #num = int(len(label_final)/50)\r\n # if len(label_final) > 50:\r\n # for i in range(num):\r\n # if i < len(label_final)/50:\r\n # #try:\r\n # save.append((dialogue_final,scene_thisround,id_final[i*50:(i+1)*50],type_final[i*50:(i+1)*50], bbox_final[i*50:(i+1)*50], label_final[i*50:(i+1)*50], first_image_feature+image_feature[1+i*50:1+(i+1)*50]))\r\n #except:\r\n # continue\r\n # if len(label_final)%50 != 0:\r\n # i = int(len(label_final) / 50)\r\n # print(i*50)\r\n # print(id_final[i*50:])\r\n # save.append((dialogue_final,scene_thisround,id_final[i*50:],type_final[i*50:], bbox_final[i*50:], label_final[i*50:], first_image_feature+image_feature[1+i*50:]))\r\n # else:\r\n # save.append((dialogue_final,scene_thisround,diag_id,id_final,type_final,bbox_final,label_final,image_feature,prefab_final))\r\n # count_num = count_num + 1\r\n # if count_num % 1000 == 0:\r\n # print(\"image feature save\")\r\n # utils_f.save_imagef(startid)\r\n #CUDA_VISIBLE_DEVICES=4 python3 searchtotal_new.py 0 2500\r\n # filename = \"object0902v1alldata_noreplace\" +str(startid) + '.bin'\r\n # print(\"filename\",filename)\r\n # with open(filename, 'wb') as fp:\r\n # pickle.dump(save,fp)\r\n print('完毕')\r\n\r\nstartid = 0\r\nendid = 100000\r\n#utils_f.init_imagef(\"0820obj\"+str(startid))\r\nsearch(json_name, dir_name, startid, endid)\r\nutils_img.save_error_bin(str(startid))\r\n"
] | [
[
"torch.cuda.empty_cache",
"torch.cuda.set_device",
"torch.distributed.init_process_group"
],
[
"numpy.array"
],
[
"numpy.argsort",
"torch.from_numpy",
"numpy.sort",
"torch.nn.functional.adaptive_avg_pool2d"
],
[
"torch.max",
"torch.zeros",
"torch.cat",
"torch.utils.data.DataLoader",
"torch.sum",
"torch.no_grad",
"torch.device",
"torch.distributed.get_rank",
"torch.ones",
"torch.distributed.init_process_group",
"torch.utils.data.distributed.DistributedSampler",
"torch.distributed.barrier",
"torch.tensor",
"torch.utils.data.sampler.RandomSampler",
"torch.distributed.is_initialized",
"torch.exp",
"torch.nn.DataParallel",
"torch.distributed.is_available",
"torch.cuda.device_count",
"torch.distributed.get_world_size",
"numpy.array",
"torch.nn.parallel.DistributedDataParallel",
"torch.Tensor",
"torch.cuda.set_device",
"torch.utils.data.sampler.SequentialSampler"
],
[
"numpy.arange",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
casszhao/contextualizing-hate-speech-models-with-explanations | [
"adee4ef6fc4f1cb7b0be45c77a7a8e39a125873e",
"adee4ef6fc4f1cb7b0be45c77a7a8e39a125873e"
] | [
"new_subjectivity_score.py",
"run_ssidw.py"
] | [
"import nltk\nnltk.download('sentiwordnet')\nnltk.download('wordnet')\nnltk.download('averaged_perceptron_tagger')\nnltk.download('stopwords')\nnltk.download('punkt')\nfrom textblob import TextBlob\n\nfrom nltk.corpus import wordnet as wn\n\nimport pandas as pd\nimport numpy as np\nfrom nltk.stem import WordNetLemmatizer\nimport nltk\nfrom nltk.corpus import stopwords\nfrom nltk.tokenize import word_tokenize\nimport re\nfrom nltk.corpus import sentiwordnet as swn\n\n\n'''\nhttps://www.kaggle.com/yommnamohamed/sentiment-analysis-using-sentiwordnet#Results-of-Preprocessing-data-(Removing-stopwords-&-Lemmatization)\n'''\n\ndata=pd.read_csv('./data/wassem/train.tsv', sep='\\t')\nEdited_Review = data['text'].copy()\ndata['Review_without_stopwords'] = Edited_Review\nTITLE = 'Tweet 18k'\nprint(data)\n\n# Function to preprocess Reviews data\ndef preprocess_Reviews_data(data,name):\n # Proprocessing the data\n data[name]=data[name].str.lower()\n # Code to remove the Hashtags from the text\n data[name]=data[name].apply(lambda x:re.sub(r'\\B#\\S+','',x))\n # Code to remove the links from the text\n data[name]=data[name].apply(lambda x:re.sub(r\"http\\S+\", \"\", x))\n # Code to remove the Special characters from the text\n data[name]=data[name].apply(lambda x:' '.join(re.findall(r'\\w+', x)))\n # Code to substitute the multiple spaces with single spaces\n data[name]=data[name].apply(lambda x:re.sub(r'\\s+', ' ', x, flags=re.I))\n # Code to remove all the single characters in the text\n data[name]=data[name].apply(lambda x:re.sub(r'\\s+[a-zA-Z]\\s+', '', x))\n # Remove the twitter handlers\n data[name]=data[name].apply(lambda x:re.sub('@[^\\s]+','',x))\n\n\n# Function to tokenize and remove the stopwords\ndef rem_stopwords_tokenize(data, name):\n def getting(sen):\n example_sent = sen\n\n filtered_sentence = []\n\n stop_words = set(stopwords.words('english'))\n\n word_tokens = word_tokenize(example_sent)\n\n filtered_sentence = [w for w in word_tokens if not w in stop_words]\n\n return filtered_sentence\n\n # Using \"getting(sen)\" function to append edited sentence to data\n x = []\n for i in data[name].values:\n x.append(getting(i))\n data[name] = x\n\n\nlemmatizer = WordNetLemmatizer()\n\n\ndef Lemmatization(data, name):\n def getting2(sen):\n example = sen\n output_sentence = []\n word_tokens2 = word_tokenize(example)\n lemmatized_output = [lemmatizer.lemmatize(w) for w in word_tokens2]\n\n # Remove characters which have length less than 2\n without_single_chr = [word for word in lemmatized_output if len(word) > 2]\n # Remove numbers\n cleaned_data_title = [word for word in without_single_chr if not word.isnumeric()]\n\n return cleaned_data_title\n\n # Using \"getting2(sen)\" function to append edited sentence to data\n x = []\n for i in data[name].values:\n x.append(getting2(i))\n data[name] = x\n\n\ndef make_sentences(data,name):\n data[name]=data[name].apply(lambda x:' '.join([i+' ' for i in x]))\n # Removing double spaces if created\n data[name]=data[name].apply(lambda x:re.sub(r'\\s+', ' ', x, flags=re.I))\n\n\n# Using the preprocessing function to preprocess the hotel data\npreprocess_Reviews_data(data,'Review_without_stopwords')\n# Using tokenizer and removing the stopwords\nrem_stopwords_tokenize(data,'Review_without_stopwords')\n# Converting all the texts back to sentences\nmake_sentences(data,'Review_without_stopwords')\n\n#Edits After Lemmatization\nfinal_Edit = data['Review_without_stopwords'].copy()\ndata[\"After_lemmatization\"] = final_Edit\n\n# Using the Lemmatization function to lemmatize the hotel data\nLemmatization(data,'After_lemmatization')\n# Converting all the texts back to sentences\nmake_sentences(data,'After_lemmatization')\n\npos=neg=obj=count=0\n\npostagging = []\nfor review in data['After_lemmatization']:\n list = word_tokenize(review)\n postagging.append(nltk.pos_tag(list))\n\ndata['pos_tags'] = postagging\n\n\n\ndef penn_to_wn(tag):\n if tag.startswith('J'):\n return wn.ADJ\n elif tag.startswith('N'):\n return wn.NOUN\n elif tag.startswith('R'):\n return wn.ADV\n elif tag.startswith('V'):\n return wn.VERB\n return None\n\n\n\n\ndef get_sentiment(word, tag):\n wn_tag = penn_to_wn(tag)\n\n if wn_tag not in (wn.NOUN, wn.ADJ, wn.ADV):\n return []\n\n # Lemmatization\n lemma = lemmatizer.lemmatize(word, pos=wn_tag)\n if not lemma:\n return []\n\n # Synset is a special kind of a simple interface that is present in NLTK to look up words in WordNet.\n # Synset instances are the groupings of synonymous words that express the same concept.\n # Some of the words have only one Synset and some have several.\n synsets = wn.synsets(word, pos=wn_tag)\n if not synsets:\n return []\n\n # Take the first sense, the most common\n synset = synsets[0]\n swn_synset = swn.senti_synset(synset.name())\n\n return [synset.name(), swn_synset.pos_score(), swn_synset.neg_score(), swn_synset.obj_score()]\n\n pos = neg = obj = count = 0\n\n\nsenti_score = []\nSentiWordNet_Scores = []\n\nfor pos_val in data['pos_tags']:\n senti_val = [get_sentiment(x, y) for (x, y) in pos_val]\n for score in senti_val:\n try:\n pos = pos + score[1] # positive score is stored at 2nd position\n neg = neg + score[2] # negative score is stored at 3rd position\n sub = obj + score[3]\n except:\n continue\n senti_score.append(pos - neg)\n SentiWordNet_Scores.append(sub)\n sub = 0\n\nprint(len(senti_score))\ndata['sub_score'] = SentiWordNet_Scores\ndata['senti_score'] = senti_score\nprint(data['sub_score'])\n\nTextBlob_Scores = []\nfor sent in data['text'].to_list():\n sent128 = sent.lower()\n # print(sent128)\n # break\n blob = TextBlob(sent128)\n subjective = blob.sentiment.subjectivity\n # polarity = blob.sentiment.polarity\n #bb_polarity.append(polarity)\n TextBlob_Scores.append(subjective)\n\n\nprint(len(data['text'].to_list()))\nprint(len(TextBlob_Scores))\n\nimport matplotlib\nimport matplotlib.pyplot as plt\n\nprint('overall data: ', len(SentiWordNet_Scores))\nprint('overall data: ', len(TextBlob_Scores))\n\nprint('for TextBlob_Scores : ')\nprint((TextBlob_Scores.count(0)+TextBlob_Scores.count(1))/ len(TextBlob_Scores))\n\nprint('for SentiWordNet_Scores : ')\nprint((SentiWordNet_Scores.count(0)+SentiWordNet_Scores.count(1))/ len(SentiWordNet_Scores))\n\nd = {\"SentiWordNet\": SentiWordNet_Scores, \"TextBlob\": TextBlob_Scores}\n\ndf = pd.DataFrame(d)\ndf.to_csv('./data/tweet18k_plot.csv')\n\n\n\nbins = np.linspace(0, 1, 30)\nplt.hist(SentiWordNet_Scores, bins, alpha=0.5, label='SentiWordNet')\nplt.hist(TextBlob_Scores, bins, alpha=0.5, label='TextBlob')\nplt.tick_params(labelsize=11)\nplt.xlabel(\"Subjective Score\",fontsize=12)\nplt.ylabel(\"Numbers of Comments\",fontsize=12)\nplt.legend([\"SentiWordNet\", \"TextBlob\"], prop={\"size\":12})\nplt.rc('legend', fontsize=14)\nplt.title(TITLE, fontsize=17)\nplt.show()",
"from __future__ import absolute_import, division, print_function\n\nimport argparse\nimport csv\nimport logging\nimport os\nimport random\nimport sys\nimport json\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch.utils.data import (DataLoader, RandomSampler, SequentialSampler,\n TensorDataset)\nfrom torch.utils.data.distributed import DistributedSampler\nfrom torch import nn\nfrom torch.nn import functional as F\nfrom tqdm import tqdm, trange\n\n\"\"\"\nRunning BERT finetuning & evaluation on hate speech classification datasets.\nIntegrated with SOC explanation regularization\n\"\"\"\n\nfrom torch.nn import CrossEntropyLoss, MSELoss\nfrom scipy.stats import pearsonr, spearmanr\nfrom sklearn.metrics import matthews_corrcoef, f1_score, confusion_matrix, classification_report\nfrom sklearn.metrics import precision_score, recall_score, roc_auc_score\n\nfrom bert.file_utils import PYTORCH_PRETRAINED_BERT_CACHE, WEIGHTS_NAME, CONFIG_NAME\nfrom bert.modeling import BertForSequenceClassification, BertConfig, BertForSequenceClassification_Ss_IDW\nfrom bert.tokenization import BertTokenizer\nfrom bert.optimization import BertAdam, WarmupLinearSchedule\n\nfrom loader import GabProcessor, WSProcessor, NytProcessor, convert_examples_to_features #,,multiclass_Processor, multilabel_Processor\nfrom utils.config import configs, combine_args\n\n# for hierarchical explanation algorithms\nfrom hiex import SamplingAndOcclusionExplain\n\nlogger = logging.getLogger(__name__)\n\ndef simple_accuracy(preds, labels):\n return (preds == labels).mean()\n\n\ndef acc_and_f1(preds, labels, pred_probs):\n acc = simple_accuracy(preds, labels)\n f1 = f1_score(y_true=labels, y_pred=preds)\n p, r = precision_score(y_true=labels, y_pred=preds), recall_score(y_true=labels, y_pred=preds)\n try:\n roc = roc_auc_score(y_true=labels, y_score=pred_probs[:,1])\n except ValueError:\n roc = 0.\n return {\n \"acc\": acc,\n \"f1\": f1,\n \"precision\": p,\n \"recall\": r,\n \"auc_roc\": roc\n }\n\n\ndef pearson_and_spearman(preds, labels):\n pearson_corr = pearsonr(preds, labels)[0]\n spearman_corr = spearmanr(preds, labels)[0]\n return {\n \"pearson\": pearson_corr,\n \"spearmanr\": spearman_corr,\n \"corr\": (pearson_corr + spearman_corr) / 2,\n }\n\n\ndef compute_metrics(task_name, preds, labels, pred_probs):\n assert len(preds) == len(labels)\n return acc_and_f1(preds, labels, pred_probs)\n\n\ndef main():\n parser = argparse.ArgumentParser()\n\n ## Required parameters\n parser.add_argument(\"--data_dir\",\n default=None,\n type=str,\n required=True,\n help=\"The input data dir. Should contain the .tsv files (or other data files) for the task.\")\n parser.add_argument(\"--bert_model\", default=None, type=str, required=True,\n help=\"Bert pre-trained model selected in the list: bert-base-uncased, \"\n \"bert-large-uncased, bert-base-cased, bert-large-cased, bert-base-multilingual-uncased, \"\n \"bert-base-multilingual-cased, bert-base-chinese.\")\n parser.add_argument(\"--task_name\",\n default=None,\n type=str,\n required=True,\n help=\"The name of the task to train.\")\n parser.add_argument(\"--output_dir\",\n default=None,\n type=str,\n required=True,\n help=\"The output directory where the model predictions and checkpoints will be written.\")\n parser.add_argument(\"--negative_weight\", default=1., type=float)\n parser.add_argument(\"--neutral_words_file\", default='data/identity.csv')\n\n # if true, use test data instead of val data\n parser.add_argument(\"--test\", action='store_true')\n\n # Explanation specific arguments below\n\n # whether run explanation algorithms\n parser.add_argument(\"--explain\", action='store_true', help='if true, explain test set predictions')\n parser.add_argument(\"--debug\", action='store_true')\n\n # which algorithm to run\n parser.add_argument(\"--algo\", choices=['soc'])\n\n # the output filename without postfix\n parser.add_argument(\"--output_filename\", default='temp.tmp')\n\n # see utils/config.py\n parser.add_argument(\"--use_padding_variant\", action='store_true')\n parser.add_argument(\"--mask_outside_nb\", action='store_true')\n parser.add_argument(\"--nb_range\", type=int)\n parser.add_argument(\"--sample_n\", type=int)\n\n # whether use explanation regularization\n parser.add_argument(\"--reg_explanations\", action='store_true')\n parser.add_argument(\"--reg_strength\", type=float)\n parser.add_argument(\"--reg_mse\", action='store_true')\n\n # whether discard other neutral words during regularization. default: False\n parser.add_argument(\"--discard_other_nw\", action='store_false', dest='keep_other_nw')\n\n # whether remove neutral words when loading datasets\n parser.add_argument(\"--remove_nw\", action='store_true')\n\n # if true, generate hierarchical explanations instead of word level outputs.\n # Only useful when the --explain flag is also added.\n parser.add_argument(\"--hiex\", action='store_true')\n parser.add_argument(\"--hiex_tree_height\", default=5, type=int)\n\n # whether add the sentence itself to the sample set in SOC\n parser.add_argument(\"--hiex_add_itself\", action='store_true')\n\n # the directory where the lm is stored\n parser.add_argument(\"--lm_dir\", default='runs/lm')\n\n # if configured, only generate explanations for instances with given line numbers\n parser.add_argument(\"--hiex_idxs\", default=None)\n # if true, use absolute values of explanations for hierarchical clustering\n parser.add_argument(\"--hiex_abs\", action='store_true')\n\n # if either of the two is true, only generate explanations for positive / negative instances\n parser.add_argument(\"--only_positive\", action='store_true')\n parser.add_argument(\"--only_negative\", action='store_true')\n\n # stop after generating x explanation\n parser.add_argument(\"--stop\", default=100000000, type=int)\n\n # early stopping with decreasing learning rate. 0: direct exit when validation F1 decreases\n parser.add_argument(\"--early_stop\", default=5, type=int)\n\n # other external arguments originally here in pytorch_transformers\n\n parser.add_argument(\"--cache_dir\",\n default=\"\",\n type=str,\n help=\"Where do you want to store the pre-trained models downloaded from s3\")\n parser.add_argument(\"--max_seq_length\",\n default=128,\n type=int,\n help=\"The maximum total input sequence length after WordPiece tokenization. \\n\"\n \"Sequences longer than this will be truncated, and sequences shorter \\n\"\n \"than this will be padded.\")\n parser.add_argument(\"--do_train\",\n action='store_true',\n help=\"Whether to run training.\")\n parser.add_argument(\"--do_eval\",\n action='store_true',\n help=\"Whether to run eval on the dev set.\")\n parser.add_argument(\"--do_lower_case\",\n action='store_true',\n help=\"Set this flag if you are using an uncased model.\")\n parser.add_argument(\"--train_batch_size\",\n default=32,\n type=int,\n help=\"Total batch size for training.\")\n parser.add_argument(\"--eval_batch_size\",\n default=32,\n type=int,\n help=\"Total batch size for eval.\")\n parser.add_argument(\"--validate_steps\",\n default=200,\n type=int,\n help=\"validate once for how many steps\")\n parser.add_argument(\"--alpha\",\n default=0.5,\n type=float,\n help=\"multi task hypeparameter\")\n parser.add_argument(\"--learning_rate\",\n default=5e-5,\n type=float,\n help=\"The initial learning rate for Adam.\")\n parser.add_argument(\"--num_train_epochs\",\n default=3.0,\n type=float,\n help=\"Total number of training epochs to perform.\")\n parser.add_argument(\"--warmup_proportion\",\n default=0.1,\n type=float,\n help=\"Proportion of training to perform linear learning rate warmup for. \"\n \"E.g., 0.1 = 10%% of training.\")\n parser.add_argument(\"--no_cuda\",\n action='store_true',\n help=\"Whether not to use CUDA when available\")\n parser.add_argument(\"--local_rank\",\n type=int,\n default=-1,\n help=\"local_rank for distributed training on gpus\")\n parser.add_argument('--seed',\n type=int,\n default=42,\n help=\"random seed for initialization\")\n parser.add_argument('--gradient_accumulation_steps',\n type=int,\n default=1,\n help=\"Number of updates steps to accumulate before performing a backward/update pass.\")\n parser.add_argument('--fp16',\n action='store_true',\n help=\"Whether to use 16-bit float precision instead of 32-bit\")\n parser.add_argument('--loss_scale',\n type=float, default=0,\n help=\"Loss scaling to improve fp16 numeric stability. Only used when fp16 set to True.\\n\"\n \"0 (default value): dynamic loss scaling.\\n\"\n \"Positive power of 2: static loss scaling value.\\n\")\n parser.add_argument('--server_ip', type=str, default='', help=\"Can be used for distant debugging.\")\n parser.add_argument('--server_port', type=str, default='', help=\"Can be used for distant debugging.\")\n args = parser.parse_args()\n\n combine_args(configs, args)\n args = configs\n\n if args.server_ip and args.server_port:\n # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script\n import ptvsd\n print(\"Waiting for debugger attach\")\n ptvsd.enable_attach(address=(args.server_ip, args.server_port), redirect_output=True)\n ptvsd.wait_for_attach()\n\n processors = {\n 'gab': GabProcessor,\n 'ws': WSProcessor,\n 'nyt': NytProcessor,\n #'multi-class': multiclass_Processor,\n #'multi-label': multilabel_Processor,\n }\n\n output_modes = {\n 'gab': 'classification',\n 'ws': 'classification',\n 'nyt': 'classification'\n }\n\n if args.local_rank == -1 or args.no_cuda:\n device = torch.device(\"cuda\" if torch.cuda.is_available() and not args.no_cuda else \"cpu\")\n n_gpu = torch.cuda.device_count()\n else:\n torch.cuda.set_device(args.local_rank)\n device = torch.device(\"cuda\", args.local_rank)\n n_gpu = 1\n # Initializes the distributed backend which will take care of sychronizing nodes/GPUs\n torch.distributed.init_process_group(backend='nccl')\n\n logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',\n datefmt='%m/%d/%Y %H:%M:%S',\n level=logging.INFO if args.local_rank in [-1, 0] else logging.WARN)\n\n logger.info(\"device: {} n_gpu: {}, distributed training: {}, 16-bits training: {}\".format(\n device, n_gpu, bool(args.local_rank != -1), args.fp16))\n\n if args.gradient_accumulation_steps < 1:\n raise ValueError(\"Invalid gradient_accumulation_steps parameter: {}, should be >= 1\".format(\n args.gradient_accumulation_steps))\n\n args.train_batch_size = args.train_batch_size // args.gradient_accumulation_steps\n\n random.seed(args.seed)\n np.random.seed(args.seed)\n torch.manual_seed(args.seed)\n if n_gpu > 0:\n torch.cuda.manual_seed_all(args.seed)\n\n if not args.do_train and not args.do_eval:\n raise ValueError(\"At least one of `do_train` or `do_eval` must be True.\")\n\n #if os.path.exists(args.output_dir) and os.listdir(args.output_dir) and args.do_train:\n # raise ValueError(\"Output directory ({}) already exists and is not empty.\".format(args.output_dir))\n if not os.path.exists(args.output_dir):\n os.makedirs(args.output_dir)\n\n # save configs\n f = open(os.path.join(args.output_dir, 'args.json'), 'w')\n json.dump(args.__dict__, f, indent=4)\n f.close()\n\n task_name = args.task_name.lower()\n\n if task_name not in processors:\n raise ValueError(\"Task not found: %s\" % (task_name))\n\n tokenizer = BertTokenizer.from_pretrained(args.bert_model, do_lower_case=args.do_lower_case)\n processor = processors[task_name](configs, tokenizer=tokenizer)\n output_mode = output_modes[task_name]\n\n label_list = processor.get_labels()\n num_labels = len(label_list)\n\n train_examples = None\n num_train_optimization_steps = None\n if args.do_train:\n train_examples = processor.get_train_examples(args.data_dir)\n num_train_optimization_steps = int(\n len(train_examples) / args.train_batch_size / args.gradient_accumulation_steps) * args.num_train_epochs\n if args.local_rank != -1:\n num_train_optimization_steps = num_train_optimization_steps // torch.distributed.get_world_size()\n\n # Prepare model\n cache_dir = args.cache_dir if args.cache_dir else os.path.join(str(PYTORCH_PRETRAINED_BERT_CACHE),\n 'distributed_{}'.format(args.local_rank))\n\n\n\n words_csv_file = args.neutral_words_file\n\n def csv2set(words_csv_file):\n data = pd.read_csv(words_csv_file, sep='\\t', header=None)\n\n identifiers_set = set(data[0].tolist())\n # with open('./idw.txt', 'a') as f:\n # for line in identity:\n # f.write(\"%s\\n\" % line)\n return identifiers_set\n\n\n igw_after_chuli = csv2set(words_csv_file)\n\n if args.do_train:\n model = BertForSequenceClassification_Ss_IDW.from_pretrained(args.bert_model,\n cache_dir=cache_dir,\n num_labels=num_labels,\n igw_after_chuli=igw_after_chuli,\n tokenizer=BertTokenizer.from_pretrained(\n 'bert-base-uncased', do_lower_case=True),\n )\n\n\n else:\n model = BertForSequenceClassification_Ss_IDW.from_pretrained(args.output_dir, num_labels=num_labels,\n igw_after_chuli=igw_after_chuli,\n tokenizer=BertTokenizer.from_pretrained(\n 'bert-base-uncased', do_lower_case=True),\n )\n\n model.to(device)\n\n if args.fp16:\n model.half()\n\n if args.local_rank != -1:\n try:\n from apex.parallel import DistributedDataParallel as DDP\n except ImportError:\n raise ImportError(\n \"Please install apex from https://www.github.com/nvidia/apex to use distributed and fp16 training.\")\n\n model = DDP(model)\n # elif n_gpu > 1:\n # model = torch.nn.DataParallel(model)\n\n # Prepare optimizer\n param_optimizer = list(model.named_parameters())\n no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n optimizer_grouped_parameters = [\n {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)], 'weight_decay': 0.01},\n {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}\n ]\n if args.fp16:\n try:\n from apex.optimizers import FP16_Optimizer\n from apex.optimizers import FusedAdam\n except ImportError:\n raise ImportError(\n \"Please install apex from https://www.github.com/nvidia/apex to use distributed and fp16 training.\")\n\n optimizer = FusedAdam(optimizer_grouped_parameters,\n lr=args.learning_rate,\n bias_correction=False,\n max_grad_norm=1.0)\n if args.loss_scale == 0:\n optimizer = FP16_Optimizer(optimizer, dynamic_loss_scale=True)\n else:\n optimizer = FP16_Optimizer(optimizer, static_loss_scale=args.loss_scale)\n warmup_linear = WarmupLinearSchedule(warmup=args.warmup_proportion,\n t_total=num_train_optimization_steps)\n\n else:\n if args.do_train:\n optimizer = BertAdam(optimizer_grouped_parameters,\n lr=args.learning_rate,\n warmup=args.warmup_proportion,\n t_total=num_train_optimization_steps)\n\n global_step = 0\n nb_tr_steps = 0\n tr_loss, tr_reg_loss = 0, 0\n tr_reg_cnt = 0\n epoch = -1\n val_best_f1 = -1\n val_best_loss = 1e10\n early_stop_countdown = args.early_stop\n\n if args.reg_explanations:\n train_lm_dataloder = processor.get_dataloader('train', configs.train_batch_size)\n dev_lm_dataloader = processor.get_dataloader('dev', configs.train_batch_size)\n explainer = SamplingAndOcclusionExplain(model, configs, tokenizer, device=device, vocab=tokenizer.vocab,\n train_dataloader=train_lm_dataloder,\n dev_dataloader=dev_lm_dataloader,\n lm_dir=args.lm_dir,\n output_path=os.path.join(configs.output_dir,\n configs.output_filename),\n\n )\n else:\n explainer = None\n\n if args.do_train:\n epoch = 0\n train_features = convert_examples_to_features(\n train_examples, label_list, args.max_seq_length, tokenizer, output_mode, configs)\n logger.info(\"***** Running training *****\")\n logger.info(\" Num examples = %d\", len(train_examples))\n logger.info(\" Batch size = %d\", args.train_batch_size)\n logger.info(\" Num steps = %d\", num_train_optimization_steps)\n all_input_ids = torch.tensor([f.input_ids for f in train_features], dtype=torch.long)\n all_input_mask = torch.tensor([f.input_mask for f in train_features], dtype=torch.long)\n all_segment_ids = torch.tensor([f.segment_ids for f in train_features], dtype=torch.long)\n\n if output_mode == \"classification\":\n all_label_ids = torch.tensor([f.label_id for f in train_features], dtype=torch.long)\n elif output_mode == \"regression\":\n all_label_ids = torch.tensor([f.label_id for f in train_features], dtype=torch.float)\n\n train_data = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_label_ids)\n if args.local_rank == -1:\n train_sampler = RandomSampler(train_data)\n else:\n train_sampler = DistributedSampler(train_data)\n train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=args.train_batch_size)\n\n class_weight = torch.FloatTensor([args.negative_weight, 1]).to(device)\n\n model.train()\n for _ in trange(int(args.num_train_epochs), desc=\"Epoch\"):\n tr_loss = 0\n nb_tr_examples, nb_tr_steps = 0, 0\n for step, batch in enumerate(tqdm(train_dataloader, desc=\"Iteration\")):\n batch = tuple(t.to(device) for t in batch)\n input_ids, input_mask, segment_ids, label_ids = batch\n\n # Not feed label to get logits\n logits = model(input_ids, segment_ids, input_mask, labels=None, device=device)\n\n if output_mode == \"classification\":\n loss_fct = CrossEntropyLoss(class_weight)\n loss = loss_fct(logits.view(-1, num_labels), label_ids.view(-1))\n elif output_mode == \"regression\":\n loss_fct = MSELoss()\n loss = loss_fct(logits.view(-1), label_ids.view(-1))\n\n if n_gpu > 1:\n loss = loss.mean() # mean() to average on multi-gpu.\n if args.gradient_accumulation_steps > 1:\n loss = loss / args.gradient_accumulation_steps\n tr_loss += loss.item()\n if args.fp16:\n optimizer.backward(loss)\n else:\n loss.backward()\n\n # regularize explanations\n # NOTE: backward performed inside this function to prevent OOM\n\n if args.reg_explanations:\n reg_loss, reg_cnt = explainer.compute_explanation_loss(input_ids, input_mask, segment_ids, label_ids,\n do_backprop=True)\n tr_reg_loss += reg_loss # float\n tr_reg_cnt += reg_cnt\n\n nb_tr_examples += input_ids.size(0)\n nb_tr_steps += 1\n if (step + 1) % args.gradient_accumulation_steps == 0:\n if args.fp16:\n # modify learning rate with special warm up BERT uses\n # if args.fp16 is False, BertAdam is used that handles this automatically\n lr_this_step = args.learning_rate * warmup_linear.get_lr(\n global_step / num_train_optimization_steps,\n args.warmup_proportion)\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr_this_step\n optimizer.step()\n optimizer.zero_grad()\n global_step += 1\n\n if global_step % args.validate_steps == 0:\n #print('global_step: %d' % global_step)\n #print('args.test: %s' % str(args.test)) #args.test: False\n\n val_result = validate(args, model, processor, tokenizer, output_mode, label_list, device,\n num_labels, task_name, tr_loss, global_step, epoch, explainer)\n val_acc, val_f1 = val_result['acc'], val_result['f1']\n if val_f1 > val_best_f1:\n val_best_f1 = val_f1\n if args.local_rank == -1 or torch.distributed.get_rank() == 0:\n save_model(args, model, tokenizer, num_labels)\n else:\n # halve the learning rate\n for param_group in optimizer.param_groups:\n param_group['lr'] *= 0.5\n early_stop_countdown -= 1\n logger.info(\"Reducing learning rate... Early stop countdown %d\" % early_stop_countdown)\n if early_stop_countdown < 0:\n break\n if early_stop_countdown < 0:\n break\n epoch += 1\n\n # if args.do_eval and (args.local_rank == -1 or torch.distributed.get_rank() == 0):\n # if not args.explain:\n # args.test = True\n # print('--Test_args.test: %s' % str(args.test)) #Test_args.test: True\n # validate(args, model, processor, tokenizer, output_mode, label_list, device, num_labels,\n # task_name, tr_loss, global_step=888, epoch=-1, explainer=explainer)\n # else:\n # print('--Test_args.test: %s' % str(args.test)) # Test_args.test: True\n # args.test = True\n # explain(args, model, processor, tokenizer, output_mode, label_list, device)\n\n\n if not args.explain:\n args.test = True\n print('--Test_args.test: %s' % str(args.test)) #Test_args.test: True\n validate(args, model, processor, tokenizer, output_mode, label_list, device, num_labels,\n task_name, tr_loss, global_step=888, epoch=-1, explainer=explainer)\n args.test = False\n else:\n print('--Test_args.test: %s' % str(args.test)) # Test_args.test: True\n args.test = True\n explain(args, model, processor, tokenizer, output_mode, label_list, device)\n args.test = False\n\n\ndef validate(args, model, processor, tokenizer, output_mode, label_list, device, num_labels,\n task_name, tr_loss, global_step, epoch, explainer=None):\n if not args.test:\n eval_examples = processor.get_dev_examples(args.data_dir)\n else:\n eval_examples = processor.get_test_examples(args.data_dir)\n #print('using test dataset')\n eval_features = convert_examples_to_features(eval_examples, label_list, args.max_seq_length,\n tokenizer, output_mode, configs)\n logger.info(\"***** Running evaluation *****\")\n logger.info(\" Num examples = %d\", len(eval_examples))\n logger.info(\" Batch size = %d\", args.eval_batch_size)\n all_input_ids = torch.tensor([f.input_ids for f in eval_features], dtype=torch.long)\n all_input_mask = torch.tensor([f.input_mask for f in eval_features], dtype=torch.long)\n all_segment_ids = torch.tensor([f.segment_ids for f in eval_features], dtype=torch.long)\n\n if output_mode == \"classification\":\n all_label_ids = torch.tensor([f.label_id for f in eval_features], dtype=torch.long)\n elif output_mode == \"regression\":\n all_label_ids = torch.tensor([f.label_id for f in eval_features], dtype=torch.float)\n\n eval_data = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_label_ids)\n # Run prediction for full data\n eval_sampler = SequentialSampler(eval_data)\n eval_dataloader = DataLoader(eval_data, sampler=eval_sampler, batch_size=args.eval_batch_size)\n\n model.train(False)\n eval_loss, eval_loss_reg = 0, 0\n eval_reg_cnt = 0\n nb_eval_steps = 0\n preds = []\n\n # for detailed prediction results\n input_seqs = []\n\n for input_ids, input_mask, segment_ids, label_ids in tqdm(eval_dataloader, desc=\"Evaluating\"):\n input_ids = input_ids.to(device)\n input_mask = input_mask.to(device)\n segment_ids = segment_ids.to(device)\n label_ids = label_ids.to(device)\n\n with torch.no_grad():\n logits = model(input_ids, segment_ids, input_mask, labels=None, device=device)\n\n # create eval loss and other metric required by the task\n if output_mode == \"classification\":\n loss_fct = CrossEntropyLoss()\n tmp_eval_loss = loss_fct(logits.view(-1, num_labels), label_ids.view(-1))\n elif output_mode == \"regression\":\n loss_fct = MSELoss()\n tmp_eval_loss = loss_fct(logits.view(-1), label_ids.view(-1))\n\n eval_loss += tmp_eval_loss.mean().item()\n\n if args.reg_explanations:\n with torch.no_grad():\n reg_loss, reg_cnt = explainer.compute_explanation_loss(input_ids, input_mask, segment_ids, label_ids,\n do_backprop=False)\n #eval_loss += reg_loss.item()\n eval_loss_reg += reg_loss\n eval_reg_cnt += reg_cnt\n\n nb_eval_steps += 1\n if len(preds) == 0:\n preds.append(logits.detach().cpu().numpy())\n else:\n preds[0] = np.append(preds[0], logits.detach().cpu().numpy(), axis=0)\n\n for b in range(input_ids.size(0)):\n i = 0\n while i < input_ids.size(1) and input_ids[b,i].item() != 0:\n i += 1\n token_list = tokenizer.convert_ids_to_tokens(input_ids[b,:i].cpu().numpy().tolist())\n input_seqs.append(' '.join(token_list))\n\n\n eval_loss = eval_loss / nb_eval_steps\n eval_loss_reg = eval_loss_reg / (eval_reg_cnt + 1e-10)\n preds = preds[0]\n if output_mode == \"classification\":\n pred_labels = np.argmax(preds, axis=1)\n elif output_mode == \"regression\":\n pred_labels = np.squeeze(preds)\n pred_prob = F.softmax(torch.from_numpy(preds).float(), -1).numpy()\n result = compute_metrics(task_name, pred_labels, all_label_ids.numpy(), pred_prob)\n loss = tr_loss / (global_step + 1e-10) if args.do_train else None\n\n result['eval_loss'] = eval_loss\n result['eval_loss_reg'] = eval_loss_reg\n result['global_step'] = global_step\n result['loss'] = loss\n\n if global_step == 888:\n CM = confusion_matrix(all_label_ids.numpy(), pred_labels)\n TN = CM[0][0]\n FN = CM[1][0]\n TP = CM[1][1]\n FP = CM[0][1]\n\n result['True Negative'] = TN\n result['False Negative'] = FN\n result['True Positive'] = TP\n result['False Positive'] = FP\n\n split = 'dev' if not args.test else 'test'\n\n # write results file\n output_eval_file = os.path.join(args.output_dir, \"eval_results_%d_%s_%s.txt\"\n % (global_step, split, args.task_name))\n with open(output_eval_file, \"w\") as writer:\n logger.info(\"***** Eval results *****\")\n logger.info(\"Epoch %d\" % epoch)\n for key in sorted(result.keys()):\n logger.info(\" %s = %s\", key, str(result[key]))\n writer.write(\"%s = %s\\n\" % (key, str(result[key])))\n\n # write details file\n output_detail_file = os.path.join(args.output_dir, \"eval_details_%d_%s_%s.txt\"\n % (global_step, split, args.task_name))\n with open(output_detail_file,'w') as writer:\n for i, seq in enumerate(input_seqs):\n pred = preds[i]\n gt = all_label_ids[i]\n prediction = pred_labels[i]\n writer.write('{}\\t{}\\t{}\\t{}\\n'.format(gt, prediction, pred, seq))\n\n model.train(True)\n return result\n\n\ndef explain(args, model, processor, tokenizer, output_mode, label_list, device):\n \"\"\"\n Added into run_model.py to support explanations\n :param args: configs, or args\n :param model: The model to be explained\n :param processor: For explanations on Gab/WS etc. Dataset, take an instance of Processor as input.\n See Processor for details about the processor\n :param tokenizer: The default BERT tokenizer\n :param output_mode: \"classification\" for Gab\n :param label_list: \"[0,1]\" for Gab\n :param device: An instance of torch.device\n :return:\n \"\"\"\n assert args.eval_batch_size == 1\n processor.set_tokenizer(tokenizer)\n\n if args.algo == 'soc':\n try:\n train_lm_dataloder = processor.get_dataloader('train', configs.train_batch_size)\n dev_lm_dataloader = processor.get_dataloader('dev', configs.train_batch_size)\n except FileNotFoundError:\n train_lm_dataloder = None\n dev_lm_dataloader = None\n\n explainer = SamplingAndOcclusionExplain(model, configs, tokenizer, device=device, vocab=tokenizer.vocab,\n train_dataloader=train_lm_dataloder,\n dev_dataloader=dev_lm_dataloader,\n lm_dir=args.lm_dir,\n output_path=os.path.join(configs.output_dir, configs.output_filename),\n )\n else:\n raise ValueError\n\n label_filter = None\n if args.only_positive and args.only_negative:\n label_filter = None\n elif args.only_positive: label_filter = 1\n elif args.only_negative: label_filter = 0\n\n if not args.test:\n eval_examples = processor.get_dev_examples(args.data_dir, label=label_filter)\n else:\n eval_examples = processor.get_test_examples(args.data_dir, label=label_filter)\n eval_features = convert_examples_to_features(\n eval_examples, label_list, args.max_seq_length, tokenizer, output_mode, configs)\n logger.info(\"***** Running evaluation *****\")\n logger.info(\" Num examples = %d\", len(eval_examples))\n logger.info(\" Batch size = %d\", args.eval_batch_size)\n all_input_ids = torch.tensor([f.input_ids for f in eval_features], dtype=torch.long)\n all_input_mask = torch.tensor([f.input_mask for f in eval_features], dtype=torch.long)\n all_segment_ids = torch.tensor([f.segment_ids for f in eval_features], dtype=torch.long)\n\n if output_mode == \"classification\":\n all_label_ids = torch.tensor([f.label_id for f in eval_features], dtype=torch.long)\n elif output_mode == \"regression\":\n all_label_ids = torch.tensor([f.label_id for f in eval_features], dtype=torch.float)\n\n eval_data = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_label_ids)\n # Run prediction for full data\n eval_sampler = SequentialSampler(eval_data)\n eval_dataloader = DataLoader(eval_data, sampler=eval_sampler, batch_size=args.eval_batch_size)\n\n if args.hiex_idxs:\n with open(args.hiex_idxs) as f:\n hiex_idxs = json.load(f)['idxs']\n print('Loaded line numbers for explanation')\n else:\n hiex_idxs = []\n\n model.train(False)\n for i, (input_ids, input_mask, segment_ids, label_ids) in tqdm(enumerate(eval_dataloader), desc=\"Evaluating\"):\n if i == args.stop: break\n if hiex_idxs and i not in hiex_idxs: continue\n input_ids = input_ids.to(device)\n input_mask = input_mask.to(device)\n segment_ids = segment_ids.to(device)\n label_ids = label_ids.to(device)\n\n if not args.hiex:\n explainer.word_level_explanation_bert(input_ids, input_mask, segment_ids, label_ids)\n else:\n explainer.hierarchical_explanation_bert(input_ids, input_mask, segment_ids, label_ids)\n if hasattr(explainer, 'dump'):\n explainer.dump()\n\ndef save_model(args, model, tokenizer, num_labels):\n # Save a trained model, configuration and tokenizer\n model_to_save = model.module if hasattr(model, 'module') else model # Only save the model it-self\n\n # If we save using the predefined names, we can load using `from_pretrained`\n output_model_file = os.path.join(args.output_dir, WEIGHTS_NAME)\n output_config_file = os.path.join(args.output_dir, CONFIG_NAME)\n\n torch.save(model_to_save.state_dict(), output_model_file)\n model_to_save.config.to_json_file(output_config_file)\n tokenizer.save_vocabulary(args.output_dir)\n\nif __name__ == \"__main__\":\n main()\n"
] | [
[
"matplotlib.pyplot.legend",
"pandas.read_csv",
"numpy.linspace",
"matplotlib.pyplot.title",
"matplotlib.pyplot.rc",
"pandas.DataFrame",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.show",
"matplotlib.pyplot.tick_params",
"matplotlib.pyplot.hist",
"matplotlib.pyplot.ylabel"
],
[
"sklearn.metrics.roc_auc_score",
"numpy.squeeze",
"torch.utils.data.DataLoader",
"torch.no_grad",
"torch.FloatTensor",
"torch.cuda.manual_seed_all",
"torch.cuda.is_available",
"torch.device",
"scipy.stats.spearmanr",
"sklearn.metrics.f1_score",
"torch.distributed.get_rank",
"torch.nn.CrossEntropyLoss",
"pandas.read_csv",
"torch.distributed.init_process_group",
"torch.utils.data.distributed.DistributedSampler",
"torch.utils.data.TensorDataset",
"torch.from_numpy",
"torch.tensor",
"numpy.argmax",
"scipy.stats.pearsonr",
"sklearn.metrics.precision_score",
"torch.cuda.device_count",
"torch.distributed.get_world_size",
"sklearn.metrics.recall_score",
"numpy.random.seed",
"torch.cuda.set_device",
"torch.manual_seed",
"torch.utils.data.SequentialSampler",
"torch.utils.data.RandomSampler",
"torch.nn.MSELoss"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"1.3",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"0.16",
"1.8"
],
"tensorflow": []
}
] |
DavorJordacevic/DeepLearningFaceRecognitionSystem | [
"b0664226d2352d7f844aa07a70566b10e9e5362c"
] | [
"utils/videoProcessor.py"
] | [
"import cv2\nimport time\nimport dlib\nimport mtcnn\nimport numpy as np\n\n### THIS WILL BE DELETED ###\n\nclass VideoProcessor:\n def __init__(self, video_source, cfg):\n\n self.video_source = video_source\n self.detector_type = cfg[\"face_detector\"]\n self.dnn_detector_path = cfg[\"face_det_model_path\"]\n self.haar_model_file = cfg[\"opencv_face_detector_uint8\"]\n self.haar_config_file = cfg[\"opencv_face_detector_pbtxt\"]\n self.recognizer = cfg[\"face_recognition\"]\n self.recognizer_path = cfg[\"face_reco_model_path\"]\n self.threshold = cfg[\"threshold\"]\n self.tracker_type = cfg[\"tracker\"]\n self.tracker_path = cfg[\"tracker_model_path\"]\n self.antispoofing = cfg[\"face_antispoofing\"]\n self.antispoofing_path = cfg[\"face_antispoofing_model_path\"]\n\n if self.detector_type == \"MTCNN\":\n if self.dnn_detector_path == \"\":\n print(\"[INFO] Loading MTCNN detection model...\")\n self.detector = mtcnn.MTCNN()\n print(\"[INFO] MTCNN detection model loaded.\")\n print(\"MTCNN version: \", mtcnn.__version__)\n\n if self.detector_type == \"HAAR\":\n # load our serialized model from disk\n print(\"[INFO] Loading Haar detection model...\")\n # Here we need to read our pre-trained neural net created using Tensorflow\n self.detector = cv2.dnn.readNetFromTensorflow(self.haar_model_file, self.haar_config_file)\n self.min_confidence = 0.5 # minimum probability to filter weak detections\n print(\"[INFO] Haar detection model loaded.\")\n\n if self.detector_type == \"dlib\":\n # load our serialized model from disk\n print(\"[INFO] Loading Haar detection model...\")\n # Here we need to read our pre-trained neural net created using Tensorflow\n self.detector = cv2.dnn.readNetFromTensorflow(self.haar_model_file, self.haar_config_file)\n self.min_confidence = 0.5 # minimum probability to filter weak detections\n print(\"[INFO] Haar detection model loaded.\")\n\n def rescale_frame(self, frame, percent=75):\n width = int(frame.shape[1] * percent / 100)\n height = int(frame.shape[0] * percent / 100)\n dim = (width, height)\n return cv2.resize(frame, dim, interpolation=cv2.INTER_AREA)\n\n def capture(self):\n # Create a VideoCapture object and read from input file\n # If the input is taken from the camera, pass 0 instead of the video file name.\n self.cap = cv2.VideoCapture(self.video_source)\n\n # Check if video capture object is openanned successfully\n if (self.cap.isOpened() == False):\n print(\"Error opening video stream or file\")\n\n ret, frame = self.cap.read()\n if self.tracker_type == 'dlib':\n tracker = dlib.correlation_tracker()\n if self.tracker_type == 'goturn':\n tracker = cv2.TrackerGOTURN_create()\n f_count = 0\n tracker_init = True\n\n # Read until video is completed\n while (self.cap.isOpened()):\n # Capture frame-by-frame\n ret, frame = self.cap.read()\n f_count += 1\n #frame = self.rescale_frame(frame, 25)\n face = False\n if f_count!=0:\n if f_count==5:\n f_count = 0\n tracker_init = True\n if self.detector_type == \"HAAR\":\n (h, w) = frame.shape[:2]\n blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 1.0, (300, 300), (104.0, 177.0, 123.0))\n self.detector.setInput(blob)\n # Runs forward pass to compute outputs of layers listed in outBlobNames.\n detections = self.detector.forward()\n\n for i in range(0, detections.shape[2]):\n # extract the confidence (probability) associated with the prediction\n confidence = detections[0, 0, i, 2]\n\n # filter out weak detections by ensuring the `confidence` is\n # greater than the minimum confidence\n if confidence > self.min_confidence:\n face = True\n # compute the (x, y)-coordinates of the bounding box for the object\n box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\n\n # Initialize tracker with first frame and bounding box\n if tracker_init:\n tracker_init = False\n (startX, startY, endX, endY) = box.astype(\"int\")\n\n if self.tracker_type == 'dlib':\n tracker.start_track(frame, (dlib.rectangle(startX, startY, endX, endY)))\n if self.tracker_type == 'goturn':\n ok = tracker.init(frame, tuple([startX, startY, endX - startX, endY - startY]))\n\n # draw the bounding box of the face along with the associated\n # probability\n text = \"{:.2f}%\".format(confidence * 100)\n y = startY - 10 if startY - 10 > 10 else startY + 10\n cv2.rectangle(frame, (startX, startY), (endX, endY),\n (0, 0, 255), 2)\n cv2.putText(frame, text, (startX, y),\n cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)\n\n if self.detector_type == \"MTCNN\":\n if self.dnn_detector_path == \"\":\n faces = self.detector.detect_faces(frame)\n for face in faces:\n # get coordinates\n x, y, width, height = face['box']\n\n cv2.rectangle(frame, (x, y), (x + width, y + height), color=(0, 0, 255), thickness=2)\n\n for key, value in face['keypoints'].items():\n # create and draw dots\n cv2.circle(frame, value, radius=2, color=(0, 0, 255), thickness=1)\n\n text = \"{:.2f}%\".format(face['confidence'] * 100)\n cv2.putText(frame, text, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)\n\n # Update tracker\n if f_count!=0 and face == False:\n if self.tracker_type == 'dlib':\n tracker.update(frame)\n pos = tracker.get_position()\n # unpack the position object\n startX = int(pos.left())\n startY = int(pos.top())\n endX = int(pos.right())\n endY = int(pos.bottom())\n cv2.rectangle(frame, (startX, startY), (endX, endY),\n (0, 0, 255), 2)\n\n if self.tracker_type == 'goturn':\n ok, bbox = tracker.update(frame)\n if ok:\n p1 = (int(bbox[0]), int(bbox[1]))\n p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3]))\n cv2.rectangle(frame, p1, p2, (0, 0, 255), 2)\n\n if ret == True:\n # Display the resulting frame\n cv2.imshow('Video stream', frame)\n\n # Press Q on keyboard to exit\n if cv2.waitKey(25) & 0xFF == ord('q'):\n break\n\n #fps = self.cap.get(cv2.CAP_PROP_FPS)\n #print(fps)\n\n # When everything done, release the video capture object\n self.cap.release()\n # Closes all the frames\n cv2.destroyAllWindows()\n\n def capture_and_write(self):\n # Create a VideoCapture object and read from input file\n # If the input is taken from the camera, pass 0 instead of the video file name.\n self.cap = cv2.VideoCapture(self.video_source)\n\n # Check if video capture object is openanned successfully\n if (self.cap.isOpened() == False):\n print(\"Error opening video stream or file\")\n\n # Default resolutions of the frame are obtained.The default resolutions are system dependent.\n # We convert the resolutions from float to integer.\n frame_width = int(self.cap.get(3))\n frame_height = int(self.cap.get(4))\n\n # Define the codec and create VideoWriter object.The output is stored in 'output_py.avi' file.\n out = cv2.VideoWriter('output.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30, (frame_width, frame_height))\n\n # Read until video is completed\n while (self.cap.isOpened()):\n # Capture frame-by-frame\n ret, frame = self.cap.read()\n if ret == True:\n # Display the resulting frame\n cv2.imshow('Video stream', frame)\n # Write the frame into the file 'output.avi'\n out.write(frame)\n\n # Press Q on keyboard to exit\n if cv2.waitKey(25) & 0xFF == ord('q'):\n break\n\n #fps = self.cap.get(cv2.CAP_PROP_FPS)\n #print(fps)\n\n # When everything done, release the video capture object\n self.cap.release()\n out.release()\n # Closes all the frames\n cv2.destroyAllWindows()\n\n def dnn_detect(self):\n pass\n\n def mtcnn_detect(self):\n pass\n\n def haar_detect(self):\n pass\n\n"
] | [
[
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
SohamChattopadhyayEE/RRCNN | [
"3bcd84bb44b68dea1d8e4dbd25923c8d4e7953ed"
] | [
"train.py"
] | [
"import os\r\nimport numpy as np\r\nimport argparse\r\nimport json\r\nimport torch\r\nimport torch.nn as nn\r\n\r\nfrom model.models import model_version\r\nfrom dataset.dataset import dataset\r\nfrom utils.optimizer import optimizer_function\r\nfrom utils.loss import loss_function\r\n\r\n\r\nparser = argparse.ArgumentParser(description=\"Training RRCNN\")\r\n# Dataset paths\r\nparser.add_argument('-d_train', '--train_data_path', type=str, default='./data/Train data/train_data.pkl',\r\n help='The path of test data')\r\nparser.add_argument('-l_train', '--train_label_path', type=str, default='./data/Train data/train_label.pkl',\r\n help='The path of test labels')\r\nparser.add_argument('-d_val', '--test_data_path', type=str, default='./data/Test data/test_data.pkl',\r\n help='The path of test data')\r\nparser.add_argument('-l_val', '--test_label_path', type=str, default='./data/Test data/test_label.pkl',\r\n help='The path of test labels')\r\nparser.add_argument('-c', '--config', type = str, default= './config/config.json', help='Path to the config file')\r\n\r\n# Training parameters\r\nparser.add_argument('-m', '--model', type = str, default = 'RRCNN_C', help = 'Choose model version')\r\nparser.add_argument('-lr', '--lr', type = float, default = 0.0001, help = 'Learning rate')\r\nparser.add_argument('-n', '--num_classes', type = int, default = 2, help = 'The number of classes')\r\nparser.add_argument('-mm', '--momentum', type = float, default = 0.58, help = 'The momentum of the optimizer')\r\nparser.add_argument('-opt', '--optimizer', type = str, default='Adam', help = 'Choose optimizer')\r\nparser.add_argument('-ne', '--epoch', type = int, default = 300, help = 'No. of epochs')\r\nparser.add_argument('-lss', '--loss', type = str, default = 'Cross entropy loss', help = 'The loss function')\r\nparser.add_argument('-mp', '--model_path', type = str, default = './model weights', \r\n help='Path where the model weights are saved')\r\nargs = parser.parse_args()\r\n\r\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\r\n\r\n# Dataloader\r\ntrain_data_path = args.train_data_path\r\ntrain_label_path = args.train_label_path\r\ntrain_data, train_label = dataset(train_data_path, train_label_path)\r\n\r\ntest_data_path = args.test_data_path\r\ntest_label_path = args.test_label_path\r\ntest_data, test_label = dataset(test_data_path, test_label_path)\r\n\r\nconfig = json.load(args.config)\r\nmodels_params = config[args.model]\r\n\r\nnum_epoch = args.epoch\r\nlr = args.lr\r\nmomentum = args.momentum\r\nnum_channels = models_params.num_channels\r\nnum_residual_features = models_params.num_residual_features\r\nnum_resedual_blocks = models_params.num_resedual_blocks\r\nnum_classes = args.num_classes\r\n\r\n\r\nmodel = model_version(num_channels = num_channels, num_classes = num_classes, \r\n num_res_ft = num_residual_features, num_res = num_resedual_blocks, model = args.model)\r\n\r\n\r\nmodel = model.to(device = device)\r\nparams = model.parameters()\r\noptm = args.optimizer\r\noptimizer = optimizer_function(params, lr, momentum, optm)\r\ncriterion = loss_function(args.loss)\r\n\r\n\r\nmodel_name = args.model + '_train'\r\nsnapshot_path = args.model_path\r\n\r\nload_model=snapshot_path+'/model_'+model_name+'.pth'\r\nloaded_flag=False\r\nif os.path.exists(load_model):\r\n checkpoint=torch.load(load_model)\r\n model.load_state_dict(checkpoint['model_state'])\r\n optimizer.load_state_dict(checkpoint['optimizer_state'])\r\n print(\"model loaded successfully\")\r\n print('starting training after epoch: ',checkpoint['epoch'])\r\n loaded_flag=True\r\n\r\n\r\nmax_acc = 0.0\r\n\r\nfor epoch in range(num_epoch):\r\n train_loss = 0.0\r\n correct = total = 0\r\n for i in range(len(train_data)):\r\n optimizer.zero_grad()\r\n data_point, label = torch.tensor(train_data[i]), torch.tensor(np.array([train_label[i]]))\r\n data_point, label = data_point.to(device=device), label.to(device=device)\r\n data_point = data_point.reshape(1,num_channels,-1)\r\n output = model(data_point.float())\r\n loss = criterion(output.reshape(1,-1), label)\r\n loss.backward()\r\n optimizer.step()\r\n train_loss += loss.item()\r\n _, predicted = torch.max(output.reshape(1,-1).data, 1)\r\n total += label.size(0)\r\n correct += (predicted == label).sum().item()\r\n\r\n print('Training Epoch: ', epoch)\r\n print('training loss: ', train_loss)\r\n print('Accuracy: ', 100*correct/total)\r\n\r\n with torch.no_grad():\r\n val_loss = 0.0\r\n total = correct = 0\r\n for j in range(len(test_data)):\r\n val_data, val_label = torch.tensor(test_data[j]), torch.tensor(np.array([test_label[j]]))\r\n val_data, val_label = val_data.to(device=device), val_label.to(device=device)\r\n val_data = val_data.reshape(1,num_channels,-1)\r\n out_val = model(val_data.float())\r\n loss = criterion(out_val.reshape(1,-1), val_label)\r\n val_loss += loss.item()\r\n _, predicted_val = torch.max(out_val.reshape(1,-1).data, 1)\r\n total += val_label.size(0)\r\n correct += (predicted_val == val_label).sum().item()\r\n print('Validation Loss: ', val_loss)\r\n print('Validation Accuracy: ', 100*correct/total)\r\n val_acc = 100*correct/total\r\n\r\n if val_acc>max_acc:\r\n state={\r\n \"epoch\":i if not loaded_flag else i+checkpoint['epoch'],\r\n \"model_state\":model.cpu().state_dict(),\r\n \"optimizer_state\":optimizer.state_dict(),\r\n \"Accuracy\":val_acc\r\n #\"loss\":min_loss,\r\n #\"train_graph\":train_loss_gph,\r\n #\"val_graph\":val_loss_gph,\r\n }\r\n\r\n max_acc=val_acc\r\n torch.save(state,os.path.join(snapshot_path,\"model_\"+model_name+'.pth'))\r\n model.cuda()\r\n print('maximum validation accuracy : ', max_acc)\r\n\r\n\r\n"
] | [
[
"torch.load",
"torch.tensor",
"torch.no_grad",
"torch.cuda.is_available",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
sanjibs/k2gap | [
"218d5ae646541a7e566553f7a31d5bc2495d622c"
] | [
"k2gap/k2gap.py"
] | [
"#Copyright (c) 2021 Sanjib Sharma\n\"\"\"\nA module for K2GAP target selection function\n\n\nExample:\n\nimport k2gap\ninsurvey=k2gap.sf(cno,ra,dec,jmag,hmag,kmag)\nor\ninsurvey=k2gap.sf(cno,ra,dec,jmag,hmag,kmag,simulate_onsilicon=True)\n\n\"\"\"\n\n\nimport numpy as np\nimport json\nimport os\n\ndef read_json(filename):\n d=None\n with open(filename,'r') as infile:\n dt=json.load(infile)\n d={key:np.array(dt[key]) for key in dt}\n return d\n\ndef jk2vmag(j,ks):\n \"\"\"\n Convert J and K band mag to V mag\n \"\"\"\n return ks+2.0*((j-ks)+0.14)+0.382*np.exp((j-ks-0.2)*2)\n\ndef lbr2xyz(l,b,r=1.0):\n \"\"\"\n Convert (longitude, latitude, radius) to cartesian coordinates (x,y,z)\n Arguments\n ---------\n l : (float) array_like \n Longitude [degree]\n\n b : (float) array_like \n Latitude [degree]\n\n r : (float) array_like \n Radius [arbitrary units]\n\n \"\"\"\n l=np.radians(l)\n b=np.radians(b)\n return [r*np.cos(b)*np.cos(l),r*np.cos(b)*np.sin(l),r*np.sin(b)]\n\ndef angsep(l1,b1,l2,b2):\n \"\"\"\n Angular distance between points (l1, b1) and (l2, b2) on a sphere\n\n Arguments\n ---------\n l1 : (float) array_like \n Longitude [degree]\n \n b1 : (float) array_like \n Latitude [degree]\n\n l2 : (float) array_like \n Longitude [degree]\n \n b2 : (float) array_like \n Latitude [degree]\n\n Returns d: (float) array_like \n Angular distance [degree] \n \n \"\"\"\n x1,y1,z1=lbr2xyz(l1,b1)\n x2,y2,z2=lbr2xyz(l2,b2)\n return np.degrees(2*np.arcsin(np.sqrt((x1-x2)**2+(y1-y2)**2+(z1-z2)**2)/2.0))\n\ndef circ_id(cno,ra,dec,radius=1.0):\n \"\"\"\n\n \"\"\"\n cno=np.zeros(ra.size,dtype=np.int64)+cno\n circ_id=np.zeros(ra.size,dtype=np.float64)-1\n circ_sep=np.zeros(ra.size,dtype=np.float64)+radius\n datafile=os.path.join(os.path.dirname(__file__),'k2circles.json') \n fields=read_json(datafile)\n for cno1 in np.unique(cno):\n indd=np.where(cno==cno1)[0]\n if (cno1 >= 0)and(cno1 < 21):\n indf=np.where(fields['circ_id']//100==cno1)[0]\n for i in indf:\n fsep=angsep(ra[indd],dec[indd],fields['ra'][i],fields['dec'][i])\n ind=np.where(fsep<circ_sep[indd])[0]\n circ_id[indd[ind]]=fields['circ_id'][i]\n circ_sep[indd[ind]]=fsep[ind]\n ind=np.where((cno<0)|(cno>20))[0]\n if ind.size> 0:\n circ_id[ind]=8 \n return circ_id\n\ndef sf(cno,ra,dec,jmag,hmag,kmag,radius=1.75,simulate_onsilicon=False):\n \"\"\"\n Implements the K2GAP selection function. For a set of observables x \n returns the function y(x) which is True if it satisfies the selection \n criteria and False otherwise.\n\n Arguments\n ---------\n cno : (int) array_like \n campaign number\n\n ra : (float) array_like \n Right ascension [degree]\n\n dec : [float] array_like\n Declination [degree]\n\n jmag : [float] array_like\n 2MASS J band magnitude \n\n hmag : [float] array_like\n 2MASS H band magnitude \n\n kmag : [float] array_like\n 2MASS Ks band magnitude \n\n simulate_onsilicon : [boolean], optional keyword\n If True it emulates the effect of \n K2fov.K2onSilicon.onSiliconCheck (https://github.com/KeplerGO/K2fov) \n by setting radius=1.4. The actual computation of onsilicion test \n is computationally expensive. This is useful when working with mock \n data. See description of keyword radius for more details.\n\n radius : [float] array_like, optional keyword\n The distance of a star in [degree] from the center of its nearest \n ccd module. The field of view of each campaign is divided up into \n 21 ccd modules with gaps between them. Circles defined by this radius and \n centered on each module are non-overalping till a radius of 1.6 degrees.\n Use radius=1.75 to encapsulate the whole ccd module when working with \n data for which K2fov.K2onSilicon.onSiliconCheck (https://github.com/KeplerGO/K2fov) \n has been applied, e.g. observational data from K2. \n Use radius=1.4, when working with \n data for which K2fov.K2onSilicon.onSiliconCheck has not been applied, \n e.g. a mock surveys. This has an area similar to that of a ccd module. \n So using radius=1.4 is effectively similar to using radius=1.75 \n but with K2fov.K2onSilicon.onSiliconCheck.\n This is to avoid running K2fov.K2onSilicon.onSiliconCheck which is slow. \n Note, for radius<=1.75 the four guiding ccds outside the science field of view \n are not included in any of the circles.\n\n Returns\n -------\n y : (boolean) array_like\n True if selection function is satisfied otherwise False \n\n \"\"\"\n \n cno1=cno; ra1=ra; dec1=dec; jmag1=jmag; hmag1=hmag; kmag1=kmag\n if simulate_onsilicon:\n radius=1.4\n \n cno1=np.zeros(ra1.size,dtype=np.int64)+cno1\n col_jk1=jmag1-kmag1\n vmag1=jk2vmag(jmag1,kmag1)\n ccd1=circ_id(cno1,ra1,dec1,radius=1.0)%100\n ccd1[ccd1>20]=-1\n ccd2=circ_id(cno1,ra1,dec1,radius=radius)%100\n ccd2[ccd2>20]=-1\n\n\n result1=np.zeros(ra1.size,dtype=np.bool)\n\n for cno in np.unique(cno1):\n indd=np.where(cno1==cno)[0]\n ra=ra1[indd]\n dec=dec1[indd]\n jmag=jmag1[indd]\n hmag=hmag1[indd]\n kmag=kmag1[indd]\n col_jk=col_jk1[indd]\n vmag=vmag1[indd]\n ccd=ccd1[indd]\n ccdb=ccd2[indd]\n\n if cno == 1:\n result=(col_jk >= 0.5)&(hmag>=7.0)&(hmag<12.927)&(ccdb>=0)\n elif cno ==2:\n ccdset=[17,12,6,14,10]\n result=(col_jk >= 0.5)&(hmag>=7.0)&(hmag<11.5)&(np.isin(ccd,ccdset))\n elif cno ==3:\n temp1=(col_jk >= 0.5)&(hmag>=7.0)&(hmag<12.0)&(ccd>=0)\n temp2=(col_jk >= 0.5)&(hmag>=7.0)&(hmag<10.929)&(ccd<0)\n result=(temp1|temp2)\n elif cno ==4:\n result=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<13.447)&(ccdb>=0)\n elif cno ==5:\n result=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<15.0)&(ccdb>=0)\n elif cno ==6:\n result=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<15.0)&(ccdb>=0)\n elif cno ==7:\n temp1=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.5)&(ccd==17)\n temp2=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.5)&(ccd==6)\n temp3=(col_jk >= 0.5)&(vmag>=14.276)&(vmag<14.5)&(ccd==14)\n result=(temp1|temp2|temp3)\n elif cno == 8:\n temp1=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.5)&(ccdb>=0)\n temp2=(col_jk >= 0.5)&(col_jk < 0.7)&(vmag>=14.5)&(vmag<14.580)&(ccdb>=0)\n result=(temp1|temp2)\n elif cno == 10:\n temp1=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.5)&(ccdb>=0)&(ccdb!=1)\n temp2=(col_jk >= 0.5)&(col_jk < 0.7)&(vmag>=14.5)&(vmag<15.577)&(ccdb>=0)&(ccdb!=1)\n result=(temp1|temp2)\n elif cno == 11:\n temp1=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<15.0)&(ccd==3)\n temp2=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.5)&(ccd==2)\n temp3=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.175)&(ccd==8)\n result=(temp1|temp2|temp3)\n elif cno == 12:\n result=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<16.0)&(ccdb>=0)&(ccdb!=1)\n elif cno == 13:\n ccdset=[0,13,7,9,4,12]\n temp1=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<15.0)&(ccd==3)\n temp2=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.5)&(ccd==8)\n temp3=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.0)&(np.isin(ccd,ccdset))\n temp4=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<12.818)&(ccd==14)\n result=(temp1|temp2|temp3|temp4) \n elif cno == 14:\n result=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<15.0)&(ccdb>=0)&(ccdb!=1)\n elif cno == 15:\n ccdset=[13,7,9,4,12,14,2]\n temp1=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<15.5)&(ccd==3)\n temp2=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<15.0)&(ccd==8)\n temp3=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<14.5)&(np.isin(ccd,ccdset))\n temp4=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<13.838)&(ccd==5)\n result=(temp1|temp2|temp3|temp4) \n elif cno == 16:\n result=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<15.0)&(ccdb>=0)&(ccdb!=1)\n elif cno == 17:\n temp1=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<16.0)&((ccd==8)|(ccd==3))\n temp2=(col_jk >= 0.5)&(vmag>=9.0)&(vmag<12.414)&(ccd!=8)&(ccd!=3)&(ccdb!=1)\n result=(temp1|temp2)\n elif cno == 18:\n result=np.zeros(vmag.size,dtype=np.bool)\n elif cno == 19:\n result=(col_jk >= 0.5)&(vmag>=9)&(vmag<14.8)&(ccdb>=0)&(ccdb!=1)\n else:\n result=np.zeros(vmag.size,dtype=np.bool)\n result1[indd]=result&(ccdb>=0)&(jmag<15)\n return result1\n\n\n"
] | [
[
"numpy.radians",
"numpy.sqrt",
"numpy.unique",
"numpy.cos",
"numpy.sin",
"numpy.exp",
"numpy.array",
"numpy.zeros",
"numpy.where",
"numpy.isin"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
DreaJulca/uxsense | [
"538800f3e071660f4a8242c90b25f500b8667aa8",
"538800f3e071660f4a8242c90b25f500b8667aa8"
] | [
"models/pt_3dpose/detectron/utils/image.py",
"models/pt_3dpose/detectron/utils/blob.py"
] | [
"# Copyright (c) 2017-present, Facebook, Inc.\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\n\"\"\"Image helper functions.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport cv2\nimport numpy as np\n\n\ndef aspect_ratio_rel(im, aspect_ratio):\n \"\"\"Performs width-relative aspect ratio transformation.\"\"\"\n im_h, im_w = im.shape[:2]\n im_ar_w = int(round(aspect_ratio * im_w))\n im_ar = cv2.resize(im, dsize=(im_ar_w, im_h))\n return im_ar\n\n\ndef aspect_ratio_abs(im, aspect_ratio):\n \"\"\"Performs absolute aspect ratio transformation.\"\"\"\n im_h, im_w = im.shape[:2]\n im_area = im_h * im_w\n\n im_ar_w = np.sqrt(im_area * aspect_ratio)\n im_ar_h = np.sqrt(im_area / aspect_ratio)\n assert np.isclose(im_ar_w / im_ar_h, aspect_ratio)\n\n im_ar = cv2.resize(im, dsize=(int(im_ar_w), int(im_ar_h)))\n return im_ar\n",
"# Copyright (c) 2017-present, Facebook, Inc.\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#\n# Based on:\n# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Caffe2 blob helper functions.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport cv2\nimport numpy as np\nfrom six.moves import cPickle as pickle\n\nfrom caffe2.proto import caffe2_pb2\n\nfrom detectron.core.config import cfg\n\n\ndef get_image_blob(im, target_scale, target_max_size):\n \"\"\"Convert an image into a network input.\n\n Arguments:\n im (ndarray): a color image in BGR order\n\n Returns:\n blob (ndarray): a data blob holding an image pyramid\n im_scale (float): image scale (target size) / (original size)\n im_info (ndarray)\n \"\"\"\n processed_im, im_scale = prep_im_for_blob(\n im, cfg.PIXEL_MEANS, target_scale, target_max_size\n )\n blob = im_list_to_blob(processed_im)\n # NOTE: this height and width may be larger than actual scaled input image\n # due to the FPN.COARSEST_STRIDE related padding in im_list_to_blob. We are\n # maintaining this behavior for now to make existing results exactly\n # reproducible (in practice using the true input image height and width\n # yields nearly the same results, but they are sometimes slightly different\n # because predictions near the edge of the image will be pruned more\n # aggressively).\n height, width = blob.shape[2], blob.shape[3]\n im_info = np.hstack((height, width, im_scale))[np.newaxis, :]\n return blob, im_scale, im_info.astype(np.float32)\n\n\ndef im_list_to_blob(ims):\n \"\"\"Convert a list of images into a network input. Assumes images were\n prepared using prep_im_for_blob or equivalent: i.e.\n - BGR channel order\n - pixel means subtracted\n - resized to the desired input size\n - float32 numpy ndarray format\n Output is a 4D HCHW tensor of the images concatenated along axis 0 with\n shape.\n \"\"\"\n if not isinstance(ims, list):\n ims = [ims]\n max_shape = np.array([im.shape for im in ims]).max(axis=0)\n # Pad the image so they can be divisible by a stride\n if cfg.FPN.FPN_ON:\n stride = float(cfg.FPN.COARSEST_STRIDE)\n max_shape[0] = int(np.ceil(max_shape[0] / stride) * stride)\n max_shape[1] = int(np.ceil(max_shape[1] / stride) * stride)\n\n num_images = len(ims)\n blob = np.zeros(\n (num_images, max_shape[0], max_shape[1], 3), dtype=np.float32\n )\n for i in range(num_images):\n im = ims[i]\n blob[i, 0:im.shape[0], 0:im.shape[1], :] = im\n # Move channels (axis 3) to axis 1\n # Axis order will become: (batch elem, channel, height, width)\n channel_swap = (0, 3, 1, 2)\n blob = blob.transpose(channel_swap)\n return blob\n\n\ndef prep_im_for_blob(im, pixel_means, target_size, max_size):\n \"\"\"Prepare an image for use as a network input blob. Specially:\n - Subtract per-channel pixel mean\n - Convert to float32\n - Rescale to each of the specified target size (capped at max_size)\n Returns a list of transformed images, one for each target size. Also returns\n the scale factors that were used to compute each returned image.\n \"\"\"\n im = im.astype(np.float32, copy=False)\n im -= pixel_means\n im_shape = im.shape\n im_size_min = np.min(im_shape[0:2])\n im_size_max = np.max(im_shape[0:2])\n im_scale = float(target_size) / float(im_size_min)\n # Prevent the biggest axis from being more than max_size\n if np.round(im_scale * im_size_max) > max_size:\n im_scale = float(max_size) / float(im_size_max)\n im = cv2.resize(\n im,\n None,\n None,\n fx=im_scale,\n fy=im_scale,\n interpolation=cv2.INTER_LINEAR\n )\n return im, im_scale\n\n\ndef zeros(shape, int32=False):\n \"\"\"Return a blob of all zeros of the given shape with the correct float or\n int data type.\n \"\"\"\n return np.zeros(shape, dtype=np.int32 if int32 else np.float32)\n\n\ndef ones(shape, int32=False):\n \"\"\"Return a blob of all ones of the given shape with the correct float or\n int data type.\n \"\"\"\n return np.ones(shape, dtype=np.int32 if int32 else np.float32)\n\n\ndef py_op_copy_blob(blob_in, blob_out):\n \"\"\"Copy a numpy ndarray given as blob_in into the Caffe2 CPUTensor blob\n given as blob_out. Supports float32 and int32 blob data types. This function\n is intended for copying numpy data into a Caffe2 blob in PythonOps.\n \"\"\"\n # Some awkward voodoo required by Caffe2 to support int32 blobs\n needs_int32_init = False\n try:\n _ = blob.data.dtype # noqa\n except Exception:\n needs_int32_init = blob_in.dtype == np.int32\n if needs_int32_init:\n # init can only take a list (failed on tuple)\n blob_out.init(list(blob_in.shape), caffe2_pb2.TensorProto.INT32)\n else:\n blob_out.reshape(blob_in.shape)\n blob_out.data[...] = blob_in\n\n\ndef get_loss_gradients(model, loss_blobs):\n \"\"\"Generate a gradient of 1 for each loss specified in 'loss_blobs'\"\"\"\n loss_gradients = {}\n for b in loss_blobs:\n loss_grad = model.net.ConstantFill(b, [b + '_grad'], value=1.0)\n loss_gradients[str(b)] = str(loss_grad)\n return loss_gradients\n\n\ndef serialize(obj):\n \"\"\"Serialize a Python object using pickle and encode it as an array of\n float32 values so that it can be feed into the workspace. See deserialize().\n \"\"\"\n return np.fromstring(pickle.dumps(obj), dtype=np.uint8).astype(np.float32)\n\n\ndef deserialize(arr):\n \"\"\"Unserialize a Python object from an array of float32 values fetched from\n a workspace. See serialize().\n \"\"\"\n return pickle.loads(arr.astype(np.uint8).tobytes())\n"
] | [
[
"numpy.sqrt",
"numpy.isclose"
],
[
"numpy.hstack",
"numpy.min",
"numpy.ones",
"numpy.round",
"numpy.max",
"numpy.ceil",
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
yakir4123/jesse | [
"e7dcc1022c6c1077a5812caeb4753c84af531332"
] | [
"jesse/services/metrics.py"
] | [
"from datetime import datetime, timedelta\nfrom typing import List, Any, Union\n\nimport numpy as np\nimport pandas as pd\nfrom quantstats import stats\n\nimport jesse.helpers as jh\nfrom jesse.models import CompletedTrade\nfrom jesse.store import store\n\n\ndef candles_info(candles_array: np.ndarray) -> dict:\n period = jh.date_diff_in_days(\n jh.timestamp_to_arrow(candles_array[0][0]),\n jh.timestamp_to_arrow(candles_array[-1][0])) + 1\n\n if period > 365:\n duration = f'{period} days ({round(period / 365, 2)} years)'\n elif period > 30:\n duration = f'{period} days ({round(period / 30, 2)} months)'\n else:\n duration = f'{period} days'\n\n return {\n 'duration': duration,\n 'starting_time': candles_array[0][0],\n 'finishing_time': (candles_array[-1][0] + 60_000),\n }\n\n\ndef routes(routes_arr: list) -> list:\n return [{\n 'exchange': r.exchange,\n 'symbol': r.symbol,\n 'timeframe': r.timeframe,\n 'strategy_name': r.strategy_name,\n } for r in routes_arr]\n\n\ndef trades(trades_list: List[CompletedTrade], daily_balance: list, final: bool = True) -> dict:\n starting_balance = 0\n current_balance = 0\n\n for e in store.exchanges.storage:\n starting_balance += store.exchanges.storage[e].starting_assets[jh.app_currency()]\n current_balance += store.exchanges.storage[e].assets[jh.app_currency()]\n\n if not trades_list:\n return {'total': 0, 'win_rate': 0, 'net_profit_percentage': 0}\n\n df = pd.DataFrame.from_records([t.to_dict for t in trades_list])\n\n total_completed = len(df)\n winning_trades = df.loc[df['PNL'] > 0]\n total_winning_trades = len(winning_trades)\n losing_trades = df.loc[df['PNL'] < 0]\n total_losing_trades = len(losing_trades)\n\n arr = df['PNL'].to_numpy()\n pos = np.clip(arr, 0, 1).astype(bool).cumsum()\n neg = np.clip(arr, -1, 0).astype(bool).cumsum()\n current_streak = np.where(arr >= 0, pos - np.maximum.accumulate(np.where(arr <= 0, pos, 0)),\n -neg + np.maximum.accumulate(np.where(arr >= 0, neg, 0)))\n\n s_min = current_streak.min()\n losing_streak = 0 if s_min > 0 else abs(s_min)\n\n s_max = current_streak.max()\n winning_streak = max(s_max, 0)\n\n largest_losing_trade = 0 if total_losing_trades == 0 else losing_trades['PNL'].min()\n largest_winning_trade = 0 if total_winning_trades == 0 else winning_trades['PNL'].max()\n\n win_rate = len(winning_trades) / (len(losing_trades) + len(winning_trades))\n longs_count = len(df.loc[df['type'] == 'long'])\n shorts_count = len(df.loc[df['type'] == 'short'])\n longs_percentage = longs_count / (longs_count + shorts_count) * 100\n shorts_percentage = 100 - longs_percentage\n fee = df['fee'].sum()\n net_profit = df['PNL'].sum()\n net_profit_percentage = (net_profit / starting_balance) * 100\n average_win = winning_trades['PNL'].mean()\n average_loss = abs(losing_trades['PNL'].mean())\n ratio_avg_win_loss = average_win / average_loss\n expectancy = (0 if np.isnan(average_win) else average_win) * win_rate - (\n 0 if np.isnan(average_loss) else average_loss) * (1 - win_rate)\n expectancy = expectancy\n expectancy_percentage = (expectancy / starting_balance) * 100\n expected_net_profit_every_100_trades = expectancy_percentage * 100\n average_holding_period = df['holding_period'].mean()\n average_winning_holding_period = winning_trades['holding_period'].mean()\n average_losing_holding_period = losing_trades['holding_period'].mean()\n gross_profit = winning_trades['PNL'].sum()\n gross_loss = losing_trades['PNL'].sum()\n\n start_date = datetime.fromtimestamp(store.app.starting_time / 1000)\n date_index = pd.date_range(start=start_date, periods=len(daily_balance))\n\n daily_return = pd.DataFrame(daily_balance, index=date_index).pct_change(1)\n\n total_open_trades = store.app.total_open_trades\n open_pl = store.app.total_open_pl\n\n\n max_drawdown = np.nan\n annual_return = np.nan\n sharpe_ratio = np.nan\n calmar_ratio = np.nan\n sortino_ratio = np.nan\n omega_ratio = np.nan\n serenity_index = np.nan\n smart_sharpe = np.nan\n smart_sortino = np.nan\n\n if len(daily_return) > 2:\n max_drawdown = stats.max_drawdown(daily_return).values[0] * 100\n annual_return = stats.cagr(daily_return).values[0] * 100\n sharpe_ratio = stats.sharpe(daily_return, periods=365).values[0]\n calmar_ratio = stats.calmar(daily_return).values[0]\n sortino_ratio = stats.sortino(daily_return, periods=365).values[0]\n omega_ratio = stats.omega(daily_return, periods=365)\n serenity_index = stats.serenity_index(daily_return).values[0]\n # As those calculations are slow they are only done for the final report and not at self.metrics in the strategy.\n if final:\n smart_sharpe = stats.smart_sharpe(daily_return, periods=365).values[0]\n smart_sortino = stats.smart_sortino(daily_return, periods=365).values[0]\n\n return {\n 'total': np.nan if np.isnan(total_completed) else total_completed,\n 'total_winning_trades': np.nan if np.isnan(total_winning_trades) else total_winning_trades,\n 'total_losing_trades': np.nan if np.isnan(total_losing_trades) else total_losing_trades,\n 'starting_balance': np.nan if np.isnan(starting_balance) else starting_balance,\n 'finishing_balance': np.nan if np.isnan(current_balance) else current_balance,\n 'win_rate': np.nan if np.isnan(win_rate) else win_rate,\n 'ratio_avg_win_loss': np.nan if np.isnan(ratio_avg_win_loss) else ratio_avg_win_loss,\n 'longs_count': np.nan if np.isnan(longs_count) else longs_count,\n 'longs_percentage': np.nan if np.isnan(longs_percentage) else longs_percentage,\n 'shorts_percentage': np.nan if np.isnan(shorts_percentage) else shorts_percentage,\n 'shorts_count': np.nan if np.isnan(shorts_count) else shorts_count,\n 'fee': np.nan if np.isnan(fee) else fee,\n 'net_profit': np.nan if np.isnan(net_profit) else net_profit,\n 'net_profit_percentage': np.nan if np.isnan(net_profit_percentage) else net_profit_percentage,\n 'average_win': np.nan if np.isnan(average_win) else average_win,\n 'average_loss': np.nan if np.isnan(average_loss) else average_loss,\n 'expectancy': np.nan if np.isnan(expectancy) else expectancy,\n 'expectancy_percentage': np.nan if np.isnan(expectancy_percentage) else expectancy_percentage,\n 'expected_net_profit_every_100_trades': np.nan if np.isnan(\n expected_net_profit_every_100_trades) else expected_net_profit_every_100_trades,\n 'average_holding_period': average_holding_period,\n 'average_winning_holding_period': average_winning_holding_period,\n 'average_losing_holding_period': average_losing_holding_period,\n 'gross_profit': gross_profit,\n 'gross_loss': gross_loss,\n 'max_drawdown': np.nan if np.isnan(max_drawdown) else max_drawdown,\n 'annual_return': np.nan if np.isnan(annual_return) else annual_return,\n 'sharpe_ratio': np.nan if np.isnan(sharpe_ratio) else sharpe_ratio,\n 'calmar_ratio': np.nan if np.isnan(calmar_ratio) else calmar_ratio,\n 'sortino_ratio': np.nan if np.isnan(sortino_ratio) else sortino_ratio,\n 'omega_ratio': np.nan if np.isnan(omega_ratio) else omega_ratio,\n 'serenity_index': np.nan if np.isnan(serenity_index) else serenity_index,\n 'smart_sharpe': np.nan if np.isnan(smart_sharpe) else smart_sharpe,\n 'smart_sortino': np.nan if np.isnan(smart_sortino) else smart_sortino,\n 'total_open_trades': total_open_trades,\n 'open_pl': open_pl,\n 'winning_streak': winning_streak,\n 'losing_streak': losing_streak,\n 'largest_losing_trade': largest_losing_trade,\n 'largest_winning_trade': largest_winning_trade,\n 'current_streak': current_streak[-1],\n }\n\n\ndef hyperparameters(routes_arr: list) -> list:\n if routes_arr[0].strategy.hp is None:\n return []\n\n hp = []\n # only for the first route\n for key in routes_arr[0].strategy.hp:\n hp.append([\n key, routes_arr[0].strategy.hp[key]\n ])\n return hp\n"
] | [
[
"numpy.clip",
"numpy.isnan",
"pandas.DataFrame",
"pandas.DataFrame.from_records",
"numpy.where"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
SylvainLan/pysap | [
"38c0d43f61adb952c3768d33f1ca41c5769fef2b"
] | [
"examples/astro/galaxy_deconvolution.py"
] | [
"\"\"\"\nGalaxy Image Deconvolution\n==========================\n\nCredit: S. Farrens\n\nIn this tutorial we will deconvolve the PSF effects from an example galaxy\nimage.\n\nImport astro data\n-----------------\n\nThe example galaxy image is convolved with the example PSF and random noise is\nadded simulating an observation with SNR~5.\n\n\"\"\"\n\nimport numpy as np\nfrom pysap import Image\nfrom pysap.data import get_sample_data\nfrom pysap.plugins.astro.deconvolve.deconvolve import sparse_deconv_condatvu\nfrom modopt.signal.noise import add_noise\nfrom modopt.math.convolve import convolve\n\n# Load the example images\ngalaxy = get_sample_data('astro-galaxy')\npsf = get_sample_data('astro-psf')\n\n# Show the clean galaxy image\ngalaxy.show()\n\n# Generate a noisy observed image\nobs_data = add_noise(convolve(galaxy.data, psf.data), sigma=0.0005)\nimage_obs = Image(data=np.abs(obs_data))\nimage_obs.show()\n\n# Deconvolve the observed image\ndeconv_data = sparse_deconv_condatvu(obs_data, psf.data, n_iter=3000)\nimage_rec = Image(data=np.abs(deconv_data))\nimage_rec.show()\n\n# Show the residual\nresidual = Image(data=np.abs(galaxy.data - deconv_data))\nresidual.show()\n"
] | [
[
"numpy.abs"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
dmytrov/stochasticcontrol | [
"a289d5c0953c4a328b2177f51168588248c00f2c"
] | [
"code/states/delayedfeedback.py"
] | [
"import time\nimport numpy as np\nimport psychopy.visual as pv\nimport utils.logger as ulog\nimport statemachine.machine as sm\nimport statemachine.states as sms\nfrom psychopy.visual.circle import Circle\nfrom statemachine.states import TextMessage, Sequence\nimport utils.soundfeedback as fbk\nfrom states.common import *\n\n\n\n\nclass DigitalStream(object):\n TRIAL_BIT = 0x01\n\n\nclass CoordSystem(object):\n Screen = 0\n Task = 1\n\n\n\nclass ExperimentParams(object):\n def __init__(self):\n super(ExperimentParams, self).__init__()\n \n self.block_number = 0 # 0 for no blocks, full trial set\n self.max_blocks = 3\n\n self.feedback_delay = -0.1\n\n self.ntraining_trials = 2 # number of trials for every goal position\n self.training_timeout = 0.75\n self.disturbance_timeout = 5.0\n \n self.start_position = np.array([0.0, -0.45])\n self.goal_positions = [[0.0, 0.0]]\n \n self.nrotation_disturbance_trials = 5 # number of trials for every disturbance\n self.rotation_disturbances = grad_to_radians(np.linspace(-30.0, 30.0, num=5)) # degrees\n \n self.ntranslation_disturbance_trials = 5 # number of trials for every disturbance\n self.translation_disturbances = [[0.0, 0.0]] # screen height units\n \n self.disturbance_CS = CoordSystem.Task\n self.disturbance_threshold = 2.0 # onset threshold, ratio of goal/start distances\n\n self.set_goal_positions_on_circle(grad_to_radians(np.linspace(-45, 45, num=5)))\n self.set_translation_x_disturbances(np.linspace(-0.1, 0.1, num=5))\n\n self.digital_io_device_number = 0\n \n\n def set_goal_positions_on_circle(self, angles, radius=0.65):\n self.goal_positions = [self.start_position + radius*np.array([np.sin(angle), np.cos(angle)]) for angle in angles]\n\n\n def set_translation_x_disturbances(self, x_disturbances):\n self.translation_disturbances = [[x_disturbance, 0.0] for x_disturbance in x_disturbances]\n\n\n\nclass TrialParams(object):\n def __init__(self, number, feedback_delay, start_position, goal_position, \n disturbance_threshold=None,\n disturbance_mode=DisturbanceMode.Rotation,\n disturbance_value=0.0,\n timeout=5.0):\n super(TrialParams, self).__init__()\n self.number = number\n self.feedback_delay = feedback_delay\n self.start_position = start_position\n self.goal_position = goal_position\n self.disturbance_threshold = disturbance_threshold\n self.disturbance_mode = disturbance_mode\n self.disturbance_value = disturbance_value\n self.timeout = timeout\n \n\n\nclass Trial(OptotrakReader):\n def __init__(self, params=None):\n super(Trial, self).__init__()\n self.params = params\n self.start_radius = 0.020\n self.start_color = [0.0, 0.0, 0.0]\n self.goal_radius = 0.015\n self.goal_color = [0.0, 1.0, 0.0]\n self._ppstart = None\n self._ppgoal = None\n \n def get_print_info(self):\n return [self.params.number, self.params.disturbance_threshold]\n \n def on_init(self):\n super(Trial, self).on_init()\n env = self.statemachine.env\n env.logger.info(ulog.NPRecord(\"Trial.params\", self.params))\n \n marker_radius = self.statemachine.env.marker_radius\n self.start_radius = 2.0 * marker_radius\n self.goal_radius = marker_radius\n self._ppstart = pv.Circle(win=self.statemachine.env.win,\n radius=self.start_radius, \n edges=50,\n lineColor=self.start_color,\n fillColor=self.start_color,\n autoDraw=False)\n self._ppstart.setPos(self.params.start_position)\n self._ppgoal = pv.Circle(win=self.statemachine.env.win,\n radius=self.goal_radius, \n edges=50,\n lineColor=self.goal_color,\n fillColor=self.goal_color,\n autoDraw=False)\n self._ppgoal.setPos(self.params.goal_position)\n\n self._ppstart.setAutoDraw(True)\n self._ppgoal.setAutoDraw(False)\n\n reach_start = WaitMarkerPosition()\n reach_start.goal_position = self.params.start_position\n reach_start.goal_radius = self.start_radius\n reach_start.marker_visible = False\n reach_start.on_goal_reached = self.on_start_reached\n\n wait_at_start = TimeoutState()\n wait_at_start.add_timeout(1.0, self.on_wait_at_start_timeout)\n\n disturbance_inducer = AffineDisturbanceInducer()\n if self.params.disturbance_mode == DisturbanceMode.Translation:\n disturbance_inducer.from_translation(self.params.disturbance_value)\n elif self.params.disturbance_mode == DisturbanceMode.Rotation:\n disturbance_inducer.from_rotation_around( \\\n self.params.disturbance_value,\n self.params.start_position)\n disturbance_inducer.triggercondition = self.disturbance_triggercondition\n \n reach_goal = WaitMarkerPosition()\n reach_goal.goal_position = self.params.goal_position\n reach_goal.goal_radius = self.goal_radius\n reach_goal.set_dt(self.params.feedback_delay)\n reach_goal.marker_visible = True\n reach_goal.color = [1.0, 1.0, 1.0]\n reach_goal.on_goal_reached = self.on_goal_reached\n reach_goal.set_disturbance_inducer(disturbance_inducer)\n reach_goal.add_timeout(0.5 * self.params.timeout, self.on_reaching_timeout_warning)\n reach_goal.add_timeout(self.params.timeout, self.on_reaching_timeout_failed)\n\n sequence = Sequence([reach_start, wait_at_start, reach_goal])\n sequence.on_sequence_complete = self.on_sequence_complete\n\n env = self.statemachine.env\n env.logger.info(\"Trial: sequence start\")\n self.statemachine.push_state(sequence)\n \n\n def on_start_reached(self, sender):\n env = self.statemachine.env\n env.logger.info(\"Trial: start reached\")\n self._ppstart.setAutoDraw(False)\n self._ppgoal.setAutoDraw(False)\n\n def on_wait_at_start_timeout(self, sender):\n env = self.statemachine.env\n env.logger.info(\"Trial: go signal\")\n env.digital_io.set_bit(DigitalStream.TRIAL_BIT)\n self._ppstart.setAutoDraw(False)\n self._ppgoal.setAutoDraw(True)\n self.statemachine.pop_state()\n\n def on_reaching_timeout_warning(self, sender):\n sender._ppmarker.setFillColor([1.0, 0.0, 0.0])\n sender._ppmarker.setLineColor([1.0, 0.0, 0.0])\n\n def on_reaching_timeout_failed(self, sender):\n env = self.statemachine.env\n env.logger.info(\"Trial: goal timeout\")\n env.digital_io.reset_bit(DigitalStream.TRIAL_BIT)\n fbk.negative()\n self.statemachine.pop_state()\n \n def on_goal_reached(self, sender):\n env = self.statemachine.env\n env.logger.info(\"Trial: goal reached\")\n env.digital_io.reset_bit(DigitalStream.TRIAL_BIT)\n fbk.positive()\n \n def on_sequence_complete(self, sender):\n env = self.statemachine.env\n env.logger.info(\"Trial: sequence end\")\n self._ppgoal.setAutoDraw(False)\n self.statemachine.pop_state()\n\n def disturbance_triggercondition(self, env, markerposition):\n if self.params.disturbance_threshold is None:\n return False\n disttostart = np.linalg.norm(markerposition - self.params.start_position)\n disttogoal = np.linalg.norm(markerposition - self.params.goal_position)\n return disttogoal < self.params.disturbance_threshold * disttostart\n\n\n\nclass Experiment(OptotrakReader):\n def __init__(self, params):\n super(Experiment, self).__init__()\n assert isinstance(params, ExperimentParams)\n self.params = params\n \n \n def on_init(self):\n super(Experiment, self).on_init()\n env = self.statemachine.env\n env.logger.info(ulog.NPRecord(\"Experiment.params\", self.params))\n env.digital_io.reset_bit(DigitalStream.TRIAL_BIT) \n np.random.seed(555)\n\n trainingtrials = []\n for goal_position in self.params.goal_positions:\n for i in range(self.params.ntraining_trials):\n trialparam = TrialParams(number=0,\n feedback_delay=self.params.feedback_delay,\n start_position=self.params.start_position, \n goal_position=goal_position,\n disturbance_mode=DisturbanceMode.NoDisturbance,\n disturbance_threshold=None,\n timeout=self.params.training_timeout)\n trainingtrials.append(Trial(trialparam))\n # Permute the training trials\n perms = np.random.permutation(len(trainingtrials))\n trainingtrials = [trainingtrials[i] for i in perms]\n\n catchtrials = []\n for goal_position in self.params.goal_positions:\n for disturbance in self.params.rotation_disturbances:\n for i in range(self.params.nrotation_disturbance_trials):\n trialparam = TrialParams(number=0,\n feedback_delay=self.params.feedback_delay, \n start_position=self.params.start_position, \n goal_position=goal_position,\n disturbance_threshold=self.params.disturbance_threshold,\n disturbance_mode=DisturbanceMode.Rotation,\n disturbance_value=disturbance,\n timeout=self.params.disturbance_timeout)\n catchtrials.append(Trial(trialparam))\n for disturbance in self.params.translation_disturbances:\n for i in range(self.params.ntranslation_disturbance_trials):\n if self.params.disturbance_CS == CoordSystem.Screen:\n disturbance_value = disturbance\n elif self.params.disturbance_CS == CoordSystem.Task:\n v = goal_position - self.params.start_position\n angle = np.arctan2(v[1], v[0]) - 0.5 * np.pi\n mr = np.array([[np.cos(angle), -np.sin(angle)],\n [np.sin(angle), np.cos(angle)]])\n disturbance_value = mr.dot(disturbance)\n trialparam = TrialParams(number=0,\n feedback_delay=self.params.feedback_delay, \n start_position=self.params.start_position, \n goal_position=goal_position,\n disturbance_threshold=self.params.disturbance_threshold,\n disturbance_mode=DisturbanceMode.Translation,\n disturbance_value=disturbance_value,\n timeout=self.params.disturbance_timeout)\n catchtrials.append(Trial(trialparam))\n\n # Permute the catch trials\n perms = np.random.permutation(len(catchtrials))\n catchtrials = [catchtrials[i] for i in perms]\n\n print(\"Full number of disturbance trials in the experiment: {}\".format(len(catchtrials)))\n\n if self.params.max_blocks > 1 and self.params.block_number != 0:\n ntrials = len(catchtrials)\n nblocks = self.params.max_blocks\n blockid = self.params.block_number - 1\n \n min_block_size = ntrials / nblocks\n start = blockid * min_block_size\n end = start + min_block_size\n if blockid == nblocks-1:\n end = ntrials\n catchtrials = [catchtrials[i] for i in range(start, end)]\n print(\"Block {} of {}. number of disturbance trials in the block: {}\".format(\n self.params.block_number, self.params.max_blocks, len(catchtrials)))\n \n if self.params.block_number > 1:\n # Random refresh training trials for blocks > 1\n np.random.seed()\n perms = np.random.permutation(len(trainingtrials))\n trainingtrials = [trainingtrials[i] for i in perms]\n trainingtrials = [trainingtrials[i] for i in range(min(10, len(trainingtrials)))]\n \n print(\"Number of trainin trials: {}\".format(len(trainingtrials)))\n print(\"Number of disturbance trials: {}\".format(len(catchtrials)))\n \n # Set trial numbers\n trials = trainingtrials + catchtrials\n for i, trial in enumerate(trials):\n trial.params.number = i\n\n trailssequence = Sequence(trials)\n trailssequence.on_step = self.on_trial_step\n\n intro = [TextMessage(\"Delayed feedback experiment start\")]\n outtro = [TextMessage(\"Delayed feedback experiment finish\")]\n sequence = Sequence(intro + [trailssequence] + outtro)\n sequence.on_sequence_complete = self.on_sequence_complete\n env.logger.info(\"Experiment: sequence start\") \n self.statemachine.push_state(sequence)\n \n def on_trial_step(self, sender):\n i = sender.index + 1\n n = len(sender.states)\n print(\"Trial {} of {} ({}%)\".format(i, n, 100.0 * i / n))\n\n def on_sequence_complete(self, sender):\n env = self.statemachine.env\n env.logger.info(\"Experiment: sequence end\")\n self.statemachine.pop_state()\n\n"
] | [
[
"numpy.random.seed",
"numpy.linspace",
"numpy.linalg.norm",
"numpy.cos",
"numpy.sin",
"numpy.arctan2",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Sara-X/transformers | [
"6d9e11a1939815910e9274cc1109b632cfa84db4"
] | [
"tests/test_tokenization_wav2vec2.py"
] | [
"# coding=utf-8\n# Copyright 2021 The HuggingFace Team. 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\"\"\"Tests for the Wav2Vec2 tokenizer.\"\"\"\nimport inspect\nimport json\nimport os\nimport random\nimport shutil\nimport tempfile\nimport unittest\n\nimport numpy as np\n\nfrom transformers import (\n WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,\n Wav2Vec2Config,\n Wav2Vec2CTCTokenizer,\n Wav2Vec2Tokenizer,\n)\nfrom transformers.models.wav2vec2.tokenization_wav2vec2 import VOCAB_FILES_NAMES\nfrom transformers.testing_utils import slow\n\nfrom .test_tokenization_common import TokenizerTesterMixin\n\n\nglobal_rng = random.Random()\n\n\ndef floats_list(shape, scale=1.0, rng=None, name=None):\n \"\"\"Creates a random float32 tensor\"\"\"\n if rng is None:\n rng = global_rng\n\n values = []\n for batch_idx in range(shape[0]):\n values.append([])\n for _ in range(shape[1]):\n values[-1].append(rng.random() * scale)\n\n return values\n\n\nclass Wav2Vec2TokenizerTest(unittest.TestCase):\n tokenizer_class = Wav2Vec2Tokenizer\n\n def setUp(self):\n super().setUp()\n\n vocab = \"<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K ' X J Q Z\".split(\" \")\n vocab_tokens = dict(zip(vocab, range(len(vocab))))\n\n self.special_tokens_map = {\"pad_token\": \"<pad>\", \"unk_token\": \"<unk>\", \"bos_token\": \"<s>\", \"eos_token\": \"</s>\"}\n\n self.tmpdirname = tempfile.mkdtemp()\n self.vocab_file = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES[\"vocab_file\"])\n with open(self.vocab_file, \"w\", encoding=\"utf-8\") as fp:\n fp.write(json.dumps(vocab_tokens) + \"\\n\")\n\n def get_tokenizer(self, **kwargs):\n kwargs.update(self.special_tokens_map)\n return Wav2Vec2Tokenizer.from_pretrained(self.tmpdirname, **kwargs)\n\n def test_tokenizer_decode(self):\n # TODO(PVP) - change to facebook\n tokenizer = Wav2Vec2Tokenizer.from_pretrained(\"facebook/wav2vec2-base-960h\")\n\n sample_ids = [\n [11, 5, 15, tokenizer.pad_token_id, 15, 8, 98],\n [24, 22, 5, tokenizer.word_delimiter_token_id, 24, 22, 5, 77],\n ]\n tokens = tokenizer.decode(sample_ids[0])\n batch_tokens = tokenizer.batch_decode(sample_ids)\n self.assertEqual(tokens, batch_tokens[0])\n self.assertEqual(batch_tokens, [\"HELLO<unk>\", \"BYE BYE<unk>\"])\n\n def test_tokenizer_decode_special(self):\n # TODO(PVP) - change to facebook\n tokenizer = Wav2Vec2Tokenizer.from_pretrained(\"facebook/wav2vec2-base-960h\")\n\n sample_ids = [\n [11, 5, 15, tokenizer.pad_token_id, 15, 8, 98],\n [24, 22, 5, tokenizer.word_delimiter_token_id, 24, 22, 5, 77],\n ]\n sample_ids_2 = [\n [11, 5, 5, 5, 5, 5, 15, 15, 15, tokenizer.pad_token_id, 15, 8, 98],\n [\n 24,\n 22,\n 5,\n tokenizer.pad_token_id,\n tokenizer.pad_token_id,\n tokenizer.pad_token_id,\n tokenizer.word_delimiter_token_id,\n 24,\n 22,\n 5,\n 77,\n tokenizer.word_delimiter_token_id,\n ],\n ]\n\n batch_tokens = tokenizer.batch_decode(sample_ids)\n batch_tokens_2 = tokenizer.batch_decode(sample_ids_2)\n self.assertEqual(batch_tokens, batch_tokens_2)\n self.assertEqual(batch_tokens, [\"HELLO<unk>\", \"BYE BYE<unk>\"])\n\n def test_tokenizer_decode_added_tokens(self):\n tokenizer = Wav2Vec2Tokenizer.from_pretrained(\"facebook/wav2vec2-base-960h\")\n tokenizer.add_tokens([\"!\", \"?\"])\n tokenizer.add_special_tokens({\"cls_token\": \"$$$\"})\n\n sample_ids = [\n [\n 11,\n 5,\n 15,\n tokenizer.pad_token_id,\n 15,\n 8,\n 98,\n 32,\n 32,\n 33,\n tokenizer.word_delimiter_token_id,\n 32,\n 32,\n 33,\n 34,\n 34,\n ],\n [24, 22, 5, tokenizer.word_delimiter_token_id, 24, 22, 5, 77, tokenizer.pad_token_id, 34, 34],\n ]\n batch_tokens = tokenizer.batch_decode(sample_ids)\n\n self.assertEqual(batch_tokens, [\"HELLO<unk>!?!?$$$\", \"BYE BYE<unk>$$$\"])\n\n def test_call(self):\n # Tests that all call wrap to encode_plus and batch_encode_plus\n tokenizer = self.get_tokenizer()\n # create three inputs of length 800, 1000, and 1200\n speech_inputs = [floats_list((1, x))[0] for x in range(800, 1400, 200)]\n np_speech_inputs = [np.asarray(speech_input) for speech_input in speech_inputs]\n\n # Test not batched input\n encoded_sequences_1 = tokenizer(speech_inputs[0], return_tensors=\"np\").input_values\n encoded_sequences_2 = tokenizer(np_speech_inputs[0], return_tensors=\"np\").input_values\n self.assertTrue(np.allclose(encoded_sequences_1, encoded_sequences_2, atol=1e-3))\n\n # Test batched\n encoded_sequences_1 = tokenizer(speech_inputs, return_tensors=\"np\").input_values\n encoded_sequences_2 = tokenizer(np_speech_inputs, return_tensors=\"np\").input_values\n for enc_seq_1, enc_seq_2 in zip(encoded_sequences_1, encoded_sequences_2):\n self.assertTrue(np.allclose(enc_seq_1, enc_seq_2, atol=1e-3))\n\n def test_padding(self, max_length=50):\n def _input_values_have_equal_length(input_values):\n length = len(input_values[0])\n for input_values_slice in input_values[1:]:\n if len(input_values_slice) != length:\n return False\n return True\n\n def _input_values_are_equal(input_values_1, input_values_2):\n if len(input_values_1) != len(input_values_2):\n return False\n\n for input_values_slice_1, input_values_slice_2 in zip(input_values_1, input_values_2):\n if not np.allclose(np.asarray(input_values_slice_1), np.asarray(input_values_slice_2), atol=1e-3):\n return False\n return True\n\n tokenizer = self.get_tokenizer()\n speech_inputs = [floats_list((1, x))[0] for x in range(800, 1400, 200)]\n\n input_values_1 = tokenizer(speech_inputs).input_values\n input_values_2 = tokenizer(speech_inputs, padding=\"longest\").input_values\n input_values_3 = tokenizer(speech_inputs, padding=\"longest\", max_length=1600).input_values\n\n self.assertFalse(_input_values_have_equal_length(input_values_1))\n self.assertTrue(_input_values_have_equal_length(input_values_2))\n self.assertTrue(_input_values_have_equal_length(input_values_3))\n self.assertTrue(_input_values_are_equal(input_values_2, input_values_3))\n self.assertTrue(len(input_values_1[0]) == 800)\n self.assertTrue(len(input_values_2[0]) == 1200)\n # padding should be 0.0\n self.assertTrue(abs(sum(np.asarray(input_values_2[0])[800:])) < 1e-3)\n self.assertTrue(abs(sum(np.asarray(input_values_2[1])[1000:])) < 1e-3)\n\n input_values_4 = tokenizer(speech_inputs, padding=\"max_length\").input_values\n input_values_5 = tokenizer(speech_inputs, padding=\"max_length\", max_length=1600).input_values\n\n self.assertTrue(_input_values_are_equal(input_values_1, input_values_4))\n self.assertTrue(input_values_5.shape, (3, 1600))\n # padding should be 0.0\n self.assertTrue(abs(sum(np.asarray(input_values_5[0])[800:1200])) < 1e-3)\n\n input_values_6 = tokenizer(speech_inputs, pad_to_multiple_of=500).input_values\n input_values_7 = tokenizer(speech_inputs, padding=\"longest\", pad_to_multiple_of=500).input_values\n input_values_8 = tokenizer(\n speech_inputs, padding=\"max_length\", pad_to_multiple_of=500, max_length=2400\n ).input_values\n\n self.assertTrue(_input_values_are_equal(input_values_1, input_values_6))\n self.assertTrue(input_values_7.shape, (3, 1500))\n self.assertTrue(input_values_8.shape, (3, 2500))\n # padding should be 0.0\n self.assertTrue(abs(sum(np.asarray(input_values_7[0])[800:])) < 1e-3)\n self.assertTrue(abs(sum(np.asarray(input_values_7[1])[1000:])) < 1e-3)\n self.assertTrue(abs(sum(np.asarray(input_values_7[2])[1200:])) < 1e-3)\n self.assertTrue(abs(sum(np.asarray(input_values_8[0])[800:])) < 1e-3)\n self.assertTrue(abs(sum(np.asarray(input_values_8[1])[1000:])) < 1e-3)\n self.assertTrue(abs(sum(np.asarray(input_values_8[2])[1200:])) < 1e-3)\n\n def test_save_pretrained(self):\n pretrained_name = list(self.tokenizer_class.pretrained_vocab_files_map[\"vocab_file\"].keys())[0]\n tokenizer = self.tokenizer_class.from_pretrained(pretrained_name)\n tmpdirname2 = tempfile.mkdtemp()\n\n tokenizer_files = tokenizer.save_pretrained(tmpdirname2)\n self.assertSequenceEqual(\n sorted(tuple(VOCAB_FILES_NAMES.values()) + (\"special_tokens_map.json\", \"added_tokens.json\")),\n sorted(tuple(x.split(\"/\")[-1] for x in tokenizer_files)),\n )\n\n # Checks everything loads correctly in the same way\n tokenizer_p = self.tokenizer_class.from_pretrained(tmpdirname2)\n\n # Check special tokens are set accordingly on Rust and Python\n for key in tokenizer.special_tokens_map:\n self.assertTrue(key in tokenizer_p.special_tokens_map)\n\n shutil.rmtree(tmpdirname2)\n\n def test_get_vocab(self):\n tokenizer = self.get_tokenizer()\n vocab_dict = tokenizer.get_vocab()\n self.assertIsInstance(vocab_dict, dict)\n self.assertGreaterEqual(len(tokenizer), len(vocab_dict))\n\n vocab = [tokenizer.convert_ids_to_tokens(i) for i in range(len(tokenizer))]\n self.assertEqual(len(vocab), len(tokenizer))\n\n tokenizer.add_tokens([\"asdfasdfasdfasdf\"])\n vocab = [tokenizer.convert_ids_to_tokens(i) for i in range(len(tokenizer))]\n self.assertEqual(len(vocab), len(tokenizer))\n\n def test_save_and_load_tokenizer(self):\n tokenizer = self.get_tokenizer()\n # Isolate this from the other tests because we save additional tokens/etc\n tmpdirname = tempfile.mkdtemp()\n\n sample_ids = [0, 1, 4, 8, 9, 0, 12]\n before_tokens = tokenizer.decode(sample_ids)\n before_vocab = tokenizer.get_vocab()\n tokenizer.save_pretrained(tmpdirname)\n\n after_tokenizer = tokenizer.__class__.from_pretrained(tmpdirname)\n after_tokens = after_tokenizer.decode(sample_ids)\n after_vocab = after_tokenizer.get_vocab()\n\n self.assertEqual(before_tokens, after_tokens)\n self.assertDictEqual(before_vocab, after_vocab)\n\n shutil.rmtree(tmpdirname)\n\n tokenizer = self.get_tokenizer()\n\n # Isolate this from the other tests because we save additional tokens/etc\n tmpdirname = tempfile.mkdtemp()\n\n before_len = len(tokenizer)\n sample_ids = [0, 1, 4, 8, 9, 0, 12, before_len, before_len + 1, before_len + 2]\n tokenizer.add_tokens([\"?\", \"!\"])\n additional_special_tokens = tokenizer.additional_special_tokens\n additional_special_tokens.append(\"&\")\n tokenizer.add_special_tokens({\"additional_special_tokens\": additional_special_tokens})\n before_tokens = tokenizer.decode(sample_ids)\n before_vocab = tokenizer.get_vocab()\n tokenizer.save_pretrained(tmpdirname)\n\n after_tokenizer = tokenizer.__class__.from_pretrained(tmpdirname)\n after_tokens = after_tokenizer.decode(sample_ids)\n after_vocab = after_tokenizer.get_vocab()\n\n self.assertEqual(before_tokens, after_tokens)\n self.assertDictEqual(before_vocab, after_vocab)\n\n self.assertTrue(len(tokenizer), before_len + 3)\n self.assertTrue(len(tokenizer), len(after_tokenizer))\n shutil.rmtree(tmpdirname)\n\n def test_tokenizer_slow_store_full_signature(self):\n signature = inspect.signature(self.tokenizer_class.__init__)\n tokenizer = self.get_tokenizer()\n\n for parameter_name, parameter in signature.parameters.items():\n if parameter.default != inspect.Parameter.empty:\n self.assertIn(parameter_name, tokenizer.init_kwargs)\n\n def test_zero_mean_unit_variance_normalization(self):\n tokenizer = self.get_tokenizer(do_normalize=True)\n speech_inputs = [floats_list((1, x))[0] for x in range(800, 1400, 200)]\n processed = tokenizer(speech_inputs, padding=\"longest\")\n input_values = processed.input_values\n\n def _check_zero_mean_unit_variance(input_vector):\n self.assertTrue(np.abs(np.mean(input_vector)) < 1e-3)\n self.assertTrue(np.abs(np.var(input_vector) - 1) < 1e-3)\n\n _check_zero_mean_unit_variance(input_values[0, :800])\n _check_zero_mean_unit_variance(input_values[1, :1000])\n _check_zero_mean_unit_variance(input_values[2])\n\n def test_return_attention_mask(self):\n speech_inputs = [floats_list((1, x))[0] for x in range(800, 1400, 200)]\n\n # default case -> no attention_mask is returned\n tokenizer = self.get_tokenizer()\n processed = tokenizer(speech_inputs)\n self.assertNotIn(\"attention_mask\", processed)\n\n # wav2vec2-lv60 -> return attention_mask\n tokenizer = self.get_tokenizer(return_attention_mask=True)\n processed = tokenizer(speech_inputs, padding=\"longest\")\n\n self.assertIn(\"attention_mask\", processed)\n self.assertListEqual(list(processed.attention_mask.shape), list(processed.input_values.shape))\n self.assertListEqual(processed.attention_mask.sum(-1).tolist(), [800, 1000, 1200])\n\n @slow\n def test_pretrained_checkpoints_are_set_correctly(self):\n # this test makes sure that models that are using\n # group norm don't have their tokenizer return the\n # attention_mask\n for model_id in WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST:\n config = Wav2Vec2Config.from_pretrained(model_id)\n tokenizer = Wav2Vec2Tokenizer.from_pretrained(model_id)\n\n # only \"layer\" feature extraction norm should make use of\n # attention_mask\n self.assertEqual(tokenizer.return_attention_mask, config.feat_extract_norm == \"layer\")\n\n\nclass Wav2Vec2CTCTokenizerTest(TokenizerTesterMixin, unittest.TestCase):\n tokenizer_class = Wav2Vec2CTCTokenizer\n test_rust_tokenizer = False\n\n def setUp(self):\n super().setUp()\n\n vocab = \"<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K ' X J Q Z\".split(\" \")\n vocab_tokens = dict(zip(vocab, range(len(vocab))))\n\n self.special_tokens_map = {\"pad_token\": \"<pad>\", \"unk_token\": \"<unk>\", \"bos_token\": \"<s>\", \"eos_token\": \"</s>\"}\n\n self.tmpdirname = tempfile.mkdtemp()\n self.vocab_file = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES[\"vocab_file\"])\n with open(self.vocab_file, \"w\", encoding=\"utf-8\") as fp:\n fp.write(json.dumps(vocab_tokens) + \"\\n\")\n\n def get_tokenizer(self, **kwargs):\n kwargs.update(self.special_tokens_map)\n return Wav2Vec2CTCTokenizer.from_pretrained(self.tmpdirname, **kwargs)\n\n def test_tokenizer_decode(self):\n tokenizer = self.tokenizer_class.from_pretrained(\"facebook/wav2vec2-base-960h\")\n\n sample_ids = [\n [11, 5, 15, tokenizer.pad_token_id, 15, 8, 98],\n [24, 22, 5, tokenizer.word_delimiter_token_id, 24, 22, 5, 77],\n ]\n tokens = tokenizer.decode(sample_ids[0])\n batch_tokens = tokenizer.batch_decode(sample_ids)\n self.assertEqual(tokens, batch_tokens[0])\n self.assertEqual(batch_tokens, [\"HELLO<unk>\", \"BYE BYE<unk>\"])\n\n def test_tokenizer_decode_special(self):\n tokenizer = self.tokenizer_class.from_pretrained(\"facebook/wav2vec2-base-960h\")\n\n sample_ids = [\n [11, 5, 15, tokenizer.pad_token_id, 15, 8, 98],\n [24, 22, 5, tokenizer.word_delimiter_token_id, 24, 22, 5, 77],\n ]\n sample_ids_2 = [\n [11, 5, 5, 5, 5, 5, 15, 15, 15, tokenizer.pad_token_id, 15, 8, 98],\n [\n 24,\n 22,\n 5,\n tokenizer.pad_token_id,\n tokenizer.pad_token_id,\n tokenizer.pad_token_id,\n tokenizer.word_delimiter_token_id,\n 24,\n 22,\n 5,\n 77,\n tokenizer.word_delimiter_token_id,\n ],\n ]\n\n batch_tokens = tokenizer.batch_decode(sample_ids)\n batch_tokens_2 = tokenizer.batch_decode(sample_ids_2)\n self.assertEqual(batch_tokens, batch_tokens_2)\n self.assertEqual(batch_tokens, [\"HELLO<unk>\", \"BYE BYE<unk>\"])\n\n def test_tokenizer_decode_added_tokens(self):\n tokenizer = self.tokenizer_class.from_pretrained(\"facebook/wav2vec2-base-960h\")\n tokenizer.add_tokens([\"!\", \"?\"])\n tokenizer.add_special_tokens({\"cls_token\": \"$$$\"})\n\n sample_ids = [\n [\n 11,\n 5,\n 15,\n tokenizer.pad_token_id,\n 15,\n 8,\n 98,\n 32,\n 32,\n 33,\n tokenizer.word_delimiter_token_id,\n 32,\n 32,\n 33,\n 34,\n 34,\n ],\n [24, 22, 5, tokenizer.word_delimiter_token_id, 24, 22, 5, 77, tokenizer.pad_token_id, 34, 34],\n ]\n batch_tokens = tokenizer.batch_decode(sample_ids)\n\n self.assertEqual(batch_tokens, [\"HELLO<unk>!?!?$$$\", \"BYE BYE<unk>$$$\"])\n\n def test_pretrained_model_lists(self):\n # Wav2Vec2Model has no max model length => no\n pass\n"
] | [
[
"numpy.asarray",
"numpy.var",
"numpy.mean",
"numpy.allclose"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ishine/nlp-dialogue | [
"d47c1438cb5c45c2c2aebfb82fea92bef4c3d65c",
"fcf985e3c9bfd6944d07c4c36afbaee3384d040d"
] | [
"dialogue/tensorflow/beamsearch.py",
"dialogue/tensorflow/gpt2/gpt2.py"
] | [
"# Copyright 2021 DengBoCong. 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\"\"\"BeachSearch实现，支持Encoder-Decoder结构，多beam输出和截断\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport copy\nimport tensorflow as tf\nfrom typing import List\nfrom typing import NoReturn\nfrom typing import Tuple\n\n\nclass BeamSearch(object):\n\n def __init__(self, beam_size, max_length, worst_score) -> NoReturn:\n \"\"\"\n :param beam_size: beam大小\n :param max_length: 句子最大长度\n :param worst_score: 最差分数\n \"\"\"\n self.BEAM_SIZE = beam_size # 保存原始beam大小，用于重置\n self.MAX_LEN = max_length - 1\n self.MIN_SCORE = worst_score # 保留原始worst_score，用于重置\n\n self.candidates = [] # 保存中间状态序列的容器，元素格式为(score, sequence)类型为(float, [])\n self.result = [] # 用来保存已经遇到结束符的序列\n self.result_plus = [] # 用来保存已经遇到结束符的带概率分布的序列\n self.candidates_plus = [] # 保存已经遇到结束符的序列及概率分布\n\n self.enc_output = None\n self.remain = None\n self.dec_inputs = None\n self.beam_size = None\n self.worst_score = None\n\n def __len__(self):\n \"\"\"当前候选结果数\n \"\"\"\n return len(self.candidates)\n\n def reset(self, enc_output: tf.Tensor, dec_input: tf.Tensor, remain: tf.Tensor) -> NoReturn:\n \"\"\"重置搜索\n\n :param enc_output: 已经序列化的输入句子\n :param dec_input: 解码器输入序列\n :param remain: 预留decoder输入\n :return: 无返回值\n \"\"\"\n self.candidates = [] # 保存中间状态序列的容器，元素格式为(score, sequence)类型为(float, [])\n self.candidates_plus = [] # 保存已经遇到结束符的序列及概率分布,元素为(score, tensor),tensor的shape为(seq_len, vocab_size)\n self.candidates.append((1, dec_input))\n self.enc_output = enc_output\n self.remain = remain\n self.dec_inputs = dec_input\n self.beam_size = self.BEAM_SIZE # 新一轮中，将beam_size重置为原beam大小\n self.worst_score = self.MIN_SCORE # 新一轮中，worst_score重置\n self.result = [] # 用来保存已经遇到结束符的序列\n self.result_plus = [] # 用来保存已经遇到结束符的带概率分布的序列元素为tensor, tensor的shape为(seq_len, vocab_size)\n\n def get_search_inputs(self) -> Tuple:\n \"\"\"为下一步预测生成输入\n\n :return: enc_output, dec_inputs, remain\n \"\"\"\n # 生成多beam输入\n enc_output = self.enc_output\n remain = self.remain\n self.dec_inputs = self.candidates[0][1]\n for i in range(1, len(self)):\n enc_output = tf.concat([enc_output, self.enc_output], 0)\n remain = tf.concat([remain, self.remain], 0)\n self.dec_inputs = tf.concat([self.dec_inputs, self.candidates[i][1]], axis=0)\n\n return enc_output, self.dec_inputs, remain\n\n def _reduce_end(self, end_sign: str) -> NoReturn:\n \"\"\" 当序列遇到了结束token，需要将该序列从容器中移除\n\n :param end_sign: 句子结束标记\n :return: 无返回值\n \"\"\"\n for idx, (s, dec) in enumerate(self.candidates):\n temp = dec.numpy()\n if temp[0][-1] == end_sign:\n self.result.append(self.candidates[idx])\n self.result_plus.append(self.candidates_plus[idx])\n del self.candidates[idx]\n del self.candidates_plus[idx]\n self.beam_size -= 1\n\n def expand(self, predictions, end_sign) -> NoReturn:\n \"\"\" 根据预测结果对候选进行扩展\n 往容器中添加预测结果，在本方法中对预测结果进行整理、排序的操作\n\n :param predictions: 传入每个时间步的模型预测值\n :param end_sign: 句子结束标记\n :return: 无返回值\n \"\"\"\n prev_candidates = copy.deepcopy(self.candidates)\n prev_candidates_plus = copy.deepcopy(self.candidates_plus)\n self.candidates.clear()\n self.candidates_plus.clear()\n predictions = predictions.numpy()\n predictions_plus = copy.deepcopy(predictions)\n # 在batch_size*beam_size个prediction中找到分值最高的beam_size个\n for i in range(self.dec_inputs.shape[0]): # 外循环遍历batch_size（batch_size的值其实就是之前选出的候选数量）\n for _ in range(self.beam_size): # 内循环遍历选出beam_size个概率最大位置\n token_index = tf.argmax(input=predictions[i], axis=0) # predictions.shape --> (batch_size, vocab_size)\n # 计算分数\n score = prev_candidates[i][0] * predictions[i][token_index]\n predictions[i][token_index] = 0\n # 判断容器容量以及分数比较\n if len(self) < self.beam_size or score > self.worst_score:\n self.candidates.append((score, tf.concat(\n [prev_candidates[i][1], tf.constant([[token_index.numpy()]], shape=(1, 1))], axis=-1)))\n if len(prev_candidates_plus) == 0:\n self.candidates_plus.append((score, predictions_plus))\n else:\n self.candidates_plus.append(\n (score, tf.concat([prev_candidates_plus[i][1], [predictions_plus[i]]], axis=0)))\n if len(self) > self.beam_size:\n sorted_scores = sorted([(s, idx) for idx, (s, _) in enumerate(self.candidates)])\n del self.candidates[sorted_scores[0][1]]\n del self.candidates_plus[sorted_scores[0][1]]\n self.worst_score = sorted_scores[1][0]\n else:\n self.worst_score = min(score, self.worst_score)\n self._reduce_end(end_sign=end_sign)\n\n def get_result(self, top_k=1) -> List:\n \"\"\"获得概率最高的top_k个结果\n\n :param top_k: 输出结果数量\n :return: 概率最高的top_k个结果\n \"\"\"\n if not self.result:\n self.result = self.candidates\n results = [element[1] for element in sorted(self.result)[-top_k:]]\n return results\n\n def get_result_plus(self, top_k=1) -> List:\n \"\"\"获得概率最高的top_k个结果\n\n :param top_k: 输出结果数量\n :return: 概率最高的top_k个带概率的结果\n \"\"\"\n sorted_scores = sorted([(s, idx) for idx, (s, _) in enumerate(self.result)], reverse=True)\n results_plus = []\n for i in range(top_k):\n results_plus.append(self.result_plus[sorted_scores[i][1]][1])\n\n return results_plus\n",
"import tensorflow as tf\n\n\ndef creat_padding_mask(inputs):\n \"\"\"\n 对input中的padding单位进行mask\n :param inputs: 句子序列输入\n :return: 填充部分标记\n \"\"\"\n mask = tf.cast(tf.math.equal(inputs, 0), dtype=tf.float32)\n return mask[:, tf.newaxis, tf.newaxis, :]\n\n\ndef creat_look_ahead_mask(inputs):\n sequence_length = tf.shape(inputs)[1]\n look_ahead_mask = 1 - \\\n tf.linalg.band_part(tf.ones((sequence_length, sequence_length)), -1, 0)\n padding_mask = creat_padding_mask(inputs)\n return tf.maximum(look_ahead_mask, padding_mask)\n\n\ndef positional_encoding(position, deep):\n i = tf.range(deep, dtype=tf.float32)[tf.newaxis, :]\n position = tf.range(position, dtype=tf.float32)[:, tf.newaxis]\n angles = 1 / tf.pow(10000, (2 * (i // 2)) / tf.cast(deep, tf.float32))\n angle_rads = position * angles\n\n sines = tf.math.sin(angle_rads[:, 0::2])\n cosines = tf.math.cos(angle_rads[:, 1::2])\n pos_encoding = tf.concat([sines, cosines], axis=-1)\n pos_encoding = pos_encoding[tf.newaxis, ...]\n return tf.cast(pos_encoding, tf.float32)\n\n\ndef split_heads(inputs, batch_size, num, deep):\n depth = deep // num\n inputs = tf.reshape(inputs, (batch_size, -1, num, depth))\n return tf.transpose(inputs, perm=[0, 2, 1, 3])\n\n\ndef positional_encoding_layer(position, deep):\n inputs = tf.keras.Input(shape=(None, deep))\n pos_encoding = positional_encoding(position, deep)\n outputs = inputs + pos_encoding[:, :tf.shape(inputs)[1], :]\n return tf.keras.Model(inputs=inputs, outputs=outputs)\n\n\ndef encoder(vocab_size, deep, dropout):\n inputs = tf.keras.Input(shape=(None,))\n embedding = tf.keras.layers.Embedding(vocab_size, deep)(inputs)\n embedding *= tf.math.sqrt(tf.cast(deep, tf.float32))\n embedding = positional_encoding_layer(vocab_size, deep)(embedding)\n outputs = tf.keras.layers.Dropout(rate=dropout)(embedding)\n\n return tf.keras.Model(inputs=inputs, outputs=outputs)\n\n\ndef self_attention(query, key, value, mask):\n matmul = tf.matmul(query, key, transpose_b=True)\n deep = tf.cast(tf.shape(key)[-1], tf.float32)\n scaled_attention = matmul / tf.math.sqrt(deep)\n\n if mask is not None:\n scaled_attention += (mask * -1e9)\n attention_weight = tf.nn.softmax(scaled_attention, axis=-1)\n output = tf.matmul(attention_weight, value)\n return output\n\n\ndef attention(deep, num):\n query = tf.keras.Input(shape=(None, deep))\n key = tf.keras.Input(shape=(None, deep))\n value = tf.keras.Input(shape=(None, deep))\n mask = tf.keras.Input(shape=(1, None, None))\n batch_size = tf.shape(query)[0]\n\n query_fc = tf.keras.layers.Dense(units=deep)(query)\n key_fc = tf.keras.layers.Dense(units=deep)(key)\n value_fc = tf.keras.layers.Dense(units=deep)(value)\n\n query_fc = split_heads(query_fc, batch_size, num, deep)\n key_fc = split_heads(key_fc, batch_size, num, deep)\n value_fc = split_heads(value_fc, batch_size, num, deep)\n\n attention_state = self_attention(query_fc, key_fc, value_fc, mask)\n attention_state = tf.transpose(attention_state, perm=[0, 2, 1, 3])\n concat_attention = tf.reshape(attention_state, (batch_size, -1, deep))\n output = tf.keras.layers.Dense(units=deep)(concat_attention)\n\n return tf.keras.Model(inputs=[query, key, value, mask], outputs=output)\n\n\ndef block(units, deep, num, dropout):\n inputs = tf.keras.Input(shape=(None, deep))\n mask = tf.keras.Input(shape=(1, None, None))\n\n attention_state = attention(deep, num)(\n inputs=[inputs, inputs, inputs, mask])\n attention_state = tf.keras.layers.LayerNormalization(\n epsilon=1e-6)(attention_state + inputs)\n outputs = tf.keras.layers.Dense(\n units=units, activation=\"relu\")(attention_state)\n outputs = tf.keras.layers.Dense(units=deep)(outputs)\n outputs = tf.keras.layers.Dropout(rate=dropout)(outputs)\n outputs = tf.keras.layers.LayerNormalization(\n epsilon=1e-6)(outputs + attention_state)\n\n return tf.keras.Model(inputs=[inputs, mask], outputs=outputs)\n\n\ndef decoder(num_layers, num_heads, units, deep, dropout):\n inputs = tf.keras.Input(shape=(None, deep))\n mask = tf.keras.Input(shape=(1, None, None))\n\n outputs = inputs\n for i in range(num_layers):\n outputs = block(units, deep, num_heads, dropout)(\n inputs=[outputs, mask])\n return tf.keras.Model(inputs=[inputs, mask], outputs=outputs)\n\n\nclass CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):\n \"\"\"\n 优化器将 Adam 优化器与自定义的学习速率调度程序配合使用，这里直接参考了官网的实现\n 因为是公式的原因，其实大同小异\n \"\"\"\n\n def __init__(self, d_model, warmup_steps=2000):\n super(CustomSchedule, self).__init__()\n self.d_model = d_model\n self.d_model = tf.cast(self.d_model, tf.float32)\n self.warmup_steps = warmup_steps\n\n def __call__(self, step):\n arg1 = tf.math.rsqrt(step)\n arg2 = step * (self.warmup_steps ** -1.5)\n return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2)\n\n\ndef gpt2(vocab_size, num_layers, units, deep, num_heads, dropout):\n inputs = tf.keras.Input(shape=(None,))\n outputs = encoder(vocab_size=vocab_size, deep=deep,\n dropout=dropout)(inputs)\n\n mask = tf.keras.layers.Lambda(\n creat_look_ahead_mask, output_shape=(1, None, None))(inputs)\n\n for i in range(num_layers):\n outputs = block(units, deep, num_heads, dropout)(\n inputs=[outputs, mask])\n output = tf.keras.layers.Dense(units=vocab_size)(outputs)\n\n return tf.keras.Model(inputs=inputs, outputs=output)\n"
] | [
[
"tensorflow.argmax",
"tensorflow.concat"
],
[
"tensorflow.keras.layers.LayerNormalization",
"tensorflow.concat",
"tensorflow.cast",
"tensorflow.math.equal",
"tensorflow.keras.Input",
"tensorflow.keras.layers.Lambda",
"tensorflow.keras.layers.Embedding",
"tensorflow.math.sin",
"tensorflow.matmul",
"tensorflow.math.cos",
"tensorflow.shape",
"tensorflow.keras.layers.Dense",
"tensorflow.math.rsqrt",
"tensorflow.keras.Model",
"tensorflow.nn.softmax",
"tensorflow.transpose",
"tensorflow.math.sqrt",
"tensorflow.range",
"tensorflow.maximum",
"tensorflow.reshape",
"tensorflow.ones",
"tensorflow.keras.layers.Dropout",
"tensorflow.math.minimum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
kilimanjaro2/MRIQC_monkey | [
"f70c410d7459d4970351949e10443725187c0df2",
"f70c410d7459d4970351949e10443725187c0df2"
] | [
"mriqc/interfaces/viz.py",
"mriqc/utils/misc.py"
] | [
"# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-\n# vi: set ft=python sts=4 ts=4 sw=4 et:\n\"\"\"Visualization interfaces.\"\"\"\nfrom pathlib import Path\nimport numpy as np\nfrom nipype.interfaces.base import (\n traits,\n TraitedSpec,\n File,\n BaseInterfaceInputSpec,\n isdefined,\n SimpleInterface,\n)\n\nfrom io import open # pylint: disable=W0622\nfrom ..viz.utils import plot_mosaic, plot_segmentation, plot_spikes\n\n\nclass PlotContoursInputSpec(BaseInterfaceInputSpec):\n in_file = File(exists=True, mandatory=True, desc=\"File to be plotted\")\n in_contours = File(\n exists=True, mandatory=True, desc=\"file to pick the contours from\"\n )\n cut_coords = traits.Int(8, usedefault=True, desc=\"number of slices\")\n levels = traits.List(\n [0.5], traits.Float, usedefault=True, desc=\"add a contour per level\"\n )\n colors = traits.List(\n [\"r\"], traits.Str, usedefault=True, desc=\"colors to be used for contours\"\n )\n display_mode = traits.Enum(\n \"ortho\",\n \"x\",\n \"y\",\n \"z\",\n \"yx\",\n \"xz\",\n \"yz\",\n usedefault=True,\n desc=\"visualization mode\",\n )\n saturate = traits.Bool(False, usedefault=True, desc=\"saturate background\")\n out_file = traits.File(exists=False, desc=\"output file name\")\n vmin = traits.Float(desc=\"minimum intensity\")\n vmax = traits.Float(desc=\"maximum intensity\")\n\n\nclass PlotContoursOutputSpec(TraitedSpec):\n out_file = File(exists=True, desc=\"output svg file\")\n\n\nclass PlotContours(SimpleInterface):\n \"\"\" Plot contours \"\"\"\n\n input_spec = PlotContoursInputSpec\n output_spec = PlotContoursOutputSpec\n\n def _run_interface(self, runtime):\n in_file_ref = Path(self.inputs.in_file)\n\n if isdefined(self.inputs.out_file):\n in_file_ref = Path(self.inputs.out_file)\n\n fname = in_file_ref.name.rstrip(\"\".join(in_file_ref.suffixes))\n out_file = (Path(runtime.cwd) / (\"plot_%s_contours.svg\" % fname)).resolve()\n self._results[\"out_file\"] = str(out_file)\n\n vmax = None if not isdefined(self.inputs.vmax) else self.inputs.vmax\n vmin = None if not isdefined(self.inputs.vmin) else self.inputs.vmin\n\n plot_segmentation(\n self.inputs.in_file,\n self.inputs.in_contours,\n out_file=str(out_file),\n cut_coords=self.inputs.cut_coords,\n display_mode=self.inputs.display_mode,\n levels=self.inputs.levels,\n colors=self.inputs.colors,\n saturate=self.inputs.saturate,\n vmin=vmin,\n vmax=vmax,\n )\n\n return runtime\n\n\nclass PlotBaseInputSpec(BaseInterfaceInputSpec):\n in_file = File(exists=True, mandatory=True, desc=\"File to be plotted\")\n title = traits.Str(desc=\"a title string for the plot\")\n annotate = traits.Bool(True, usedefault=True, desc=\"annotate left/right\")\n figsize = traits.Tuple(\n (11.69, 8.27), traits.Float, traits.Float, usedefault=True, desc=\"Figure size\"\n )\n dpi = traits.Int(300, usedefault=True, desc=\"Desired DPI of figure\")\n out_file = File(\"mosaic.svg\", usedefault=True, desc=\"output file name\")\n cmap = traits.Str(\"Greys_r\", usedefault=True)\n\n\nclass PlotMosaicInputSpec(PlotBaseInputSpec):\n bbox_mask_file = File(exists=True, desc=\"brain mask\")\n only_noise = traits.Bool(False, desc=\"plot only noise\")\n\n\nclass PlotMosaicOutputSpec(TraitedSpec):\n out_file = File(exists=True, desc=\"output pdf file\")\n\n\nclass PlotMosaic(SimpleInterface):\n\n \"\"\"\n Plots slices of a 3D volume into a pdf file\n \"\"\"\n\n input_spec = PlotMosaicInputSpec\n output_spec = PlotMosaicOutputSpec\n\n def _run_interface(self, runtime):\n mask = None\n if isdefined(self.inputs.bbox_mask_file):\n mask = self.inputs.bbox_mask_file\n\n title = None\n if isdefined(self.inputs.title):\n title = self.inputs.title\n\n plot_mosaic(\n self.inputs.in_file,\n out_file=self.inputs.out_file,\n title=title,\n only_plot_noise=self.inputs.only_noise,\n bbox_mask_file=mask,\n cmap=self.inputs.cmap,\n annotate=self.inputs.annotate,\n )\n self._results[\"out_file\"] = str(\n (Path(runtime.cwd) / self.inputs.out_file).resolve()\n )\n return runtime\n\n\nclass PlotSpikesInputSpec(PlotBaseInputSpec):\n in_spikes = File(exists=True, mandatory=True, desc=\"tsv file of spikes\")\n in_fft = File(exists=True, mandatory=True, desc=\"nifti file with the 4D FFT\")\n\n\nclass PlotSpikesOutputSpec(TraitedSpec):\n out_file = File(exists=True, desc=\"output svg file\")\n\n\nclass PlotSpikes(SimpleInterface):\n \"\"\"\n Plot slices of a dataset with spikes\n \"\"\"\n\n input_spec = PlotSpikesInputSpec\n output_spec = PlotSpikesOutputSpec\n\n def _run_interface(self, runtime):\n out_file = str((Path(runtime.cwd) / self.inputs.out_file).resolve())\n self._results[\"out_file\"] = out_file\n\n spikes_list = np.loadtxt(self.inputs.in_spikes, dtype=int).tolist()\n # No spikes\n if not spikes_list:\n with open(out_file, \"w\") as f:\n f.write(\"<p>No high-frequency spikes were found in this dataset</p>\")\n return runtime\n\n spikes_list = [tuple(i) for i in np.atleast_2d(spikes_list).tolist()]\n plot_spikes(\n self.inputs.in_file, self.inputs.in_fft, spikes_list, out_file=out_file\n )\n return runtime\n",
"# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-\n# vi: set ft=python sts=4 ts=4 sw=4 et:\n\"\"\"Helper functions \"\"\"\n\nfrom pathlib import Path\nfrom collections import OrderedDict\nimport json\nimport pandas as pd\n\ntry:\n from collections.abc import MutableMapping\nexcept ImportError:\n from collections import MutableMapping\n\nIMTYPES = {\n \"T1w\": \"anat\",\n \"T2w\": \"anat\",\n \"bold\": \"func\",\n}\n\nBIDS_COMP = OrderedDict(\n [\n (\"subject_id\", \"sub\"),\n (\"session_id\", \"ses\"),\n (\"task_id\", \"task\"),\n (\"acq_id\", \"acq\"),\n (\"rec_id\", \"rec\"),\n (\"run_id\", \"run\"),\n ]\n)\n\nBIDS_EXPR = \"\"\"\\\n^sub-(?P<subject_id>[a-zA-Z0-9]+)(_ses-(?P<session_id>[a-zA-Z0-9]+))?\\\n(_task-(?P<task_id>[a-zA-Z0-9]+))?(_acq-(?P<acq_id>[a-zA-Z0-9]+))?\\\n(_rec-(?P<rec_id>[a-zA-Z0-9]+))?(_run-(?P<run_id>[a-zA-Z0-9]+))?\\\n\"\"\"\n\n\ndef reorder_csv(csv_file, out_file=None):\n \"\"\"\n Put subject, session and scan in front of csv file\n\n :param str csv_file: the input csv file\n :param str out_file: if provided, a new csv file is created\n\n :return: the path to the file with the columns reordered\n\n\n \"\"\"\n if isinstance(csv_file, list):\n csv_file = csv_file[-1]\n\n if out_file is None:\n out_file = csv_file\n\n dataframe = pd.read_csv(csv_file)\n cols = dataframe.columns.tolist() # pylint: disable=no-member\n try:\n cols.remove(\"Unnamed: 0\")\n except ValueError:\n # The column does not exist\n pass\n\n for col in [\"scan\", \"session\", \"subject\"]:\n cols.remove(col)\n cols.insert(0, col)\n\n dataframe[cols].to_csv(out_file)\n return out_file\n\n\ndef rotate_files(fname):\n \"\"\"A function to rotate file names\"\"\"\n import glob\n import os\n import os.path as op\n\n name, ext = op.splitext(fname)\n if ext == \".gz\":\n name, ext2 = op.splitext(fname)\n ext = ext2 + ext\n\n if not op.isfile(fname):\n return\n\n prev = glob.glob(\"{}.*{}\".format(name, ext))\n prev.insert(0, fname)\n prev.append(\"{0}.{1:d}{2}\".format(name, len(prev) - 1, ext))\n for i in reversed(list(range(1, len(prev)))):\n os.rename(prev[i - 1], prev[i])\n\n\ndef bids_path(subid, sesid=None, runid=None, prefix=None, out_path=None, ext=\"json\"):\n import os.path as op\n\n fname = \"{}\".format(subid)\n if prefix is not None:\n if not prefix.endswith(\"_\"):\n prefix += \"_\"\n fname = prefix + fname\n if sesid is not None:\n fname += \"_ses-{}\".format(sesid)\n if runid is not None:\n fname += \"_run-{}\".format(runid)\n\n if out_path is not None:\n fname = op.join(out_path, fname)\n return op.abspath(fname + \".\" + ext)\n\n\ndef generate_pred(derivatives_dir, output_dir, mod):\n \"\"\"\n Reads the metadata in the JIQM (json iqm) files and\n generates a corresponding prediction CSV table\n \"\"\"\n\n if mod != \"T1w\":\n return None\n\n # If some were found, generate the CSV file and group report\n jsonfiles = list(output_dir.glob(\"sub-*/**/%s/sub-*_%s.json\" % (IMTYPES[mod], mod)))\n if not jsonfiles:\n return None\n\n headers = list(BIDS_COMP.keys()) + [\"mriqc_pred\"]\n predictions = {k: [] for k in headers}\n\n for jsonfile in jsonfiles:\n with open(jsonfile, \"r\") as jsondata:\n data = json.load(jsondata).pop(\"bids_meta\", None)\n\n if data is None:\n continue\n\n for k in headers:\n predictions[k].append(data.pop(k, None))\n\n dataframe = pd.DataFrame(predictions).sort_values(by=list(BIDS_COMP.keys()))\n\n # Drop empty columns\n dataframe.dropna(axis=\"columns\", how=\"all\", inplace=True)\n\n bdits_cols = list(set(BIDS_COMP.keys()) & set(dataframe.columns.ravel()))\n\n # Drop duplicates\n dataframe.drop_duplicates(bdits_cols, keep=\"last\", inplace=True)\n\n out_csv = Path(output_dir) / (\"%s_predicted_qa_csv\" % mod)\n dataframe[bdits_cols + [\"mriqc_pred\"]].to_csv(str(out_csv), index=False)\n return out_csv\n\n\ndef generate_tsv(output_dir, mod):\n \"\"\"\n Generates a tsv file from all json files in the derivatives directory\n \"\"\"\n\n # If some were found, generate the CSV file and group report\n out_tsv = output_dir / (\"group_%s.tsv\" % mod)\n jsonfiles = list(output_dir.glob(\"sub-*/**/%s/sub-*_%s.json\" % (IMTYPES[mod], mod)))\n if not jsonfiles:\n return None, out_tsv\n\n datalist = []\n for jsonfile in jsonfiles:\n dfentry = _read_and_save(jsonfile)\n\n if dfentry is not None:\n bids_name = str(Path(jsonfile.name).stem)\n dfentry.pop(\"bids_meta\", None)\n dfentry.pop(\"provenance\", None)\n dfentry[\"bids_name\"] = bids_name\n datalist.append(dfentry)\n\n dataframe = pd.DataFrame(datalist)\n cols = dataframe.columns.tolist() # pylint: disable=no-member\n dataframe = dataframe.sort_values(by=[\"bids_name\"])\n\n # Drop duplicates\n dataframe.drop_duplicates([\"bids_name\"], keep=\"last\", inplace=True)\n\n # Set filename at front\n cols.insert(0, cols.pop(cols.index(\"bids_name\")))\n dataframe[cols].to_csv(str(out_tsv), index=False, sep=\"\\t\")\n return dataframe, out_tsv\n\n\ndef _read_and_save(in_file):\n data = json.loads(Path(in_file).read_text())\n return data if data else None\n\n\ndef _flatten(in_dict, parent_key=\"\", sep=\"_\"):\n items = []\n for k, val in list(in_dict.items()):\n new_key = parent_key + sep + k if parent_key else k\n if isinstance(val, MutableMapping):\n items.extend(list(_flatten(val, new_key, sep=sep).items()))\n else:\n items.append((new_key, val))\n return dict(items)\n\n\ndef _flatten_dict(indict):\n out_qc = {}\n for k, value in list(indict.items()):\n if not isinstance(value, dict):\n out_qc[k] = value\n else:\n for subk, subval in list(value.items()):\n if not isinstance(subval, dict):\n out_qc[\"_\".join([k, subk])] = subval\n else:\n for ssubk, ssubval in list(subval.items()):\n out_qc[\"_\".join([k, subk, ssubk])] = ssubval\n return out_qc\n"
] | [
[
"numpy.atleast_2d",
"numpy.loadtxt"
],
[
"pandas.read_csv",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
jjudy60334/my-nlp-wrangler | [
"cd0e941ab224a5614550060e15255a786923fdd8"
] | [
"tests/test_cleaner.py"
] | [
"import unittest\nfrom unittest import TestCase\n\nimport pandas as pd\nfrom mynlpwrangler.cleaner import ArticleCleaner\nimport pandas.testing as pd_testing\n\n\nclass TestCleaner(TestCase):\n def setUp(self) -> None:\n self.data = {\"id\": [\"10001\", \"11375\", \"23423\"], \"text\": [\n \"Hello, https://www.google.com/\", \"Hello,world\", 'How do you do? http://www.google.com']}\n self._df = pd.DataFrame(self.data)\n self._ac = ArticleCleaner(col=\"text\", cleaned_col=\"clean_text\")\n self._clean_dict = {\n \"id\": [\"10001\", \"11375\", \"23423\"],\n \"text\": [\"Hello, https://www.google.com/\", \"Hello,world\", 'How do you do? http://www.google.com'],\n \"clean_text\": [\"Hello \", \"Hello world\", \"How do you do \"]}\n self._clean_df = pd.DataFrame(self._clean_dict)\n\n def test_remove_url(self):\n text = self._ac.remove_url(\"Hello, https://www.google.com/\")\n self.assertFalse(text)\n\n def test_remove_punctuation(self):\n rm_punt = self._ac.remove_punctuation(\"Hello,world\")\n self.assertEqual(rm_punt, \"Hello world\")\n\n def test_set_clean_data(self):\n def clean_data_fun(df, col, new_col):\n df[new_col] = df[col].str.replace(\" \", \"\")\n return df\n self._ac.set_clean_data(clean_data_fun)\n cleaned_data = self._ac.clean_data(self._df)\n self.assertEqual(\n cleaned_data['clean_text'].tolist(),\n [\"Hello,https://www.google.com/\", \"Hello,world\", \"Howdoyoudo?http://www.google.com\"])\n\n def test_clean_data(self):\n cleaned_data = self._ac.clean_data(self._df)\n self.assertIsInstance(cleaned_data, pd.DataFrame)\n pd_testing.assert_frame_equal(cleaned_data, self._clean_df)\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
] | [
[
"pandas.testing.assert_frame_equal",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
xi2pi/gamlss | [
"497af26671316679c1648185ec49c009dffb0e9d"
] | [
"1D/gamlss_distributions.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Fri Feb 9 08:20:58 2018\n\n@author: Christian Winkler\n\"\"\"\nimport matplotlib.pyplot as plt\nfrom scipy import asarray as ar,exp\nfrom scipy.special import erf, gamma\nimport numpy as np\n\ndef NO(x,M,S):\n return 1/(np.sqrt(2*np.pi)*S)*exp(-(x-M)**2/(2*S**2))\n\ndef BCCG(x,M,S,L):\n # Funktioniert noch nicht???\n # Musst noch überprüft werden!\n #Phi = 0.5*(1 + erf(((1/(S*np.abs(L)))-M)/(S*np.sqrt(2))))\n Phi = 0.5*(1 + erf((1/(S*np.abs(L)))/(np.sqrt(2))))\n \n if L == 0:\n z = (1/S)*np.log(x/M)\n else:\n z = (1/(S*L))*(((x/M)**L)-1)\n \n f = (x**(L-1)*np.exp(-0.5*z**2))/((M**L)*S*Phi*np.sqrt(2*np.pi))\n return f\n \ndef BCPE(x,M,S,L,T):\n c = np.sqrt(2**(-2/T)*gamma(1/T)/gamma(3/T))\n \n if L == 0:\n z = (1/S)*np.log(x/M)\n else:\n z = (1/(S*L))*(((x/M)**L)-1)\n \n f_z = T/(c*2**(1+1/T)*gamma(1/T))*exp(-0.5*np.abs(z/c)**T)\n f_y = (x**(L-1))/(M**L*S)*f_z\n return f_y\n\nx = np.arange(0,20,0.1)\n\n#plt.plot(x,NO(x,10,5),'b',label='Gaussian')\n#plt.plot(x[1:],BCCG(x[1:],10,5,3),'r',label='BCCG')\n\n#Smooth centile curves for skew and kurtotic data modelled using the Box-Cox power exponential distribution\n#Rigby, Robert A., Stasinopoulos, D. Mikis\n\nfor i in [3, 2.5, 2, 1.5]:\n plt.plot(x[1:],BCPE(x[1:],10,0.1,3,i),'b',label='BCPE; T = ' + str(i) )\nplt.legend()\nplt.title('Distributions')\nplt.show()\n\nfor i in [3, 2.5, 2, 1.5]:\n plt.plot(x[1:],BCPE(x[1:],10,0.1,-1,i),'b',label='BCPE; T = ' + str(i) )\n \nplt.legend()\nplt.title('Distributions')\nplt.show()\n\n\n# Modelling skewness and kurtosis with the BCPE density in GAMLSS\n\nfor i in [0.1, 0.4]:\n plt.plot(x[1:],BCPE(x[1:],5, i, 1, 1.2),'b',label='BCPE; M = ' + str(i) )\n \nplt.legend()\nplt.title('Distributions')\nplt.show()\n \n#####BCCG\n#plt.plot(x[1:],BCCG(x[1:],5,0.5,-1),'b',label='BCCG; L = ' + str(-1) )\n# \n#plt.legend()\n#plt.title('Distributions')\n#plt.show()\n\n\n\n\n'''\nfunction (mu.link = \"identity\", sigma.link = \"log\", nu.link = \"identity\") \n{\n mstats <- checklink(\"mu.link\", \"BC Cole Green\", substitute(mu.link), \n c(\"inverse\", \"log\", \"identity\", \"own\"))\n dstats <- checklink(\"sigma.link\", \"BC Cole Green\", substitute(sigma.link), \n c(\"inverse\", \"log\", \"identity\", \"own\"))\n vstats <- checklink(\"nu.link\", \"BC Cole Green\", substitute(nu.link), \n c(\"inverse\", \"log\", \"identity\", \"own\"))\n \n structure(list(family = c(\"BCCG\", \"Box-Cox-Cole-Green\"), \n parameters = list(mu = TRUE, sigma = TRUE, nu = TRUE), \n nopar = 3, type = \"Continuous\", mu.link = as.character(substitute(mu.link)), \n sigma.link = as.character(substitute(sigma.link)), nu.link = as.character(substitute(nu.link)), \n mu.linkfun = mstats$linkfun, sigma.linkfun = dstats$linkfun, \n nu.linkfun = vstats$linkfun, mu.linkinv = mstats$linkinv, \n sigma.linkinv = dstats$linkinv, nu.linkinv = vstats$linkinv, \n mu.dr = mstats$mu.eta, sigma.dr = dstats$mu.eta, nu.dr = vstats$mu.eta, \n \n dldm = function(y, mu, sigma, nu) {\n z <- ifelse(nu != 0, (((y/mu)^nu - 1)/(nu * sigma)), \n log(y/mu)/sigma)\n dldm <- ((z/sigma) + nu * (z * z - 1))/mu\n dldm\n \n }, d2ldm2 = function(y, mu, sigma, nu) {\n d2ldm2 <- -(1 + 2 * nu * nu * sigma * sigma)\n d2ldm2 <- d2ldm2/(mu * mu * sigma * sigma)\n d2ldm2\n \n }, dldd = function(y, mu, sigma, nu) {\n z <- ifelse(nu != 0, (((y/mu)^nu - 1)/(nu * sigma)), \n log(y/mu)/sigma)\n h <- dnorm(1/(sigma * abs(nu)))/pnorm(1/(sigma * \n abs(nu)))\n dldd <- (z^2 - 1)/sigma + h/(sigma^2 * abs(nu))\n dldd\n \n }, d2ldd2 = function(sigma) {\n d2ldd2 <- -2/(sigma^2)\n d2ldd2\n \n }, dldv = function(y, mu, sigma, nu) {\n z <- ifelse(nu != 0, (((y/mu)^nu - 1)/(nu * sigma)), \n log(y/mu)/sigma)\n h <- dnorm(1/(sigma * abs(nu)))/pnorm(1/(sigma * \n abs(nu)))\n l <- log(y/mu)\n dldv <- (z - (l/sigma)) * (z/nu) - l * (z * z - \n 1)\n dldv <- dldv + sign(nu) * h/(sigma * nu^2)\n dldv\n \n }, d2ldv2 = function(sigma) {\n d2ldv2 <- -7 * sigma * sigma/4\n d2ldv2\n \n }, \n d2ldmdd = function(mu, sigma, nu) -2 * nu/(mu * sigma), \n d2ldmdv = function(mu) 1/(2 * mu), \n d2ldddv = function(sigma, nu) -sigma * nu, \n G.dev.incr = function(y, mu, sigma, nu, ...) -2 * dBCCG(y, mu = mu, sigma = sigma, nu = nu, \n log = TRUE), \n rqres = expression(rqres(pfun = \"pBCCG\", \n type = \"Continuous\", y = y, mu = mu, sigma = sigma, \n nu = nu)), mu.initial = expression(mu <- (y + mean(y))/2),\n \n sigma.initial = expression(sigma <- rep(0.1, length(y))), \n nu.initial = expression(nu <- rep(0.5, length(y))), \n mu.valid = function(mu) TRUE, sigma.valid = function(sigma) all(sigma > \n 0), nu.valid = function(nu) TRUE, y.valid = function(y) all(y > \n 0)), class = c(\"gamlss.family\", \"family\"))\n}\n'''"
] | [
[
"matplotlib.pyplot.legend",
"numpy.log",
"scipy.special.gamma",
"numpy.sqrt",
"matplotlib.pyplot.title",
"numpy.abs",
"numpy.arange",
"numpy.exp",
"matplotlib.pyplot.show",
"scipy.exp"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
bjlfzs/Fundus-vessel-segmentation | [
"26ffabb7bd9b215ca6d3b03bd0aae1c0141b56e7"
] | [
"test.py"
] | [
"import joblib,copy\nimport torch.backends.cudnn as cudnn\nfrom torch.utils.data import DataLoader\nimport torch,sys\nfrom tqdm import tqdm\n\nfrom collections import OrderedDict\nfrom lib.visualize import save_img,group_images,concat_result\nimport os\nimport argparse\nfrom lib.logger import Logger, Print_Logger\nfrom lib.extract_patches import *\nfrom os.path import join\nfrom lib.dataset import TestDataset\nfrom lib.metrics import Evaluate\nimport models\nfrom lib.common import setpu_seed,dict_round\nfrom config import parse_args\nfrom lib.pre_processing import my_PreProc\n\nsetpu_seed(2021)\n\nclass Test():\n def __init__(self, args):\n self.args = args\n assert (args.stride_height <= args.test_patch_height and args.stride_width <= args.test_patch_width)\n # save path\n self.path_experiment = join(args.outf, args.save)\n\n self.patches_imgs_test, self.test_imgs, self.test_masks, self.test_FOVs, self.new_height, self.new_width = get_data_test_overlap(\n test_data_path_list=args.test_data_path_list,\n patch_height=args.test_patch_height,\n patch_width=args.test_patch_width,\n stride_height=args.stride_height,\n stride_width=args.stride_width\n )\n self.img_height = self.test_imgs.shape[2]\n self.img_width = self.test_imgs.shape[3]\n\n test_set = TestDataset(self.patches_imgs_test)\n self.test_loader = DataLoader(test_set, batch_size=args.batch_size, shuffle=False, num_workers=3)\n\n # Inference prediction process\n def inference(self, net):\n net.eval()\n preds = []\n with torch.no_grad():\n for batch_idx, inputs in tqdm(enumerate(self.test_loader), total=len(self.test_loader)):\n inputs = inputs.cuda()\n outputs = net(inputs)\n outputs = outputs[:,1].data.cpu().numpy()\n preds.append(outputs)\n predictions = np.concatenate(preds, axis=0)\n self.pred_patches = np.expand_dims(predictions,axis=1)\n \n # Evaluate ate and visualize the predicted images\n def evaluate(self):\n self.pred_imgs = recompone_overlap(\n self.pred_patches, self.new_height, self.new_width, self.args.stride_height, self.args.stride_width)\n ## restore to original dimensions\n self.pred_imgs = self.pred_imgs[:, :, 0:self.img_height, 0:self.img_width]\n\n #predictions only inside the FOV\n y_scores, y_true = pred_only_in_FOV(self.pred_imgs, self.test_masks, self.test_FOVs)\n eval = Evaluate(save_path=self.path_experiment)\n eval.add_batch(y_true, y_scores)\n log = eval.save_all_result(plot_curve=True,save_name=\"performance.txt\")\n # save labels and probs for plot ROC and PR curve when k-fold Cross-validation\n np.save('{}/result.npy'.format(self.path_experiment), np.asarray([y_true, y_scores]))\n return dict_round(log, 6)\n\n # save segmentation imgs\n def save_segmentation_result(self):\n img_path_list, _, _ = load_file_path_txt(self.args.test_data_path_list)\n img_name_list = [item.split('/')[-1].split('.')[0] for item in img_path_list]\n\n kill_border(self.pred_imgs, self.test_FOVs) # only for visualization\n self.save_img_path = join(self.path_experiment,'result_img')\n if not os.path.exists(join(self.save_img_path)):\n os.makedirs(self.save_img_path)\n # self.test_imgs = my_PreProc(self.test_imgs) # Uncomment to save the pre processed image\n for i in range(self.test_imgs.shape[0]):\n total_img = concat_result(self.test_imgs[i],self.pred_imgs[i],self.test_masks[i])\n save_img(total_img,join(self.save_img_path, \"Result_\"+img_name_list[i]+'.png'))\n\n # Val on the test set at each epoch\n def val(self):\n self.pred_imgs = recompone_overlap(\n self.pred_patches, self.new_height, self.new_width, self.args.stride_height, self.args.stride_width)\n ## recover to original dimensions\n self.pred_imgs = self.pred_imgs[:, :, 0:self.img_height, 0:self.img_width]\n\n #predictions only inside the FOV\n y_scores, y_true = pred_only_in_FOV(self.pred_imgs, self.test_masks, self.test_FOVs)\n eval = Evaluate(save_path=self.path_experiment)\n eval.add_batch(y_true, y_scores)\n confusion,accuracy,specificity,sensitivity,precision = eval.confusion_matrix()\n log = OrderedDict([('val_auc_roc', eval.auc_roc()),\n ('val_f1', eval.f1_score()),\n ('val_acc', accuracy),\n ('SE', sensitivity),\n ('SP', specificity)])\n return dict_round(log, 6)\n\nif __name__ == '__main__':\n args = parse_args()\n save_path = join(args.outf, args.save)\n sys.stdout = Print_Logger(os.path.join(save_path, 'test_log.txt'))\n device = torch.device(\"cuda\" if torch.cuda.is_available() and args.cuda else \"cpu\")\n\n\n # net = models.UNetFamily.Dense_Unet(1,2).to(device)\n net = models.LadderNet(inplanes=1, num_classes=2, layers=3, filters=16).to(device)\n cudnn.benchmark = True\n\n # Load checkpoint\n print('==> Loading checkpoint...')\n checkpoint = torch.load(join(save_path, 'best_model.pth'))\n net.load_state_dict(checkpoint['net'])\n\n eval = Test(args)\n eval.inference(net)\n print(eval.evaluate())\n eval.save_segmentation_result()\n"
] | [
[
"torch.no_grad",
"torch.utils.data.DataLoader",
"torch.cuda.is_available"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Wingham1/hessidf | [
"18e63e25f9989565f1f361458f7ff8e53f4579e9"
] | [
"flare_classifier/intersect_hessi_goes.py"
] | [
"\"\"\"\nThis script uses data from the hessi mission to find the location (x, y, in arcsec) of flares and their dates,\nand the goes mission to find the class of flares and their dates, then it makes a new dataset with the date, class and location of each flare,\nthe dataset is exported to a csv file so it can be read into a pandas dataframe for future projects.\n\n\"\"\"\n\nimport hessi_df as hdf\nimport goes_df as gdf\nimport datetime as dt\nimport pandas as pd\n\ndef intersect_hessi_goes(to_csv=False):\n \"\"\"\n Groups the datetime, location and class of each solar flare in one dataframe (GOES mass missing location data and isn't as accurate)\n \n Param:\n to_csv boolean, if True -> export the datframe to csv\n \n Return:\n data pandas dataframe, this contains the matched flares with their date, location and class\n \"\"\"\n \n # HESSI mission has good locations for flares with their dates\n print('Getting HESSI flare data')\n hessi = hdf.hessi_flare_dataframe(web=False)\n \n # filtering\n print('Filtering')\n bad_flags = ['NS','SD'] # NS non solar event, SD spacecraft in South Atlantic Anomaly where magnetic data is weird https://image.gsfc.nasa.gov/poetry/ask/q525.html\n hessi = hdf.filter(hessi, bad_flags)\n print(hessi.head())\n \n # GOES mission is used to classify flares with their dates\n print('Getting GOES flare data')\n goes = gdf.goes_dataframe()\n print(goes.head())\n \n # Combine, for each flare in GOES find the flare in HESSI for the accurate location\n print('Using dates to match flares in each dataset and create a new dataframe')\n data = {'Peak_time': [], 'X_pos': [], 'Y_pos': [], 'Class': []}\n for idx, row in goes.iterrows(): \n match = hessi[hessi['Peak_time'].between(row['Start_time'], row['End_time'])]\n # currently only find flares where there was one match (multiple flares happening together are ignored)\n if len(match.index) == 1:\n hessi_idx = match.index\n data['Peak_time'].append(match['Peak_time'].to_numpy()[0]) # use to_numpy!!\n data['X_pos'].append(match['X Pos (asec)'].to_numpy()[0])\n data['Y_pos'].append(match['Y Pos (asec)'].to_numpy()[0])\n data['Class'].append(row['Class'])\n data = pd.DataFrame.from_dict(data)\n print('total flares = {}, num B class = {}, num C class = {}'.format(len(data.index), len(data[data['Class'] == 'B'].index), len(data[data['Class'] == 'C'].index)))\n print(data.head())\n if to_csv:\n data.to_csv('hessi_goes_flare_data.csv', index=False)\n \n return data\n\nif __name__ == '__main__':\n together = intersect_hessi_goes(to_csv=True)\n "
] | [
[
"pandas.DataFrame.from_dict"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
mabounassif/t3f | [
"28acf14812481f6a47ea6dbedeb55048e2e6203b",
"28acf14812481f6a47ea6dbedeb55048e2e6203b",
"28acf14812481f6a47ea6dbedeb55048e2e6203b"
] | [
"t3f/initializers.py",
"t3f/tensor_train.py",
"t3f/batch_ops_test.py"
] | [
"import numpy as np\nimport tensorflow as tf\n\nfrom t3f.tensor_train import TensorTrain\nfrom t3f.tensor_train_batch import TensorTrainBatch\nfrom t3f.tensor_train_base import TensorTrainBase\nfrom t3f import shapes\n\n\ndef _validate_input_parameters(is_tensor, shape, **params):\n \"\"\"Internal function for validating input parameters\n\n Args:\n is_tensor: bool, determines whether we attempt to construct a TT-tensor or\n a TT-matrix (needed for the correct shape checks).\n shape: array, the desired shape of the generated TT object\n params: optional, possible values:\n batch_size: int, for constructing batches\n tt_rank: array or int, desired TT-ranks\n \"\"\"\n\n if is_tensor:\n if len(shape.shape) != 1:\n raise ValueError('shape should be 1d array, got %a' % shape)\n if np.any(shape < 1):\n raise ValueError('all elements in `shape` should be positive, got %a' %\n shape)\n if not all(isinstance(sh, np.integer) for sh in shape):\n raise ValueError('all elements in `shape` should be integers, got %a' %\n shape)\n else:\n if len(shape.shape) != 2:\n raise ValueError('shape should be 2d array, got %a' % shape)\n if shape[0].size != shape[1].size:\n raise ValueError('shape[0] should have the same length as shape[1], but'\n 'got %d and %d' % (shape[0].size, shape[1].size))\n if np.any(shape.flatten() < 1):\n raise ValueError('all elements in `shape` should be positive, got %a' %\n shape)\n if not all(isinstance(sh, np.integer) for sh in shape.flatten()):\n raise ValueError('all elements in `shape` should be integers, got %a' %\n shape)\n\n if 'batch_size' in params:\n batch_size = params['batch_size']\n if not isinstance(batch_size, (int, np.integer)):\n raise ValueError('`batch_size` should be integer, got %f' % batch_size)\n if batch_size < 1:\n raise ValueError('Batch size should be positive, got %d' % batch_size)\n if 'tt_rank' in params:\n tt_rank = params['tt_rank']\n if tt_rank.size == 1:\n if not isinstance(tt_rank[()], np.integer):\n raise ValueError('`tt_rank` should be integer, got %f' % tt_rank[()])\n if tt_rank.size > 1:\n if not all(isinstance(tt_r, np.integer) for tt_r in tt_rank):\n raise ValueError('all elements in `tt_rank` should be integers, got'\n ' %a' % tt_rank)\n if np.any(tt_rank < 1):\n raise ValueError('`tt_rank` should be positive, got %a' % tt_rank)\n\n if is_tensor:\n if tt_rank.size != 1 and tt_rank.size != (shape.size + 1):\n raise ValueError('`tt_rank` array has inappropriate size, expected'\n '1 or %d, got %d' % (shape.size + 1, tt_rank.size))\n else:\n if tt_rank.size != 1 and tt_rank.size != (shape[0].size + 1):\n raise ValueError('`tt_rank` array has inappropriate size, expected'\n '1 or %d, got %d' % (shape[0].size + 1, tt_rank.size))\n\n\ndef tensor_ones(shape, dtype=tf.float32, name='t3f_tensor_ones'):\n \"\"\"Generate TT-tensor of the given shape with all entries equal to 1.\n\n Args:\n shape: array representing the shape of the future tensor\n dtype: [tf.float32] dtype of the resulting tensor.\n name: string, name of the Op.\n\n Returns:\n TensorTrain object containing a TT-tensor\n \"\"\"\n\n shape = np.array(shape)\n _validate_input_parameters(is_tensor=True, shape=shape)\n num_dims = shape.size\n tt_rank = np.ones(num_dims + 1)\n\n with tf.name_scope(name):\n tt_cores = num_dims * [None]\n for i in range(num_dims):\n curr_core_shape = (1, shape[i], 1)\n tt_cores[i] = tf.ones(curr_core_shape, dtype=dtype)\n\n return TensorTrain(tt_cores, shape, tt_rank)\n\n\ndef tensor_zeros(shape, dtype=tf.float32, name='t3f_tensor_zeros'):\n \"\"\"Generate TT-tensor of the given shape with all entries equal to 0.\n\n Args:\n shape: array representing the shape of the future tensor\n dtype: [tf.float32] dtype of the resulting tensor.\n name: string, name of the Op.\n\n Returns:\n TensorTrain object containing a TT-tensor\n \"\"\"\n\n shape = np.array(shape)\n _validate_input_parameters(is_tensor=True, shape=shape)\n num_dims = shape.size\n tt_rank = np.ones(num_dims + 1)\n tt_cores = num_dims * [None]\n with tf.name_scope(name):\n for i in range(num_dims):\n curr_core_shape = (1, shape[i], 1)\n tt_cores[i] = tf.zeros(curr_core_shape, dtype=dtype)\n\n return TensorTrain(tt_cores, shape, tt_rank)\n\n\ndef eye(shape, dtype=tf.float32, name='t3f_eye'):\n \"\"\"Creates an identity TT-matrix.\n\n Args:\n shape: array which defines the shape of the matrix row and column\n indices.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing an identity TT-matrix of size\n np.prod(shape) x np.prod(shape)\n \"\"\"\n shape = np.array(shape)\n # In this special case shape is in the same format as in the TT-tensor case\n _validate_input_parameters(is_tensor=True, shape=shape)\n\n num_dims = shape.size\n tt_ranks = np.ones(num_dims + 1)\n\n with tf.name_scope(name):\n tt_cores = num_dims * [None]\n for i in range(num_dims):\n curr_core_shape = (1, shape[i], shape[i], 1)\n tt_cores[i] = tf.reshape(tf.eye(shape[i], dtype=dtype), curr_core_shape)\n\n true_shape = np.vstack([shape, shape])\n return TensorTrain(tt_cores, true_shape, tt_ranks)\n\n\ndef matrix_ones(shape, dtype=tf.float32, name='t3f_matrix_ones'):\n \"\"\"Generate a TT-matrix of the given shape with each entry equal to 1.\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n matrix_ones([[2, 2, 2], None])\n and\n matrix_ones([None, [2, 2, 2]])\n will create an 8-element column and row vectors correspondingly.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-matrix of size\n np.prod(shape[0]) x np.prod(shape[1]) with each entry equal to 1\n \"\"\"\n\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n\n _validate_input_parameters(is_tensor=False, shape=shape)\n\n num_dims = shape[0].size\n tt_rank = np.ones(shape[0].size + 1)\n\n with tf.name_scope(name):\n tt_cores = [None] * num_dims\n for i in range(num_dims):\n curr_core_shape = (1, shape[0][i], shape[1][i], 1)\n tt_cores[i] = tf.ones(curr_core_shape, dtype=dtype)\n\n return TensorTrain(tt_cores, shape, tt_rank)\n\n\ndef matrix_zeros(shape, dtype=tf.float32, name='t3f_matrix_zeros'):\n \"\"\"Generate a TT-matrix of the given shape with each entry equal to 0.\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n matrix_zeros([[2, 2, 2], None])\n and\n matrix_zeros([None, [2, 2, 2]])\n will create an 8-element column and row vectors correspondingly.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-matrix of size\n np.prod(shape[0]) x np.prod(shape[1]) with each entry equal to 0\n \"\"\"\n\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n\n _validate_input_parameters(is_tensor=False, shape=shape)\n num_dims = shape[0].size\n tt_rank = np.ones(shape[0].size + 1)\n\n with tf.name_scope(name):\n tt_cores = [None] * num_dims\n for i in range(num_dims):\n curr_core_shape = (1, shape[0][i], shape[1][i], 1)\n tt_cores[i] = tf.zeros(curr_core_shape, dtype=dtype)\n\n return TensorTrain(tt_cores, shape, tt_rank)\n\n\ndef tensor_with_random_cores(shape, tt_rank=2, mean=0., stddev=1.,\n dtype=tf.float32,\n name='t3f_tensor_with_random_cores'):\n \"\"\"Generate a TT-tensor of the given shape with N(mean, stddev^2) cores.\n\n Args:\n shape: array representing the shape of the future tensor.\n tt_rank: a number or a (d+1)-element array with the desired ranks.\n mean: a number, the mean of the normal distribution used for\n initializing TT-cores.\n stddev: a number, the standard deviation of the normal distribution used\n for initializing TT-cores.\n dtype: [tf.float32] dtype of the resulting tensor.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-tensor\n \"\"\"\n # TODO: good distribution to init training.\n # TODO: support shape and tt_ranks as TensorShape?.\n # TODO: support None as a dimension.\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=True, shape=shape, tt_rank=tt_rank)\n num_dims = shape.size\n if tt_rank.size == 1:\n tt_rank = tt_rank * np.ones(num_dims - 1)\n tt_rank = np.insert(tt_rank, 0, 1)\n tt_rank = np.append(tt_rank, 1)\n\n tt_rank = tt_rank.astype(int)\n tt_cores = [None] * num_dims\n with tf.name_scope(name):\n for i in range(num_dims):\n curr_core_shape = (tt_rank[i], shape[i], tt_rank[i + 1])\n tt_cores[i] = tf.random_normal(curr_core_shape, mean=mean, stddev=stddev,\n dtype=dtype)\n\n return TensorTrain(tt_cores, shape, tt_rank)\n\n\ndef tensor_batch_with_random_cores(shape, tt_rank=2, batch_size=1,\n mean=0., stddev=1., dtype=tf.float32,\n name='t3f_tensor_batch_with_random_cores'):\n \"\"\"Generate a batch of TT-tensors of given shape with N(mean, stddev^2) cores.\n\n Args:\n shape: array representing the shape of the future tensor.\n tt_rank: a number or a (d+1)-element array with ranks.\n batch_size: an integer.\n mean: a number, the mean of the normal distribution used for\n initializing TT-cores.\n stddev: a number, the standard deviation of the normal distribution used\n for initializing TT-cores.\n dtype: [tf.float32] dtype of the resulting tensor.\n name: string, name of the Op.\n\n Returns:\n TensorTrainBatch containing TT-tensors\n \"\"\"\n\n # TODO: support shape and tt_ranks as TensorShape?.\n # TODO: support None as a dimension.\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=True, shape=shape, tt_rank=tt_rank,\n batch_size=batch_size)\n num_dims = shape.size\n if tt_rank.size == 1:\n tt_rank = tt_rank * np.ones(num_dims - 1)\n tt_rank = np.insert(tt_rank, 0, 1)\n tt_rank = np.append(tt_rank, 1)\n tt_rank = tt_rank.astype(int)\n tt_cores = [None] * num_dims\n with tf.name_scope(name):\n for i in range(num_dims):\n curr_core_shape = (batch_size, tt_rank[i], shape[i], tt_rank[i + 1])\n tt_cores[i] = tf.random_normal(curr_core_shape, mean=mean, stddev=stddev,\n dtype=dtype)\n\n return TensorTrainBatch(tt_cores, shape, tt_rank, batch_size)\n\n\ndef matrix_with_random_cores(shape, tt_rank=2, mean=0., stddev=1.,\n dtype=tf.float32,\n name='t3f_matrix_with_random_cores'):\n \"\"\"Generate a TT-matrix of given shape with N(mean, stddev^2) cores.\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n matrix_with_random_cores([[2, 2, 2], None])\n and\n matrix_with_random_cores([None, [2, 2, 2]])\n will create an 8-element column and row vectors correspondingly.\n tt_rank: a number or a (d+1)-element array with ranks.\n mean: a number, the mean of the normal distribution used for\n initializing TT-cores.\n stddev: a number, the standard deviation of the normal distribution used\n for initializing TT-cores.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-matrix of size\n np.prod(shape[0]) x np.prod(shape[1])\n \"\"\"\n # TODO: good distribution to init training.\n # In case the shape is immutable.\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=False, shape=shape, tt_rank=tt_rank)\n\n num_dims = shape[0].size\n if tt_rank.size == 1:\n tt_rank = tt_rank * np.ones(num_dims - 1)\n tt_rank = np.concatenate([[1], tt_rank, [1]])\n\n tt_rank = tt_rank.astype(int)\n tt_cores = [None] * num_dims\n with tf.name_scope(name):\n for i in range(num_dims):\n curr_core_shape = (tt_rank[i], shape[0][i], shape[1][i],\n tt_rank[i + 1])\n tt_cores[i] = tf.random_normal(curr_core_shape, mean=mean, stddev=stddev,\n dtype=dtype)\n\n return TensorTrain(tt_cores, shape, tt_rank)\n\n\ndef matrix_batch_with_random_cores(shape, tt_rank=2, batch_size=1,\n mean=0., stddev=1., dtype=tf.float32,\n name='t3f_matrix_batch_with_random_cores'):\n \"\"\"Generate a batch of TT-matrices of given shape with N(mean, stddev^2) cores.\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n matrix_batch_with_random_cores([[2, 2, 2], None])\n and\n matrix_batch_with_random_cores([None, [2, 2, 2]])\n will create a batch of one 8-element column and row vector correspondingly.\n\n tt_rank: a number or a (d+1)-element array with ranks.\n batch_size: an integer.\n mean: a number, the mean of the normal distribution used for\n initializing TT-cores.\n stddev: a number, the standard deviation of the normal distribution used\n for initializing TT-cores.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrainBatch containing a batch of TT-matrices of size\n np.prod(shape[0]) x np.prod(shape[1])\n \"\"\"\n # TODO: good distribution to init training.\n # In case the shape is immutable.\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=False, shape=shape, tt_rank=tt_rank,\n batch_size=batch_size)\n num_dims = shape[0].size\n if tt_rank.size == 1:\n tt_rank = tt_rank * np.ones(num_dims - 1)\n tt_rank = np.concatenate([[1], tt_rank, [1]])\n shape = shape.astype(int)\n tt_rank = tt_rank.astype(int)\n tt_cores = [None] * num_dims\n with tf.name_scope(name):\n for i in range(num_dims):\n curr_core_shape = (batch_size, tt_rank[i], shape[0][i], shape[1][i],\n tt_rank[i + 1])\n tt_cores[i] = tf.random_normal(curr_core_shape, mean=mean, stddev=stddev,\n dtype=dtype)\n\n return TensorTrainBatch(tt_cores, shape, tt_rank, batch_size)\n\n\ndef ones_like(tt, name='t3f_ones_like'):\n \"\"\"Constructs t3f.ones with the shape of `tt`.\n\n In the case when `tt` is TensorTrainBatch constructs t3f.ones with the shape\n of a TensorTrain in `tt`.\n\n Args:\n tt: TensorTrain object\n name: string, name of the Op.\n\n Returns:\n TensorTrain object of the same shape as `tt` but with all entries equal to\n 1.\n\n \"\"\"\n if not isinstance(tt, TensorTrainBase):\n raise ValueError(\"`tt` has to be a Tensor Train object\")\n else:\n shape = shapes.lazy_raw_shape(tt)\n # I guess variables=tt.tt_cores is not needed here since the output of\n # the function doesn't depend on the values of the TT-cores, only on their\n # shapes etc. But I'm not 100% sure.\n with tf.name_scope(name):\n if tt.is_tt_matrix():\n return matrix_ones(shape, dtype=tt.dtype)\n else:\n return tensor_ones(shape[0, :], dtype=tt.dtype)\n\n\ndef zeros_like(tt, name='t3f_zeros_like'):\n \"\"\"Constructs t3f.zeros with the shape of `tt`.\n\n In the case when `tt` is a TensorTrainBatch constructs t3f.zeros with\n the shape of a TensorTrain in `tt`.\n\n Args:\n tt: TensorTrain object\n name: string, name of the Op.\n\n Returns:\n TensorTrain object of the same shape as `tt` but with all entries equal to\n 0.\n\n \"\"\"\n if not isinstance(tt, TensorTrainBase):\n raise ValueError(\"`tt` has to be a Tensor Train object\")\n else:\n shape = shapes.lazy_raw_shape(tt)\n # I guess variables=tt.tt_cores is not needed here since the output of\n # the function doesn't depend on the values of the TT-cores, only on their\n # shapes etc. But I'm not 100% sure.\n with tf.name_scope(name):\n if tt.is_tt_matrix():\n return matrix_zeros(shape, dtype=tt.dtype)\n else:\n return tensor_zeros(shape[0, :], dtype=tt.dtype)\n\n\ndef random_tensor(shape, tt_rank=2, mean=0., stddev=1., dtype=tf.float32,\n name='t3f_random_tensor'):\n \"\"\"Generate a random TT-tensor of the given shape with given mean and stddev.\n\n Entries of the generated tensor (in the full format) will be iid and satisfy\n E[x_{i1i2..id}] = mean, Var[x_{i1i2..id}] = stddev^2, but the distribution is\n in fact not Gaussian (but is close for large tensors).\n\n In the current implementation only mean 0 is supported. To get\n a random_tensor with specified mean but tt_rank greater by 1 you can\n call\n x = t3f.random_tensor(shape, tt_rank, stddev=stddev)\n x = mean * t3f.ones_like(x) + x\n\n Args:\n shape: array representing the shape of the future tensor.\n tt_rank: a number or a (d+1)-element array with the desired ranks.\n mean: a number, the desired mean for the distribution of entries.\n stddev: a number, the desired standard deviation for the distribution of\n entries.\n dtype: [tf.float32] dtype of the resulting tensor.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-tensor\n \"\"\"\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=True, shape=shape, tt_rank=tt_rank)\n\n num_dims = shape.size\n if tt_rank.size == 1:\n tt_rank = tt_rank * np.ones(num_dims - 1)\n tt_rank = np.insert(tt_rank, 0, 1)\n tt_rank = np.append(tt_rank, 1)\n\n tt_rank = tt_rank.astype(int)\n\n # Empirically entries of a TT tensor with cores initialized from N(0, 1)\n # will have variances np.prod(tt_rank) and mean 0.\n # We scale each TT-core to obtain the desired stddev\n\n cr_exponent = -1.0 / (2 * num_dims)\n var = np.prod(tt_rank ** cr_exponent)\n core_stddev = stddev ** (1.0 / num_dims) * var\n with tf.name_scope(name):\n tt = tensor_with_random_cores(shape, tt_rank=tt_rank, stddev=core_stddev,\n dtype=dtype)\n\n if np.abs(mean) < 1e-8:\n return tt\n else:\n raise NotImplementedError('non-zero mean is not supported yet')\n\n\ndef random_tensor_batch(shape, tt_rank=2, batch_size=1, mean=0., stddev=1.,\n dtype=tf.float32, name='t3f_random_tensor_batch'):\n \"\"\"Generate a batch of TT-tensors with given shape, mean and stddev.\n\n Entries of the generated tensors (in the full format) will be iid and satisfy\n E[x_{i1i2..id}] = mean, Var[x_{i1i2..id}] = stddev^2, but the distribution is\n in fact not Gaussian (but is close for large tensors).\n\n In the current implementation only mean 0 is supported. To get\n a random_tensor_batch with specified mean but tt_rank greater by 1 you can\n call\n x = t3f.random_tensor_batch(shape, tt_rank, batch_size=bs, stddev=stddev)\n x = mean * t3f.ones_like(x) + x\n\n Args:\n shape: array representing the shape of the future tensor.\n tt_rank: a number or a (d+1)-element array with ranks.\n batch_size: an integer.\n mean: a number, the desired mean for the distribution of entries.\n stddev: a number, the desired standard deviation for the distribution of\n entries.\n dtype: [tf.float32] dtype of the resulting tensor.\n name: string, name of the Op.\n\n Returns:\n TensorTrainBatch containing TT-tensors.\n \"\"\"\n # TODO: support shape and tt_ranks as TensorShape?.\n # TODO: support None as a dimension.\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=True, shape=shape, tt_rank=tt_rank,\n batch_size=batch_size)\n num_dims = shape.size\n if tt_rank.size == 1:\n tt_rank = tt_rank * np.ones(num_dims - 1)\n tt_rank = np.insert(tt_rank, 0, 1)\n tt_rank = np.append(tt_rank, 1)\n tt_rank = tt_rank.astype(int)\n\n cr_exponent = -1.0 / (2 * num_dims)\n var = np.prod(tt_rank ** cr_exponent)\n cr_stddev = stddev ** (1.0 / num_dims) * var\n with tf.name_scope(name):\n tt = tensor_batch_with_random_cores(shape, tt_rank=tt_rank, stddev=cr_stddev,\n batch_size=batch_size, dtype=dtype)\n\n if np.abs(mean) < 1e-8:\n return tt\n else:\n raise NotImplementedError('non-zero mean is not supported yet')\n\n\ndef random_matrix(shape, tt_rank=2, mean=0., stddev=1.,\n dtype=tf.float32, name='t3f_random_matrix'):\n \"\"\"Generate a random TT-matrix of the given shape with given mean and stddev.\n\n Entries of the generated matrix (in the full format) will be iid and satisfy\n E[x_{i1i2..id}] = mean, Var[x_{i1i2..id}] = stddev^2, but the distribution is\n in fact not Gaussian.\n\n In the current implementation only mean 0 is supported. To get\n a random_matrix with specified mean but tt_rank greater by 1 you can call\n x = t3f.random_matrix(shape, tt_rank, stddev=stddev)\n x = mean * t3f.ones_like(x) + x\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n random_matrix([[2, 2, 2], None])\n and\n random_matrix([None, [2, 2, 2]])\n will create an 8-element column and row vectors correspondingly.\n tt_rank: a number or a (d+1)-element array with ranks.\n mean: a number, the desired mean for the distribution of entries.\n stddev: a number, the desired standard deviation for the distribution of\n entries.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-matrix of size\n np.prod(shape[0]) x np.prod(shape[1])\n \"\"\"\n # TODO: good distribution to init training.\n # In case the shape is immutable.\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n\n _validate_input_parameters(is_tensor=False, shape=shape, tt_rank=tt_rank)\n\n num_dims = shape[0].size\n if tt_rank.size == 1:\n tt_rank = tt_rank * np.ones(num_dims - 1)\n tt_rank = np.concatenate([[1], tt_rank, [1]])\n\n tt_rank = tt_rank.astype(int)\n var = np.prod(tt_rank)\n\n # Empirically entries of a TT tensor with cores initialized from N(0, 1)\n # will have variances np.prod(tt_rank) and mean 0.\n # We scale each TT-core to obtain the desired stddev\n\n cr_exponent = -1.0 / (2 * num_dims)\n var = np.prod(tt_rank ** cr_exponent)\n core_stddev = stddev ** (1.0 / num_dims) * var\n with tf.name_scope(name):\n tt = matrix_with_random_cores(shape, tt_rank=tt_rank, stddev=core_stddev,\n dtype=dtype)\n\n if np.abs(mean) < 1e-8:\n return tt\n else:\n raise NotImplementedError('non-zero mean is not supported yet')\n\n\ndef random_matrix_batch(shape, tt_rank=2, batch_size=1, mean=0., stddev=1.,\n dtype=tf.float32, name='t3f_random_matrix_batch'):\n \"\"\"Generate a batch of TT-matrices with given shape, mean and stddev.\n\n Entries of the generated matrices (in the full format) will be iid and\n satisfy E[x_{i1i2..id}] = mean, Var[x_{i1i2..id}] = stddev^2, but the\n distribution is in fact not Gaussian.\n\n In the current implementation only mean 0 is supported. To get a\n random_matrix_batch with specified mean but tt_rank greater by 1 you can call\n x = t3f.random_matrix_batch(shape, tt_rank, batch_size=bs, stddev=stddev)\n x = mean * t3f.ones_like(x) + x\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n random_matrix_batch([[2, 2, 2], None])\n and\n random_matrix_batch([None, [2, 2, 2]])\n will create a batch of one 8-element column and row vector correspondingly.\n tt_rank: a number or a (d+1)-element array with ranks.\n batch_size: an integer.\n mean: a number, the desired mean for the distribution of entries.\n stddev: a number, the desired standard deviation for the distribution of\n entries.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrainBatch containing a batch of TT-matrices of size\n np.prod(shape[0]) x np.prod(shape[1])\n \"\"\"\n # In case the shape is immutable.\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=False, shape=shape, tt_rank=tt_rank,\n batch_size=batch_size)\n num_dims = shape[0].size\n if tt_rank.size == 1:\n tt_rank = tt_rank * np.ones(num_dims - 1)\n tt_rank = np.concatenate([[1], tt_rank, [1]])\n\n shape = shape.astype(int)\n tt_rank = tt_rank.astype(int)\n\n cr_exponent = -1.0 / (2 * num_dims)\n var = np.prod(tt_rank ** cr_exponent)\n core_stddev = stddev ** (1.0 / num_dims) * var\n with tf.name_scope(name):\n tt = matrix_batch_with_random_cores(shape, tt_rank=tt_rank,\n stddev=core_stddev,\n batch_size=batch_size,\n dtype=dtype)\n\n if np.abs(mean) < 1e-8:\n return tt\n else:\n raise NotImplementedError('non-zero mean is not supported yet')\n\n\ndef glorot_initializer(shape, tt_rank=2, dtype=tf.float32,\n name='t3f_glorot_initializer'):\n \"\"\"Constructs a random TT matrix with entrywise variance 2.0 / (n_in + n_out)\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n glorot_initializer([[2, 2, 2], None])\n and\n glorot_initializer([None, [2, 2, 2]])\n will create an 8-element column and row vectors correspondingly.\n tt_rank: a number or a (d+1)-element array with ranks.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-matrix of size\n np.prod(shape[0]) x np.prod(shape[1])\n \"\"\"\n\n # In case the shape is immutable.\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=False, shape=shape, tt_rank=tt_rank)\n n_in = np.prod(shape[0])\n n_out = np.prod(shape[1])\n lamb = 2.0 / (n_in + n_out)\n\n with tf.name_scope(name):\n return random_matrix(shape, tt_rank=tt_rank, stddev=np.sqrt(lamb),\n dtype=dtype)\n\n\ndef he_initializer(shape, tt_rank=2, dtype=tf.float32,\n name='t3f_he_initializer'):\n \"\"\"Constructs a random TT matrix with entrywise variance 2.0 / n_in\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n he_initializer([[2, 2, 2], None])\n and\n he_initializer([None, [2, 2, 2]])\n will create an 8-element column and row vectors correspondingly.\n tt_rank: a number or a (d+1)-element array with ranks.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-matrix of size\n np.prod(shape[0]) x np.prod(shape[1])\n \"\"\"\n\n # In case the shape is immutable.\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=False, shape=shape, tt_rank=tt_rank)\n n_in = np.prod(shape[0])\n lamb = 2.0 / n_in\n\n with tf.name_scope(name):\n return random_matrix(shape, tt_rank=tt_rank, stddev=np.sqrt(lamb),\n dtype=dtype)\n\n\ndef lecun_initializer(shape, tt_rank=2, dtype=tf.float32,\n name='t3f_lecun_initializer'):\n \"\"\"Constructs a random TT matrix with entrywise variance 1.0 / n_in\n\n Args:\n shape: 2d array, shape[0] is the shape of the matrix row-index,\n shape[1] is the shape of the column index.\n shape[0] and shape[1] should have the same number of elements (d)\n Also supports omitting one of the dimensions for vectors, e.g.\n lecun_initializer([[2, 2, 2], None])\n and\n lecun_initializer([None, [2, 2, 2]])\n will create an 8-element column and row vectors correspondingly.\n tt_rank: a number or a (d+1)-element array with ranks.\n dtype: [tf.float32] dtype of the resulting matrix.\n name: string, name of the Op.\n\n Returns:\n TensorTrain containing a TT-matrix of size\n np.prod(shape[0]) x np.prod(shape[1])\n \"\"\"\n\n # In case the shape is immutable.\n shape = list(shape)\n # In case shape represents a vector, e.g. [None, [2, 2, 2]]\n if shape[0] is None:\n shape[0] = np.ones(len(shape[1]), dtype=int)\n # In case shape represents a vector, e.g. [[2, 2, 2], None]\n if shape[1] is None:\n shape[1] = np.ones(len(shape[0]), dtype=int)\n shape = np.array(shape)\n tt_rank = np.array(tt_rank)\n _validate_input_parameters(is_tensor=False, shape=shape, tt_rank=tt_rank)\n n_in = np.prod(shape[0])\n lamb = 1.0 / n_in\n with tf.name_scope(name):\n return random_matrix(shape, tt_rank=tt_rank, stddev=np.sqrt(lamb),\n dtype=dtype)\n",
"import tensorflow as tf\n\nfrom t3f.tensor_train_base import TensorTrainBase\nfrom t3f import shapes\n\n\nclass TensorTrain(TensorTrainBase):\n \"\"\"Represents a Tensor Train object (a TT-tensor or TT-matrix).\n\n t3f represents a Tensor Train object as a tuple of TT-cores.\n \"\"\"\n\n def __init__(self, tt_cores, shape=None, tt_ranks=None,\n convert_to_tensors=True, name=\"TensorTrain\"):\n \"\"\"Creates a `TensorTrain`.\n\n Args:\n tt_cores: A tuple of 3d or 4d tensor-like objects of shape\n `[r_k-1, n_k, r_k]`.\n Tensor-like can be numpy array, tf.Tensor, of tf.Variable\n shape: Shape of the underlying tensor. If None, tries to infer from the\n cores (not always possible even if it should be, e.g. if ranks are\n unknown, than the whole shape of a core can be unknown).\n tt_ranks: a TensorShape of length d+1 (d is the dimensionality of\n the underlying tensor). The first and the last ranks are assumed to\n equal to 1. If None, tries to infer the ranks from the cores.\n convert_to_tensors: bool, if True than convert each element of the\n tt_cores tuple into a tf.Tensor (e.g. to initialize from np.array)\n name: The name of ops.\n\n Returns:\n A `TensorTrain`.\n\n Raises:\n ValueError if the provided TT-cores are not valid or inconsistent with\n the provided shape.\n \"\"\"\n tt_cores = list(tt_cores)\n if convert_to_tensors:\n with tf.name_scope(name):\n for i in range(len(tt_cores)):\n name = \"core%d\" % i\n tt_cores[i] = tf.convert_to_tensor(tt_cores[i], name=name)\n\n if not _are_tt_cores_valid(tt_cores, shape, tt_ranks):\n raise ValueError('The tt_cores provided to TensorTrain constructor are '\n 'not valid, have different dtypes, or are inconsistent '\n 'with the provided shape or TT-ranks.')\n\n self._tt_cores = tuple(tt_cores)\n self._raw_shape = shapes.clean_raw_shape(shape)\n if self._raw_shape is None:\n self._raw_shape = _infer_raw_shape(self._tt_cores)\n self._tt_ranks = None if tt_ranks is None else tf.TensorShape(tt_ranks)\n if self._tt_ranks is None:\n self._tt_ranks = _infer_tt_ranks(self._tt_cores)\n\n @property\n def tt_cores(self):\n \"\"\"A tuple of TT-cores.\n\n Returns:\n A tuple of 3d or 4d tensors shape\n `[r_k-1, n_k, r_k]`\n or\n `[r_k-1, n_k, m_k, r_k]`\n \"\"\"\n return self._tt_cores\n\n @property\n def left_tt_rank_dim(self):\n \"\"\"The dimension of the left TT-rank in each TT-core.\"\"\"\n return 0\n\n @property\n def right_tt_rank_dim(self):\n \"\"\"The dimension of the right TT-rank in each TT-core.\"\"\"\n if self.is_tt_matrix():\n # The dimensions of each TT-core are\n # [left_rank, n, m, right_rank]\n return 3\n else:\n # The dimensions of each TT-core are\n # [left_rank, n, right_rank]\n return 2\n\n def __str__(self):\n \"\"\"A string describing the TensorTrain object, its TT-rank, and shape.\"\"\"\n shape = self.get_shape()\n tt_ranks = self.get_tt_ranks()\n variable_str = ' variable' if self.is_variable() else ''\n if self.is_tt_matrix():\n raw_shape = self.get_raw_shape()\n return \"A TT-Matrix%s of size %d x %d, underlying tensor \" \\\n \"shape: %s x %s, TT-ranks: %s\" % (variable_str, shape[0], shape[1],\n raw_shape[0], raw_shape[1],\n tt_ranks)\n else:\n return \"A Tensor Train%s of shape %s, TT-ranks: %s\" % (variable_str,\n shape, tt_ranks)\n\n def __getitem__(self, slice_spec):\n \"\"\"Basic indexing, returns a `TensorTrain` containing the specified region.\n\n Examples:\n >>> a = t3f.random_tensor((2, 3, 4))\n >>> a[1, :, :]\n is a 2D TensorTrain 3 x 4.\n >>> a[1:2, :, :]\n is a 3D TensorTrain 1 x 3 x 4\n \"\"\"\n if len(slice_spec) != self.ndims():\n raise ValueError('Expected %d indices, got %d' % (self.ndims(),\n len(slice_spec)))\n new_tt_cores = []\n remainder = None\n for i in range(self.ndims()):\n curr_core = self.tt_cores[i]\n if self.is_tt_matrix():\n raise NotImplementedError\n else:\n sliced_core = curr_core[:, slice_spec[i], :]\n if len(curr_core.get_shape()) != len(sliced_core.get_shape()):\n # This index is specified exactly and we want to collapse this axis.\n if remainder is None:\n remainder = sliced_core\n else:\n remainder = tf.matmul(remainder, sliced_core)\n else:\n if remainder is not None:\n # Add reminder from the previous collapsed cores to the current\n # core.\n sliced_core = tf.einsum('ab,bid->aid', remainder, sliced_core)\n remainder = None\n new_tt_cores.append(sliced_core)\n\n if remainder is not None:\n # The reminder obtained from collapsing the last cores.\n new_tt_cores[-1] = tf.einsum('aib,bd->aid', new_tt_cores[-1], remainder)\n remainder = None\n # TODO: infer the output ranks and shape.\n return TensorTrain(new_tt_cores)\n\n\ndef _are_tt_cores_valid(tt_cores, shape, tt_ranks):\n \"\"\"Check if dimensions of the TT-cores are consistent and the dtypes coincide.\n\n Args:\n tt_cores: a tuple of `Tensor` objects\n shape: An np.array, a tf.TensorShape (for tensors), a tuple of\n tf.TensorShapes (for TT-matrices or tensors), or None\n tt_ranks: An np.array or a tf.TensorShape of length len(tt_cores)+1.\n\n Returns:\n boolean, True if the dimensions and dtypes are consistent.\n \"\"\"\n shape = shapes.clean_raw_shape(shape)\n num_dims = len(tt_cores)\n\n for core_idx in range(1, num_dims):\n if tt_cores[core_idx].dtype != tt_cores[0].dtype:\n return False\n try:\n for core_idx in range(num_dims):\n curr_core_shape = tt_cores[core_idx].get_shape()\n if len(curr_core_shape) != len(tt_cores[0].get_shape()):\n # Shapes are inconsistent.\n return False\n if shape is not None:\n for i in range(len(shape)):\n if curr_core_shape[i + 1] != shape[i][core_idx]:\n # The TT-cores are not aligned with the given shape.\n return False\n if core_idx >= 1:\n prev_core_shape = tt_cores[core_idx - 1].get_shape()\n if curr_core_shape[0] != prev_core_shape[-1]:\n # TT-ranks are inconsistent.\n return False\n if tt_ranks is not None:\n if curr_core_shape[0] != tt_ranks[core_idx]:\n # The TT-ranks are not aligned with the TT-cores shape.\n return False\n if curr_core_shape[-1] != tt_ranks[core_idx + 1]:\n # The TT-ranks are not aligned with the TT-cores shape.\n return False\n if tt_cores[0].get_shape()[0] != 1 or tt_cores[-1].get_shape()[-1] != 1:\n # The first or the last rank is not 1.\n return False\n except ValueError:\n # The shape of the TT-cores is undetermined, can not validate it.\n pass\n return True\n\n\ndef _infer_raw_shape(tt_cores):\n \"\"\"Tries to infer the (static) raw shape from the TT-cores.\"\"\"\n num_dims = len(tt_cores)\n num_tensor_shapes = len(tt_cores[0].get_shape().as_list()) - 2\n raw_shape = [[] for _ in range(num_tensor_shapes)]\n for dim in range(num_dims):\n curr_core_shape = tt_cores[dim].get_shape()\n for i in range(num_tensor_shapes):\n raw_shape[i].append(curr_core_shape[i + 1])\n for i in range(num_tensor_shapes):\n raw_shape[i] = tf.TensorShape(raw_shape[i])\n return tuple(raw_shape)\n\n\ndef _infer_tt_ranks(tt_cores):\n \"\"\"Tries to infer the (static) raw shape from the TT-cores.\"\"\"\n tt_ranks = []\n for i in range(len(tt_cores)):\n tt_ranks.append(tt_cores[i].get_shape()[0])\n tt_ranks.append(tt_cores[-1].get_shape()[-1])\n return tf.TensorShape(tt_ranks)\n",
"import numpy as np\nimport tensorflow as tf\n\nfrom t3f import ops\nfrom t3f import batch_ops\nfrom t3f import initializers\n\n\nclass _BatchOpsTest():\n\n def testConcatMatrix(self):\n # Test concating TTMatrix batches along batch dimension.\n first = initializers.random_matrix_batch(((2, 3), (3, 3)), batch_size=1,\n dtype=self.dtype)\n second = initializers.random_matrix_batch(((2, 3), (3, 3)), batch_size=4,\n dtype=self.dtype)\n third = initializers.random_matrix_batch(((2, 3), (3, 3)), batch_size=3,\n dtype=self.dtype)\n first_res = batch_ops.concat_along_batch_dim((first))\n first_res = ops.full(first_res)\n first_second_res = batch_ops.concat_along_batch_dim((first, second))\n first_second_res = ops.full(first_second_res)\n first_second_third_res = batch_ops.concat_along_batch_dim((first, second,\n third))\n first_second_third_res = ops.full(first_second_third_res)\n\n first_full = ops.full(first)\n second_full = ops.full(second)\n third_full = ops.full(third)\n first_desired = first_full\n first_second_desired = tf.concat((first_full, second_full), axis=0)\n first_second_third_desired = tf.concat((first_full, second_full, third_full),\n axis=0)\n with self.test_session() as sess:\n res = sess.run((first_res, first_second_res, first_second_third_res,\n first_desired, first_second_desired,\n first_second_third_desired))\n first_res_val = res[0]\n first_second_res_val = res[1]\n first_second_third_res_val = res[2]\n first_desired_val = res[3]\n first_second_desired_val = res[4]\n first_second_third_desired_val = res[5]\n self.assertAllClose(first_res_val, first_desired_val)\n self.assertAllClose(first_second_res_val, first_second_desired_val)\n self.assertAllClose(first_second_third_res_val, first_second_third_desired_val)\n\n def testConcatTensorPlaceholders(self):\n # Test concating TTTensors of unknown batch sizes along batch dimension.\n number_of_objects = tf.placeholder(tf.int32)\n all = initializers.random_tensor_batch((2, 3), batch_size=5,\n dtype=self.dtype)\n actual = batch_ops.concat_along_batch_dim((all[:number_of_objects],\n all[number_of_objects:]))\n with self.test_session() as sess:\n desired_val, actual_val = sess.run((ops.full(all), ops.full(actual)),\n feed_dict={number_of_objects: 2})\n self.assertAllClose(desired_val, actual_val)\n\n def testConcatMatrixPlaceholders(self):\n # Test concating TTMatrices of unknown batch sizes along batch dimension.\n number_of_objects = tf.placeholder(tf.int32)\n all = initializers.random_matrix_batch(((2, 3), (2, 3)), batch_size=5,\n dtype=self.dtype)\n actual = batch_ops.concat_along_batch_dim((all[:number_of_objects],\n all[number_of_objects:]))\n with self.test_session() as sess:\n desired_val, actual_val = sess.run((ops.full(all), ops.full(actual)),\n feed_dict={number_of_objects: 2})\n self.assertAllClose(desired_val, actual_val)\n\n def testBatchMultiply(self):\n # Test multiplying batch of TTMatrices by individual numbers.\n tt = initializers.random_matrix_batch(((2, 3), (3, 3)), batch_size=3,\n dtype=self.dtype)\n weights = [0.1, 0, -10]\n actual = batch_ops.multiply_along_batch_dim(tt, weights)\n individual_desired = [weights[i] * tt[i:i+1] for i in range(3)]\n desired = batch_ops.concat_along_batch_dim(individual_desired)\n with self.test_session() as sess:\n desired_val, acutual_val = sess.run((ops.full(desired), ops.full(actual)))\n self.assertAllClose(desired_val, acutual_val)\n\n def testGramMatrix(self):\n # Test Gram Matrix of a batch of TT vectors.\n tt_vectors = initializers.random_matrix_batch(((2, 3), None), batch_size=5,\n dtype=self.dtype)\n res_actual = batch_ops.gram_matrix(tt_vectors)\n full_vectors = tf.reshape(ops.full(tt_vectors), (5, 6))\n res_desired = tf.matmul(full_vectors, tf.transpose(full_vectors))\n res_desired = tf.squeeze(res_desired)\n with self.test_session() as sess:\n res_actual_val, res_desired_val = sess.run((res_actual, res_desired))\n self.assertAllClose(res_desired_val, res_actual_val)\n\n def testGramMatrixWithMatrix(self):\n # Test Gram Matrix of a batch of TT vectors with providing a matrix, so we\n # should compute\n # res[i, j] = tt_vectors[i] ^ T * matrix * tt_vectors[j]\n tt_vectors = initializers.random_matrix_batch(((2, 3), None), batch_size=4,\n dtype=self.dtype)\n matrix = initializers.random_matrix(((2, 3), (2, 3)), dtype=self.dtype)\n res_actual = batch_ops.gram_matrix(tt_vectors, matrix)\n full_vectors = tf.reshape(ops.full(tt_vectors), (4, 6))\n with self.test_session() as sess:\n res = sess.run((res_actual, full_vectors, ops.full(matrix)))\n res_actual_val, vectors_val, matrix_val = res\n res_desired_val = np.zeros((4, 4))\n for i in range(4):\n for j in range(4):\n curr_val = np.dot(vectors_val[i], matrix_val)\n curr_val = np.dot(curr_val, vectors_val[j])\n res_desired_val[i, j] = curr_val\n self.assertAllClose(res_desired_val, res_actual_val, atol=1e-5, rtol=1e-5)\n\n def testPairwiseFlatInnerTensor(self):\n # Test pairwise_flat_inner of a batch of TT tensors.\n tt_tensors_1 = initializers.random_tensor_batch((2, 3, 2), batch_size=5,\n dtype=self.dtype)\n tt_tensors_2 = initializers.random_tensor_batch((2, 3, 2), batch_size=5,\n dtype=self.dtype)\n res_actual = batch_ops.pairwise_flat_inner(tt_tensors_1, tt_tensors_2)\n full_tensors_1 = tf.reshape(ops.full(tt_tensors_1), (5, 12))\n full_tensors_2 = tf.reshape(ops.full(tt_tensors_2), (5, 12))\n res_desired = tf.matmul(full_tensors_1, tf.transpose(full_tensors_2))\n res_desired = tf.squeeze(res_desired)\n with self.test_session() as sess:\n res_actual_val, res_desired_val = sess.run((res_actual, res_desired))\n self.assertAllClose(res_desired_val, res_actual_val)\n\n def testPairwiseFlatInnerMatrix(self):\n # Test pairwise_flat_inner of a batch of TT matrices.\n tt_vectors_1 = initializers.random_matrix_batch(((2, 3), (2, 3)),\n batch_size=5,\n dtype=self.dtype)\n tt_vectors_2 = initializers.random_matrix_batch(((2, 3), (2, 3)),\n batch_size=5,\n dtype=self.dtype)\n res_actual = batch_ops.pairwise_flat_inner(tt_vectors_1, tt_vectors_2)\n full_vectors_1 = tf.reshape(ops.full(tt_vectors_1), (5, 36))\n full_vectors_2 = tf.reshape(ops.full(tt_vectors_2), (5, 36))\n res_desired = tf.matmul(full_vectors_1, tf.transpose(full_vectors_2))\n res_desired = tf.squeeze(res_desired)\n with self.test_session() as sess:\n res_actual_val, res_desired_val = sess.run((res_actual, res_desired))\n self.assertAllClose(res_desired_val, res_actual_val, atol=1e-5, rtol=1e-5)\n\n def testPairwiseFlatInnerVectorsWithMatrix(self):\n # Test pairwise_flat_inner of a batch of TT vectors with providing a matrix,\n # so we should compute\n # res[i, j] = tt_vectors[i] ^ T * matrix * tt_vectors[j]\n tt_vectors_1 = initializers.random_matrix_batch(((2, 3), None),\n batch_size=2,\n dtype=self.dtype)\n tt_vectors_2 = initializers.random_matrix_batch(((2, 3), None),\n batch_size=3,\n dtype=self.dtype)\n matrix = initializers.random_matrix(((2, 3), (2, 3)), dtype=self.dtype)\n res_actual = batch_ops.pairwise_flat_inner(tt_vectors_1, tt_vectors_2,\n matrix)\n full_vectors_1 = tf.reshape(ops.full(tt_vectors_1), (2, 6))\n full_vectors_2 = tf.reshape(ops.full(tt_vectors_2), (3, 6))\n with self.test_session() as sess:\n res = sess.run((res_actual, full_vectors_1, full_vectors_2,\n ops.full(matrix)))\n res_actual_val, vectors_1_val, vectors_2_val, matrix_val = res\n res_desired_val = np.zeros((2, 3))\n for i in range(2):\n for j in range(3):\n curr_val = np.dot(vectors_1_val[i], matrix_val)\n curr_val = np.dot(curr_val, vectors_2_val[j])\n res_desired_val[i, j] = curr_val\n self.assertAllClose(res_desired_val, res_actual_val)\n\n\nclass BatchOpsTestFloat32(tf.test.TestCase, _BatchOpsTest):\n dtype = tf.float32\n\n\nclass BatchOpsTestFloat64(tf.test.TestCase, _BatchOpsTest):\n dtype = tf.float64\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n\n"
] | [
[
"numpy.abs",
"numpy.sqrt",
"tensorflow.zeros",
"tensorflow.ones",
"tensorflow.eye",
"numpy.ones",
"numpy.concatenate",
"numpy.append",
"tensorflow.name_scope",
"numpy.any",
"numpy.prod",
"numpy.insert",
"numpy.array",
"numpy.vstack",
"tensorflow.random_normal"
],
[
"tensorflow.convert_to_tensor",
"tensorflow.TensorShape",
"tensorflow.matmul",
"tensorflow.einsum",
"tensorflow.name_scope"
],
[
"numpy.dot",
"tensorflow.transpose",
"tensorflow.concat",
"tensorflow.squeeze",
"tensorflow.test.main",
"tensorflow.placeholder",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
}
] |
gavincangan/pyro | [
"d9115a6da7edd7e3fecd6b89a850cc137d7e7e9a",
"d9115a6da7edd7e3fecd6b89a850cc137d7e7e9a",
"d9115a6da7edd7e3fecd6b89a850cc137d7e7e9a",
"d9115a6da7edd7e3fecd6b89a850cc137d7e7e9a",
"d9115a6da7edd7e3fecd6b89a850cc137d7e7e9a",
"d9115a6da7edd7e3fecd6b89a850cc137d7e7e9a",
"d9115a6da7edd7e3fecd6b89a850cc137d7e7e9a",
"d9115a6da7edd7e3fecd6b89a850cc137d7e7e9a"
] | [
"examples/rsa/search_inference.py",
"pyro/distributions/iaf.py",
"tests/contrib/gp/test_models.py",
"pyro/contrib/oed/eig.py",
"pyro/distributions/testing/naive_dirichlet.py",
"pyro/contrib/gp/kernels/periodic.py",
"pyro/contrib/gp/parameterized.py",
"examples/inclined_plane.py"
] | [
"\"\"\"\nInference algorithms and utilities used in the RSA example models.\n\nAdapted from: http://dippl.org/chapters/03-enumeration.html\n\"\"\"\n\nfrom __future__ import absolute_import, division, print_function\n\nimport collections\n\nimport six\nimport torch\nfrom six.moves import queue\n\nimport pyro\nimport pyro.distributions as dist\nimport pyro.poutine as poutine\nfrom pyro.infer.abstract_infer import TracePosterior\nfrom pyro.poutine.runtime import NonlocalExit\n\nif six.PY3:\n import functools\nelse:\n import functools32 as functools\n\n\ndef memoize(fn=None, **kwargs):\n if fn is None:\n return lambda _fn: memoize(_fn, **kwargs)\n return functools.lru_cache(**kwargs)(fn)\n\n\ndef factor(name, value):\n \"\"\"\n Like factor in webPPL, adds a scalar weight to the log-probability of the trace\n \"\"\"\n value = value if torch.is_tensor(value) else torch.tensor(value)\n d = dist.Bernoulli(logits=value)\n pyro.sample(name, d, obs=torch.ones(value.size()))\n\n\nclass HashingMarginal(dist.Distribution):\n \"\"\"\n :param trace_dist: a TracePosterior instance representing a Monte Carlo posterior\n\n Marginal histogram distribution.\n Turns a TracePosterior object into a Distribution\n over the return values of the TracePosterior's model.\n \"\"\"\n def __init__(self, trace_dist, sites=None):\n assert isinstance(trace_dist, TracePosterior), \\\n \"trace_dist must be trace posterior distribution object\"\n\n if sites is None:\n sites = \"_RETURN\"\n\n assert isinstance(sites, (str, list)), \\\n \"sites must be either '_RETURN' or list\"\n\n self.sites = sites\n super(HashingMarginal, self).__init__()\n self.trace_dist = trace_dist\n\n has_enumerate_support = True\n\n @memoize(maxsize=10)\n def _dist_and_values(self):\n # XXX currently this whole object is very inefficient\n values_map, logits = collections.OrderedDict(), collections.OrderedDict()\n for tr, logit in zip(self.trace_dist.exec_traces,\n self.trace_dist.log_weights):\n if isinstance(self.sites, str):\n value = tr.nodes[self.sites][\"value\"]\n else:\n value = {site: tr.nodes[site][\"value\"] for site in self.sites}\n if not torch.is_tensor(logit):\n logit = torch.tensor(logit)\n\n if torch.is_tensor(value):\n value_hash = hash(value.cpu().contiguous().numpy().tobytes())\n elif isinstance(value, dict):\n value_hash = hash(self._dict_to_tuple(value))\n else:\n value_hash = hash(value)\n if value_hash in logits:\n # Value has already been seen.\n logits[value_hash] = dist.util.logsumexp(torch.stack([logits[value_hash], logit]), dim=-1)\n else:\n logits[value_hash] = logit\n values_map[value_hash] = value\n\n logits = torch.stack(list(logits.values())).contiguous().view(-1)\n logits = logits - dist.util.logsumexp(logits, dim=-1)\n d = dist.Categorical(logits=logits)\n return d, values_map\n\n def sample(self):\n d, values_map = self._dist_and_values()\n ix = d.sample()\n return list(values_map.values())[ix]\n\n def log_prob(self, val):\n d, values_map = self._dist_and_values()\n if torch.is_tensor(val):\n value_hash = hash(val.cpu().contiguous().numpy().tobytes())\n elif isinstance(val, dict):\n value_hash = hash(self._dict_to_tuple(val))\n else:\n value_hash = hash(val)\n return d.log_prob(torch.tensor([list(values_map.keys()).index(value_hash)]))\n\n def enumerate_support(self):\n d, values_map = self._dist_and_values()\n return list(values_map.values())[:]\n\n def _dict_to_tuple(self, d):\n \"\"\"\n Recursively converts a dictionary to a list of key-value tuples\n Only intended for use as a helper function inside HashingMarginal!!\n May break when keys cant be sorted, but that is not an expected use-case\n \"\"\"\n if isinstance(d, dict):\n return tuple([(k, self._dict_to_tuple(d[k])) for k in sorted(d.keys())])\n else:\n return d\n\n def _weighted_mean(self, value, dim=0):\n weights = self._log_weights.reshape([-1] + (value.dim() - 1) * [1])\n max_weight = weights.max(dim=dim)[0]\n relative_probs = (weights - max_weight).exp()\n return (value * relative_probs).sum(dim=dim) / relative_probs.sum(dim=dim)\n\n @property\n def mean(self):\n samples = torch.stack(list(self._dist_and_values()[1].values()))\n return self._weighted_mean(samples)\n\n @property\n def variance(self):\n samples = torch.stack(list(self._dist_and_values()[1].values()))\n deviation_squared = torch.pow(samples - self.mean, 2)\n return self._weighted_mean(deviation_squared)\n\n\n########################\n# Exact Search inference\n########################\n\nclass Search(TracePosterior):\n \"\"\"\n Exact inference by enumerating over all possible executions\n \"\"\"\n def __init__(self, model, max_tries=int(1e6), **kwargs):\n self.model = model\n self.max_tries = max_tries\n super(Search, self).__init__(**kwargs)\n\n def _traces(self, *args, **kwargs):\n q = queue.Queue()\n q.put(poutine.Trace())\n p = poutine.trace(\n poutine.queue(self.model, queue=q, max_tries=self.max_tries))\n while not q.empty():\n tr = p.get_trace(*args, **kwargs)\n yield tr, tr.log_prob_sum()\n\n\n###############################################\n# Best-first Search Inference\n###############################################\n\n\ndef pqueue(fn, queue):\n\n def sample_escape(tr, site):\n return (site[\"name\"] not in tr) and \\\n (site[\"type\"] == \"sample\") and \\\n (not site[\"is_observed\"])\n\n def _fn(*args, **kwargs):\n\n for i in range(int(1e6)):\n assert not queue.empty(), \\\n \"trying to get() from an empty queue will deadlock\"\n\n priority, next_trace = queue.get()\n try:\n ftr = poutine.trace(poutine.escape(poutine.replay(fn, next_trace),\n functools.partial(sample_escape,\n next_trace)))\n return ftr(*args, **kwargs)\n except NonlocalExit as site_container:\n site_container.reset_stack()\n for tr in poutine.util.enum_extend(ftr.trace.copy(),\n site_container.site):\n # add a little bit of noise to the priority to break ties...\n queue.put((tr.log_prob_sum().item() - torch.rand(1).item() * 1e-2, tr))\n\n raise ValueError(\"max tries ({}) exceeded\".format(str(1e6)))\n\n return _fn\n\n\nclass BestFirstSearch(TracePosterior):\n \"\"\"\n Inference by enumerating executions ordered by their probabilities.\n Exact (and results equivalent to Search) if all executions are enumerated.\n \"\"\"\n def __init__(self, model, num_samples=None, **kwargs):\n if num_samples is None:\n num_samples = 100\n self.num_samples = num_samples\n self.model = model\n super(BestFirstSearch, self).__init__(**kwargs)\n\n def _traces(self, *args, **kwargs):\n q = queue.PriorityQueue()\n # add a little bit of noise to the priority to break ties...\n q.put((torch.zeros(1).item() - torch.rand(1).item() * 1e-2, poutine.Trace()))\n q_fn = pqueue(self.model, queue=q)\n for i in range(self.num_samples):\n if q.empty():\n # num_samples was too large!\n break\n tr = poutine.trace(q_fn).get_trace(*args, **kwargs) # XXX should block\n yield tr, tr.log_prob_sum()\n",
"from __future__ import absolute_import, division, print_function\n\nimport torch\nimport torch.nn as nn\nfrom torch.distributions import constraints\n\nfrom pyro.distributions.torch_transform import TransformModule\nfrom pyro.distributions.util import copy_docs_from\n\n# This helper function clamps gradients but still passes through the gradient in clamped regions\n\n\ndef clamp_preserve_gradients(x, min, max):\n return x + (x.clamp(min, max) - x).detach()\n\n\n@copy_docs_from(TransformModule)\nclass InverseAutoregressiveFlow(TransformModule):\n \"\"\"\n An implementation of Inverse Autoregressive Flow, using Eq (10) from Kingma Et Al., 2016,\n\n :math:`\\\\mathbf{y} = \\\\mu_t + \\\\sigma_t\\\\odot\\\\mathbf{x}`\n\n where :math:`\\\\mathbf{x}` are the inputs, :math:`\\\\mathbf{y}` are the outputs, :math:`\\\\mu_t,\\\\sigma_t`\n are calculated from an autoregressive network on :math:`\\\\mathbf{x}`, and :math:`\\\\sigma_t>0`.\n\n Together with `TransformedDistribution` this provides a way to create richer variational approximations.\n\n Example usage:\n\n >>> from pyro.nn import AutoRegressiveNN\n >>> base_dist = dist.Normal(torch.zeros(10), torch.ones(10))\n >>> iaf = InverseAutoregressiveFlow(AutoRegressiveNN(10, [40]))\n >>> pyro.module(\"my_iaf\", iaf) # doctest: +SKIP\n >>> iaf_dist = dist.TransformedDistribution(base_dist, [iaf])\n >>> iaf_dist.sample() # doctest: +SKIP\n tensor([-0.4071, -0.5030, 0.7924, -0.2366, -0.2387, -0.1417, 0.0868,\n 0.1389, -0.4629, 0.0986])\n\n The inverse of the Bijector is required when, e.g., scoring the log density of a sample with\n `TransformedDistribution`. This implementation caches the inverse of the Bijector when its forward\n operation is called, e.g., when sampling from `TransformedDistribution`. However, if the cached value\n isn't available, either because it was overwritten during sampling a new value or an arbitary value is\n being scored, it will calculate it manually. Note that this is an operation that scales as O(D) where D is\n the input dimension, and so should be avoided for large dimensional uses. So in general, it is cheap\n to sample from IAF and score a value that was sampled by IAF, but expensive to score an arbitrary value.\n\n :param autoregressive_nn: an autoregressive neural network whose forward call returns a real-valued\n mean and logit-scale as a tuple\n :type autoregressive_nn: nn.Module\n :param log_scale_min_clip: The minimum value for clipping the log(scale) from the autoregressive NN\n :type log_scale_min_clip: float\n :param log_scale_max_clip: The maximum value for clipping the log(scale) from the autoregressive NN\n :type log_scale_max_clip: float\n\n References:\n\n 1. Improving Variational Inference with Inverse Autoregressive Flow [arXiv:1606.04934]\n Diederik P. Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, Max Welling\n\n 2. Variational Inference with Normalizing Flows [arXiv:1505.05770]\n Danilo Jimenez Rezende, Shakir Mohamed\n\n 3. MADE: Masked Autoencoder for Distribution Estimation [arXiv:1502.03509]\n Mathieu Germain, Karol Gregor, Iain Murray, Hugo Larochelle\n \"\"\"\n\n domain = constraints.real\n codomain = constraints.real\n bijective = True\n event_dim = 1\n\n def __init__(self, autoregressive_nn, log_scale_min_clip=-5., log_scale_max_clip=3.):\n super(InverseAutoregressiveFlow, self).__init__(cache_size=1)\n self.arn = autoregressive_nn\n self._cached_log_scale = None\n self.log_scale_min_clip = log_scale_min_clip\n self.log_scale_max_clip = log_scale_max_clip\n\n def _call(self, x):\n \"\"\"\n :param x: the input into the bijection\n :type x: torch.Tensor\n\n Invokes the bijection x=>y; in the prototypical context of a TransformedDistribution `x` is a\n sample from the base distribution (or the output of a previous flow)\n \"\"\"\n mean, log_scale = self.arn(x)\n log_scale = clamp_preserve_gradients(log_scale, self.log_scale_min_clip, self.log_scale_max_clip)\n self._cached_log_scale = log_scale\n scale = torch.exp(log_scale)\n\n y = scale * x + mean\n return y\n\n def _inverse(self, y):\n \"\"\"\n :param y: the output of the bijection\n :type y: torch.Tensor\n\n Inverts y => x. Uses a previously cached inverse if available, otherwise performs the inversion afresh.\n \"\"\"\n x_size = y.size()[:-1]\n perm = self.arn.permutation\n input_dim = y.size(-1)\n x = [torch.zeros(x_size, device=y.device)] * input_dim\n\n # NOTE: Inversion is an expensive operation that scales in the dimension of the input\n for idx in perm:\n mean, log_scale = self.arn(torch.stack(x, dim=-1))\n inverse_scale = torch.exp(-clamp_preserve_gradients(\n log_scale[..., idx], min=self.log_scale_min_clip, max=self.log_scale_max_clip))\n mean = mean[..., idx]\n x[idx] = (y[..., idx] - mean) * inverse_scale\n\n x = torch.stack(x, dim=-1)\n log_scale = clamp_preserve_gradients(log_scale, min=self.log_scale_min_clip, max=self.log_scale_max_clip)\n self._cached_log_scale = log_scale\n return x\n\n def log_abs_det_jacobian(self, x, y):\n \"\"\"\n Calculates the elementwise determinant of the log jacobian\n \"\"\"\n if self._cached_log_scale is not None:\n log_scale = self._cached_log_scale\n else:\n _, log_scale = self.arn(x)\n log_scale = clamp_preserve_gradients(log_scale, self.log_scale_min_clip, self.log_scale_max_clip)\n return log_scale.sum(-1)\n\n\n@copy_docs_from(TransformModule)\nclass InverseAutoregressiveFlowStable(TransformModule):\n \"\"\"\n An implementation of an Inverse Autoregressive Flow, using Eqs (13)/(14) from Kingma Et Al., 2016,\n\n :math:`\\\\mathbf{y} = \\\\sigma_t\\\\odot\\\\mathbf{x} + (1-\\\\sigma_t)\\\\odot\\\\mu_t`\n\n where :math:`\\\\mathbf{x}` are the inputs, :math:`\\\\mathbf{y}` are the outputs, :math:`\\\\mu_t,\\\\sigma_t`\n are calculated from an autoregressive network on :math:`\\\\mathbf{x}`, and :math:`\\\\sigma_t` is\n restricted to :math:`(0,1)`.\n\n This variant of IAF is claimed by the authors to be more numerically stable than one using Eq (10),\n although in practice it leads to a restriction on the distributions that can be represented,\n presumably since the input is restricted to rescaling by a number on :math:`(0,1)`.\n\n Example usage:\n\n >>> from pyro.nn import AutoRegressiveNN\n >>> base_dist = dist.Normal(torch.zeros(10), torch.ones(10))\n >>> iaf = InverseAutoregressiveFlowStable(AutoRegressiveNN(10, [40]))\n >>> iaf_module = pyro.module(\"my_iaf\", iaf)\n >>> iaf_dist = dist.TransformedDistribution(base_dist, [iaf])\n >>> iaf_dist.sample() # doctest: +SKIP\n tensor([-0.4071, -0.5030, 0.7924, -0.2366, -0.2387, -0.1417, 0.0868,\n 0.1389, -0.4629, 0.0986])\n\n See `InverseAutoregressiveFlow` docs for a discussion of the running cost.\n\n :param autoregressive_nn: an autoregressive neural network whose forward call returns a real-valued\n mean and logit-scale as a tuple\n :type autoregressive_nn: nn.Module\n :param sigmoid_bias: bias on the hidden units fed into the sigmoid; default=`2.0`\n :type sigmoid_bias: float\n\n References:\n\n 1. Improving Variational Inference with Inverse Autoregressive Flow [arXiv:1606.04934]\n Diederik P. Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, Max Welling\n\n 2. Variational Inference with Normalizing Flows [arXiv:1505.05770]\n Danilo Jimenez Rezende, Shakir Mohamed\n\n 3. MADE: Masked Autoencoder for Distribution Estimation [arXiv:1502.03509]\n Mathieu Germain, Karol Gregor, Iain Murray, Hugo Larochelle\n \"\"\"\n\n domain = constraints.real\n codomain = constraints.real\n bijective = True\n event_dim = 1\n\n def __init__(self, autoregressive_nn, sigmoid_bias=2.0):\n super(InverseAutoregressiveFlowStable, self).__init__(cache_size=1)\n self.arn = autoregressive_nn\n self.sigmoid = nn.Sigmoid()\n self.logsigmoid = nn.LogSigmoid()\n self.sigmoid_bias = sigmoid_bias\n self._cached_log_scale = None\n\n def _call(self, x):\n \"\"\"\n :param x: the input into the bijection\n :type x: torch.Tensor\n\n Invokes the bijection x=>y; in the prototypical context of a TransformedDistribution `x` is a\n sample from the base distribution (or the output of a previous flow)\n \"\"\"\n mean, logit_scale = self.arn(x)\n logit_scale = logit_scale + self.sigmoid_bias\n scale = self.sigmoid(logit_scale)\n log_scale = self.logsigmoid(logit_scale)\n self._cached_log_scale = log_scale\n\n y = scale * x + (1 - scale) * mean\n return y\n\n def _inverse(self, y):\n \"\"\"\n :param y: the output of the bijection\n :type y: torch.Tensor\n\n Inverts y => x.\n \"\"\"\n x_size = y.size()[:-1]\n perm = self.arn.permutation\n input_dim = y.size(-1)\n x = [torch.zeros(x_size, device=y.device)] * input_dim\n\n # NOTE: Inversion is an expensive operation that scales in the dimension of the input\n for idx in perm:\n mean, logit_scale = self.arn(torch.stack(x, dim=-1))\n inverse_scale = 1 + torch.exp(-logit_scale[..., idx] - self.sigmoid_bias)\n x[idx] = inverse_scale * y[..., idx] + (1 - inverse_scale) * mean[..., idx]\n self._cached_log_scale = inverse_scale\n\n x = torch.stack(x, dim=-1)\n return x\n\n def log_abs_det_jacobian(self, x, y):\n \"\"\"\n Calculates the elementwise determinant of the log jacobian\n \"\"\"\n if self._cached_log_scale is not None:\n log_scale = self._cached_log_scale\n else:\n _, logit_scale = self.arn(x)\n log_scale = self.logsigmoid(logit_scale + self.sigmoid_bias)\n return log_scale.sum(-1)\n",
"from __future__ import absolute_import, division, print_function\n\nimport logging\nfrom collections import defaultdict, namedtuple\n\nimport pytest\nimport torch\n\nimport pyro.distributions as dist\nfrom pyro.contrib.gp.kernels import Cosine, Matern32, RBF, WhiteNoise\nfrom pyro.contrib.gp.likelihoods import Gaussian\nfrom pyro.contrib.gp.models import (GPLVM, GPRegression, SparseGPRegression,\n VariationalGP, VariationalSparseGP)\nfrom pyro.contrib.gp.util import train\nfrom pyro.infer.mcmc.hmc import HMC\nfrom pyro.infer.mcmc.mcmc import MCMC\nfrom tests.common import assert_equal\n\nlogger = logging.getLogger(__name__)\n\nT = namedtuple(\"TestGPModel\", [\"model_class\", \"X\", \"y\", \"kernel\", \"likelihood\"])\n\nX = torch.tensor([[1., 5., 3.], [4., 3., 7.]])\ny1D = torch.tensor([2., 1.])\ny2D = torch.tensor([[1., 2.], [3., 3.], [1., 4.], [-1., 1.]])\nnoise = torch.tensor(1e-7)\n\n\ndef _kernel():\n return RBF(input_dim=3, variance=torch.tensor(3.), lengthscale=torch.tensor(2.))\n\n\ndef _likelihood():\n return Gaussian(torch.tensor(1e-7))\n\n\ndef _TEST_CASES():\n TEST_CASES = [\n T(\n GPRegression,\n X, y1D, _kernel(), noise\n ),\n T(\n GPRegression,\n X, y2D, _kernel(), noise\n ),\n T(\n SparseGPRegression,\n X, y1D, _kernel(), noise\n ),\n T(\n SparseGPRegression,\n X, y2D, _kernel(), noise\n ),\n T(\n VariationalGP,\n X, y1D, _kernel(), _likelihood()\n ),\n T(\n VariationalGP,\n X, y2D, _kernel(), _likelihood()\n ),\n T(\n VariationalSparseGP,\n X, y1D, _kernel(), _likelihood()\n ),\n T(\n VariationalSparseGP,\n X, y2D, _kernel(), _likelihood()\n ),\n ]\n\n return TEST_CASES\n\n\nTEST_IDS = [t[0].__name__ + \"_y{}D\".format(str(t[2].dim()))\n for t in _TEST_CASES()]\n\n\[email protected](\"model_class, X, y, kernel, likelihood\", _TEST_CASES(), ids=TEST_IDS)\ndef test_model(model_class, X, y, kernel, likelihood):\n if model_class is SparseGPRegression or model_class is VariationalSparseGP:\n gp = model_class(X, None, kernel, X, likelihood)\n else:\n gp = model_class(X, None, kernel, likelihood)\n\n loc, var = gp.model()\n if model_class is VariationalGP or model_class is VariationalSparseGP:\n assert_equal(loc.norm().item(), 0)\n assert_equal(var, torch.ones(var.shape[-1]).expand(var.shape))\n else:\n assert_equal(loc.norm().item(), 0)\n assert_equal(var, kernel(X).diag())\n\n\[email protected](\"model_class, X, y, kernel, likelihood\", _TEST_CASES(), ids=TEST_IDS)\ndef test_forward(model_class, X, y, kernel, likelihood):\n if model_class is SparseGPRegression or model_class is VariationalSparseGP:\n gp = model_class(X, y, kernel, X, likelihood)\n else:\n gp = model_class(X, y, kernel, likelihood)\n\n # test shape\n Xnew = torch.tensor([[2.0, 3.0, 1.0]])\n loc0, cov0 = gp(Xnew, full_cov=True)\n loc1, var1 = gp(Xnew, full_cov=False)\n assert loc0.dim() == y.dim()\n assert loc0.shape[-1] == Xnew.shape[0]\n # test latent shape\n assert loc0.shape[:-1] == y.shape[:-1]\n assert cov0.shape[:-2] == y.shape[:-1]\n assert cov0.shape[-1] == cov0.shape[-2]\n assert cov0.shape[-1] == Xnew.shape[0]\n assert_equal(loc0, loc1)\n n = Xnew.shape[0]\n cov0_diag = torch.stack([mat.diag() for mat in cov0.view(-1, n, n)]).reshape(var1.shape)\n assert_equal(cov0_diag, var1)\n\n # test trivial forward: Xnew = X\n loc, cov = gp(X, full_cov=True)\n if model_class is VariationalGP or model_class is VariationalSparseGP:\n assert_equal(loc.norm().item(), 0)\n assert_equal(cov, torch.eye(cov.shape[-1]).expand(cov.shape))\n else:\n assert_equal(loc, y)\n assert_equal(cov.norm().item(), 0)\n\n # test same input forward: Xnew[0,:] = Xnew[1,:] = ...\n Xnew = torch.tensor([[2.0, 3.0, 1.0]]).expand(10, 3)\n loc, cov = gp(Xnew, full_cov=True)\n loc_diff = loc - loc[..., :1].expand(y.shape[:-1] + (10,))\n assert_equal(loc_diff.norm().item(), 0)\n cov_diff = cov - cov[..., :1, :1].expand(y.shape[:-1] + (10, 10))\n assert_equal(cov_diff.norm().item(), 0)\n\n # test noise kernel forward: kernel = WhiteNoise\n gp.kernel = WhiteNoise(input_dim=3, variance=torch.tensor(10.))\n loc, cov = gp(X, full_cov=True)\n assert_equal(loc.norm().item(), 0)\n assert_equal(cov, torch.eye(cov.shape[-1]).expand(cov.shape) * 10)\n\n\[email protected](\"model_class, X, y, kernel, likelihood\", _TEST_CASES(), ids=TEST_IDS)\ndef test_forward_with_empty_latent_shape(model_class, X, y, kernel, likelihood):\n # regression models don't use latent_shape, no need for test\n if model_class is GPRegression or model_class is SparseGPRegression:\n return\n elif model_class is VariationalGP:\n gp = model_class(X, y, kernel, likelihood, latent_shape=torch.Size([]))\n else: # model_class is VariationalSparseGP\n gp = model_class(X, y, kernel, X, likelihood, latent_shape=torch.Size([]))\n\n # test shape\n Xnew = torch.tensor([[2.0, 3.0, 1.0]])\n loc0, cov0 = gp(Xnew, full_cov=True)\n loc1, var1 = gp(Xnew, full_cov=False)\n assert loc0.shape[-1] == Xnew.shape[0]\n assert cov0.shape[-1] == cov0.shape[-2]\n assert cov0.shape[-1] == Xnew.shape[0]\n # test latent shape\n assert loc0.shape[:-1] == torch.Size([])\n assert cov0.shape[:-2] == torch.Size([])\n assert_equal(loc0, loc1)\n assert_equal(cov0.diag(), var1)\n\n\[email protected](\"model_class, X, y, kernel, likelihood\", _TEST_CASES(), ids=TEST_IDS)\[email protected](rng_seed=0)\ndef test_inference(model_class, X, y, kernel, likelihood):\n # skip variational GP models because variance/lengthscale highly\n # depend on variational parameters\n if model_class is VariationalGP or model_class is VariationalSparseGP:\n return\n elif model_class is GPRegression:\n gp = model_class(X, y, RBF(input_dim=3), likelihood)\n else: # model_class is SparseGPRegression\n gp = model_class(X, y, RBF(input_dim=3), X, likelihood)\n # fix inducing points because variance/lengthscale highly depend on it\n gp.Xu.requires_grad_(False)\n\n generator = dist.MultivariateNormal(torch.zeros(X.shape[0]), kernel(X))\n target_y = generator(sample_shape=torch.Size([1000])).detach()\n gp.set_data(X, target_y)\n\n train(gp)\n\n y_cov = gp.kernel(X)\n target_y_cov = kernel(X)\n assert_equal(y_cov, target_y_cov, prec=0.1)\n\n\[email protected](rng_seed=0)\ndef test_inference_sgpr():\n N = 1000\n X = dist.Uniform(torch.zeros(N), torch.ones(N)*5).sample()\n y = 0.5 * torch.sin(3*X) + dist.Normal(torch.zeros(N), torch.ones(N)*0.5).sample()\n kernel = RBF(input_dim=1)\n Xu = torch.arange(0., 5.5, 0.5)\n\n sgpr = SparseGPRegression(X, y, kernel, Xu)\n train(sgpr)\n\n Xnew = torch.arange(0., 5.05, 0.05)\n loc, var = sgpr(Xnew, full_cov=False)\n target = 0.5 * torch.sin(3*Xnew)\n\n assert_equal((loc - target).abs().mean().item(), 0, prec=0.07)\n\n\[email protected](rng_seed=0)\ndef test_inference_vsgp():\n N = 1000\n X = dist.Uniform(torch.zeros(N), torch.ones(N)*5).sample()\n y = 0.5 * torch.sin(3*X) + dist.Normal(torch.zeros(N), torch.ones(N)*0.5).sample()\n kernel = RBF(input_dim=1)\n Xu = torch.arange(0., 5.5, 0.5)\n\n vsgp = VariationalSparseGP(X, y, kernel, Xu, Gaussian())\n optimizer = torch.optim.Adam(vsgp.parameters(), lr=0.03)\n train(vsgp, optimizer)\n\n Xnew = torch.arange(0., 5.05, 0.05)\n loc, var = vsgp(Xnew, full_cov=False)\n target = 0.5 * torch.sin(3*Xnew)\n\n assert_equal((loc - target).abs().mean().item(), 0, prec=0.06)\n\n\[email protected](rng_seed=0)\ndef test_inference_whiten_vsgp():\n N = 1000\n X = dist.Uniform(torch.zeros(N), torch.ones(N)*5).sample()\n y = 0.5 * torch.sin(3*X) + dist.Normal(torch.zeros(N), torch.ones(N)*0.5).sample()\n kernel = RBF(input_dim=1)\n Xu = torch.arange(0., 5.5, 0.5)\n\n vsgp = VariationalSparseGP(X, y, kernel, Xu, Gaussian(), whiten=True)\n train(vsgp)\n\n Xnew = torch.arange(0., 5.05, 0.05)\n loc, var = vsgp(Xnew, full_cov=False)\n target = 0.5 * torch.sin(3*Xnew)\n\n assert_equal((loc - target).abs().mean().item(), 0, prec=0.07)\n\n\[email protected](\"model_class, X, y, kernel, likelihood\", _TEST_CASES(), ids=TEST_IDS)\ndef test_inference_with_empty_latent_shape(model_class, X, y, kernel, likelihood):\n # regression models don't use latent_shape (default=torch.Size([]))\n if model_class is GPRegression or model_class is SparseGPRegression:\n return\n elif model_class is VariationalGP:\n gp = model_class(X, y, kernel, likelihood, latent_shape=torch.Size([]))\n else: # model_class is SparseVariationalGP\n gp = model_class(X, y, kernel, X.clone(), likelihood, latent_shape=torch.Size([]))\n\n train(gp, num_steps=1)\n\n\[email protected](\"model_class, X, y, kernel, likelihood\", _TEST_CASES(), ids=TEST_IDS)\ndef test_inference_with_whiten(model_class, X, y, kernel, likelihood):\n # regression models don't use whiten\n if model_class is GPRegression or model_class is SparseGPRegression:\n return\n elif model_class is VariationalGP:\n gp = model_class(X, y, kernel, likelihood, whiten=True)\n else: # model_class is SparseVariationalGP\n gp = model_class(X, y, kernel, X.clone(), likelihood, whiten=True)\n\n train(gp, num_steps=1)\n\n\[email protected](\"model_class, X, y, kernel, likelihood\", _TEST_CASES(), ids=TEST_IDS)\ndef test_hmc(model_class, X, y, kernel, likelihood):\n if model_class is SparseGPRegression or model_class is VariationalSparseGP:\n gp = model_class(X, y, kernel, X.clone(), likelihood)\n else:\n gp = model_class(X, y, kernel, likelihood)\n\n if model_class is GPRegression:\n model_name = \"GPR\"\n elif model_class is SparseGPRegression:\n model_name = \"SGPR\"\n elif model_class is VariationalGP:\n model_name = \"VGP\"\n else:\n model_name = \"VSGP\"\n\n kernel.set_prior(\"variance\", dist.Uniform(torch.tensor(0.5), torch.tensor(1.5)))\n kernel.set_prior(\"lengthscale\", dist.Uniform(torch.tensor(1.0), torch.tensor(3.0)))\n\n hmc_kernel = HMC(gp.model, step_size=1)\n mcmc_run = MCMC(hmc_kernel, num_samples=10)\n\n post_trace = defaultdict(list)\n for trace, _ in mcmc_run._traces():\n variance_name = \"{}/RBF/variance\".format(model_name)\n post_trace[\"variance\"].append(trace.nodes[variance_name][\"value\"])\n lengthscale_name = \"{}/RBF/lengthscale\".format(model_name)\n post_trace[\"lengthscale\"].append(trace.nodes[lengthscale_name][\"value\"])\n if model_class is VariationalGP:\n f_name = \"VGP/f\"\n post_trace[\"f\"].append(trace.nodes[f_name][\"value\"])\n if model_class is VariationalSparseGP:\n u_name = \"VSGP/u\"\n post_trace[\"u\"].append(trace.nodes[u_name][\"value\"])\n\n for param in post_trace:\n param_mean = torch.mean(torch.stack(post_trace[param]), 0)\n logger.info(\"Posterior mean - {}\".format(param))\n logger.info(param_mean)\n\n\ndef test_inference_deepGP():\n gp1 = GPRegression(X, None, RBF(input_dim=3, variance=torch.tensor(3.),\n lengthscale=torch.tensor(2.)))\n Z, _ = gp1.model()\n gp2 = VariationalSparseGP(Z, y2D, Matern32(input_dim=3), Z.clone(),\n Gaussian(torch.tensor(1e-6)))\n\n class DeepGP(torch.nn.Module):\n def __init__(self, gp1, gp2):\n super(DeepGP, self).__init__()\n self.gp1 = gp1\n self.gp2 = gp2\n\n def model(self):\n Z, _ = self.gp1.model()\n self.gp2.set_data(Z, y2D)\n self.gp2.model()\n\n def guide(self):\n self.gp1.guide()\n self.gp2.guide()\n\n deepgp = DeepGP(gp1, gp2)\n train(deepgp, num_steps=1)\n\n\[email protected](\"model_class, X, y, kernel, likelihood\", _TEST_CASES(), ids=TEST_IDS)\ndef test_gplvm(model_class, X, y, kernel, likelihood):\n if model_class is SparseGPRegression or model_class is VariationalSparseGP:\n gp = model_class(X, y, kernel, X.clone(), likelihood)\n else:\n gp = model_class(X, y, kernel, likelihood)\n\n gplvm = GPLVM(gp)\n # test inference\n train(gplvm, num_steps=1)\n # test forward\n gplvm(Xnew=X)\n\n\ndef _pre_test_mean_function():\n def f(x):\n return 2 * x + 3 + 5 * torch.sin(7 * x)\n\n X = torch.arange(100, dtype=torch.Tensor().dtype)\n y = f(X)\n Xnew = torch.arange(100, 150, dtype=torch.Tensor().dtype)\n ynew = f(Xnew)\n\n kernel = Cosine(input_dim=1)\n\n class Trend(torch.nn.Module):\n def __init__(self):\n super(Trend, self).__init__()\n self.a = torch.nn.Parameter(torch.tensor(0.))\n self.b = torch.nn.Parameter(torch.tensor(1.))\n\n def forward(self, x):\n return self.a * x + self.b\n\n trend = Trend()\n return X, y, Xnew, ynew, kernel, trend\n\n\ndef _mape(y_true, y_pred):\n return ((y_pred - y_true) / y_true).abs().mean()\n\n\ndef _post_test_mean_function(gpmodule, Xnew, y_true):\n assert_equal(gpmodule.mean_function.a.item(), 2, prec=0.02)\n assert_equal(gpmodule.mean_function.b.item(), 3, prec=0.02)\n\n y_pred, _ = gpmodule(Xnew)\n assert_equal(_mape(y_true, y_pred).item(), 0, prec=0.02)\n\n\ndef test_mean_function_GPR():\n X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()\n gpmodule = GPRegression(X, y, kernel, mean_function=mean_fn)\n train(gpmodule)\n _post_test_mean_function(gpmodule, Xnew, ynew)\n\n\ndef test_mean_function_SGPR():\n X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()\n Xu = X[::20].clone()\n gpmodule = SparseGPRegression(X, y, kernel, Xu, mean_function=mean_fn)\n train(gpmodule)\n _post_test_mean_function(gpmodule, Xnew, ynew)\n\n\ndef test_mean_function_SGPR_DTC():\n X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()\n Xu = X[::20].clone()\n gpmodule = SparseGPRegression(X, y, kernel, Xu, mean_function=mean_fn, approx=\"DTC\")\n train(gpmodule)\n _post_test_mean_function(gpmodule, Xnew, ynew)\n\n\ndef test_mean_function_SGPR_FITC():\n X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()\n Xu = X[::20].clone()\n gpmodule = SparseGPRegression(X, y, kernel, Xu, mean_function=mean_fn, approx=\"FITC\")\n train(gpmodule)\n _post_test_mean_function(gpmodule, Xnew, ynew)\n\n\ndef test_mean_function_VGP():\n X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()\n likelihood = Gaussian()\n gpmodule = VariationalGP(X, y, kernel, likelihood, mean_function=mean_fn)\n train(gpmodule)\n _post_test_mean_function(gpmodule, Xnew, ynew)\n\n\ndef test_mean_function_VGP_whiten():\n X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()\n likelihood = Gaussian()\n gpmodule = VariationalGP(X, y, kernel, likelihood, mean_function=mean_fn,\n whiten=True)\n optimizer = torch.optim.Adam(gpmodule.parameters(), lr=0.1)\n train(gpmodule, optimizer)\n _post_test_mean_function(gpmodule, Xnew, ynew)\n\n\ndef test_mean_function_VSGP():\n X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()\n Xu = X[::20].clone()\n likelihood = Gaussian()\n gpmodule = VariationalSparseGP(X, y, kernel, Xu, likelihood, mean_function=mean_fn)\n optimizer = torch.optim.Adam(gpmodule.parameters(), lr=0.02)\n train(gpmodule, optimizer)\n _post_test_mean_function(gpmodule, Xnew, ynew)\n\n\ndef test_mean_function_VSGP_whiten():\n X, y, Xnew, ynew, kernel, mean_fn = _pre_test_mean_function()\n Xu = X[::20].clone()\n likelihood = Gaussian()\n gpmodule = VariationalSparseGP(X, y, kernel, Xu, likelihood, mean_function=mean_fn,\n whiten=True)\n optimizer = torch.optim.Adam(gpmodule.parameters(), lr=0.1)\n train(gpmodule, optimizer)\n _post_test_mean_function(gpmodule, Xnew, ynew)\n",
"from __future__ import absolute_import, division, print_function\n\nimport math\nimport torch\n\nimport pyro\nfrom pyro import poutine\nfrom pyro.contrib.autoguide import mean_field_guide_entropy\nfrom pyro.contrib.oed.search import Search\nfrom pyro.contrib.util import lexpand\nfrom pyro.infer import EmpiricalMarginal, Importance, SVI\nfrom pyro.util import torch_isnan, torch_isinf\n\n\ndef vi_ape(model, design, observation_labels, target_labels,\n vi_parameters, is_parameters, y_dist=None):\n \"\"\"Estimates the average posterior entropy (APE) loss function using\n variational inference (VI).\n\n The APE loss function estimated by this method is defined as\n\n :math:`APE(d)=E_{Y\\\\sim p(y|\\\\theta, d)}[H(p(\\\\theta|Y, d))]`\n\n where :math:`H[p(x)]` is the `differential entropy\n <https://en.wikipedia.org/wiki/Differential_entropy>`_.\n The APE is related to expected information gain (EIG) by the equation\n\n :math:`EIG(d)=H[p(\\\\theta)]-APE(d)`\n\n in particular, minimising the APE is equivalent to maximising EIG.\n\n :param function model: A pyro model accepting `design` as only argument.\n :param torch.Tensor design: Tensor representation of design\n :param list observation_labels: A subset of the sample sites\n present in `model`. These sites are regarded as future observations\n and other sites are regarded as latent variables over which a\n posterior is to be inferred.\n :param list target_labels: A subset of the sample sites over which the posterior\n entropy is to be measured.\n :param dict vi_parameters: Variational inference parameters which should include:\n `optim`: an instance of :class:`pyro.Optim`, `guide`: a guide function\n compatible with `model`, `num_steps`: the number of VI steps to make,\n and `loss`: the loss function to use for VI\n :param dict is_parameters: Importance sampling parameters for the\n marginal distribution of :math:`Y`. May include `num_samples`: the number\n of samples to draw from the marginal.\n :param pyro.distributions.Distribution y_dist: (optional) the distribution\n assumed for the response variable :math:`Y`\n :return: Loss function estimate\n :rtype: `torch.Tensor`\n\n \"\"\"\n\n if isinstance(observation_labels, str):\n observation_labels = [observation_labels]\n if target_labels is not None and isinstance(target_labels, str):\n target_labels = [target_labels]\n\n def posterior_entropy(y_dist, design):\n # Important that y_dist is sampled *within* the function\n y = pyro.sample(\"conditioning_y\", y_dist)\n y_dict = {label: y[i, ...] for i, label in enumerate(observation_labels)}\n conditioned_model = pyro.condition(model, data=y_dict)\n SVI(conditioned_model, **vi_parameters).run(design)\n # Recover the entropy\n return mean_field_guide_entropy(vi_parameters[\"guide\"], [design], whitelist=target_labels)\n\n if y_dist is None:\n y_dist = EmpiricalMarginal(Importance(model, **is_parameters).run(design),\n sites=observation_labels)\n\n # Calculate the expected posterior entropy under this distn of y\n loss_dist = EmpiricalMarginal(Search(posterior_entropy).run(y_dist, design))\n loss = loss_dist.mean\n\n return loss\n\n\ndef naive_rainforth_eig(model, design, observation_labels, target_labels=None,\n N=100, M=10, M_prime=None):\n \"\"\"\n Naive Rainforth (i.e. Nested Monte Carlo) estimate of the expected information\n gain (EIG). The estimate is\n\n .. math::\n\n \\\\frac{1}{N}\\\\sum_{n=1}^N \\\\log p(y_n | \\\\theta_n, d) -\n \\\\log \\\\left(\\\\frac{1}{M}\\\\sum_{m=1}^M p(y_n | \\\\theta_m, d)\\\\right)\n\n Monte Carlo estimation is attempted for the :math:`\\\\log p(y | \\\\theta, d)` term if\n the parameter `M_prime` is passed. Otherwise, it is assumed that that :math:`\\\\log p(y | \\\\theta, d)`\n can safely be read from the model itself.\n\n :param function model: A pyro model accepting `design` as only argument.\n :param torch.Tensor design: Tensor representation of design\n :param list observation_labels: A subset of the sample sites\n present in `model`. These sites are regarded as future observations\n and other sites are regarded as latent variables over which a\n posterior is to be inferred.\n :param list target_labels: A subset of the sample sites over which the posterior\n entropy is to be measured.\n :param int N: Number of outer expectation samples.\n :param int M: Number of inner expectation samples for `p(y|d)`.\n :param int M_prime: Number of samples for `p(y | theta, d)` if required.\n :return: EIG estimate\n :rtype: `torch.Tensor`\n \"\"\"\n\n if isinstance(observation_labels, str):\n observation_labels = [observation_labels]\n if isinstance(target_labels, str):\n target_labels = [target_labels]\n\n # Take N samples of the model\n expanded_design = lexpand(design, N)\n trace = poutine.trace(model).get_trace(expanded_design)\n trace.compute_log_prob()\n\n if M_prime is not None:\n y_dict = {l: lexpand(trace.nodes[l][\"value\"], M_prime) for l in observation_labels}\n theta_dict = {l: lexpand(trace.nodes[l][\"value\"], M_prime) for l in target_labels}\n theta_dict.update(y_dict)\n # Resample M values of u and compute conditional probabilities\n conditional_model = pyro.condition(model, data=theta_dict)\n # Not acceptable to use (M_prime, 1) here - other variables may occur after\n # theta, so need to be sampled conditional upon it\n reexpanded_design = lexpand(design, M_prime, N)\n retrace = poutine.trace(conditional_model).get_trace(reexpanded_design)\n retrace.compute_log_prob()\n conditional_lp = sum(retrace.nodes[l][\"log_prob\"] for l in observation_labels).logsumexp(0) \\\n - math.log(M_prime)\n else:\n # This assumes that y are independent conditional on theta\n # Furthermore assume that there are no other variables besides theta\n conditional_lp = sum(trace.nodes[l][\"log_prob\"] for l in observation_labels)\n\n y_dict = {l: lexpand(trace.nodes[l][\"value\"], M) for l in observation_labels}\n # Resample M values of theta and compute conditional probabilities\n conditional_model = pyro.condition(model, data=y_dict)\n # Using (M, 1) instead of (M, N) - acceptable to re-use thetas between ys because\n # theta comes before y in graphical model\n reexpanded_design = lexpand(design, M, 1)\n retrace = poutine.trace(conditional_model).get_trace(reexpanded_design)\n retrace.compute_log_prob()\n marginal_lp = sum(retrace.nodes[l][\"log_prob\"] for l in observation_labels).logsumexp(0) \\\n - math.log(M)\n\n return (conditional_lp - marginal_lp).sum(0)/N\n\n\ndef donsker_varadhan_eig(model, design, observation_labels, target_labels,\n num_samples, num_steps, T, optim, return_history=False,\n final_design=None, final_num_samples=None):\n \"\"\"\n Donsker-Varadhan estimate of the expected information gain (EIG).\n\n The Donsker-Varadhan representation of EIG is\n\n .. math::\n\n \\\\sup_T E_{p(y, \\\\theta | d)}[T(y, \\\\theta)] - \\\\log E_{p(y|d)p(\\\\theta)}[\\\\exp(T(\\\\bar{y}, \\\\bar{\\\\theta}))]\n\n where :math:`T` is any (measurable) function.\n\n This methods optimises the loss function over a pre-specified class of\n functions `T`.\n\n :param function model: A pyro model accepting `design` as only argument.\n :param torch.Tensor design: Tensor representation of design\n :param list observation_labels: A subset of the sample sites\n present in `model`. These sites are regarded as future observations\n and other sites are regarded as latent variables over which a\n posterior is to be inferred.\n :param list target_labels: A subset of the sample sites over which the posterior\n entropy is to be measured.\n :param int num_samples: Number of samples per iteration.\n :param int num_steps: Number of optimisation steps.\n :param function or torch.nn.Module T: optimisable function `T` for use in the\n Donsker-Varadhan loss function.\n :param pyro.optim.Optim optim: Optimiser to use.\n :param bool return_history: If `True`, also returns a tensor giving the loss function\n at each step of the optimisation.\n :param torch.Tensor final_design: The final design tensor to evaluate at. If `None`, uses\n `design`.\n :param int final_num_samples: The number of samples to use at the final evaluation, If `None,\n uses `num_samples`.\n :return: EIG estimate, optionally includes full optimisatio history\n :rtype: `torch.Tensor` or `tuple`\n \"\"\"\n if isinstance(observation_labels, str):\n observation_labels = [observation_labels]\n if isinstance(target_labels, str):\n target_labels = [target_labels]\n loss = donsker_varadhan_loss(model, T, observation_labels, target_labels)\n return opt_eig_ape_loss(design, loss, num_samples, num_steps, optim, return_history,\n final_design, final_num_samples)\n\n\ndef barber_agakov_ape(model, design, observation_labels, target_labels,\n num_samples, num_steps, guide, optim, return_history=False,\n final_design=None, final_num_samples=None):\n \"\"\"\n Barber-Agakov estimate of average posterior entropy (APE).\n\n The Barber-Agakov representation of APE is\n\n :math:`sup_{q}E_{p(y, \\\\theta | d)}[\\\\log q(\\\\theta | y, d)]`\n\n where :math:`q` is any distribution on :math:`\\\\theta`.\n\n This method optimises the loss over a given guide family `guide`\n representing :math:`q`.\n\n :param function model: A pyro model accepting `design` as only argument.\n :param torch.Tensor design: Tensor representation of design\n :param list observation_labels: A subset of the sample sites\n present in `model`. These sites are regarded as future observations\n and other sites are regarded as latent variables over which a\n posterior is to be inferred.\n :param list target_labels: A subset of the sample sites over which the posterior\n entropy is to be measured.\n :param int num_samples: Number of samples per iteration.\n :param int num_steps: Number of optimisation steps.\n :param function guide: guide family for use in the (implicit) posterior estimation.\n The parameters of `guide` are optimised to maximise the Barber-Agakov\n objective.\n :param pyro.optim.Optim optim: Optimiser to use.\n :param bool return_history: If `True`, also returns a tensor giving the loss function\n at each step of the optimisation.\n :param torch.Tensor final_design: The final design tensor to evaluate at. If `None`, uses\n `design`.\n :param int final_num_samples: The number of samples to use at the final evaluation, If `None,\n uses `num_samples`.\n :return: EIG estimate, optionally includes full optimisatio history\n :rtype: `torch.Tensor` or `tuple`\n \"\"\"\n if isinstance(observation_labels, str):\n observation_labels = [observation_labels]\n if isinstance(target_labels, str):\n target_labels = [target_labels]\n loss = barber_agakov_loss(model, guide, observation_labels, target_labels)\n return opt_eig_ape_loss(design, loss, num_samples, num_steps, optim, return_history,\n final_design, final_num_samples)\n\n\ndef opt_eig_ape_loss(design, loss_fn, num_samples, num_steps, optim, return_history=False,\n final_design=None, final_num_samples=None):\n\n if final_design is None:\n final_design = design\n if final_num_samples is None:\n final_num_samples = num_samples\n\n params = None\n history = []\n for step in range(num_steps):\n if params is not None:\n pyro.infer.util.zero_grads(params)\n agg_loss, loss = loss_fn(design, num_samples)\n agg_loss.backward()\n if return_history:\n history.append(loss)\n params = [value.unconstrained()\n for value in pyro.get_param_store().values()]\n optim(params)\n _, loss = loss_fn(final_design, final_num_samples)\n if return_history:\n return torch.stack(history), loss\n else:\n return loss\n\n\ndef donsker_varadhan_loss(model, T, observation_labels, target_labels):\n\n ewma_log = EwmaLog(alpha=0.90)\n\n try:\n pyro.module(\"T\", T)\n except AssertionError:\n pass\n\n def loss_fn(design, num_particles):\n\n expanded_design = lexpand(design, num_particles)\n\n # Unshuffled data\n unshuffled_trace = poutine.trace(model).get_trace(expanded_design)\n y_dict = {l: unshuffled_trace.nodes[l][\"value\"] for l in observation_labels}\n\n # Shuffled data\n # Not actually shuffling, resimulate for safety\n conditional_model = pyro.condition(model, data=y_dict)\n shuffled_trace = poutine.trace(conditional_model).get_trace(expanded_design)\n\n T_joint = T(expanded_design, unshuffled_trace, observation_labels,\n target_labels)\n T_independent = T(expanded_design, shuffled_trace, observation_labels,\n target_labels)\n\n joint_expectation = T_joint.sum(0)/num_particles\n\n A = T_independent - math.log(num_particles)\n s, _ = torch.max(A, dim=0)\n independent_expectation = s + ewma_log((A - s).exp().sum(dim=0), s)\n\n loss = joint_expectation - independent_expectation\n # Switch sign, sum over batch dimensions for scalar loss\n agg_loss = -loss.sum()\n return agg_loss, loss\n\n return loss_fn\n\n\ndef barber_agakov_loss(model, guide, observation_labels, target_labels):\n\n def loss_fn(design, num_particles):\n\n expanded_design = lexpand(design, num_particles)\n\n # Sample from p(y, theta | d)\n trace = poutine.trace(model).get_trace(expanded_design)\n y_dict = {l: trace.nodes[l][\"value\"] for l in observation_labels}\n theta_dict = {l: trace.nodes[l][\"value\"] for l in target_labels}\n\n # Run through q(theta | y, d)\n conditional_guide = pyro.condition(guide, data=theta_dict)\n cond_trace = poutine.trace(conditional_guide).get_trace(\n y_dict, expanded_design, observation_labels, target_labels)\n cond_trace.compute_log_prob()\n\n loss = -sum(cond_trace.nodes[l][\"log_prob\"] for l in target_labels).sum(0)/num_particles\n agg_loss = loss.sum()\n return agg_loss, loss\n\n return loss_fn\n\n\nclass _EwmaLogFn(torch.autograd.Function):\n @staticmethod\n def forward(ctx, input, ewma):\n ctx.save_for_backward(ewma)\n return input.log()\n\n @staticmethod\n def backward(ctx, grad_output):\n ewma, = ctx.saved_tensors\n return grad_output / ewma, None\n\n\n_ewma_log_fn = _EwmaLogFn.apply\n\n\nclass EwmaLog(object):\n \"\"\"Logarithm function with exponentially weighted moving average\n for gradients.\n\n For input `inputs` this function return :code:`inputs.log()`. However, it\n computes the gradient as\n\n :math:`\\\\frac{\\\\sum_{t=0}^{T-1} \\\\alpha^t}{\\\\sum_{t=0}^{T-1} \\\\alpha^t x_{T-t}}`\n\n where :math:`x_t` are historical input values passed to this function,\n :math:`x_T` being the most recently seen value.\n\n This gradient may help with numerical stability when the sequence of\n inputs to the function form a convergent sequence.\n \"\"\"\n\n def __init__(self, alpha):\n self.alpha = alpha\n self.ewma = 0.\n self.n = 0\n self.s = 0.\n\n def __call__(self, inputs, s, dim=0, keepdim=False):\n \"\"\"Updates the moving average, and returns :code:`inputs.log()`.\n \"\"\"\n self.n += 1\n if torch_isnan(self.ewma) or torch_isinf(self.ewma):\n ewma = inputs\n else:\n ewma = inputs * (1. - self.alpha) / (1 - self.alpha**self.n) \\\n + torch.exp(self.s - s) * self.ewma \\\n * (self.alpha - self.alpha**self.n) / (1 - self.alpha**self.n)\n self.ewma = ewma.detach()\n self.s = s.detach()\n return _ewma_log_fn(inputs, ewma)\n",
"from __future__ import absolute_import, division, print_function\n\nimport torch\n\nfrom pyro.distributions.torch import Beta, Dirichlet, Gamma\nfrom pyro.distributions.util import copy_docs_from\n\n\n@copy_docs_from(Dirichlet)\nclass NaiveDirichlet(Dirichlet):\n \"\"\"\n Implementation of ``Dirichlet`` via ``Gamma``.\n\n This naive implementation has stochastic reparameterized gradients, which\n have higher variance than PyTorch's ``Dirichlet`` implementation.\n \"\"\"\n def __init__(self, concentration, validate_args=None):\n super(NaiveDirichlet, self).__init__(concentration)\n self._gamma = Gamma(concentration, torch.ones_like(concentration), validate_args=validate_args)\n\n def rsample(self, sample_shape=torch.Size()):\n gammas = self._gamma.rsample(sample_shape)\n return gammas / gammas.sum(-1, True)\n\n\n@copy_docs_from(Beta)\nclass NaiveBeta(Beta):\n \"\"\"\n Implementation of ``Beta`` via ``Gamma``.\n\n This naive implementation has stochastic reparameterized gradients, which\n have higher variance than PyTorch's ``Beta`` implementation.\n \"\"\"\n def __init__(self, concentration1, concentration0, validate_args=None):\n super(NaiveBeta, self).__init__(concentration1, concentration0, validate_args=validate_args)\n alpha_beta = torch.stack([concentration1, concentration0], -1)\n self._gamma = Gamma(alpha_beta, torch.ones_like(alpha_beta))\n\n def rsample(self, sample_shape=torch.Size()):\n gammas = self._gamma.rsample(sample_shape)\n probs = gammas / gammas.sum(-1, True)\n return probs[..., 0]\n",
"from __future__ import absolute_import, division, print_function\n\nimport math\n\nimport torch\nfrom torch.distributions import constraints\nfrom torch.nn import Parameter\n\nfrom .isotropic import Isotropy\nfrom .kernel import Kernel\n\n\nclass Cosine(Isotropy):\n r\"\"\"\n Implementation of Cosine kernel:\n\n :math:`k(x,z) = \\sigma^2 \\cos\\left(\\frac{|x-z|}{l}\\right).`\n\n :param torch.Tensor lengthscale: Length-scale parameter of this kernel.\n \"\"\"\n def __init__(self, input_dim, variance=None, lengthscale=None, active_dims=None):\n super(Cosine, self).__init__(input_dim, variance, lengthscale, active_dims)\n\n def forward(self, X, Z=None, diag=False):\n if diag:\n return self._diag(X)\n\n r = self._scaled_dist(X, Z)\n return self.variance * torch.cos(r)\n\n\nclass Periodic(Kernel):\n r\"\"\"\n Implementation of Periodic kernel:\n\n :math:`k(x,z)=\\sigma^2\\exp\\left(-2\\times\\frac{\\sin^2(\\pi(x-z)/p)}{l^2}\\right),`\n\n where :math:`p` is the ``period`` parameter.\n\n References:\n\n [1] `Introduction to Gaussian processes`,\n David J.C. MacKay\n\n :param torch.Tensor lengthscale: Length scale parameter of this kernel.\n :param torch.Tensor period: Period parameter of this kernel.\n \"\"\"\n def __init__(self, input_dim, variance=None, lengthscale=None, period=None, active_dims=None):\n super(Periodic, self).__init__(input_dim, active_dims)\n\n variance = torch.tensor(1.) if variance is None else variance\n self.variance = Parameter(variance)\n self.set_constraint(\"variance\", constraints.positive)\n\n lengthscale = torch.tensor(1.) if lengthscale is None else lengthscale\n self.lengthscale = Parameter(lengthscale)\n self.set_constraint(\"lengthscale\", constraints.positive)\n\n period = torch.tensor(1.) if period is None else period\n self.period = Parameter(period)\n self.set_constraint(\"period\", constraints.positive)\n\n def forward(self, X, Z=None, diag=False):\n if diag:\n return self.variance.expand(X.size(0))\n\n if Z is None:\n Z = X\n X = self._slice_input(X)\n Z = self._slice_input(Z)\n if X.size(1) != Z.size(1):\n raise ValueError(\"Inputs must have the same number of features.\")\n\n d = X.unsqueeze(1) - Z.unsqueeze(0)\n scaled_sin = torch.sin(math.pi * d / self.period) / self.lengthscale\n return self.variance * torch.exp(-2 * (scaled_sin ** 2).sum(-1))\n",
"from __future__ import absolute_import, division, print_function\n\nfrom collections import OrderedDict\n\nimport torch.nn as nn\nfrom torch.distributions import biject_to, constraints, transform_to\nfrom torch.nn import Parameter\n\nimport pyro\nimport pyro.distributions as dist\nfrom pyro.contrib import autoname\nfrom pyro.distributions.util import eye_like\n\n\ndef _get_independent_support(dist_instance):\n # XXX Should we treat the case dist_instance is Independent(Independent(Normal))?\n if isinstance(dist_instance, dist.Independent):\n return dist_instance.base_dist.support\n else:\n return dist_instance.support\n\n\nclass Parameterized(nn.Module):\n \"\"\"\n A wrapper of :class:`torch.nn.Module` whose parameters can be set\n constraints, set priors.\n\n Under the hood, we move parameters to a buffer store and create \"root\"\n parameters which are used to generate that parameter's value. For example,\n if we set a contraint to a parameter, an \"unconstrained\" parameter will be\n created, and the constrained value will be transformed from that\n \"unconstrained\" parameter.\n\n By default, when we set a prior to a parameter, an auto Delta guide will be\n created. We can use the method :meth:`autoguide` to setup other auto guides.\n To fix a parameter to a specific value, it is enough to turn off its \"root\"\n parameters' ``requires_grad`` flags.\n\n Example::\n\n >>> class Linear(Parameterized):\n ... def __init__(self, a, b):\n ... super(Linear, self).__init__()\n ... self.a = Parameter(a)\n ... self.b = Parameter(b)\n ...\n ... def forward(self, x):\n ... return self.a * x + self.b\n ...\n >>> linear = Linear(torch.tensor(1.), torch.tensor(0.))\n >>> linear.set_constraint(\"a\", constraints.positive)\n >>> linear.set_prior(\"b\", dist.Normal(0, 1))\n >>> linear.autoguide(\"b\", dist.Normal)\n >>> assert \"a_unconstrained\" in dict(linear.named_parameters())\n >>> assert \"b_loc\" in dict(linear.named_parameters())\n >>> assert \"b_scale_unconstrained\" in dict(linear.named_parameters())\n >>> assert \"a\" in dict(linear.named_buffers())\n >>> assert \"b\" in dict(linear.named_buffers())\n >>> assert \"b_scale\" in dict(linear.named_buffers())\n\n Note that by default, data of a parameter is a float :class:`torch.Tensor`\n (unless we use :func:`torch.set_default_tensor_type` to change default\n tensor type). To cast these parameters to a correct data type or GPU device,\n we can call methods such as :meth:`~torch.nn.Module.double` or\n :meth:`~torch.nn.Module.cuda`. See :class:`torch.nn.Module` for more\n information.\n \"\"\"\n def __init__(self):\n super(Parameterized, self).__init__()\n self._constraints = OrderedDict()\n self._priors = OrderedDict()\n self._guides = OrderedDict()\n self._mode = None\n\n def set_constraint(self, name, constraint):\n \"\"\"\n Sets the constraint of an existing parameter.\n\n :param str name: Name of the parameter.\n :param ~constraints.Constraint constraint: A PyTorch constraint. See\n :mod:`torch.distributions.constraints` for a list of constraints.\n \"\"\"\n if constraint in [constraints.real, constraints.real_vector]:\n if name in self._constraints: # delete previous constraints\n self._constraints.pop(name, None)\n self._parameters.pop(\"{}_unconstrained\".format(name))\n\n if name not in self._priors:\n # no prior -> no guide\n # so we can move param back from buffer\n p = Parameter(self._buffers.pop(name).detach())\n self.register_parameter(name, p)\n return\n\n if name in self._priors:\n raise ValueError(\"Parameter {} already has a prior. Can not set a constraint for it.\"\n .format(name))\n\n if name in self._parameters:\n p = self._parameters.pop(name)\n elif name in self._buffers:\n p = self._buffers[name]\n else:\n raise ValueError(\"There is no parameter with name: {}\".format(name))\n\n p_unconstrained = Parameter(transform_to(constraint).inv(p).detach())\n self.register_parameter(\"{}_unconstrained\".format(name), p_unconstrained)\n # due to precision issue, we might get f(f^-1(x)) != x\n # so it is necessary to transform back\n p = transform_to(constraint)(p_unconstrained)\n self.register_buffer(name, p.detach())\n self._constraints[name] = constraint\n\n def set_prior(self, name, prior):\n \"\"\"\n Sets the constraint of an existing parameter.\n\n :param str name: Name of the parameter.\n :param ~pyro.distributions.distribution.Distribution prior: A Pyro prior\n distribution.\n \"\"\"\n if name in self._parameters:\n # move param to _buffers\n p = self._parameters.pop(name)\n self.register_buffer(name, p)\n elif name not in self._buffers:\n raise ValueError(\"There is no parameter with name: {}\".format(name))\n\n self._priors[name] = prior\n # remove the constraint and its unconstrained parameter\n self.set_constraint(name, constraints.real)\n\n self.autoguide(name, dist.Delta)\n\n def autoguide(self, name, dist_constructor):\n \"\"\"\n Sets an autoguide for an existing parameter with name ``name`` (mimic\n the behavior of module :mod:`pyro.contrib.autoguide`).\n\n .. note:: `dist_constructor` should be one of\n :class:`~pyro.distributions.Delta`,\n :class:`~pyro.distributions.Normal`, and\n :class:`~pyro.distributions.MultivariateNormal`. More distribution\n constructor will be supported in the future if needed.\n\n :param str name: Name of the parameter.\n :param dist_constructor: A\n :class:`~pyro.distributions.distribution.Distribution` constructor.\n \"\"\"\n if name not in self._priors:\n raise ValueError(\"There is no prior for parameter: {}\".format(name))\n\n if dist_constructor not in [dist.Delta, dist.Normal, dist.MultivariateNormal]:\n raise NotImplementedError(\"Unsupported distribution type: {}\"\n .format(dist_constructor))\n\n if name in self._guides:\n # delete previous guide's parameters\n dist_args = self._guides[name][1]\n for arg in dist_args:\n arg_name = \"{}_{}\".format(name, arg)\n if arg_name in self._constraints:\n # delete its unconstrained parameter\n self.set_constraint(arg_name, constraints.real)\n delattr(self, arg_name)\n\n # TODO: create a new argument `autoguide_args` to store other args for other\n # constructors. For example, in LowRankMVN, we need argument `rank`.\n p = self._buffers[name]\n if dist_constructor is dist.Delta:\n p_map = Parameter(p.detach())\n self.register_parameter(\"{}_map\".format(name), p_map)\n self.set_constraint(\"{}_map\".format(name), _get_independent_support(self._priors[name]))\n dist_args = {\"map\"}\n elif dist_constructor is dist.Normal:\n loc = Parameter(biject_to(self._priors[name].support).inv(p).detach())\n scale = Parameter(loc.new_ones(loc.shape))\n self.register_parameter(\"{}_loc\".format(name), loc)\n self.register_parameter(\"{}_scale\".format(name), scale)\n dist_args = {\"loc\", \"scale\"}\n elif dist_constructor is dist.MultivariateNormal:\n loc = Parameter(biject_to(self._priors[name].support).inv(p).detach())\n identity = eye_like(loc, loc.size(-1))\n scale_tril = Parameter(identity.repeat(loc.shape[:-1] + (1, 1)))\n self.register_parameter(\"{}_loc\".format(name), loc)\n self.register_parameter(\"{}_scale_tril\".format(name), scale_tril)\n dist_args = {\"loc\", \"scale_tril\"}\n else:\n raise NotImplementedError\n\n if dist_constructor is not dist.Delta:\n # each arg has a constraint, so we set constraints for them\n for arg in dist_args:\n self.set_constraint(\"{}_{}\".format(name, arg),\n dist_constructor.arg_constraints[arg])\n self._guides[name] = (dist_constructor, dist_args)\n\n def set_mode(self, mode):\n \"\"\"\n Sets ``mode`` of this object to be able to use its parameters in\n stochastic functions. If ``mode=\"model\"``, a parameter will get its\n value from its prior. If ``mode=\"guide\"``, the value will be drawn from\n its guide.\n\n .. note:: This method automatically sets ``mode`` for submodules which\n belong to :class:`Parameterized` class.\n\n :param str mode: Either \"model\" or \"guide\".\n \"\"\"\n with autoname.name_count():\n for module in self.modules():\n if isinstance(module, Parameterized):\n module.mode = mode\n\n @property\n def mode(self):\n return self._mode\n\n @mode.setter\n def mode(self, mode):\n self._mode = mode\n # We should get buffer values for constrained params first\n # otherwise, autoguide will use the old buffer for `scale` or `scale_tril`\n for name in self._constraints:\n if name not in self._priors:\n self._register_param(name)\n for name in self._priors:\n self._register_param(name)\n\n def _sample_from_guide(self, name):\n dist_constructor, dist_args = self._guides[name]\n\n if dist_constructor is dist.Delta:\n p_map = getattr(self, \"{}_map\".format(name))\n return pyro.sample(name, dist.Delta(p_map, event_dim=p_map.dim()))\n\n # create guide\n dist_args = {arg: getattr(self, \"{}_{}\".format(name, arg)) for arg in dist_args}\n guide = dist_constructor(**dist_args)\n\n # no need to do transforms when support is real (for mean field ELBO)\n if _get_independent_support(self._priors[name]) is constraints.real:\n return pyro.sample(name, guide.to_event())\n\n # otherwise, we do inference in unconstrained space and transform the value\n # back to original space\n # TODO: move this logic to contrib.autoguide or somewhere else\n unconstrained_value = pyro.sample(\"{}_latent\".format(name), guide.to_event(),\n infer={\"is_auxiliary\": True})\n transform = biject_to(self._priors[name].support)\n value = transform(unconstrained_value)\n log_density = transform.inv.log_abs_det_jacobian(value, unconstrained_value)\n return pyro.sample(name, dist.Delta(value, log_density.sum(), event_dim=value.dim()))\n\n def _register_param(self, name):\n \"\"\"\n In \"model\" mode, lifts the parameter with name ``name`` to a random\n sample using a predefined prior (from :meth:`set_prior` method). In\n \"guide\" mode, we use the guide generated from :meth:`autoguide`.\n\n :param str name: Name of the parameter.\n \"\"\"\n if name in self._priors:\n with autoname.scope(prefix=self._get_name()):\n if self.mode == \"model\":\n p = pyro.sample(name, self._priors[name])\n else:\n p = self._sample_from_guide(name)\n elif name in self._constraints:\n p_unconstrained = self._parameters[\"{}_unconstrained\".format(name)]\n p = transform_to(self._constraints[name])(p_unconstrained)\n self.register_buffer(name, p)\n",
"from __future__ import print_function\n\nimport argparse\n\nimport numpy as np\nimport torch\n\nimport pyro\nfrom pyro.distributions import Normal, Uniform\nfrom pyro.infer import EmpiricalMarginal, Importance\n\n\"\"\"\nSamantha really likes physics---but she likes Pyro even more. Instead of using\ncalculus to do her physics lab homework (which she could easily do), she's going\nto use bayesian inference. The problem setup is as follows. In lab she observed\na little box slide down an inclined plane (length of 2 meters and with an incline of\n30 degrees) 20 times. Each time she measured and recorded the descent time. The timing\ndevice she used has a known measurement error of 20 milliseconds. Using the observed\ndata, she wants to infer the coefficient of friction mu between the box and the inclined\nplane. She already has (deterministic) python code that can simulate the amount of time\nthat it takes the little box to slide down the inclined plane as a function of mu. Using\nPyro, she can reverse the simulator and infer mu from the observed descent times.\n\"\"\"\n\nlittle_g = 9.8 # m/s/s\nmu0 = 0.12 # actual coefficient of friction in the experiment\ntime_measurement_sigma = 0.02 # observation noise in seconds (known quantity)\n\n\n# the forward simulator, which does numerical integration of the equations of motion\n# in steps of size dt, and optionally includes measurement noise\n\ndef simulate(mu, length=2.0, phi=np.pi / 6.0, dt=0.005, noise_sigma=None):\n T = torch.zeros(())\n velocity = torch.zeros(())\n displacement = torch.zeros(())\n acceleration = torch.tensor(little_g * np.sin(phi)) - \\\n torch.tensor(little_g * np.cos(phi)) * mu\n\n if acceleration.numpy() <= 0.0: # the box doesn't slide if the friction is too large\n return torch.tensor(1.0e5) # return a very large time instead of infinity\n\n while displacement.numpy() < length: # otherwise slide to the end of the inclined plane\n displacement += velocity * dt\n velocity += acceleration * dt\n T += dt\n\n if noise_sigma is None:\n return T\n else:\n return T + noise_sigma * torch.randn(())\n\n\n# analytic formula that the simulator above is computing via\n# numerical integration (no measurement noise)\n\ndef analytic_T(mu, length=2.0, phi=np.pi / 6.0):\n numerator = 2.0 * length\n denominator = little_g * (np.sin(phi) - mu * np.cos(phi))\n return np.sqrt(numerator / denominator)\n\n\n# generate N_obs observations using simulator and the true coefficient of friction mu0\nprint(\"generating simulated data using the true coefficient of friction %.3f\" % mu0)\nN_obs = 20\ntorch.manual_seed(2)\nobserved_data = torch.tensor([simulate(torch.tensor(mu0), noise_sigma=time_measurement_sigma)\n for _ in range(N_obs)])\nobserved_mean = np.mean([T.item() for T in observed_data])\n\n\n# define model with uniform prior on mu and gaussian noise on the descent time\ndef model(observed_data):\n mu_prior = Uniform(0.0, 1.0)\n mu = pyro.sample(\"mu\", mu_prior)\n\n def observe_T(T_obs, obs_name):\n T_simulated = simulate(mu)\n T_obs_dist = Normal(T_simulated, torch.tensor(time_measurement_sigma))\n pyro.sample(obs_name, T_obs_dist, obs=T_obs)\n\n for i, T_obs in enumerate(observed_data):\n observe_T(T_obs, \"obs_%d\" % i)\n\n return mu\n\n\ndef main(args):\n # create an importance sampler (the prior is used as the proposal distribution)\n importance = Importance(model, guide=None, num_samples=args.num_samples)\n # get posterior samples of mu (which is the return value of model)\n # from the raw execution traces provided by the importance sampler.\n print(\"doing importance sampling...\")\n emp_marginal = EmpiricalMarginal(importance.run(observed_data))\n\n # calculate statistics over posterior samples\n posterior_mean = emp_marginal.mean\n posterior_std_dev = emp_marginal.variance.sqrt()\n\n # report results\n inferred_mu = posterior_mean.item()\n inferred_mu_uncertainty = posterior_std_dev.item()\n print(\"the coefficient of friction inferred by pyro is %.3f +- %.3f\" %\n (inferred_mu, inferred_mu_uncertainty))\n\n # note that, given the finite step size in the simulator, the simulated descent times will\n # not precisely match the numbers from the analytic result.\n # in particular the first two numbers reported below should match each other pretty closely\n # but will be systematically off from the third number\n print(\"the mean observed descent time in the dataset is: %.4f seconds\" % observed_mean)\n print(\"the (forward) simulated descent time for the inferred (mean) mu is: %.4f seconds\" %\n simulate(posterior_mean).item())\n print((\"disregarding measurement noise, elementary calculus gives the descent time\\n\" +\n \"for the inferred (mean) mu as: %.4f seconds\") % analytic_T(posterior_mean.item()))\n\n \"\"\"\n ################## EXERCISE ###################\n # vectorize the computations in this example! #\n ###############################################\n \"\"\"\n\n\nif __name__ == '__main__':\n assert pyro.__version__.startswith('0.3.1')\n parser = argparse.ArgumentParser(description=\"parse args\")\n parser.add_argument('-n', '--num-samples', default=500, type=int)\n args = parser.parse_args()\n main(args)\n"
] | [
[
"torch.zeros",
"torch.is_tensor",
"torch.tensor",
"torch.rand",
"torch.stack",
"torch.pow"
],
[
"torch.zeros",
"torch.nn.Sigmoid",
"torch.exp",
"torch.nn.LogSigmoid",
"torch.stack"
],
[
"torch.Size",
"torch.ones",
"torch.Tensor",
"torch.sin",
"torch.zeros",
"torch.eye",
"torch.tensor",
"torch.arange",
"torch.stack"
],
[
"torch.stack",
"torch.exp",
"torch.max"
],
[
"torch.stack",
"torch.Size",
"torch.ones_like"
],
[
"torch.nn.Parameter",
"torch.sin",
"torch.cos",
"torch.tensor"
],
[
"torch.distributions.transform_to",
"torch.distributions.biject_to"
],
[
"numpy.sqrt",
"torch.zeros",
"torch.manual_seed",
"torch.randn",
"numpy.cos",
"torch.tensor",
"numpy.sin"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
DLR-SC/memilio | [
"e83243df95e21b5841e3bc077a667fe5446da866"
] | [
"pycode/memilio-epidata/memilio/epidata_test/test_epidata_getCommuterMobility.py"
] | [
"#############################################################################\n# Copyright (C) 2020-2021 German Aerospace Center (DLR-SC)\n#\n# Authors:\n#\n# Contact: Martin J. Kuehn <[email protected]>\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\nfrom pyfakefs import fake_filesystem_unittest\nfrom unittest.mock import patch\nimport unittest\nimport pandas as pd\nimport os\nimport collections\nfrom memilio.epidata import getCommuterMobility as gcm\nfrom memilio.epidata import geoModificationGermany as geoger\nfrom memilio.epidata import getDataIntoPandasDataFrame as gD\nfrom memilio.epidata import getPopulationData as gpd\n\n\nclass TestCommuterMigration(fake_filesystem_unittest.TestCase):\n path = '/home/CMData/'\n\n setup_dict = {'num_counties': 2, 'abs_tol': 100, 'rel_tol': 0.01,\n 'num_govregions': 2, 'counties': 'empty', 'path': path}\n\n test_govkey_list = [\n '01', '02', '031', '032', '033', '034', '04', '051', '053', '055',\n '057', '059']\n\n countykey_list = geoger.get_county_ids(merge_eisenach=False, zfill=True)\n govkey_list = geoger.get_governing_regions()\n\n test_countykey_list = [1001, 1002, 1003, 1004,\n 1051, 1053, 1054, 1055, 1056, 1057, 1058, 3159]\n\n test_countykey_list2 = [1001, 1002, 1003, 1051,\n 1053, 1004, 1055, 1054, 1056, 1057, 1058]\n\n test_countykey2govkey = {'01055': 0, '02000': 1, '03101': 2}\n\n test_countykey2localnumlist = {\n '01001': 0, '01004': 3, '01060': 12, '10045': 4, '11000': 0}\n\n test_state_gov_table = [['01'], ['02'], ['031', '032', '033', '034'], [\n '04'], ['051', '053', '055', '057', '059']]\n\n test_gov_county_table = (\n ['02000'],\n ['05512', '05513', '05515', '05554', '05558', '05562', '05566',\n '05570'],\n ['05711', '05754', '05758', '05762', '05766', '05770', '05774'])\n\n def setUp(self):\n self.setUpPyfakefs()\n\n def write_kreise_deu_data(self, out_folder):\n # sheet 0 is unused in commuter_migration_bfa, but other one has to have index 1\n sheet0 = pd.DataFrame(\n {'0': ['0', '0', '0', '0'], '1': ['1', '2', '3', '4']})\n # 'nothing' strings used to interpret keys as Strings instead of numbers\n sheet1 = pd.DataFrame({'Schlüssel-nummer': ['nothing', '01', '01001', '01053', '02', '02000', '03', '03101',\n '04', '04012', '05', '051', '05112', '053', '05316', '06', '06532',\n '06632', '07', '071', '07141',\n '07235', '08', '081', '0811', '08111', '09', '091', '09181', '10',\n '10044', '11',\n '11000', '12', '12051', '12066', '13', '13003', '14', '145',\n '14511', '15',\n '15082',\n '16', '16069'],\n\n 'Regionale Bezeichnung': ['', 'Schleswig-Holstein', 'Kreisfreie Stadt', 'Kreis',\n 'Hamburg',\n 'Kreisfreie Stadt', 'Niedersachsen', 'Kreisfreie Stadt',\n 'Bremen',\n 'Kreisfreie Stadt', 'Nordrhein-Westfalen',\n 'Reg.-Bez. Düsseldorf',\n 'Kreisfreie Stadt', 'Reg.-Bez. Köln', 'Kreisfreie Stadt',\n 'Hessen', 'Landkreis',\n 'Landkreis', 'Rheinland-Pfalz', 'früher: Reg.-Bez. Koblenz',\n 'Landkreis',\n 'Landkreis', 'Baden-Württemberg', 'Reg.-Bez. Stuttgart',\n 'Region Stuttgart',\n 'Stadtkreis', 'Bayern', 'Reg.-Bez. Oberbayern', 'Landkreis',\n 'Saarland',\n 'Landkreis', 'Berlin', 'Kreisfreie Stadt', 'Brandenburg',\n 'Kreisfreie Stadt',\n 'Landkreis', 'Mecklenburg-Vorpommern', 'Kreisfreie Stadt',\n 'Sachsen', 'Direktionsbezirk Chemnitz',\n 'Kreisfreie Stadt', 'Sachsen-Anhalt', 'Landkreis', 'Thüringen',\n 'Landkreis'],\n\n 'Kreis / Landkreis': ['', '', 'Flensburg, Stadt', 'Herzogtum Lauenburg', '',\n 'Hamburg, Freie und Hansestadt', '', 'Braunschweig, Stadt', '',\n 'Bremerhaven, Stadt', '', '', 'Duisburg, Stadt', '',\n 'Leverkusen, Stadt',\n '', 'Lahn-Dill-Kreis', 'Hersfeld-Rotenburg', '', '',\n 'Rhein-Lahn-Kreis',\n 'Trier-Saarburg', '', '', '', 'Stuttgart, Stadtkreis', '',\n '', 'Landsberg am Lech', '', 'Saarlouis', '', 'Berlin, Stadt', '',\n 'Brandenburg an der Havel, Stadt', 'Oberspreewald-Lausitz', '',\n 'Rostock', '', '', 'Chemnitz, Stadt', '', 'Anhalt-Bitterfeld', '',\n 'Hildburghausen'],\n\n 'NUTS3': ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',\n '0', '0', '0', '0',\n '0', '0',\n '0',\n '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',\n '0', '0', '0',\n '0', '0',\n '0', '0', '0'],\n 'Fläche in km2': ['', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',\n '0', '0', '0',\n '0', '0', '0',\n '0', '0', '0',\n '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',\n '0', '0', '0', '0',\n '0', '0',\n '0', '0', '0'],\n\n 'insgesamt': ['', '', 90164, 198019, '', 1847253, '', 249406, '', 113643, '', '', 498686,\n '', 163729, '',\n 253319, 120719, '', '', 122297, 149398, '', '', '', 635911, '', '', 120302,\n '', 194319, '', 3669491, '', 72184, 109371, '', 209191, '', '', 246334, '',\n 158486,\n '', 63197]})\n\n sheets = {'Deckblatt': sheet0,\n 'Kreisfreie Städte u. Landkreise': sheet1}\n data_path = os.path.join(out_folder, 'kreise_deu.xlsx')\n dummy = pd.ExcelWriter(data_path)\n for sheet_name in sheets.keys():\n sheets[sheet_name].to_excel(\n dummy, sheet_name=sheet_name, index=False)\n dummy.save()\n dummy.close()\n\n def write_commuter_all_federal_states(self, out_folder):\n # just 3rd sheet is interesting\n sheet0 = pd.DataFrame(\n {'0': ['0', '0', '0', '0'], '1': ['1', '2', '3', '4']})\n\n sheet1 = pd.DataFrame({'Arbeitsort': ['nothing', '01001', '', '', '', '', '', '', '', '', '', '', '01053', ''],\n 'Arbeitsort2': ['', 'Flensburg, Stadt', '', '', '', '', '', '', '', '', '', '',\n 'Herzogtum Lauenburg', ''],\n 'Wohnort': ['nothing', '', '01053', '02', '02000', '03', '04', '05',\n '051', '05112', '053', '05316', '', '01001'],\n 'Wohnort2': ['', '', 'Herzogtum Lauenburg', 'Hamburg',\n 'Hamburg, Freie und Hansestadt', 'Niedersachsen', 'Bremen',\n 'Nordrhein-Westfalen', 'Reg.-Bez. Düsseldorf', 'Duisburg, Stadt',\n 'Reg.-Bez. Köln', 'Leverkusen, Stadt', '', 'Flensburg, Stadt'],\n 'Insgesamt': ['', '', 30, 272, 272, 543, 48, 251, 76, 13, 52, 17, '', 17]})\n sheet2 = pd.DataFrame({'Arbeitsort': ['nothing', '02000', '', '', ''],\n 'Arbeitsort2': ['', 'Hamburg, Freie und Hansestadt', '', '', ''],\n 'Wohnort': ['nothing', '', '01053', '04', '06532'],\n 'Wohnort2': ['', '', 'Herzogtum Lauenburg', 'Bremen',\n 'Lahn-Dill-Kreis'],\n 'Insgesamt': ['', '', 23230, 4628, 92]})\n sheet3 = pd.DataFrame({'Arbeitsort': ['nothing', '03101', '', '', ''],\n 'Arbeitsort2': ['', 'Braunschweig, Stadt', '', '', ''],\n 'Wohnort': ['nothing', '', '01053', '07', '14511'],\n 'Wohnort2': ['', '', 'Herzogtum Lauenburg', 'Rheinland-Pfalz',\n 'Chemnitz, Stadt'],\n 'Insgesamt': ['', '', 17, 123, 15]})\n sheet4 = pd.DataFrame({'Arbeitsort': ['nothing', '04012', '', '', ''],\n 'Arbeitsort2': ['', 'Bremerhaven, Stadt', '', '', ''],\n 'Wohnort': ['nothing', '', '06532', '05', '12051'],\n 'Wohnort2': ['', '', 'Lahn-Dill-Kreis', 'Nordrhein-Westfalen',\n 'Brandenburg an der Havel, St.'],\n 'Insgesamt': ['', '', 22, 299, 10]})\n sheet5 = pd.DataFrame({'Arbeitsort': ['nothing', '05112', '', '', '', '05316', '', ''],\n 'Arbeitsort2': ['', 'Duisburg, Stadt', '', '', '', 'Leverkusen, Stadt', '', ''],\n 'Wohnort': ['nothing', '', '12066', '13003', 'ZZ', '', '14511', 'ZZ'],\n 'Wohnort2': ['', '', 'Oberspreewald-Lausitz', 'Rostock, Hansestadt',\n 'Einpendler aus dem Bundesgebiet',\n '', 'Chemnitz, Stadt', 'Einpendler aus dem Bundesgebiet'],\n 'Insgesamt': ['', '', 34, 299, 305, '', 12, 12]})\n sheet6 = pd.DataFrame({'Arbeitsort': ['nothing', '06532', '', '', '06632', '', ''],\n 'Arbeitsort2': ['', 'Lahn-Dill-Kreis', '', '', 'Hersfeld-Rotenburg', '', ''],\n 'Wohnort': ['nothing', '', '02000', '01053', '', '02000', '091'],\n 'Wohnort2': ['', '', 'Hamburg, Freie und Hansestadt', 'Herzogtum Lauenburg',\n '', 'Hamburg, Freie und Hansestadt', 'Übrige Kreise (Regierungsbezirk)'],\n 'Insgesamt': ['nothing', '', 112, 13, '', 28, 47]})\n sheet7 = pd.DataFrame({'Arbeitsort': ['nothing', '07141', '', '', '07235', ''],\n 'Arbeitsort2': ['', 'Rhein-Lahn-Kreis', '', '', 'Trier-Saarburg', ''],\n 'Wohnort': ['nothing', '', '02000', '07235', '', '02000'],\n 'Wohnort2': ['', '', 'Hamburg, Freie und Hansestadt', 'Trier-Saarburg',\n '', 'Hamburg, Freie und Hansestadt'],\n 'Insgesamt': ['', '', 18, 19, '', 10]})\n sheet8 = pd.DataFrame({'Arbeitsort': ['nothing', '08111', '', ''],\n 'Arbeitsort2': ['', 'Stuttgart, Landeshauptstadt', '', ''],\n 'Wohnort': ['nothing', '', '01053', '13003'],\n 'Wohnort2': ['', '', 'Herzogtum Lauenburg', 'Rostock, Hansestadt'],\n 'Insgesamt': ['', '', 32, 38]})\n sheet9 = pd.DataFrame({'Arbeitsort': ['nothing', '09181', '', ''],\n 'Arbeitsort2': ['', 'Landsberg am Lech', '', ''],\n 'Wohnort': ['nothing', '', '08111', '11000'],\n 'Wohnort2': ['', '', 'Stuttgart, Landeshauptstadt', 'Berlin, Stadt'],\n 'Insgesamt': ['', '', 57, 43]})\n sheet10 = pd.DataFrame({'Arbeitsort': ['nothing', '10044', ''],\n 'Arbeitsort2': ['', 'Saarlouis', ''],\n 'Wohnort': ['nothing', '', '07235'],\n 'Wohnort2': ['', '', 'Trier-Saarburg'],\n 'Insgesamt': ['', '', 220]})\n sheet11 = pd.DataFrame({'Arbeitsort': ['nothing', '11000', '', ''],\n 'Arbeitsort2': ['', 'Berlin, Stadt', '', ''],\n 'Wohnort': ['nothing', '', '01053', '08111'],\n 'Wohnort2': ['', '', 'Herzogtum Lauenburg', 'Stuttgart, Landeshauptstadt'],\n 'Insgesamt': ['', '', 297, 1186]})\n sheet12 = pd.DataFrame({'Arbeitsort': ['nothing', '12051', '', '', '12066', ''],\n 'Arbeitsort2': ['', 'Brandenburg an der Havel, St.', '', '', 'Oberspreewald-Lausitz',\n ''],\n 'Wohnort': ['nothing', '', '11000', '12066', '', '05112'],\n 'Wohnort2': ['', '', 'Berlin, Stadt', 'Oberspreewald-Lausitz', '', 'Duisburg, Stadt'],\n 'Insgesamt': ['', '', 571, 24, '', 10]})\n sheet13 = pd.DataFrame({'Arbeitsort': ['nothing', '13003', '', ''],\n 'Arbeitsort2': ['', 'Rostock, Hansestadt', '', ''],\n 'Wohnort': ['nothing', '', '01053', '12066'],\n 'Wohnort2': ['', '', 'Herzogtum Lauenburg', 'Oberspreewald-Lausitz'],\n 'Insgesamt': ['', '', 42, 12]})\n sheet14 = pd.DataFrame({'Arbeitsort': ['nothing', '14511', '', ''],\n 'Arbeitsort2': ['', 'Chemnitz, Stadt', '', ''],\n 'Wohnort': ['nothing', '', '02000', '11000'],\n 'Wohnort2': ['', '', 'Hamburg, Freie und Hansestadt', 'Berlin, Stadt'],\n 'Insgesamt': ['', '', 74, 524]})\n sheet15 = pd.DataFrame({'Arbeitsort': ['nothing', '15082', '', ''],\n 'Arbeitsort2': ['', 'Anhalt-Bitterfeld', '', ''],\n 'Wohnort': ['nothing', '', '12066', '14511'],\n 'Wohnort2': ['', '', 'Oberspreewald-Lausitz', 'Chemnitz, Stadt'],\n 'Insgesamt': ['', '', 27, 26]})\n sheet16 = pd.DataFrame({'Arbeitsort': ['nothing', '16069', '', ''],\n 'Arbeitsort2': ['', 'Hildburghausen', '', ''],\n 'Wohnort': ['nothing', '', '03', '05'],\n 'Wohnort2': ['', '', 'Niedersachsen', 'Nordrhein-Westfalen'],\n 'Insgesamt': ['', '', 29, 34]})\n states = (\n sheet1, sheet2, sheet3, sheet4, sheet5, sheet6, sheet7, sheet8, sheet9, sheet10, sheet11, sheet12, sheet13,\n sheet14, sheet15, sheet16)\n for i in range(16):\n sheets = {'Deckblatt': sheet0, 'Impressum': sheet0, 'Auspendler Kreise': sheet0,\n 'Einpendler Kreise': states[i]}\n if i < 9:\n name = 'krpend_0' + str(i + 1) + \"_0.xlsx\"\n else:\n name = 'krpend_' + str(i + 1) + \"_0.xlsx\"\n data_path = os.path.join(out_folder, name)\n dummy = pd.ExcelWriter(data_path)\n for sheet_name in sheets.keys():\n sheets[sheet_name].to_excel(\n dummy, sheet_name=sheet_name, index=False)\n dummy.save()\n dummy.close()\n\n @patch('builtins.print')\n def test_verify_sorted(self, mock_print):\n self.assertEqual(True, gcm.verify_sorted(self.test_countykey_list))\n self.assertEqual(False, gcm.verify_sorted(self.test_countykey_list2))\n Errorcall = ('Error. Input list not sorted.')\n mock_print.assert_called_with(Errorcall)\n\n @patch('builtins.print')\n def test_assign_geographical_entities(self, mock_print):\n (countykey2govkey, countykey2localnumlist, gov_county_table,\n state_gov_table) = gcm.assign_geographical_entities(self.countykey_list, self.govkey_list)\n for item in self.test_countykey2govkey.keys():\n self.assertEqual(\n self.test_countykey2govkey.get(item),\n countykey2govkey.get(item))\n\n # check if all countyIDs are in countykey2govkey\n for key in geoger.get_county_ids(True, False, True):\n self.assertIn(key, countykey2govkey.keys())\n self.assertIn(key, countykey2localnumlist.keys())\n for item in self.test_countykey2localnumlist.keys():\n self.assertEqual(self.test_countykey2localnumlist.get(\n item), countykey2localnumlist.get(item))\n for item in self.test_state_gov_table:\n self.assertIn(item, state_gov_table)\n for item in self.test_gov_county_table:\n self.assertIn(item, gov_county_table)\n\n # test case with not matching countykey and govkey lists\n (countykey2govkey, countykey2localnumlist, gov_county_table,\n state_gov_table) = gcm.assign_geographical_entities(\n self.test_countykey_list, self.test_govkey_list)\n self.assertEqual(countykey2govkey, collections.OrderedDict())\n self.assertEqual(countykey2localnumlist, collections.OrderedDict())\n self.assertEqual(gov_county_table, [\n [], [], [], [], [], [], [], [], [], [], [], []])\n self.assertEqual(state_gov_table, self.test_state_gov_table)\n\n # test case with different number of data\n gcm.assign_geographical_entities(\n self.test_countykey_list, self.govkey_list)\n Errorcall = ('Error. Number of government regions wrong.')\n mock_print.assert_called_with(Errorcall)\n\n @patch('builtins.print')\n def test_some_errors(self, mock_print):\n gD.check_dir(self.path)\n self.write_kreise_deu_data(self.path)\n self.write_commuter_all_federal_states(self.path)\n self.assertEqual(len(os.listdir(self.path)), 17)\n\n def test_commuter_data(self):\n \"\"\"! Tests migration data by some randomly chosen tests.\n \"\"\"\n\n df_commuter_migration = gcm.get_commuter_data(out_folder=self.path)\n # the first column and first row are just the county IDs\n # mat_commuter_migration is the real Data that should be tested\n mat_commuter_migration = df_commuter_migration.iloc[:, 0:]\n mat_commuter_migration = mat_commuter_migration.iloc[0:, :]\n\n countykey2numlist = collections.OrderedDict(\n zip(self.countykey_list, list(range(0, len(self.countykey_list)))))\n\n gD.check_dir(self.path)\n self.write_kreise_deu_data(self.path)\n self.write_commuter_all_federal_states(self.path)\n self.assertEqual(len(os.listdir(self.path)), 18)\n\n # just do some tests on randomly chosen migrations\n\n # check migration from Leverkusen (averaged from NRW, 05) to Hildburghausen\n city_from = countykey2numlist['05316']\n city_to = countykey2numlist['16069']\n population = gpd.get_age_population_data(\n out_folder=self.path, merge_eisenach=False, write_df=True)\n countypop_list = list(population[\"Total\"])\n self.assertEqual(countypop_list[city_from], 163905)\n self.assertAlmostEqual(\n mat_commuter_migration.iat[city_from, city_to], 1.526, 2)\n\n # check migration from Duisburg to Oberspreewald-Lausitz\n city_from = countykey2numlist['05112']\n city_to = countykey2numlist['12066']\n self.assertEqual(mat_commuter_migration.iat[city_from, city_to], 11)\n\n # check migration from Lahn-Dill-Kreis to Hamburg\n city_from = countykey2numlist['06532']\n city_to = countykey2numlist['02000']\n self.assertEqual(mat_commuter_migration.iat[city_from, city_to], 96)\n\n # check migration from Herzogtum Lauenburg to Flensburg, Stadt\n city_from = countykey2numlist['01001']\n city_to = countykey2numlist['01053']\n self.assertEqual(mat_commuter_migration.iat[city_from, city_to], 14)\n\n @patch('builtins.print')\n def test_get_neighbors_mobility(self, mock_print):\n\n testcountyid = 1051\n tci = testcountyid\n #direction = both\n (countykey_list, commuter_all) = gcm.get_neighbors_mobility(\n tci, direction='both', abs_tol=0, rel_tol=0,\n tol_comb='or', merge_eisenach=True, out_folder=self.path)\n self.assertEqual(len(countykey_list), 398)\n self.assertAlmostEqual(228, commuter_all[0], 2)\n self.assertAlmostEqual(2146, commuter_all[9], 2)\n self.assertAlmostEqual(293, commuter_all[11], 2)\n self.assertAlmostEqual(1, commuter_all[397], 2)\n\n # direction = in\n (countykey_list, commuter_all) = gcm.get_neighbors_mobility(\n tci, direction='in', abs_tol=0, rel_tol=0,\n tol_comb='or', merge_eisenach=True, out_folder=self.path)\n self.assertEqual(len(countykey_list), 393)\n self.assertAlmostEqual(48, commuter_all[0], 2)\n self.assertAlmostEqual(842, commuter_all[9], 2)\n self.assertAlmostEqual(92, commuter_all[11], 2)\n\n # direction = out\n (countykey_list, commuter_all) = gcm.get_neighbors_mobility(\n tci, direction='out', abs_tol=0, rel_tol=0,\n tol_comb='or', merge_eisenach=True, out_folder=self.path)\n self.assertEqual(len(countykey_list), 375)\n self.assertAlmostEqual(180, commuter_all[0], 2)\n self.assertAlmostEqual(1304, commuter_all[9], 2)\n self.assertAlmostEqual(201, commuter_all[11], 2)\n\n\nif __name__ == '__main__':\n unittest.main()\n"
] | [
[
"pandas.DataFrame",
"pandas.ExcelWriter"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
vghost2008/wml | [
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff",
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff",
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff",
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff",
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff",
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff",
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff",
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff",
"d0c5a1da6c228e321ae59a563e9ac84aa66266ff"
] | [
"optimizer/padam.py",
"object_detection2/data/mtest.py",
"datasets_tools/create_voc_tf_record_by_coco.py",
"object_detection2/modeling/proposal_generator/rpn_giou_outputs.py",
"object_detection2/modeling/roi_heads/mask_head.py",
"object_detection2/modeling/roi_heads/box_head.py",
"wtorch/summary.py",
"object_detection2/modeling/keypoints_heads/utest.py",
"object_detection2/modeling/sampling.py"
] | [
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.ops import control_flow_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import resource_variable_ops\nfrom tensorflow.python.ops import state_ops\nfrom tensorflow.python.training import optimizer\nfrom tensorflow.python.training import training_ops\nfrom tensorflow.python.util.tf_export import tf_export\nimport tensorflow as tf\n\n\nclass PAdamOptimizer(optimizer.Optimizer):\n\n def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8,\n switch_step=50,\n use_locking=False, name=\"PAdam\"):\n \"\"\"Construct a new Adam optimizer.\n\n Initialization:\n\n $$m_0 := 0 \\text{(Initialize initial 1st moment vector)}$$\n $$v_0 := 0 \\text{(Initialize initial 2nd moment vector)}$$\n $$t := 0 \\text{(Initialize timestep)}$$\n\n The update rule for `variable` with gradient `g` uses an optimization\n described at the end of section2 of the paper:\n\n $$t := t + 1$$\n $$lr_t := \\text{learning\\_rate} * \\sqrt{1 - beta_2^t} / (1 - beta_1^t)$$\n\n $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$\n $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$\n $$variable := variable - lr_t * m_t / (\\sqrt{v_t} + \\epsilon)$$\n\n The default value of 1e-8 for epsilon might not be a good default in\n general. For example, when training an Inception network on ImageNet a\n current good choice is 1.0 or 0.1. Note that since PAdamOptimizer uses the\n formulation just before Section 2.1 of the Kingma and Ba paper rather than\n the formulation in Algorithm 1, the \"epsilon\" referred to here is \"epsilon\n hat\" in the paper.\n\n The sparse implementation of this algorithm (used when the gradient is an\n IndexedSlices object, typically because of `tf.gather` or an embedding\n lookup in the forward pass) does apply momentum to variable slices even if\n they were not used in the forward pass (meaning they have a gradient equal\n to zero). Momentum decay (beta1) is also applied to the entire momentum\n accumulator. This means that the sparse behavior is equivalent to the dense\n behavior (in contrast to some momentum implementations which ignore momentum\n unless a variable slice was actually used).\n\n Args:\n learning_rate: A Tensor or a floating point value. The learning rate.\n beta1: A float value or a constant float tensor.\n The exponential decay rate for the 1st moment estimates.\n beta2: A float value or a constant float tensor.\n The exponential decay rate for the 2nd moment estimates.\n epsilon: A small constant for numerical stability. This epsilon is\n \"epsilon hat\" in the Kingma and Ba paper (in the formula just before\n Section 2.1), not the epsilon in Algorithm 1 of the paper.\n use_locking: If True use locks for update operations.\n name: Optional name for the operations created when applying gradients.\n Defaults to \"Adam\".\n\n @compatibility(eager)\n When eager execution is enabled, `learning_rate`, `beta1`, `beta2`, and\n `epsilon` can each be a callable that takes no arguments and returns the\n actual value to use. This can be useful for changing these values across\n different invocations of optimizer functions.\n @end_compatibility\n \"\"\"\n super(PAdamOptimizer, self).__init__(use_locking, name)\n self._lr = learning_rate\n self._beta1 = beta1\n self._beta2 = beta2\n self._epsilon = epsilon\n\n # Tensor versions of the constructor arguments, created in _prepare().\n self._lr_t = None\n self._beta1_t = None\n self._beta2_t = None\n self._epsilon_t = None\n\n # Created in SparseApply if needed.\n self._updated_lr = None\n self._switch_step = switch_step\n self._use_nesterov = False\n print(f\"PAdam switch step = {switch_step}\")\n\n def _get_beta_accumulators(self):\n with ops.init_scope():\n if context.executing_eagerly():\n graph = None\n else:\n graph = ops.get_default_graph()\n return (self._get_non_slot_variable(\"beta1_power\", graph=graph),\n self._get_non_slot_variable(\"beta2_power\", graph=graph))\n\n def _create_slots(self, var_list):\n # Create the beta1 and beta2 accumulators on the same device as the first\n # variable. Sort the var_list to make sure this device is consistent across\n # workers (these need to go on the same PS, otherwise some updates are\n # silently ignored).\n first_var = min(var_list, key=lambda x: x.name)\n self._create_non_slot_variable(initial_value=self._beta1,\n name=\"beta1_power\",\n colocate_with=first_var)\n self._create_non_slot_variable(initial_value=self._beta2,\n name=\"beta2_power\",\n colocate_with=first_var)\n\n # Create slots for the first and second moments.\n for v in var_list:\n self._zeros_slot(v, \"m\", self._name)\n self._zeros_slot(v, \"v\", self._name)\n\n def _prepare(self):\n lr = self._call_if_callable(self._lr)\n beta1 = self._call_if_callable(self._beta1)\n beta2 = self._call_if_callable(self._beta2)\n epsilon = self._call_if_callable(self._epsilon)\n\n self._lr_t = ops.convert_to_tensor(lr, name=\"learning_rate\")\n self._beta1_t = ops.convert_to_tensor(beta1, name=\"beta1\")\n self._beta2_t = ops.convert_to_tensor(beta2, name=\"beta2\")\n self._epsilon_t = ops.convert_to_tensor(epsilon, name=\"epsilon\")\n\n def _apply_dense(self, grad, var):\n #return self.momentum_apply_dense(grad, var)\n #return self.adam_apply_dense(grad, var)\n return tf.cond(tf.train.get_or_create_global_step()<self._switch_step,\n lambda:self.adam_apply_dense(grad,var),\n lambda:self.momentum_apply_dense(grad,var))\n pass\n def _apply_sparse(self, grad, var):\n #return self.momentum_apply_sparse(grad, var)\n #return self.adam_apply_sparse(grad, var),\n return tf.cond(tf.train.get_or_create_global_step()<self._switch_step,\n lambda:self.adam_apply_sparse(grad,var),\n lambda:self.momentum_apply_sparse(grad,var))\n\n def adam_apply_dense(self, grad, var):\n m = self.get_slot(var, \"m\")\n v = self.get_slot(var, \"v\")\n beta1_power, beta2_power = self._get_beta_accumulators()\n #grad = tf.Print(grad,[\"A\"])\n return training_ops.apply_adam(\n var, m, v,\n math_ops.cast(beta1_power, var.dtype.base_dtype),\n math_ops.cast(beta2_power, var.dtype.base_dtype),\n math_ops.cast(self._lr_t, var.dtype.base_dtype),\n math_ops.cast(self._beta1_t, var.dtype.base_dtype),\n math_ops.cast(self._beta2_t, var.dtype.base_dtype),\n math_ops.cast(self._epsilon_t, var.dtype.base_dtype),\n grad, use_locking=self._use_locking).op\n\n def _resource_apply_dense(self, grad, var):\n m = self.get_slot(var, \"m\")\n v = self.get_slot(var, \"v\")\n grad = tf.Print(grad,[\"AR\"])\n beta1_power, beta2_power = self._get_beta_accumulators()\n return training_ops.resource_apply_adam(\n var.handle, m.handle, v.handle,\n math_ops.cast(beta1_power, grad.dtype.base_dtype),\n math_ops.cast(beta2_power, grad.dtype.base_dtype),\n math_ops.cast(self._lr_t, grad.dtype.base_dtype),\n math_ops.cast(self._beta1_t, grad.dtype.base_dtype),\n math_ops.cast(self._beta2_t, grad.dtype.base_dtype),\n math_ops.cast(self._epsilon_t, grad.dtype.base_dtype),\n grad, use_locking=self._use_locking)\n\n def _apply_sparse_shared(self, grad, var, indices, scatter_add):\n beta1_power, beta2_power = self._get_beta_accumulators()\n beta1_power = math_ops.cast(beta1_power, var.dtype.base_dtype)\n beta2_power = math_ops.cast(beta2_power, var.dtype.base_dtype)\n lr_t = math_ops.cast(self._lr_t, var.dtype.base_dtype)\n beta1_t = math_ops.cast(self._beta1_t, var.dtype.base_dtype)\n beta2_t = math_ops.cast(self._beta2_t, var.dtype.base_dtype)\n epsilon_t = math_ops.cast(self._epsilon_t, var.dtype.base_dtype)\n lr = (lr_t * math_ops.sqrt(1 - beta2_power) / (1 - beta1_power))\n # m_t = beta1 * m + (1 - beta1) * g_t\n m = self.get_slot(var, \"m\")\n m_scaled_g_values = grad * (1 - beta1_t)\n m_t = state_ops.assign(m, m * beta1_t,\n use_locking=self._use_locking)\n with ops.control_dependencies([m_t]):\n m_t = scatter_add(m, indices, m_scaled_g_values)\n # v_t = beta2 * v + (1 - beta2) * (g_t * g_t)\n v = self.get_slot(var, \"v\")\n v_scaled_g_values = (grad * grad) * (1 - beta2_t)\n v_t = state_ops.assign(v, v * beta2_t, use_locking=self._use_locking)\n with ops.control_dependencies([v_t]):\n v_t = scatter_add(v, indices, v_scaled_g_values)\n v_sqrt = math_ops.sqrt(v_t)\n var_update = state_ops.assign_sub(var,\n lr * m_t / (v_sqrt + epsilon_t),\n use_locking=self._use_locking)\n return control_flow_ops.group(*[var_update, m_t, v_t])\n\n def adam_apply_sparse(self, grad, var):\n return self._apply_sparse_shared(\n grad.values, var, grad.indices,\n lambda x, i, v: state_ops.scatter_add( # pylint: disable=g-long-lambda\n x, i, v, use_locking=self._use_locking))\n\n def _resource_scatter_add(self, x, i, v):\n with ops.control_dependencies(\n [resource_variable_ops.resource_scatter_add(\n x.handle, i, v)]):\n return x.value()\n\n def _resource_apply_sparse(self, grad, var, indices):\n return self._apply_sparse_shared(\n grad, var, indices, self._resource_scatter_add)\n\n def _finish(self, update_ops, name_scope):\n # Update the power accumulators.\n with ops.control_dependencies(update_ops):\n beta1_power, beta2_power = self._get_beta_accumulators()\n with ops.colocate_with(beta1_power):\n update_beta1 = beta1_power.assign(\n beta1_power * self._beta1_t, use_locking=self._use_locking)\n update_beta2 = beta2_power.assign(\n beta2_power * self._beta2_t, use_locking=self._use_locking)\n return control_flow_ops.group(*update_ops + [update_beta1, update_beta2],\n name=name_scope)\n\n def momentum_apply_dense(self, grad, var):\n mom = self.get_slot(var, \"m\")\n #grad = tf.Print(grad,[\"B\",tf.train.get_or_create_global_step(),self._switch_step])\n return training_ops.apply_momentum(\n var, mom,\n math_ops.cast(self._lr_t, var.dtype.base_dtype),\n grad,\n math_ops.cast(self._beta1_t, var.dtype.base_dtype),\n use_locking=self._use_locking,\n use_nesterov=self._use_nesterov).op\n\n def momentum_resource_apply_dense(self, grad, var):\n mom = self.get_slot(var, \"m\")\n return training_ops.resource_apply_momentum(\n var.handle, mom.handle,\n math_ops.cast(self._lr_t, grad.dtype.base_dtype),\n grad,\n math_ops.cast(self._beta1_t, grad.dtype.base_dtype),\n use_locking=self._use_locking,\n use_nesterov=self._use_nesterov)\n\n def momentum_apply_sparse(self, grad, var):\n mom = self.get_slot(var, \"m\")\n return training_ops.sparse_apply_momentum(\n var, mom,\n math_ops.cast(self._lr_t, var.dtype.base_dtype),\n grad.values, grad.indices,\n math_ops.cast(self._beta1_t, var.dtype.base_dtype),\n use_locking=self._use_locking,\n use_nesterov=self._use_nesterov).op\n",
"#coding=utf-8\nimport tensorflow as tf\nfrom object_detection2.data.dataloader import DataLoader\nimport time\nimport tensorflow as tf\nimport wml_tfutils as wmlt\nimport wsummary\nimport wml_utils as wmlu\nimport iotoolkit.coco_tf_decodev2 as cocodecode\nimport iotoolkit.coco_toolkit as cocot\nimport wsummary\nimport iotoolkit.transform as trans\nfrom object_detection2.config.config import CfgNode as CN\nfrom object_detection2.data.datasets.build import DATASETS_REGISTRY\nfrom object_detection2.data.dataloader import *\nfrom wml_utils import AvgTimeThis\nfrom object_detection2.standard_names import *\nfrom object_detection2.config.config import *\nimport os\n\nos.environ['CUDA_VISIBLE_DEVICES'] = ''\n\ntf.app.flags.DEFINE_string('logdir', wmlu.home_dir(\"ai/tmp/tools_logdir/\"),\"Logdir path\")\n\nFLAGS = tf.app.flags.FLAGS\nslim = tf.contrib.slim\nfrom object_detection2.data.buildin_dataprocess import DATAPROCESS_REGISTRY\n\naa = trans.RandomSelectSubTransform([\n [trans.WRandomTranslate(prob=1,pixels=20),trans.WRandomTranslate(prob=0.5,pixels=20)],\n [trans.WRandomTranslate(prob=1, pixels=20,translate_horizontal=False), trans.WRandomTranslate(prob=0.5, pixels=20,translate_horizontal=False)]\n])\n\n@DATAPROCESS_REGISTRY.register()\ndef simple_semantic1(cfg, is_training):\n if is_training:\n trans_on_single_img = [trans.MaskNHW2HWN(),\n trans.ResizeToFixedSize(),\n trans.MaskHWN2NHW(),\n trans.WRemoveCrowdInstance(False),\n trans.GetSemanticMaskFromCOCO(num_classes=3,no_background=False),\n trans.AddBoxLens(),\n trans.UpdateHeightWidth(),\n ]\n trans_on_batch_img = [trans.FixDataInfo()]\n else:\n trans_on_single_img = [trans.MaskNHW2HWN(),\n trans.ResizeToFixedSize(),\n trans.MaskHWN2NHW(),\n trans.BBoxesRelativeToAbsolute(),\n trans.AddBoxLens(),\n ]\n trans_on_batch_img = [trans.BBoxesAbsoluteToRelative(),\n trans.FixDataInfo()]\n return trans_on_single_img,trans_on_batch_img\n\n@DATAPROCESS_REGISTRY.register()\ndef test(cfg,is_training):\n return [\n trans.ShowInfo(),\n trans.BBoxesRelativeToAbsolute(),\n trans.RandomRotateAnyAngle(use_mask=False,rotate_bboxes_type=0,rotate_probability=1,max_angle=15),\n trans.RemoveZeroAreaBBox(),\n trans.GetSemanticMaskFromCOCO(num_classes=3,no_background=False),\n trans.UpdateHeightWidth(),\n trans.AddBoxLens(),\n ],\\\n [trans.NoTransform(),trans.BBoxesAbsoluteToRelative()]\n_C = get_cfg()\n_C.DATASETS.SKIP_CROWD_DURING_TRAINING = False\n_C.DATASETS.TRAIN = \"coco_2017_kp_train_test\"\n_C.INPUT.DATAPROCESS = \"OPENPOSE\"\n_C.INPUT.MIN_SIZE_TRAIN = [640,640]\n_C.INPUT.SHUFFLE_BUFFER_SIZE = 1\n_C.INPUT.ROTATE_ANY_ANGLE.ENABLE = True\n\n#_C.MODEL.KEYPOINTS.POINTS_PAIRS = [0,1,1,2]\n#_C.MODEL.KEYPOINTS.NUM_KEYPOINTS= 3\n\nset_global_cfg(_C)\n\ndef main(_):\n cfg = _C\n data_loader = DataLoader(cfg=cfg,is_training=True)\n data_args = DATASETS_REGISTRY[cfg.DATASETS.TRAIN]\n with tf.device(\":/cpu:0\"):\n data,num_classes = data_loader.load_data(*data_args)\n res = data.get_next()\n print(res)\n data_loader.detection_image_summary(res,max_boxes_to_draw=200,max_outputs=4)\n wsummary.image_summaries(res['image'],'image')\n res[IMAGE] = tf.ones_like(res[IMAGE])*200\n data_loader.detection_image_summary(res,max_boxes_to_draw=200,max_outputs=4)\n config = tf.ConfigProto(allow_soft_placement=True)\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n\n merged = tf.summary.merge_all()\n summary_writer = tf.summary.FileWriter(FLAGS.logdir, sess.graph)\n with tf.control_dependencies([tf.group(wmlt.get_hash_table_collection())]):\n initializer = tf.global_variables_initializer()\n sess.run(initializer)\n log_step = 1\n step = 0\n tt = AvgTimeThis()\n att = AvgTimeThis()\n while True:\n if step%log_step == 0:\n summary,bboxes,lens = sess.run([merged,res[GT_BOXES],res[GT_LENGTH]])\n wmlu.show_nparray(bboxes[0][:lens[0]])\n summary_writer.add_summary(summary, step)\n else:\n with tt:\n with att:\n image,bbox,mask = sess.run([res[IMAGE],res[GT_MASKS],res[GT_BOXES]])\n print(\"step %5d, %f %f secs/batch\" % (step,tt.get_time(),att.get_time()))\n step += 1\n if step>20:\n break\n sess.close()\n summary_writer.close()\n\nif __name__ == \"__main__\":\n if tf.gfile.Exists(FLAGS.logdir):\n tf.gfile.DeleteRecursively(FLAGS.logdir)\n tf.app.run()\n",
"# 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\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport hashlib\nimport io\nimport json\nimport os\nimport numpy as np\nimport PIL.Image\nimport wml_utils as wmlu\n\nfrom pycocotools import mask\nimport tensorflow as tf\n\nimport iotoolkit.dataset_util as dataset_util\nimport iotoolkit.label_map_util as label_map_util\nfrom iotoolkit.coco_toolkit import *\nfrom iotoolkit.pascal_voc_data import ID_TO_TEXT\nfrom wml_tfutils import int64_feature,bytes_feature,floats_feature\n\nflags = tf.app.flags\ntf.flags.DEFINE_boolean('include_masks', True,\n 'Whether to include instance segmentations masks '\n '(PNG encoded) in the result. default: False.')\ntf.flags.DEFINE_string('train_image_dir', '',\n 'Training image directory.')\ntf.flags.DEFINE_string('val_image_dir', '',\n 'Validation image directory.')\ntf.flags.DEFINE_string('test_image_dir', '',\n 'Test image directory.')\ntf.flags.DEFINE_string('train_annotations_file', '',\n 'Training annotations JSON file.')\ntf.flags.DEFINE_string('val_annotations_file', '',\n 'Validation annotations JSON file.')\ntf.flags.DEFINE_string('testdev_annotations_file', '',\n 'Test-dev annotations JSON file.')\ntf.flags.DEFINE_string('output_dir', '/tmp/', 'Output data directory.')\n\ncoco_id_to_voc_id = {5:1,2:2,16:3,9:4,44:5,6:6,3:7,17:8,62:9,21:10,67:11,18:12,19:13,4:14,1:15,64:16,20:17,63:18,7:19,72:20}\ncoco_ids = list(coco_id_to_voc_id.keys())\n\nFLAGS = flags.FLAGS\n\ntf.logging.set_verbosity(tf.logging.INFO)\n\nTRAIN_SIZE_LIMIT = None\nVAL_SIZE_LIMIT = None\nsrc_file_index = 0\ndef trans_category_ids(ids):\n return [coco_id_to_voc_id[x] for x in ids]\ndef category_to_text(ids):\n return [ID_TO_TEXT[x] for x in ids]\n\ndef category_id_filter(category_id):\n return category_id in coco_ids\n\ndef create_tf_example(image,\n annotations_list,\n image_dir,\n category_index,\n include_masks=False):\n \"\"\"Converts image and annotations to a tf.Example proto.\n\n Args:\n image: dict with keys:\n [u'license', u'file_name', u'coco_url', u'height', u'width',\n u'date_captured', u'flickr_url', u'id']\n annotations_list:\n list of dicts with keys:\n [u'segmentation', u'area', u'iscrowd', u'image_id',\n u'bbox', u'category_id', u'id']\n Notice that bounding box coordinates in the official COCO dataset are\n given as [x, y, width, height] tuples using absolute coordinates where\n x, y represent the top-left (0-indexed) corner. This function converts\n to the format expected by the Tensorflow Object Detection API (which is\n which is [ymin, xmin, ymax, xmax] with coordinates normalized relative\n to image size).\n image_dir: directory containing the image files.\n category_index: a dict containing COCO category information keyed\n by the 'id' field of each category. See the\n label_map_util.create_category_index function.\n include_masks: Whether to include instance segmentations masks\n (PNG encoded) in the result. default: False.\n Returns:\n example: The converted tf.Example\n num_annotations_skipped: Number of (invalid) annotations that were ignored.\n\n Raises:\n ValueError: if the image pointed to by data['filename'] is not a valid JPEG\n \"\"\"\n global src_file_index\n image_height = image['height']\n image_width = image['width']\n filename = image['file_name']\n image_id = image['id']\n\n full_path = os.path.join(image_dir, filename)\n with tf.gfile.GFile(full_path, 'rb') as fid:\n encoded_jpg = fid.read()\n encoded_jpg_io = io.BytesIO(encoded_jpg)\n image = PIL.Image.open(encoded_jpg_io)\n key = hashlib.sha256(encoded_jpg).hexdigest()\n\n xmin = []\n xmax = []\n ymin = []\n ymax = []\n is_crowd = []\n category_names = []\n category_ids = []\n area = []\n encoded_mask_png = []\n num_annotations_skipped = 0\n for object_annotations in annotations_list:\n (x, y, width, height) = tuple(object_annotations['bbox'])\n if width <= 0 or height <= 0:\n num_annotations_skipped += 1\n continue\n if x + width > image_width or y + height > image_height:\n num_annotations_skipped += 1\n continue\n category_id = int(object_annotations['category_id'])\n if not category_id_filter(category_id):\n num_annotations_skipped += 1\n continue\n\n xmin.append(float(x) / image_width)\n xmax.append(float(x + width) / image_width)\n ymin.append(float(y) / image_height)\n ymax.append(float(y + height) / image_height)\n is_crowd.append(object_annotations['iscrowd'])\n category_ids.append(category_id)\n category_names.append(category_index[category_id]['name'].encode('utf8'))\n area.append(object_annotations['area'])\n\n if include_masks:\n run_len_encoding = mask.frPyObjects(object_annotations['segmentation'],\n image_height, image_width)\n binary_mask = mask.decode(run_len_encoding)\n if not object_annotations['iscrowd']:\n binary_mask = np.amax(binary_mask, axis=2)\n pil_image = PIL.Image.fromarray(binary_mask)\n output_io = io.BytesIO()\n pil_image.save(output_io, format='PNG')\n encoded_mask_png.append(output_io.getvalue())\n\n if len(category_ids)==0:\n return None,None,None\n category_ids = trans_category_ids(category_ids)\n feature_dict = {\n 'image/height':\n int64_feature(image_height),\n 'image/width':\n int64_feature(image_width),\n 'image/channels': int64_feature(3),\n 'image/shape': int64_feature([image_height,image_width,3]),\n 'image/filename':\n dataset_util.bytes_feature(filename.encode('utf8')),\n 'image/source_id':\n dataset_util.bytes_feature(str(image_id).encode('utf8')),\n 'image/key/sha256':\n dataset_util.bytes_feature(key.encode('utf8')),\n 'image/encoded':\n dataset_util.bytes_feature(encoded_jpg),\n 'image/format':\n dataset_util.bytes_feature('jpeg'.encode('utf8')),\n 'image/object/bbox/xmin':\n dataset_util.float_list_feature(xmin),\n 'image/object/bbox/xmax':\n dataset_util.float_list_feature(xmax),\n 'image/object/bbox/ymin':\n dataset_util.float_list_feature(ymin),\n 'image/object/bbox/ymax':\n dataset_util.float_list_feature(ymax),\n 'image/object/bboxlabel':\n dataset_util.int64_list_feature(category_ids),\n 'image/object/bbox/label':\n dataset_util.int64_list_feature(category_ids),\n 'image/object/bbox/label_text':\n bytes_feature(category_to_text(category_ids)),\n 'image/object/difficult':\n dataset_util.int64_list_feature(is_crowd),\n 'image/object/truncated':\n dataset_util.int64_list_feature(np.ones_like(is_crowd)),\n 'image/object/area':\n dataset_util.float_list_feature(area),\n 'image/file_index':dataset_util.int64_feature(src_file_index),\n }\n\n if include_masks:\n feature_dict['image/object/mask'] = (\n dataset_util.bytes_list_feature(encoded_mask_png))\n example = tf.train.Example(features=tf.train.Features(feature=feature_dict))\n src_file_index += 1\n return key, example, num_annotations_skipped\n\n\ndef _create_tf_record_from_coco_annotations(\n annotations_file, image_dir, output_path, include_masks,is_train_data=True,img_filter=None):\n \"\"\"Loads COCO annotation json files and converts to tf.Record format.\n\n Args:\n annotations_file: JSON file containing bounding box annotations.\n image_dir: Directory containing the image files.\n output_path: Path to output tf.Record file.\n include_masks: Whether to include instance segmentations masks\n (PNG encoded) in the result. default: False.\n \"\"\"\n with tf.gfile.GFile(annotations_file, 'r') as fid:\n groundtruth_data = json.load(fid)\n images = groundtruth_data['images']\n if img_filter is not None:\n images = list(filter(img_filter,images))\n print(f\"Image len {len(images)}.\")\n category_index = label_map_util.create_category_index(\n groundtruth_data['categories'])\n\n annotations_index = {}\n if 'annotations' in groundtruth_data:\n tf.logging.info(\n 'Found groundtruth annotations. Building annotations index.')\n for annotation in groundtruth_data['annotations']:\n image_id = annotation['image_id']\n if image_id not in annotations_index:\n annotations_index[image_id] = []\n annotations_index[image_id].append(annotation)\n missing_annotation_count = 0\n for image in images:\n image_id = image['id']\n if image_id not in annotations_index:\n missing_annotation_count += 1\n annotations_index[image_id] = []\n tf.logging.info('%d images are missing annotations.',\n missing_annotation_count)\n\n tf.logging.info('writing to output path: %s', output_path)\n writer = tf.python_io.TFRecordWriter(output_path)\n total_num_annotations_skipped = 0\n skip_file = 0\n for idx, image in enumerate(images):\n if idx % 100 == 0:\n tf.logging.info('On image %d of %d', idx, len(images))\n if is_train_data and (TRAIN_SIZE_LIMIT is not None) and (idx>TRAIN_SIZE_LIMIT):\n break\n elif (not is_train_data) and (VAL_SIZE_LIMIT is not None) and (idx>VAL_SIZE_LIMIT):\n break\n annotations_list = annotations_index[image['id']]\n _, tf_example, num_annotations_skipped = create_tf_example(\n image, annotations_list, image_dir, category_index, include_masks)\n if tf_example is not None:\n total_num_annotations_skipped += num_annotations_skipped\n writer.write(tf_example.SerializeToString())\n else:\n skip_file += 1\n writer.close()\n tf.logging.info('Finished writing, skipped %d annotations. skipped %d files.',\n total_num_annotations_skipped,skip_file)\n\n\ndef main(_):\n assert FLAGS.train_image_dir, '`train_image_dir` missing.'\n assert FLAGS.val_image_dir, '`val_image_dir` missing.'\n assert FLAGS.train_annotations_file, '`train_annotations_file` missing.'\n assert FLAGS.val_annotations_file, '`val_annotations_file` missing.'\n\n if not tf.gfile.IsDirectory(FLAGS.output_dir):\n tf.gfile.MakeDirs(FLAGS.output_dir)\n train_output_path = os.path.join(FLAGS.output_dir, 'train_coco0.tfrecord')\n val_output_path = os.path.join(FLAGS.output_dir, 'train_coco1.tfrecord')\n\n _create_tf_record_from_coco_annotations(\n FLAGS.train_annotations_file,\n FLAGS.train_image_dir,\n train_output_path,\n FLAGS.include_masks,\n is_train_data=True)\n\n _create_tf_record_from_coco_annotations(\n FLAGS.val_annotations_file,\n FLAGS.val_image_dir,\n val_output_path,\n FLAGS.include_masks,\n is_train_data=True)\n\n\nif __name__ == '__main__':\n SCRATCH_DIR=wmlu.home_dir(\"ai/mldata/coco\")\n FLAGS.train_image_dir = os.path.join(SCRATCH_DIR,\"train2014\")\n FLAGS.val_image_dir = os.path.join(SCRATCH_DIR,\"val2014\")\n FLAGS.train_annotations_file = os.path.join(SCRATCH_DIR,\"annotations/instances_train2014.json\")\n FLAGS.val_annotations_file = os.path.join(SCRATCH_DIR,\"annotations/instances_val2014.json\")\n FLAGS.output_dir = output_dir = os.path.join(SCRATCH_DIR,\"voc_tfdata1\")\n tf.app.run()\n",
"import tensorflow as tf\nimport wml_tfutils as wmlt\nimport tfop\nfrom object_detection2.config.config import global_cfg\nfrom object_detection2.modeling.build import HEAD_OUTPUTS\nimport itertools\nimport logging\nimport numpy as np\nfrom ..sampling import subsample_labels\nimport wsummary\nfrom object_detection2.standard_names import *\nfrom object_detection2.datadef import *\nimport object_detection2.wlayers as odl\nimport wnn\nfrom .rpn_toolkit import *\n\nlogger = logging.getLogger(__name__)\n\ndef rpn_losses_giou(\n gt_objectness_logits,\n gt_anchor_deltas,\n pred_objectness_logits,\n pred_anchor_deltas,\n):\n reg_loss_sum = 1.0 - odl.giou(pred_anchor_deltas, gt_anchor_deltas)\n localization_loss = tf.reduce_sum(reg_loss_sum)\n\n objectness_loss = tf.losses.sigmoid_cross_entropy(\n logits=tf.expand_dims(pred_objectness_logits,1),\n multi_class_labels=tf.cast(tf.expand_dims(gt_objectness_logits,axis=1),tf.float32),\n reduction=tf.losses.Reduction.SUM,\n loss_collection=None\n )\n return objectness_loss, localization_loss\n\n\n@HEAD_OUTPUTS.register()\nclass RPNGIOUOutputs(object):\n def __init__(\n self,\n box2box_transform,\n anchor_matcher,\n batch_size_per_image,\n positive_fraction,\n pred_objectness_logits,\n pred_anchor_deltas,\n anchors,\n gt_boxes=None,\n gt_length=None,\n ):\n \"\"\"\n Args:\n box2box_transform (Box2BoxTransform): :class:`Box2BoxTransform` instance for\n anchor-proposal transformations.\n anchor_matcher (Matcher): :class:`Matcher` instance for matching anchors to\n ground-truth boxes; used to determine training labels.\n batch_size_per_image (int): number of proposals to sample when training\n positive_fraction (float): target fraction of sampled proposals that should be positive\n images (ImageList): :class:`ImageList` instance representing N input images\n pred_objectness_logits (list[Tensor]): A list of L elements.\n Element i is a tensor of shape (N, A, Hi, Wi) representing\n the predicted objectness logits for anchors.\n pred_anchor_deltas (list[Tensor]): A list of L elements. Element i is a tensor of shape\n (N, A*4, Hi, Wi) representing the predicted \"deltas\" used to transform anchors\n to proposals.\n anchors (list[Tensor]): A list of Tensor. Each element is a Tensor with shape [?,4]\n boundary_threshold (int): if >= 0, then anchors that extend beyond the image\n boundary by more than boundary_thresh are not used in training. Set to a very large\n number or < 0 to disable this behavior. Only needed in training.\n gt_boxes (list[Boxes], optional): A list of N elements. Element i a Boxes storing\n the ground-truth (\"gt\") boxes for image i.\n \"\"\"\n self.box2box_transform = box2box_transform\n self.anchor_matcher = anchor_matcher\n self.batch_size_per_image = batch_size_per_image\n self.positive_fraction = positive_fraction\n self.pred_objectness_logits = pred_objectness_logits\n self.pred_anchor_deltas = pred_anchor_deltas\n self.anchors_lens = [tf.shape(x)[0] for x in anchors]\n\n anchors = tf.concat(anchors,axis=0)\n anchors = tf.expand_dims(anchors,axis=0)\n self.anchors = anchors\n self.gt_boxes = gt_boxes\n self.gt_length = gt_length\n self.num_feature_maps = len(pred_objectness_logits)\n self.mid_results = {}\n print(\"RPNGIOUOutputs v1.0\")\n\n def _get_ground_truth(self):\n \"\"\"\n Returns:\n gt_objectness_logits: list of N tensors. Tensor i is a vector whose length is the\n total number of anchors in image i (i.e., len(anchors[i])). Label values are\n in {-1, 0, 1}, with meanings: -1 = ignore; 0 = negative class; 1 = positive class.\n gt_anchor_deltas: list of N tensors. Tensor i has shape (len(anchors[i]), 4).\n \"\"\"\n res = self.anchor_matcher(self.anchors,self.gt_boxes,tf.ones(tf.shape(self.gt_boxes)[:2]),self.gt_length,\n boxes_len=self.anchors_lens)\n gt_objectness_logits_i, scores, indices = res\n self.mid_results['anchor_matcher'] = res\n\n gt_anchor_deltas = wmlt.batch_gather(self.gt_boxes,tf.maximum(indices,0))\n #gt_objectness_logits_i为相应anchor box的标签\n return gt_objectness_logits_i, gt_anchor_deltas\n\n def losses(self):\n with tf.variable_scope(\"RPNLoss\"):\n gt_objectness_logits, gt_anchor_deltas = self._get_ground_truth()\n #In a image, all anchors concated togather and sample, Detectron2 use the same strategy\n pos_idx, neg_idx = subsample_labels(gt_objectness_logits,\n self.batch_size_per_image, self.positive_fraction)\n\n batch_size = self.pred_objectness_logits[0].get_shape().as_list()[0]\n num_cell_anchors = self.pred_objectness_logits[0].get_shape().as_list()[-1] #RPN num classes==1\n box_dim = self.pred_anchor_deltas[0].get_shape().as_list()[-1]//num_cell_anchors\n pred_objectness_logits = [tf.reshape(x,[batch_size,-1]) for x in self.pred_objectness_logits]\n pred_objectness_logits = tf.concat(pred_objectness_logits,axis=1)\n pred_anchor_deltas = [tf.reshape(x,[batch_size,-1,box_dim]) for x in self.pred_anchor_deltas]\n pred_anchor_deltas = tf.concat(pred_anchor_deltas,axis=1) #shape=[B,-1,4]\n pred_objectness_logits = tf.reshape(pred_objectness_logits,[-1])\n anchors = tf.tile(self.anchors,[batch_size,1,1])\n anchors = tf.reshape(anchors,[-1,box_dim])\n pred_anchor_deltas = tf.reshape(pred_anchor_deltas,[-1,box_dim])\n \n \n\n if global_cfg.GLOBAL.DEBUG:\n with tf.device(\":/cpu:0\"):\n with tf.name_scope(\"rpn_sampled_box\"):\n log_anchors = self.anchors*tf.ones([batch_size,1,1])\n logmask = tf.reshape(pos_idx,[batch_size,-1])\n wsummary.detection_image_summary_by_logmask(images=self.inputs[IMAGE],boxes=log_anchors,\n logmask=logmask)\n\n valid_mask = tf.logical_or(pos_idx,neg_idx)\n gt_objectness_logits = tf.reshape(gt_objectness_logits,[-1])\n gt_objectness_logits = tf.boolean_mask(gt_objectness_logits,valid_mask)\n pred_objectness_logits = tf.boolean_mask(pred_objectness_logits,valid_mask)\n \n gt_anchor_deltas = tf.reshape(gt_anchor_deltas,[-1,box_dim])\n \n gt_anchor_deltas = tf.boolean_mask(gt_anchor_deltas,pos_idx)\n pred_anchor_deltas = tf.boolean_mask(pred_anchor_deltas,pos_idx)\n anchors = tf.boolean_mask(anchors,pos_idx)\n \n pred_anchor_deltas = self.box2box_transform.apply_deltas(deltas=pred_anchor_deltas,boxes=anchors)\n objectness_loss, localization_loss = rpn_losses_giou(\n gt_objectness_logits,\n gt_anchor_deltas,\n pred_objectness_logits,\n pred_anchor_deltas,\n )\n if global_cfg.GLOBAL.SUMMARY_LEVEL<=SummaryLevel.INFO:\n with tf.name_scope(\"RPNCorrectRatio\"):\n ratio = wnn.sigmoid_accuracy_ratio(logits=pred_objectness_logits,labels=gt_objectness_logits)\n tf.summary.scalar(\"rpn_accuracy_ratio\",ratio)\n normalizer = 1.0 / (batch_size* self.batch_size_per_image)\n loss_cls = objectness_loss * normalizer # cls: classification loss\n loss_loc = localization_loss * normalizer # loc: localization loss\n losses = {\"loss_rpn_cls\": loss_cls, \"loss_rpn_loc\": loss_loc}\n wsummary.histogram_or_scalar(loss_cls,\"rpn/cls_loss\")\n wsummary.histogram_or_scalar(loss_loc,\"rpn/loc_loss\")\n\n return losses\n\n def predict_proposals(self):\n \"\"\"\n Transform anchors into proposals by applying the predicted anchor deltas.\n\n Returns:\n proposals (list[Tensor]): A list of L tensors. Tensor i has shape\n (N, Hi*Wi*A, B), where B is box dimension (4 or 5).\n \"\"\"\n with tf.name_scope(\"predict_proposals\"):\n batch_size = self.pred_objectness_logits[0].get_shape().as_list()[0]\n num_cell_anchors = self.pred_objectness_logits[0].get_shape().as_list()[-1]\n box_dim = self.pred_anchor_deltas[0].get_shape().as_list()[-1]//num_cell_anchors\n pred_anchor_deltas = [tf.reshape(x,[batch_size,-1,box_dim]) for x in self.pred_anchor_deltas]\n pred_anchor_deltas = tf.concat(pred_anchor_deltas,axis=1)\n proposals = self.box2box_transform.apply_deltas(deltas=pred_anchor_deltas,boxes=self.anchors)\n return proposals\n\n def predict_objectness_logits(self):\n \"\"\"\n Return objectness logits in the same format as the proposals returned by\n :meth:`predict_proposals`.\n\n Returns:\n pred_objectness_logits (list[Tensor]): A list of L tensors. Tensor i has shape\n (N, Hi*Wi*A).\n \"\"\"\n with tf.name_scope(\"predict_objectness_logits\"):\n batch_size = self.pred_objectness_logits[0].get_shape().as_list()[0]\n pred_objectness_logits = [tf.reshape(x,[batch_size,-1]) for x in self.pred_objectness_logits]\n pred_objectness_logits = tf.concat(pred_objectness_logits,axis=1)\n return pred_objectness_logits\n",
"#coding=utf-8\nfrom thirdparty.registry import Registry\nimport wmodule\nimport tensorflow as tf\nimport wml_tfutils as wmlt\nfrom object_detection2.datadef import *\nimport object_detection2.config.config as config\nimport image_visualization as ivis\nimport wsummary\nimport img_utils as wmli\nimport object_detection2.od_toolkit as odt\nimport basic_tftools as btf\nfrom basic_tftools import channel as get_channel\n\nslim = tf.contrib.slim\n\nROI_MASK_HEAD_REGISTRY = Registry(\"ROI_MASK_HEAD\")\nROI_MASK_HEAD_REGISTRY.__doc__ = \"\"\"\nRegistry for mask heads, which predicts instance masks given\nper-region features.\n\nThe registered object will be called with `obj(cfg, input_shape)`.\n\"\"\"\n\n\[email protected]_name_scope\ndef mask_rcnn_loss(inputs,pred_mask_logits, proposals:EncodedData,fg_selection_mask,log=True):\n '''\n\n :param inputs:inputs[GT_MASKS] [batch_size,N,H,W]\n :param pred_mask_logits: [Y,H,W,C] C==1 if cls_anostic_mask else num_classes, H,W is the size of mask\n not the position in org image\n :param proposals:proposals.indices:[batch_size,M], proposals.boxes [batch_size,M],proposals.gt_object_logits:[batch_size,M]\n :param fg_selection_mask: [X]\n X = batch_size*M\n Y = tf.reduce_sum(fg_selection_mask)\n :return:\n '''\n cls_agnostic_mask = pred_mask_logits.get_shape().as_list()[-1] == 1\n total_num_masks,mask_H,mask_W,C = wmlt.combined_static_and_dynamic_shape(pred_mask_logits)\n assert mask_H==mask_W, \"Mask prediction must be square!\"\n\n gt_masks = inputs[GT_MASKS] #[batch_size,N,H,W]\n\n with tf.device(\"/cpu:0\"):\n #当输入图像分辨率很高时这里可能会消耗过多的GPU资源，因此改在CPU上执行\n batch_size,X,H,W = wmlt.combined_static_and_dynamic_shape(gt_masks)\n #background include in proposals, which's indices is -1\n gt_masks = tf.reshape(gt_masks,[batch_size*X,H,W])\n indices = btf.twod_indexs_to_oned_indexs(tf.nn.relu(proposals.indices),depth=X)\n indices = tf.boolean_mask(indices,fg_selection_mask)\n gt_masks = tf.gather(gt_masks,indices)\n\n boxes = proposals.boxes\n batch_size,box_nr,box_dim = wmlt.combined_static_and_dynamic_shape(boxes)\n boxes = tf.reshape(boxes,[batch_size*box_nr,box_dim])\n boxes = tf.boolean_mask(boxes,fg_selection_mask)\n\n with tf.device(\"/cpu:0\"):\n #当输入图像分辨率很高时这里可能会消耗过多的GPU资源，因此改在CPU上执行\n gt_masks = tf.expand_dims(gt_masks,axis=-1)\n croped_masks_gt_masks = wmlt.tf_crop_and_resize(gt_masks,boxes,[mask_H,mask_W])\n\n if not cls_agnostic_mask:\n gt_classes = proposals.gt_object_logits\n gt_classes = tf.reshape(gt_classes,[-1])\n gt_classes = tf.boolean_mask(gt_classes,fg_selection_mask)\n pred_mask_logits = tf.transpose(pred_mask_logits,[0,3,1,2])\n pred_mask_logits = wmlt.batch_gather(pred_mask_logits,gt_classes-1) #预测中不包含背景\n pred_mask_logits = tf.expand_dims(pred_mask_logits,axis=-1)\n\n\n if log and config.global_cfg.GLOBAL.SUMMARY_LEVEL<=SummaryLevel.DEBUG:\n with tf.device(\":/cpu:0\"):\n with tf.name_scope(\"mask_loss_summary\"):\n pmasks_2d = tf.reshape(fg_selection_mask,[batch_size,box_nr])\n boxes_3d = tf.expand_dims(boxes,axis=1)\n wsummary.positive_box_on_images_summary(inputs[IMAGE],proposals.boxes,\n pmasks=pmasks_2d)\n image = wmlt.select_image_by_mask(inputs[IMAGE],pmasks_2d)\n t_gt_masks = tf.expand_dims(tf.squeeze(gt_masks,axis=-1),axis=1)\n wsummary.detection_image_summary(images=image,boxes=boxes_3d,instance_masks=t_gt_masks,\n name=\"mask_and_boxes_in_mask_loss\")\n log_mask = gt_masks\n log_mask = ivis.draw_detection_image_summary(log_mask,boxes=tf.expand_dims(boxes,axis=1))\n log_mask = wmli.concat_images([log_mask, croped_masks_gt_masks])\n wmlt.image_summaries(log_mask,\"mask\",max_outputs=3)\n\n log_mask = wmli.concat_images([gt_masks, tf.cast(pred_mask_logits>0.5,tf.float32)])\n wmlt.image_summaries(log_mask,\"gt_vs_pred\",max_outputs=3)\n mask_loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=croped_masks_gt_masks,logits=pred_mask_logits)\n mask_loss = btf.safe_reduce_mean(mask_loss)\n\n return mask_loss\n pass\n\[email protected]_name_scope\ndef mask_rcnn_inference(pred_mask_logits, pred_instances):\n \"\"\"\n Convert pred_mask_logits to estimated foreground probability masks while also\n extracting only the masks for the predicted classes in pred_instances. For each\n predicted box, the mask of the same class is attached to the instance by adding a\n new RD_MASKS field to pred_instances.\n\n Args:\n pred_mask_logits (Tensor): A tensor of shape (B,Hmask, Wmask,C) or (B, Hmask, Wmask, 1)\n for class-specific or class-agnostic, where B is the total number of predicted masks\n in all images, C is the number of foreground classes, and Hmask, Wmask are the height\n and width of the mask predictions. The values are logits.\n pred_instances (dict): A dict of prediction results, pred_instances[RD_LABELS]:[batch_size,Y],\n pred_instances[RD_LENGTH], [batch_size]\n current the batch_size must be 1, and X == pred_instances[RD_LENGTH][0] == Y\n Returns:\n None. pred_instances will contain an extra RD_MASKS field storing a mask of size [batch_size,Y,Hmask,\n Wmask] for predicted class. Note that the masks are returned as a soft (non-quantized)\n masks the resolution predicted by the network; post-processing steps, such as resizing\n the predicted masks to the original image resolution and/or binarizing them, is left\n to the caller.\n \"\"\"\n cls_agnostic_mask = pred_mask_logits.get_shape().as_list()[-1] == 1\n labels = pred_instances[RD_LABELS]\n batch_size,box_nr = wmlt.combined_static_and_dynamic_shape(labels)\n if not cls_agnostic_mask:\n # Select masks corresponding to the predicted classes\n pred_mask_logits = tf.transpose(pred_mask_logits,[0,3,1,2])\n labels = tf.reshape(labels,[-1])-1 #去掉背景\n #当同时预测多个图片时，labels后面可能有填充的0，上一步减1时可能出现负数\n pred_mask_logits = wmlt.batch_gather(pred_mask_logits,tf.nn.relu(labels))\n total_box_nr,H,W = wmlt.combined_static_and_dynamic_shape(pred_mask_logits)\n pred_mask_logits = tf.reshape(pred_mask_logits,[batch_size,box_nr,H,W])\n\n pred_mask_logits = tf.nn.sigmoid(pred_mask_logits)\n\n pred_instances[RD_MASKS] = pred_mask_logits\n\n\n@ROI_MASK_HEAD_REGISTRY.register()\nclass MaskRCNNConvUpsampleHead(wmodule.WChildModule):\n \"\"\"\n A mask head with several conv layers, plus an upsample layer (with `ConvTranspose2d`).\n \"\"\"\n\n def __init__(self, cfg,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv: the number of conv layers\n conv_dim: the dimension of the conv layers\n norm: normalization for the conv layers\n \"\"\"\n super(MaskRCNNConvUpsampleHead, self).__init__(cfg,**kwargs)\n #Detectron2默认没有使用normalizer, 使用测试数据发现是否使用normalizer并没有什么影响\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_MASK_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_MASK_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x):\n cfg = self.cfg\n # fmt: off\n num_classes = cfg.MODEL.ROI_HEADS.NUM_CLASSES\n conv_dims = cfg.MODEL.ROI_MASK_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_MASK_HEAD.NUM_CONV\n cls_agnostic_mask = cfg.MODEL.ROI_MASK_HEAD.CLS_AGNOSTIC_MASK\n # fmt: on\n num_mask_classes = 1 if cls_agnostic_mask else num_classes\n\n with tf.variable_scope(\"MaskHead\"):\n for k in range(num_conv):\n x = slim.conv2d(x,conv_dims,[3,3],padding=\"SAME\",\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n scope=f\"Conv{k}\")\n x = slim.conv2d_transpose(x,conv_dims,kernel_size=2,\n stride=2,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n scope=\"Upsample\")\n x = slim.conv2d(x,num_mask_classes,kernel_size=1,activation_fn=None,normalizer_fn=None,\n scope=\"predictor\")\n return x\n\n@ROI_MASK_HEAD_REGISTRY.register()\nclass HighResolutionMaskHead(wmodule.WChildModule):\n \"\"\"\n A mask head with several conv layers, plus an upsample layer (with `ConvTranspose2d`).\n \"\"\"\n\n def __init__(self, cfg,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv: the number of conv layers\n conv_dim: the dimension of the conv layers\n norm: normalization for the conv layers\n \"\"\"\n super(HighResolutionMaskHead, self).__init__(cfg,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_MASK_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_MASK_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x):\n cfg = self.cfg\n # fmt: off\n num_classes = cfg.MODEL.ROI_HEADS.NUM_CLASSES\n conv_dims = cfg.MODEL.ROI_MASK_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_MASK_HEAD.NUM_CONV\n cls_agnostic_mask = cfg.MODEL.ROI_MASK_HEAD.CLS_AGNOSTIC_MASK\n # fmt: on\n num_mask_classes = 1 if cls_agnostic_mask else num_classes\n x_channel = get_channel(x)\n assert x_channel>conv_dims,\"error conv dims for mask.\"\n\n with tf.variable_scope(\"MaskHead\"):\n x_identity,x = tf.split(x,num_or_size_splits=[x_channel-conv_dims,conv_dims],axis=-1)\n x_iden_channel = get_channel(x_identity)\n if 'G' in self.norm_params and self.norm_params['G'] > get_channel(x):\n self.norm_params['G'] = get_channel(x)\n for k in range(num_conv):\n x = slim.conv2d(x,conv_dims,[3,3],padding=\"SAME\",\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n scope=f\"Conv{k}\")\n x = slim.conv2d_transpose(x,x_iden_channel,kernel_size=2,\n stride=2,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n scope=\"Upsample\")\n B,H,W,C = btf.combined_static_and_dynamic_shape(x)\n x_identity = tf.image.resize_bilinear(x_identity,size=(H,W))\n x = x_identity+x\n x = slim.conv2d(x,num_mask_classes,kernel_size=1,activation_fn=None,normalizer_fn=None,\n scope=\"predictor\")\n return x\n\ndef build_mask_head(cfg,*args,**kwargs):\n \"\"\"\n Build a mask head defined by `cfg.MODEL.ROI_MASK_HEAD.NAME`.\n \"\"\"\n name = cfg.MODEL.ROI_MASK_HEAD.NAME\n return ROI_MASK_HEAD_REGISTRY.get(name)(cfg,*args,**kwargs)\n",
"import numpy as np\nimport tensorflow as tf\nfrom thirdparty.registry import Registry\nimport object_detection2.bboxes as odb\nimport wsummary\nimport wmodule\nimport wml_tfutils as wmlt\nimport wnnlayer as wnnl\nimport object_detection2.od_toolkit as odt\nfrom collections import Iterable\nfrom .build import ROI_BOX_HEAD_REGISTRY\nimport basic_tftools as btf\nfrom object_detection2.modeling.matcher import Matcher\nfrom object_detection2.standard_names import *\nfrom object_detection2.datadef import *\nfrom nlp.transformer import real_former_transformer_model\n\nslim = tf.contrib.slim\nclass BoxesForwardType:\n BBOXES = 1\n CLASSES = 2\n IOUS = 4\n ALL = 15\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass FastRCNNConvFCHead(wmodule.WChildModule):\n \"\"\"\n A head with several 3x3 conv layers (each followed by norm & relu) and\n several fc layers (each followed by relu).\n \"\"\"\n\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n '''\n Detectron2默认没有使用任何normalizer\n 但我在使用测试数据时发现，使用group_norm(默认参数)后性能会显著提升\n '''\n self.normalizer_fn = wnnl.group_norm\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\"):\n with tf.variable_scope(scope):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n for _ in range(num_conv):\n x = slim.conv2d(x,conv_dim,[3,3],activation_fn=tf.nn.relu,\n normalizer_fn=None)\n if num_fc>0:\n if len(x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n x = tf.reshape(x,[shape[0],dim])\n for _ in range(num_fc):\n x = slim.fully_connected(x,fc_dim,activation_fn=tf.nn.relu,\n normalizer_fn=self.normalizer_fn)\n return x\n\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHead(wmodule.WChildModule):\n \"\"\"\n \"\"\"\n\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\"):\n with tf.variable_scope(scope):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n if not isinstance(x,tf.Tensor) and isinstance(x,Iterable):\n assert len(x) == 2,\"error feature map length\"\n cls_x = x[0]\n box_x = x[1]\n else:\n cls_x = x\n box_x = x\n if cfg.MODEL.ROI_BOX_HEAD.FC_WEIGHT_DECAY > 0.0:\n fc_weights_regularizer = slim.l2_regularizer(cfg.MODEL.ROI_BOX_HEAD.FC_WEIGHT_DECAY)\n else:\n fc_weights_regularizer = None\n if cfg.MODEL.ROI_BOX_HEAD.CONV_WEIGHT_DECAY > 0.0:\n conv_weights_regularizer = slim.l2_regularizer(cfg.MODEL.ROI_BOX_HEAD.CONV_WEIGHT_DECAY)\n else:\n conv_weights_regularizer = None\n\n with tf.variable_scope(\"ClassPredictionTower\"):\n for _ in range(num_conv):\n cls_x = slim.conv2d(cls_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n weights_regularizer=conv_weights_regularizer,\n padding = 'SAME')\n\n\n if num_fc>0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n cls_x = tf.reshape(cls_x,[shape[0],dim])\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n weights_regularizer=fc_weights_regularizer,\n normalizer_params=self.norm_params)\n\n with tf.variable_scope(\"BoxPredictionTower\"):\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n weights_regularizer=conv_weights_regularizer,\n padding = 'SAME')\n\n if num_fc>0:\n if len(box_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(box_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n box_x = tf.reshape(box_x,[shape[0],dim])\n for _ in range(num_fc):\n box_x = slim.fully_connected(box_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n weights_regularizer=fc_weights_regularizer,\n normalizer_params=self.norm_params)\n\n return cls_x,box_x\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHeadV2(wmodule.WChildModule):\n \"\"\"\n Rethinking Classification and Localization for Object Detection\n \"\"\"\n\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\",reuse=None,fwd_type=BoxesForwardType.ALL):\n with tf.variable_scope(scope,reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n if not isinstance(x,tf.Tensor) and isinstance(x,Iterable):\n assert len(x) >= 2,\"error feature map length\"\n cls_x = x[0]\n box_x = x[1]\n if len(x)>=3:\n iou_x = x[2]\n else:\n iou_x = x[1]\n else:\n cls_x = x\n box_x = x\n iou_x = x\n\n with tf.variable_scope(\"ClassPredictionTower\"):\n if fwd_type&BoxesForwardType.CLASSES:\n if num_fc>0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n cls_x = tf.reshape(cls_x,[shape[0],dim])\n if cfg.MODEL.ROI_BOX_HEAD.FC_WEIGHT_DECAY > 0.0:\n weights_regularizer = slim.l2_regularizer(cfg.MODEL.ROI_BOX_HEAD.FC_WEIGHT_DECAY)\n else:\n weights_regularizer = None\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n weights_regularizer=weights_regularizer)\n \n if cfg.MODEL.ROI_BOX_HEAD.ENABLE_CLS_DROPBLOCK and self.is_training:\n keep_prob = wnnl.get_dropblock_keep_prob(tf.train.get_or_create_global_step(),self.cfg.SOLVER.STEPS[-1],\n max_keep_prob=self.cfg.MODEL.ROI_BOX_HEAD.CLS_KEEP_PROB)\n if self.cfg.GLOBAL.SUMMARY_LEVEL <= SummaryLevel.DEBUG:\n tf.summary.scalar(name=\"box_head_cls_keep_prob\",tensor=keep_prob)\n cls_x = slim.dropout(cls_x, keep_prob=keep_prob,is_training=self.is_training)\n\n with tf.variable_scope(\"BoxPredictionTower\"):\n if fwd_type&BoxesForwardType.BBOXES:\n if cfg.MODEL.ROI_BOX_HEAD.CONV_WEIGHT_DECAY > 0.0:\n weights_regularizer = slim.l2_regularizer(cfg.MODEL.ROI_BOX_HEAD.CONV_WEIGHT_DECAY)\n else:\n weights_regularizer = None\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n weights_regularizer=weights_regularizer)\n \n if cfg.MODEL.ROI_BOX_HEAD.ENABLE_BOX_DROPBLOCK and self.is_training:\n keep_prob = wnnl.get_dropblock_keep_prob(tf.train.get_or_create_global_step(),self.cfg.SOLVER.STEPS[-1],\n max_keep_prob=self.cfg.MODEL.ROI_BOX_HEAD.BOX_KEEP_PROB)\n if self.cfg.GLOBAL.SUMMARY_LEVEL <= SummaryLevel.DEBUG:\n tf.summary.scalar(name=\"box_head_box_keep_prob\",tensor=keep_prob)\n box_x = slim.dropout(box_x, keep_prob=keep_prob,is_training=self.is_training)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n if fwd_type&BoxesForwardType.IOUS:\n iou_num_conv = cfg.MODEL.ROI_BOX_HEAD.IOU_NUM_CONV\n iou_num_fc = cfg.MODEL.ROI_BOX_HEAD.IOU_NUM_FC\n with tf.variable_scope(\"BoxIOUPredictionTower\"):\n for _ in range(iou_num_conv):\n iou_x = slim.conv2d(iou_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n if iou_num_fc>0:\n if len(iou_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(iou_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n iou_x = tf.reshape(iou_x,[shape[0],dim])\n for _ in range(iou_num_fc):\n iou_x = slim.fully_connected(iou_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x,box_x,iou_x\n else:\n return cls_x,box_x\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHeadV3(wmodule.WChildModule):\n \"\"\"\n \"\"\"\n\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\"):\n with tf.variable_scope(scope):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n if not isinstance(x,tf.Tensor) and isinstance(x,Iterable):\n assert len(x) == 2,\"error feature map length\"\n cls_x = x[0]\n box_x = x[1]\n else:\n cls_x = x\n box_x = x\n\n with tf.variable_scope(\"ClassPredictionTower\"):\n lconv_dim = conv_dim\n for _ in range(num_conv):\n lconv_dim += 64\n cls_x = slim.conv2d(cls_x,lconv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n padding = 'VALID')\n\n\n if num_fc>0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n cls_x = tf.reshape(cls_x,[shape[0],dim])\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n\n with tf.variable_scope(\"BoxPredictionTower\"):\n lconv_dim = conv_dim\n for _ in range(num_conv):\n lconv_dim += 64\n box_x = slim.conv2d(box_x,lconv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n padding = 'VALID')\n\n if num_fc>0:\n if len(box_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(box_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n box_x = tf.reshape(box_x,[shape[0],dim])\n for _ in range(num_fc):\n box_x = slim.fully_connected(box_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n\n return cls_x,box_x\n\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHeadV4(wmodule.WChildModule):\n \"\"\"\n Rethinking Classification and Localization for Object Detection\n \"\"\"\n\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\",reuse=None,fwd_type=BoxesForwardType.ALL):\n with tf.variable_scope(scope,reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n if not isinstance(x,tf.Tensor) and isinstance(x,Iterable):\n assert len(x) >= 2,\"error feature map length\"\n cls_x = x[0]\n box_x = x[1]\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n if len(x) == 3:\n iou_x = x[2]\n else:\n iou_x = box_x\n else:\n cls_x = x\n box_x = x\n iou_x = x\n\n if fwd_type&BoxesForwardType.CLASSES:\n with tf.variable_scope(\"ClassPredictionTower\"):\n if num_fc>0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n cls_x = tf.reshape(cls_x,[shape[0],dim])\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n if fwd_type&BoxesForwardType.BBOXES:\n with tf.variable_scope(\"BoxPredictionTower\"):\n nets = []\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n nets.append(box_x)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU and ( fwd_type&BoxesForwardType.IOUS or fwd_type&BoxesForwardType.BBOXES):\n with tf.variable_scope(\"BoxIOUPredictionTower\",reuse=tf.AUTO_REUSE):\n if num_fc > 0:\n if len(iou_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(iou_x)\n dim = 1\n for i in range(1, len(shape)):\n dim = dim * shape[i]\n iou_x = tf.reshape(iou_x, [shape[0], dim])\n for _ in range(num_fc):\n iou_x = slim.fully_connected(iou_x, fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n box_channel = btf.channel(box_x)\n att = slim.fully_connected(iou_x,box_channel,\n activation_fn=tf.nn.sigmoid,\n normalizer_fn=None)\n att = tf.expand_dims(att, axis=1)\n att = tf.expand_dims(att, axis=1)\n wsummary.histogram_or_scalar(att,\"iou_box_att\")\n box_x = box_x*att\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x,box_x,iou_x\n else:\n return cls_x,box_x\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass FastRCNNConvHead(wmodule.WChildModule):\n\n def __init__(self, cfg,*args,**kwargs):\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x,scope=\"FastRCNNConvHead\",reuse=None):\n with tf.variable_scope(scope,reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n\n for _ in range(num_conv):\n x = slim.conv2d(x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_params=self.norm_params,\n normalizer_fn=self.normalizer_fn)\n cls_x = x\n box_x = x\n msk_x = x\n cls_x = slim.conv2d(cls_x,256,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n padding = 'SAME',\n scope=\"cls\")\n\n\n box_x = slim.conv2d(box_x,256,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n padding = 'VALID',\n scope=\"box\")\n if cfg.MODEL.MASK_ON:\n msk_x = slim.conv2d(msk_x, 256, [3, 3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n padding='SAME',\n scope=\"mask\")\n return cls_x,box_x,msk_x\n else:\n return cls_x,box_x\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHeadV5(wmodule.WChildModule):\n \"\"\"\n Rethinking Classification and Localization for Object Detection\n \"\"\"\n\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\",reuse=None):\n with tf.variable_scope(scope,reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n assert len(x) == 2,\"error feature map length\"\n cls_x = x[0]\n box_x = wnnl.non_local_blockv3(x[0],x[1],x[1],inner_dims_multiplier=[1,1,1],\n normalizer_params=self.norm_params,\n normalizer_fn=self.normalizer_fn,\n activation_fn=self.activation_fn)\n with tf.variable_scope(\"ClassPredictionTower\"):\n if num_fc>0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n cls_x = tf.reshape(cls_x,[shape[0],dim])\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n with tf.variable_scope(\"BoxPredictionTower\"):\n nets = []\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n nets.append(box_x)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n with tf.variable_scope(\"BoxIOUPredictionTower\"):\n net = nets[-2]\n iou_x = slim.conv2d(net,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x,box_x,iou_x\n else:\n return cls_x,box_x\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHeadV6(wmodule.WChildModule):\n \"\"\"\n Rethinking Classification and Localization for Object Detection\n \"\"\"\n\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\",reuse=None):\n with tf.variable_scope(scope,reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n assert len(x) == 2,\"error feature map length\"\n cls_x = x[0]\n box_x = wnnl.non_local_blockv3(x[1],x[0],x[0],inner_dims_multiplier=[1,1,1],\n normalizer_params=self.norm_params,\n normalizer_fn=self.normalizer_fn,\n activation_fn=self.activation_fn)\n with tf.variable_scope(\"ClassPredictionTower\"):\n if num_fc>0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n cls_x = tf.reshape(cls_x,[shape[0],dim])\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n with tf.variable_scope(\"BoxPredictionTower\"):\n nets = []\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n nets.append(box_x)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n with tf.variable_scope(\"BoxIOUPredictionTower\"):\n net = nets[-2]\n iou_x = slim.conv2d(net,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x,box_x,iou_x\n else:\n return cls_x,box_x\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHeadV7(wmodule.WChildModule):\n \"\"\"\n Rethinking Classification and Localization for Object Detection\n \"\"\"\n\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\",reuse=None):\n with tf.variable_scope(scope,reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n assert len(x) == 2,\"error feature map length\"\n with tf.variable_scope(\"Attenation\"):\n _,S0,_,C = wmlt.combined_static_and_dynamic_shape(x[0])\n _,S1,_,_ = wmlt.combined_static_and_dynamic_shape(x[1])\n E_nr = (S1-S0)//2\n data0 = x[1][:,0:E_nr:,E_nr:E_nr+S0,:]\n data1 = x[1][:,E_nr:E_nr+S0,S1-E_nr:,:]\n data2 = x[1][:,S1-E_nr:,E_nr:E_nr+S0,:]\n data3 = x[1][:,E_nr:E_nr+S0,0:E_nr,:]\n def data_trans(_data):\n i,data = _data\n data = wnnl.non_local_blockv3(x[0],data,data,inner_dims_multiplier=[2,2,2],\n normalizer_params=self.norm_params,\n normalizer_fn=self.normalizer_fn,\n activation_fn=self.activation_fn,\n weighed_sum=False,skip_connect=False,\n scope=f\"trans_data{i}\")\n return data\n datas = [data0,data1,data2,data3]\n datas = list(map(data_trans,enumerate(datas)))\n datas = tf.concat(datas,axis=-1)\n datas = tf.reduce_mean(datas,axis=[1,2],keepdims=False)\n datas = slim.fully_connected(datas,C, activation_fn=tf.nn.relu, normalizer_fn=None)\n att = slim.fully_connected(datas,C, activation_fn=tf.nn.sigmoid, normalizer_fn=None)\n att = tf.expand_dims(att,axis=1)\n att = tf.expand_dims(att,axis=1)\n\n x_data = x[0]*att\n\n\n cls_x = x_data\n box_x = x_data\n with tf.variable_scope(\"ClassPredictionTower\"):\n if num_fc>0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n cls_x = tf.reshape(cls_x,[shape[0],dim])\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n with tf.variable_scope(\"BoxPredictionTower\"):\n nets = []\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n nets.append(box_x)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n with tf.variable_scope(\"BoxIOUPredictionTower\"):\n net = nets[-2]\n iou_x = slim.conv2d(net,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x,box_x,iou_x\n else:\n return cls_x,box_x\n \n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHeadV8(wmodule.WChildModule):\n \"\"\"\n Rethinking Classification and Localization for Object Detection\n \"\"\"\n MAX_IOU = 0.9\n def __init__(self, cfg,*args,**kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg,*args,**kwargs)\n self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM,self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n self.iou_threshold = 0.5\n self.head_nr = 4\n self.num_classes = cfg.MODEL.ROI_HEADS.NUM_CLASSES #不包含背景\n self.cls_agnostic_bbox_reg = cfg.MODEL.ROI_BOX_HEAD.CLS_AGNOSTIC_BBOX_REG\n self.box_dim = 4\n\n def forward_branch(self,cls_x,box_x,branch):\n cfg = self.cfg\n\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n with tf.variable_scope(f\"ClassPredictionTower{branch}\"):\n if num_fc > 0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1, len(shape)):\n dim = dim * shape[i]\n cls_x = tf.reshape(cls_x, [shape[0], dim])\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x, fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n with tf.variable_scope(f\"BoxPredictionTower{branch}\"):\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x, conv_dim, [3, 3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n\n return cls_x,box_x\n\n '''def forward_with_ious(self,cls_x,box_x,ious):\n cls_x_datas = []\n box_x_datas = []\n index = tf.nn.relu(ious-self.iou_threshold)*self.head_nr/(1-self.iou_threshold)\n for i in range(self.head_nr):\n data = self.forward_branch(cls_x,box_x,i)\n cls_x_datas.append(data[0])\n box_x_datas.append(data[1])\n\n wsummary.histogram_or_scalar(index,\"head_index\")\n index = tf.cast(index,tf.int32)\n index = tf.clip_by_value(index,clip_value_min=0,clip_value_max=self.head_nr-1)\n cls_x_datas = tf.stack(cls_x_datas,axis=1)\n cls_x = wmlt.batch_gather(cls_x_datas,index)\n box_x_datas = tf.stack(box_x_datas,axis=1)\n box_x = wmlt.batch_gather(box_x_datas,index)\n\n return cls_x,box_x'''\n\n def trans(self,net):\n if len(net.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(net)\n dim = 1\n for x in shape[1:]:\n dim *= x\n return tf.reshape(net, [shape[0], dim])\n else:\n return net\n\n def forward_with_ious(self,cls_x,box_x,ious):\n foreground_num_classes = self.num_classes\n num_bbox_reg_classes = 1 if self.cls_agnostic_bbox_reg else foreground_num_classes\n \n cls_x_datas = []\n box_x_datas = []\n index = tf.nn.relu(ious-self.iou_threshold)*self.head_nr/(self.MAX_IOU-self.iou_threshold)\n wsummary.histogram_or_scalar(index,\"head_index\")\n index = tf.cast(index,tf.int32)\n index = tf.clip_by_value(index,clip_value_min=0,clip_value_max=self.head_nr-1)\n data_indexs = []\n B = btf.batch_size(cls_x)\n data_raw_indexs = tf.range(B,dtype=tf.int32)\n for i in range(self.head_nr):\n mask = tf.equal(index,i)\n data_indexs.append(tf.boolean_mask(data_raw_indexs,mask))\n t_cls_x = tf.boolean_mask(cls_x,mask)\n t_box_x = tf.boolean_mask(box_x,mask)\n data = self.forward_branch(t_cls_x,t_box_x,i)\n cls_x_datas.append(data[0])\n box_x_datas.append(data[1])\n\n cls_x_datas = tf.concat(cls_x_datas,axis=0)\n cls_x_datas = self.trans(cls_x_datas)\n box_x_datas = tf.concat(box_x_datas,axis=0)\n box_x_datas = self.trans(box_x_datas)\n with tf.variable_scope(\"BoxPredictor\"):\n cls_x_datas = slim.fully_connected(cls_x_datas, self.num_classes + 1, activation_fn=None,\n normalizer_fn=None, scope=\"cls_score\")\n box_x_datas = slim.fully_connected(box_x_datas, self.box_dim * num_bbox_reg_classes, activation_fn=None,\n normalizer_fn=None, scope=\"bbox_pred\")\n data_indexs = tf.concat(data_indexs,axis=0)\n data_indexs = tf.reshape(data_indexs,[B,1])\n \n shape = wmlt.combined_static_and_dynamic_shape(cls_x_datas)\n shape[0] = B\n cls_x = tf.scatter_nd(data_indexs,cls_x_datas,shape)\n shape = wmlt.combined_static_and_dynamic_shape(box_x_datas)\n shape[0] = B\n box_x = tf.scatter_nd(data_indexs,box_x_datas,shape)\n\n return cls_x,box_x\n\n\n def forward(self, x,scope=\"FastRCNNConvFCHead\",reuse=None):\n with tf.variable_scope(scope,reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n if not isinstance(x,tf.Tensor) and isinstance(x,Iterable):\n assert len(x) >= 2,\"error feature map length\"\n cls_x = x[0]\n box_x = x[1]\n if len(x)>=3:\n iou_x = x[2]\n else:\n iou_x = x[1]\n else:\n cls_x = x\n box_x = x\n iou_x = x\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n iou_num_conv = cfg.MODEL.ROI_BOX_HEAD.IOU_NUM_CONV\n iou_num_fc = cfg.MODEL.ROI_BOX_HEAD.IOU_NUM_FC\n with tf.variable_scope(\"BoxIOUPredictionTower\"):\n for _ in range(iou_num_conv):\n iou_x = slim.conv2d(iou_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n if iou_num_fc>0:\n if len(iou_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(iou_x)\n dim = 1\n for i in range(1,len(shape)):\n dim = dim*shape[i]\n iou_x = tf.reshape(iou_x,[shape[0],dim])\n for _ in range(iou_num_fc):\n iou_x = slim.fully_connected(iou_x,fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n iou_x = self.trans(iou_x)\n with tf.variable_scope(\"BoxPredictor\"):\n iou_x = slim.fully_connected(iou_x, 1,\n activation_fn=None,\n normalizer_fn=None,\n scope=\"iou_pred\")\n\n with tf.name_scope(\"get_ious\"):\n if self.is_training:\n def fn0():\n matcher = Matcher(\n [1e-3],\n allow_low_quality_matches=False,\n cfg=self.cfg,\n parent=self\n )\n mh_res0 = matcher(self.parent.t_proposal_boxes,\n self.parent.batched_inputs[GT_BOXES],\n self.parent.batched_inputs[GT_LABELS],\n self.parent.batched_inputs[GT_LENGTH])\n ious0 = tf.reshape(mh_res0[1],[-1]) #proposal_boxes与gt boxes的 iou\n return ious0\n\n def fn1():\n ious1 = tf.nn.sigmoid(iou_x)\n ious1 = tf.reshape(ious1,[-1])\n return ious1\n\n use_gt_probability = wnnl.get_dropblock_keep_prob(tf.train.get_or_create_global_step(),self.cfg.SOLVER.STEPS[-1],\n max_keep_prob=0.01)\n tf.summary.scalar(name=\"use_gt_ious_probability\",tensor=use_gt_probability)\n p = tf.random_uniform(())\n ious = tf.cond(tf.less(p,use_gt_probability),fn0,fn1)\n else:\n ious = tf.nn.sigmoid(iou_x)\n ious = tf.reshape(ious,[-1])\n\n cls_x,box_x = self.forward_with_ious(cls_x,box_x,ious)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x,box_x,iou_x\n else:\n return cls_x,box_x\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNConvFCHeadV9(wmodule.WChildModule):\n \"\"\"\n Rethinking Classification and Localization for Object Detection\n \"\"\"\n\n def __init__(self, cfg, *args, **kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg, *args, **kwargs)\n self.normalizer_fn, self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM, self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n self.size_threshold = 64\n self.head_nr = 4\n self.num_classes = cfg.MODEL.ROI_HEADS.NUM_CLASSES # 不包含背景\n self.cls_agnostic_bbox_reg = cfg.MODEL.ROI_BOX_HEAD.CLS_AGNOSTIC_BBOX_REG\n self.box_dim = 4\n\n def forward_branch(self, cls_x, box_x, branch):\n cfg = self.cfg\n\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n\n assert num_conv + num_fc > 0\n\n with tf.variable_scope(f\"ClassPredictionTower{branch}\"):\n if num_fc > 0:\n if len(cls_x.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(cls_x)\n dim = 1\n for i in range(1, len(shape)):\n dim = dim * shape[i]\n cls_x = tf.reshape(cls_x, [shape[0], dim])\n for _ in range(num_fc):\n cls_x = slim.fully_connected(cls_x, fc_dim,\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n with tf.variable_scope(f\"BoxPredictionTower{branch}\"):\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x, conv_dim, [3, 3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params)\n\n return cls_x, box_x\n\n def trans(self, net):\n if len(net.get_shape()) > 2:\n shape = wmlt.combined_static_and_dynamic_shape(net)\n dim = 1\n for x in shape[1:]:\n dim *= x\n return tf.reshape(net, [shape[0], dim])\n else:\n return net\n\n def forward_with_size(self, cls_x, box_x, size):\n foreground_num_classes = self.num_classes\n num_bbox_reg_classes = 1 if self.cls_agnostic_bbox_reg else foreground_num_classes\n\n cls_x_datas = []\n box_x_datas = []\n index = tf.nn.relu(size) * self.head_nr /self.size_threshold\n wsummary.histogram_or_scalar(index, \"head_index\")\n index = tf.cast(index, tf.int32)\n index = tf.clip_by_value(index, clip_value_min=0, clip_value_max=self.head_nr - 1)\n data_indexs = []\n B = btf.batch_size(cls_x)\n data_raw_indexs = tf.range(B, dtype=tf.int32)\n for i in range(self.head_nr):\n mask = tf.equal(index, i)\n data_indexs.append(tf.boolean_mask(data_raw_indexs, mask))\n t_cls_x = tf.boolean_mask(cls_x, mask)\n t_box_x = tf.boolean_mask(box_x, mask)\n data = self.forward_branch(t_cls_x, t_box_x, i)\n cls_x_datas.append(data[0])\n box_x_datas.append(data[1])\n\n cls_x_datas = tf.concat(cls_x_datas, axis=0)\n cls_x_datas = self.trans(cls_x_datas)\n box_x_datas = tf.concat(box_x_datas, axis=0)\n box_x_datas = self.trans(box_x_datas)\n with tf.variable_scope(\"BoxPredictor\"):\n cls_x_datas = slim.fully_connected(cls_x_datas, self.num_classes + 1, activation_fn=None,\n normalizer_fn=None, scope=\"cls_score\")\n box_x_datas = slim.fully_connected(box_x_datas, self.box_dim * num_bbox_reg_classes, activation_fn=None,\n normalizer_fn=None, scope=\"bbox_pred\")\n data_indexs = tf.concat(data_indexs, axis=0)\n data_indexs = tf.reshape(data_indexs, [B, 1])\n\n shape = wmlt.combined_static_and_dynamic_shape(cls_x_datas)\n shape[0] = B\n cls_x = tf.scatter_nd(data_indexs, cls_x_datas, shape)\n shape = wmlt.combined_static_and_dynamic_shape(box_x_datas)\n shape[0] = B\n box_x = tf.scatter_nd(data_indexs, box_x_datas, shape)\n\n return cls_x, box_x\n\n def forward(self, x, scope=\"FastRCNNConvFCHeadV9\", reuse=None):\n with tf.variable_scope(scope, reuse=reuse):\n cfg = self.cfg\n if not isinstance(x, tf.Tensor) and isinstance(x, Iterable):\n assert len(x) >= 2, \"error feature map length\"\n cls_x = x[0]\n box_x = x[1]\n if len(x) >= 3:\n iou_x = x[2]\n else:\n iou_x = x[1]\n else:\n cls_x = x\n box_x = x\n iou_x = x\n with tf.name_scope(\"get_size\"):\n img_size = wmlt.combined_static_and_dynamic_shape(self.parent.batched_inputs[IMAGE])\n p_bboxes = odb.tfrelative_boxes_to_absolutely_boxes(self.parent.t_proposal_boxes,width=img_size[2],height=img_size[1])\n bboxes_size = tf.sqrt(odb.box_area(p_bboxes))\n bboxes_size = tf.reshape(bboxes_size,[-1])\n\n cls_x, box_x = self.forward_with_size(cls_x, box_x, bboxes_size)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x, box_x, iou_x\n else:\n return cls_x, box_x\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNAttHeadV1(wmodule.WChildModule):\n\n def __init__(self, cfg, *args, **kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg, *args, **kwargs)\n self.normalizer_fn, self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM, self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n self.size_threshold = 64\n self.head_nr = 4\n self.num_classes = cfg.MODEL.ROI_HEADS.NUM_CLASSES # 不包含背景\n self.cls_agnostic_bbox_reg = cfg.MODEL.ROI_BOX_HEAD.CLS_AGNOSTIC_BBOX_REG\n self.box_dim = 4\n\n def forward(self, x, scope=\"SeparateFastRCNNAttHeadV1\", reuse=None):\n with tf.variable_scope(scope, reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n cfg = self.cfg\n\n def add_encode_data(x, scope):\n assert len(x.get_shape()) == 3, f\"Error x shape size {x.get_shape()}\"\n with tf.variable_scope(scope, \"add_tag\"):\n shape = wmlt.combined_static_and_dynamic_shape(x)\n add_data = tf.get_variable(\"output_tag\", shape=[1, 1, shape[-1]], dtype=x.dtype,\n initializer=tf.zeros_initializer())\n add_data = tf.tile(add_data,[shape[0],1,1])\n return tf.concat([add_data, x], axis=1)\n\n def pos_embedding(x,scope=None):\n shape = wmlt.combined_static_and_dynamic_shape(x)\n with tf.variable_scope(scope,default_name=\"pos_embedding\"):\n pos_embs_shape = [1, shape[1], shape[2]]\n pos_embedding = tf.get_variable(\"pos_embs\", shape=pos_embs_shape, dtype=tf.float32,\n initializer=tf.random_normal_initializer(stddev=0.02))\n\n return x+pos_embedding\n\n def trans_data(x,name=None):\n assert len(x.get_shape())==4, f\"Error x shape size {x.get_shape()}\"\n shape = wmlt.combined_static_and_dynamic_shape(x)\n x = tf.reshape(x, [shape[0], shape[1]*shape[2],shape[-1]])\n x = add_encode_data(x,scope=name+\"_add_tag\")\n x = pos_embedding(x,scope=name+\"_embedding\")\n x = tf.layers.dense(\n x,\n fc_dim,\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),\n name = name+\"_dense\")\n return x\n\n\n if not isinstance(x, tf.Tensor) and isinstance(x, Iterable):\n assert len(x) >= 2, \"error feature map length\"\n cls_x = x[0]\n box_x = x[1]\n if len(x) >= 3:\n iou_x = x[2]\n else:\n iou_x = x[1]\n else:\n cls_x = x\n box_x = x\n iou_x = x\n\n cls_x = trans_data(cls_x,\"cls\")\n box_x = trans_data(box_x,\"box\")\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n iou_x = trans_data(iou_x,\"iou\")\n with tf.variable_scope(\"ClassPredictionTower\"):\n cls_x = real_former_transformer_model(cls_x,hidden_size=fc_dim,\n num_hidden_layers=num_fc,\n num_attention_heads=4,\n intermediate_size=fc_dim,\n is_training=self.is_training)\n cls_x = cls_x[:,0,:]\n\n with tf.variable_scope(\"BoxPredictionTower\"):\n box_x = real_former_transformer_model(box_x,hidden_size=fc_dim,\n num_hidden_layers=num_fc,\n num_attention_heads=4,\n intermediate_size=fc_dim,\n is_training=self.is_training)\n box_x = box_x[:,0,:]\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n with tf.variable_scope(\"BoxPredictionTower\"):\n iou_x = real_former_transformer_model(iou_x,hidden_size=fc_dim,\n num_hidden_layers=num_fc,\n num_attention_heads=4,\n intermediate_size=fc_dim,\n is_training=self.is_training)\n iou_x = iou_x[:,0,:]\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x, box_x, iou_x\n else:\n return cls_x, box_x\n\n\n@ROI_BOX_HEAD_REGISTRY.register()\nclass SeparateFastRCNNAttHeadV2(wmodule.WChildModule):\n\n def __init__(self, cfg, *args, **kwargs):\n \"\"\"\n The following attributes are parsed from config:\n num_conv, num_fc: the number of conv/fc layers\n conv_dim/fc_dim: the dimension of the conv/fc layers\n norm: normalization for the conv layers\n \"\"\"\n super().__init__(cfg, *args, **kwargs)\n self.normalizer_fn, self.norm_params = odt.get_norm(self.cfg.MODEL.ROI_BOX_HEAD.NORM, self.is_training)\n self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)\n self.size_threshold = 64\n self.head_nr = 4\n self.num_classes = cfg.MODEL.ROI_HEADS.NUM_CLASSES # 不包含背景\n self.cls_agnostic_bbox_reg = cfg.MODEL.ROI_BOX_HEAD.CLS_AGNOSTIC_BBOX_REG\n self.box_dim = 4\n\n def forward(self, x, scope=\"SeparateFastRCNNAttHeadV2\", reuse=None):\n with tf.variable_scope(scope, reuse=reuse):\n cfg = self.cfg\n conv_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_DIM\n num_conv = cfg.MODEL.ROI_BOX_HEAD.NUM_CONV\n fc_dim = cfg.MODEL.ROI_BOX_HEAD.FC_DIM\n num_fc = cfg.MODEL.ROI_BOX_HEAD.NUM_FC\n cfg = self.cfg\n\n def add_encode_data(x,scope):\n assert len(x.get_shape()) == 3, f\"Error x shape size {x.get_shape()}\"\n with tf.variable_scope(scope,\"add_tag\"):\n shape = wmlt.combined_static_and_dynamic_shape(x)\n add_data = tf.get_variable(\"output_tag\",shape=[1, 1, shape[-1]], dtype=x.dtype,\n initializer=tf.zeros_initializer())\n add_data = tf.tile(add_data,[shape[0],1,1])\n return tf.concat([add_data, x], axis=1)\n\n def pos_embedding(x, scope=None):\n shape = wmlt.combined_static_and_dynamic_shape(x)\n with tf.variable_scope(scope, default_name=\"pos_embedding\"):\n pos_embs_shape = [1, shape[1], shape[2]]\n pos_embedding = tf.get_variable(\"pos_embs\", shape=pos_embs_shape, dtype=tf.float32,\n initializer=tf.random_normal_initializer(stddev=0.02))\n\n return x + pos_embedding\n\n def trans_data(x, name=None):\n assert len(x.get_shape()) == 4, f\"Error x shape size {x.get_shape()}\"\n shape = wmlt.combined_static_and_dynamic_shape(x)\n x = tf.reshape(x, [shape[0], shape[1] * shape[2], shape[-1]])\n x = add_encode_data(x,scope=name+\"_add_tag\")\n x = pos_embedding(x, scope=name + \"_embedding\")\n x = tf.layers.dense(\n x,\n fc_dim,\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),\n name=name + \"_dense\")\n return x\n\n if not isinstance(x, tf.Tensor) and isinstance(x, Iterable):\n assert len(x) >= 2, \"error feature map length\"\n cls_x = x[0]\n box_x = x[1]\n if len(x) >= 3:\n iou_x = x[2]\n else:\n iou_x = x[1]\n else:\n cls_x = x\n box_x = x\n iou_x = x\n\n cls_x = trans_data(cls_x, \"cls\")\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n iou_x = trans_data(iou_x,\"iou\")\n with tf.variable_scope(\"ClassPredictionTower\"):\n cls_x = real_former_transformer_model(cls_x, hidden_size=fc_dim,\n num_hidden_layers=num_fc,\n num_attention_heads=4,\n intermediate_size=fc_dim,\n is_training=self.is_training)\n cls_x = cls_x[:, 0, :]\n\n with tf.variable_scope(\"BoxPredictionTower\"):\n if cfg.MODEL.ROI_BOX_HEAD.CONV_WEIGHT_DECAY > 0.0:\n weights_regularizer = slim.l2_regularizer(cfg.MODEL.ROI_BOX_HEAD.CONV_WEIGHT_DECAY)\n else:\n weights_regularizer = None\n for _ in range(num_conv):\n box_x = slim.conv2d(box_x,conv_dim,[3,3],\n activation_fn=self.activation_fn,\n normalizer_fn=self.normalizer_fn,\n normalizer_params=self.norm_params,\n weights_regularizer=weights_regularizer)\n\n if cfg.MODEL.ROI_BOX_HEAD.ENABLE_BOX_DROPBLOCK and self.is_training:\n keep_prob = wnnl.get_dropblock_keep_prob(tf.train.get_or_create_global_step(),self.cfg.SOLVER.STEPS[-1],\n max_keep_prob=self.cfg.MODEL.ROI_BOX_HEAD.BOX_KEEP_PROB)\n if self.cfg.GLOBAL.SUMMARY_LEVEL <= SummaryLevel.DEBUG:\n tf.summary.scalar(name=\"box_head_box_keep_prob\",tensor=keep_prob)\n box_x = slim.dropout(box_x, keep_prob=keep_prob,is_training=self.is_training)\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n with tf.variable_scope(\"BoxIOUPredictionTower\"):\n iou_x = real_former_transformer_model(iou_x, hidden_size=fc_dim,\n num_hidden_layers=num_fc,\n num_attention_heads=4,\n intermediate_size=fc_dim,\n is_training=self.is_training)\n iou_x = iou_x[:, 0, :]\n\n if cfg.MODEL.ROI_HEADS.PRED_IOU:\n return cls_x, box_x, iou_x\n else:\n return cls_x, box_x\n",
"import torch\nfrom wsummary import _draw_text_on_image\nfrom collections import Iterable\nimport numpy as np\n#import tensorboardX as tb\n#tb.SummaryWriter.add_video()\n#tb.add_images\n\ndef log_all_variable(tb,net:torch.nn.Module,global_step):\n for name,param in net.named_parameters():\n if param.numel()>1:\n tb.add_histogram(name,param,global_step)\n else:\n tb.add_scalar(name,param,global_step)\n\n data = net.state_dict()\n for name in data:\n if \"running\" in name:\n param = data[name]\n if param.numel()>1:\n tb.add_histogram(\"BN_\"+name,param,global_step)\n else:\n tb.add_scalar(\"BN\"+name,param,global_step)\n\ndef log_basic_info(tb,name,value:torch.Tensor,global_step):\n if value.numel()>1:\n min_v = torch.min(value)\n max_v = torch.max(value)\n mean_v = torch.mean(value)\n std_v = torch.std(value)\n tb.add_scalar(name+\"_min\",min_v,global_step)\n tb.add_scalar(name+\"_max\",max_v,global_step)\n tb.add_scalar(name+\"_mean\",mean_v,global_step)\n tb.add_scalar(name+\"_std\",std_v,global_step)\n else:\n tb.add_scalar(name,value,global_step)\n\ndef add_image_with_label(tb,name,image,label,global_step):\n label = str(label)\n image = image.numpy()\n image = image.transpose(1,2,0)\n image = _draw_text_on_image(image,label)\n image = image.transpose(2,0,1)\n tb.add_image(name,image,global_step)\n\ndef add_images_with_label(tb,name,image,label,global_step,font_scale=1.2):\n if isinstance(image,torch.Tensor):\n image = image.numpy()\n image = image.transpose(0,2,3,1)\n image = np.ascontiguousarray(image)\n if not isinstance(label,Iterable):\n label = str(label)\n image[0] = _draw_text_on_image(image[0], label,font_scale=font_scale)\n elif len(label) == 1:\n label = str(label[0])\n image[0] = _draw_text_on_image(image[0],label,font_scale=font_scale)\n elif len(label) == image.shape[0]:\n for i in range(len(label)):\n image[i] = _draw_text_on_image(image[i], str(label[i]),font_scale=font_scale)\n else:\n print(f\"ERROR label {label}\")\n return\n\n image = image.transpose(0,3,1,2)\n tb.add_images(name,image,global_step)\n\ndef add_video_with_label(tb,name,video,label,global_step,fps=4,font_scale=1.2):\n '''\n Args:\n tb:\n name:\n video: (N, T, C, H, W)\n label:\n global_step:\n fps:\n font_scale:\n\n Returns:\n\n '''\n video = video.transpose(0,1,3,4,2)\n if isinstance(video,torch.Tensor):\n video = video.numpy()\n video = np.ascontiguousarray(video)\n for i in range(video.shape[0]):\n l = label[i]\n for j in range(video.shape[1]):\n _draw_text_on_image(video[i,j],l,font_scale=font_scale)\n #video (N,T,H,W,C)\n video = video.transpose(0,1,4,2,3)\n tb.add_video(name,video,global_step)\n",
"import tensorflow as tf\nfrom object_detection2.modeling.keypoints_heads.hrnet_pe_outputs import *\nfrom object_detection2.config.config import *\nimport wmodule\nimport numpy as np\n\ntf.enable_eager_execution()\n\ncfg = get_cfg()\ndata = list(range(60))\n#net = np.zeros([1,5,4,3],dtype=np.float32)\ndata = np.array(data,dtype=np.float32)\ndata = np.reshape(data,[1,5,4,3])\nnet = tf.convert_to_tensor(data)\n#net = np.zeros([1,5,4,3],dtype=np.float32)\nindexs = np.zeros([1,2,3],dtype=np.int32)\nindexs[0,0,0] = 0\nindexs[0,0,1] = 1\nindexs[0,0,2] = 2\n\nindexs[0,1,0] = 0+3\nindexs[0,1,1] = 5+3\nindexs[0,1,2] = 10+3\n\nindexs = tf.convert_to_tensor(indexs)\n\nlength = np.array([2],dtype=np.int32)\nlength = tf.convert_to_tensor(length)\n\nparent = wmodule.WRootModule()\noutput = HRNetPEOutputs(cfg.MODEL.KEYPOINTS,parent,gt_length=length,pred_maps=None)\nloss = output.ae_loss(net,indexs)\nprint(loss)\n",
"#coding=utf-8\nimport tensorflow as tf\nimport wml_tfutils as wmlt\nfrom object_detection2.config.config import global_cfg\nfrom object_detection2.datadef import *\n\ndef subsample_labels(labels, num_samples, positive_fraction):\n '''\n 大于0为正样本，等于零为背景，小于0为忽略\n :param labels:[...]\n :param num_samples:\n :param positive_fraction:\n :return:\n [N],[N] (N=num_elements(labels)\n '''\n\n with tf.variable_scope(\"subsample_labels\"):\n labels = tf.reshape(labels, shape=[-1])\n\n pmask = tf.greater(labels,0)\n psize = int(num_samples*positive_fraction)\n select_pmask = wmlt.subsample_indicator(pmask,psize)\n\n nmask = tf.equal(labels,0)\n psize = tf.reduce_sum(tf.cast(select_pmask, tf.int32))\n nsize = num_samples-psize\n select_nmask = wmlt.subsample_indicator(nmask,nsize)\n if global_cfg.GLOBAL.DEBUG:\n tf.summary.scalar(\"psize\",psize)\n tf.summary.scalar(\"nsize\",nsize)\n\n return select_pmask,select_nmask\n\ndef subsample_labels_by_negative_loss(labels, num_samples, probability,num_classes,positive_fraction):\n '''\n 大于0为正样本，等于零为背景，小于0为忽略\n SSD选择样本的方法，最指定百分比的正样本，负样本按损失大小选\n :param probability: [batch_size,X]必须为相应的概率，不然计算不准确\n :param labels:[batch_size,X]\n :param num_samples:\n :param positive_fraction:\n :return:\n [batch_size,num_samples],[batch_size,num_samples]\n '''\n\n with tf.variable_scope(\"subsample_labels_negative_loss\"):\n selected_pmask,selected_nmask = wmlt.static_or_dynamic_map_fn(lambda x:subsample_labels_by_negative_loss_on_single_img(x[0],\n num_samples,\n x[1],\n num_classes,\n positive_fraction),\n elems=[labels,probability],back_prop=True,\n )\n selected_nmask = tf.reshape(selected_nmask,[-1])\n selected_pmask = tf.reshape(selected_pmask,[-1])\n if global_cfg.GLOBAL.SUMMARY_LEVEL<=SummaryLevel.DEBUG:\n tf.summary.scalar(\"psize\",tf.reduce_sum(tf.cast(selected_pmask,tf.int32)))\n tf.summary.scalar(\"nsize\",tf.reduce_sum(tf.cast(selected_nmask,tf.int32)))\n\n return selected_pmask,selected_nmask\n\n\ndef subsample_labels_by_negative_loss_on_single_img(labels, num_samples, probability,num_classes,positive_fraction):\n '''\n 大于0为正样本，等于零为背景，小于0为忽略\n SSD选择样本的方法，最指定百分比的正样本，负样本按损失大小选\n :param probability: 必须为相应的概率，不然计算不准确\n :param labels:\n :param num_samples:\n :param positive_fraction:\n :return:\n [N],[N] (N=num_elements(labels)\n '''\n\n with tf.variable_scope(\"subsample_labels_negative_loss\"):\n labels = tf.reshape(labels, shape=[-1])\n probability = tf.reshape(probability, [-1, num_classes+1])\n pmask = tf.greater(labels,0)\n\n psize = int(num_samples*positive_fraction)\n selected_pmask = wmlt.subsample_indicator(pmask,psize)\n\n nmask = tf.equal(labels,0)\n psize = tf.reduce_sum(tf.cast(selected_pmask, tf.int32))\n nsize = num_samples-psize\n\n fnmask = tf.cast(nmask, tf.float32)\n # 负样本的概率为模型预测为负样本的概率，正样本的地方设置为1\n nclass_prediction = tf.where(nmask, probability[:, 0], tf.ones_like(fnmask))\n # 取预测的最不好的nsize个负样本\n selected_nmask = tf.logical_and(nmask, wmlt.bottom_k_mask(nclass_prediction, k=nsize))\n\n return [selected_pmask,selected_nmask]\n"
] | [
[
"tensorflow.Print",
"tensorflow.python.ops.control_flow_ops.group",
"tensorflow.python.framework.ops.init_scope",
"tensorflow.python.framework.ops.colocate_with",
"tensorflow.python.ops.resource_variable_ops.resource_scatter_add",
"tensorflow.train.get_or_create_global_step",
"tensorflow.python.framework.ops.get_default_graph",
"tensorflow.python.ops.state_ops.assign_sub",
"tensorflow.python.ops.math_ops.sqrt",
"tensorflow.python.framework.ops.convert_to_tensor",
"tensorflow.python.ops.state_ops.assign",
"tensorflow.python.framework.ops.control_dependencies",
"tensorflow.python.eager.context.executing_eagerly",
"tensorflow.python.ops.state_ops.scatter_add",
"tensorflow.python.ops.math_ops.cast"
],
[
"tensorflow.device",
"tensorflow.summary.FileWriter",
"tensorflow.gfile.DeleteRecursively",
"tensorflow.gfile.Exists",
"tensorflow.ones_like",
"tensorflow.ConfigProto",
"tensorflow.global_variables_initializer",
"tensorflow.summary.merge_all",
"tensorflow.Session",
"tensorflow.app.run"
],
[
"tensorflow.flags.DEFINE_boolean",
"numpy.amax",
"numpy.ones_like",
"tensorflow.flags.DEFINE_string",
"tensorflow.gfile.GFile",
"tensorflow.python_io.TFRecordWriter",
"tensorflow.gfile.MakeDirs",
"tensorflow.logging.info",
"tensorflow.logging.set_verbosity",
"tensorflow.train.Features",
"tensorflow.gfile.IsDirectory",
"tensorflow.app.run"
],
[
"tensorflow.boolean_mask",
"tensorflow.device",
"tensorflow.concat",
"tensorflow.shape",
"tensorflow.logical_or",
"tensorflow.reduce_sum",
"tensorflow.maximum",
"tensorflow.reshape",
"tensorflow.expand_dims",
"tensorflow.ones",
"tensorflow.name_scope",
"tensorflow.variable_scope",
"tensorflow.summary.scalar",
"tensorflow.tile"
],
[
"tensorflow.boolean_mask",
"tensorflow.nn.relu",
"tensorflow.device",
"tensorflow.image.resize_bilinear",
"tensorflow.nn.sigmoid",
"tensorflow.transpose",
"tensorflow.reshape",
"tensorflow.cast",
"tensorflow.expand_dims",
"tensorflow.squeeze",
"tensorflow.nn.sigmoid_cross_entropy_with_logits",
"tensorflow.gather",
"tensorflow.name_scope",
"tensorflow.variable_scope",
"tensorflow.split"
],
[
"tensorflow.concat",
"tensorflow.cast",
"tensorflow.equal",
"tensorflow.summary.scalar",
"tensorflow.boolean_mask",
"tensorflow.truncated_normal_initializer",
"tensorflow.train.get_or_create_global_step",
"tensorflow.name_scope",
"tensorflow.random_normal_initializer",
"tensorflow.tile",
"tensorflow.nn.sigmoid",
"tensorflow.less",
"tensorflow.zeros_initializer",
"tensorflow.scatter_nd",
"tensorflow.clip_by_value",
"tensorflow.nn.relu",
"tensorflow.range",
"tensorflow.reduce_mean",
"tensorflow.reshape",
"tensorflow.expand_dims",
"tensorflow.variable_scope",
"tensorflow.random_uniform"
],
[
"torch.mean",
"torch.max",
"numpy.ascontiguousarray",
"torch.min",
"torch.std"
],
[
"tensorflow.convert_to_tensor",
"tensorflow.enable_eager_execution",
"numpy.reshape",
"numpy.array",
"numpy.zeros"
],
[
"tensorflow.greater",
"tensorflow.reshape",
"tensorflow.equal",
"tensorflow.cast",
"tensorflow.ones_like",
"tensorflow.variable_scope",
"tensorflow.summary.scalar"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.13",
"1.7",
"1.10",
"1.12"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
lygztq/gomoku | [
"c833d4234291b9518a9fc2e6893a1380d927261a"
] | [
"src/pygomoku/GameServer.py"
] | [
"import numpy as np\nfrom pygomoku.Board import Board\nfrom pygomoku import Player\n\ndef change_color(color):\n if color == Board.kPlayerBlack:\n return Board.kPlayerWhite\n elif color == Board.kPlayerWhite:\n return Board.kPlayerBlack\n else:\n return color\n\nclass GameServer(object):\n \"\"\"The server of gomoku game.\n\n The GameServer class determines which class of game will go on\n and control the game.\n\n Attributes:\n board: A pygomoku.Board.Board instance, the board we use during game.\n mode: The mode of game. Valid values are GameServer.kSelfPlayGame and \n GameServer.kNormalGame.\n player1: A pygomoku.Player instance. Player #1 who will play first.\n player2: A pygomoku.Player instance. Player #2. This player will be None if current game is self-play game.\n silent: A Boolean Value. If True, Game server will not print game info during game. \n\n Constants:\n kSelfPlayGame: A constant. This value means current game is a self-play\n game which played by computer itself.\n kNormalPlayGame: A constant. This value means current game is a normal \n game with two players(either human or ai).\n\n \"\"\"\n\n kSelfPlayGame = 0\n kNormalPlayGame = 1\n\n def __init__(self, board, mode, player1, player2=None, silent=False):\n self.board = board\n self.mode = mode\n self.silent = silent\n \n # Get player1\n if isinstance(player1, Player.Player):\n self.player1 = player1\n self.player1.silent = silent\n else:\n raise ValueError(\"Invalid type for player 1, expect pygomoku.Player.Player, get {}\".format(type(player1)))\n\n # Get Player2, if self-play, set Player2 None.\n if mode == GameServer.kNormalPlayGame:\n if isinstance(player2, Player.Player):\n if player2.color == player1.color:\n raise ValueError(\"Player 2 has same color with Player1 !\")\n self.player2 = player2\n self.player2.silent = silent\n else:\n raise ValueError(\"Invalid type for player 2, expect pygomoku.Player.Player, get {}\".format(type(player2)))\n elif mode == GameServer.kSelfPlayGame:\n player2 = None\n else:\n raise ValueError(\"Invalid value for 'mode' attribute of GameServer.\")\n \n def showGameInfo(self):\n \"\"\"Show game informations.\n\n If game mode is normal play, this method will print player\n information first and then the board state.\n If game mode is self-play, only the board state will be printed.\n \"\"\"\n if self.mode == GameServer.kNormalPlayGame:\n if isinstance(self.player1, Player.Player):\n print(\"[Player1]:\\n-------------\")\n print(self.player1)\n print('\\n')\n if isinstance(self.player2, Player.Player):\n print(\"[Player2]:\\n-------------\")\n print(self.player2)\n print('\\n')\n else:\n print(\"Self Play\\n\")\n self.board.printBoard()\n \n def _startNormalGame(self):\n \"\"\"Start a normal game.\n \n Can be human vs. human or human vs. AI.\n Return color of the winner.\n \"\"\"\n # initial board\n self.board.initBoard(self.player1.color)\n \n # key: color, value: player\n players = {\n self.player1.color: self.player1,\n self.player2.color: self.player2\n }\n\n stone_color = {\n Board.kPlayerBlack: \"@\",\n Board.kPlayerWhite: \"O\"\n }\n\n if not self.silent:\n self.showGameInfo()\n \n # The main process of a game\n while True:\n current_player = players[self.board.current_player]\n move = current_player.getAction(self.board)\n while not self.board.play(move):\n print(\"Invalid movement.\") #TODO: some bug here, infinite invalid movement.\n if not self.silent:\n self.showGameInfo()\n is_end, winner = self.board.gameEnd()\n if is_end:\n if not self.silent:\n if winner is not None:\n print(\"Game end with winner {}(color {}).\".format(players[winner].name, stone_color[winner]))\n else:\n print(\"Game end with no winner.\")\n return winner\n \n def _startSelfPlayGame(self):\n \"\"\"Start a self-play game using a MCTS player.\n\n This method will reuse the search tree and store the \n self-play data: (state, mcts_probs, z) for training\n\n Return:\n winner: An integer whose value can be Board.kPlayerBlack,\n Board.kPlayerWhite or None.\n states_batch: A numpy array with shape (N, 4, board_height, board_width)\n which shows the state of board during the game.\n action_probs_batch: A numpy array with shape (N, board_height*board_width)\n which shows the probability of each move of each step during game.\n winner_vec: A numpy array with shape (N, ) which shows the winner of the game, also\n represents the evaluate value of each state of board.\n \"\"\"\n self.board.initBoard()\n states_batch, action_probs_batch, current_players_batch = [], [], []\n while True:\n move, probs = self.player1.getAction(self.board,\n return_policy_vec=True)\n # Get training data\n states_batch.append(self.board.currentState())\n action_probs_batch.append(probs)\n current_players_batch.append(self.board.current_player)\n \n # move\n self.board.play(move)\n self.player1.color = change_color(self.player1.color)\n if not self.silent:\n self.showGameInfo()\n \n is_end, winner = self.board.gameEnd()\n if is_end:\n winner_vec = np.zeros(len(current_players_batch))\n if winner is not None: # if has winner\n winner_vec[np.array(current_players_batch) == winner] = 1.0\n winner_vec[np.array(current_players_batch) != winner] = -1.0\n \n self.player1.reset()\n if not self.silent:\n if winner is not None:\n print(\"Game end with winner [{}]\".format(Board.kStoneChar[winner]))\n else:\n print(\"Game end with no winner.\")\n # return winner, zip(states_batch, action_probs_batch, winner_vec)\n return winner, np.array(states_batch), np.array(action_probs_batch), winner_vec\n\n def startGame(self):\n \"\"\"Start the game.\n \"\"\"\n if self.mode == GameServer.kNormalPlayGame:\n return self._startNormalGame()\n else:\n return self._startSelfPlayGame()\n \n"
] | [
[
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
bhatiaharsh/naturalHHD | [
"7a8efd44fb7c348a53fae05f59a9098ba0f4046b"
] | [
"pynhhd-v1.1/pynhhd/spherical.py"
] | [
"'''\nCopyright (c) 2015, Harsh Bhatia ([email protected])\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n1. Redistributions of source code must retain the above copyright notice, this\nlist of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright notice,\nthis list of conditions and the following disclaimer in the documentation\nand/or other materials provided with the distribution.\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n'''\n\nimport sys\nimport numpy as np\nfrom scipy import interpolate\nimport logging\nLOGGER = logging.getLogger(__name__)\n\nfrom .utils.timer import Timer\n\n#\n# the following are not needed, unless wrap_xesmf will be called from outside\ntry:\n import xarray as xr\nexcept ImportError:\n pass\n\ntry:\n import xesmf as xe\nexcept ImportError:\n pass\n\ndef wrap_xesmf(sfield,lat,lon,lat2,lon2,dx,mode='bilinear',reuse_w=False,periodic=True):\n '''\n wrap xesmf\n '''\n lat2_b = numpy.arange(lat2.min()-dx[0]/2, lat2.max()+dx[0], dx[0])\n lon2_b = numpy.arange(lon2.min()-dx[1]/2, lon2.max()+dx[1], dx[1])\n lat_b = numpy.arange(lat.min()-dx[0]/2, lat.max()+dx[0], dx[0])\n lon_b = numpy.arange(lon.min()-dx[1]/2, lon.max()+dx[1], dx[1])\n ds_out = xr.Dataset({'lat': (['lat'], lat[:,0]),'lon': (['lon'], lon[0,:]), 'lat_b':(['lat_b'], lat_b), 'lon_b': (['lon_b'], lon_b), })\n ds_in = xr.Dataset({'lat': (['lat'], lat2[:,0]),'lon': (['lon'], lon2[0,:]), 'lat_b':(['lat_b'], lat2_b), 'lon_b': (['lon_b'], lon2_b), })\n regridder = xe.Regridder(ds_in, ds_out, mode, filename=mode+'_'+str(lat.min())+str(lat.max())+str(lon.min())+str(lon.max())+'_to_'+str(lat2.min())+str(lat2.max())+str(lon2.min())+str(lon2.max())+'_periodic_'+str(periodic)+'.nc',reuse_weights=reuse_w,periodic=periodic)\n dum = sfield.copy()\n dum[numpy.where(numpy.isnan(dum))]=0\n mask=numpy.ones(dum.shape)\n mask[numpy.where(dum==0)]=0\n out = regridder(dum)\n mask = regridder(mask)\n out = out/mask\n out[numpy.where(numpy.isnan(out))]=0\n #\n return out\n\n# ------------------------------------------------------------------------------\nclass StructuredSphericalGrid(object):\n\n # --------------------------------------------------------------------------\n # --------------------------------------------------------------------------\n def __init__(self, **kwargs):\n\n '''\n kwargs:\n sphericalgrid: ndarray of grid dimensions (Y,X) or (Z,Y,X)\n spacings: ndarray of grid spacings (dy, dx) or (dz, dy, dx) (dy,dx are in degrees)\n verbose: verbosity level\n lat: latitude (2D)\n lon: longitude (2D)\n '''\n\n args = list(kwargs.keys())\n\n if not ('sphericalgrid' in args) or not ('spacings' in args):\n raise SyntaxError(\"Dimensions and spacings of the grid are required\")\n\n self.dims = kwargs['sphericalgrid']\n self.dx = kwargs['spacings'] # in degrees - needs to be regular\n self.lat = kwargs['lat'] # needs to be 2D\n self.lon = kwargs['lon'] # needs to be 2D\n self.dim = len(self.dims)\n\n if self.dim != 2 and self.dim != 3:\n raise ValueError(\"SphericalGrid works for 2D and 3D only\")\n\n if self.dim != len(self.dx):\n raise ValueError(\"Dimensions of spacings should match that of the grid\")\n\n LOGGER.info('Initialized {}D spherical grid'.format(self.dim))\n\n\n def divcurl2(self, vfield, verbose=False, glob=True, r=6371E3):\n '''\n THIS IS NOT USED AT THE MOMENT - BUT FEEL FREE TO PLAY AROUND\n\n Here we use splines to get more accurate (?) gradients than just central differences\n\n '''\n dudx_spline = interpolate.RectBivariateSpline(np.radians(self.lat[:,0]), np.radians(self.lon[0,:]), vfield[:,:,0])\n dvdx_spline = interpolate.RectBivariateSpline(np.radians(self.lat[:,0]), np.radians(self.lon[0,:]), vfield[:,:,1])\n dudy_spline = interpolate.RectBivariateSpline(np.radians(self.lat[:,0]), np.radians(self.lon[0,:]), vfield[:,:,0]*np.cos(np.radians(self.lat)))\n dvdy_spline = interpolate.RectBivariateSpline(np.radians(self.lat[:,0]), np.radians(self.lon[0,:]), vfield[:,:,1]*np.cos(np.radians(self.lat)))\n #\n dudx = dudx_spline.ev(np.radians(self.lat),np.radians(self.lon),0,1)/(r*np.cos(np.radians(self.lat))) #note that our variables are [y,x] so\n dudy = dudy_spline.ev(np.radians(self.lat),np.radians(self.lon),1,0)/(r*np.cos(np.radians(self.lat))) #therefore the derivatives are flipped from\n dvdx = dvdx_spline.ev(np.radians(self.lat),np.radians(self.lon),0,1)/(r*np.cos(np.radians(self.lat))) #what the documentation says\n dvdy = dvdy_spline.ev(np.radians(self.lat),np.radians(self.lon),1,0)/(r*np.cos(np.radians(self.lat)))\n #\n div = np.add(dudx, dvdy)\n curl = np.subtract(dvdx, dudy)\n\n return (div, curl)\n\n def divcurl3(self, vfield, verbose=False, glob=True, r=6371E3, use_xesmf=True, mode='bilinear'):\n '''\n THIS IS NOT USED AT THE MOMENT -BUT FEEL FREE TO PLAY AROUND\n\n Define the derivatives as forward derivatives and then use the spline interpolation to center the derivatives\n this is closer to the original central difference approach - and wrapping around is easier to take care of\n note that could also use xesmf for the regridding\n '''\n\n dudy = np.zeros(vfield[:,:,0].shape)\n dudx = np.zeros(vfield[:,:,0].shape)\n dvdy = np.zeros(vfield[:,:,0].shape)\n dvdx = np.zeros(vfield[:,:,0].shape)\n lon2,lat2 = np.meshgrid(np.arange(self.lon[0,0]+self.dx[1]/2,self.lon[0,-1]+self.dx[1],self.dx[1])-self.dx[1],np.arange(self.lat[0,0]+self.dx[0]/2,self.lat[-1,0]+self.dx[0],self.dx[0])-self.dx[0])\n lon2x = np.radians(lon2[:,1:])\n lat2x = np.radians(lat2[:,1:])\n lon2y = np.radians(lon2[1:,:])\n lat2y = np.radians(lat2[1:,:])\n dudy[1:,:] = (vfield[1:,:,0]*np.cos(np.radians(self.lat[1:,:]))-vfield[:-1,:,0]*np.cos(np.radians(self.lat[:-1,:])))/(np.radians(self.dx[0])*r*np.cos(lat2y))\n dvdy[1:,:] = (vfield[1:,:,1]*np.cos(np.radians(self.lat[1:,:]))-vfield[:-1,:,1]*np.cos(np.radians(self.lat[:-1,:])))/(np.radians(self.dx[0])*r*np.cos(lat2y))\n dudx[:,1:] = (vfield[:,1:,0]-vfield[:,:-1,0])/(np.radians(self.dx[1])*r*np.cos(lat2x))\n dvdx[:,1:] = (vfield[:,1:,1]-vfield[:,:-1,1])/(np.radians(self.dx[1])*r*np.cos(lat2x))\n dudx[:,0] = (vfield[:,0,0]-vfield[:,1,0])/(np.radians(self.dx[1])*r*np.cos(lat2x[:,0]))\n dvdx[:,0] = (vfield[:,0,1]-vfield[:,1,1])/(np.radians(self.dx[1])*r*np.cos(lat2x[:,0]))\n #\n if not use_xesmf:\n dudx_spline = interpolate.RectBivariateSpline(np.radians(self.lat[:,0]), np.radians(lon2[0,:]), dudx) #centered in lat, shifted in lon\n dvdx_spline = interpolate.RectBivariateSpline(np.radians(self.lat[:,0]), np.radians(lon2[0,:]), dvdx)\n dudy_spline = interpolate.RectBivariateSpline(np.radians(lat2[:,0]), np.radians(self.lon[0,:]), dudy) #centered in lon, shifted in lat\n dvdy_spline = interpolate.RectBivariateSpline(np.radians(lat2[:,0]), np.radians(self.lon[0,:]), dvdy)\n #\n dudx2 = dudx_spline.ev(np.radians(self.lat),np.radians(self.lon))\n dudy2 = dudy_spline.ev(np.radians(self.lat),np.radians(self.lon))\n dvdx2 = dvdx_spline.ev(np.radians(self.lat),np.radians(self.lon))\n dvdy2 = dvdy_spline.ev(np.radians(self.lat),np.radians(self.lon))\n elif use_xesmf:\n dudx2 = nutils.wrap_xesmf(dudx, self.lat, self.lon, self.lat, lon2, self.dx, reuse_w=True, mode=mode)\n dvdx2 = nutils.wrap_xesmf(dvdx, self.lat, self.lon, self.lat, lon2, self.dx, reuse_w=True, mode=mode)\n dudy2 = nutils.wrap_xesmf(dudy, self.lat, self.lon, lat2, self.lon, self.dx, reuse_w=True, mode=mode)\n dvdy2 = nutils.wrap_xesmf(dvdy, self.lat, self.lon, lat2, self.lon, self.dx, reuse_w=True, mode=mode)\n #\n div2 = np.add(dudx2, dvdy2)\n curl2 = np.subtract(dvdx2, dudy2)\n #\n print(div2.min(),div2.max())\n print(curl2.min(),curl2.max())\n #\n return (div2, curl2)\n\n #\n # --------------------------------------------------------------------------\n # --------------------------------------------------------------------------\n def divcurl(self, vfield, verbose=False, glob=True, r=6371E3):\n '''\n THIS IS USED AT THE MOMENT - EXACTLY THE SAME APPROACH AS IN NON-SPHERICAL GRID,\n BUT GRADIENTS ARE DEFINED ON A SPHERE\n\n (discrete) Divergence and curl are calculated from a vector field.\n If glob=True a wrap around in longitude is assumed.\n This function uses central differences.\n '''\n\n if (vfield.shape[-1] != self.dim) or (vfield.shape[0:self.dim] != self.dims):\n raise ValueError(\"Dimensions of vector field should match that of the grid\")\n\n LOGGER.debug('Computing divcurl')\n mtimer = Timer()\n\n if self.dim == 2:\n\n if glob:\n #second order derivative at the wrapping longitude boundary\n dudy = np.gradient(vfield[:,:,0]*np.cos(np.radians(self.lat)), np.radians(self.dx[0]), axis=0)/(r*np.cos(np.radians(self.lat)))\n #dudy2 = np.gradient(vfield[:,:,0], np.radians(self.dx[0]), axis=-2)/(r*np.cos(np.radians(self.lat))) - vfield[:,:,0]*np.tan(np.radians(self.lat))/r\n dudx = np.gradient(vfield[:,:,0], np.radians(self.dx[1]), axis=1)/(r*np.cos(np.radians(self.lat)))\n dudx[:,0] = np.gradient(np.concatenate([vfield[:,-1:,0],vfield[:,:2,0]],axis=1), np.radians(self.dx[1]), axis=1)[:,1]/(r*np.cos(np.radians(self.lat[:,0])))\n dudx[:,-1] = np.gradient(np.concatenate([vfield[:,-2:,0],vfield[:,:1,0]],axis=1), np.radians(self.dx[1]), axis=1)[:,1]/(r*np.cos(np.radians(self.lat[:,0])))\n dvdy = np.gradient(vfield[:,:,1]*np.cos(np.radians(self.lat)), np.radians(self.dx[0]), axis=0)/(r*np.cos(np.radians(self.lat)))\n #dvdy2 = np.gradient(vfield[:,:,1], np.radians(self.dx[0]), axis=-2)/(r*np.cos(np.radians(self.lat))) - vfield[:,:,1]*np.tan(np.radians(self.lat))/r\n dvdx = np.gradient(vfield[:,:,1], np.radians(self.dx[1]), axis=1)/(r*np.cos(np.radians(self.lat)))\n dvdx[:,0] = np.gradient(np.concatenate([vfield[:,-1:,1],vfield[:,:2,1]],axis=1), np.radians(self.dx[1]), axis=1)[:,1]/(r*np.cos(np.radians(self.lat[:,0])))\n dvdx[:,-1] = np.gradient(np.concatenate([vfield[:,-2:,1],vfield[:,:1,1]],axis=1), np.radians(self.dx[1]), axis=1)[:,1]/(r*np.cos(np.radians(self.lat[:,0])))\n else:\n\n # self.dx = (dy,dx)\n dudy = np.gradient(vfield[:,:,0]*np.cos(np.radians(self.lat)), np.radians(self.dx[0]), axis=0)/(r*np.cos(np.radians(self.lat)))\n dudx = np.gradient(vfield[:,:,0], np.radians(self.dx[1]), axis=1)/(r*np.cos(np.radians(self.lat)))\n dvdy = np.gradient(vfield[:,:,1]*np.cos(np.radians(self.lat)), np.radians(self.dx[0]), axis=0)/(r*np.cos(np.radians(self.lat)))\n dvdx = np.gradient(vfield[:,:,1], np.radians(self.dx[1]), axis=1)/(r*np.cos(np.radians(self.lat)))\n\n div = np.add(dudx, dvdy)\n curl = np.subtract(dvdx, dudy) #note the sign convention\n\n mtimer.end()\n LOGGER.debug('Computing divcurl done! took {}'.format(mtimer))\n\n return (div, curl)\n\n elif self.dim == 3:\n print('NOT IMPLEMENTED - WILL RETURN THE SAME AS CARTESIAN DIV')\n # self.dx = (dz,dy,dx)\n dudz, dudy, dudx = np.gradient(vfield[:,:,:,0], self.dx[0], self.dx[1], self.dx[2])\n dvdz, dvdy, dvdx = np.gradient(vfield[:,:,:,1], self.dx[0], self.dx[1], self.dx[2])\n dwdz, dwdy, dwdx = np.gradient(vfield[:,:,:,2], self.dx[0], self.dx[1], self.dx[2])\n\n np.add(dudx, dvdy, dudx)\n np.add(dudx, dvdz, dudx)\n\n np.subtract(dwdy, dvdz, dwdy)\n np.subtract(dudz, dwdx, dudz)\n np.subtract(dvdx, dudy, dvdx)\n\n mtimer.end()\n LOGGER.debug('Computing divcurl done! took {}'.format(mtimer))\n\n return (dudx, dwdy, dudz, dvdx)\n\n def curl3D(self, vfield, verbose=False):\n\n #if (vfield.shape[-1] != self.dim) or (vfield.shape[0:self.dim] - self.dims).any():\n if (vfield.shape[-1] != self.dim) or (vfield.shape[0:self.dim] != self.dims):\n raise ValueError(\"Dimensions of vector field should match that of the grid\")\n\n if self.dim != 3:\n raise ValueError(\"curl3D works only for 2D\")\n\n if verbose:\n print(' Computing curl...',)\n sys.stdout.flush()\n mtimer = Timer()\n\n # self.dx = (dz,dy,dx)\n dudz, dudy, dudx = np.gradient(vfield[:,:,:,0], self.dx[0], self.dx[1], self.dx[2])\n dvdz, dvdy, dvdx = np.gradient(vfield[:,:,:,1], self.dx[0], self.dx[1], self.dx[2])\n dwdz, dwdy, dwdx = np.gradient(vfield[:,:,:,2], self.dx[0], self.dx[1], self.dx[2])\n\n np.subtract(dwdy, dvdz, dwdy)\n np.subtract(dudz, dwdx, dudz)\n np.subtract(dvdx, dudy, dvdx)\n\n if verbose:\n print(' Done!',)\n mtimer.end()\n\n return (dwdy, dudz, dvdx)\n\n def rotated_gradient(self, sfield, verbose=False, r=6371E3, glob=True):\n '''Same as gradient but rotated 90 degrees '''\n if (sfield.shape != self.dims):\n\t #if (sfield.shape - self.dims).any():\n raise ValueError(\"Dimensions of scalar field should match that of the grid\")\n\n if self.dim != 2:\n raise ValueError(\"rotated_gradient works only for 2D\")\n\n if verbose:\n print(' Computing rotated gradient...',)\n sys.stdout.flush()\n mtimer = Timer()\n\n if glob:\n # central difference also at the boundary\n ddy = np.gradient(sfield, np.radians(self.dx[0]), axis=0)/r\n ddx = np.gradient(sfield, np.radians(self.dx[1]), axis=1)/(r*np.cos(np.radians(self.lat)))\n ddx[:,0] = np.gradient(np.concatenate([sfield[:,-1:],sfield[:,:2]],axis=1), np.radians(self.dx[1]), axis=1)[:,1]/(r*np.cos(np.radians(self.lat[:,0])))\n ddx[:,-1] = np.gradient(np.concatenate([sfield[:,-2:],sfield[:,:1]],axis=1), np.radians(self.dx[1]), axis=1)[:,1]/(r*np.cos(np.radians(self.lat[:,0])))\n else:\n #ddy, ddx = np.gradient(sfield, self.dx[0], self.dx[1])\n ddy = np.gradient(sfield, np.radians(self.dx[0]), axis=0)/r\n ddx = np.gradient(sfield, np.radians(self.dx[1]), axis=1)/(r*np.cos(np.radians(self.lat)))\n #\n ddy = -1.0*ddy\n\n grad = np.stack((ddy, ddx), axis=-1)\n\n if verbose:\n print(' Done!',)\n mtimer.end()\n\n return grad\n\n def gradient(self, sfield, verbose=False, glob=True, r=6371E3):\n '''\n Calculate the discrete (central differences) gradient of a scalar field.\n\n if glob=True we assume a global doamin and wrapping around in longitude (axis=1)\n In this case also the end points will use central differences, else they will use\n forward (backward) differences at the left and right hand extremes of the matrix.\n '''\n\n verbose = True\n\n if (sfield.shape != self.dims):\n\t #if (sfield.shape - self.dims).any():\n raise ValueError(\"Dimensions of scalar field should match that of the grid\")\n\n if verbose:\n print(' Computing gradient...',)\n sys.stdout.flush()\n mtimer = Timer()\n\n if self.dim == 2:\n\n print (glob, self.dx, r)\n print (sfield.min(), sfield.max())\n\n if glob:\n ddy = np.gradient(sfield, np.radians(self.dx[0]), axis=0)/r\n ddx = np.gradient(sfield, np.radians(self.dx[1]), axis=1)/(r*np.cos(np.radians(self.lat)))\n ddx[:,0] = np.gradient(np.concatenate([sfield[:,-1:],sfield[:,:2]],axis=1), np.radians(self.dx[1]), axis=1)[:,1]/(r*np.cos(np.radians(self.lat[:,0])))\n ddx[:,-1] = np.gradient(np.concatenate([sfield[:,-2:],sfield[:,:1]],axis=1), np.radians(self.dx[1]), axis=1)[:,1]/(r*np.cos(np.radians(self.lat[:,0])))\n else:\n # self.dx = (dy,dx)\n ddy = np.gradient(sfield, np.radians(self.dx[0]), axis=0)/r\n ddx = np.gradient(sfield, np.radians(self.dx[1]), axis=1)/(r*np.cos(np.radians(self.lat)))\n\n grad = np.stack((ddx, ddy), axis = -1)\n\n elif self.dim == 3:\n print('not implemented yet! - will return the same as cartesian')\n # self.dx = (dz,dy,dx)\n ddz, ddy, ddx = np.gradient(sfield, self.dx[0], self.dx[1], self.dx[2])\n grad = np.stack((ddx, ddy, ddz), axis = -1)\n\n if verbose:\n print(' Done!',)\n mtimer.end()\n\n return grad\n\n # --------------------------------------------------------------------------\n # --------------------------------------------------------------------------\n"
] | [
[
"numpy.radians",
"numpy.gradient",
"numpy.arange",
"numpy.subtract",
"numpy.cos",
"numpy.stack",
"numpy.concatenate",
"numpy.add",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.